@timeax/form-palette 0.0.3 → 0.0.5

package/dist/index.d.ts

@@ -0,0 +1,3744 @@
+import * as React from 'react';
+import React__default, { RefObject, ComponentType } from 'react';
+import { z } from 'zod';
+import { Method, AdapterResult, AdapterKey, AdapterSubmit } from './adapters.js';
+export { AdapterCallbacks, AdapterConfig, AdapterError, AdapterFactory, AdapterOk, Adapters, NamedAdapterConfig, NamedAdapterFactory, createAxiosAdapter, createInertiaAdapter, getAdapter, hasAdapter, localAdapter, registerAdapter, registerAxiosAdapter, registerInertiaAdapter, registerKnownAdapter } from './adapters.js';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { DayPicker } from 'react-day-picker';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+import * as SwitchPrimitive from '@radix-ui/react-switch';
+import * as RadioGroupPrimitive from '@radix-ui/react-radio-group';
+import { $ZodError } from 'zod/v4/core';
+import 'axios';
+import './../../../../node_modules/@inertiajs/core/types/types.d';
+
+/**
+ * Imperative handle for a submit button registered with the core.
+ *
+ * This mirrors the legacy `ButtonRef` interface, but is aligned with the
+ * current CoreProvider implementation:
+ *
+ * - The core will try `setLoading(v)` / `setDisabled(v)` if available.
+ * - Otherwise, it will fall back to setting `loading` / `disabled` props.
+ */
+interface ButtonRef {
+    /**
+     * Logical name of the button.
+     *
+     * Used by the core runtime to track the "active" button
+     * and to map behaviours to a specific action.
+     */
+    name: string;
+    /**
+     * Loading flag. The core may read or assign this directly if
+     * no setter is provided.
+     */
+    loading?: boolean;
+    /**
+     * Disabled flag. The core may read or assign this directly if
+     * no setter is provided.
+     */
+    disabled?: boolean;
+    /**
+     * Optional setter used by the core to toggle loading.
+     */
+    setLoading?(v: boolean): void;
+    /**
+     * Optional setter used by the core to toggle disabled state.
+     */
+    setDisabled?(v: boolean): void;
+}
+/**
+ * Runtime representation of a single field registered with the core.
+ *
+ * This is a direct, type-safe evolution of the legacy `Field` interface
+ * from the old `types.ts`, updated to match the new core + binder flow.
+ */
+interface Field {
+    /**
+     * Primary field name, used in values, error bags, and schema mapping.
+     *
+     * May be omitted for purely bound/virtual fields that participate in
+     * binder flows but are not directly part of the value bag.
+     */
+    name?: string;
+    /**
+     * Internal binding identifier.
+     *
+     * Used by "bound" helpers (observe-bound-field, wait-for-bound-field)
+     * to locate shared/aliased fields without going through the name.
+     */
+    bindId?: string;
+    /**
+     * Optional explicit binding identifier.
+     * Use to bind to a specific field in a nested object that has bindId
+     */
+    bind?: string;
+    /**
+     * Ref to the underlying DOM element used for focus/scroll operations.
+     *
+     * Implementations typically point this at the outer wrapper of the field.
+     */
+    ref?: RefObject<HTMLElement> | null;
+    /**
+     * Whether this field is required.
+     *
+     * Variant-level and schema-level validation may use this.
+     */
+    required?: boolean;
+    /**
+     * Current error message for the field.
+     *
+     * Undefined or empty string means "no error".
+     */
+    error?: string;
+    /**
+     * Current value of the field, as seen by the core runtime.
+     *
+     * For formatted inputs, this may be the formatted representation.
+     */
+    value?: unknown;
+    /**
+     * Initial/default value for the field.
+     *
+     * This is typically the "un-touched" value coming from props or
+     * from a persisted value bag.
+     */
+    defaultValue?: unknown;
+    /**
+     * Original, unformatted value as first seen by the core.
+     *
+     * This allows callers to compare "what changed" relative to the
+     * original snapshot, independent of any display formatting.
+     */
+    originalValue?: unknown;
+    /**
+     * Whether this field is currently performing an async operation
+     * (e.g. remote validation).
+     */
+    loading?: boolean;
+    /**
+     * Optional group identifier used to group related fields together
+     * (e.g. radio groups, segmented inputs).
+     */
+    groupId?: string;
+    /**
+     * Optional alias for this field.
+     *
+     * Aliases allow mapping server error bags or schema keys that do
+     * not strictly match the `name` property.
+     */
+    alias?: string;
+    /**
+     * Marks this field as the "main" one in a group.
+     *
+     * Used by some variants/layouts to determine which field drives
+     * overall group state.
+     */
+    main?: boolean;
+    /**
+     * If true, this field will be ignored when building values or
+     * running certain validation flows.
+     */
+    ignore?: boolean;
+    /**
+     * Stable unique key (distinct from `name` and `bindId`).
+     *
+     * Used internally by registries and React lists.
+     */
+    key?: string;
+    /**
+     * Shared key for fields that share their value (e.g. custom views
+     * over the same underlying data).
+     *
+     * This is used by the core when building nested objects, e.g.:
+     *   shared = "profile", name = "first_name"
+     *   ⇒ values.profile.first_name
+     */
+    shared?: string;
+    /**
+     * Run validation for this field.
+     *
+     * @param report If true, the field should update its own error state;
+     *               if false, it may simply return whether it is valid.
+     * @returns `true` if the field is currently valid, `false` otherwise.
+     */
+    validate?(report?: boolean): boolean;
+    /**
+     * Optional hook used by the core or higher-level utilities to retrieve
+     * the current value of the field.
+     *
+     * If omitted, the core will fall back to the `value` property.
+     */
+    getValue?(): unknown;
+    /**
+     * Optional hook used by the core or higher-level utilities to update
+     * the current value of the field.
+     *
+     * If omitted, the core will fall back to mutating the `value` property.
+     */
+    setValue?(value: unknown): void;
+    /**
+     * Optional hook used by the core to reset the field back to its
+     * default/original value.
+     */
+    reset?(): void;
+    /**
+     * Optional hook used by the core to set or clear the field error.
+     *
+     * If omitted, the core will fall back to assigning the `error` property.
+     */
+    setError?(message?: string): void;
+    /**
+     * Optional hook called whenever the field value changes.
+     *
+     * Used by binder utilities to propagate changes across bound fields.
+     *
+     * @param value   New value.
+     * @param old     Previous value.
+     * @param source  Source tag responsible for the change
+     *                (e.g. "variant", "util", "paste", "programmatic").
+     */
+    onChange?(value: unknown, old: unknown, source: string): void;
+}
+
+/**
+ * Minimal surface needed for bound helpers.
+ *
+ * CoreContext already satisfies this, and FieldRegistry can be made to
+ * satisfy it as well (via getBind).
+ */
+interface BindHost<V extends Dict = Dict> {
+    getBind(id: string): Field | undefined;
+    controlButton?(): void;
+}
+
+/**
+ * BinderRegistry: bound-field utilities for a given host (CoreContext or FieldRegistry).
+ *
+ * - Hosts must satisfy BindHost (getBind + optional controlButton).
+ * - FieldRegistry already does (via getBind() we added).
+ * - CoreContext also does.
+ *
+ * You typically access this via:
+ *   form.inputs.binding  // where inputs is a FieldRegistry
+ */
+declare class BinderRegistry<V extends Dict = Dict> {
+    private readonly host;
+    constructor(host: BindHost<V>);
+    /** Raw field access. */
+    get(bindId: string): Field | undefined;
+    has(bindId: string): boolean;
+    /** Read current value. */
+    value<T = unknown>(bindId: string): T | undefined;
+    /** Set value (and trigger controlButton / onChange). */
+    set<T = unknown>(bindId: string, value: T, variant?: string): boolean;
+    /** Set error message on the bound field. */
+    error(bindId: string, msg: string): boolean;
+    /** Run the field’s own validate(). */
+    validate(bindId: string, report?: boolean): boolean;
+    /** Observe a bound field’s value/error and liveness. */
+    observe<T = unknown>(bindId: string, handler: (evt: {
+        exists: boolean;
+        field?: Field;
+        value?: T;
+        error?: string;
+    }) => void, pollMs?: number): () => void;
+    /** Wait for a bound field to appear. */
+    wait(bindId: string, timeoutMs?: number): Promise<Field>;
+}
+
+/**
+ * Central store for all fields registered with the core runtime.
+ *
+ * Responsibilities:
+ * - Keep a stable list of Field instances (no duplicates).
+ * - Only track fields that have at least one identifier:
+ *   - name (non-empty, trimmed)
+ *   - bindId
+ *   - groupId
+ * - Provide convenient lookup methods:
+ *   - all / getAllNamed / getAllBound / getAllGrouped
+ *   - getByName / getAllByName
+ *   - getByGroupId / getAllByGroupId
+ *   - getByBind / getAllByBind (binder semantics, prefer mounted)
+ */
+declare class FieldRegistry {
+    #private;
+    private list;
+    /**
+     * Whether this field should be tracked at all.
+     *
+     * We require at least one of: name, bindId, groupId.
+     */
+    hasIdentifier(field: Field): boolean;
+    /**
+     * Add a field to the registry if it has an identifier.
+     * Duplicate instances are ignored.
+     */
+    add(field: Field): void;
+    /**
+     * Remove a field from the registry.
+     */
+    remove(field: Field): void;
+    /**
+     * Clear all tracked fields.
+     */
+    clear(): void;
+    /**
+     * All fields tracked by this registry.
+     */
+    all(): Field[];
+    /** All fields that have a non-empty name. */
+    getAllNamed(): Field[];
+    /** All fields that have a bindId. */
+    getAllBound(): Field[];
+    /** All fields that have a groupId. */
+    getAllGrouped(): Field[];
+    /**
+     * First field with a given name (exact, trimmed match).
+     *
+     * Note: expects the raw name used by the field, e.g.:
+     *   "email"  or  "tags[]"
+     */
+    getByName(name: string): Field | undefined;
+    /**
+     * All fields with a given name (exact, trimmed match).
+     */
+    getAllByName(name: string): Field[];
+    /** First field with the given groupId. */
+    getByGroupId(id: string): Field | undefined;
+    /** All fields with the given groupId. */
+    getAllByGroupId(id: string): Field[];
+    /**
+     * All fields that share the given bindId.
+     */
+    getAllByBind(id: string): Field[];
+    /**
+     * First field with the given bindId.
+     *
+     * Behaviour:
+     * - Prefer a field whose ref is currently in the DOM.
+     * - If none are mounted, fall back to the first matching field.
+     */
+    getByBind(id: string): Field | undefined;
+    getBind(id: string): Field | undefined;
+    get binding(): BinderRegistry;
+}
+
+/**
+ * Generic dictionary type used throughout the core.
+ *
+ * This matches the legacy Dict<T> from the old types.ts.
+ */
+type Dict<T = unknown> = Record<string, T>;
+/**
+ * If a Zod schema is present, infer the values from that schema;
+ * otherwise use the fallback V type. Ensured to be a Dict so it
+ * can safely be used as CoreContext's generic argument.
+ */
+type InferFromSchema<S, V extends Dict> = S extends z.ZodType ? z.infer<S> & Dict : V;
+/**
+ * Event object passed to onSubmit, matching the legacy SubmitEvent
+ * but kept transport-agnostic. The host decides how route/method/xhr
+ * are interpreted and which adapter is used.
+ *
+ * @template TValues Shape of the outbound data for this submit event.
+ */
+type SubmitEvent<TValues extends Dict> = {
+    /**
+     * Prevent the default submit behavior.
+     *
+     * In practice this prevents the core from continuing with its
+     * normal submit/prepare flow.
+     */
+    preventDefault(): void;
+    /**
+     * Mutate the outbound data just before it is used.
+     *
+     * The callback may return a new data object or mutate in-place.
+     */
+    editData(cb: (data: TValues) => TValues | void): void;
+    /**
+     * Override the route/URL for this submission only.
+     *
+     * The core itself does not enforce any semantics here; the host
+     * is expected to interpret this when wiring submissions.
+     */
+    setRoute(route: string): void;
+    /**
+     * Override the HTTP method for this submission only.
+     */
+    setMethod(method: Method): void;
+    /**
+     * The button that triggered this submit, if any.
+     */
+    button?: ButtonRef;
+    /**
+     * The current outbound data snapshot (after any internal merges).
+     */
+    readonly formData: TValues;
+    /**
+     * The core context associated with this submit event.
+     */
+    form: CoreContext<TValues>;
+    /**
+     * If set to false, the core will abort the submit flow after
+     * this handler returns.
+     */
+    continue: boolean;
+};
+/**
+ * Shared base props for the core runtime, matching the spirit of
+ * the legacy BaseProps, but transport-agnostic.
+ *
+ * @template V Shape of the underlying value map (pre-schema).
+ * @template S Optional Zod schema type.
+ */
+type BaseProps$7<V extends Dict, S extends z.ZodType | undefined> = {
+    /**
+     * Field names that should be ignored when building diffs or snapshots.
+     * Useful for excluding secrets like passwords from logs.
+     */
+    exceptions?: string[];
+    /**
+     * Whether the core should persist values to the provided valueBag.
+     */
+    persist?: boolean;
+    /**
+     * Optional logical name for the core instance.
+     */
+    name?: string;
+    /**
+     * If true, a button may be automatically marked as "active" when
+     * certain changes occur.
+     */
+    activateButtonOnChange?: boolean;
+    /**
+     * Called whenever a field changes.
+     *
+     * current is the field that changed; options carries any
+     * variant-specific metadata.
+     */
+    onChange?(form: CoreContext<InferFromSchema<S, V>>, current: Field, options: Dict): void;
+    /**
+     * Called when the overall values snapshot is considered "updated".
+     */
+    onUpdate?(values: InferFromSchema<S, V>): void;
+    /**
+     * If true, onChange may run before certain internal updates.
+     */
+    changeBefore?: boolean;
+    /**
+     * Optional ref to the core context instance, for imperative access.
+     */
+    formRef?: React__default.MutableRefObject<CoreContext<InferFromSchema<S, V>> | null>;
+    /**
+     * Initial value bag for hydration / persistence.
+     */
+    valueBag?: InferFromSchema<S, V>;
+    /**
+     * Optional hook used to transform a single value as it is being
+     * persisted or fed into the core.
+     */
+    valueFeed?: <K extends keyof InferFromSchema<S, V>>(name: K, value: InferFromSchema<S, V>[K], form: CoreContext<InferFromSchema<S, V>>) => InferFromSchema<S, V>[K] | undefined;
+    /**
+     * Called at the end of certain flows (legacy "finish" hook).
+     *
+     * Receives the core context so you can read values, errors, etc.
+     */
+    onFinish?(form: CoreContext<InferFromSchema<S, V>>): void;
+    /**
+     * Called after the core initializes.
+     */
+    init?(form: CoreContext<InferFromSchema<S, V>>): void;
+    /**
+     * Intercepts the submit event before the core proceeds.
+     *
+     * You can:
+     * - mutate data,
+     * - change route/method/xhr flags,
+     * - abort by setting e.continue = false.
+     */
+    onSubmit?<T extends Dict = InferFromSchema<S, V>>(e: SubmitEvent<T>): Promise<void> | void;
+    /**
+     * Optional Zod schema used for validation and value inference.
+     */
+    schema?: S;
+};
+/**
+ * Public core props, adapter-centric.
+ *
+ * - The library defines a built-in 'local' adapter flavour.
+ *   AdapterSubmit<'local'> is `{ data: unknown }`.
+ * - Hosts can extend the Adapters interface (schema/adapter.ts) to add
+ *   their own adapter flavours (axios, inertia, etc.) and then use
+ *   those keys here.
+ *
+ * @template V Shape of the underlying value map (pre-schema).
+ * @template S Optional Zod schema type.
+ * @template K Adapter key; defaults to 'local'.
+ */
+interface CoreProps<V extends Dict, S extends z.ZodType | undefined, K extends AdapterKey = "local"> extends BaseProps$7<V, S> {
+    /**
+     * Which adapter flavour this core instance should use.
+     *
+     * - 'local' (default) → library-defined local submission (no URL/method semantics).
+     * - extended keys      → host-defined adapters via Adapters augmentation.
+     */
+    adapter?: K;
+    /**
+     * Called after a submission completes. The payload type is derived from
+     * the selected adapter key via the adapter registry:
+     *
+     *   AdapterSubmit<'local'> → { data: unknown }
+     *   AdapterSubmit<'axios'> → host-defined type, etc.
+     */
+    onSubmitted?(form: CoreContext<InferFromSchema<S, V>>, payload: AdapterSubmit<K>, resolve?: () => void): void | Promise<void>;
+}
+/**
+ * Backwards-compatible alias for legacy naming, if you want it.
+ */
+type FormProps<V extends Dict, S extends z.ZodType | undefined, K extends AdapterKey = "local"> = CoreProps<V, S, K>;
+/**
+ * Result of a submit operation: values + validity flag.
+ */
+type ValuesResult<V extends Dict> = {
+    values: V;
+    valid: boolean;
+};
+/**
+ * Query API for fields, similar to DOM helpers but scoped
+ * to the current form instance.
+ *
+ * "id" here refers to the field's groupId.
+ */
+interface InputStore {
+    /** All registered inputs (with at least one identifier). */
+    all(): Field[];
+    /** All inputs that have a non-empty name. */
+    getAllNamed(): Field[];
+    /** All inputs that have a bindId. */
+    getAllBound(): Field[];
+    /** All inputs that have a groupId. */
+    getAllGrouped(): Field[];
+    /** First field matching an exact name. */
+    getByName(name: string): Field | undefined;
+    /** All fields matching an exact name. */
+    getAllByName(name: string): Field[];
+    /** First field with this groupId. */
+    getById(id: string): Field | undefined;
+    /** All fields with this groupId. */
+    getAllById(id: string): Field[];
+    /** First bound field with this bindId (prefers mounted fields). */
+    getByBind(id: string): Field | undefined;
+    /** All fields that share this bindId. */
+    getAllByBind(id: string): Field[];
+}
+/**
+ * Core runtime context, renamed from the legacy FormContext.
+ *
+ * @template V Shape of the values object produced by this core instance.
+ */
+interface CoreContext<V extends Dict> {
+    /**
+     * Compute the current values snapshot from registered fields.
+     */
+    values(): V;
+    /**
+     * Run validation and return the values + validity flag.
+     */
+    submit(): ValuesResult<V>;
+    /**
+     * Lookup a field by its binding id.
+     */
+    getBind(id: string): Field | undefined;
+    /**
+     * Run validation across fields.
+     *
+     * @param report If true, fields should update their own error states.
+     * @returns true if all fields are valid, false otherwise.
+     */
+    validate(report?: boolean): boolean;
+    /**
+     * Register a new field with the core.
+     */
+    addField(field: Field): void;
+    /**
+     * Generic internal bucket for arbitrary metadata.
+     */
+    bucket: Dict;
+    /**
+     * Set a single field error or map an error bag.
+     */
+    error(name: string, msg: string): void;
+    error(bag: Record<string, string>): void;
+    /**
+     * Re-run button control logic (which button is active/disabled etc.).
+     */
+    controlButton(): void;
+    /**
+     * Prepare an adapter-backed request.
+     *
+     * This mirrors the legacy prepare method:
+     * - Builds a payload from values + extra.
+     * - May run validation / beforeSubmit hooks.
+     * - Returns an adapter result or undefined if aborted.
+     *
+     * The concrete adapter wiring is the host's responsibility.
+     */
+    prepare(type: Method, route: string, extra?: Partial<V>, ignoreForm?: boolean, autoErr?: boolean): Promise<AdapterResult<any> | undefined>;
+    /**
+     * Persist values to a provided data object, optionally transforming
+     * values via the feed function.
+     */
+    persist(data: Partial<V>, feed?: (name: string, value: unknown, original: unknown) => unknown): void;
+    /**
+     * Imperatively set a single value by field name.
+     */
+    setValue(name: string, value: unknown): void;
+    /**
+     * Kick off a submit flow using optional extra data.
+     */
+    go(data?: Partial<V>, ignoreForm?: boolean): void;
+    /**
+     * Reset specific inputs by name.
+     */
+    reset(inputs: string[]): void;
+    /**
+     * Register the current active button.
+     */
+    set button(v: ButtonRef);
+    /**
+     * Force a submit regardless of validation state.
+     */
+    forceSubmit(): Promise<void>;
+    /**
+     * All registered fields.
+     */
+    readonly fields: Field[];
+    /**
+     * Effective core props at runtime, excluding internal-only fields.
+     *
+     * Note: the adapter key parameter is erased here (set to any) because
+     * the runtime does not need the specific key for structural typing;
+     * hosts can still use more precise generics at the component level.
+     */
+    readonly props: Omit<CoreProps<V, z.ZodType | undefined, any>, "formRef" | "valueBag">;
+    /**
+     * Mark a button as active by name.
+     */
+    setActiveButton(name: string): void;
+    /**
+     * Return uncaught messages (errors that could not be mapped to a field).
+     *
+     * Typically used by an error strip component.
+     */
+    getUncaught(): readonly string[];
+    /**
+     * Field-query "DOM" for this form.
+     *
+     * Example:
+     *   const email = form.inputs.getByName("email");
+     *   const phoneFields = form.inputs.getAllById("phone-group");
+     *   const bound = form.inputs.getByBind("shipping");
+     */
+    inputs: Omit<FieldRegistry, "add" | "remove">;
+    /**
+     * Checks if the form values have changed
+     */
+    isDirty(): boolean;
+}
+
+/**
+ * Size hint for field variants.
+ *
+ * Presets can interpret these however they like (font size, padding, etc.).
+ */
+type FieldSize = "sm" | "md" | "lg";
+/**
+ * Density hint for field variants.
+ *
+ * - "compact"     → tight vertical spacing
+ * - "comfortable" → default spacing
+ * - "loose"       → extra breathing room
+ */
+type FieldDensity = "compact" | "comfortable" | "loose";
+/**
+ * Logical source of a change event.
+ *
+ * Variants and utilities can tag changes to help the host reason
+ * about where a value came from.
+ */
+type ChangeSource = "variant" | "paste" | "programmatic" | "util" | (string & {});
+/**
+ * Additional context passed along with value changes.
+ */
+interface ChangeDetail<TMeta = unknown, TRaw = unknown> {
+    /**
+     * Logical source for this change.
+     */
+    source: ChangeSource;
+    /**
+     * Optional raw input that produced this value.
+     *
+     * Example: original keyboard input or pasted string.
+     */
+    raw?: TRaw;
+    nativeEvent?: React__default.SyntheticEvent;
+    /**
+     * Variant-specific metadata (e.g. cursor position).
+     */
+    meta?: TMeta;
+}
+/**
+ * Base props shared by all variant components.
+ *
+ * Each variant module will extend this with its own props type.
+ */
+interface VariantBaseProps<TValue> {
+    /**
+     * Current logical value for this field.
+     */
+    value?: TValue | undefined;
+    /**
+     * Called whenever the variant wants to update the value.
+     *
+     * The detail payload describes where the change came from.
+     */
+    onValue?(value: TValue | undefined, detail?: ChangeDetail): void;
+    /**
+     * State flags.
+     */
+    disabled?: boolean;
+    defaultValue?: TValue;
+    readOnly?: boolean;
+    required?: boolean;
+    alias?: string;
+    main?: boolean;
+    /**
+     * Current error message for this field, if any.
+     */
+    error?: string;
+    /**
+     * Size & density hints.
+     *
+     * Variants are free to ignore these, but presets (e.g. Shadcn)
+     * will typically honour them.
+     */
+    size?: FieldSize;
+    density?: FieldDensity;
+}
+interface Extras {
+    trailingIcons?: React__default.ReactNode[];
+    leadingIcons?: React__default.ReactNode[];
+    icon?: React__default.ReactNode;
+    iconGap?: number;
+    trailingIconSpacing?: number;
+    leadingIconSpacing?: number;
+    trailingControl?: React__default.ReactNode;
+    leadingControl?: React__default.ReactNode;
+    /**
+     * Optional className applied to the container that wraps the leading control.
+     * This does not affect the control node itself, only the wrapper div.
+     */
+    leadingControlClassName?: string;
+    /**
+     * Optional className applied to the container that wraps the trailing control.
+     * This does not affect the control node itself, only the wrapper div.
+     */
+    trailingControlClassName?: string;
+    px?: number;
+    py?: number;
+    pb?: number;
+    pe?: number;
+    ps?: number;
+}
+type ExtraFieldProps<Props> = Extras & Props;
+
+/**
+ * Result type for validation hooks.
+ *
+ * Used by:
+ * - variant modules (`validate`)
+ * - per-field `onValidate` (InputField)
+ */
+type ValidateResult = boolean | string | string[] | null | void;
+/**
+ * Placement of the main label relative to the field control.
+ *
+ * This is a macro layout decision: where the label block lives
+ * compared to the input/control block.
+ */
+type LabelPlacement = "top" | "left" | "right" | "hidden";
+/**
+ * Shared placement for helper slots relative to their *root*.
+ *
+ * Example:
+ *  - "above" → above the label root or input root
+ *  - "below" → below the label root or input root
+ *  - "left"  → left of the label root or input root
+ *  - "right" → right of the label root or input root
+ *  - "hidden" → not rendered
+ */
+type SlotPlacement = "left" | "right" | "above" | "below" | "hidden";
+/**
+ * Placement of the sublabel relative to its root block.
+ */
+type SublabelPlacement = SlotPlacement;
+/**
+ * Placement for the longer description block.
+ */
+type DescriptionPlacement = SlotPlacement;
+/**
+ * Placement for helper text (typically small, subtle text).
+ */
+type HelpTextPlacement = SlotPlacement;
+/**
+ * Placement for explicit error text (visual error copy).
+ */
+type ErrorTextPlacement = SlotPlacement;
+/**
+ * Registry of all logical "slots" a field can render.
+ *
+ * Hosts can extend this via declaration merging, e.g.:
+ *
+ *   declare module "@/schema/input-field" {
+ *     interface FieldSlots {
+ *       charCounter: true;
+ *     }
+ *   }
+ */
+interface FieldSlots {
+    /** The main label text. */
+    label: true;
+    /** Optional smaller label text. */
+    sublabel: true;
+    /** Longer, usually multi-line description. */
+    description: true;
+    /** Small helper text, usually subtle. */
+    helpText: true;
+    /** Error text (validation message) when present. */
+    errorText: true;
+    /** The actual control/input element. */
+    input: true;
+    /**tags */
+    tags: true;
+}
+/**
+ * Registry of logical "roots" / anchor blocks.
+ *
+ * Other slots are positioned relative to one of these.
+ */
+interface FieldRoots {
+    /** Label root block. */
+    label: true;
+    /** Input/control root block. */
+    input: true;
+}
+type FieldSlotId = keyof FieldSlots;
+type FieldRootId = keyof FieldRoots;
+/**
+ * Map of which root each *non-root* slot belongs to.
+ *
+ * Example:
+ *   relativeRoots: {
+ *     sublabel: "label",
+ *     description: "input",
+ *     helpText: "input",
+ *     errorText: "input",
+ *   }
+ */
+type RelativeRootsMap = Partial<Record<Exclude<FieldSlotId, FieldRootId>, // non-root slots only
+FieldRootId>>;
+/**
+ * Relative ordering of *non-root* slots per root.
+ *
+ * This is *not* about placement; it only decides "who comes first"
+ * when multiple slots share the same:
+ *   - root (label/input), and
+ *   - placement (above/below/left/right)
+ *
+ * Example:
+ *   ordering: {
+ *     input: ["errorText", "description", "helpText"],
+ *   }
+ *
+ * If description and helpText are both "below" the input, then the
+ * above config means:
+ *   - errorText (below input) first,
+ *   - then description (below input),
+ *   - then helpText (below input).
+ */
+type FieldOrdering = Partial<Record<FieldRootId, Exclude<FieldSlotId, FieldRootId>[]>>;
+/**
+ * Layout defaults for a field/variant.
+ *
+ * Variants can provide these as defaults; InputField merges them
+ * with per-field overrides.
+ *
+ * The high-level placement props remain the main public API.
+ * `relativeRoots` and `ordering` provide a lower-level layout graph
+ * that InputField can use to render slots relative to "label" or
+ * "input" in a predictable order.
+ */
+interface FieldLayoutConfig {
+    /**
+     * Where to render the main label relative to the control.
+     */
+    labelPlacement?: LabelPlacement;
+    /**
+     * Where to render the sublabel relative to its root.
+     */
+    sublabelPlacement?: SublabelPlacement;
+    /**
+     * Where to render the description block relative to its root.
+     */
+    descriptionPlacement?: DescriptionPlacement;
+    /**
+     * Where to render helper text relative to its root.
+     */
+    helpTextPlacement?: HelpTextPlacement;
+    /**
+     * Where to render error text (if any) relative to its root.
+     */
+    errorTextPlacement?: ErrorTextPlacement;
+    /**Where to render the tags (if any) relative to ites root */
+    tagPlacement?: SlotPlacement;
+    /**
+     * Hint that the field should render inline with other controls.
+     */
+    inline?: boolean;
+    /**
+     * Hint that the field should stretch to the full available width.
+     */
+    fullWidth?: boolean;
+    /**
+     * Optional default size/density hints.
+     *
+     * These are advisory; variants/presets may override them.
+     */
+    defaultSize?: FieldSize;
+    defaultDensity?: FieldDensity;
+    /**
+     * Which root each non-root slot is attached to.
+     *
+     * If omitted, InputField can infer reasonable defaults, e.g.:
+     * - sublabel     → "label"
+     * - description  → "input"
+     * - helpText     → "input"
+     * - errorText    → "input"
+     */
+    relativeRoots?: RelativeRootsMap;
+    /**
+     * Relative ordering of non-root slots per root.
+     *
+     * Used only when multiple slots share the same
+     * root + placement combination.
+     */
+    ordering?: FieldOrdering;
+}
+/**
+ * Effective layout for a field after merging:
+ * - variant defaults, and
+ * - per-field overrides.
+ */
+interface EffectiveFieldLayout extends FieldLayoutConfig {
+    /**
+     * Concrete size/density after merging defaults + overrides.
+     */
+    size?: FieldSize;
+    density?: FieldDensity;
+}
+/**
+ * Context passed to a variant's layout resolver.
+ *
+ * - `defaults`: layout defaults defined by the variant module.
+ * - `overrides`: only the layout keys explicitly set on <InputField />.
+ * - `props`: the raw <InputField /> props for this field.
+ *
+ * The resolver MUST respect host overrides: if a key is present in
+ * `overrides`, it should not change it.
+ */
+interface LayoutResolveContext<T = unknown> {
+    defaults: FieldLayoutConfig;
+    overrides: Partial<FieldLayoutConfig>;
+    props: T;
+}
+/**
+ * Variant-level layout resolver.
+ *
+ * This allows variants to implement mapping rules such as:
+ * - "if labelPlacement is left ⇒ inline=true, error below, etc."
+ * while still allowing host overrides to win.
+ *
+ * Variants may also fill in `relativeRoots` and `ordering` to define
+ * how slots are attached to "label" vs "input" and in what relative
+ * order they should render.
+ */
+type LayoutResolver<T = unknown> = (ctx: LayoutResolveContext<T>) => FieldLayoutConfig;
+
+/**
+ * Props for the Shadcn-based text variant.
+ *
+ * This is a *form* wrapper around the base <Input />:
+ *  - Handles value ↔ ChangeDetail mapping.
+ *  - Delegates all visual concerns (masking, affixes, icons, controls,
+ *    size, density) to the Input component.
+ */
+type ShadcnTextVariantProps = ExtraFieldProps<VariantBaseProps<string | undefined>> & {
+    /**
+     * If true and there are controls, the input + controls share one box
+     * (borders, radius, focus states).
+     *
+     * Delegated to the underlying <Input />.
+     */
+    joinControls?: boolean;
+    /**
+     * When joinControls is true, whether the box styling extends over controls
+     * (true) or controls are visually separate (false).
+     */
+    extendBoxToControls?: boolean;
+};
+
+type InputRef = HTMLInputElement;
+interface InputNumberValueChangeEvent {
+    originalEvent: React.SyntheticEvent<any> | null;
+    value: number | null;
+    stopPropagation(): void;
+    preventDefault(): void;
+    target: {
+        name?: string | null;
+        id?: string | null;
+        value: number | null;
+    };
+}
+interface InputNumberProps extends Omit<ShadcnTextVariantProps, 'min' | 'max' | 'value'>, Omit<React.InputHTMLAttributes<HTMLInputElement>, "value" | "defaultValue" | "onChange" | "onInput" | "onKeyDown" | "onKeyUp" | "size" | 'max' | 'min'> {
+    onKeyUp?(event: React.KeyboardEvent<HTMLInputElement>): unknown;
+    onKeyDown?(event: React.KeyboardEvent<HTMLInputElement>): unknown;
+    value?: number | null;
+    /**
+     * Emitted when the numeric value changes (Prime-style).
+     */
+    onValueChange?: (e: InputNumberValueChangeEvent) => void;
+    /**
+     * Optional simple change handler (numeric value).
+     */
+    onChange?: (e: {
+        originalEvent: React.SyntheticEvent<any>;
+        value: number | null;
+    }) => void;
+    locale?: string;
+    localeMatcher?: Intl.NumberFormatOptions["localeMatcher"];
+    mode?: "decimal" | "currency";
+    currency?: string;
+    currencyDisplay?: Intl.NumberFormatOptions["currencyDisplay"];
+    useGrouping?: boolean;
+    minFractionDigits?: number;
+    maxFractionDigits?: number;
+    roundingMode?: Intl.NumberFormatOptions["roundingMode"];
+    min?: number | null;
+    max?: number | null;
+    step?: number;
+    allowEmpty?: boolean;
+    format?: boolean;
+    inputId?: string;
+    inputClassName?: string;
+    inputStyle?: React.CSSProperties;
+    inputRef?: React.Ref<InputRef> | null;
+    /**
+     * String prefix/suffix (like Prime). They are part of formatting logic.
+     * You can ALSO forward them to your text variant as visual adornments.
+     */
+    prefix?: string;
+    suffix?: string;
+    size?: FieldSize;
+    invalid?: boolean;
+}
+declare const InputNumber: React.MemoExoticComponent<React.ForwardRefExoticComponent<InputNumberProps & React.RefAttributes<HTMLInputElement>>>;
+
+type ShadcnNumberVariantProps = Omit<InputNumberProps, "onValueChange" | "onChange" | "leadingControl" | "trailingControl"> & {
+    /**
+     * Show +/- buttons around the numeric field.
+     * Defaults to false.
+     */
+    showButtons?: boolean;
+    /**
+     * How the step buttons are laid out when showButtons is true.
+     *
+     * - 'inline': "-" on the left, "+" on the right
+     * - 'stacked': vertical +/- stack on the right
+     */
+    buttonLayout?: "inline" | "stacked";
+};
+
+type BaseProps$6 = VariantBaseProps<string | undefined>;
+/**
+ * Single-country phone config.
+ *
+ * - code: ISO 3166-1 alpha-2 ("NG", "US", "GB", ...)
+ * - dial: dial code without "+" ("234", "1", "44", ...)
+ * - mask: NATIONAL portion mask only (no dial), e.g. "999 999 9999"
+ */
+interface PhoneCountry {
+    code: string;
+    label: string;
+    dial: string;
+    mask: string;
+    flag?: React.ReactNode;
+}
+/**
+ * How the variant emits the form value.
+ *
+ * - "masked"  → "+234 801 234 5678"
+ * - "e164"    → "2348012345678"   (dial + national digits, no "+")
+ * - "national"→ "8012345678"
+ */
+type PhoneValueMode = "masked" | "e164" | "national";
+interface PhoneSpecificProps {
+    countries?: PhoneCountry[];
+    defaultCountry?: string;
+    onCountryChange?: (country: PhoneCountry) => void;
+    showCountry?: boolean;
+    countryPlaceholder?: string;
+    showFlag?: boolean;
+    showSelectedLabel?: boolean;
+    showSelectedDial?: boolean;
+    showDialInList?: boolean;
+    /**
+     * Controls how the emitted value is shaped.
+     *
+     * Default mirrors legacy autoUnmask=true + emitE164=true → "e164".
+     */
+    valueMode?: PhoneValueMode;
+    /**
+     * When true, the national mask keeps placeholder characters
+     * for not-yet-filled positions. When false, trailing mask
+     * fragments are omitted.
+     */
+    keepCharPositions?: boolean;
+    /**
+     * Style hooks for the internal country selector.
+     */
+    countrySelectClassName?: string;
+    countryTriggerClassName?: string;
+    countryValueClassName?: string;
+    countryContentClassName?: string;
+    countryItemClassName?: string;
+}
+type TextUiProps$4 = Omit<ShadcnTextVariantProps, "type" | "inputMode" | "leadingControl" | "value" | "onValue">;
+/**
+ * Full props for the phone variant as seen by the form runtime.
+ *
+ * - Keeps the same `value`/`onValue` contract as other variants.
+ * - Inherits visual/behavioural text props (size, density, className, etc.).
+ * - Adds phone-specific configuration (countries, valueMode, etc.).
+ */
+type ShadcnPhoneVariantProps = TextUiProps$4 & PhoneSpecificProps & Pick<BaseProps$6, "value" | "onValue">;
+
+type BaseProps$5 = VariantBaseProps<string | undefined>;
+/**
+ * Extra options specific to the color variant.
+ */
+interface ColorSpecificProps {
+    /**
+     * If false, we hide the colour preview box.
+     * Default: true
+     */
+    showPreview?: boolean;
+    /**
+     * If false, we hide the picker toggle control/icon.
+     * Default: true
+     */
+    showPickerToggle?: boolean;
+    /**
+     * Size of the colour swatch in pixels.
+     * Default: 18
+     */
+    previewSize?: number;
+    /**
+     * Optional className for the outer wrapper that hosts
+     * the Input + hidden color input.
+     */
+    wrapperClassName?: string;
+    /**
+     * Optional className for the preview button itself (around the swatch).
+     */
+    previewButtonClassName?: string;
+    /**
+     * Optional className for the swatch box inside the preview button.
+     */
+    previewSwatchClassName?: string;
+    /**
+     * Optional className for the hidden `<input type="color">`.
+     *
+     * By default this input is visually hidden and only used
+     * to invoke the browser/OS colour picker, but you can override
+     * this class to make it visible and style it.
+     */
+    pickerInputClassName?: string;
+    /**
+     * Custom icon shown in the trailing control as the picker toggle.
+     * If omitted, a tiny ▾ triangle is used.
+     */
+    pickerToggleIcon?: React.ReactNode;
+    className?: string;
+}
+/**
+ * We inherit the *visual/behavioural* props from ShadcnTextVariant,
+ * but control value / onValue / type / inputMode / leadingControl / trailingControl ourselves.
+ */
+type TextUiProps$3 = Omit<ShadcnTextVariantProps, "type" | "inputMode" | "leadingControl" | "trailingControl" | "value" | "onValue">;
+/**
+ * Full props for the color variant as seen by the form runtime.
+ */
+type ShadcnColorVariantProps = TextUiProps$3 & ColorSpecificProps & Pick<BaseProps$5, "value" | "onValue">;
+
+type BaseProps$4 = VariantBaseProps<string | undefined>;
+/**
+ * Options for the built-in password strength meter.
+ *
+ * NOTE: Score is always in the range 0–4 (inclusive).
+ */
+interface StrengthOptions {
+    /**
+     * Custom scoring function.
+     * Return a number in the range 0–4 (inclusive) where 0 = weakest, 4 = strongest.
+     */
+    calc?: (value: string) => number;
+    /**
+     * Labels for each score bucket (index 0..4).
+     * Defaults to: ["Very weak", "Weak", "Okay", "Good", "Strong"]
+     */
+    labels?: [string, string, string, string, string];
+    /**
+     * Thresholds for score steps using a 0–100 bar.
+     * Defaults to [0, 25, 50, 75, 100] mapping to scores 0..4 respectively.
+     */
+    thresholds?: [number, number, number, number, number];
+    /**
+     * Minimum score required to consider the password acceptable (0–4).
+     * This is purely visual unless you enforce it in validate/onChange.
+     * Default: 2
+     */
+    minScore?: number | 2;
+    /**
+     * Whether to show the textual label next to/under the bar.
+     * Default: true
+     */
+    showLabel?: boolean;
+    /**
+     * Where to render the meter.
+     * - "inline" → compact row under the input
+     * - "block" → stacked with more spacing
+     * Default: "inline"
+     */
+    display?: "inline" | "block";
+}
+interface PasswordRuleConfig {
+    /**
+     * Pattern used to decide if the rule passes.
+     */
+    pattern: RegExp;
+    /**
+     * If true, the rule is considered optional (recommendation).
+     * Default: false unless the rule name is not prefixed with "!".
+     */
+    optional?: boolean;
+    /**
+     * Weight in the scoring (relative importance).
+     * Default: 1, doubled if the use key is prefixed with "!".
+     */
+    weight?: number;
+    /**
+     * Short label for the rule (e.g. "At least 8 characters").
+     * Defaults to the map key if omitted.
+     */
+    label?: string;
+    /**
+     * Longer description, used in detailed rule view.
+     */
+    description?: string;
+}
+/**
+ * A definition entry can be:
+ * - string     → treated as a regex source
+ * - RegExp     → used directly
+ * - full config
+ */
+type PasswordRuleDefinition = string | RegExp | PasswordRuleConfig;
+/**
+ * Map of alias/keys → definition entries.
+ */
+type PasswordDefinitionMap = Record<string, PasswordRuleDefinition>;
+/**
+ * Internal normalized state for a single rule.
+ */
+interface NormalizedRuleState {
+    key: string;
+    label: string;
+    description?: string;
+    optional: boolean;
+    required: boolean;
+    weight: number;
+    passed: boolean;
+}
+/**
+ * Props passed to custom meter renderers.
+ */
+interface PasswordMeterRenderProps {
+    /** Raw password value. */
+    value: string;
+    /** Bucket score 0..4 based on percent + thresholds. */
+    score: number;
+    /** 0–100 progress used for the bar. */
+    percent: number;
+    /** Human label for the current score. */
+    label: string;
+    /** Whether score >= minScore. */
+    passed: boolean;
+    /** Effective minScore after normalization. */
+    minScore: number;
+    /** Effective thresholds used for bucketing. */
+    thresholds: [number, number, number, number, number];
+    /** Effective labels used. */
+    labels: [string, string, string, string, string];
+    /** Rule-level details when using a definition map. */
+    rules: NormalizedRuleState[];
+}
+/**
+ * Password-only props (on top of Shadcn text UI props & VariantBaseProps).
+ *
+ * This is what the form runtime sees as VariantPropsFor<"password">.
+ */
+interface PasswordVariantProps {
+    /** Maximum number of characters permitted. */
+    maxLength?: number;
+    /** Browser autocomplete hint (e.g., "current-password", "new-password"). */
+    autoComplete?: string;
+    /** Show an eye button to toggle between obscured/plain text. (default: true) */
+    revealToggle?: boolean;
+    /** Start in the revealed (plain text) state. */
+    defaultRevealed?: boolean;
+    /** Called whenever the reveal state changes. */
+    onRevealChange?(revealed: boolean): void;
+    /** Override the icons used for hide/show. */
+    renderToggleIcon?(revealed: boolean): React.ReactNode;
+    /** Accessible label for the toggle button. */
+    toggleAriaLabel?(revealed: boolean): string;
+    /**
+     * Extra className for the reveal toggle button.
+     */
+    toggleButtonClassName?: string;
+    /**
+     * Enable the built-in strength meter (boolean or options).
+     *
+     * - false / undefined → no built-in meter is shown
+     * - true              → use defaults
+     * - object            → merge with defaults
+     */
+    strengthMeter?: boolean | StrengthOptions;
+    /**
+     * Optional rule definition map.
+     */
+    ruleDefinitions?: PasswordDefinitionMap;
+    /**
+     * Selection of rule aliases to apply.
+     *
+     * - "length"  → use ruleDefinitions["length"] with default importance
+     * - "!length" → same rule but treated as more important
+     */
+    ruleUses?: string[];
+    /**
+     * Built-in meter style:
+     * - "simple" → single bar + label
+     * - "rules"  → bar + per-rule checklist
+     * Default: "simple"
+     */
+    meterStyle?: "simple" | "rules";
+    /**
+     * Optional custom meter renderer.
+     */
+    renderMeter?(props: PasswordMeterRenderProps): React.ReactNode;
+    /**
+     * ClassNames for the meter and rules UI.
+     */
+    meterWrapperClassName?: string;
+    meterContainerClassName?: string;
+    meterBarClassName?: string;
+    meterLabelClassName?: string;
+    rulesWrapperClassName?: string;
+    rulesHeadingClassName?: string;
+    rulesListClassName?: string;
+    ruleItemClassName?: string;
+    ruleIconClassName?: string;
+    ruleLabelClassName?: string;
+    /**
+     * Extra className for the outer field wrapper.
+     */
+    className?: string;
+}
+type TextUiProps$2 = Omit<ShadcnTextVariantProps, "type" | "inputMode" | "leadingControl" | "trailingControl" | "value" | "onValue">;
+/**
+ * Full props for the Shadcn-based password variant.
+ */
+type ShadcnPasswordVariantProps = TextUiProps$2 & PasswordVariantProps & Pick<BaseProps$4, "value" | "onValue" | "error">;
+
+declare const buttonVariants: (props?: ({
+    variant?: "default" | "link" | "destructive" | "outline" | "secondary" | "ghost" | null | undefined;
+    size?: "default" | "sm" | "lg" | "icon" | "icon-sm" | "icon-lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare function Button({ className, variant, size, asChild, ...props }: React.ComponentProps<"button"> & VariantProps<typeof buttonVariants> & {
+    asChild?: boolean;
+}): react_jsx_runtime.JSX.Element;
+
+declare function Calendar({ className, classNames, showOutsideDays, captionLayout, buttonVariant, formatters, components, ...props }: React.ComponentProps<typeof DayPicker> & {
+    buttonVariant?: React.ComponentProps<typeof Button>["variant"];
+}): react_jsx_runtime.JSX.Element;
+
+type DateMode = "single" | "range";
+interface DateRange {
+    from?: Date;
+    to?: Date;
+}
+type DateValue = Date | DateRange | undefined;
+type BaseProps$3 = VariantBaseProps<DateValue>;
+type DisabledDays = React.ComponentProps<typeof Calendar>["disabled"];
+/**
+ * Logical temporal "kind" for the field.
+ *
+ * This controls the default mask + formatting/parsing.
+ *
+ * - "date"      → yyyy-MM-dd (default)
+ * - "datetime"  → yyyy-MM-dd HH:mm
+ * - "time"      → HH:mm
+ * - "hour"      → HH
+ * - "monthYear" → MM/yyyy
+ * - "year"      → yyyy
+ */
+type DateKind = "date" | "datetime" | "time" | "hour" | "monthYear" | "year" | (string & {});
+/**
+ * Public props for the date variant (legacy + mask extensions).
+ */
+interface DateVariantProps {
+    mode?: DateMode;
+    placeholder?: React.ReactNode;
+    clearable?: boolean;
+    minDate?: Date;
+    maxDate?: Date;
+    disabledDays?: DisabledDays;
+    /**
+     * Pattern for single dates.
+     *
+     * Tokens:
+     * - yyyy → full year
+     * - MM   → month (01–12)
+     * - dd   → day (01–31)
+     * - HH   → hours (00–23)
+     * - mm   → minutes (00–59)
+     *
+     * Default depends on `kind`:
+     * - date      → "yyyy-MM-dd"
+     * - datetime  → "yyyy-MM-dd HH:mm"
+     * - time      → "HH:mm"
+     * - hour      → "HH"
+     * - monthYear → "MM/yyyy"
+     * - year      → "yyyy"
+     */
+    formatSingle?: string;
+    /**
+     * String pattern or custom formatter for ranges.
+     *
+     * - string → same token rules as formatSingle, applied to both ends
+     * - function → full control over display text
+     */
+    formatRange?: string | ((range: DateRange | undefined) => string);
+    /**
+     * Separator when formatRange is a string pattern.
+     * Default: " – "
+     */
+    rangeSeparator?: string;
+    /**
+     * When true, keep the calendar open after a selection.
+     *
+     * For range mode, the picker also stays open until both
+     * `from` and `to` are chosen.
+     */
+    stayOpenOnSelect?: boolean;
+    /**
+     * Controlled open state for the popover.
+     */
+    open?: boolean;
+    onOpenChange?(o: boolean): void;
+    /**
+     * Temporal kind (controls default mask + formatting/parsing).
+     *
+     * Default: "date".
+     */
+    kind?: DateKind;
+    /**
+     * Optional explicit input mask pattern for the text input.
+     *
+     * If omitted, a sensible default based on `kind` is used.
+     *
+     * Mask tokens follow the same rules as the underlying Input mask:
+     *   9 = digit, a = letter, * = alphanumeric.
+     */
+    inputMask?: string;
+    /**
+     * Whether to render the calendar popover.
+     *
+     * Defaults:
+     * - true  for `kind` = "date" | "datetime"
+     * - false for time-only kinds ("time", "hour", "monthYear", "year")
+     */
+    showCalendar?: boolean;
+}
+/**
+ * We still reuse the Shadcn text UI props (size, density, icons, etc.),
+ * but we take over type/value/onValue and the controls.
+ */
+type TextUiProps$1 = Omit<ShadcnTextVariantProps, "type" | "inputMode" | "leadingControl" | "trailingControl" | "value" | "onValue">;
+/**
+ * Full props for the Shadcn-based date variant.
+ */
+type ShadcnDateVariantProps = TextUiProps$1 & DateVariantProps & Pick<BaseProps$3, "value" | "onValue" | "error">;
+
+type ChipsValue = string[] | undefined;
+type BaseProps$2 = VariantBaseProps<ChipsValue>;
+/**
+ * How we split text into chips when committing.
+ */
+type ChipsSeparator = string | RegExp | (string | RegExp)[];
+/**
+ * Placement of chips relative to the entry control.
+ *
+ * - "inline" → inside the same visual box (Input) or in the textarea toolbox.
+ * - "below"  → chips rendered as a block underneath the field.
+ */
+type ChipsPlacement = "inline" | "below";
+/**
+ * Chips-only props, on top of the injected ones.
+ */
+interface ChipsVariantProps {
+    /**
+     * Placeholder shown when there are no chips and input is empty.
+     */
+    placeholder?: string;
+    /**
+     * Separators used to split raw input into chips.
+     *
+     * - string  → split on that string
+     * - RegExp  → split with regex
+     * - array   → try each in order
+     *
+     * Default: [",", ";"]
+     */
+    separators?: ChipsSeparator;
+    /**
+     * When true, pressing Enter commits the current input as chips.
+     * Default: true
+     */
+    addOnEnter?: boolean;
+    /**
+     * When true, pressing Tab commits the current input as chips.
+     * Default: true
+     */
+    addOnTab?: boolean;
+    /**
+     * When true, blurring the field commits any remaining input as chips.
+     * Default: true
+     */
+    addOnBlur?: boolean;
+    /**
+     * When false, duplicate chips are ignored.
+     * Default: false
+     */
+    allowDuplicates?: boolean;
+    /**
+     * Maximum number of chips allowed.
+     * Undefined → unlimited.
+     */
+    maxChips?: number;
+    /**
+     * When true, Backspace on empty input removes the last chip.
+     * Default: true
+     */
+    backspaceRemovesLast?: boolean;
+    /**
+     * Show a small clear-all button.
+     * Default: false
+     */
+    clearable?: boolean;
+    /**
+     * Called when chips are added.
+     */
+    onAddChips?(added: string[], next: string[]): void;
+    /**
+     * Called when chips are removed.
+     */
+    onRemoveChips?(removed: string[], next: string[]): void;
+    /**
+     * Optional custom chip renderer.
+     *
+     * If provided, you are responsible for calling onRemove(index)
+     * from your UI when you want to remove a chip.
+     */
+    renderChip?(chip: string, index: number, ctx: {
+        remove(): void;
+        chips: string[];
+    }): React.ReactNode;
+    /**
+     * Optional custom overflow chip renderer.
+     *
+     * Receives the hidden count and the full chip list.
+     */
+    renderOverflowChip?(hiddenCount: number, chips: string[]): React.ReactNode;
+    /**
+     * Max number of chips to *render*.
+     * Extra chips are summarized as "+N more".
+     */
+    maxVisibleChips?: number;
+    /**
+     * Max number of characters to *display* per chip.
+     * The underlying value is not truncated.
+     */
+    maxChipChars?: number;
+    /**
+     * CSS max-width for chip labels (e.g. 160 or "12rem").
+     */
+    maxChipWidth?: number | string;
+    /**
+     * When true, the entry control is a Textarea instead of Input.
+     * Good for comment-style chip entry.
+     */
+    textareaMode?: boolean;
+    /**
+     * Where chips are rendered relative to the entry.
+     *
+     * Default:
+     * - Input mode → "inline"
+     * - Textarea mode → "inline"
+     */
+    placement?: ChipsPlacement;
+    className?: string;
+    chipsClassName?: string;
+    chipClassName?: string;
+    chipLabelClassName?: string;
+    chipRemoveClassName?: string;
+    inputClassName?: string;
+}
+/**
+ * We still type against ShadcnTextVariantProps so chips can reuse
+ * size/density/icon props etc. We take control of:
+ * - type / value / onValue
+ * - leadingControl / trailingControl
+ */
+type TextUiProps = Omit<ShadcnTextVariantProps, "type" | "inputMode" | "leadingControl" | "trailingControl" | "value" | "onValue">;
+/**
+ * Full props for the Shadcn-based chips variant.
+ */
+type ShadcnChipsVariantProps = TextUiProps & ChipsVariantProps & Pick<BaseProps$2, "value" | "onValue" | "error">;
+
+interface TextareaIconControlProps {
+    leadingIcons?: React.ReactNode[];
+    trailingIcons?: React.ReactNode[];
+    icon?: React.ReactNode;
+    iconGap?: number;
+    leadingIconSpacing?: number;
+    trailingIconSpacing?: number;
+    leadingControl?: React.ReactNode;
+    trailingControl?: React.ReactNode;
+    leadingControlClassName?: string;
+    trailingControlClassName?: string;
+    /**
+     * If true, move the visual box (border, bg, radius, focus) from
+     * `textarea-field` to `textarea-inner` so the side controls are
+     * inside the same frame.
+     *
+     * Default: false (controls sit outside the border).
+     */
+    extendBoxToControls?: boolean;
+    /**
+     * If true, move the visual box all the way up to `textarea-box`,
+     * so the upper toolbox and the inner row share a single frame.
+     *
+     * When this is true, it overrides `extendBoxToControls`.
+     *
+     * Default: false.
+     */
+    extendBoxToToolbox?: boolean;
+    /**
+     * Extra padding knobs (same semantics as Input).
+     *
+     * px → symmetric horizontal padding
+     * py → symmetric vertical padding
+     * ps/pe → logical start/end padding adjustments
+     * pb → extra bottom padding (stacked with py)
+     */
+    px?: number;
+    py?: number;
+    ps?: number;
+    pe?: number;
+    pb?: number;
+    /**
+     * Extra classes merged into the raw <textarea>.
+     * (The box padding/border live on the wrappers.)
+     */
+    inputClassName?: string;
+}
+interface TextareaSizeProps {
+    size?: "sm" | "md" | "lg" | (string & {});
+    density?: "compact" | "normal" | "relaxed" | "dense" | "loose" | (string & {});
+}
+interface TextareaProps extends Omit<React.TextareaHTMLAttributes<HTMLTextAreaElement>, "size">, TextareaIconControlProps, TextareaSizeProps {
+    /**
+     * Auto-resize based on content.
+     * Default: true.
+     */
+    autoResize?: boolean;
+    /**
+     * Minimum number of visual rows.
+     * Default: 1.
+     */
+    rows?: number;
+    /**
+     * Maximum number of visual rows.
+     * Undefined → unlimited.
+     */
+    maxRows?: number;
+    /**
+     * Optional upper toolbox area.
+     */
+    upperControl?: React.ReactNode;
+    upperControlClassName?: string;
+}
+declare const Textarea: React.ForwardRefExoticComponent<TextareaProps & React.RefAttributes<HTMLTextAreaElement>>;
+
+type TextareaValue = string | undefined;
+type BaseProps$1 = VariantBaseProps<TextareaValue>;
+/**
+ * Full props for the Shadcn-based textarea variant.
+ *
+ * - Reuses all UI-level behaviour from `Textarea` (autoResize, upperControl,
+ *   leading/trailing controls, icons, size/density, padding knobs, etc.).
+ * - Takes over `value` / `onChange` so it can emit through `onValue` with
+ *   a `ChangeDetail`.
+ */
+interface ShadcnTextareaVariantProps extends Omit<TextareaProps, "value" | "defaultValue" | "onChange">, Pick<BaseProps$1, "value" | "onValue" | "error"> {
+}
+
+declare function Switch({ className, thumbClassName, ...props }: React.ComponentProps<typeof SwitchPrimitive.Root> & {
+    thumbClassName?: string;
+}): react_jsx_runtime.JSX.Element;
+
+type ToggleValue = boolean | undefined;
+type BaseProps = VariantBaseProps<ToggleValue>;
+type Size = "sm" | "md" | "lg";
+type Density = "default" | "dense";
+/**
+ * UI props specific to the Shadcn-based toggle.
+ *
+ * This uses Switch as the underlying control, but we keep
+ * the API surface small and focused.
+ */
+interface ShadcnToggleUiProps extends Omit<React.ComponentProps<typeof Switch>, "checked" | "onCheckedChange" | "className"> {
+    /**
+     * Visual size of the switch / text.
+     * Default: "md".
+     */
+    size?: Size;
+    /**
+     * Row density (vertical padding & gap).
+     * Default: "default".
+     */
+    density?: Density;
+    /**
+     * Place the switch on the left or right of the state text.
+     * Default: "left".
+     */
+    controlPlacement?: "left" | "right";
+    /**
+     * Optional state text shown next to the control when ON.
+     */
+    onText?: React.ReactNode;
+    /**
+     * Optional state text shown next to the control when OFF.
+     */
+    offText?: React.ReactNode;
+    /**
+     * Wrapper class for the whole toggle row.
+     */
+    className?: string;
+    /**
+     * Extra classes for the Switch root.
+     */
+    switchClassName?: string;
+    /**
+     * Extra classes for the Switch thumb.
+     * (Your patched Switch should support thumbClassName.)
+     */
+    switchThumbClassName?: string;
+}
+/**
+ * Full props for the Shadcn-based toggle variant.
+ *
+ * We only pick value/onValue/error from the variant base props;
+ * everything else (id, disabled, aria-*) flows via Switch props.
+ */
+type ShadcnToggleVariantProps = ShadcnToggleUiProps & Pick<BaseProps, "value" | "onValue" | "error">;
+
+declare function RadioGroup({ className, ...props }: React.ComponentProps<typeof RadioGroupPrimitive.Root>): react_jsx_runtime.JSX.Element;
+
+/**
+ * Visual size of the radio UI.
+ */
+type RadioSize = "sm" | "md" | "lg";
+/**
+ * Vertical density of each radio row.
+ *
+ * Names aligned with your FieldDensity, but local to this variant.
+ */
+type RadioDensity = "compact" | "comfortable" | "loose";
+/**
+ * Layout mode for the group.
+ *
+ * - "list" → stacked rows
+ * - "grid" → CSS grid with `columns`
+ */
+type RadioLayoutMode = "list" | "grid";
+/**
+ * Base radio item shape.
+ */
+interface RadioItem<TValue> {
+    value: TValue;
+    label: React.ReactNode;
+    description?: React.ReactNode;
+    disabled?: boolean;
+    key?: React.Key;
+}
+/**
+ * Mapping functions used when TItem is not `RadioItem<TValue>`.
+ */
+interface RadioMappers<TItem, TValue> {
+    getValue: (item: TItem, index: number) => TValue;
+    getLabel: (item: TItem, index: number) => React.ReactNode;
+    getDescription?: (item: TItem, index: number) => React.ReactNode;
+    isDisabled?: (item: TItem, index: number) => boolean;
+    getKey?: (item: TItem, index: number) => React.Key;
+}
+/**
+ * Context passed to a custom renderOption callback.
+ */
+interface RadioRenderOptionContext<TValue> {
+    item: RadioItem<TValue>;
+    index: number;
+    selected: boolean;
+    disabled: boolean;
+    size: RadioSize;
+    density: RadioDensity;
+    /**
+     * DOM id of this option (tied to the underlying RadioGroupItem).
+     */
+    optionId?: string;
+    /**
+     * Prebuilt radio control for convenience.
+     * You can ignore this and render your own if you want.
+     */
+    radio: React.ReactNode;
+}
+/**
+ * UI-specific radio props (independent of VariantBaseProps).
+ */
+interface ShadcnRadioUiProps<TItem, TValue> {
+    /**
+     * Items to render as choices.
+     *
+     * Can be:
+     * - `RadioItem<TValue>[]`, or
+     * - any custom TItem[] when used with mapping functions
+     *   or optionValue/optionLabel keys.
+     */
+    items: readonly TItem[];
+    /**
+     * Mapping functions for TItem → value/label/etc.
+     *
+     * Takes precedence over optionValue/optionLabel if provided.
+     */
+    mappers?: RadioMappers<TItem, TValue>;
+    /**
+     * Property name on TItem that holds the **value**.
+     *
+     * Example:
+     *   items = [{ id: "free", title: "Free" }]
+     *   optionValue = "id"
+     */
+    optionValue?: keyof TItem;
+    /**
+     * Property name on TItem that holds the **label**.
+     *
+     * Example:
+     *   items = [{ id: "free", title: "Free" }]
+     *   optionLabel = "title"
+     */
+    optionLabel?: keyof TItem;
+    /**
+     * Optional custom renderer for each option.
+     *
+     * If provided, the default label/description layout is skipped and
+     * this function is responsible for rendering the row.
+     */
+    renderOption?: (ctx: RadioRenderOptionContext<TValue>) => React.ReactNode;
+    /**
+     * Layout mode for the group.
+     * Default: "list".
+     */
+    layout?: RadioLayoutMode;
+    /**
+     * Number of columns in grid mode.
+     * Default: 2.
+     */
+    columns?: number;
+    /**
+     * Gap between items (list rows or grid cells) in px.
+     * If omitted, Tailwind gaps/classes can handle spacing.
+     */
+    itemGapPx?: number;
+    /**
+     * Visual size of the radios.
+     * Default: "md".
+     */
+    size?: RadioSize;
+    /**
+     * Vertical density (padding) of each row.
+     * Default: "comfortable".
+     */
+    density?: RadioDensity;
+    /**
+     * ARIA overrides for the group.
+     */
+    "aria-label"?: string;
+    "aria-labelledby"?: string;
+    /**
+     * Wrapper class for the whole radio group.
+     */
+    groupClassName?: string;
+    /**
+     * Extra classes for each radio option row.
+     */
+    optionClassName?: string;
+    /**
+     * Extra classes for the option label node.
+     */
+    labelClassName?: string;
+    /**
+     * Extra classes for the description text under the label.
+     */
+    descriptionClassName?: string;
+}
+/**
+ * Full props for the Shadcn-based radio variant.
+ */
+type ShadcnRadioVariantProps<TValue, TItem = RadioItem<TValue>> = ShadcnRadioUiProps<TItem, TValue> & Pick<VariantBaseProps<TValue | undefined>, "value" | "onValue" | "error" | "disabled" | "required"> & Pick<React.ComponentProps<typeof RadioGroup>, "name"> & {
+    id?: string;
+    className?: string;
+    "aria-describedby"?: string;
+};
+
+type CheckboxSize = "sm" | "md" | "lg";
+type CheckboxDensity = "compact" | "comfortable" | "loose";
+type CheckboxLayoutMode = "list" | "grid";
+/**
+ * Internal state we store in the value list.
+ * "none" never goes into the external value.
+ */
+type CheckboxTriStateValue = true | false;
+/**
+ * Internal state we pass to the Shadcn checkbox.
+ * "none" is used to represent "no stance yet".
+ */
+type CheckboxInternalState = true | false | "none";
+interface CheckboxGroupEntry<TValue> {
+    value: TValue;
+    state: CheckboxTriStateValue;
+}
+type CheckboxGroupValue<TValue> = readonly CheckboxGroupEntry<TValue>[] | undefined;
+/**
+ * Single checkbox value.
+ * undefined → "none"
+ */
+type CheckboxSingleValue = boolean | undefined;
+/**
+ * Public union type for the variant's value.
+ *
+ * - In single mode: we expect CheckboxSingleValue
+ * - In group mode: we expect CheckboxGroupValue<TValue>
+ *
+ * At the type level this is a union; at runtime we branch using `single`.
+ */
+type CheckboxVariantValue<TValue> = CheckboxSingleValue | CheckboxGroupValue<TValue>;
+interface CheckboxItem<TValue> {
+    value: TValue;
+    label: React.ReactNode;
+    description?: React.ReactNode;
+    disabled?: boolean;
+    key?: React.Key;
+    /**
+     * Override tri-state behaviour for this item.
+     * If undefined, variant-level `tristate` is used.
+     */
+    tristate?: boolean;
+}
+interface CheckboxMappers<TItem, TValue> {
+    getValue: (item: TItem, index: number) => TValue;
+    getLabel: (item: TItem, index: number) => React.ReactNode;
+    getDescription?: (item: TItem, index: number) => React.ReactNode;
+    isDisabled?: (item: TItem, index: number) => boolean;
+    getKey?: (item: TItem, index: number) => React.Key;
+    getTristate?: (item: TItem, index: number) => boolean | undefined;
+}
+interface CheckboxRenderOptionContext<TValue> {
+    item: CheckboxItem<TValue>;
+    index: number;
+    state: CheckboxInternalState;
+    effectiveTristate: boolean;
+    disabled: boolean;
+    size: CheckboxSize;
+    density: CheckboxDensity;
+    checkboxId?: string;
+    /**
+     * Prebuilt Shadcn checkbox node.
+     */
+    checkbox: React.ReactNode;
+}
+/**
+ * UI props for both single and group modes.
+ */
+interface ShadcnCheckboxUiProps<TItem, TValue> {
+    /**
+     * Group mode:
+     *  - Required when `single` is not true.
+     *
+     * Single mode:
+     *  - Optional; if provided, `items[0]` can supply label/description.
+     */
+    items?: readonly TItem[];
+    /**
+     * Mapping functions for arbitrary item shapes.
+     * Takes precedence over optionValue/optionLabel.
+     */
+    mappers?: CheckboxMappers<TItem, TValue>;
+    /**
+     * Property name that holds the value on each item.
+     *
+     * Example:
+     *   items = [{ id: "read", label: "Read" }]
+     *   optionValue = "id"
+     */
+    optionValue?: keyof TItem;
+    /**
+     * Property name that holds the label on each item.
+     *
+     * Example:
+     *   items = [{ id: "read", title: "Read" }]
+     *   optionLabel = "title"
+     */
+    optionLabel?: keyof TItem;
+    /**
+     * Custom renderer for each option row.
+     */
+    renderOption?: (ctx: CheckboxRenderOptionContext<TValue>) => React.ReactNode;
+    /**
+     * If true, treat this variant as a single checkbox instead of a group.
+     *
+     * Value is then CheckboxSingleValue (boolean | undefined).
+     */
+    single?: boolean;
+    /**
+     * Variant-level default tri-state behaviour.
+     *
+     * - In single mode: directly controls tri-state for the single checkbox.
+     * - In group mode: default for all items, unless item.tristate overrides.
+     */
+    tristate?: boolean;
+    /**
+     * Layout mode in group mode: vertical list or CSS grid.
+     */
+    layout?: CheckboxLayoutMode;
+    /**
+     * Number of columns in grid mode.
+     * Default: 2.
+     */
+    columns?: number;
+    /**
+     * Gap between items in px.
+     */
+    itemGapPx?: number;
+    /**
+     * Visual size of the checkbox / text.
+     * Default: "md".
+     */
+    size?: CheckboxSize;
+    /**
+     * Vertical density of each row.
+     * Default: "comfortable".
+     */
+    density?: CheckboxDensity;
+    /**
+     * ARIA attributes for the group wrapper.
+     */
+    "aria-label"?: string;
+    "aria-labelledby"?: string;
+    /**
+     * Wrapper class for the entire group (or single field).
+     */
+    groupClassName?: string;
+    /**
+     * Extra classes for each option row (group mode).
+     */
+    optionClassName?: string;
+    /**
+     * Extra classes for the option label text.
+     */
+    labelClassName?: string;
+    /**
+     * Extra classes for the option description text.
+     */
+    descriptionClassName?: string;
+    /**
+     * Single-mode inline label (if you want variant-level text).
+     * Usually you'll rely on InputField's label instead.
+     */
+    singleLabel?: React.ReactNode;
+    /**
+     * Single-mode description text under the label.
+     */
+    singleDescription?: React.ReactNode;
+}
+/**
+ * Full props for the Shadcn-based checkbox variant.
+ *
+ * TValue: primitive or object key
+ * TItem: item shape used to build checkbox items
+ */
+type ShadcnCheckboxVariantProps<TValue, TItem = CheckboxItem<TValue>> = ShadcnCheckboxUiProps<TItem, TValue> & Pick<VariantBaseProps<CheckboxVariantValue<TValue>>, "value" | "onValue" | "error" | "disabled" | "required"> & {
+    id?: string;
+    className?: string;
+    name?: string;
+    "aria-describedby"?: string;
+};
+/**
+ * Default item value type for the checkbox variant.
+ *
+ * You can still use the generic ShadcnCheckboxVariantProps<TValue, TItem>
+ * directly if you need a different TValue; the registry uses this alias.
+ */
+type DefaultCheckboxItemValue = string | number;
+/**
+ * Public "value" type for the checkbox variant used by the registry:
+ *
+ * - Single mode: boolean | undefined
+ * - Group mode: CheckboxGroupEntry<DefaultCheckboxItemValue>[] | undefined
+ *
+ * In tri-state group mode, both `true` and `false` entries are present;
+ * `"none"` never appears in this type.
+ */
+type CheckboxVariantPublicValue = CheckboxVariantValue<DefaultCheckboxItemValue>;
+/**
+ * Public props type for the checkbox variant used by the registry.
+ *
+ * This is ShadcnCheckboxVariantProps with TValue fixed to DefaultCheckboxItemValue.
+ */
+type ShadcnCheckboxVariantPublicProps = ShadcnCheckboxVariantProps<DefaultCheckboxItemValue>;
+
+type SelectPrimitive$1 = string | number;
+type MultiSelectOption = SelectPrimitive$1 | {
+    label?: React.ReactNode;
+    value?: SelectPrimitive$1;
+    description?: React.ReactNode;
+    disabled?: boolean;
+    icon?: React.ReactNode;
+    [key: string]: any;
+};
+type NormalizedMultiItem = {
+    key: string;
+    value: SelectPrimitive$1;
+    labelNode: React.ReactNode;
+    labelText: string;
+    description?: React.ReactNode;
+    disabled?: boolean;
+    icon?: React.ReactNode;
+    raw: MultiSelectOption;
+};
+interface ShadcnMultiSelectVariantProps extends Pick<VariantBaseProps<SelectPrimitive$1[] | undefined>, "value" | "onValue" | "error" | "disabled" | "readOnly" | "size" | "density"> {
+    /**
+     * Options for the multi-select.
+     *
+     * You can pass:
+     * - primitives: ["ng", "gh", "ke"]
+     * - objects:    [{ label, value, ...extra }]
+     */
+    options?: MultiSelectOption[];
+    /**
+     * Automatically capitalise the first letter of the label
+     * (when the resolved label is a string).
+     */
+    autoCap?: boolean;
+    /**
+     * How to read the label from each option.
+     *
+     * - string → key on the option object
+     * - function → custom mapper
+     * - omitted → tries `label`, else String(value)
+     */
+    optionLabel?: string | ((item: MultiSelectOption) => React.ReactNode);
+    /**
+     * How to read the value from each option.
+     *
+     * - string → key on the option object
+     * - function → custom mapper
+     * - omitted → uses `value`, or `id`, or `key`, or index
+     */
+    optionValue?: string | ((item: MultiSelectOption) => SelectPrimitive$1);
+    /**
+     * Optional description line under the label.
+     */
+    optionDescription?: string | ((item: MultiSelectOption) => React.ReactNode);
+    /**
+     * How to determine if an option is disabled.
+     */
+    optionDisabled?: string | ((item: MultiSelectOption) => boolean);
+    /**
+     * How to extract an icon for each option.
+     *
+     * - string → key on the option object (default "icon")
+     * - function → custom mapper
+     */
+    optionIcon?: string | ((item: MultiSelectOption) => React.ReactNode);
+    /**
+     * How to compute the React key for each option.
+     */
+    optionKey?: string | ((item: MultiSelectOption, index: number) => React.Key);
+    /**
+     * Enable inline search inside the dropdown.
+     */
+    searchable?: boolean;
+    /**
+     * Placeholder for the search input.
+     */
+    searchPlaceholder?: string;
+    /**
+     * Text to show when search yields no results.
+     */
+    emptySearchText?: React.ReactNode;
+    /**
+     * Placeholder when nothing is selected.
+     */
+    placeholder?: React.ReactNode;
+    /**
+     * Show a small clear button in the trigger when any value is selected.
+     */
+    clearable?: boolean;
+    /**
+     * Whether to show a "Select all" row.
+     */
+    showSelectAll?: boolean;
+    /**
+     * Label for the "Select all" row.
+     * Default: "Select all".
+     */
+    selectAllLabel?: React.ReactNode;
+    /**
+     * Where to place the "Select all" row.
+     * Default: "top".
+     */
+    selectAllPosition?: "top" | "bottom";
+    /**
+     * Custom renderer for each option row (checkbox + label).
+     */
+    renderOption?: (ctx: {
+        item: NormalizedMultiItem;
+        selected: boolean;
+        index: number;
+        option: React.ReactNode;
+    }) => React.ReactNode;
+    /**
+     * Custom renderer for the trigger summary.
+     */
+    renderValue?: (ctx: {
+        selectedItems: NormalizedMultiItem[];
+        placeholder?: React.ReactNode;
+    }) => React.ReactNode;
+    /**
+     * Custom renderer for the checkbox.
+     *
+     * - item: the option item (or null for "select all")
+     * - selected: whether this row is currently fully selected
+     * - indeterminate: partially selected (used for "select all")
+     * - isSelectAll: true for the "select all" row
+     */
+    renderCheckbox?: (ctx: {
+        item: NormalizedMultiItem | null;
+        selected: boolean;
+        indeterminate: boolean;
+        isSelectAll: boolean;
+    }) => React.ReactNode;
+    /**
+     * Max height (in px) for the dropdown list before scrolling.
+     * Default: 260.
+     */
+    maxListHeight?: number;
+    /**
+     * Wrapper class for the whole variant.
+     */
+    className?: string;
+    /**
+     * Extra classes for the trigger button.
+     */
+    triggerClassName?: string;
+    /**
+     * Extra classes for the popover content.
+     */
+    contentClassName?: string;
+    /**
+     * One or more icons displayed inside the trigger, on the left.
+     *
+     * If not provided and `icon` is set, that single icon
+     * is treated as `leadingIcons[0]`.
+     */
+    leadingIcons?: React.ReactNode[];
+    /**
+     * Icons displayed on the right side of the trigger,
+     * near the clear button / chevron area.
+     */
+    trailingIcons?: React.ReactNode[];
+    /**
+     * Convenience single-icon prop for the left side.
+     */
+    icon?: React.ReactNode;
+    /**
+     * Base gap between icons and text.
+     * Defaults to 4px-ish via `gap-1`.
+     */
+    iconGap?: number;
+    /**
+     * Extra spacing to apply between leading icons and the text.
+     */
+    leadingIconSpacing?: number;
+    /**
+     * Extra spacing to apply between trailing icons and the clear button.
+     */
+    trailingIconSpacing?: number;
+    /**
+     * Arbitrary React node rendered before the select (e.g. a button).
+     */
+    leadingControl?: React.ReactNode;
+    /**
+     * Arbitrary React node rendered after the select (e.g. a button).
+     */
+    trailingControl?: React.ReactNode;
+    /**
+     * Extra classes for the leading control wrapper.
+     */
+    leadingControlClassName?: string;
+    /**
+     * Extra classes for the trailing control wrapper.
+     */
+    trailingControlClassName?: string;
+    /**
+     * If true and there are controls, the select trigger + controls share
+     * a single visual box (borders, radius, focus states).
+     */
+    joinControls?: boolean;
+    /**
+     * When joinControls is true, whether the box styling extends over controls
+     * (true) or controls are visually separate (false).
+     */
+    extendBoxToControls?: boolean;
+}
+
+type SliderValue$1 = number | undefined;
+interface ShadcnSliderVariantProps extends Pick<VariantBaseProps<SliderValue$1>, "value" | "onValue" | "error" | "disabled" | "readOnly" | "size" | "density"> {
+    /**
+     * Minimum value for the slider.
+     * Default: 0
+     */
+    min?: number;
+    /**
+     * Maximum value for the slider.
+     * Default: 100
+     */
+    max?: number;
+    /**
+     * Step between values.
+     * Default: 1
+     */
+    step?: number;
+    /**
+     * Show the current value as text next to the slider.
+     * Default: true
+     */
+    showValue?: boolean;
+    /**
+     * Where to place the value label, relative to the slider.
+     * - "end"   → right of the slider (horizontal)
+     * - "start" → left of the slider
+     *
+     * Default: "end"
+     */
+    valuePlacement?: "start" | "end";
+    /**
+     * Custom formatter for the numeric value.
+     * If omitted, uses the raw number.
+     */
+    formatValue?: (value: SliderValue$1) => React.ReactNode;
+    /**
+     * Wrapper class for the entire slider field.
+     */
+    className?: string;
+    /**
+     * Extra classes for the Slider root.
+     */
+    sliderClassName?: string;
+    /**
+     * Extra classes for the value label.
+     */
+    valueClassName?: string;
+    /**
+     * One or more icons displayed inside the slider region, on the left.
+     *
+     * If not provided and `icon` is set, that single icon
+     * is treated as `leadingIcons[0]`.
+     */
+    leadingIcons?: React.ReactNode[];
+    /**
+     * Icons displayed on the right side of the slider region
+     * (before/after the value label depending on placement).
+     */
+    trailingIcons?: React.ReactNode[];
+    /**
+     * Convenience single-icon prop for the left side.
+     */
+    icon?: React.ReactNode;
+    /**
+     * Base gap between icons and slider/value.
+     * Defaults to 4px-ish via `gap-1`.
+     */
+    iconGap?: number;
+    /**
+     * Extra spacing to apply between leading icons and the slider track.
+     */
+    leadingIconSpacing?: number;
+    /**
+     * Extra spacing to apply between trailing icons and the value label.
+     */
+    trailingIconSpacing?: number;
+    /**
+     * Arbitrary React node rendered before the slider (e.g. a button).
+     */
+    leadingControl?: React.ReactNode;
+    /**
+     * Arbitrary React node rendered after the slider (e.g. a button).
+     */
+    trailingControl?: React.ReactNode;
+    /**
+     * Extra classes for the leading control wrapper.
+     */
+    leadingControlClassName?: string;
+    /**
+     * Extra classes for the trailing control wrapper.
+     */
+    trailingControlClassName?: string;
+    /**
+     * If true and there are controls, the slider + controls share
+     * a single visual box (borders, radius, focus states).
+     * Default: true (to match text/select behaviour).
+     */
+    joinControls?: boolean;
+    /**
+     * When joinControls is true, whether the box styling extends over controls
+     * (true) or controls are visually separate (false).
+     * Default: true.
+     */
+    extendBoxToControls?: boolean;
+    /**
+     * Built-in +/- controls around the slider.
+     *
+     * - "none"  → no built-in step buttons (default)
+     * - "boxed" → +/- inside the same frame as the slider
+     * - "edge"  → loose layout: "- [ slider ] +"
+     */
+    controlVariant?: "none" | "boxed" | "edge";
+    /**
+     * Step used when clicking the +/- controls.
+     * Defaults to `step`.
+     */
+    controlStep?: number;
+    /**
+     * Custom node for the decrement control. Default: "−".
+     */
+    controlDecrementIcon?: React.ReactNode;
+    /**
+     * Custom node for the increment control. Default: "+".
+     */
+    controlIncrementIcon?: React.ReactNode;
+}
+
+/**
+ * Slider value type:
+ * - `number | undefined` for now (single-value slider).
+ *   If/when you add range support, this can be widened to [number, number].
+ */
+type SliderValue = number | undefined;
+
+type KeyValueMap = Record<string, string>;
+interface KV {
+    key: string;
+    value: string;
+}
+interface ShadcnKeyValueVariantProps extends Pick<VariantBaseProps<KeyValueMap | undefined>, "value" | "onValue" | "error" | "disabled" | "readOnly" | "size" | "density"> {
+    min?: number;
+    max?: number;
+    minVisible?: number;
+    maxVisible?: number;
+    showAddButton?: boolean;
+    showMenuButton?: boolean;
+    placeholder?: React.ReactNode;
+    dialogTitle?: React.ReactNode;
+    keyLabel?: React.ReactNode;
+    valueLabel?: React.ReactNode;
+    submitLabel?: React.ReactNode;
+    moreLabel?: (count: number) => React.ReactNode;
+    emptyLabel?: React.ReactNode;
+    className?: string;
+    chipsClassName?: string;
+    chipClassName?: string;
+    renderChip?: (ctx: {
+        pair: KV;
+        index: number;
+        onEdit: () => void;
+        onRemove: () => void;
+        defaultChip: React.ReactNode;
+    }) => React.ReactNode;
+}
+
+/**
+ * Props for the generic "custom" variant.
+ *
+ * - The only special props we define are:
+ *   - component: the React component to render
+ *   - valueProp / changeProp / disabledProp / readOnlyProp / errorProp
+ *   - idProp / nameProp / placeholderProp
+ *   - mapValue / mapDetail (optional hooks)
+ *
+ * - All other props are treated as "component props" and forwarded
+ *   directly to the underlying component.
+ *
+ * The underlying component is expected to:
+ *   - accept the mapped `valueProp`
+ *   - call the mapped `changeProp` with the next value (first argument)
+ *   - optionally use disabled/readOnly/error/id/name/placeholder via the mapped names
+ */
+interface ShadcnCustomVariantProps<TValue = unknown> extends VariantBaseProps<TValue> {
+    /**
+     * The actual React component to render.
+     *
+     * Example:
+     *   component={MyToggle}
+     */
+    component: React.ComponentType<any>;
+    /**
+     * Prop name that carries the current value for the component.
+     * Default: "value".
+     */
+    valueProp?: string;
+    /**
+     * Prop name for the change handler that the component will call.
+     * Default: "onChange".
+     *
+     * The component is expected to call:
+     *   props[changeProp](nextValue, ...otherArgs?)
+     *
+     * The first argument is taken as the new value.
+     */
+    changeProp?: string;
+    /**
+     * Prop name for disabled state.
+     * Default: "disabled".
+     */
+    disabledProp?: string;
+    /**
+     * Prop name for read-only state.
+     * Default: "readOnly".
+     */
+    readOnlyProp?: string;
+    /**
+     * Prop name for passing error to the component (if it cares).
+     * If provided, we pass the `error` field as-is.
+     * Example values: "error", "isInvalid", "status".
+     */
+    errorProp?: string;
+    /**
+     * Prop name for the id attribute.
+     * Default: "id".
+     */
+    idProp?: string;
+    /**
+     * Prop name for the name attribute.
+     * Default: "name".
+     */
+    nameProp?: string;
+    /**
+     * Prop name for the placeholder attribute.
+     * Default: "placeholder".
+     */
+    placeholderProp?: string;
+    /**
+     * Optional transform for the raw next value before it hits the field.
+     *
+     * Receives the first argument that the component passes to the change
+     * handler, plus the full argument list for flexibility.
+     */
+    mapValue?: (raw: any, ...args: any[]) => TValue;
+    /**
+     * Optional builder for ChangeDetail, given the raw next value.
+     *
+     * If omitted, a default { source: "variant", raw } detail is used.
+     */
+    mapDetail?: (raw: any, ...args: any[]) => ChangeDetail;
+    /**
+     * Any other props are assumed to belong to the custom component.
+     */
+    [key: string]: unknown;
+}
+
+type TreeKey = string | number;
+type TreeValue = TreeKey | TreeKey[] | undefined;
+type TreeSelectOption = TreeKey | {
+    label?: React.ReactNode;
+    value?: TreeKey;
+    description?: React.ReactNode;
+    disabled?: boolean;
+    icon?: React.ReactNode;
+    children?: TreeSelectOption[];
+    [key: string]: any;
+};
+type NormalizedTreeItem = {
+    key: string;
+    value: TreeKey;
+    labelNode: React.ReactNode;
+    labelText: string;
+    description?: React.ReactNode;
+    disabled?: boolean;
+    icon?: React.ReactNode;
+    level: number;
+    parentValue?: TreeKey;
+    path: TreeKey[];
+    hasChildren: boolean;
+    children: NormalizedTreeItem[];
+    raw: TreeSelectOption;
+};
+interface ShadcnTreeSelectVariantProps extends Pick<VariantBaseProps<TreeValue>, "value" | "onValue" | "error" | "disabled" | "readOnly" | "size" | "density"> {
+    options?: TreeSelectOption[];
+    /**
+     * If true, allows multiple selection (checkboxes).
+     * If false, allows single selection (no checkboxes, closes on select).
+     * Default: true
+     */
+    multiple?: boolean;
+    autoCap?: boolean;
+    optionLabel?: string | ((item: TreeSelectOption) => React.ReactNode);
+    optionValue?: string | ((item: TreeSelectOption) => TreeKey);
+    optionDescription?: string | ((item: TreeSelectOption) => React.ReactNode);
+    optionDisabled?: string | ((item: TreeSelectOption) => boolean);
+    optionIcon?: string | ((item: TreeSelectOption) => React.ReactNode);
+    optionKey?: string | ((item: TreeSelectOption, index: number) => React.Key);
+    searchable?: boolean;
+    searchPlaceholder?: string;
+    emptyLabel?: React.ReactNode;
+    emptySearchText?: React.ReactNode;
+    clearable?: boolean;
+    placeholder?: React.ReactNode;
+    className?: string;
+    triggerClassName?: string;
+    contentClassName?: string;
+    renderOption?: (ctx: {
+        item: NormalizedTreeItem;
+        selected: boolean;
+        index: number;
+        option: React.ReactNode;
+    }) => React.ReactNode;
+    renderValue?: (ctx: {
+        selectedItems: NormalizedTreeItem[];
+        placeholder?: React.ReactNode;
+    }) => React.ReactNode;
+    expandAll?: boolean;
+    defaultExpandedValues?: TreeKey[];
+    leafOnly?: boolean;
+    leadingIcons?: React.ReactNode[];
+    trailingIcons?: React.ReactNode[];
+    icon?: React.ReactNode;
+    iconGap?: number;
+    leadingIconSpacing?: number;
+    trailingIconSpacing?: number;
+    leadingControl?: React.ReactNode;
+    trailingControl?: React.ReactNode;
+    leadingControlClassName?: string;
+    trailingControlClassName?: string;
+    joinControls?: boolean;
+    extendBoxToControls?: boolean;
+}
+
+type FileSourceKind = "native" | "path" | "url" | "custom";
+interface FileItem {
+    id: string;
+    kind: FileSourceKind;
+    file?: File;
+    path?: string;
+    url?: string;
+    name: string;
+    size?: number;
+    type?: string;
+    status?: "idle" | "loading" | "done" | "failed";
+    error?: string | null;
+    meta?: any;
+}
+type FileLike = File | string | {
+    id?: string;
+    file?: File;
+    path?: string;
+    url?: string;
+    name?: string;
+    size?: number;
+    type?: string;
+    status?: FileItem["status"];
+    error?: string | null;
+    meta?: any;
+    [key: string]: unknown;
+};
+type CustomFileLoaderResult = FileLike | FileLike[] | null | undefined;
+type CustomFileLoader = (ctx: {
+    multiple: boolean;
+    current: FileItem[];
+}) => Promise<CustomFileLoaderResult> | CustomFileLoaderResult;
+interface ShadcnFileVariantProps extends Pick<VariantBaseProps<FileItem[]>, "value" | "onValue" | "error" | "disabled" | "readOnly" | "size" | "density"> {
+    multiple?: boolean;
+    accept?: string | string[];
+    maxFiles?: number;
+    maxTotalSize?: number;
+    showDropArea?: boolean;
+    dropIcon?: React.ReactNode;
+    dropTitle?: React.ReactNode;
+    dropDescription?: React.ReactNode;
+    renderDropArea?: (ctx: {
+        openPicker: () => void;
+        isDragging: boolean;
+    }) => React.ReactNode;
+    renderFileItem?: (ctx: {
+        item: FileItem;
+        index: number;
+        selected: boolean;
+        toggleSelected: () => void;
+        remove: () => void;
+    }) => React.ReactNode;
+    showCheckboxes?: boolean;
+    onFilesAdded?: (added: FileItem[], detail: ChangeDetail<{
+        from: "input" | "drop" | "custom-loader";
+    }>) => void;
+    customLoader?: CustomFileLoader;
+    mergeMode?: "append" | "replace";
+    formatFileName?: (item: FileItem) => React.ReactNode;
+    formatFileSize?: (size?: number) => React.ReactNode;
+    placeholder?: string;
+    className?: string;
+    dropAreaClassName?: string;
+    listClassName?: string;
+    leadingIcons?: React.ReactNode[];
+    trailingIcons?: React.ReactNode[];
+    icon?: React.ReactNode;
+    leadingControl?: React.ReactNode;
+    trailingControl?: React.ReactNode;
+    leadingControlClassName?: string;
+    trailingControlClassName?: string;
+    joinControls?: boolean;
+    extendBoxToControls?: boolean;
+}
+
+type SelectPrimitive = string | number;
+type SelectOption = SelectPrimitive | {
+    label?: React.ReactNode;
+    value?: SelectPrimitive;
+    description?: React.ReactNode;
+    disabled?: boolean;
+    [key: string]: any;
+};
+type NormalizedSelectItem = {
+    key: string;
+    value: SelectPrimitive;
+    labelNode: React.ReactNode;
+    labelText: string;
+    description?: React.ReactNode;
+    disabled?: boolean;
+    icon?: React.ReactNode;
+    raw: SelectOption;
+};
+/**
+ * Shadcn-based Select variant.
+ */
+interface ShadcnSelectVariantProps extends Pick<VariantBaseProps<SelectPrimitive | undefined>, "value" | "onValue" | "error" | "disabled" | "readOnly" | "size" | "density"> {
+    /**
+     * Options for the select.
+     *
+     * You can pass:
+     * - primitives: ["ng", "gh", "ke"]
+     * - objects:    [{ label, value, ...extra }]
+     */
+    options?: SelectOption[];
+    /**
+     * Automatically capitalise the first letter of the label
+     * (when the resolved label is a string).
+     */
+    autoCap?: boolean;
+    /**
+     * How to read the label from each option.
+     *
+     * - string → key on the option object
+     * - function → custom mapper
+     * - omitted → tries `label`, else String(value)
+     */
+    optionLabel?: string | ((item: SelectOption) => React.ReactNode);
+    /**
+     * How to read the value from each option.
+     *
+     * - string → key on the option object
+     * - function → custom mapper
+     * - omitted → uses `value`, or `id`, or `key`, or index
+     */
+    optionValue?: string | ((item: SelectOption) => SelectPrimitive);
+    /**
+     * Optional description line under the label.
+     */
+    optionDescription?: string | ((item: SelectOption) => React.ReactNode);
+    /**
+     * How to determine if an option is disabled.
+     */
+    optionDisabled?: string | ((item: SelectOption) => boolean);
+    /**
+     * How to extract an icon for each option.
+     *
+     * - string → key on the option object (default "icon")
+     * - function → custom mapper
+     */
+    optionIcon?: string | ((item: SelectOption) => React.ReactNode);
+    /**
+     * How to compute the React key for each option.
+     */
+    optionKey?: string | ((item: SelectOption, index: number) => React.Key);
+    /**
+     * Enable inline search inside the dropdown.
+     */
+    searchable?: boolean;
+    /**
+     * Placeholder for the search input.
+     */
+    searchPlaceholder?: string;
+    /**
+     * Label shown when there are no options available at all.
+     *
+     * If omitted, falls back to `emptySearchText` or a default message.
+     */
+    emptyLabel?: React.ReactNode;
+    /**
+     * Text to show when search yields no results
+     * (but there *are* options in general).
+     */
+    emptySearchText?: React.ReactNode;
+    /**
+     * Show a small clear button in the trigger when a value is selected.
+     */
+    clearable?: boolean;
+    /**
+     * Placeholder when nothing is selected.
+     */
+    placeholder?: React.ReactNode;
+    /**
+     * Wrapper class for the whole variant.
+     */
+    className?: string;
+    /**
+     * Extra classes for the SelectTrigger.
+     */
+    triggerClassName?: string;
+    /**
+     * Extra classes for the SelectContent popover.
+     */
+    contentClassName?: string;
+    /**
+     * Custom renderer for each option row.
+     */
+    renderOption?: (ctx: {
+        item: NormalizedSelectItem;
+        selected: boolean;
+        index: number;
+        option: React.ReactNode;
+    }) => React.ReactNode;
+    /**
+     * Custom renderer for the trigger value.
+     */
+    renderValue?: (ctx: {
+        selectedItem: NormalizedSelectItem | null;
+        placeholder?: React.ReactNode;
+    }) => React.ReactNode;
+    /**
+     * One or more icons displayed inside the trigger, on the left.
+     *
+     * If not provided and `icon` is set, that single icon
+     * is treated as `leadingIcons[0]`.
+     */
+    leadingIcons?: React.ReactNode[];
+    /**
+     * Icons displayed on the right side of the trigger,
+     * near the clear button / chevron area.
+     */
+    trailingIcons?: React.ReactNode[];
+    /**
+     * Convenience single-icon prop for the left side.
+     */
+    icon?: React.ReactNode;
+    /**
+     * Base gap between icons and text.
+     * Defaults to 4px-ish via `gap-1`.
+     */
+    iconGap?: number;
+    /**
+     * Extra spacing to apply between leading icons and the text.
+     */
+    leadingIconSpacing?: number;
+    /**
+     * Extra spacing to apply between trailing icons and the clear button.
+     */
+    trailingIconSpacing?: number;
+    /**
+     * Arbitrary React node rendered before the select (e.g. a button).
+     */
+    leadingControl?: React.ReactNode;
+    /**
+     * Arbitrary React node rendered after the select (e.g. a button).
+     */
+    trailingControl?: React.ReactNode;
+    /**
+     * Extra classes for the leading control wrapper.
+     */
+    leadingControlClassName?: string;
+    /**
+     * Extra classes for the trailing control wrapper.
+     */
+    trailingControlClassName?: string;
+    /**
+     * If true and there are controls, the select trigger + controls share
+     * a single visual box (borders, radius, focus states).
+     */
+    joinControls?: boolean;
+    /**
+     * When joinControls is true, whether the box styling extends over controls
+     * (true) or controls are visually separate (false).
+     */
+    extendBoxToControls?: boolean;
+    /**
+     * Enable incremental rendering for large option lists.
+     *
+     * When true, only a page of options is rendered initially,
+     * and more are revealed as the user scrolls down.
+     */
+    virtualScroll?: boolean;
+    /**
+     * Number of options to render per "page" when virtualScroll is enabled.
+     * Default: 50.
+     */
+    virtualScrollPageSize?: number;
+    /**
+     * Distance from the bottom (in px) at which the next page loads.
+     * Default: 48px.
+     */
+    virtualScrollThreshold?: number;
+}
+
+type SelectVariantProps = ShadcnSelectVariantProps;
+
+/**
+ * Helper type for a single variant registry entry.
+ *
+ * Keeps the shape consistent and easy to extend via declaration merging.
+ */
+interface VariantEntry<TValue, TProps> {
+    value: TValue;
+    props: TProps;
+}
+/**
+ * Base type-level variant registry.
+ *
+ * This is the **canonical mapping** used by:
+ * - InputFieldProps<K>
+ * - VariantModule<K>
+ *
+ * Hosts & presets extend it via declaration merging:
+ *
+ *   declare module "@/schema/variant" {
+ *     interface Variants {
+ *       select: VariantEntry<SelectValuePublic, SelectPropsPublic>;
+ *     }
+ *   }
+ */
+interface Variants<H = unknown> {
+    /**
+     * Built-in "text" variant.
+     *
+     * Shadcn-based implementation lives in presets/shadcn-variants/text.tsx
+     */
+    text: VariantEntry<string | undefined, ShadcnTextVariantProps>;
+    /**
+     * Example scalar variant.
+     *
+     * You can repurpose this for "custom" or drop it later.
+     */
+    number: VariantEntry<number | undefined, ShadcnNumberVariantProps>;
+    phone: VariantEntry<string | number | undefined, ShadcnPhoneVariantProps>;
+    color: VariantEntry<string | undefined, ShadcnColorVariantProps>;
+    password: VariantEntry<string | undefined, ShadcnPasswordVariantProps>;
+    date: VariantEntry<string | undefined, ShadcnDateVariantProps>;
+    chips: VariantEntry<string[] | undefined, ShadcnChipsVariantProps>;
+    textarea: VariantEntry<string | undefined, ShadcnTextareaVariantProps>;
+    toggle: VariantEntry<boolean | undefined, ShadcnToggleVariantProps>;
+    radio: VariantEntry<unknown | undefined, ShadcnRadioVariantProps<unknown, RadioItem<unknown>>>;
+    checkbox: VariantEntry<CheckboxVariantPublicValue, ShadcnCheckboxVariantPublicProps>;
+    select: VariantEntry<string | number | undefined, SelectVariantProps>;
+    'multi-select': VariantEntry<Array<string | number> | undefined, ShadcnMultiSelectVariantProps>;
+    slider: VariantEntry<SliderValue, ShadcnSliderVariantProps>;
+    keyvalue: VariantEntry<KeyValueMap | undefined, ShadcnKeyValueVariantProps>;
+    custom: VariantEntry<unknown | undefined, ShadcnCustomVariantProps>;
+    treeselect: VariantEntry<string | number | undefined, ShadcnTreeSelectVariantProps>;
+    file: VariantEntry<FileLike, ShadcnFileVariantProps>;
+}
+/**
+ * Union of all variant keys.
+ */
+type VariantKey = keyof Variants;
+/**
+ * Value type for a given variant key.
+ *
+ * Strongly drives autocomplete:
+ * - InputFieldProps<"text"> → TValue = string | undefined
+ */
+type VariantValueFor<K extends VariantKey, H = unknown> = Variants<H>[K]["value"];
+/**
+ * Props type for a given variant key.
+ *
+ * Strongly drives autocomplete:
+ * - InputFieldProps<"text"> → props = TextVariantProps
+ */
+type VariantPropsFor<K extends VariantKey, H = unknown> = Variants<H>[K]["props"];
+/**
+ * Signature for variant-level validation functions.
+ */
+type VariantValidateFn<TValue, TProps> = (value: TValue | undefined, ctx: {
+    required?: boolean;
+    props: TProps;
+    field: Field;
+    form: CoreContext<Dict>;
+}) => ValidateResult;
+/**
+ * Layout defaults for a variant.
+ *
+ * This extends FieldLayoutConfig, so it automatically includes:
+ * - placement props (labelPlacement, descriptionPlacement, etc.)
+ * - layout hints (inline, fullWidth, defaultSize/density)
+ * - layout graph (relativeRoots, ordering)
+ */
+interface VariantLayoutDefaults extends FieldLayoutConfig {
+}
+/**
+ * Runtime module definition for a variant.
+ *
+ * IMPORTANT:
+ * - This is **tied directly** to the registry:
+ *     TValue = VariantValueFor<K>
+ *     TProps = VariantPropsFor<K>
+ *
+ *   So if you change the entry in `Variants`, both:
+ *     - <InputField variant="..." /> props
+ *     - The Variant component in the module
+ *   will see the updated types and IntelliSense matches everywhere.
+ *
+ * - For complex variants (select/multiselect):
+ *   you model the relationship via unions in `Variants["select"]`.
+ */
+interface VariantModule<K extends VariantKey = VariantKey> {
+    /**
+     * Unique key for this variant, e.g. "text", "number", "select".
+     */
+    variant: K;
+    /**
+     * React component that renders the control.
+     *
+     * It receives:
+     * - VariantBaseProps<VariantValueFor<K>>
+     * - VariantPropsFor<K>
+     */
+    Variant: ComponentType<VariantBaseProps<VariantValueFor<K>> & VariantPropsFor<K>>;
+    /**
+     * Optional validation logic specific to this variant.
+     */
+    validate?: VariantValidateFn<VariantValueFor<K>, VariantPropsFor<K>>;
+    /**
+     * Optional default layout hints for this variant.
+     */
+    defaults?: {
+        layout?: VariantLayoutDefaults;
+    };
+    /**
+     * Optional smart layout resolver.
+     *
+     * Must respect host overrides.
+     */
+    resolveLayout?: LayoutResolver<VariantPropsFor<K>>;
+    /**
+     * Optional metadata, useful for docs/inspectors.
+     */
+    meta?: {
+        label?: string;
+        description?: string;
+        tags?: string[];
+    };
+}
+/**
+ * Convenience alias when you want to be explicit:
+ *
+ *   const textModule: VariantModuleFor<"text"> = { ... }
+ */
+type VariantModuleFor<K extends VariantKey> = VariantModule<K>;
+
+type Props<V extends Dict, S extends z.ZodType | undefined, K extends AdapterKey> = CoreProps<V, S, K> & {
+    children?: React.ReactNode;
+};
+/**
+ * CoreProvider: owns the form/core runtime state and implements CoreContext.
+ *
+ * - Tracks all inputs in a single store (inputsRef)
+ * - Supports:
+ *   - named inputs via `name`
+ *   - bound inputs via `bindId`
+ *   - grouped inputs via `groupId`
+ * - Manages errors + uncaught messages
+ * - Builds values snapshots (including bucket values)
+ * - Orchestrates submission via the adapter registry
+ */
+declare function CoreProvider<V extends Dict, S extends z.ZodType | undefined, K extends AdapterKey = "local">(props: Props<V, S, K>): react_jsx_runtime.JSX.Element;
+
+interface CoreRootProps extends React.FormHTMLAttributes<HTMLFormElement> {
+    /**
+     * If true, the global ErrorStrip will not be rendered automatically.
+     */
+    noErrorStrip?: boolean;
+    /**
+     * Optional hook invoked after CoreRoot orchestrates the submit.
+     *
+     * - The native event is already `preventDefault()`-ed.
+     * - The adapter flow is triggered via `form.go(...)`.
+     * - Use this to tap into submit without breaking the core.
+     */
+    onSubmitForm?(event: React.FormEvent<HTMLFormElement>, form: CoreContext<Dict>): void | Promise<void>;
+}
+/**
+ * CoreRoot: actual <form> element wired to the core runtime.
+ *
+ * Responsibilities:
+ * - Own the native submit event and prevent full-page navigation.
+ * - Delegate submit orchestration to form.go().
+ * - Optionally render the global ErrorStrip at the top.
+ */
+declare function CoreRoot(props: CoreRootProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Combined provider + form-root wrapper.
+ *
+ * Usage:
+ *   <CoreShell adapter="local" schema={schema} formProps={{ className: "space-y-4" }}>
+ *     {...fields + buttons...}
+ *   </CoreShell>
+ */
+interface CoreShellProps<V extends Dict = Dict, S extends z.ZodType | undefined = z.ZodType | undefined, K extends AdapterKey = "local"> extends CoreProps<V, S, K> {
+    /**
+     * Props passed directly to the underlying <form> element via CoreRoot.
+     */
+    formProps?: CoreRootProps;
+    children?: React.ReactNode;
+}
+declare function CoreShell<V extends Dict, S extends z.ZodType | undefined, K extends AdapterKey = "local">(props: CoreShellProps<V, S, K>): react_jsx_runtime.JSX.Element;
+
+interface UseButtonOptions {
+    /**
+     * Logical name of the button.
+     *
+     * Used by the core to:
+     * - mark this as the "active" button before submit
+     * - toggle loading/disabled specifically for this button
+     */
+    name: string;
+    /**
+     * If true, clicking this button should trigger a submit:
+     *
+     * - form.setActiveButton(name)
+     * - form.go()
+     */
+    submit?: boolean;
+    /**
+     * Initial disabled state.
+     */
+    disabled?: boolean;
+    /**
+     * Optional click handler.
+     *
+     * This runs *in addition to* the submit behavior (if `submit` is true).
+     * You can call `event.preventDefault()` to prevent the auto-submit.
+     */
+    onClick?(event: React.MouseEvent<HTMLButtonElement>, form: CoreContext<Dict>): void | Promise<void>;
+}
+interface UseButtonReturn {
+    /**
+     * Current loading state, controlled by the core (via adapters) and
+     * optionally by the host via setLoading.
+     */
+    loading: boolean;
+    setLoading(loading: boolean): void;
+    /**
+     * Current disabled state.
+     */
+    disabled: boolean;
+    setDisabled(disabled: boolean): void;
+    /**
+     * Ref for the underlying <button>.
+     */
+    ref: React.RefObject<HTMLButtonElement>;
+    /**
+     * Click handler wired to the core.
+     */
+    onClick(event: React.MouseEvent<HTMLButtonElement>): void;
+    /**
+     * Convenience bundle for spreading onto a <button>.
+     *
+     * Example:
+     *   const btn = useButton({ name: "save", submit: true });
+     *   return <button {...btn.buttonProps}>Save</button>;
+     */
+    buttonProps: {
+        ref: React.RefObject<HTMLButtonElement>;
+        disabled: boolean;
+        "data-loading"?: "true" | "false";
+        onClick(event: React.MouseEvent<HTMLButtonElement>): void;
+    };
+}
+/**
+ * useButton
+ *
+ * - Registers a ButtonRef with the core.
+ * - Cooperates with setActiveButton + adapter-based submit.
+ * - Handles loading/disabled toggling via the core's callbacks.
+ */
+declare function useButton(options: UseButtonOptions): UseButtonReturn;
+
+/**
+ * Convenience alias for useCoreContext.
+ *
+ * This mirrors the legacy useForm hook: you get the full CoreContext,
+ * and can call core.values(), core.submit(), core.go(), etc.
+ */
+declare function useCore<V extends Dict = Dict>(): CoreContext<V>;
+
+/**
+ * Typed hook to access the current core/form context.
+ *
+ * Must be used inside a <CoreProvider>. If no provider is found,
+ * this will throw to make misuse obvious.
+ */
+declare function useCoreContext<V extends Dict = Dict>(): CoreContext<V>;
+
+type UseFieldValidate<T> = (value: T, report: boolean) => boolean | string;
+interface UseFieldOptions<T = unknown> {
+    /**
+     * Primary field name.
+     *
+     * This is the key that will show up in the values snapshot and
+     * error bags (unless mapped via `shared` or `alias`).
+     */
+    name?: string;
+    /**
+     * Optional internal binding identifier.
+     *
+     * Used by the bound helpers (observeBoundField, waitForBoundField)
+     * and the binder registry.
+     */
+    bindId?: string;
+    /**
+     * Optional external binding key – a semantic identifier for this
+     * field’s binding group.
+     *
+     * Example:
+     *   bind="shipping"
+     */
+    bind?: string;
+    /**
+     * Shared key for nested grouping, e.g:
+     *
+     *   shared="profile", name="first_name"
+     *   → values.profile.first_name
+     */
+    shared?: string;
+    /**
+     * Optional grouping identifier used to group related controls
+     * (e.g. radio groups, segmented inputs).
+     */
+    groupId?: string;
+    /**
+     * Optional alias for error / mapping purposes.
+     *
+     * Example:
+     *   alias="email" but name="contact.email"
+     */
+    alias?: string;
+    /**
+     * Marks this field as the "main" one in a group.
+     */
+    main?: boolean;
+    /**
+     * If true, this field is ignored by snapshot / some validation
+     * flows, but may still exist in the registry.
+     */
+    ignore?: boolean;
+    /**
+     * Whether the field is required.
+     */
+    required?: boolean;
+    /**
+     * Initial/default value for this field.
+     */
+    defaultValue?: T;
+    /**
+     * Initial disabled flag.
+     */
+    disabled?: boolean;
+    /**
+     * Initial readOnly flag.
+     */
+    readOnly?: boolean;
+    /**
+     * Custom validation hook.
+     *
+     * Return:
+     * - `true`       → valid
+     * - `false`      → invalid (no message)
+     * - `"message"`  → invalid with explicit message
+     */
+    validate?: UseFieldValidate<T>;
+    /**
+     * Optional projector to derive an "original" value from the
+     * initial default.
+     */
+    getOriginalValue?(value: T | undefined): unknown;
+    /**
+     * Local change hook for the field.
+     *
+     * This is in addition to the form-level `onChange`.
+     */
+    onValueChange?(next: T, prev: T, variant: string): void;
+}
+interface UseFieldReturn<T = unknown> {
+    /** Ref to the underlying DOM element */
+    ref: React.RefObject<HTMLElement>;
+    key: string;
+    /** Current value */
+    value: T | undefined;
+    setValue(next: T | undefined, variant?: string): void;
+    /** Current error message */
+    error: string;
+    setError(message: string): void;
+    /** Async-loading flag (e.g. remote validation) */
+    loading: boolean;
+    setLoading(loading: boolean): void;
+    /** Required flag */
+    required: boolean;
+    setRequired(required: boolean): void;
+    /** Disabled flag */
+    disabled: boolean;
+    setDisabled(disabled: boolean): void;
+    /** Readonly flag */
+    readOnly: boolean;
+    setReadOnly(readOnly: boolean): void;
+    /** Metadata / wiring */
+    name: string;
+    bindId: string;
+    bind?: string;
+    shared?: string;
+    groupId?: string;
+    alias?: string;
+    main?: boolean;
+    ignore?: boolean;
+    /** Snapshots */
+    readonly defaultValue: T | undefined;
+    readonly originalValue: unknown;
+    /** Owning core context */
+    form: CoreContext<Dict>;
+    /** Run validation (optionally reporting errors) */
+    validate(report?: boolean): boolean | undefined;
+}
+/**
+ * Strict field hook.
+ *
+ * - Registers the field with the core provider / registry.
+ * - Exposes value/error/loading and lifecycle helpers.
+ * - Wires into:
+ *   - core-level `onChange`
+ *   - `controlButton()` dirty logic
+ */
+declare function useField<T = unknown>(options: UseFieldOptions<T>): UseFieldReturn<T>;
+
+/**
+ * Optional variant of `useField`.
+ *
+ * - If there is a CoreProvider, behaves like `useField`.
+ * - If not, it becomes a self-managed field (value/error/loading/etc).
+ */
+declare function useOptionalField<T = unknown>(options: UseFieldOptions<T>): UseFieldReturn<T>;
+
+type ErrorBag = Record<string, string | string[] | undefined | null>;
+type ErrorBagMapResult = {
+    /** Field-specific errors keyed by field name. */
+    fieldErrors: Record<string, string>;
+    /** Errors that could not be mapped to a specific field. */
+    uncaught: string[];
+};
+/**
+ * Map a generic "error bag" object into field errors + uncaught messages.
+ *
+ * Typical input:
+ *   {
+ *     name: "Name is required",
+ *     email: ["Email is invalid"],
+ *     message: "Something went wrong" // global
+ *   }
+ *
+ * Heuristics:
+ * - Keys like "message", "error", "_", "global" → treated as global/uncaught.
+ * - Everything else → treated as a field error.
+ * - Array values are joined with "\n".
+ */
+declare function mapErrorBag(bag: ErrorBag): ErrorBagMapResult;
+
+type ZodErrorMapResult = {
+    /** Field-specific errors keyed by field name. */
+    fieldErrors: Record<string, string>;
+    /** Errors that could not be mapped to a specific field. */
+    uncaught: string[];
+};
+/**
+ * Map a ZodError into field-specific errors + uncaught messages.
+ *
+ * Heuristics:
+ * - If issue.path[0] is a string → treated as a field name.
+ * - Otherwise → message is pushed into `uncaught`.
+ *
+ * If a field has multiple issues, messages are joined with `\n`.
+ */
+declare function mapZodError(error: $ZodError): ZodErrorMapResult;
+
+interface ErrorStripProps extends React.HTMLAttributes<HTMLElement> {
+    /**
+     * Optional explicit form context. If omitted, the strip will use
+     * the nearest CoreProvider via useCore().
+     */
+    form?: CoreContext<Dict>;
+    /**
+     * Optional explicit messages. If provided, these are used instead of
+     * form.getUncaught().
+     */
+    messages?: readonly string[];
+    /**
+     * Custom renderer for each message.
+     */
+    renderMessage?: (message: string, index: number) => React.ReactNode;
+    /**
+     * Wrapper element type. Defaults to "div".
+     */
+    as?: React.ElementType;
+    /**
+     * Props forwarded to the inner <ul> element.
+     */
+    listProps?: React.HTMLAttributes<HTMLUListElement>;
+}
+/**
+ * Simple global/uncaught error renderer.
+ *
+ * Reads messages from `form.getUncaught()` (unless `messages` is provided)
+ * and renders them as a list.
+ */
+declare function ErrorStrip(props: ErrorStripProps): react_jsx_runtime.JSX.Element | null;
+
+/**
+ * Core, variant-agnostic props for InputField.
+ *
+ * @template TValue Logical value type for this field. Will be refined by
+ *                  variant typing (VariantValueFor<K>).
+ */
+interface InputFieldBaseProps<TValue = unknown> {
+    name?: string;
+    bind?: string;
+    groupId?: string;
+    shared?: string;
+    ignore?: boolean;
+    alias?: string;
+    main?: boolean;
+    tags?: FieldTag[];
+    contain?: boolean;
+    label?: React.ReactNode;
+    sublabel?: React.ReactNode;
+    description?: React.ReactNode;
+    helpText?: React.ReactNode;
+    /**
+     * Optional explicit error text to display.
+     *
+     * This is *visual* error copy. The actual validation state still
+     * lives in field.error / schema / onValidate.
+     */
+    errorText?: React.ReactNode;
+    /**
+     * Placement hints for label / sublabel / description / helpText / errorText.
+     *
+     * These are purely layout hints; actual behaviour is implemented
+     * by the preset / host component.
+     */
+    labelPlacement?: LabelPlacement;
+    sublabelPlacement?: SublabelPlacement;
+    descriptionPlacement?: DescriptionPlacement;
+    helpTextPlacement?: HelpTextPlacement;
+    errorTextPlacement?: ErrorTextPlacement;
+    tagPlacement?: SlotPlacement;
+    required?: boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+    size?: FieldSize;
+    density?: FieldDensity;
+    inline?: boolean;
+    fullWidth?: boolean;
+    onValidate?(value: TValue | undefined, field: Field, form: CoreContext<Dict>): ValidateResult;
+    /**
+     * Per-field change hook at the InputField level.
+     *
+     * - `value` is what the variant is trying to set.
+     * - `detail` comes from the variant (`ChangeDetail`).
+     * - If you return `undefined`, the original value is used.
+     * - If you return *anything else*, that is what will be stored
+     *   in the core (and emitted to the form).
+     */
+    onChange?(e: {
+        value: TValue | undefined;
+        preventDefault(): void;
+        event?: React.SyntheticEvent;
+        readonly isDefaultPrevented?: boolean;
+        readonly detail: ChangeDetail;
+    }): void;
+}
+/**
+ * Public props for <InputField />.
+ *
+ * - `variant` selects the variant module.
+ * - All variant-specific props are merged directly into the field props
+ *   via `VariantPropsFor<K>`.
+ *
+ * NOTE: this is a type alias (not an interface) so we can safely intersect
+ * unions coming from VariantPropsFor<K> / VariantValueFor<K>.
+ */
+type InputFieldProps<K extends VariantKey = VariantKey, H = unknown> = InputFieldBaseProps<VariantValueFor<K, H>> & VariantPropsFor<K, H> & Omit<React.HTMLAttributes<HTMLDivElement>, 'onChange'> & {
+    variant: K;
+    classes?: Partial<InputFieldClassNames>;
+};
+interface InputFieldClassNames {
+    root?: string;
+    labelRow?: string;
+    inlineRow?: string;
+    label?: string;
+    sublabel?: string;
+    description?: string;
+    helpText?: string;
+    error?: string;
+    group?: string;
+    content?: string;
+    variant?: string;
+    inlineInputColumn?: string;
+    inlineLabelColumn?: string;
+    required?: string;
+    tag?: string;
+}
+interface FieldTag {
+    label: React.ReactNode;
+    icon?: React.ReactNode;
+    className?: string;
+    color?: string;
+    bgColor?: string;
+}
+
+/**
+ * Public InputField component.
+ *
+ * - Uses `useField` to register a Field and manage value/error/loading.
+ * - Delegates rendering to the chosen variant's `Variant` component.
+ * - Uses Shadcn's Field primitives for structure.
+ * - Lets variants influence layout via defaults + optional resolveLayout().
+ * - Uses a layout graph (buildLayoutGraph) + getSlotsFor().render(...) to
+ *   position helpers (sublabel, description, helpText, error, tags) relative to
+ *   "label" vs "input" roots without empty wrapper divs.
+ */
+declare function InputField<K extends VariantKey = VariantKey>(props: InputFieldProps<K>): react_jsx_runtime.JSX.Element | null;
+
+/**
+ * Register (or overwrite) a variant module.
+ *
+ * Typically called from presets, e.g.:
+ *
+ *   registerVariant(textVariant);
+ *   registerVariant(numberVariant);
+ */
+declare function registerVariant<K extends VariantKey>(module: VariantModule<K>): void;
+/**
+ * Look up a variant module by key.
+ */
+declare function getVariant<K extends VariantKey>(key: K): VariantModule<K> | undefined;
+/**
+ * List all registered variant modules.
+ */
+declare function listVariants(): VariantModule<VariantKey>[];
+
+/**
+ * Register all core/built-in variants.
+ *
+ * Hosts can call this once at bootstrap:
+ *
+ *   import { registerCoreVariants } from "@timeax/form-palette/variants";
+ *   registerCoreVariants();
+ */
+declare function registerCoreVariants(): void;
+
+interface InputMaskChangeEvent {
+    originalEvent: React.SyntheticEvent<HTMLInputElement> | Event | undefined;
+    value: string;
+    stopPropagation(): void;
+    preventDefault(): void;
+    target: {
+        name?: string;
+        id?: string;
+        value: string;
+    };
+}
+interface InputMaskCompleteEvent {
+    originalEvent: React.SyntheticEvent<HTMLInputElement> | Event;
+    value: string;
+}
+interface InputMaskRef {
+    focus(): void;
+    getElement(): HTMLInputElement | null;
+}
+interface InputMaskProps$1 extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "onChange" | "value" | "defaultValue"> {
+    mask: string | null;
+    autoClear?: boolean;
+    autoFocus?: boolean;
+    invalid?: boolean;
+    unmask?: boolean;
+    slotChar?: string;
+    'data-slot'?: string;
+    value?: string | null;
+    onChange?: (e: InputMaskChangeEvent) => void;
+    onComplete?: (e: InputMaskCompleteEvent) => void;
+}
+declare const InputMask: React.MemoExoticComponent<React.ForwardRefExoticComponent<InputMaskProps$1 & React.RefAttributes<InputMaskRef>>>;
+
+type MaskMode = "raw" | "masked";
+interface InputMaskProps {
+    mask?: string;
+    maskDefinitions?: Record<string, RegExp>;
+    slotChar?: string;
+    autoClear?: boolean;
+    unmask?: MaskMode | boolean;
+    maskInsertMode?: "stream" | "caret";
+}
+interface InputAffixProps {
+    prefix?: string;
+    suffix?: string;
+    /**
+     * If true (default), we assume the model value does NOT contain the prefix
+     * and we only add it visually at render time.
+     */
+    stripPrefix?: boolean;
+    /**
+     * If true (default), we assume the model value does NOT contain the suffix
+     * and we only add it visually at render time.
+     */
+    stripSuffix?: boolean;
+}
+interface InputIconControlProps {
+    leadingIcons?: React.ReactNode[];
+    trailingIcons?: React.ReactNode[];
+    icon?: React.ReactNode;
+    iconGap?: number;
+    leadingIconSpacing?: number;
+    trailingIconSpacing?: number;
+    leadingControl?: React.ReactNode;
+    trailingControl?: React.ReactNode;
+    leadingControlClassName?: string;
+    trailingControlClassName?: string;
+    joinControls?: boolean;
+    extendBoxToControls?: boolean;
+    px?: number;
+    py?: number;
+    ps?: number;
+    pe?: number;
+    pb?: number;
+    inputClassName?: string;
+}
+interface InputSizeProps {
+    size?: "sm" | "md" | "lg" | (string & {});
+    density?: "compact" | "normal" | "relaxed" | "dense" | "loose" | (string & {});
+}
+type InputKeyFilter = string | RegExp | ((nextValue: string, ctx: {
+    event: any;
+    currentValue: string;
+    input: HTMLInputElement;
+}) => boolean);
+interface InputKeyFilterProps {
+    /**
+     * Filter that constrains what can be typed / pasted.
+     *
+     * - string preset: "int" | "num" | "money" | "hex" | "alpha" | "alphanum" | "email"
+     * - string pattern: converted to new RegExp(pattern)
+     * - RegExp: used directly
+     * - function: custom validator
+     */
+    keyFilter?: InputKeyFilter;
+    /**
+     * Which keyboard event to hook for filtering:
+     * - "keydown"
+     * - "keypress" (closest to PrimeReact default)
+     * - "beforeinput"
+     *
+     * Default: "keypress"
+     */
+    keyFilterOn?: "keydown" | "keypress" | "beforeinput";
+    /**
+     * Whether to apply keyFilter to paste events.
+     * Default: true
+     */
+    keyFilterOnPaste?: boolean;
+}
+interface InputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "size">, InputMaskProps, InputAffixProps, InputIconControlProps, InputSizeProps, InputKeyFilterProps {
+}
+declare const Input: React.ForwardRefExoticComponent<InputProps & React.RefAttributes<HTMLInputElement>>;
+
+export { AdapterKey, AdapterResult, AdapterSubmit, type BaseProps$7 as BaseProps, type ButtonRef, type CoreContext, type CoreProps, CoreProvider, type CoreShellProps, type DescriptionPlacement, type Dict, type EffectiveFieldLayout, type ErrorBag, type ErrorBagMapResult, ErrorStrip, type ErrorStripProps, type ErrorTextPlacement, type Field, type FieldLayoutConfig, type FieldOrdering, type FieldRootId, type FieldRoots, type FieldSlotId, type FieldSlots, CoreShell as Form, type FormProps, CoreRoot as FormRoot, type HelpTextPlacement, type InferFromSchema, Input, InputField, type InputFieldBaseProps, type InputFieldProps, InputMask, InputNumber, type InputStore, type LabelPlacement, type LayoutResolveContext, type LayoutResolver, Method, type RelativeRootsMap, type SlotPlacement, type SublabelPlacement, type SubmitEvent, Textarea, type UseButtonOptions, type UseButtonReturn, type UseFieldOptions, type UseFieldReturn, type UseFieldValidate, type ValidateResult, type ValuesResult, type VariantEntry, type VariantKey, type VariantLayoutDefaults, type VariantModule, type VariantModuleFor, type VariantPropsFor, type VariantValidateFn, type VariantValueFor, type Variants, type ZodErrorMapResult, getVariant, listVariants, mapErrorBag, mapZodError, registerCoreVariants, registerVariant, useButton, useCore, useCoreContext, useField, useOptionalField };