@saastro/forms 0.1.3

package/dist/index.d.ts

@@ -0,0 +1,3754 @@
+import * as React$1 from 'react';
+import React__default, { ReactNode } from 'react';
+import { z } from 'zod';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+import * as react_hook_form from 'react-hook-form';
+import { UseFormReturn, Control } from 'react-hook-form';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+
+declare const inputVariantsConfig: {
+    readonly variants: {
+        readonly size: {
+            readonly xs: "h-6 px-2 text-xs";
+            readonly sm: "h-8 px-3 text-sm";
+            readonly md: "h-10 px-3 py-2 text-base";
+            readonly lg: "h-12 px-4 text-lg";
+            readonly xl: "h-14 px-4 text-xl";
+        };
+    };
+    readonly defaultVariants: {
+        readonly size: "md";
+    };
+};
+declare const textareaVariantsConfig: {
+    readonly variants: {
+        readonly size: {
+            readonly xs: "px-2 text-xs";
+            readonly sm: "px-3 text-sm";
+            readonly md: "px-3 py-2 text-base";
+            readonly lg: "px-4 text-lg";
+            readonly xl: "px-4 text-xl";
+        };
+    };
+    readonly defaultVariants: {
+        readonly size: "md";
+    };
+};
+declare const inputVariants: (props?: ({
+    readonly size?: "sm" | "md" | "lg" | "xl" | "xs" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const textareaVariants: (props?: ({
+    readonly size?: "sm" | "md" | "lg" | "xl" | "xs" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const iconVariantsConfig: {
+    readonly variants: {
+        readonly size: {
+            readonly xs: "absolute h-3 w-3 top-1.5 right-1.5";
+            readonly sm: "absolute h-4 w-4 top-2 right-2";
+            readonly md: "absolute h-5 w-5 top-2.5 right-2.5";
+            readonly lg: "absolute h-6 w-6 top-3 right-3";
+            readonly xl: "absolute h-7 w-7 top-3.5 right-3.5";
+        };
+    };
+    readonly defaultVariants: {
+        readonly size: "md";
+    };
+};
+declare const iconVariants: (props?: ({
+    readonly size?: "sm" | "md" | "lg" | "xl" | "xs" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type InputSize = VariantProps<typeof inputVariants>['size'];
+
+/**
+ * Logic Types
+ *
+ * Generic structures for declarative conditions and logic groups.
+ * Used for step navigation and field behavior (visibility, disabled, etc).
+ */
+type ConditionOperator = 'equals' | 'notEquals' | 'contains' | 'notContains' | 'greaterThan' | 'lessThan' | 'greaterThanOrEqual' | 'lessThanOrEqual' | 'isTrue' | 'isFalse' | 'isEmpty' | 'isNotEmpty';
+/**
+ * A single condition evaluation
+ */
+type Condition = {
+    /** The field name to watch */
+    field: string;
+    /** The comparison operator */
+    operator: ConditionOperator;
+    /** The value to compare against (if applicable) */
+    value?: string | number | boolean | null;
+};
+/**
+ * A group of conditions combined with a logic operator
+ */
+type ConditionGroup = {
+    /** Array of conditions to evaluate */
+    conditions: Condition[];
+    /** How to combine the results */
+    operator: 'AND' | 'OR';
+};
+
+/**
+ * Submit Actions Types
+ *
+ * Sistema modular de acciones de submit que permite configurar
+ * múltiples endpoints, webhooks, emails y funciones custom.
+ * Cada acción puede tener su propio trigger (cuándo se ejecuta).
+ */
+
+type SubmitActionType = 'http' | 'webhook' | 'email' | 'custom';
+interface HttpEndpointConfig {
+    url: string;
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    headers?: Record<string, string>;
+}
+interface HttpBodyConfig {
+    /** Formato del body */
+    format: 'json' | 'form-data' | 'url-encoded';
+    /** Template con placeholders {{fieldName}} */
+    template?: string;
+    /** Solo incluir estos campos (si no se especifica, incluye todos) */
+    includeFields?: string[];
+    /** Excluir estos campos del payload */
+    excludeFields?: string[];
+}
+interface HttpAuthConfig {
+    type: 'none' | 'bearer' | 'basic' | 'api-key';
+    /** Token para bearer auth */
+    token?: string;
+    /** Usuario para basic auth */
+    username?: string;
+    /** Password para basic auth */
+    password?: string;
+    /** Nombre del header para api-key (default: X-API-Key) */
+    headerName?: string;
+}
+interface HttpRetryConfig {
+    enabled: boolean;
+    maxAttempts: number;
+    delayMs: number;
+}
+interface HttpSubmitAction {
+    type: 'http';
+    name: string;
+    endpoint: HttpEndpointConfig;
+    body?: HttpBodyConfig;
+    auth?: HttpAuthConfig;
+    retry?: HttpRetryConfig;
+    /** Timeout en ms (default: 30000) */
+    timeout?: number;
+}
+interface WebhookSubmitAction {
+    type: 'webhook';
+    name: string;
+    url: string;
+    /** Secret para firma HMAC (opcional) */
+    secret?: string;
+    /** Headers adicionales */
+    headers?: Record<string, string>;
+    /** Template del payload con placeholders {{fieldName}} */
+    payloadTemplate?: string;
+    /** Solo incluir estos campos */
+    includeFields?: string[];
+    /** Excluir estos campos */
+    excludeFields?: string[];
+}
+type EmailProvider = 'smtp' | 'sendgrid' | 'resend' | 'mailgun';
+interface EmailSubmitAction {
+    type: 'email';
+    name: string;
+    /** Proveedor de email */
+    provider: EmailProvider;
+    /** Endpoint del servicio (para SMTP o API custom) */
+    endpoint?: string;
+    /** API Key del proveedor */
+    apiKey?: string;
+    /** Destinatarios */
+    to: string | string[];
+    cc?: string[];
+    bcc?: string[];
+    /** From address */
+    from?: string;
+    /** Asunto del email (soporta placeholders {{fieldName}}) */
+    subject: string;
+    /** Tipo de template */
+    template: 'default' | 'custom';
+    /** HTML del template custom (soporta placeholders {{fieldName}}) */
+    customTemplate?: string;
+    /** Reply-to address */
+    replyTo?: string;
+}
+interface CustomSubmitAction {
+    type: 'custom';
+    name: string;
+    /** Función que se ejecuta con los valores del formulario */
+    handler: (values: Record<string, unknown>) => Promise<unknown>;
+}
+type SubmitAction = HttpSubmitAction | WebhookSubmitAction | EmailSubmitAction | CustomSubmitAction;
+type SubmitTriggerType = 'onSubmit' | 'onStepEnter' | 'onStepExit' | 'onFieldChange' | 'onFieldBlur' | 'onDelay' | 'manual';
+interface SubmitTrigger {
+    type: SubmitTriggerType;
+    /** Para onStepEnter/onStepExit: ID del step */
+    stepId?: string;
+    /** Para onFieldChange/onFieldBlur: nombre del campo */
+    fieldName?: string;
+    /** Para onDelay: milisegundos de inactividad */
+    delayMs?: number;
+    /** Debounce en ms para evitar ejecuciones múltiples (default: 0) */
+    debounceMs?: number;
+}
+interface SubmitActionCondition {
+    /** Campo a evaluar */
+    field: string;
+    /** Operador de comparación */
+    operator: ConditionOperator;
+    /** Valor a comparar */
+    value: unknown;
+}
+/** Built-in value transforms applied per-field before sending. */
+type BuiltinTransform = 'toString' | 'toNumber' | 'toBoolean' | 'booleanString' | 'dateISO' | 'dateYMD' | 'dateDMY' | 'dateTimestamp' | 'trim' | 'lowercase' | 'uppercase' | 'emptyToNull';
+/** Custom transform function for field values. */
+type FieldTransformFn = (value: unknown) => unknown;
+/** Advanced field mapping entry with rename + transform. */
+interface FieldMapEntry {
+    /** Target field name in the API payload */
+    to: string;
+    /** Value transform — built-in name or custom function */
+    transform?: BuiltinTransform | FieldTransformFn;
+}
+/**
+ * A resolver injects computed/dynamic values into the payload.
+ * Distinguished from static values by the `$resolver` key.
+ */
+type FieldResolver = {
+    $resolver: 'timestamp';
+} | {
+    $resolver: 'hostname';
+} | {
+    $resolver: 'urlParam';
+    param: string;
+    fallback?: string;
+} | {
+    $resolver: 'ip';
+    endpoint?: string;
+    fallback?: string;
+} | {
+    $resolver: 'pageUrl';
+} | {
+    $resolver: 'referrer';
+} | {
+    $resolver: 'userAgent';
+} | {
+    $resolver: 'custom';
+    fn: () => unknown;
+};
+/**
+ * Serializable subset of FieldResolver (excludes 'custom' which requires a runtime function).
+ * Used by hidden fields in the form builder where config must be JSON-serializable.
+ */
+type SerializableFieldResolver = Exclude<FieldResolver, {
+    $resolver: 'custom';
+}>;
+/**
+ * Built-in resolver definitions with labels and descriptions for the builder UI.
+ */
+declare const BUILTIN_RESOLVERS: readonly [{
+    readonly id: "timestamp";
+    readonly label: "Timestamp";
+    readonly description: "Current date/time in ISO format";
+}, {
+    readonly id: "hostname";
+    readonly label: "Hostname";
+    readonly description: "Current page hostname";
+}, {
+    readonly id: "pageUrl";
+    readonly label: "Page URL";
+    readonly description: "Full page URL (window.location.href)";
+}, {
+    readonly id: "referrer";
+    readonly label: "Referrer";
+    readonly description: "Referring page URL (document.referrer)";
+}, {
+    readonly id: "userAgent";
+    readonly label: "User Agent";
+    readonly description: "Browser user agent string";
+}, {
+    readonly id: "ip";
+    readonly label: "IP Address";
+    readonly description: "Visitor IP via external API";
+}, {
+    readonly id: "urlParam";
+    readonly label: "URL Parameter";
+    readonly description: "Value from a URL query parameter";
+}];
+/**
+ * Advanced field mapping configuration.
+ *
+ * Supports renaming, value transforms, computed field injection,
+ * field exclusion, and passthrough control.
+ *
+ * @example
+ * ```ts
+ * fieldMapping: {
+ *   fields: {
+ *     nombre: "first_name",                           // simple rename
+ *     fecha: { to: "birth_date", transform: "dateYMD" }, // rename + transform
+ *     acepta: { to: "accepts", transform: "booleanString" },
+ *   },
+ *   inject: {
+ *     campaign_id: "10653",                           // static value
+ *     timestamp: { $resolver: "timestamp" },          // computed
+ *     hostname: { $resolver: "hostname" },
+ *     sub_aff_id: { $resolver: "urlParam", param: "sub_aff_id", fallback: "seo_organico" },
+ *   },
+ *   exclude: ["internal_field"],
+ *   passthrough: true,
+ * }
+ * ```
+ */
+interface FieldMapping {
+    /** Map/transform form fields → API fields */
+    fields?: Record<string, string | FieldMapEntry>;
+    /** Inject additional fields not from form inputs. Use `{ $resolver: ... }` for dynamic values. */
+    inject?: Record<string, unknown>;
+    /** Exclude these form fields from the payload */
+    exclude?: string[];
+    /** If false, only mapped fields are sent. Default: true (unmapped pass through) */
+    passthrough?: boolean;
+}
+/**
+ * Field mapping configuration — supports two formats:
+ * - Simple: `Record<string, string>` — rename fields only (backward compatible)
+ * - Advanced: `FieldMapping` — rename, transform, inject, exclude
+ */
+type FieldMappingConfig = Record<string, string> | FieldMapping;
+interface SubmitActionNode {
+    /** ID único del nodo */
+    id: string;
+    /** Configuración de la acción */
+    action: SubmitAction;
+    /** Cuándo se ejecuta */
+    trigger: SubmitTrigger;
+    /** Condición opcional para ejecutar (si no se cumple, se salta) */
+    condition?: SubmitActionCondition;
+    /** Orden de ejecución (para modo secuencial) */
+    order?: number;
+    /** Si true, continúa con las siguientes acciones aunque esta falle */
+    continueOnError?: boolean;
+    /** Si true, la acción está deshabilitada */
+    disabled?: boolean;
+    /**
+     * Maps form field names to API-expected field names, with optional
+     * value transforms and computed field injection.
+     *
+     * Supports two formats:
+     * 1. Simple rename: `Record<string, string>`
+     * 2. Advanced: `FieldMapping` with transforms, inject, exclude
+     *
+     * @example
+     * ```ts
+     * // Simple: rename only
+     * fieldMapping: {
+     *   nombre: "first_name",
+     *   email: "email_address",
+     * }
+     *
+     * // Advanced: rename + transform + inject
+     * fieldMapping: {
+     *   fields: {
+     *     nombre: "first_name",
+     *     fecha_nacimiento: { to: "birth_date", transform: "dateYMD" },
+     *     seguro_enfermedad: { to: "has_insurance", transform: "booleanString" },
+     *   },
+     *   inject: {
+     *     campaign_id: "10653",
+     *     ip: { $resolver: "custom", fn: () => getIpAddress() },
+     *     timestamp: { $resolver: "timestamp" },
+     *   },
+     * }
+     * ```
+     */
+    fieldMapping?: FieldMappingConfig;
+}
+interface SubmitExecutionConfig {
+    /** Modo de ejecución de múltiples acciones */
+    mode: 'sequential' | 'parallel';
+    /** Si true, detiene la ejecución en el primer error (solo para sequential) */
+    stopOnFirstError?: boolean;
+    /** Timeout global para todas las acciones (ms) */
+    globalTimeout?: number;
+}
+interface SubmitActionResult {
+    /** ID de la acción ejecutada */
+    actionId: string;
+    /** Nombre de la acción */
+    actionName: string;
+    /** Si la ejecución fue exitosa */
+    success: boolean;
+    /** Datos de respuesta (si success = true) */
+    data?: unknown;
+    /** Error (si success = false) */
+    error?: Error;
+    /** Duración de la ejecución en ms */
+    durationMs: number;
+    /** Timestamp de inicio */
+    startedAt: Date;
+    /** Timestamp de fin */
+    completedAt: Date;
+}
+interface SubmitActionsResult {
+    /** Resultados de todas las acciones */
+    results: SubmitActionResult[];
+    /** Si todas las acciones fueron exitosas */
+    allSuccessful: boolean;
+    /** Número de acciones exitosas */
+    successCount: number;
+    /** Número de acciones fallidas */
+    failureCount: number;
+    /** Duración total */
+    totalDurationMs: number;
+}
+
+/**
+ * Serializable validation rules for form fields.
+ *
+ * This flat type can be stored as JSON in a database or API response.
+ * The field `type` discriminates which rules apply at runtime.
+ * Rules are compiled to Zod schemas internally via `compileValidationRules()`.
+ */
+type ValidationRules = {
+    required?: boolean;
+    requiredMessage?: string;
+    minLength?: number;
+    minLengthMessage?: string;
+    maxLength?: number;
+    maxLengthMessage?: string;
+    pattern?: string;
+    patternMessage?: string;
+    format?: 'email' | 'url' | 'uuid' | 'cuid' | 'emoji';
+    formatMessage?: string;
+    min?: number;
+    minMessage?: string;
+    max?: number;
+    maxMessage?: string;
+    integer?: boolean;
+    integerMessage?: string;
+    positive?: boolean;
+    positiveMessage?: string;
+    minItems?: number;
+    minItemsMessage?: string;
+    maxItems?: number;
+    maxItemsMessage?: string;
+    mustBeTrue?: boolean;
+    mustBeTrueMessage?: string;
+    minDate?: string;
+    minDateMessage?: string;
+    maxDate?: string;
+    maxDateMessage?: string;
+    mustBeFuture?: boolean;
+    mustBeFutureMessage?: string;
+    mustBePast?: boolean;
+    mustBePastMessage?: string;
+    preset?: string;
+};
+/**
+ * Union type for the `schema` property on field configs.
+ * Accepts either a raw Zod schema or serializable ValidationRules.
+ */
+type SchemaType = z.ZodType | ValidationRules;
+
+interface LabelProps$1 {
+    /** Label shown to the user (puede ser HTML) */
+    label?: string;
+    /** Opcionalmente oculta el label del campo */
+    hideLabel?: boolean;
+    /** Clase CSS opcional para el label */
+    label_className?: string;
+    /** Descripción del campo (se muestra como texto adicional o tooltip) */
+    description?: string;
+}
+interface FieldLayoutConfig {
+    /** Número de columnas que ocupa el campo por breakpoint (1-12, default, sm, md, lg, xl, 2xl) */
+    columns?: Partial<Record<Breakpoint$1, number>>;
+    /** Orden de visualización (útil para reordenar sin arrastrar). Puede ser un número fijo o responsive por breakpoint */
+    order?: number | Partial<Record<Breakpoint$1, number>>;
+}
+interface LayoutProps {
+    /** Configuración de layout del campo (columns, orden, visibilidad) */
+    layout?: FieldLayoutConfig;
+    /** Número de columnas que ocupa el campo por breakpoint (1-12) - Atajo para layout.columns */
+    columns?: Partial<Record<Breakpoint$1, number>>;
+    /** Alias para columns - usado por form-builder */
+    gridSpan?: number | Partial<Record<Breakpoint$1, number>>;
+    /** Orden de visualización del campo */
+    order?: number | Partial<Record<Breakpoint$1, number>>;
+    /** Clase CSS opcional para el FormItem */
+    wrapper_className?: string;
+    /** Clase CSS general para el campo */
+    className?: string;
+}
+interface InputProps$1 {
+    /** Clase CSS opcional para el input/control */
+    input_className?: string;
+    /** Valor inicial del campo */
+    value?: unknown;
+    /** Valor por defecto del campo */
+    defaultValue?: unknown;
+    /** Placeholder del campo */
+    placeholder?: string;
+    /** Atributo HTML autocomplete */
+    autocomplete?: string;
+    /** Indica si el campo es requerido (complementa la validación Zod) */
+    required?: boolean;
+    /** Tamaño opcional para inputs y textareas */
+    size?: InputSize;
+    /** Elemento React para el icono */
+    icon?: ReactNode;
+    /** Props opcionales para el icono (color, tamaño, etc) */
+    iconProps?: {
+        className?: string;
+        [key: string]: unknown;
+    };
+}
+interface ValidationProps {
+    /** Esquema de validación Zod or serializable ValidationRules */
+    schema?: z.ZodType | ValidationRules;
+    /** Names of plugin-registered validators to apply to this field */
+    customValidators?: string[];
+    /** Clase CSS opcional para el mensaje de error */
+    error_className?: string;
+    /** Texto de ayuda opcional que se muestra debajo del input */
+    helperText?: string;
+    /** Clase CSS opcional para el mensaje de ayuda */
+    helper_className?: string;
+    /** Texto de ayuda contextual que se muestra en un tooltip */
+    tooltip?: string;
+}
+
+interface StateProps {
+    /** Oculta el campo basado en una condición booleana, una función, un grupo de condiciones declarativas, o responsive por breakpoint */
+    hidden?: boolean | ((values: Record<string, unknown>) => boolean) | ConditionGroup | Partial<Record<Breakpoint$1, 'visible' | 'hidden'>>;
+    /** Deshabilita el campo basado en una condición booleana, una función o un grupo de condiciones declarativas */
+    disabled?: boolean | ((values: Record<string, unknown>) => boolean) | ConditionGroup;
+    /** Hace el campo de solo lectura basado en una condición booleana, una función o un grupo de condiciones declarativas */
+    readOnly?: boolean | ((values: Record<string, unknown>) => boolean) | ConditionGroup;
+}
+interface OptionsLayoutProps {
+    /** Clases CSS para controlar el layout del grid de opciones (por defecto: "grid grid-cols-1 gap-2") */
+    optionsClassName?: string;
+}
+interface TransformProps {
+    /** Value transform(s) applied before submission.
+     * Runs before plugin transformValues and action-level fieldMapping.
+     * Use a single built-in name, an array for chaining, or a custom function.
+     */
+    transform?: BuiltinTransform | BuiltinTransform[] | FieldTransformFn;
+}
+interface ComputedProps {
+    /** Reactive computation — value is auto-set from other field values.
+     * The field is readOnly while computed is active.
+     */
+    computed?: {
+        /** Field names this computation depends on */
+        dependsOn: string[];
+        /** Pure function that computes the value from all form values */
+        compute: (values: Record<string, unknown>) => unknown;
+    };
+}
+interface AdvancedProps {
+    /** Clave para tracking/analytics */
+    trackingKey?: string;
+}
+interface BaseFieldProps extends LabelProps$1, LayoutProps, InputProps$1, ValidationProps, StateProps, TransformProps, ComputedProps, AdvancedProps {
+}
+type Option = {
+    label: string;
+    value: string;
+    icon?: ReactNode;
+    iconProps?: Record<string, unknown>;
+};
+type ButtonCardOption = {
+    value: string;
+    text: string;
+    description?: string;
+    icon?: ReactNode;
+    iconProps?: Record<string, unknown>;
+};
+interface TextFieldProps extends BaseFieldProps {
+    type: 'text' | 'email' | 'tel' | 'url' | 'password' | 'number';
+    placeholder?: string;
+    schema: z.ZodType | ValidationRules;
+}
+interface TextareaFieldProps extends BaseFieldProps {
+    type: 'textarea';
+    placeholder?: string;
+    schema: z.ZodType | ValidationRules;
+    rows?: number;
+    maxLength?: number;
+}
+interface SliderFieldProps extends BaseFieldProps {
+    type: 'slider';
+    defaultValue?: number[];
+    max?: number;
+    min?: number;
+    step?: number;
+    /** 'default' = single thumb, 'range' = two thumbs (min/max), 'multi' = multiple thumbs */
+    variant?: 'default' | 'range' | 'multi';
+    /** Slider orientation */
+    orientation?: 'horizontal' | 'vertical';
+    /** Number of thumbs for 'multi' variant (default: 3) */
+    thumbCount?: number;
+    /** Show min/max labels below slider */
+    showLabels?: boolean;
+    /** Show current value(s) */
+    showValue?: boolean;
+    /** Format function for displayed values (e.g., add units) */
+    valueFormat?: string;
+    schema: z.ZodType | ValidationRules;
+}
+interface SelectFieldProps extends BaseFieldProps {
+    type: 'select';
+    options: Option[];
+    schema: z.ZodType | ValidationRules;
+}
+interface ComboboxFieldProps extends BaseFieldProps {
+    type: 'combobox';
+    options: Option[];
+    schema: z.ZodType | ValidationRules;
+    placeholder?: string;
+    searchPlaceholder?: string;
+    emptyText?: string;
+}
+interface NativeSelectFieldProps extends BaseFieldProps {
+    type: 'native-select';
+    options: Option[];
+    schema: z.ZodType | ValidationRules;
+}
+interface RadioFieldProps extends BaseFieldProps {
+    type: 'radio';
+    options: Option[];
+    schema: z.ZodType | ValidationRules;
+}
+interface ButtonRadioFieldProps extends BaseFieldProps, OptionsLayoutProps {
+    type: 'button-radio';
+    options: Option[];
+    schema: z.ZodType | ValidationRules;
+}
+interface CheckboxFieldProps extends BaseFieldProps {
+    type: 'checkbox';
+    schema: z.ZodType | ValidationRules;
+}
+interface SwitchFieldProps extends BaseFieldProps {
+    type: 'switch';
+    schema: z.ZodType | ValidationRules;
+}
+interface CheckboxGroupFieldProps extends BaseFieldProps, OptionsLayoutProps {
+    type: 'checkbox-group';
+    options: Option[];
+    schema: z.ZodType | ValidationRules;
+}
+interface SwitchGroupFieldProps extends BaseFieldProps, OptionsLayoutProps {
+    type: 'switch-group';
+    options: Option[];
+    schema: z.ZodType | ValidationRules;
+}
+interface ButtonCheckboxFieldProps extends BaseFieldProps, OptionsLayoutProps {
+    type: 'button-checkbox';
+    options: Option[];
+    schema: z.ZodType | ValidationRules;
+}
+interface DateFieldProps extends BaseFieldProps {
+    type: 'date';
+    schema: z.ZodType | ValidationRules;
+    placeholder?: string;
+    dateType?: 'simple' | 'popover';
+    showTime?: boolean;
+    presets?: Array<{
+        label: string;
+        value: number;
+    }>;
+}
+interface DateRangeFieldProps extends BaseFieldProps {
+    type: 'daterange';
+    schema: z.ZodType | ValidationRules;
+    placeholder?: string;
+}
+interface HtmlFieldProps extends BaseFieldProps {
+    type: 'html';
+    html?: string;
+    content?: string;
+}
+interface ButtonCardFieldProps extends BaseFieldProps, OptionsLayoutProps {
+    type: 'button-card';
+    options: ButtonCardOption[];
+    multiple?: boolean;
+    schema: z.ZodType | ValidationRules;
+}
+interface OtpFieldProps extends BaseFieldProps {
+    type: 'otp';
+    length?: number;
+    schema: z.ZodType | ValidationRules;
+}
+interface CommandFieldProps extends BaseFieldProps {
+    type: 'command';
+    options: Option[];
+    schema: z.ZodType | ValidationRules;
+    placeholder?: string;
+    searchPlaceholder?: string;
+    emptyText?: string;
+}
+interface InputGroupFieldProps extends BaseFieldProps {
+    type: 'input-group';
+    prefix?: string;
+    suffix?: string;
+    placeholder?: string;
+    schema: z.ZodType | ValidationRules;
+}
+interface RepeaterFieldProps extends BaseFieldProps {
+    type: 'repeater';
+    /** Sub-field definitions for each item in the list */
+    itemFields: Record<string, FieldConfig>;
+    /** Minimum number of items (default: 0) */
+    minItems?: number;
+    /** Maximum number of items */
+    maxItems?: number;
+    /** Label for the add button (default: "Add item") */
+    addLabel?: string;
+    /** Label for the remove button (default: "Remove") */
+    removeLabel?: string;
+    schema?: z.ZodType | ValidationRules;
+}
+interface FileFieldProps extends BaseFieldProps {
+    type: 'file';
+    /** Accepted file types (e.g. "image/*", ".pdf,.doc") */
+    accept?: string;
+    /** Allow multiple file selection */
+    multiple?: boolean;
+    /** Max file size in bytes */
+    maxSize?: number;
+    schema?: z.ZodType | ValidationRules;
+}
+interface CurrencyFieldProps extends BaseFieldProps {
+    type: 'currency';
+    prefix?: string;
+    suffix?: string;
+    placeholder?: string;
+    schema: z.ZodType | ValidationRules;
+}
+interface RangeFieldProps extends BaseFieldProps {
+    type: 'range';
+    defaultValue?: number[];
+    max?: number;
+    min?: number;
+    step?: number;
+    variant?: 'default' | 'range' | 'multi';
+    orientation?: 'horizontal' | 'vertical';
+    thumbCount?: number;
+    showLabels?: boolean;
+    showValue?: boolean;
+    valueFormat?: string;
+    schema: z.ZodType | ValidationRules;
+}
+interface HiddenFieldProps extends BaseFieldProps {
+    type: 'hidden';
+    /** Resolver that computes the field value at form init */
+    resolver: SerializableFieldResolver;
+}
+type FieldConfig = TextFieldProps | TextareaFieldProps | SliderFieldProps | RangeFieldProps | SelectFieldProps | ComboboxFieldProps | NativeSelectFieldProps | RadioFieldProps | ButtonRadioFieldProps | CheckboxFieldProps | SwitchFieldProps | CheckboxGroupFieldProps | SwitchGroupFieldProps | ButtonCheckboxFieldProps | DateFieldProps | DateRangeFieldProps | HtmlFieldProps | ButtonCardFieldProps | OtpFieldProps | CommandFieldProps | InputGroupFieldProps | CurrencyFieldProps | FileFieldProps | RepeaterFieldProps | HiddenFieldProps | ButtonConfig;
+
+interface ButtonConfig extends BaseFieldProps {
+    type: 'button' | 'submit' | 'next' | 'back';
+    action?: () => void;
+    loading?: boolean;
+    /** Elemento React para el icono */
+    icon?: ReactNode;
+    iconPosition?: 'left' | 'right';
+    variant?: 'default' | 'destructive' | 'outline' | 'secondary' | 'ghost' | 'link';
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    effect?: string;
+    rounded?: string;
+    label?: string;
+}
+/** Props que puede recibir un botón del formulario  */
+type FormButtonProps = React.ComponentProps<'button'> & {
+    /** Clase CSS opcional para el botón */
+    className?: string;
+    /** Col-span para el botón en el grid */
+    colSpan?: number;
+    /** Texto del botón */
+    text?: string;
+    variant?: string;
+    size?: string;
+};
+interface FormButtons {
+    submit?: ButtonConfig;
+    next?: ButtonConfig;
+    back?: ButtonConfig;
+    /** Alineación horizontal de los botones */
+    align?: 'start' | 'center' | 'end' | 'between' | 'responsive';
+    /** Si true, los botones se muestran en la misma línea que los campos (inline form) */
+    inline?: boolean;
+}
+
+type StepCondition = ConditionGroup & {
+    target: string;
+};
+type Step = {
+    /** Step identifier. Optional when using `Record<string, Step>` — the key serves as the id. */
+    id?: string;
+    fields: string[];
+    next?: StepCondition[];
+    defaultNext?: string;
+};
+
+interface RecaptchaConfig {
+    siteKey: string;
+    action: string;
+}
+interface EndpointConfig {
+    url: string;
+    clientId: string;
+}
+type SubmitType = 'default' | 'default-no-recaptcha' | 'custom';
+interface DefaultSubmitConfig {
+    type: 'default' | 'default-no-recaptcha';
+    endpoint: EndpointConfig;
+    recaptcha?: RecaptchaConfig;
+}
+interface CustomSubmitConfig {
+    type: 'custom';
+    onSubmit: (values: Record<string, any>) => Promise<void>;
+}
+type SubmitConfig = DefaultSubmitConfig | CustomSubmitConfig;
+
+/**
+ * ============================================
+ * PLUGIN SYSTEM - Extensibility Architecture
+ * ============================================
+ *
+ * Sistema de plugins para extender funcionalidad sin modificar código fuente.
+ */
+/**
+ * Contexto de validación para plugins.
+ */
+interface ValidationContext {
+    fieldName: string;
+    allValues: Record<string, unknown>;
+    abortSignal?: AbortSignal;
+}
+/**
+ * Renderer personalizado de campo para plugins.
+ */
+type FieldRenderer$1 = React.ComponentType<{
+    name: string;
+    fieldConfig: any;
+    control: any;
+    colSpanItem: string;
+}>;
+/**
+ * Interfaz principal de un plugin de formulario.
+ *
+ * Los plugins pueden interceptar el ciclo de vida del formulario,
+ * registrar campos personalizados y transformar configuraciones.
+ */
+interface FormPlugin {
+    /** Nombre único del plugin */
+    name: string;
+    /** Versión del plugin */
+    version: string;
+    /** Descripción opcional del plugin */
+    description?: string;
+    /**
+     * Se ejecuta cuando el formulario se inicializa.
+     *
+     * @param config - Configuración del formulario
+     */
+    onFormInit?: (config: FormConfig) => void;
+    /**
+     * Se ejecuta cuando cambia el step actual.
+     *
+     * @param stepId - ID del nuevo step
+     * @param values - Valores actuales del formulario
+     */
+    onStepChange?: (stepId: string, values: Record<string, unknown>) => void;
+    /**
+     * Se ejecuta antes de enviar el formulario.
+     * Puede ser asíncrono para validaciones adicionales.
+     *
+     * @param values - Valores a enviar
+     * @throws Error si la validación falla
+     */
+    onBeforeSubmit?: (values: Record<string, unknown>) => void | Promise<void>;
+    /**
+     * Se ejecuta después de enviar exitosamente el formulario.
+     *
+     * @param values - Valores enviados
+     * @param response - Respuesta del servidor
+     */
+    onAfterSubmit?: (values: Record<string, unknown>, response: unknown) => void;
+    /**
+     * Se ejecuta cuando ocurre un error.
+     *
+     * @param error - Error ocurrido
+     * @param values - Valores actuales del formulario
+     */
+    onError?: (error: Error, values?: Record<string, unknown>) => void;
+    /**
+     * Se ejecuta cuando un campo cambia de valor.
+     *
+     * @param fieldName - Nombre del campo
+     * @param value - Nuevo valor
+     * @param allValues - Todos los valores del formulario
+     */
+    onFieldChange?: (fieldName: string, value: unknown, allValues: Record<string, unknown>) => void;
+    /**
+     * Registra campos personalizados.
+     *
+     * @returns Objeto con tipos de campo y sus renderizadores
+     *
+     * @example
+     * ```tsx
+     * registerFields() {
+     *   return {
+     *     signature: SignatureFieldRenderer,
+     *     wysiwyg: WysiwygFieldRenderer,
+     *   };
+     * }
+     * ```
+     */
+    registerFields?: () => Record<string, FieldRenderer$1>;
+    /**
+     * Transforma la configuración del formulario antes de usarla.
+     *
+     * @param config - Configuración original
+     * @returns Configuración transformada
+     *
+     * @example
+     * ```tsx
+     * transformConfig(config) {
+     *   // Agregar prefijo a todos los campos
+     *   return {
+     *     ...config,
+     *     fields: Object.fromEntries(
+     *       Object.entries(config.fields).map(([key, value]) => [
+     *         `prefix_${key}`,
+     *         value
+     *       ])
+     *     )
+     *   };
+     * }
+     * ```
+     */
+    transformConfig?: (config: FormConfig) => FormConfig;
+    /**
+     * Transforma los valores antes de enviar.
+     *
+     * @param values - Valores originales
+     * @returns Valores transformados
+     *
+     * @example
+     * ```tsx
+     * transformValues(values) {
+     *   // Convertir fechas a ISO string
+     *   return Object.fromEntries(
+     *     Object.entries(values).map(([key, value]) => [
+     *       key,
+     *       value instanceof Date ? value.toISOString() : value
+     *     ])
+     *   );
+     * }
+     * ```
+     */
+    transformValues?: (values: Record<string, unknown>) => Record<string, unknown> | Promise<Record<string, unknown>>;
+    /**
+     * Registra validadores personalizados.
+     *
+     * @returns Objeto con nombre del validador y función de validación
+     *
+     * @example
+     * ```tsx
+     * validators: {
+     *   uniqueEmail: async (value, context) => {
+     *     const response = await fetch(`/api/check-email?email=${value}`);
+     *     const { exists } = await response.json();
+     *     return exists ? "Email already registered" : true;
+     *   }
+     * }
+     * ```
+     */
+    validators?: Record<string, (value: unknown, context: ValidationContext) => boolean | string | Promise<boolean | string>>;
+    /**
+     * Opciones de configuración del plugin.
+     */
+    options?: Record<string, unknown>;
+    /**
+     * Inicializa el plugin con opciones personalizadas.
+     *
+     * @param options - Opciones de configuración
+     */
+    init?: (options?: Record<string, unknown>) => void;
+    /**
+     * Limpia recursos del plugin.
+     */
+    cleanup?: () => void;
+}
+/**
+ * Tipo helper para crear plugins con type safety.
+ */
+type DefinePlugin = (options?: Record<string, unknown>) => FormPlugin;
+/**
+ * Helper para definir un plugin con type safety.
+ *
+ * @param plugin - Configuración del plugin
+ * @returns Plugin tipado
+ *
+ * @example
+ * ```tsx
+ * export const myPlugin = definePlugin({
+ *   name: "my-plugin",
+ *   version: "1.0.0",
+ *   onFormInit(config) {
+ *     console.log("Form initialized:", config.formId);
+ *   },
+ * });
+ * ```
+ */
+declare function definePlugin(plugin: FormPlugin): FormPlugin;
+
+/**
+ * ============================================
+ * PLUGIN MANAGER - Plugin System Core
+ * ============================================
+ *
+ * Gestiona el registro, ejecución y coordinación de plugins.
+ */
+declare class PluginManager {
+    private plugins;
+    private customFields;
+    private validators;
+    /**
+     * Registra un nuevo plugin.
+     *
+     * @param plugin - Plugin a registrar
+     * @throws Error si el plugin ya está registrado
+     *
+     * @example
+     * ```tsx
+     * const pluginManager = new PluginManager();
+     * pluginManager.register(localStoragePlugin);
+     * pluginManager.register(analyticsPlugin);
+     * ```
+     */
+    register(plugin: FormPlugin): void;
+    /**
+     * Desregistra un plugin.
+     *
+     * @param pluginName - Nombre del plugin a desregistrar
+     * @returns true si se desregistró, false si no existía
+     */
+    unregister(pluginName: string): boolean;
+    /**
+     * Obtiene un plugin registrado.
+     *
+     * @param pluginName - Nombre del plugin
+     * @returns Plugin o undefined si no existe
+     */
+    getPlugin(pluginName: string): FormPlugin | undefined;
+    /**
+     * Obtiene todos los plugins registrados.
+     *
+     * @returns Array de plugins
+     */
+    getAllPlugins(): FormPlugin[];
+    /**
+     * Obtiene un renderer de campo personalizado.
+     *
+     * @param type - Tipo de campo
+     * @returns Renderer o undefined si no existe
+     */
+    getCustomField(type: string): FieldRenderer$1 | undefined;
+    /**
+     * Verifica si existe un tipo de campo personalizado.
+     *
+     * @param type - Tipo de campo
+     * @returns true si existe
+     */
+    hasCustomField(type: string): boolean;
+    /**
+     * Obtiene un validador personalizado.
+     *
+     * @param name - Nombre del validador
+     * @returns Validador o undefined si no existe
+     */
+    getValidator(name: string): ((value: unknown, context: ValidationContext) => boolean | string | Promise<boolean | string>) | undefined;
+    /**
+     * Ejecuta un hook en todos los plugins que lo implementen.
+     *
+     * @param hook - Nombre del hook a ejecutar
+     * @param args - Argumentos para el hook
+     *
+     * @example
+     * ```tsx
+     * await pluginManager.executeHook("onFormInit", formConfig);
+     * await pluginManager.executeHook("onStepChange", "step2", values);
+     * ```
+     */
+    executeHook(hook: keyof FormPlugin, ...args: any[]): Promise<void>;
+    /**
+     * Transforma la configuración del formulario aplicando todos los transformers.
+     *
+     * @param config - Configuración original
+     * @returns Configuración transformada
+     */
+    transformConfig(config: FormConfig): FormConfig;
+    /**
+     * Transforma los valores del formulario aplicando todos los transformers.
+     * Supports both sync and async transformers (chained in registration order).
+     *
+     * @param values - Valores originales
+     * @returns Valores transformados
+     */
+    transformValues(values: Record<string, unknown>): Promise<Record<string, unknown>>;
+    /**
+     * Limpia todos los plugins registrados.
+     */
+    cleanup(): void;
+    /**
+     * Obtiene estadísticas del plugin manager.
+     *
+     * @returns Objeto con estadísticas
+     */
+    getStats(): {
+        totalPlugins: number;
+        customFields: number;
+        validators: number;
+        plugins: {
+            name: string;
+            version: string;
+            description: string | undefined;
+        }[];
+    };
+}
+/**
+ * Instancia global del plugin manager (opcional).
+ * Los usuarios pueden crear sus propias instancias si lo prefieren.
+ */
+declare const globalPluginManager: PluginManager;
+
+type Fields = Record<string, FieldConfig>;
+type Steps = Record<string, Step>;
+/** Breakpoints de Tailwind */
+type Breakpoint$1 = 'default' | 'sm' | 'md' | 'lg' | 'xl' | '2xl';
+/** Tipo para valores de gap (0-12, donde 0 = sin gap) */
+type GapValue = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
+/** Tipo para valores de columnas (1-12) */
+type ColumnsValue = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
+interface FormLayout {
+    /** Modo de layout: "auto" (adaptativo) o "manual" (fijo) */
+    mode: 'auto' | 'manual';
+    /** Tamaño de gap entre campos (0-12, default: 4, donde 0 = sin gap) */
+    gap?: GapValue;
+    /** Ancho mínimo de campo en píxeles (solo para modo "auto", default: 240) */
+    minFieldWidth?: number;
+    /** Número de columnas (1-12, default: 1)
+     * - En modo "auto": máximo de columnas (opcional)
+     * - En modo "manual": columnas fijas (opcional, default: 1)
+     */
+    columns?: ColumnsValue;
+    /** Clases CSS adicionales para el contenedor del grid */
+    className?: string;
+}
+/**
+ * Configuración para el sistema de confirmación de envío con campos opcionales.
+ * Permite advertir al usuario antes de enviar si hay campos opcionales vacíos.
+ */
+interface SubmitConfirmationConfig {
+    /**
+     * Campos opcionales que generan advertencia si están vacíos.
+     * El sistema verifica estos campos antes de submit/navegación.
+     */
+    optionalFields: Array<{
+        /** Nombre del campo a verificar */
+        name: string;
+        /** Mensaje descriptivo de por qué es importante este campo */
+        message: string;
+    }>;
+    /**
+     * Comportamiento visual del botón durante la advertencia
+     */
+    buttonBehavior: {
+        /** Texto original del botón (opcional, se usa el del ButtonConfig si no se especifica) */
+        defaultText?: string;
+        /** Texto a mostrar cuando hay campos vacíos (primera vez que se hace click) */
+        warningText: string;
+        /** Variant del botón durante advertencia (opcional) */
+        warningVariant?: ButtonConfig['variant'];
+        /** Effect del botón durante advertencia (opcional) */
+        warningEffect?: ButtonConfig['effect'];
+        /** Tiempo en ms antes de volver al estado normal (default: 3000) */
+        resetDelay?: number;
+    };
+    /**
+     * Dónde aplicar la confirmación:
+     * - "submit": Solo en el botón de envío final
+     * - "steps": Solo en navegación entre steps (botón Next)
+     * - "both": En ambos casos
+     */
+    applyOn: 'submit' | 'steps' | 'both';
+    /**
+     * Si true, la advertencia solo se muestra una vez por sesión.
+     * Después de confirmar una vez, no vuelve a aparecer.
+     * @default true
+     */
+    showOnce?: boolean;
+}
+interface FormConfig {
+    formId: string;
+    fields: Fields;
+    steps: Steps;
+    initialStep?: string;
+    layout?: FormLayout;
+    /** @deprecated Use submitActions for modular submit configuration */
+    submit?: SubmitConfig;
+    buttons?: FormButtons;
+    submitConfirmation?: SubmitConfirmationConfig;
+    pluginManager?: PluginManager;
+    successMessage?: string | ((values: Record<string, unknown>) => string);
+    errorMessage?: string | ((error: Error, values: Record<string, unknown>) => string);
+    onStepChange?: (step: string) => void;
+    onSuccess?: (values: Record<string, unknown>) => void;
+    onError?: (error: Error, values: Record<string, unknown>) => void;
+    /**
+     * Redirect after successful submission.
+     *
+     * - `string` — static URL (e.g. "/thanks")
+     * - `(values) => string` — dynamic URL based on submitted values
+     *
+     * The redirect executes after onSuccess and plugin hooks.
+     * If set, the success message UI is never shown.
+     */
+    redirect?: string | ((values: Record<string, unknown>) => string);
+    /**
+     * Acciones de submit modulares.
+     * Permite configurar múltiples endpoints, webhooks, emails, etc.
+     * Cada acción tiene su propio trigger (cuándo se ejecuta).
+     */
+    submitActions?: Record<string, SubmitActionNode>;
+    /**
+     * Configuración de ejecución para submitActions.
+     * Define si las acciones se ejecutan en paralelo o secuencial.
+     */
+    submitExecution?: SubmitExecutionConfig;
+}
+
+/**
+ * ============================================
+ * COMPONENT REGISTRY - Dependency Injection System
+ * ============================================
+ *
+ * Este sistema permite que el plugin sea agnóstico de la librería UI.
+ * Los usuarios inyectan sus propios componentes (shadcn, Chakra, Material UI, etc.)
+ */
+interface InputProps extends React__default.InputHTMLAttributes<HTMLInputElement> {
+    className?: string;
+}
+interface TextareaProps extends React__default.TextareaHTMLAttributes<HTMLTextAreaElement> {
+    className?: string;
+}
+interface ButtonProps extends React__default.ButtonHTMLAttributes<HTMLButtonElement> {
+    className?: string;
+    variant?: string;
+    size?: string;
+}
+interface LabelProps extends React__default.LabelHTMLAttributes<HTMLLabelElement> {
+    className?: string;
+}
+interface CheckboxProps {
+    id?: string;
+    checked?: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+    disabled?: boolean;
+    className?: string;
+}
+interface SwitchProps {
+    id?: string;
+    checked?: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+    disabled?: boolean;
+    className?: string;
+}
+interface RadioGroupProps {
+    value?: string;
+    onValueChange?: (value: string) => void;
+    disabled?: boolean;
+    className?: string;
+    children?: React__default.ReactNode;
+}
+interface RadioGroupItemProps {
+    id?: string;
+    value: string;
+    disabled?: boolean;
+    className?: string;
+}
+interface SelectProps {
+    value?: string;
+    onValueChange?: (value: string) => void;
+    disabled?: boolean;
+    children?: React__default.ReactNode;
+}
+interface SelectTriggerProps {
+    className?: string;
+    children?: React__default.ReactNode;
+}
+interface SelectContentProps {
+    className?: string;
+    children?: React__default.ReactNode;
+}
+interface SelectItemProps {
+    value: string;
+    className?: string;
+    children?: React__default.ReactNode;
+}
+interface SelectValueProps {
+    placeholder?: string;
+}
+interface NativeSelectProps extends React__default.SelectHTMLAttributes<HTMLSelectElement> {
+    className?: string;
+}
+interface SliderProps {
+    value?: number[];
+    defaultValue?: number[];
+    onValueChange?: (value: number[]) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+    disabled?: boolean;
+    orientation?: 'horizontal' | 'vertical';
+    className?: string;
+}
+interface PopoverProps {
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    children?: React__default.ReactNode;
+}
+interface PopoverTriggerProps {
+    asChild?: boolean;
+    children?: React__default.ReactNode;
+}
+interface PopoverContentProps {
+    className?: string;
+    align?: 'start' | 'center' | 'end';
+    children?: React__default.ReactNode;
+}
+interface TooltipProps {
+    children?: React__default.ReactNode;
+}
+interface TooltipTriggerProps {
+    asChild?: boolean;
+    children?: React__default.ReactNode;
+}
+interface TooltipContentProps {
+    className?: string;
+    children?: React__default.ReactNode;
+}
+interface TooltipProviderProps {
+    children?: React__default.ReactNode;
+}
+interface SeparatorProps {
+    className?: string;
+    orientation?: 'horizontal' | 'vertical';
+}
+interface DialogProps {
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    children?: React__default.ReactNode;
+}
+interface DialogTriggerProps {
+    asChild?: boolean;
+    children?: React__default.ReactNode;
+}
+interface DialogContentProps {
+    className?: string;
+    children?: React__default.ReactNode;
+}
+interface DialogHeaderProps {
+    className?: string;
+    children?: React__default.ReactNode;
+}
+interface DialogTitleProps {
+    className?: string;
+    children?: React__default.ReactNode;
+}
+interface DialogDescriptionProps {
+    className?: string;
+    children?: React__default.ReactNode;
+}
+interface CommandProps {
+    className?: string;
+    children?: React__default.ReactNode;
+}
+interface CommandInputProps {
+    placeholder?: string;
+    className?: string;
+}
+interface CommandListProps {
+    className?: string;
+    children?: React__default.ReactNode;
+}
+interface CommandEmptyProps {
+    className?: string;
+    children?: React__default.ReactNode;
+}
+interface CommandGroupProps {
+    className?: string;
+    children?: React__default.ReactNode;
+}
+interface CommandItemProps {
+    value: string;
+    onSelect?: (value: string) => void;
+    className?: string;
+    children?: React__default.ReactNode;
+}
+interface InputOTPProps {
+    value?: string;
+    onChange?: (value: string) => void;
+    maxLength?: number;
+    disabled?: boolean;
+    className?: string;
+    containerClassName?: string;
+    children?: React__default.ReactNode;
+}
+interface InputOTPGroupProps {
+    className?: string;
+    children?: React__default.ReactNode;
+}
+interface InputOTPSlotProps {
+    index: number;
+    className?: string;
+}
+interface AccordionProps {
+    type?: 'single' | 'multiple';
+    collapsible?: boolean;
+    value?: string;
+    onValueChange?: (value: string) => void;
+    className?: string;
+    children?: React__default.ReactNode;
+}
+interface AccordionItemProps {
+    value: string;
+    className?: string;
+    children?: React__default.ReactNode;
+}
+interface AccordionTriggerProps {
+    className?: string;
+    children?: React__default.ReactNode;
+}
+interface AccordionContentProps {
+    className?: string;
+    children?: React__default.ReactNode;
+}
+interface CalendarProps {
+    mode?: 'single' | 'range' | 'multiple';
+    selected?: unknown;
+    onSelect?: unknown;
+    className?: string;
+    disabled?: unknown;
+    captionLayout?: string;
+    buttonVariant?: string;
+    numberOfMonths?: number;
+    children?: React__default.ReactNode;
+}
+interface FormFieldProps {
+    name: string;
+    control?: unknown;
+    render: (props: {
+        field: {
+            value: unknown;
+            onChange: (value: unknown) => void;
+            onBlur: () => void;
+            name: string;
+            ref: React__default.Ref<unknown>;
+        };
+        fieldState: {
+            invalid: boolean;
+            isTouched: boolean;
+            isDirty: boolean;
+            isValidating: boolean;
+            error?: {
+                message?: string;
+            };
+        };
+    }) => React__default.ReactElement;
+}
+interface FormControlProps {
+    children?: React__default.ReactNode;
+}
+interface FieldProps {
+    className?: string;
+    children?: React__default.ReactNode;
+    orientation?: 'horizontal' | 'vertical';
+    'data-invalid'?: boolean;
+}
+interface FieldLabelProps {
+    className?: string;
+    children?: React__default.ReactNode;
+    dangerouslySetInnerHTML?: {
+        __html: string;
+    };
+}
+interface FieldDescriptionProps {
+    className?: string;
+    children?: React__default.ReactNode;
+}
+interface FieldErrorProps {
+    className?: string;
+    children?: React__default.ReactNode;
+    errors?: Array<{
+        message?: string;
+    }>;
+}
+/**
+ * Registry de todos los componentes UI necesarios para el plugin.
+ * Los usuarios deben proveer una implementación completa de esta interfaz.
+ */
+interface ComponentRegistry {
+    Input: React__default.ComponentType<InputProps>;
+    Textarea: React__default.ComponentType<TextareaProps>;
+    Button: React__default.ComponentType<ButtonProps>;
+    Label: React__default.ComponentType<LabelProps>;
+    Checkbox: React__default.ComponentType<CheckboxProps>;
+    Switch: React__default.ComponentType<SwitchProps>;
+    RadioGroup: React__default.ComponentType<RadioGroupProps>;
+    RadioGroupItem: React__default.ComponentType<RadioGroupItemProps>;
+    Select: React__default.ComponentType<SelectProps>;
+    SelectTrigger: React__default.ComponentType<SelectTriggerProps>;
+    SelectContent: React__default.ComponentType<SelectContentProps>;
+    SelectItem: React__default.ComponentType<SelectItemProps>;
+    SelectValue: React__default.ComponentType<SelectValueProps>;
+    NativeSelect: React__default.ComponentType<NativeSelectProps>;
+    Slider: React__default.ComponentType<SliderProps>;
+    Popover: React__default.ComponentType<PopoverProps>;
+    PopoverTrigger: React__default.ComponentType<PopoverTriggerProps>;
+    PopoverContent: React__default.ComponentType<PopoverContentProps>;
+    Tooltip: React__default.ComponentType<TooltipProps>;
+    TooltipTrigger: React__default.ComponentType<TooltipTriggerProps>;
+    TooltipContent: React__default.ComponentType<TooltipContentProps>;
+    TooltipProvider: React__default.ComponentType<TooltipProviderProps>;
+    Separator: React__default.ComponentType<SeparatorProps>;
+    Dialog: React__default.ComponentType<DialogProps>;
+    DialogTrigger: React__default.ComponentType<DialogTriggerProps>;
+    DialogContent: React__default.ComponentType<DialogContentProps>;
+    DialogHeader: React__default.ComponentType<DialogHeaderProps>;
+    DialogTitle: React__default.ComponentType<DialogTitleProps>;
+    DialogDescription: React__default.ComponentType<DialogDescriptionProps>;
+    Command: React__default.ComponentType<CommandProps>;
+    CommandInput: React__default.ComponentType<CommandInputProps>;
+    CommandList: React__default.ComponentType<CommandListProps>;
+    CommandEmpty: React__default.ComponentType<CommandEmptyProps>;
+    CommandGroup: React__default.ComponentType<CommandGroupProps>;
+    CommandItem: React__default.ComponentType<CommandItemProps>;
+    InputOTP: React__default.ComponentType<InputOTPProps>;
+    InputOTPGroup: React__default.ComponentType<InputOTPGroupProps>;
+    InputOTPSlot: React__default.ComponentType<InputOTPSlotProps>;
+    Accordion: React__default.ComponentType<AccordionProps>;
+    AccordionItem: React__default.ComponentType<AccordionItemProps>;
+    AccordionTrigger: React__default.ComponentType<AccordionTriggerProps>;
+    AccordionContent: React__default.ComponentType<AccordionContentProps>;
+    Calendar: React__default.ComponentType<CalendarProps>;
+    FormField: React__default.ComponentType<FormFieldProps>;
+    FormControl: React__default.ComponentType<FormControlProps>;
+    Field: React__default.ComponentType<FieldProps>;
+    FieldLabel: React__default.ComponentType<FieldLabelProps>;
+    FieldDescription: React__default.ComponentType<FieldDescriptionProps>;
+    FieldError: React__default.ComponentType<FieldErrorProps>;
+}
+/**
+ * Partial registry para desarrollo incremental.
+ * Permite proveer solo los componentes que se necesitan.
+ */
+type PartialComponentRegistry = Partial<ComponentRegistry>;
+/**
+ * Input type for createComponentRegistry() and Form's components prop.
+ * Uses React.ComponentType<any> for each slot to avoid contravariance issues
+ * when the consumer's components have stricter prop types (e.g. shadcn Button
+ * with specific variant literals vs our generic `variant?: string`).
+ */
+type ComponentRegistryInput = {
+    [K in keyof ComponentRegistry]: React__default.ComponentType<any>;
+};
+/**
+ * Type for the Form component's `components` prop.
+ * More permissive than PartialComponentRegistry to accept any compatible components.
+ * This avoids TypeScript contravariance errors when users pass their own shadcn
+ * components which may have stricter prop types (e.g., specific size/variant literals).
+ */
+type ComponentOverrides = Partial<{
+    [K in keyof ComponentRegistry]: React__default.ComponentType<any>;
+}>;
+/**
+ * Helper type para validar que un objeto implementa ComponentRegistry
+ */
+type ValidateComponentRegistry<T extends ComponentRegistry> = T;
+
+interface ComponentProviderProps {
+    /** Registry completo de componentes UI */
+    components: ComponentRegistry;
+    /** Componentes hijos que tendrán acceso al registry */
+    children: React__default.ReactNode;
+}
+/**
+ * Provider que inyecta los componentes UI en el árbol de React.
+ * This is the legacy provider that requires a full ComponentRegistry.
+ *
+ * @example
+ * ```tsx
+ * import { ComponentProvider, createComponentRegistry } from "@saastro/forms";
+ * import * as shadcn from "@/lib/form-components";
+ *
+ * const registry = createComponentRegistry(shadcn);
+ *
+ * function App() {
+ *   return (
+ *     <ComponentProvider components={registry}>
+ *       <MyForm />
+ *     </ComponentProvider>
+ *   );
+ * }
+ * ```
+ *
+ * @deprecated Consider using the zero-config approach with inline components prop on Form
+ */
+declare const ComponentProvider: React__default.FC<ComponentProviderProps>;
+interface InternalComponentProviderProps {
+    /** Partial registry de componentes UI */
+    components: PartialComponentRegistry;
+    /** Componentes hijos que tendrán acceso al registry */
+    children: React__default.ReactNode;
+}
+/**
+ * Internal provider used by Form component for zero-config mode.
+ * Accepts a partial registry - only the components needed for the form.
+ *
+ * @internal
+ */
+declare const InternalComponentProvider: React__default.FC<InternalComponentProviderProps>;
+/**
+ * Hook para acceder al registry de componentes inyectados.
+ *
+ * Supports both legacy (ComponentProvider) and zero-config (InternalComponentContext) modes.
+ * Legacy mode takes precedence for backwards compatibility.
+ *
+ * @throws Error si se usa fuera de cualquier provider
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { Input, Button } = useComponents();
+ *
+ *   return (
+ *     <div>
+ *       <Input placeholder="Email" />
+ *       <Button>Submit</Button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare const useComponents: () => ComponentRegistry;
+/**
+ * Hook to access partial components safely (may have missing components).
+ * Returns null for components that are not provided.
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const components = usePartialComponents();
+ *
+ *   if (!components.Input) {
+ *     return <MissingComponentFallback missingComponents={['Input']} />;
+ *   }
+ *
+ *   return <components.Input placeholder="Email" />;
+ * }
+ * ```
+ */
+declare const usePartialComponents: () => PartialComponentRegistry;
+/**
+ * HOC para envolver componentes que necesitan acceso a los componentes UI.
+ *
+ * @example
+ * ```tsx
+ * const MyFormWithComponents = withComponents(MyForm);
+ * ```
+ */
+declare function withComponents<P extends object>(Component: React__default.ComponentType<P>): React__default.FC<P>;
+/**
+ * Hook para verificar si estamos dentro de un ComponentProvider.
+ * Útil para componentes que pueden funcionar con o sin provider.
+ *
+ * @returns true si hay un provider activo (legacy or internal), false en caso contrario
+ */
+declare const useHasComponentProvider: () => boolean;
+/**
+ * Hook to check which mode we're operating in
+ */
+declare const useComponentMode: () => "legacy" | "zero-config" | "none";
+/**
+ * Merge multiple component registries with later ones taking precedence
+ */
+declare function mergeComponentRegistries(...registries: Array<PartialComponentRegistry | undefined>): PartialComponentRegistry;
+/**
+ * Type for Vite's import.meta.glob result.
+ * Accepts the actual Vite return type which is Record<string, unknown>.
+ */
+type GlobModules = Record<string, unknown>;
+/**
+ * Parse Vite's import.meta.glob result into a component registry.
+ *
+ * This function extracts all named exports from the glob modules
+ * and creates a flat registry of components.
+ *
+ * @param modules - Result of import.meta.glob('@/components/ui/*.tsx', { eager: true })
+ * @returns Component registry ready to use with Form
+ *
+ * @example
+ * ```tsx
+ * const modules = import.meta.glob('@/components/ui/*.tsx', { eager: true });
+ * const components = parseGlobModules(modules);
+ * // { Button, Input, Label, Select, SelectTrigger, ... }
+ * ```
+ */
+declare function parseGlobModules(modules: GlobModules): PartialComponentRegistry;
+interface FormComponentsProviderProps {
+    /**
+     * Glob modules from import.meta.glob.
+     * Use { eager: true } for synchronous loading.
+     *
+     * @example
+     * ```tsx
+     * <FormComponentsProvider
+     *   components={import.meta.glob('@/components/ui/*.tsx', { eager: true })}
+     * >
+     * ```
+     */
+    components: GlobModules;
+    /** Child components */
+    children: React__default.ReactNode;
+}
+/**
+ * Provider for auto-discovered shadcn components using Vite's import.meta.glob.
+ *
+ * Place this once at your app's root layout. Forms will automatically
+ * use any shadcn components installed in your project.
+ *
+ * @example
+ * ```tsx
+ * // app/layout.tsx or _app.tsx - ONE TIME SETUP
+ * import { FormComponentsProvider } from '@saastro/forms';
+ *
+ * export default function RootLayout({ children }) {
+ *   return (
+ *     <FormComponentsProvider
+ *       components={import.meta.glob('@/components/ui/*.tsx', { eager: true })}
+ *     >
+ *       {children}
+ *     </FormComponentsProvider>
+ *   );
+ * }
+ * ```
+ *
+ * Then use Form anywhere without passing components:
+ * ```tsx
+ * <Form config={config} />
+ * ```
+ *
+ * If a component is missing, a helpful message will appear
+ * with installation instructions.
+ */
+declare const FormComponentsProvider: React__default.FC<FormComponentsProviderProps>;
+
+/**
+ * Form Component - Renders a complete form from FormConfig
+ *
+ * This component is the main entry point for rendering forms from configuration.
+ * Supports two modes:
+ * 1. Zero-config: Provide components inline via `components` prop
+ * 2. Legacy: Wrap with ComponentProvider for global component injection
+ */
+
+/** Methods exposed via ref on the Form component */
+interface FormRef {
+    setValue: UseFormReturn['setValue'];
+    reset: UseFormReturn['reset'];
+    getValues: UseFormReturn['getValues'];
+    trigger: UseFormReturn['trigger'];
+}
+interface FormProps {
+    /** Form configuration */
+    config: FormConfig;
+    /**
+     * UI components for the form. Accepts either:
+     *
+     * 1. **Glob modules (Recommended)** - Pass Vite's import.meta.glob result directly:
+     * ```tsx
+     * <Form
+     *   config={config}
+     *   components={import.meta.glob('@/components/ui/*.tsx', { eager: true })}
+     * />
+     * ```
+     *
+     * 2. **Component object** - Pass individual components:
+     * ```tsx
+     * <Form
+     *   config={config}
+     *   components={{ Input, Button, Label }}
+     * />
+     * ```
+     *
+     * Both approaches support partial registries - only provide what you need.
+     * Missing components will show helpful installation instructions.
+     */
+    components?: ComponentOverrides | GlobModules;
+    /**
+     * Called when the form is submitted successfully
+     */
+    onSubmit?: (values: Record<string, unknown>) => void | Promise<void>;
+    /**
+     * Called when form submission fails
+     */
+    onError?: (error: Error) => void;
+    /**
+     * CSS class for the form element
+     */
+    className?: string;
+}
+/**
+ * Form component that renders a complete form from configuration.
+ *
+ * Supports multiple modes:
+ *
+ * **1. Auto-discovery with glob (Recommended):**
+ * Pass Vite's import.meta.glob result directly - components are auto-discovered.
+ *
+ * ```tsx
+ * import { Form } from "@saastro/forms";
+ *
+ * <Form
+ *   config={config}
+ *   components={import.meta.glob('@/components/ui/*.tsx', { eager: true })}
+ * />
+ * ```
+ *
+ * **2. Explicit components:**
+ * Pass specific components you need.
+ *
+ * ```tsx
+ * import { Form } from "@saastro/forms";
+ * import { Input, Button } from "@/components/ui";
+ *
+ * <Form
+ *   config={config}
+ *   components={{ Input, Button }}
+ * />
+ * ```
+ *
+ * **3. Provider-based (Legacy):**
+ * Wrap with `ComponentProvider` or `FormComponentsProvider`.
+ *
+ * ```tsx
+ * <FormComponentsProvider components={globModules}>
+ *   <Form config={config} />
+ * </FormComponentsProvider>
+ * ```
+ *
+ * The `components` prop takes precedence over context-provided components.
+ */
+declare const Form: React__default.ForwardRefExoticComponent<FormProps & React__default.RefAttributes<FormRef>>;
+
+/**
+ * ============================================
+ * FIELD BUILDER - Fluent API for Field Configuration
+ * ============================================
+ *
+ * Builder pattern para crear configuraciones de campo de forma fluida y type-safe.
+ */
+declare class FieldBuilder {
+    private name;
+    private config;
+    constructor(name: string);
+    /**
+     * Configura el tipo de campo.
+     *
+     * @param type - Tipo de campo
+     * @returns this para encadenamiento
+     */
+    type(type: FieldConfig['type']): this;
+    /**
+     * Configura el label del campo.
+     *
+     * @param label - Texto del label
+     * @returns this para encadenamiento
+     */
+    label(label: string): this;
+    /**
+     * Oculta el label del campo.
+     *
+     * @returns this para encadenamiento
+     */
+    hideLabel(): this;
+    /**
+     * Configura el esquema de validación Zod.
+     *
+     * @param schema - Esquema Zod
+     * @returns this para encadenamiento
+     */
+    schema(schema: z.ZodType): this;
+    /**
+     * Adds plugin-registered validator names to apply to this field.
+     *
+     * @param names - Validator names registered via plugin.validators
+     * @returns this para encadenamiento
+     *
+     * @example
+     * ```tsx
+     * field.type('email').customValidators('uniqueEmail', 'corporateOnly')
+     * ```
+     */
+    customValidators(...names: string[]): this;
+    /**
+     * Configura el placeholder del campo.
+     *
+     * @param placeholder - Texto placeholder
+     * @returns this para encadenamiento
+     */
+    placeholder(placeholder: string): this;
+    /**
+     * Configura el valor inicial del campo.
+     *
+     * @param value - Valor inicial
+     * @returns this para encadenamiento
+     */
+    value(value: unknown): this;
+    /**
+     * Configura el texto de ayuda del campo.
+     *
+     * @param helperText - Texto de ayuda
+     * @returns this para encadenamiento
+     */
+    helperText(helperText: string): this;
+    /**
+     * Configura el tooltip del campo.
+     *
+     * @param tooltip - Texto del tooltip
+     * @returns this para encadenamiento
+     */
+    tooltip(tooltip: string): this;
+    /**
+     * Configura el icono del campo.
+     *
+     * @param icon - Elemento React del icono
+     * @param iconProps - Props adicionales para el icono
+     * @returns this para encadenamiento
+     */
+    icon(icon: ReactNode, iconProps?: Record<string, unknown>): this;
+    /**
+     * Configura el tamaño del campo.
+     *
+     * @param size - Tamaño del campo
+     * @returns this para encadenamiento
+     */
+    size(size: 'sm' | 'md' | 'lg'): this;
+    /**
+     * Configura las opciones del campo (para select, radio, checkbox-group, etc.).
+     *
+     * @param options - Array de opciones
+     * @returns this para encadenamiento
+     */
+    options(options: Option[]): this;
+    /**
+     * Configura las opciones de button-card.
+     *
+     * @param options - Array de opciones de button-card
+     * @returns this para encadenamiento
+     */
+    buttonCardOptions(options: ButtonCardOption[]): this;
+    /**
+     * Configura el número de filas (para textarea).
+     *
+     * @param rows - Número de filas
+     * @returns this para encadenamiento
+     */
+    rows(rows: number): this;
+    /**
+     * Configura el máximo de caracteres (para textarea).
+     *
+     * @param maxLength - Máximo de caracteres
+     * @returns this para encadenamiento
+     */
+    maxLength(maxLength: number): this;
+    /**
+     * Configura el rango del slider.
+     *
+     * @param min - Valor mínimo
+     * @param max - Valor máximo
+     * @param step - Paso del slider
+     * @returns this para encadenamiento
+     */
+    range(min: number, max: number, step?: number): this;
+    /**
+     * Configura la variante del slider.
+     *
+     * @param variant - 'default' (single thumb), 'range' (two thumbs), 'multi' (multiple thumbs)
+     * @returns this para encadenamiento
+     *
+     * @example
+     * .sliderVariant('range') // Two thumbs for min/max selection
+     */
+    sliderVariant(variant: 'default' | 'range' | 'multi'): this;
+    /**
+     * Configura la orientación del slider.
+     *
+     * @param orientation - 'horizontal' o 'vertical'
+     * @returns this para encadenamiento
+     *
+     * @example
+     * .sliderOrientation('vertical')
+     */
+    sliderOrientation(orientation: 'horizontal' | 'vertical'): this;
+    /**
+     * Configura el número de thumbs para slider 'multi'.
+     *
+     * @param count - Número de thumbs (default: 3)
+     * @returns this para encadenamiento
+     *
+     * @example
+     * .thumbCount(4)
+     */
+    thumbCount(count: number): this;
+    /**
+     * Muestra u oculta las etiquetas min/max del slider.
+     *
+     * @param show - true para mostrar, false para ocultar
+     * @returns this para encadenamiento
+     */
+    showLabels(show: boolean): this;
+    /**
+     * Muestra u oculta el valor actual del slider.
+     *
+     * @param show - true para mostrar, false para ocultar
+     * @returns this para encadenamiento
+     */
+    showValue(show: boolean): this;
+    /**
+     * Formato para mostrar el valor del slider.
+     * Usa {value} como placeholder para el valor numérico.
+     *
+     * @param format - String de formato (e.g., "${value}", "{value}%", "{value}°C")
+     * @returns this para encadenamiento
+     *
+     * @example
+     * .valueFormat('${value}')  // Shows "$50"
+     * .valueFormat('{value}%')  // Shows "75%"
+     * .valueFormat('{value}°C') // Shows "22°C"
+     */
+    valueFormat(format: string): this;
+    /**
+     * Configura la condición de visibilidad del campo.
+     *
+     * @param condition - Condición booleana, función, grupo de condiciones, o visibilidad responsive por breakpoint
+     * @returns this para encadenamiento
+     *
+     * @example
+     * // Ocultar siempre
+     * .hidden(true)
+     *
+     * @example
+     * // Ocultar condicionalmente
+     * .hidden((values) => values.premium === false)
+     *
+     * @example
+     * // Ocultar responsive: oculto en mobile, visible en desktop
+     * .hidden({ default: "hidden", md: "visible" })
+     *
+     * @example
+     * // Visible hasta tablet, oculto en desktop
+     * .hidden({ default: "visible", lg: "hidden" })
+     */
+    hidden(condition: boolean | ((values: Record<string, unknown>) => boolean) | Partial<Record<Breakpoint$1, 'visible' | 'hidden'>> | ConditionGroup): this;
+    /**
+     * Configura la condición de deshabilitación del campo.
+     *
+     * @param condition - Condición booleana, función o grupo de condiciones
+     * @returns this para encadenamiento
+     */
+    disabled(condition: boolean | ((values: Record<string, unknown>) => boolean) | ConditionGroup): this;
+    /**
+     * Configura la condición de solo lectura del campo.
+     *
+     * @param condition - Condición booleana, función o grupo de condiciones
+     * @returns this para encadenamiento
+     */
+    readOnly(condition: boolean | ((values: Record<string, unknown>) => boolean) | ConditionGroup): this;
+    /**
+     * Configura el layout del campo.
+     *
+     * @param layout - Configuración de layout
+     * @returns this para encadenamiento
+     */
+    layout(layout: FieldLayoutConfig): this;
+    /**
+     * Configura las columnas del campo por breakpoint.
+     *
+     * Si no se define, el campo ocupará todas las columnas disponibles del formulario.
+     *
+     * @param columns - Objeto con columnas por breakpoint (1-12)
+     *
+     * @example
+     * // Ocupar todo el ancho en mobile, mitad en desktop
+     * .columns({ default: 12, md: 6 })
+     *
+     * @example
+     * // Ocupar todo el ancho siempre
+     * .columns({ default: 12 })
+     *
+     * @example
+     * // Ocupar 1/3 en mobile, 1/2 en tablet, 1/4 en desktop
+     * .columns({ default: 12, sm: 6, md: 4, lg: 3 })
+     *
+     * @returns this para encadenamiento
+     */
+    columns(columns: Partial<Record<Breakpoint$1, number>>): this;
+    /**
+     * Configura el orden del campo.
+     *
+     * @param order - Orden de visualización (número fijo o responsive por breakpoint)
+     * @returns this para encadenamiento
+     *
+     * @example
+     * // Orden fijo
+     * .order(1)
+     *
+     * @example
+     * // Orden responsive: primero en mobile, tercero en desktop
+     * .order({ default: 1, md: 3 })
+     *
+     * @example
+     * // Reordenar según tamaño: último en mobile, primero en desktop
+     * .order({ default: 5, lg: 1 })
+     */
+    order(order: number | Partial<Record<Breakpoint$1, number>>): this;
+    /**
+     * Configura clases CSS personalizadas.
+     *
+     * @param wrapper - Clases para el wrapper
+     * @param input - Clases para el input
+     * @param label - Clases para el label
+     * @param error - Clases para el mensaje de error
+     * @param helper - Clases para el mensaje de ayuda
+     * @returns this para encadenamiento
+     */
+    classNames(options: {
+        wrapper?: string;
+        input?: string;
+        label?: string;
+        error?: string;
+        helper?: string;
+    }): this;
+    /**
+     * Sets value transform(s) applied before submission.
+     * Accepts a single built-in transform name, multiple names (chained left-to-right),
+     * or a custom function.
+     *
+     * @example
+     * .transform('trim')
+     * .transform('trim', 'lowercase')
+     * .transform((v) => String(v).replace(/\s+/g, '-'))
+     */
+    transform(...transforms: (BuiltinTransform | FieldTransformFn)[]): this;
+    /**
+     * Sets the slider minimum value (individual setter; see also `.range()`).
+     */
+    min(value: number): this;
+    /**
+     * Sets the slider maximum value (individual setter; see also `.range()`).
+     */
+    max(value: number): this;
+    /**
+     * Sets the slider step size (individual setter; see also `.range()`).
+     */
+    step(value: number): this;
+    /**
+     * Sets the date picker style.
+     *
+     * @param style - 'simple' (inline calendar) or 'popover' (dropdown calendar)
+     */
+    dateType(style: 'simple' | 'popover'): this;
+    /**
+     * Enables or disables the time picker on date fields.
+     */
+    showTime(show: boolean): this;
+    /**
+     * Sets quick-select date presets.
+     *
+     * @param presets - Array of { label, value } where value is days from today
+     */
+    datePresets(presets: Array<{
+        label: string;
+        value: number;
+    }>): this;
+    /**
+     * Sets the input-group prefix text.
+     */
+    prefix(text: string): this;
+    /**
+     * Sets the input-group suffix text.
+     */
+    suffix(text: string): this;
+    /**
+     * Sets the combobox/command search placeholder.
+     */
+    searchPlaceholder(text: string): this;
+    /**
+     * Sets the combobox/command empty state text.
+     */
+    emptyText(text: string): this;
+    /**
+     * Enables or disables multi-select on button-card fields.
+     */
+    multiple(allow: boolean): this;
+    /**
+     * Sets the OTP digit count.
+     *
+     * @param length - Number of digits (default: 6)
+     */
+    otpLength(length: number): this;
+    /**
+     * Sets the field default value.
+     */
+    defaultValue(value: unknown): this;
+    /**
+     * Sets the field description (metadata, shown as additional text or tooltip).
+     */
+    description(text: string): this;
+    /**
+     * Sets the HTML autocomplete attribute.
+     */
+    autocomplete(attr: string): this;
+    /**
+     * Sets CSS classes for the options grid layout (checkbox-group, button-radio, etc.).
+     */
+    optionsClassName(cls: string): this;
+    /**
+     * Sets the resolver for a hidden field.
+     * Resolvers compute dynamic values (IP, URL params, timestamps, etc.) at form init.
+     *
+     * @param config - Serializable resolver configuration
+     * @returns this for chaining
+     *
+     * @example
+     * field.type('hidden').resolver({ $resolver: 'timestamp' })
+     * field.type('hidden').resolver({ $resolver: 'urlParam', param: 'utm_source', fallback: 'direct' })
+     * field.type('hidden').resolver({ $resolver: 'ip' })
+     */
+    resolver(config: SerializableFieldResolver): this;
+    /**
+     * Sets accepted file types for a file field.
+     *
+     * @param types - MIME types or extensions (e.g. "image/*", ".pdf,.doc")
+     * @returns this for chaining
+     *
+     * @example
+     * field.type('file').accept('image/*')
+     * field.type('file').accept('.pdf,.docx')
+     */
+    accept(types: string): this;
+    /**
+     * Sets maximum file size in bytes for a file field.
+     *
+     * @param bytes - Max size in bytes
+     * @returns this for chaining
+     *
+     * @example
+     * field.type('file').maxSize(5 * 1024 * 1024) // 5MB
+     */
+    maxSize(bytes: number): this;
+    /**
+     * Sets the sub-field definitions for a repeater field.
+     * @example
+     * field.type('repeater').itemFields({ name: { type: 'text', label: 'Name' } })
+     */
+    itemFields(fields: Record<string, unknown>): this;
+    /** Minimum number of items for a repeater field. */
+    minItems(n: number): this;
+    /** Maximum number of items for a repeater field. */
+    maxItems(n: number): this;
+    /** Label for the repeater "add" button. */
+    addLabel(label: string): this;
+    /** Label for the repeater "remove" button. */
+    removeLabel(label: string): this;
+    /**
+     * Ensures `this.config.schema` is a ValidationRules object (not a Zod schema).
+     * If it's already a Zod schema, it's left untouched and a new ValidationRules is created.
+     */
+    private ensureValidationRules;
+    /**
+     * Mark the field as required (validation).
+     */
+    required(message?: string): this;
+    /**
+     * Mark the field as optional (validation).
+     */
+    optional(): this;
+    /**
+     * Set minimum length validation (string fields).
+     */
+    minLength(n: number, message?: string): this;
+    /**
+     * Set maximum length validation (string fields).
+     * Note: This sets validation rules, not the HTML maxLength attribute.
+     * For textarea HTML maxLength, use the existing `.maxLength()` method before calling validation methods.
+     */
+    maxLengthValidation(n: number, message?: string): this;
+    /**
+     * Set email format validation.
+     */
+    email(message?: string): this;
+    /**
+     * Set URL format validation.
+     */
+    url(message?: string): this;
+    /**
+     * Set regex pattern validation.
+     */
+    regex(pattern: string, message?: string): this;
+    /**
+     * Set number range validation.
+     */
+    numberRange(min?: number, max?: number): this;
+    /**
+     * Set array item count validation.
+     */
+    itemCount(min?: number, max?: number): this;
+    /**
+     * Require the boolean field to be true (e.g. terms checkbox).
+     */
+    mustBeTrue(message?: string): this;
+    /**
+     * Apply a named validation preset.
+     */
+    preset(id: string): this;
+    /**
+     * Construye y valida la configuración final del campo.
+     *
+     * @returns FieldConfig completo y validado
+     * @throws Error si falta información requerida
+     */
+    build(): FieldConfig;
+    /**
+     * Construye sin validaciones (útil para desarrollo).
+     *
+     * @returns FieldConfig parcial
+     */
+    buildUnsafe(): Partial<FieldConfig>;
+}
+
+interface DatabowlConfig {
+    /** DataBowl API token (Bearer auth) */
+    token: string;
+    /**
+     * API endpoint. Default: `https://www.databowl.com/api/v4/leads`
+     *
+     * Set to a local proxy route (e.g. `/api/send-lead`) for CORS/security.
+     * The proxy should forward the request to DataBowl.
+     */
+    endpoint?: string;
+    /**
+     * Field mapping — simple rename or advanced with transforms/inject.
+     *
+     * @example
+     * ```ts
+     * // Simple rename
+     * fieldMapping: { nombre: "first_name", telefono: "phone" }
+     *
+     * // Advanced: transform dates, booleans, inject computed fields
+     * fieldMapping: {
+     *   fields: {
+     *     nombre: "first_name",
+     *     fecha_nacimiento: { to: "birth_date", transform: "dateYMD" },
+     *     seguro_enfermedad: { to: "has_insurance", transform: "booleanString" },
+     *   },
+     *   inject: {
+     *     campaign_id: "10653",
+     *     ip: { $resolver: "custom", fn: () => fetchIpAddress() },
+     *     sub_aff_id: { $resolver: "urlParam", param: "sub_aff_id", fallback: "seo_organico" },
+     *     timestamp: { $resolver: "timestamp" },
+     *     hostname: { $resolver: "hostname" },
+     *   },
+     * }
+     * ```
+     */
+    fieldMapping?: FieldMappingConfig;
+    /** Extra static fields to include in every submission */
+    staticFields?: Record<string, unknown>;
+    /**
+     * Body format. Default: `'url-encoded'` (DataBowl standard).
+     * Set to `'json'` if your proxy expects JSON.
+     */
+    bodyFormat?: 'json' | 'url-encoded';
+    /** Action ID (default: "databowl") */
+    actionId?: string;
+    /** Continue form submission if DataBowl fails (default: false) */
+    continueOnError?: boolean;
+}
+/**
+ * Creates a pre-configured HTTP submit action for DataBowl.
+ *
+ * Use this with `.submitAction()` when you need fine-grained control
+ * or want to combine it with other actions.
+ *
+ * @example
+ * ```tsx
+ * FormBuilder.create("lead")
+ *   .addField("nombre", f => f.type("text").label("Nombre"))
+ *   .addStep("main", ["nombre"])
+ *   .submitAction("databowl", databowlAction({
+ *     token: import.meta.env.DATABOWL_TOKEN,
+ *     endpoint: "/api/send-lead-databowl", // proxy
+ *   }), "onSubmit", {
+ *     fieldMapping: { nombre: "first_name" },
+ *   })
+ *   .build();
+ * ```
+ */
+declare function databowlAction(config: Pick<DatabowlConfig, 'token' | 'endpoint' | 'bodyFormat'>): HttpSubmitAction;
+/**
+ * DataBowl plugin for @saastro/forms.
+ *
+ * Automatically injects a DataBowl submit action into the form config.
+ * Handles field mapping (with transforms + inject), static fields, and error tracking.
+ *
+ * @example
+ * ```tsx
+ * // Basic usage with simple rename
+ * const pm = new PluginManager();
+ * pm.register(databowlPlugin({
+ *   token: import.meta.env.DATABOWL_TOKEN,
+ *   fieldMapping: {
+ *     nombre: "first_name",
+ *     email: "email_address",
+ *     telefono: "phone",
+ *   },
+ *   staticFields: {
+ *     source: "landing-energy",
+ *   },
+ * }));
+ *
+ * // Advanced: proxy + transforms + computed fields
+ * pm.register(databowlPlugin({
+ *   token: import.meta.env.DATABOWL_TOKEN,
+ *   endpoint: "/api/send-lead-databowl",
+ *   bodyFormat: "json", // proxy expects JSON, converts to url-encoded
+ *   fieldMapping: {
+ *     fields: {
+ *       nombre: "first_name",
+ *       fecha_nacimiento: { to: "birth_date", transform: "dateYMD" },
+ *       seguro_enfermedad: { to: "has_insurance", transform: "booleanString" },
+ *     },
+ *     inject: {
+ *       campaign_id: "10653",
+ *       sub_aff_id: { $resolver: "urlParam", param: "sub_aff_id", fallback: "seo_organico" },
+ *       timestamp: { $resolver: "timestamp" },
+ *       hostname: { $resolver: "hostname" },
+ *     },
+ *   },
+ * }));
+ *
+ * const form = FormBuilder.create("lead")
+ *   .usePlugins(pm)
+ *   .addField("nombre", f => f.type("text").label("Nombre"))
+ *   .addStep("main", ["nombre"])
+ *   .redirect("/gracias")
+ *   .build();
+ * ```
+ */
+declare const databowlPlugin: (config: DatabowlConfig) => FormPlugin;
+
+/**
+ * ============================================
+ * FORM BUILDER - Fluent API for Form Configuration
+ * ============================================
+ *
+ * Builder pattern para crear configuraciones de formulario de forma fluida y type-safe.
+ */
+declare class FormBuilder {
+    private config;
+    /**
+     * Asegura que el objeto layout existe en la configuración.
+     * @private
+     */
+    private ensureLayout;
+    /**
+     * Asegura que el PluginManager existe en la configuración.
+     * @private
+     */
+    private ensurePluginManager;
+    /**
+     * Valida la configuración de botones.
+     * @private
+     */
+    private validateButtons;
+    /**
+     * Crea una nueva instancia del builder.
+     *
+     * @param formId - ID único del formulario
+     * @returns Nueva instancia de FormBuilder
+     *
+     * @example
+     * ```tsx
+     * const form = FormBuilder.create("registro")
+     *   .layout("manual")
+     *   .columns(4)
+     *   .build();
+     * ```
+     */
+    static create(formId: string): FormBuilder;
+    /**
+     * Configura el modo de layout del formulario.
+     *
+     * @param mode - "auto" (adaptativo) o "manual" (fijo)
+     * @returns this para encadenamiento
+     */
+    layout(mode: 'auto' | 'manual'): this;
+    /**
+     * Configura el gap entre campos.
+     *
+     * @param gap - Valor de gap (1-12), cada unidad = 0.25rem
+     * @returns this para encadenamiento
+     */
+    gap(gap: GapValue): this;
+    /**
+     * Configura el número de columnas del grid.
+     *
+     * - En modo 'manual': crea un grid fijo de N columnas (col-span funciona)
+     * - En modo 'auto': actúa como límite máximo de columnas
+     *
+     * @param columns - Número de columnas (1-12)
+     * @returns this para encadenamiento
+     */
+    columns(columns: ColumnsValue): this;
+    /**
+     * Configura el ancho mínimo de campo (solo para modo "auto").
+     *
+     * @param minWidth - Ancho mínimo en píxeles
+     * @returns this para encadenamiento
+     */
+    minFieldWidth(minWidth: number): this;
+    /**
+     * Agrega clases CSS personalizadas al contenedor del formulario.
+     *
+     * @param className - Clases CSS
+     * @returns this para encadenamiento
+     */
+    layoutClassName(className: string): this;
+    /**
+     * Agrega un campo al formulario usando un builder fluido.
+     *
+     * @param name - Nombre único del campo
+     * @param builder - Función que recibe un FieldBuilder y retorna la configuración
+     * @returns this para encadenamiento
+     *
+     * @example
+     * ```tsx
+     * builder.addField("email", field =>
+     *   field
+     *     .type("email")
+     *     .label("Email")
+     *     .schema(z.string().email())
+     *     .columns({ default: 12, md: 6 })
+     * )
+     * ```
+     */
+    addField(name: string, builder: (field: FieldBuilder) => FieldBuilder): this;
+    /**
+     * Agrega múltiples campos al formulario.
+     *
+     * @param fields - Objeto con campos configurados
+     * @returns this para encadenamiento
+     */
+    addFields(fields: Fields): this;
+    /**
+     * Agrega un step al formulario.
+     *
+     * @param stepId - ID único del step
+     * @param fields - Array de nombres de campos que pertenecen a este step
+     * @param options - Opciones adicionales del step
+     * @returns this para encadenamiento
+     *
+     * @example
+     * ```tsx
+     * builder.addStep("step1", ["email", "password"])
+     * ```
+     */
+    addStep(stepId: string, fields: string[], options?: {
+        defaultNext?: string;
+        next?: StepCondition[];
+    }): this;
+    /**
+     * Configura el step inicial del formulario.
+     *
+     * @param stepId - ID del step inicial
+     * @returns this para encadenamiento
+     */
+    initialStep(stepId: string): this;
+    /**
+     * Configura el callback de éxito.
+     *
+     * @param callback - Función que se ejecuta al enviar exitosamente
+     * @returns this para encadenamiento
+     */
+    onSuccess(callback: (values: Record<string, unknown>) => void): this;
+    /**
+     * Configura el callback de error.
+     *
+     * @param callback - Función que se ejecuta al fallar el envío
+     * @returns this para encadenamiento
+     */
+    onError(callback: (error: Error, values: Record<string, unknown>) => void): this;
+    /**
+     * Configura el callback de cambio de step.
+     *
+     * @param callback - Función que se ejecuta al cambiar de step
+     * @returns this para encadenamiento
+     */
+    onStepChange(callback: (stepId: string) => void): this;
+    /**
+     * Configura el mensaje de éxito.
+     *
+     * @param message - Mensaje estático o función que retorna el mensaje
+     * @returns this para encadenamiento
+     */
+    successMessage(message: string | ((values: Record<string, unknown>) => string)): this;
+    /**
+     * Configura el mensaje de error.
+     *
+     * @param message - Mensaje estático o función que retorna el mensaje
+     * @returns this para encadenamiento
+     */
+    errorMessage(message: string | ((error: Error, values: Record<string, unknown>) => string)): this;
+    /**
+     * Configura los botones del formulario.
+     *
+     * @param buttons - Configuración de botones
+     * @returns this para encadenamiento
+     */
+    buttons(buttons: FormButtons): this;
+    /**
+     * Configura el envío del formulario.
+     *
+     * @param submit - Configuración de envío
+     * @returns this para encadenamiento
+     */
+    submit(submit: SubmitConfig): this;
+    /**
+     * Redirect after successful submission.
+     *
+     * @param url - Static URL string or function that receives values and returns URL
+     * @returns this para encadenamiento
+     *
+     * @example
+     * ```tsx
+     * FormBuilder.create("lead")
+     *   .redirect("/thanks")
+     *   // or dynamic:
+     *   .redirect((values) => `/thanks?email=${values.email}`)
+     * ```
+     */
+    redirect(url: string | ((values: Record<string, unknown>) => string)): this;
+    /**
+     * Configura el gestor de plugins del formulario.
+     *
+     * @param pluginManager - Instancia de PluginManager con plugins registrados
+     * @returns this para encadenamiento
+     *
+     * @example
+     * ```tsx
+     * import { FormBuilder, PluginManager, analyticsPlugin } from "@saastro/forms";
+     *
+     * const pluginManager = new PluginManager();
+     * pluginManager.register(analyticsPlugin());
+     *
+     * const form = FormBuilder.create("my-form")
+     *   .usePlugins(pluginManager)
+     *   .addField("name", f => f.type("text").label("Name"))
+     *   .build();
+     * ```
+     */
+    usePlugins(pluginManager: PluginManager): this;
+    /**
+     * Enable DataBowl lead integration.
+     *
+     * Automatically registers the DataBowl plugin, which injects an HTTP submit
+     * action via `transformConfig` and merges `staticFields` via `transformValues`.
+     * Compatible with other plugins — can be combined with `.usePlugins()`.
+     *
+     * @param config - DataBowl configuration
+     * @returns this for chaining
+     *
+     * @example
+     * ```tsx
+     * FormBuilder.create("lead-energy")
+     *   .addField("nombre", f => f.type("text").label("Nombre"))
+     *   .addField("email", f => f.type("email").label("Email"))
+     *   .addField("telefono", f => f.type("tel").label("Teléfono"))
+     *   .addStep("main", ["nombre", "email", "telefono"])
+     *
+     *   .useDatabowl({
+     *     token: import.meta.env.DATABOWL_TOKEN,
+     *     fieldMapping: {
+     *       nombre: "first_name",
+     *       email: "email_address",
+     *       telefono: "phone",
+     *     },
+     *     staticFields: {
+     *       source: "landing-energy",
+     *       campaign: "google-ads",
+     *     },
+     *   })
+     *
+     *   .redirect("/gracias")
+     *   .build();
+     * ```
+     */
+    useDatabowl(config: DatabowlConfig): this;
+    /**
+     * Configura advertencia de confirmación para campos opcionales.
+     *
+     * Permite mostrar una advertencia cuando el usuario intenta enviar el formulario
+     * (o navegar entre steps) con campos opcionales vacíos. El botón cambia su texto
+     * y variant, requiriendo un segundo click para confirmar.
+     *
+     * @param config - Configuración de confirmación
+     * @returns this para encadenamiento
+     *
+     * @example
+     * ```tsx
+     * FormBuilder.create("registro")
+     *   .addField("email", f => f.type("email").label("Email").schema(z.string().email()))
+     *   .addField("phone", f => f.type("text").label("Teléfono (opcional)"))
+     *   .addStep("main", ["email", "phone"])
+     *
+     *   .submitConfirmation({
+     *     optionalFields: [
+     *       {
+     *         name: "phone",
+     *         message: "Sin teléfono no podremos contactarte para confirmar"
+     *       }
+     *     ],
+     *     buttonBehavior: {
+     *       warningText: "⚠️ Continuar sin teléfono",
+     *       warningVariant: "outline",
+     *       resetDelay: 4000
+     *     },
+     *     applyOn: "submit",
+     *     showOnce: true
+     *   })
+     *
+     *   .buttons({
+     *     submit: { type: "submit", label: "Crear Cuenta" }
+     *   })
+     *   .build();
+     * ```
+     */
+    submitConfirmation(config: SubmitConfirmationConfig): this;
+    /**
+     * Add a modular submit action to the form.
+     *
+     * Submit actions replace the legacy `.submit()` config with a more flexible system
+     * that supports multiple endpoints, webhooks, emails, and custom handlers — each
+     * with its own trigger, condition, and execution order.
+     *
+     * @param id - Unique action identifier
+     * @param action - Action configuration (http, webhook, email, or custom)
+     * @param trigger - When to execute: trigger type string or full SubmitTrigger object
+     * @param options - Optional: condition, order, continueOnError, disabled
+     * @returns this for chaining
+     *
+     * @example
+     * ```tsx
+     * FormBuilder.create("lead")
+     *   .addField("email", f => f.type("email").label("Email"))
+     *   .addField("name", f => f.type("text").label("Name"))
+     *   .addStep("main", ["email", "name"])
+     *
+     *   // HTTP POST to your API
+     *   .submitAction("save-lead", {
+     *     type: "http",
+     *     name: "Save Lead",
+     *     endpoint: { url: "/api/leads", method: "POST" },
+     *     body: { format: "json" },
+     *   }, "onSubmit")
+     *
+     *   // Webhook to external service
+     *   .submitAction("notify-crm", {
+     *     type: "webhook",
+     *     name: "CRM Webhook",
+     *     url: "https://hooks.example.com/lead",
+     *   }, "onSubmit", { continueOnError: true, order: 2 })
+     *
+     *   // Custom handler
+     *   .submitAction("analytics", {
+     *     type: "custom",
+     *     name: "Track Conversion",
+     *     handler: async (values) => { analytics.track("lead", values); },
+     *   }, "onSubmit", { continueOnError: true })
+     *
+     *   // Field mapping: form uses "nombre"/"email", API expects "first_name"/"email_address"
+     *   .submitAction("crm", {
+     *     type: "http",
+     *     name: "CRM Sync",
+     *     endpoint: { url: "https://crm.example.com/api/leads", method: "POST" },
+     *   }, "onSubmit", {
+     *     fieldMapping: { nombre: "first_name", email: "email_address" },
+     *   })
+     *
+     *   .submitExecution({ mode: "sequential", stopOnFirstError: true })
+     *   .build();
+     * ```
+     */
+    submitAction(id: string, action: SubmitAction, trigger: SubmitTriggerType | SubmitTrigger, options?: {
+        condition?: SubmitActionCondition;
+        order?: number;
+        continueOnError?: boolean;
+        disabled?: boolean;
+        /** Map form field names to API-expected field names (simple or advanced) */
+        fieldMapping?: FieldMappingConfig;
+    }): this;
+    /**
+     * Configure how multiple submit actions are executed.
+     *
+     * @param config - Execution configuration
+     * @returns this for chaining
+     *
+     * @example
+     * ```tsx
+     * builder
+     *   .submitAction("primary", { ... }, "onSubmit")
+     *   .submitAction("secondary", { ... }, "onSubmit", { continueOnError: true })
+     *   .submitExecution({ mode: "sequential", stopOnFirstError: true })
+     * ```
+     */
+    submitExecution(config: SubmitExecutionConfig): this;
+    /**
+     * Construye y valida la configuración final del formulario.
+     *
+     * @returns FormConfig completo y validado
+     * @throws Error si falta información requerida
+     */
+    build(): FormConfig;
+    /**
+     * Construye sin validaciones (útil para desarrollo).
+     *
+     * @returns FormConfig parcial
+     */
+    buildUnsafe(): Partial<FormConfig>;
+}
+
+/**
+ * ============================================
+ * FIELD BUILDER REGISTRY MAP
+ * ============================================
+ *
+ * Single source of truth that keeps FieldBuilder methods, the TSX code generator,
+ * and the docs in sync. A contract test verifies all three stay aligned.
+ *
+ * When `method` is omitted in a PropertyMapping, it defaults to `prop` (the common case).
+ * Entries where prop ≠ method are the historic bug sources (e.g. presets → datePresets).
+ */
+type SerializationHint = 'string' | 'number' | 'boolean' | 'json';
+type PropertyMapping = {
+    /** The config property name on the FieldConfig object */
+    prop: string;
+    /** The FieldBuilder method name. Defaults to `prop` if omitted. */
+    method?: string;
+    /** How to serialize the value in generated code */
+    serialize: SerializationHint;
+};
+/**
+ * Maps field types to their type-specific config properties and the
+ * corresponding FieldBuilder methods. Used by the TSX generator to
+ * emit the correct method calls.
+ */
+declare const TYPE_SPECIFIC_PROPERTIES: Record<string, PropertyMapping[]>;
+/**
+ * Field types that accept an `.options()` array.
+ * The generator emits `.options(...)` for these when options exist.
+ */
+declare const OPTION_BASED_TYPES: string[];
+/**
+ * Methods available on all field types (common configuration).
+ */
+declare const COMMON_METHODS: string[];
+/**
+ * Declarative validation methods (produce ValidationRules).
+ */
+declare const VALIDATION_METHODS: string[];
+/**
+ * Build methods (terminal operations).
+ */
+declare const BUILD_METHODS: string[];
+/**
+ * Returns the union of all known FieldBuilder method names across all categories.
+ * Used by the contract test to verify FieldBuilder ↔ Map completeness.
+ *
+ * Includes: common, type-specific, validation, build methods,
+ * plus composite helpers like `range()` that set multiple props.
+ */
+declare function getAllKnownMethods(): string[];
+
+/**
+ * Plugin para persistir el estado del formulario en localStorage.
+ *
+ * Uses `transformConfig` to restore saved values as field defaults,
+ * `onFieldChange` to persist progress, and `onAfterSubmit` to clean up.
+ *
+ * @example
+ * ```tsx
+ * const pluginManager = new PluginManager();
+ * pluginManager.register(localStoragePlugin);
+ *
+ * const config = FormBuilder.create('contact')
+ *   .addField('name', f => f.type('text').label('Name'))
+ *   .pluginManager(pluginManager)
+ *   .build();
+ *
+ * // On page reload, field values are automatically restored.
+ * ```
+ */
+declare const localStoragePlugin: FormPlugin;
+
+/**
+ * Plugin para tracking de analytics (Google Analytics, Mixpanel, etc.).
+ *
+ * @param options - Opciones de configuración
+ * @returns Plugin configurado
+ *
+ * @example
+ * ```tsx
+ * const pluginManager = new PluginManager();
+ * pluginManager.register(analyticsPlugin());
+ * ```
+ */
+declare const analyticsPlugin: FormPlugin;
+
+/**
+ * Plugin para guardado automático periódico.
+ *
+ * @param options - Opciones de configuración
+ * @returns Plugin configurado
+ *
+ * @example
+ * ```tsx
+ * const pluginManager = new PluginManager();
+ * pluginManager.register(autosavePlugin({ interval: 30000 })); // 30 segundos
+ * ```
+ */
+declare const autosavePlugin: (options?: {
+    interval?: number;
+    endpoint?: string;
+}) => FormPlugin;
+
+/**
+ * ============================================
+ * RECAPTCHA PLUGIN - Google reCAPTCHA v3
+ * ============================================
+ *
+ * Injects the reCAPTCHA v3 script and attaches a fresh token
+ * to every submission via `transformValues`.
+ */
+interface RecaptchaPluginConfig {
+    /** reCAPTCHA v3 site key */
+    siteKey: string;
+    /** Action name sent to Google (default: 'submit') */
+    action?: string;
+    /** Field name for the token in submitted values (default: '_recaptchaToken') */
+    tokenField?: string;
+}
+declare global {
+    interface Window {
+        grecaptcha?: {
+            ready: (cb: () => void) => void;
+            execute: (siteKey: string, options: {
+                action: string;
+            }) => Promise<string>;
+        };
+    }
+}
+/**
+ * Google reCAPTCHA v3 plugin.
+ *
+ * - `onFormInit`: Injects the reCAPTCHA script into `<body>` (once, deduped)
+ * - `transformValues`: Fetches a fresh token and adds it to the submitted values
+ * - `cleanup`: Removes the injected script
+ *
+ * @example
+ * ```tsx
+ * import { recaptchaPlugin, PluginManager, FormBuilder } from '@saastro/forms';
+ *
+ * const pm = new PluginManager();
+ * pm.register(recaptchaPlugin({ siteKey: 'your-site-key' }));
+ *
+ * const config = FormBuilder.create('contact')
+ *   .usePlugins(pm)
+ *   .addField('email', (f) => f.type('email').label('Email').required().email())
+ *   .addStep('main', ['email'])
+ *   .build();
+ * ```
+ */
+declare function recaptchaPlugin(config: RecaptchaPluginConfig): FormPlugin;
+
+/**
+ * ============================================
+ * SHADCN/UI PRESET - Component Registry
+ * ============================================
+ *
+ * Preset predefinido para usar con shadcn/ui.
+ * Los usuarios pueden importar este preset y usarlo directamente,
+ * o crear su propio mapeo personalizado.
+ */
+
+/**
+ * Crea un registry de componentes UI a partir de un objeto con los componentes importados.
+ * Genérico — funciona con shadcn/ui, saastro, o cualquier set de componentes compatibles.
+ *
+ * @param components - Objeto con todos los componentes UI importados
+ * @returns ComponentRegistry completo listo para usar con ComponentProvider
+ *
+ * @example
+ * ```tsx
+ * import { ComponentProvider, createComponentRegistry } from "@saastro/forms";
+ * import * as uiComponents from "@/lib/form-components-shadcn";
+ *
+ * const registry = createComponentRegistry(uiComponents);
+ *
+ * function App() {
+ *   return (
+ *     <ComponentProvider components={registry}>
+ *       <MyForm />
+ *     </ComponentProvider>
+ *   );
+ * }
+ * ```
+ */
+declare function createComponentRegistry(components: ComponentRegistryInput): ComponentRegistry;
+/** @deprecated Use createComponentRegistry instead */
+declare const createShadcnRegistry: typeof createComponentRegistry;
+
+/**
+ * Props for MissingComponentFallback
+ */
+interface MissingComponentFallbackProps {
+    /** Name of the field that requires the missing component */
+    fieldName: string;
+    /** Type of the field (e.g., 'text', 'select', 'date') */
+    fieldType: string;
+    /** List of missing component names */
+    missingComponents: string[];
+    /** Optional custom message */
+    message?: string;
+    /** Optional className for layout (e.g., column span classes) */
+    className?: string;
+}
+/**
+ * Fallback component displayed when required UI components are missing.
+ * Shows a helpful warning with installation instructions.
+ *
+ * @example
+ * ```tsx
+ * <MissingComponentFallback
+ *   fieldName="birthdate"
+ *   fieldType="date"
+ *   missingComponents={['Calendar', 'Popover']}
+ * />
+ * ```
+ */
+declare function MissingComponentFallback({ fieldName, fieldType, missingComponents, message, className, }: MissingComponentFallbackProps): React__default.ReactElement;
+/**
+ * Creates a placeholder component that renders the MissingComponentFallback
+ * Can be used as a drop-in replacement for missing components
+ */
+declare function createMissingComponentPlaceholder(componentName: string, fieldType: string): React__default.FC<{
+    name?: string;
+}>;
+
+/**
+ * ============================================
+ * FIELD TYPE COMPONENTS - Mapping System
+ * ============================================
+ *
+ * Maps field types to their required UI components.
+ * Used for auto-discovery to determine which components need to be loaded.
+ */
+
+/**
+ * Type for the component registry keys
+ */
+type ComponentName = keyof ComponentRegistry;
+/**
+ * Mapping of field type → required components
+ * Each field type lists all the UI components it needs to render properly
+ */
+declare const fieldTypeComponents: Record<string, ComponentName[]>;
+/**
+ * Core components that are always needed for any form
+ */
+declare const coreComponents: ComponentName[];
+/**
+ * Get all required components for a form configuration
+ *
+ * @param config - The form configuration
+ * @returns Array of unique component names needed for this form
+ *
+ * @example
+ * ```ts
+ * const config = FormBuilder.create('contact')
+ *   .addField('name', f => f.type('text'))
+ *   .addField('email', f => f.type('email'))
+ *   .build();
+ *
+ * const needed = getRequiredComponents(config);
+ * // ['Input', 'Label', 'Button', 'Field', 'FieldLabel', 'FieldDescription', 'FieldError', 'FormField', 'FormControl']
+ * ```
+ */
+declare function getRequiredComponents(config: FormConfig): ComponentName[];
+/**
+ * Get missing components by comparing required vs provided
+ *
+ * @param required - Components needed for the form
+ * @param provided - Components available in the registry
+ * @returns Array of missing component names
+ */
+declare function getMissingComponents(required: ComponentName[], provided: Partial<Record<ComponentName, unknown>>): ComponentName[];
+/**
+ * Group missing components by their source package
+ * Useful for generating install commands
+ */
+declare function groupMissingByPackage(missing: ComponentName[]): Record<string, ComponentName[]>;
+/**
+ * Generate a shell command to install missing components
+ */
+declare function getInstallCommand(missing: ComponentName[]): string;
+
+/**
+ * ============================================
+ * COMPONENT RESOLVER - Auto-discovery System
+ * ============================================
+ *
+ * Automatically resolves UI components from the user's project.
+ * Detects shadcn/ui installation and loads components dynamically.
+ *
+ * Features:
+ * - Zero config for shadcn/ui projects
+ * - Caches resolved components
+ * - Graceful fallback for missing components
+ * - Works with custom component paths
+ */
+
+/**
+ * Configuration for component resolution
+ */
+interface ComponentResolverConfig {
+    /** Base path for UI components (e.g., "@/components/ui") */
+    uiPath?: string;
+    /** Custom component importers for non-standard setups */
+    importers?: Record<string, () => Promise<React__default.ComponentType<any>>>;
+}
+/**
+ * Result of component resolution
+ */
+interface ResolvedComponents {
+    /** Successfully resolved components */
+    components: PartialComponentRegistry;
+    /** Components that failed to load */
+    missing: string[];
+}
+/**
+ * ComponentResolver - Handles auto-discovery and caching of UI components
+ */
+declare class ComponentResolver {
+    private cache;
+    private uiPath;
+    private importers;
+    private resolvePromises;
+    constructor(config?: ComponentResolverConfig);
+    /**
+     * Get or create the singleton resolver instance
+     */
+    static getInstance(config?: ComponentResolverConfig): ComponentResolver;
+    /**
+     * Reset the singleton (useful for testing)
+     */
+    static reset(): void;
+    /**
+     * Configure the resolver's UI path
+     */
+    setUiPath(path: string): void;
+    /**
+     * Get the current UI path
+     */
+    getUiPath(): string;
+    /**
+     * Register custom importers for specific components
+     */
+    registerImporter(name: string, importer: () => Promise<React__default.ComponentType<any>>): void;
+    /**
+     * Check if a component is cached
+     */
+    isCached(name: string): boolean;
+    /**
+     * Get a cached component (returns null if not cached or missing)
+     */
+    getCached(name: string): React__default.ComponentType<any> | null;
+    /**
+     * Pre-cache components (useful for SSR or avoiding loading states)
+     */
+    preCache(components: PartialComponentRegistry): void;
+    /**
+     * Resolve a single component by name
+     * Returns null if the component cannot be loaded
+     */
+    resolve(name: keyof ComponentRegistry): Promise<React__default.ComponentType<any> | null>;
+    /**
+     * Internal resolution logic
+     */
+    private doResolve;
+    /**
+     * Resolve multiple components at once
+     * Returns an object with resolved components and a list of missing ones
+     */
+    resolveMany(names: Array<keyof ComponentRegistry>): Promise<ResolvedComponents>;
+    /**
+     * Clear the component cache
+     */
+    clearCache(): void;
+}
+/**
+ * Get the singleton ComponentResolver instance
+ */
+declare function getComponentResolver(config?: ComponentResolverConfig): ComponentResolver;
+/**
+ * Pre-configure components synchronously (for use in providers)
+ * This bypasses dynamic imports by accepting already-imported components
+ */
+declare function configureComponents(components: PartialComponentRegistry): void;
+
+interface StepsAccordionProps {
+    steps: Steps;
+    currentStepId: string;
+    stepHistory: string[];
+    fields: Fields;
+    onStepSelect?: (stepId: string) => void;
+    allowNavigation?: boolean;
+    className?: string;
+    showFieldCount?: boolean;
+    showErrors?: boolean;
+    showProgress?: boolean;
+}
+declare function StepsAccordion({ steps, currentStepId, stepHistory, fields, onStepSelect, allowNavigation, className, showFieldCount, showErrors, showProgress, }: StepsAccordionProps): react_jsx_runtime.JSX.Element;
+
+interface StepsNavigationProps {
+    steps: Steps;
+    currentStepId: string;
+    stepHistory: string[];
+    fields: Fields;
+    onStepClick?: (stepId: string) => void;
+    className?: string;
+    orientation?: 'horizontal' | 'vertical';
+    showLabels?: boolean;
+    showFieldCount?: boolean;
+    allowNavigation?: boolean;
+}
+declare function StepsNavigation({ steps, currentStepId, stepHistory, fields, onStepClick, className, orientation, showLabels, showFieldCount, allowNavigation, }: StepsNavigationProps): react_jsx_runtime.JSX.Element;
+
+interface StepsProgressProps {
+    steps: Steps;
+    currentStepId: string;
+    stepHistory: string[];
+    fields: Fields;
+    className?: string;
+    showLabels?: boolean;
+    showPercentage?: boolean;
+    variant?: 'bar' | 'dots' | 'steps';
+}
+declare function StepsProgress({ steps, currentStepId, stepHistory, fields, className, showLabels, showPercentage, variant, }: StepsProgressProps): react_jsx_runtime.JSX.Element;
+
+interface Props {
+    /** React-Hook-Form control */
+    control: Control<Record<string, unknown>>;
+    /** Field name (path) */
+    name: string;
+    fieldConfig: FieldConfig;
+    /** Clase CSS opcional para el Field */
+    colSpanItem?: string;
+    /** Plugin manager for custom field types */
+    pluginManager?: PluginManager;
+}
+declare const FieldRenderer: React__default.NamedExoticComponent<Props>;
+
+/**
+ * ============================================
+ * CONSTANTS - Magic numbers and strings
+ * ============================================
+ *
+ * Constantes extraídas para mejorar mantenibilidad
+ */
+/**
+ * Valores por defecto para campos de formulario
+ */
+declare const FIELD_DEFAULTS: {
+    /** Valor por defecto para slider min */
+    readonly SLIDER_MIN: 0;
+    /** Valor por defecto para slider max */
+    readonly SLIDER_MAX: 100;
+    /** Valor por defecto para slider step */
+    readonly SLIDER_STEP: 1;
+    /** Valor por defecto para slider defaultValue */
+    readonly SLIDER_DEFAULT_VALUE: number[];
+    /** Longitud por defecto para OTP */
+    readonly OTP_DEFAULT_LENGTH: 6;
+};
+/**
+ * Clases CSS comunes para componentes
+ */
+declare const COMMON_CLASSES: {
+    /** Clase para width completo */
+    readonly FULL_WIDTH: "w-full";
+    /** Clase para gap entre elementos */
+    readonly GAP_4: "gap-4";
+    /** Clase para padding right cuando hay icono */
+    readonly ICON_PADDING: "pr-10";
+    /** Clase para items center */
+    readonly ITEMS_CENTER: "items-center";
+    /** Clase para flex */
+    readonly FLEX: "flex";
+    /** Clase para space-x-2 */
+    readonly SPACE_X_2: "space-x-2";
+};
+/**
+ * Mensajes y strings comunes
+ */
+declare const COMMON_STRINGS: {
+    /** Placeholder por defecto para daterange */
+    readonly DATERANGE_PLACEHOLDER: "Select date range";
+    /** Texto por defecto cuando no hay opciones en command */
+    readonly COMMAND_EMPTY: "No option found.";
+    /** Placeholder por defecto para búsqueda en command */
+    readonly COMMAND_SEARCH_PLACEHOLDER: "Search...";
+};
+/**
+ * Configuraciones de loading/suspense
+ */
+declare const SUSPENSE_CONFIG: {
+    /** Fallback para date picker */
+    readonly DATE_FALLBACK: "h-10 w-full animate-pulse rounded-md bg-muted";
+};
+
+declare function useFormLayout(layout?: FormLayout): {
+    gridClassName: string;
+    gridStyle: React$1.CSSProperties;
+};
+
+declare function useFormState({ config: rawConfig, fields: rawFields, steps: rawSteps, }: {
+    config: FormConfig;
+    fields: Fields;
+    steps?: Steps;
+}): {
+    currentStepId: string;
+    loading: boolean;
+    submitted: boolean;
+    error: Error | null;
+    methods: react_hook_form.UseFormReturn<{
+        [x: string]: any;
+    }, unknown, {
+        [x: string]: any;
+    }>;
+    nextStep: (values: Record<string, unknown>) => boolean;
+    prevStep: () => boolean;
+    handleSubmit: (data: Record<string, unknown>) => Promise<void>;
+    validateAndNext: (e?: React.MouseEvent) => Promise<void>;
+    isLast: boolean;
+    getSuccessMessage: () => string;
+    getErrorMessage: () => string;
+    resetError: () => void;
+    stepHistory: string[];
+};
+
+type StepStatus = 'pending' | 'current' | 'completed' | 'error';
+interface StepInfo {
+    id: string;
+    fields: string[];
+    fieldCount: number;
+    status: StepStatus;
+    hasErrors: boolean;
+    errorCount: number;
+    isVisited: boolean;
+    isCurrent: boolean;
+    isCompleted: boolean;
+    canNavigate: boolean;
+}
+interface FormStepsInfo {
+    steps: StepInfo[];
+    currentStepId: string;
+    totalSteps: number;
+    completedSteps: number;
+    progress: number;
+    stepHistory: string[];
+    canGoNext: boolean;
+    canGoPrev: boolean;
+    getStepInfo: (stepId: string) => StepInfo | undefined;
+    getStepStatus: (stepId: string) => StepStatus;
+}
+/**
+ * Hook que expone información completa sobre los pasos del formulario
+ * para construir componentes de UI como acordeones, barras de progreso, etc.
+ */
+declare function useFormStepsInfo({ steps, currentStepId, stepHistory, fields, }: {
+    steps: Steps;
+    currentStepId: string;
+    stepHistory: string[];
+    fields: Fields;
+}): FormStepsInfo;
+
+/**
+ * @deprecated Use `recaptchaPlugin()` instead. This hook only injects the script —
+ * the plugin also handles token generation via `transformValues`.
+ *
+ * ```tsx
+ * // Before (hook — only injects script, token must be handled manually):
+ * useRecaptcha(config);
+ *
+ * // After (plugin — injects script AND adds token to submitted values):
+ * import { recaptchaPlugin } from '@saastro/forms';
+ * pm.register(recaptchaPlugin({ siteKey: '...' }));
+ * ```
+ */
+declare function useRecaptcha(config: FormConfig): void;
+
+/**
+ * Props override para el botón durante advertencia
+ */
+interface ButtonOverrideProps {
+    text?: string;
+    variant?: ButtonConfig['variant'];
+    effect?: ButtonConfig['effect'];
+}
+/**
+ * Resultado del hook useSubmitConfirmation
+ */
+interface UseSubmitConfirmationReturn {
+    /** Hay campos opcionales vacíos que requieren confirmación? */
+    needsConfirmation: boolean;
+    /** Esperando segundo click para confirmar? */
+    isAwaitingConfirmation: boolean;
+    /** Campos vacíos detectados */
+    warningFields: string[];
+    /** Props para override del botón (text, variant, effect) */
+    buttonProps: ButtonOverrideProps;
+    /** Handler del click que intercepta y gestiona la confirmación */
+    handleClick: (e: React.MouseEvent<HTMLButtonElement>) => void;
+    /** Reset manual del estado de confirmación */
+    resetConfirmation: () => void;
+}
+/**
+ * Hook para manejar confirmación condicional de submit/navegación.
+ *
+ * Detecta si hay campos opcionales vacíos configurados y requiere
+ * doble click para confirmar (primera vez muestra advertencia cambiando
+ * el botón, segunda vez procede con la acción).
+ *
+ * @param config - Configuración del formulario
+ * @param currentValues - Valores actuales del formulario (de methods.watch())
+ * @param onProceed - Callback a ejecutar cuando se confirma o no hay advertencia
+ * @param buttonType - Tipo de botón: "submit" o "next" (para aplicar según applyOn)
+ * @returns Objeto con estado y handlers para gestionar la confirmación
+ *
+ * @example
+ * ```tsx
+ * const submitConfirmation = useSubmitConfirmation(
+ *   config,
+ *   methods.watch(),
+ *   () => methods.handleSubmit(onFormSubmit)(),
+ *   "submit"
+ * );
+ *
+ * <ButtonPro
+ *   onClick={submitConfirmation.handleClick}
+ *   variant={submitConfirmation.isAwaitingConfirmation
+ *     ? submitConfirmation.buttonProps.variant
+ *     : "default"}
+ * >
+ *   {submitConfirmation.isAwaitingConfirmation
+ *     ? submitConfirmation.buttonProps.text
+ *     : "Submit"}
+ * </ButtonPro>
+ * ```
+ */
+declare function useSubmitConfirmation(config: FormConfig, currentValues: Record<string, unknown>, onProceed: () => void, buttonType?: 'submit' | 'next'): UseSubmitConfirmationReturn;
+
+/**
+ * useSubmitActionTriggers
+ *
+ * Hook que maneja la ejecución automática de submit actions
+ * basada en diferentes triggers (step change, field change, delay).
+ */
+
+interface UseSubmitActionTriggersOptions {
+    /** Configuración del formulario */
+    config: FormConfig;
+    /** Función para obtener los valores actuales (evita re-renders por valores) */
+    getValues: () => Record<string, unknown>;
+    /** Step actual */
+    currentStep: string;
+    /** Callback cuando se ejecuta una acción */
+    onActionExecuted?: (result: SubmitActionsResult) => void;
+    /** Callback cuando hay un error */
+    onActionError?: (error: Error, actionName: string) => void;
+    /** Si los triggers están habilitados */
+    enabled?: boolean;
+}
+interface UseSubmitActionTriggersReturn {
+    /** Ejecutar acciones para un cambio de campo específico */
+    triggerFieldChange: (fieldName: string, value: unknown) => void;
+    /** Ejecutar acciones para blur de un campo */
+    triggerFieldBlur: (fieldName: string) => void;
+    /** Ejecutar acciones manuales */
+    triggerManual: (actionIds?: string[]) => Promise<SubmitActionsResult>;
+    /** Verificar si hay acciones para un trigger específico */
+    hasActionsForTrigger: (triggerType: 'onSubmit' | 'onStepEnter' | 'onStepExit' | 'onFieldChange' | 'onFieldBlur' | 'onDelay' | 'manual', triggerValue?: string) => boolean;
+}
+declare function useSubmitActionTriggers({ config, getValues, currentStep, onActionExecuted, onActionError, enabled, }: UseSubmitActionTriggersOptions): UseSubmitActionTriggersReturn;
+
+/**
+ * Resolves hidden field values at form init.
+ * Filters fields with type 'hidden', runs their resolvers,
+ * and sets the values via react-hook-form's setValue.
+ */
+declare function useHiddenFieldResolvers(methods: UseFormReturn<Record<string, unknown>>, fields: Fields): void;
+
+/**
+ * useComputedFields
+ *
+ * Watches dependency fields and reactively updates computed field values.
+ * Only runs when at least one field has a `computed` config.
+ */
+declare function useComputedFields(methods: UseFormReturn<Record<string, unknown>>, fields: Fields): void;
+
+/**
+ * Check if a schema value is a Zod schema instance.
+ * Zod schemas have a `_def` property on their prototype.
+ */
+declare function isZodSchema(schema: unknown): schema is z.ZodType;
+/**
+ * Check if a schema value is a plain ValidationRules object (serializable JSON).
+ */
+declare function isValidationRules(schema: unknown): schema is ValidationRules;
+
+/**
+ * Compile a serializable `ValidationRules` object into a Zod schema.
+ *
+ * @param rules - The declarative validation rules
+ * @param fieldType - The field type (used to determine the base Zod type)
+ * @returns A Zod schema ready for use with react-hook-form
+ */
+declare function compileValidationRules(rules: ValidationRules, fieldType: string): z.ZodTypeAny;
+
+type ValidationPresetMeta = {
+    id: string;
+    label: string;
+    description: string;
+    category: 'string' | 'number' | 'array' | 'boolean' | 'date';
+    rules: ValidationRules;
+};
+/**
+ * Resolve a preset ID to its ValidationRules.
+ * Returns `undefined` if the preset doesn't exist.
+ */
+declare function resolvePreset(id: string): ValidationRules | undefined;
+/**
+ * Register a custom validation preset at runtime.
+ */
+declare function registerPreset(preset: ValidationPresetMeta): void;
+/**
+ * Get all available presets (built-in + registered).
+ */
+declare function getAvailablePresets(): ValidationPresetMeta[];
+
+declare function defaultSubmit({ values, config, }: {
+    values: Record<string, unknown>;
+    config: FormConfig;
+}): Promise<void>;
+
+/**
+ * Field Mapping Utility
+ *
+ * Transforms form values before sending to an API endpoint.
+ * Supports field renaming, value transforms, computed field injection,
+ * field exclusion, and passthrough control.
+ *
+ * Two formats:
+ * 1. Simple: Record<string, string> — rename fields only (backward compatible)
+ * 2. Advanced: FieldMapping — rename, transform, inject, exclude
+ */
+
+/**
+ * Checks whether a mapping config is the advanced FieldMapping format
+ * (vs the simple Record<string, string> format).
+ */
+declare function isAdvancedMapping(mapping: FieldMappingConfig): mapping is FieldMapping;
+/** Applies a built-in transform to a value. */
+declare function applyBuiltinTransform(value: unknown, transform: BuiltinTransform): unknown;
+/** Applies a transform (built-in or custom function) to a value. */
+declare function applyTransform(value: unknown, transform: BuiltinTransform | FieldTransformFn): unknown;
+/** Resolves a dynamic field value from a FieldResolver (async — supports IP fetch). */
+declare function resolveValue(resolver: FieldResolver): Promise<unknown>;
+/**
+ * Synchronous resolver — returns instant values for sync resolvers,
+ * placeholders for async ones (ip, custom). Used by debug panel dry-runs.
+ */
+declare function resolveValueSync(resolver: FieldResolver): unknown;
+/**
+ * Applies field mapping configuration to form values.
+ *
+ * Supports two formats:
+ * 1. Simple: `Record<string, string>` — rename fields, unmapped pass through
+ * 2. Advanced: `FieldMapping` — rename, transform, inject, exclude, passthrough control
+ *
+ * @param values - Raw form values
+ * @param mapping - Field mapping configuration
+ * @returns Transformed values ready for the API
+ *
+ * @example
+ * ```ts
+ * // Simple rename
+ * applyFieldMapping({ nombre: "Ana" }, { nombre: "first_name" });
+ * // → { first_name: "Ana" }
+ *
+ * // Advanced: transform + inject
+ * applyFieldMapping({ fecha: new Date("2000-01-15"), acepta: true }, {
+ *   fields: {
+ *     fecha: { to: "birth_date", transform: "dateYMD" },
+ *     acepta: { to: "accepts", transform: "booleanString" },
+ *   },
+ *   inject: {
+ *     campaign: "10653",
+ *     timestamp: { $resolver: "timestamp" },
+ *   },
+ * });
+ * // → { birth_date: "2000-01-15", accepts: "true", campaign: "10653", timestamp: "2026-..." }
+ * ```
+ */
+declare function applyFieldMapping(values: Record<string, unknown>, mapping: FieldMappingConfig): Promise<Record<string, unknown>>;
+/**
+ * Synchronous version of applyFieldMapping — uses resolveValueSync for inject resolvers.
+ * Suitable for debug panel dry-runs where async is not practical.
+ */
+declare function applyFieldMappingSync(values: Record<string, unknown>, mapping: FieldMappingConfig): Record<string, unknown>;
+/**
+ * Applies field-level transforms to form values.
+ * Iterates over all fields in the config and applies their `transform` property.
+ * Returns a new object with transformed values (does not mutate input).
+ *
+ * @param fields - Form field configurations (from config.fields)
+ * @param values - Raw form values from react-hook-form
+ * @returns New object with field-level transforms applied
+ */
+declare function applyFieldTransforms(fields: Record<string, any>, values: Record<string, unknown>): Record<string, unknown>;
+
+/**
+ * Submit Action Executors
+ *
+ * Ejecutores individuales para cada tipo de acción de submit.
+ * Cada ejecutor maneja la lógica específica de su tipo.
+ */
+
+declare function executeHttpAction(action: HttpSubmitAction, values: Record<string, unknown>): Promise<unknown>;
+declare function executeWebhookAction(action: WebhookSubmitAction, values: Record<string, unknown>): Promise<unknown>;
+declare function executeEmailAction(action: EmailSubmitAction, values: Record<string, unknown>): Promise<unknown>;
+declare function executeCustomAction(action: CustomSubmitAction, values: Record<string, unknown>): Promise<unknown>;
+declare function executeSubmitAction(action: SubmitAction, values: Record<string, unknown>): Promise<unknown>;
+
+/**
+ * Submit Orchestrator
+ *
+ * Orquesta la ejecución de múltiples submit actions,
+ * manejando ejecución secuencial o paralela, condiciones, y errores.
+ */
+
+declare function getActionsByTrigger(config: FormConfig, triggerType: SubmitTriggerType, triggerValue?: string): SubmitActionNode[];
+/**
+ * Obtiene el delay mínimo para acciones con trigger onDelay
+ */
+declare function getMinDelayMs(config: FormConfig): number;
+/**
+ * Ejecuta múltiples acciones de submit según la configuración
+ */
+declare function executeSubmitActions(actions: SubmitActionNode[], values: Record<string, unknown>, config: FormConfig): Promise<SubmitActionsResult>;
+/**
+ * Ejecuta todas las acciones de submit del formulario filtradas por trigger
+ */
+declare function executeSubmitActionsByTrigger(config: FormConfig, triggerType: SubmitTriggerType, values: Record<string, unknown>, triggerValue?: string): Promise<SubmitActionsResult>;
+
+/**
+ * Test Data Generator — generates realistic field values for form testing.
+ *
+ * Lightweight, no external dependencies (no faker.js).
+ * Two layers of intelligence:
+ *   1. Field type → appropriate format (email, date, select option, etc.)
+ *   2. Label/name heuristics → contextual data ("nombre" → "Carlos", "email" → "test@example.com")
+ */
+
+type TestDataLocale = 'en' | 'es';
+interface TestDataOptions {
+    /** Force a specific locale instead of auto-detecting */
+    locale?: TestDataLocale;
+    /** Seed for deterministic pseudo-random (optional) */
+    seed?: number;
+}
+declare function detectLocale(fields: Fields): TestDataLocale;
+declare function generateFieldValue(name: string, config: FieldConfig, options?: TestDataOptions & {
+    rng?: () => number;
+}): unknown;
+declare function generateTestData(fields: Fields, options?: TestDataOptions): Record<string, unknown>;
+
+type Breakpoint = 'default' | 'sm' | 'md' | 'lg' | 'xl' | '2xl';
+/**
+ * Convierte píxeles a rem (asumiendo base 16px)
+ */
+declare function pxToRem(px: number): number;
+/**
+ * Genera las clases CSS para el grid del formulario
+ */
+declare function getFormGridClass(layout?: {
+    mode?: 'manual' | 'auto';
+    columns?: number;
+    gap?: number;
+    minFieldWidth?: number;
+}): {
+    className: string;
+    style: React__default.CSSProperties;
+};
+/**
+ * Genera las clases CSS para un campo individual
+ */
+declare function getFieldClass(formLayout?: {
+    mode?: 'manual' | 'auto';
+    columns?: number;
+}, fieldLayout?: {
+    columns?: Partial<Record<Breakpoint, number>>;
+    order?: number | Partial<Record<Breakpoint, number>>;
+}): string;
+/**
+ * Genera clases de hidden responsive
+ */
+declare function getHiddenClasses(hidden?: Partial<Record<Breakpoint, 'visible' | 'hidden'>>): string;
+
+export { type AccordionContentProps, type AccordionItemProps, type AccordionProps, type AccordionTriggerProps, BUILD_METHODS, BUILTIN_RESOLVERS, type BaseFieldProps, type Breakpoint$1 as Breakpoint, type BuiltinTransform, type ButtonCardFieldProps, type ButtonCardOption, type ButtonCheckboxFieldProps, type ButtonConfig, type ButtonProps, type ButtonRadioFieldProps, COMMON_CLASSES, COMMON_METHODS, COMMON_STRINGS, type CalendarProps, type CheckboxFieldProps, type CheckboxGroupFieldProps, type CheckboxProps, type ColumnsValue, type ComboboxFieldProps, type CommandEmptyProps, type CommandFieldProps, type CommandGroupProps, type CommandInputProps, type CommandItemProps, type CommandListProps, type CommandProps, type ComponentName, type ComponentOverrides, ComponentProvider, type ComponentProviderProps, type ComponentRegistry, type ComponentRegistryInput, ComponentResolver, type ComponentResolverConfig, type Condition, type ConditionGroup, type ConditionOperator, type CurrencyFieldProps, type CustomSubmitAction, type CustomSubmitConfig, type DatabowlConfig, type DateFieldProps, type DateRangeFieldProps, type DefaultSubmitConfig, type DefinePlugin, type DialogContentProps, type DialogDescriptionProps, type DialogHeaderProps, type DialogProps, type DialogTitleProps, type DialogTriggerProps, type EmailProvider, type EmailSubmitAction, type EndpointConfig, FIELD_DEFAULTS, FieldBuilder, type FieldConfig, type FieldDescriptionProps, type FieldErrorProps, type FieldLabelProps, type FieldLayoutConfig, type FieldMapEntry, type FieldMapping, type FieldMappingConfig, type FieldProps, FieldRenderer, type FieldResolver, type FieldTransformFn, type Fields, type FileFieldProps, Form, FormBuilder, type FormButtonProps, type FormButtons, FormComponentsProvider, type FormComponentsProviderProps, type FormConfig, type FormControlProps, type FormFieldProps, type FormLayout, type FormPlugin, type FormProps, type FormRef, type FormStepsInfo, type GapValue, type GlobModules, type HiddenFieldProps, type HtmlFieldProps, type HttpAuthConfig, type HttpBodyConfig, type HttpEndpointConfig, type HttpRetryConfig, type HttpSubmitAction, type InputGroupFieldProps, type InputOTPGroupProps, type InputOTPProps, type InputOTPSlotProps, type InputProps, type InputSize, InternalComponentProvider, type InternalComponentProviderProps, type LabelProps, MissingComponentFallback, type MissingComponentFallbackProps, type NativeSelectFieldProps, type NativeSelectProps, OPTION_BASED_TYPES, type Option, type OtpFieldProps, type PartialComponentRegistry, PluginManager, type PopoverContentProps, type PopoverProps, type PopoverTriggerProps, type PropertyMapping, type RadioFieldProps, type RadioGroupItemProps, type RadioGroupProps, type RangeFieldProps, type RecaptchaConfig, type RecaptchaPluginConfig, type RepeaterFieldProps, type ResolvedComponents, SUSPENSE_CONFIG, type SchemaType, type SelectContentProps, type SelectFieldProps, type SelectItemProps, type SelectProps, type SelectTriggerProps, type SelectValueProps, type SeparatorProps, type SerializableFieldResolver, type SerializationHint, type SliderFieldProps, type SliderProps, type Step, type StepCondition, type StepInfo, type StepStatus, type Steps, StepsAccordion, StepsNavigation, StepsProgress, type SubmitAction, type SubmitActionCondition, type SubmitActionNode, type SubmitActionResult, type SubmitActionType, type SubmitActionsResult, type SubmitConfig, type SubmitConfirmationConfig, type SubmitExecutionConfig, type SubmitTrigger, type SubmitTriggerType, type SubmitType, type SwitchFieldProps, type SwitchGroupFieldProps, type SwitchProps, TYPE_SPECIFIC_PROPERTIES, type TestDataLocale, type TestDataOptions, type TextFieldProps, type TextareaFieldProps, type TextareaProps, type TooltipContentProps, type TooltipProps, type TooltipProviderProps, type TooltipTriggerProps, type UseSubmitConfirmationReturn, VALIDATION_METHODS, type ValidateComponentRegistry, type ValidationContext, type ValidationPresetMeta, type ValidationRules, type WebhookSubmitAction, analyticsPlugin, applyBuiltinTransform, applyFieldMapping, applyFieldMappingSync, applyFieldTransforms, applyTransform, autosavePlugin, compileValidationRules, configureComponents, coreComponents, createComponentRegistry, createMissingComponentPlaceholder, createShadcnRegistry, databowlAction, databowlPlugin, defaultSubmit, definePlugin, detectLocale, executeCustomAction, executeEmailAction, executeHttpAction, executeSubmitAction, executeSubmitActions, executeSubmitActionsByTrigger, executeWebhookAction, fieldTypeComponents, generateFieldValue, generateTestData, getActionsByTrigger, getAllKnownMethods, getAvailablePresets, getComponentResolver, getFieldClass, getFormGridClass, getHiddenClasses, getInstallCommand, getMinDelayMs, getMissingComponents, getRequiredComponents, globalPluginManager, groupMissingByPackage, iconVariants, iconVariantsConfig, inputVariants, inputVariantsConfig, isAdvancedMapping, isValidationRules, isZodSchema, localStoragePlugin, mergeComponentRegistries, parseGlobModules, pxToRem, recaptchaPlugin, registerPreset, resolvePreset, resolveValue, resolveValueSync, textareaVariants, textareaVariantsConfig, useComponentMode, useComponents, useComputedFields, useFormLayout, useFormState, useFormStepsInfo, useHasComponentProvider, useHiddenFieldResolvers, usePartialComponents, useRecaptcha, useSubmitActionTriggers, useSubmitConfirmation, withComponents };