orynn 0.1.0 → 0.5.0

package/dist/index.d.cts

@@ -1,24 +1,288 @@
 import * as react from 'react';
-import { ComponentType, SyntheticEvent, SelectHTMLAttributes, ReactNode, ChangeEvent, InputHTMLAttributes, FormEvent } from 'react';
+import { ReactNode, HTMLAttributes, InputHTMLAttributes, ChangeEvent, ComponentType, SyntheticEvent, TextareaHTMLAttributes, FormEvent, FormHTMLAttributes, ComponentProps, ComponentPropsWithoutRef, MouseEvent, CSSProperties } from 'react';
+import { Label as Label$1, Separator as Separator$1, Switch as Switch$1, Tabs as Tabs$1, Dialog as Dialog$1, Popover as Popover$1, Tooltip as Tooltip$1, DropdownMenu as DropdownMenu$1 } from 'radix-ui';
 
+type ControlSize = "sm" | "md" | "lg";
+type ControlVariant = "outline" | "filled" | "flushed" | "unstyled";
+type ControlRadius = "none" | "sm" | "md" | "lg" | "pill";
+interface FieldBoxOwnProps {
+    size?: ControlSize;
+    variant?: ControlVariant;
+    radius?: ControlRadius;
+    disabled?: boolean;
+    invalid?: boolean;
+    /** Success / valid visual state. */
+    valid?: boolean;
+    /** Controlled focus ring. Omit to auto-track via focus-within. */
+    focused?: boolean;
+    /** Whether the floating label is raised (usually focused || has value). */
+    active?: boolean;
+    /** Rotates a chevron marked `.orynn-select__chevron`. */
+    open?: boolean;
+    /** Floating label node (usually a `<label class="orynn-box__label">`). */
+    floatingLabel?: ReactNode;
+    left?: ReactNode;
+    right?: ReactNode;
+    /** Segment glued to the start, *outside* the border (e.g. `https://`). */
+    addonBefore?: ReactNode;
+    /** Segment glued to the end, *outside* the border (e.g. `.com`). */
+    addonAfter?: ReactNode;
+    /** Adds `.orynn-box--textarea` sizing. */
+    textarea?: boolean;
+}
+interface FieldBoxProps extends FieldBoxOwnProps, Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    children: ReactNode;
+}
+declare const FieldBox: react.ForwardRefExoticComponent<FieldBoxProps & react.RefAttributes<HTMLDivElement>>;
+
+/** One message, several messages, or nothing. */
+type Feedback = string | string[] | undefined;
+/**
+ * Props shared by every labelled control (Input, Textarea, NumberField,
+ * Dropdown, DatePicker, …). Individual controls add their own on top.
+ */
+interface BaseControlProps {
+    label?: ReactNode;
+    /** Help text under the label. */
+    description?: ReactNode;
+    /** Error message(s). Presence puts the control in its invalid state. */
+    error?: Feedback;
+    /** Success state — `true`, or a confirmation message to show. */
+    success?: string | boolean;
+    required?: boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+    size?: ControlSize;
+    variant?: ControlVariant;
+    radius?: ControlRadius;
+    /** Render the label floating inside the control border. */
+    floatingLabel?: boolean;
+    /** Content before the field (icon, text). */
+    startContent?: ReactNode;
+    /** Content after the field (icon, text). */
+    endContent?: ReactNode;
+    /** Show an ✕ button to clear the value. */
+    clearable?: boolean;
+    onClear?: () => void;
+    /** Show a spinner in the end slot. */
+    loading?: boolean;
+    id?: string;
+    name?: string;
+    className?: string;
+}
+
+type NativeCheckbox = Omit<InputHTMLAttributes<HTMLInputElement>, "type" | "checked" | "defaultChecked" | "onChange" | "size" | "value">;
+interface CheckboxProps extends NativeCheckbox {
+    label?: ReactNode;
+    description?: ReactNode;
+    checked?: boolean;
+    defaultChecked?: boolean;
+    indeterminate?: boolean;
+    onChange?: (checked: boolean, event: ChangeEvent<HTMLInputElement>) => void;
+    /** Value used when inside a `<CheckboxGroup>`. */
+    value?: string;
+    disabled?: boolean;
+    readOnly?: boolean;
+    required?: boolean;
+    invalid?: boolean;
+    size?: ControlSize;
+    /** `"filled"` (default) paints the box on check; `"outline"` keeps it hollow. */
+    variant?: "filled" | "outline";
+    /** Put the label before the box. */
+    labelPlacement?: "end" | "start";
+    /** Bordered selectable card. */
+    card?: boolean;
+    /** Custom checked / indeterminate glyphs. */
+    icon?: ReactNode;
+    indeterminateIcon?: ReactNode;
+    className?: string;
+}
+declare const Checkbox: react.ForwardRefExoticComponent<CheckboxProps & react.RefAttributes<HTMLInputElement>>;
+
+interface CheckboxOption {
+    label: ReactNode;
+    value: string;
+    description?: ReactNode;
+    /** Leading icon shown before the label. */
+    icon?: ReactNode;
+    disabled?: boolean;
+}
+interface CheckboxGroupProps {
+    label?: ReactNode;
+    description?: ReactNode;
+    error?: Feedback;
+    success?: string | boolean;
+    required?: boolean;
+    disabled?: boolean;
+    name?: string;
+    size?: ControlSize;
+    value?: string[];
+    defaultValue?: string[];
+    onChange?: (value: string[]) => void;
+    orientation?: "vertical" | "horizontal";
+    /** Lay the options out in an N-column grid. */
+    columns?: number;
+    /** Minimum selections (blocks unchecking below it). */
+    min?: number;
+    /** Maximum selections (blocks checking above it). */
+    max?: number;
+    /** Show a "select all" checkbox above the options. */
+    showSelectAll?: boolean;
+    selectAllLabel?: ReactNode;
+    /** Convenience: render items from data instead of children. */
+    options?: CheckboxOption[];
+    children?: ReactNode;
+    className?: string;
+    id?: string;
+}
+declare function CheckboxGroup(props: CheckboxGroupProps): react.JSX.Element;
+
+/** A `{ start, end }` selection. Either side may be `null` while picking. */
+interface DateRange {
+    start: Date | null;
+    end: Date | null;
+}
+
+type CalendarView = "day" | "month" | "year";
+type CalendarPrecision = "day" | "month" | "year";
+
+/** `{ start, end }` selection returned by `onChange` in `mode="range"`. */
+type DatePickerRange = DateRange;
+type LooseDate = Date | string | null;
+type LooseRange = {
+    start?: LooseDate;
+    end?: LooseDate;
+} | null;
+/** A one-click shortcut in the picker's side rail (Today, Last 7 days, …). */
+interface DatePickerPreset {
+    label: string;
+    /** Static value, in the same shape as the picker's `mode`. */
+    value?: Date | DatePickerRange | Date[];
+    /** Computed on click — wins over `value`. */
+    getValue?: () => Date | DatePickerRange | Date[];
+}
+/** Props shared by every `mode`. */
+interface DatePickerCommonProps extends Omit<BaseControlProps, "startContent" | "endContent" | "loading"> {
+    /**
+     * Display / parse pattern (`yyyy MM dd M d MMM MMMM HH mm a`) or an
+     * `Intl.DateTimeFormatOptions` object. Default `"yyyy-MM-dd"`.
+     */
+    format?: string | Intl.DateTimeFormatOptions;
+    minDate?: Date;
+    maxDate?: Date;
+    disabledDates?: Date[] | ((date: Date) => boolean);
+    /** Predicate form of `disabledDates` (react-aria naming). */
+    isDateUnavailable?: (date: Date) => boolean;
+    firstDayOfWeek?: number;
+    locale?: string;
+    showWeekNumbers?: boolean;
+    showToday?: boolean;
+    showClear?: boolean;
+    /** Starting inner view of the calendar. Defaults to `precision`. */
+    defaultView?: CalendarView;
+    /**
+     * How far the picker drills: `"day"` (default), `"month"` (select a whole
+     * month), or `"year"`.
+     */
+    precision?: CalendarPrecision;
+    /** Always render six week rows. Default true. */
+    fixedWeeks?: boolean;
+    /** Side-by-side month panels. Default 1. */
+    numberOfMonths?: number;
+    /** Show an hour / minute picker beside the calendar (`single` mode). */
+    showTime?: boolean;
+    /** Minute granularity for the time picker. Default 5. */
+    timeStep?: number;
+    /** Month to show first when there's no value yet. */
+    defaultMonth?: Date;
+    /** One-click shortcuts rendered in a side rail. */
+    presets?: DatePickerPreset[];
+    /** Render the calendar always, without a text field. */
+    inline?: boolean;
+    /** Allow typing a date into the field (`single` mode only). Default true. */
+    allowInput?: boolean;
+    closeOnSelect?: boolean;
+    /** Controlled open state of the popover. */
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    placeholder?: string;
+}
+interface DatePickerSingleProps extends DatePickerCommonProps {
+    mode?: "single";
+    value?: Date | string | null;
+    defaultValue?: Date | string | null;
+    onChange?: (value: Date | null) => void;
+}
+interface DatePickerRangeProps extends DatePickerCommonProps {
+    mode: "range";
+    value?: LooseRange;
+    defaultValue?: LooseRange;
+    onChange?: (value: DatePickerRange) => void;
+}
+interface DatePickerMultipleProps extends DatePickerCommonProps {
+    mode: "multiple";
+    value?: Array<Date | string> | null;
+    defaultValue?: Array<Date | string> | null;
+    onChange?: (value: Date[]) => void;
+}
+type DatePickerProps = DatePickerSingleProps | DatePickerRangeProps | DatePickerMultipleProps;
+declare const DatePicker: react.ForwardRefExoticComponent<DatePickerProps & react.RefAttributes<HTMLInputElement>>;
+
+/** `pattern` accepts a RegExp, a source string, or `{ value, flags }`. */
+type PatternRule = RegExp | string | {
+    value: string | RegExp;
+    flags?: string;
+};
+/** `equals` accepts a literal, or `{ field }` to compare against another field. */
+type EqualsRule = unknown | {
+    field: string;
+};
+/** Custom per-field validator. String = message, `false` = generic failure. */
+type CustomValidator = (value: unknown, allValues: Record<string, unknown>) => string | boolean | null | Promise<string | boolean | null>;
 /**
- * Per-field validation config. V1 ships `required` / `minLength` / `maxLength`.
- * Future rule keys (regex, email, min, max, validate, ...) are added here without
- * a breaking change.
+ * Per-field validation config. All keys are optional and additive.
+ * Custom rules registered with `registerRule` add their own keys here via
+ * module augmentation, or are accepted loosely.
  */
 interface FieldValidation {
     required?: boolean;
+    /** String / array length. */
     minLength?: number;
     maxLength?: number;
+    /** Array item count (checkbox groups, multi-selects). */
+    minItems?: number;
+    maxItems?: number;
+    /** Numeric bounds (value coerced to number). */
+    min?: number;
+    max?: number;
+    integer?: boolean;
+    /** Date bounds (value + param coerced to a timestamp). */
+    minDate?: string | Date;
+    maxDate?: string | Date;
+    /** Range-mode day-span bounds (inclusive; a single day counts as 1). */
+    minRangeDays?: number;
+    maxRangeDays?: number;
+    email?: boolean;
+    url?: boolean;
+    pattern?: PatternRule;
+    /** Value must be one of these. */
+    oneOf?: unknown[];
+    /** Equal to a literal, or to another field's value: `{ field: "password" }`. */
+    equals?: EqualsRule;
+    /** Custom validator — sync or async. */
+    validate?: CustomValidator;
     /** Per-rule message overrides, e.g. `{ required: "Name is required" }`. */
     messages?: Partial<Record<string, string>>;
+    /** Allow custom `registerRule` keys without a type error. */
+    [rule: string]: unknown;
 }
 /** A single validation failure. Shape is frozen — new fields must stay optional. */
 interface FieldError {
-    /** Rule that failed: `"required"`, `"minLength"`, `"custom"`, `"async"`, ... */
+    /** Rule that failed: `"required"`, `"minLength"`, `"pattern"`, `"validate"`, `"schema"`, ... */
     rule: string;
     message: string;
-    /** Reserved for cross-field / nested errors. Unused in V1. */
+    /** Dotted path for cross-field / nested errors. */
     path?: string;
 }
 /**
@@ -36,23 +300,29 @@ interface ValidationContext {
     trigger: ValidationTrigger;
 }
 /**
- * The single seam through which all validation flows. V1's default resolver is
- * rule-based and synchronous; the `Promise` return type keeps async, schema, and
- * cross-field validation additive.
+ * The single seam through which all validation flows. The default resolver is
+ * rule-based; the `Promise` return keeps async, schema, and cross-field
+ * validation additive.
  */
 type ValidationResolver = (values: Record<string, unknown>, config: FieldsetConfig, context: ValidationContext) => ValidationResult | Promise<ValidationResult>;
 /**
  * A single rule implementation. Returns an error message string on failure, or
- * `null` on success. `allValues` is passed so cross-field rules need no
- * signature change later.
+ * `null` on success — synchronously or as a Promise. `allValues` is passed so
+ * cross-field rules need no signature change.
  */
-type RuleFn = (value: unknown, param: unknown, allValues: Record<string, unknown>) => string | null;
+type RuleFn = (value: unknown, param: unknown, allValues: Record<string, unknown>) => string | null | Promise<string | null>;
 
-/** A single selectable option in a {@link DropdownFieldConfig}. */
+/** A single selectable option for `Dropdown` / a {@link DropdownFieldConfig}. */
 interface DropdownOption {
     label: string;
     value: string;
     disabled?: boolean;
+    /** Secondary line under the label. */
+    description?: ReactNode;
+    /** Leading icon / flag. */
+    icon?: ReactNode;
+    /** Group heading this option is listed under. */
+    group?: string;
 }
 /** Number of columns at each responsive breakpoint. */
 interface ColumnSpec {
@@ -60,6 +330,18 @@ interface ColumnSpec {
     tablet: number;
     mobile: number;
 }
+/**
+ * Show / validate a field only when a condition holds. An object targets one
+ * other field; a function gets all values.
+ */
+type FieldCondition = {
+    field: string;
+    eq?: unknown;
+    ne?: unknown;
+    in?: unknown[];
+    notIn?: unknown[];
+    truthy?: boolean;
+} | ((values: Record<string, unknown>) => boolean);
 /** Fields common to every field type. */
 interface BaseFieldConfig {
     /** Unique key within the fieldset; also the key in the values object. */
@@ -71,20 +353,143 @@ interface BaseFieldConfig {
     readOnly?: boolean;
     defaultValue?: unknown;
     validation?: FieldValidation;
+    /** Render + validate this field only when the condition holds. */
+    when?: FieldCondition;
     /** Field-level column span, overriding the fieldset's `columns`. */
     layout?: Partial<ColumnSpec>;
+    /** `sm` / `md` / `lg`. */
+    size?: "sm" | "md" | "lg";
+    /** `outline` / `filled` / `flushed` / `unstyled`. */
+    variant?: "outline" | "filled" | "flushed" | "unstyled";
+    /** Float the label into the control border. */
+    floatingLabel?: boolean;
     /** Escape hatch: spread verbatim onto the underlying control. */
     props?: Record<string, unknown>;
 }
-/** Native `<input>` field. `inputType` maps to the DOM `type` attribute. */
+/** Single-line text field. */
 interface InputFieldConfig extends BaseFieldConfig {
     type: "input";
-    inputType?: "text" | "email" | "password" | "number" | "tel" | "url";
+    inputType?: "text" | "email" | "password" | "search" | "tel" | "url";
+    prefix?: string;
+    suffix?: string;
+    /** Segments attached outside the border. */
+    addonBefore?: string;
+    addonAfter?: string;
+    clearable?: boolean;
+    maxLength?: number;
+    /** Live character counter. */
+    showCount?: boolean;
+    /** Debounce `onChange` by N ms. */
+    debounce?: number;
+    /** Virtual-keyboard hint. */
+    inputMode?: "text" | "numeric" | "decimal" | "tel" | "email" | "url" | "search";
+    /** HTML `pattern` for native validation. */
+    pattern?: string;
 }
-/** Native `<select>` field. */
+/** Multi-line text field. */
+interface TextareaFieldConfig extends BaseFieldConfig {
+    type: "textarea";
+    rows?: number;
+    maxRows?: number;
+    autoResize?: boolean;
+    resize?: "none" | "vertical" | "both";
+    maxLength?: number;
+    showCount?: boolean;
+    /** Enter (no Shift) submits and suppresses the newline. */
+    submitOnEnter?: boolean;
+}
+/** Numeric field with steppers + Intl formatting. Value is `number | null`. */
+interface NumberFieldConfig extends BaseFieldConfig {
+    type: "number";
+    min?: number;
+    max?: number;
+    step?: number;
+    precision?: number;
+    /** Alias for `precision`. */
+    decimalScale?: number;
+    currency?: string;
+    /** `decimal` | `currency` | `percent` | `unit`. */
+    style?: "decimal" | "currency" | "percent" | "unit";
+    locale?: string;
+    prefix?: string;
+    suffix?: string;
+    /** Override the locale thousands separator. */
+    thousandSeparator?: string;
+    /** Allow values below zero. Default true. */
+    allowNegative?: boolean;
+    /** `strict` | `blur` | `none`. */
+    clampBehavior?: "strict" | "blur" | "none";
+    /** Hide the stepper buttons. */
+    hideControls?: boolean;
+}
+/** Combobox (searchable listbox). */
 interface DropdownFieldConfig extends BaseFieldConfig {
     type: "dropdown";
     options: DropdownOption[];
+    searchable?: boolean;
+    multiple?: boolean;
+    clearable?: boolean;
+    /** Allow inventing an option from the query (needs `searchable`). */
+    creatable?: boolean;
+    /** Multiple: cap how many options can be chosen. */
+    maxValues?: number;
+    /** Multiple: hide options already selected. */
+    hidePickedOptions?: boolean;
+    /** Multiple: show a Select all / Clear row. */
+    showSelectAll?: boolean;
+    /** Debounce, in ms, before the field's search would hit a server. */
+    searchDebounce?: number;
+}
+/**
+ * Calendar date field. Value is an ISO date string (`yyyy-MM-dd`) for `single`,
+ * `{ start, end }` ISO strings for `range`, or `string[]` for `multiple`.
+ */
+interface DateFieldConfig extends BaseFieldConfig {
+    type: "date";
+    format?: string;
+    /** Selection model. Default `"single"`. */
+    mode?: "single" | "range" | "multiple";
+    /** Drill depth: `"day"` (default), `"month"`, or `"year"`. */
+    precision?: "day" | "month" | "year";
+    minDate?: string | Date;
+    maxDate?: string | Date;
+    showToday?: boolean;
+    clearable?: boolean;
+    /** Side-rail shortcuts. `value` matches `mode` (ISO strings). */
+    presets?: Array<{
+        label: string;
+        value: string | {
+            start: string;
+            end: string;
+        } | string[];
+    }>;
+}
+/** A single boolean checkbox. Value is `boolean`. */
+interface CheckboxFieldConfig extends BaseFieldConfig {
+    type: "checkbox";
+    /** Text shown next to the box (falls back to `label`). */
+    checkboxLabel?: string;
+}
+/** A set of checkboxes. Value is `string[]`. */
+interface CheckboxGroupFieldConfig extends BaseFieldConfig {
+    type: "checkbox-group";
+    options: DropdownOption[];
+    orientation?: "vertical" | "horizontal";
+    /** Lay the options out in an N-column grid. */
+    columns?: number;
+    /** Show a "select all" checkbox. */
+    showSelectAll?: boolean;
+    min?: number;
+    max?: number;
+}
+/** A radio group. Value is `string`. */
+interface RadioFieldConfig extends BaseFieldConfig {
+    type: "radio";
+    options: DropdownOption[];
+    orientation?: "vertical" | "horizontal";
+    /** Lay the options out in an N-column grid. */
+    columns?: number;
+    radioVariant?: "default" | "card";
 }
 /**
  * Maps a field `type` string to its config shape. Consumers register custom
@@ -100,7 +505,13 @@ interface DropdownFieldConfig extends BaseFieldConfig {
  */
 interface FieldConfigRegistry {
     input: InputFieldConfig;
+    textarea: TextareaFieldConfig;
+    number: NumberFieldConfig;
     dropdown: DropdownFieldConfig;
+    date: DateFieldConfig;
+    checkbox: CheckboxFieldConfig;
+    "checkbox-group": CheckboxGroupFieldConfig;
+    radio: RadioFieldConfig;
 }
 /** Discriminated union of every registered field config. */
 type FieldConfig = FieldConfigRegistry[keyof FieldConfigRegistry];
@@ -111,13 +522,85 @@ interface FieldsetConfig {
     fields: FieldConfig[];
     /** Rendered in a `<legend>` when present. */
     legend?: string;
-    /** Columns per breakpoint. Defaults to `{ desktop: 3, tablet: 2, mobile: 1 }`. */
-    columns?: Partial<ColumnSpec>;
+    /**
+     * Column layout. A **number** means "use up to N columns, fluidly, down to
+     * one when narrow". An **object** snaps to exact counts at wide / medium /
+     * narrow container widths. Defaults to `{ desktop: 3, tablet: 2, mobile: 1 }`.
+     */
+    columns?: Partial<ColumnSpec> | number;
+    /**
+     * Minimum comfortable width for a single column (number = px, or a CSS length
+     * like `"14rem"`). Drives when the grid adds/removes columns. Default `192`.
+     */
+    minColumnWidth?: string | number;
     /** Grid gap; a number is treated as pixels. */
     gap?: string | number;
     id?: string;
 }
 
+/** Options may also be passed pre-grouped. */
+interface DropdownOptionGroup {
+    group: string;
+    items: DropdownOption[];
+}
+interface OptionState {
+    selected: boolean;
+    active: boolean;
+    disabled: boolean;
+    /** Query the option matched, for highlighting. */
+    query: string;
+}
+interface DropdownProps extends Omit<BaseControlProps, "startContent" | "endContent"> {
+    options: DropdownOption[] | DropdownOptionGroup[];
+    value?: string | string[] | null;
+    defaultValue?: string | string[] | null;
+    onChange?: (value: string | string[] | null) => void;
+    multiple?: boolean;
+    /** Type in the control to filter options. */
+    searchable?: boolean;
+    filterMode?: "contains" | "startsWith";
+    filterFn?: (option: DropdownOption, query: string) => boolean;
+    /** Bold the matched substring in option labels. Default true when searchable. */
+    highlightMatch?: boolean;
+    renderOption?: (option: DropdownOption, state: OptionState) => ReactNode;
+    renderValue?: (selected: DropdownOption[]) => ReactNode;
+    renderGroupLabel?: (label: string) => ReactNode;
+    placeholder?: string;
+    emptyMessage?: ReactNode;
+    /** Shown in place of `emptyMessage` while `loading` and there are no options. */
+    loadingMessage?: ReactNode;
+    /** Close the panel after a pick. Default true for single, false for multiple. */
+    closeOnSelect?: boolean;
+    /** Cap the chips shown before "+N". */
+    maxSelectedLabels?: number;
+    /** Multiple: cap how many options can be selected. */
+    maxValues?: number;
+    /** Multiple: drop already-selected options from the list. */
+    hidePickedOptions?: boolean;
+    /** Multiple: show a "Select all / Clear" action row. */
+    showSelectAll?: boolean;
+    /** Fall back to a native `<select>` (single, no search). */
+    native?: boolean;
+    startContent?: ReactNode;
+    /** Allow creating an option from the current query (needs `searchable`). */
+    creatable?: boolean;
+    onCreate?: (inputValue: string) => void;
+    /** Gate the create row. Default: non-empty query with no exact label match. */
+    isValidNewOption?: (inputValue: string, options: DropdownOption[]) => boolean;
+    formatCreateLabel?: (inputValue: string) => ReactNode;
+    createPosition?: "first" | "last";
+    /** Fires (debounced) as the query changes; disables local filtering. */
+    onSearch?: (query: string) => void;
+    searchDebounce?: number;
+    /** Controlled panel open state. */
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    /** Cap the listbox height, px. */
+    maxHeight?: number;
+}
+declare const Dropdown: react.ForwardRefExoticComponent<DropdownProps & react.RefAttributes<HTMLInputElement>>;
+
 /**
  * The contract every control receives from `Fieldset`. This is the stability
  * boundary between the orchestrator and the controls: as long as this holds,
@@ -139,12 +622,25 @@ interface ControlProps<TValue = unknown> {
     describedById?: string;
     /** The full field config, for type-specific data (e.g. dropdown `options`). */
     config: FieldConfig;
+    /**
+     * Only set for `selfContained` registrations (the component renders its own
+     * `<Field>`): the field's label / description, and the current error messages.
+     */
+    label?: string;
+    description?: string;
+    errors?: string[];
 }
 /** A React component that satisfies {@link ControlProps}. */
 type ControlComponent<TValue = any> = ComponentType<ControlProps<TValue>>;
 /** A registry entry for one field `type`. */
 interface FieldRegistration<TValue = any> {
     component: ControlComponent<TValue>;
+    /**
+     * The component renders its own `<Field>` (label / description / error). When
+     * true, `FieldRenderer` does not wrap it, and passes `label` / `description` /
+     * `errors` on {@link ControlProps} instead of `describedById`.
+     */
+    selfContained?: boolean;
     /** Value used when neither the config nor the form supplies one. */
     defaultValue?: TValue;
     /** Normalize an incoming value before it reaches the control. */
@@ -178,43 +674,30 @@ interface FieldRenderContext {
     /** Value for the control's `aria-describedby`, or `undefined`. */
     describedById: string | undefined;
     invalid: boolean;
+    valid: boolean;
     required: boolean | undefined;
     disabled: boolean | undefined;
 }
 /**
- * Low-level layout + a11y wrapper. Renders label, description and error region
- * and wires the ARIA relationships. `Input` and `Dropdown` are built on it, and
- * it is exported for custom control authors.
+ * Low-level layout + a11y wrapper. Renders label, description and an
+ * error / success region and wires the ARIA relationships. Every control is
+ * built on it, and it is exported for custom control authors.
  */
 interface FieldProps {
     label?: ReactNode;
     description?: ReactNode;
     error?: ErrorProp;
+    /** `true`, or a confirmation message, to show the success state. */
+    success?: string | boolean;
     required?: boolean;
     disabled?: boolean;
+    /** Skip rendering the `<label>` (e.g. the control floats its own). */
+    hideLabel?: boolean;
     /** Control id; generated with `useId` when omitted. */
     id?: string;
     className?: string;
     children: ReactNode | ((ctx: FieldRenderContext) => ReactNode);
 }
-/** Props shared by the standalone controls. */
-interface SharedControlProps {
-    label?: ReactNode;
-    description?: ReactNode;
-    error?: ErrorProp;
-}
-interface InputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "onChange" | "value" | "type">, SharedControlProps {
-    value?: string;
-    onChange?: (value: string, event?: ChangeEvent<HTMLInputElement>) => void;
-    type?: "text" | "email" | "password" | "number" | "tel" | "url";
-}
-interface DropdownProps extends Omit<SelectHTMLAttributes<HTMLSelectElement>, "onChange" | "value">, SharedControlProps {
-    options: DropdownOption[];
-    value?: string;
-    onChange?: (value: string, event?: ChangeEvent<HTMLSelectElement>) => void;
-    /** Renders a non-selectable prompt option when the value is empty. */
-    placeholder?: string;
-}
 interface FieldsetProps<TValues extends Record<string, unknown> = Record<string, unknown>> {
     config: FieldsetConfig;
     /** Controlled values. Omit and use `defaultValue` for uncontrolled. */
@@ -234,18 +717,10 @@ interface FieldsetProps<TValues extends Record<string, unknown> = Record<string,
     id?: string;
 }
 
-/**
- * A labelled single-select built on the native `<select>` element (accessible
- * and keyboard-navigable out of the box). Works with or without `<Fieldset>`.
- */
-declare const Dropdown: react.ForwardRefExoticComponent<DropdownProps & react.RefAttributes<HTMLSelectElement>>;
-
 /**
  * Layout + accessibility wrapper for a single control. Renders the label,
- * optional description, and an error region, and wires the ARIA relationships
- * (`htmlFor`, `aria-describedby`, `aria-invalid`, `aria-required`).
- *
- * Pass a render function as `children` to receive the resolved ids:
+ * optional description, and an error/success region, and wires the ARIA
+ * relationships (`htmlFor`, `aria-describedby`, `aria-invalid`, `aria-required`).
  *
  * ```tsx
  * <Field label="Name" error={error}>
@@ -257,18 +732,179 @@ declare const Dropdown: react.ForwardRefExoticComponent<DropdownProps & react.Re
  */
 declare function Field(props: FieldProps): react.JSX.Element;
 
-/**
- * A labelled text input. Controlled when `value` is passed, uncontrolled
- * otherwise (`defaultValue` flows through to the native element). Works with or
- * without `<Fieldset>`.
- */
+type NativeInput = Omit<InputHTMLAttributes<HTMLInputElement>, "value" | "defaultValue" | "onChange" | "type" | "size" | "prefix">;
+/** `showCount` config: `true`, or an object with a cap + a custom formatter. */
+type ShowCount = boolean | {
+    max?: number;
+    formatter?: (count: number, max?: number) => ReactNode;
+};
+interface InputProps extends BaseControlProps, NativeInput {
+    value?: string;
+    defaultValue?: string;
+    onChange?: (value: string, event: ChangeEvent<HTMLInputElement>) => void;
+    /** Fired on Enter. */
+    onEnter?: (value: string) => void;
+    type?: "text" | "email" | "password" | "search" | "tel" | "url";
+    /** Static text glued to the start (e.g. `https://`). */
+    prefix?: ReactNode;
+    /** Static text glued to the end (e.g. `.com`). */
+    suffix?: ReactNode;
+    /** Segment attached before the field, outside the border. */
+    addonBefore?: ReactNode;
+    /** Segment attached after the field, outside the border. */
+    addonAfter?: ReactNode;
+    /** Show a show/hide toggle (implied for `type="password"`). */
+    passwordToggle?: boolean;
+    /** Controlled reveal state for a password field. */
+    passwordVisible?: boolean;
+    onPasswordVisibleChange?: (visible: boolean) => void;
+    /** Custom toggle icon; gets the current reveal state. */
+    visibilityToggleIcon?: (revealed: boolean) => ReactNode;
+    /** Show a live character counter. Pass an object for a cap / custom render. */
+    showCount?: ShowCount;
+    /** Debounce `onChange` by this many ms (drive uncontrolled to avoid lag). */
+    debounce?: number;
+}
 declare const Input: react.ForwardRefExoticComponent<InputProps & react.RefAttributes<HTMLInputElement>>;
 
+type NativeNumberInput = Omit<InputHTMLAttributes<HTMLInputElement>, "value" | "defaultValue" | "onChange" | "type" | "min" | "max" | "step" | "size" | "prefix" | "style">;
+type ClampBehavior = "strict" | "blur" | "none";
+interface NumberFieldProps extends BaseControlProps, NativeNumberInput {
+    value?: number | null;
+    defaultValue?: number | null;
+    onChange?: (value: number | null) => void;
+    /** Fires alongside `onChange` with the formatted string too. */
+    onValueChange?: (payload: {
+        value: number | null;
+        formatted: string;
+    }) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+    /** Larger step for Shift+Arrow / PageUp-Down. Default `step * 10`. */
+    shiftStep?: number;
+    /** Smaller step for Alt+Arrow. Default `step / 10`. */
+    smallStep?: number;
+    /** Decimal places to keep. Alias: `decimalScale`. */
+    precision?: number;
+    decimalScale?: number;
+    /** Pad to `decimalScale` with trailing zeros. */
+    fixedDecimalScale?: boolean;
+    /** Stepper buttons. Default `"stacked"`. */
+    buttons?: "stacked" | "horizontal" | false;
+    /** Alias for `buttons={false}`. */
+    hideControls?: boolean;
+    /** Group thousands (`1,000`). */
+    grouping?: boolean;
+    /** Override the locale's thousands separator. */
+    thousandSeparator?: string;
+    /** Override the locale's decimal separator. */
+    decimalSeparator?: string;
+    /** BCP-47 locale for formatting. */
+    locale?: string;
+    /** Number style. `currency` needs `currency`; `unit` needs `unit`. */
+    style?: "decimal" | "currency" | "percent" | "unit";
+    /** ISO currency code (implies `style="currency"`). */
+    currency?: string;
+    /** Intl unit identifier for `style="unit"` (e.g. `"kilogram"`). */
+    unit?: string;
+    /** Raw `Intl.NumberFormatOptions` — wins over the individual knobs. */
+    formatOptions?: Intl.NumberFormatOptions;
+    /** Fully custom display. */
+    format?: (value: number) => string;
+    /** Fully custom parse. */
+    parse?: (text: string) => number | null;
+    /** Text before the number. */
+    prefix?: string;
+    /** Text after the number (e.g. `%`, `kg`). */
+    suffix?: string;
+    /** Allow values below zero. Default true. */
+    allowNegative?: boolean;
+    /** `"strict"` (never leaves range) · `"blur"` (default) · `"none"`. */
+    clampBehavior?: ClampBehavior;
+    /** Deprecated alias — `false` maps to `clampBehavior="none"`. */
+    clampOnBlur?: boolean;
+    /** Value committed for an empty field. Default `null`. */
+    emptyValue?: number | null;
+    /** Step with the mouse wheel while focused. Default false. */
+    allowMouseWheel?: boolean;
+    /** Inverse of `allowMouseWheel`. */
+    isWheelDisabled?: boolean;
+    /** Delay before hold-to-repeat kicks in, ms. Default 300. */
+    stepHoldDelay?: number;
+    /** Interval between repeats while held, ms. Default 60. */
+    stepHoldInterval?: number;
+}
+declare const NumberField: react.ForwardRefExoticComponent<NumberFieldProps & react.RefAttributes<HTMLInputElement>>;
+
+type NativeRadio = Omit<InputHTMLAttributes<HTMLInputElement>, "type" | "checked" | "defaultChecked" | "onChange" | "size" | "value">;
+interface RadioProps extends NativeRadio {
+    value: string;
+    label?: ReactNode;
+    description?: ReactNode;
+    disabled?: boolean;
+    size?: ControlSize;
+    card?: boolean;
+    labelPlacement?: "end" | "start";
+    className?: string;
+}
+declare const Radio: react.ForwardRefExoticComponent<RadioProps & react.RefAttributes<HTMLInputElement>>;
+interface RadioOption {
+    label: ReactNode;
+    value: string;
+    description?: ReactNode;
+    /** Leading icon shown before the label. */
+    icon?: ReactNode;
+    disabled?: boolean;
+}
+interface RadioGroupProps {
+    label?: ReactNode;
+    description?: ReactNode;
+    error?: Feedback;
+    success?: string | boolean;
+    required?: boolean;
+    disabled?: boolean;
+    name?: string;
+    size?: ControlSize;
+    variant?: "default" | "card";
+    value?: string | null;
+    defaultValue?: string | null;
+    onChange?: (value: string) => void;
+    orientation?: "vertical" | "horizontal";
+    /** Lay the options out in an N-column grid. */
+    columns?: number;
+    options?: RadioOption[];
+    children?: ReactNode;
+    className?: string;
+    id?: string;
+}
+declare function RadioGroup(props: RadioGroupProps): react.JSX.Element;
+
+type NativeTextarea = Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, "value" | "defaultValue" | "onChange" | "rows" | "cols">;
+interface TextareaProps extends Omit<BaseControlProps, "startContent">, NativeTextarea {
+    value?: string;
+    defaultValue?: string;
+    onChange?: (value: string, event: ChangeEvent<HTMLTextAreaElement>) => void;
+    /** Fired on Enter (without Shift). */
+    onEnter?: (value: string) => void;
+    /** Enter (no Shift) fires `onEnter` and suppresses the newline. */
+    submitOnEnter?: boolean;
+    /** Grow with content between `minRows` and `maxRows`. */
+    autoResize?: boolean;
+    minRows?: number;
+    maxRows?: number;
+    /** Native resize handle. Default `"vertical"` (`"none"` when `autoResize`). */
+    resize?: "none" | "vertical" | "both";
+    /** Live counter — `true`, or `{ max?, formatter?(count, max) }`. */
+    showCount?: ShowCount;
+}
+declare const Textarea: react.ForwardRefExoticComponent<TextareaProps & react.RefAttributes<HTMLTextAreaElement>>;
+
 /**
  * Renders a form (or a form section) from a `FieldsetConfig`. Controlled when
  * `value` is passed, uncontrolled otherwise. Renders a native `<fieldset>` — so
  * `disabled` cascades to every control — and does not render its own `<form>`;
- * wrap it in one and use `useFieldsetState().handleSubmit` for submission.
+ * wrap it in one and use `useFieldsetState().handleSubmit`, or use `<Form>`.
  */
 declare function Fieldset<TValues extends Record<string, unknown> = Record<string, unknown>>(props: FieldsetProps<TValues>): react.JSX.Element;
 
@@ -289,6 +925,8 @@ interface FieldsetState {
 interface NormalizedFieldsetConfig {
     fields: FieldConfig[];
     columns: ColumnSpec;
+    /** Minimum comfortable width for one column, in px. */
+    minColWidth: number;
     /** CSS length for the grid gap, or `undefined` to use the token default. */
     gap: string | undefined;
     legend: string | undefined;
@@ -304,8 +942,8 @@ interface NormalizedFieldsetConfig {
  */
 declare function normalizeConfig(config: FieldsetConfig, registry?: FieldRegistry): NormalizedFieldsetConfig;
 
-type Values = Record<string, unknown>;
-interface UseFieldsetStateOptions<TValues extends Values = Values> {
+type Values$1 = Record<string, unknown>;
+interface UseFieldsetStateOptions<TValues extends Values$1 = Values$1> {
     /** Controlled values. Omit and pass `defaultValue` for uncontrolled. */
     value?: TValues;
     defaultValue?: Partial<TValues>;
@@ -327,7 +965,7 @@ interface FieldSlice {
     setValue: (value: unknown) => void;
     markTouched: () => void;
 }
-interface UseFieldsetStateReturn<TValues extends Values = Values> {
+interface UseFieldsetStateReturn<TValues extends Values$1 = Values$1> {
     config: NormalizedFieldsetConfig;
     state: FieldsetState;
     values: TValues;
@@ -348,7 +986,371 @@ interface UseFieldsetStateReturn<TValues extends Values = Values> {
  * markup. Manages values (controlled or uncontrolled), touched/dirty tracking,
  * and validation through a pluggable resolver.
  */
-declare function useFieldsetState<TValues extends Values = Values>(config: FieldsetConfig, options?: UseFieldsetStateOptions<TValues>): UseFieldsetStateReturn<TValues>;
+declare function useFieldsetState<TValues extends Values$1 = Values$1>(config: FieldsetConfig, options?: UseFieldsetStateOptions<TValues>): UseFieldsetStateReturn<TValues>;
+
+interface FieldsetViewProps {
+    /** The return of `useFieldsetState`. */
+    state: UseFieldsetStateReturn;
+    registry?: FieldRegistry;
+    disabled?: boolean;
+    className?: string;
+    id?: string;
+}
+/**
+ * Presentational half of `<Fieldset>` — renders the grid of fields from an
+ * existing `useFieldsetState` instance. Used by `<Fieldset>` and `<Form>` so
+ * they never run the state hook twice.
+ */
+declare function FieldsetView({ state, registry, disabled, className, id }: FieldsetViewProps): react.JSX.Element;
+
+type Values = Record<string, unknown>;
+interface FormProps<TValues extends Values = Values> extends Omit<FormHTMLAttributes<HTMLFormElement>, "onSubmit" | "onInvalid" | "children" | "onChange" | "defaultValue"> {
+    config: FieldsetConfig;
+    value?: TValues;
+    defaultValue?: Partial<TValues>;
+    onChange?: (values: TValues) => void;
+    /** Called with the values when the form passes validation. */
+    onSubmit: (values: TValues, fs: UseFieldsetStateReturn<TValues>) => void;
+    /** Called with the errors when submit is blocked. */
+    onInvalid?: (errors: ValidationResult) => void;
+    resolver?: ValidationResolver;
+    validateOn?: ValidationTrigger;
+    disabled?: boolean;
+    /** Content after the fieldset — usually a submit button. Gets `fs`. */
+    children?: ReactNode | ((fs: UseFieldsetStateReturn<TValues>) => ReactNode);
+}
+/**
+ * A `<form>` that owns its state: renders `<Fieldset>` from `config`, and calls
+ * `onSubmit(values)` only when validation passes. `children` (or a render
+ * function receiving the `useFieldsetState` return) is where the submit button
+ * goes.
+ *
+ * ```tsx
+ * <Form config={config} onSubmit={(v) => save(v)}>
+ *   {(fs) => <button type="submit" disabled={!fs.isValid}>Save</button>}
+ * </Form>
+ * ```
+ */
+declare function Form<TValues extends Values = Values>(props: FormProps<TValues>): react.JSX.Element;
+
+type ButtonVariant = "default" | "secondary" | "destructive" | "outline" | "ghost" | "link";
+type ButtonSize = "default" | "sm" | "lg" | "icon";
+type BadgeVariant = "default" | "secondary" | "destructive" | "outline";
+/**
+ * Class list for a shadcn-style button. Exported so a non-`<button>` element can
+ * be styled as one: `<a className={buttonClasses("outline")}>…</a>`.
+ */
+declare function buttonClasses(variant?: ButtonVariant, size?: ButtonSize): string;
+/** Class list for a badge — same idea as {@link buttonClasses}. */
+declare function badgeClasses(variant?: BadgeVariant): string;
+
+interface ButtonProps extends ComponentProps<"button"> {
+    /** default · secondary · destructive · outline · ghost · link */
+    variant?: ButtonVariant;
+    /** default (h-9) · sm (h-8) · lg (h-10) · icon (square) */
+    size?: ButtonSize;
+    /** Render `children` as the button, merging button props/classes onto it. */
+    asChild?: boolean;
+    /** Show a spinner and disable the button. */
+    loading?: boolean;
+    /** Replaces the label while `loading`. */
+    loadingText?: ReactNode;
+    /** Icon before the label (ignored with `asChild`). */
+    leftIcon?: ReactNode;
+    /** Icon after the label (ignored with `asChild`). */
+    rightIcon?: ReactNode;
+    /** Stretch to the container width. */
+    fullWidth?: boolean;
+}
+declare const Button: react.ForwardRefExoticComponent<Omit<ButtonProps, "ref"> & react.RefAttributes<HTMLButtonElement>>;
+
+interface LabelProps extends ComponentPropsWithoutRef<typeof Label$1.Root> {
+    /** Append a required asterisk. */
+    required?: boolean;
+    /** Append an "(optional)" hint (ignored when `required`). */
+    optional?: boolean | ReactNode;
+}
+declare const Label: react.ForwardRefExoticComponent<LabelProps & react.RefAttributes<HTMLLabelElement>>;
+
+type DivProps = ComponentProps<"div">;
+interface CardProps extends DivProps {
+    /** Render `children` as the card element (e.g. an `<a>` or `<button>`). */
+    asChild?: boolean;
+    /** Hover / focus-visible affordance for a clickable card. */
+    interactive?: boolean;
+}
+declare const Card: react.ForwardRefExoticComponent<Omit<CardProps, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const CardHeader: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const CardTitle: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const CardDescription: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const CardAction: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const CardContent: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const CardFooter: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+
+interface BadgeProps extends ComponentProps<"span"> {
+    /** default · secondary · destructive · outline */
+    variant?: BadgeVariant;
+    /** `sm` or `md` (default). */
+    size?: "sm" | "md";
+    /** Leading status dot. */
+    dot?: boolean;
+    /** Leading icon (ignored with `asChild`). */
+    icon?: ReactNode;
+    /** Render a trailing ✕ that calls `onRemove`. */
+    removable?: boolean;
+    onRemove?: (e: MouseEvent<HTMLButtonElement>) => void;
+    /** Render `children` as the badge element (drops the extras). */
+    asChild?: boolean;
+}
+declare const Badge: react.ForwardRefExoticComponent<Omit<BadgeProps, "ref"> & react.RefAttributes<HTMLSpanElement>>;
+
+type AlertVariant = "default" | "destructive" | "success" | "warning" | "info";
+interface AlertProps extends Omit<ComponentProps<"div">, "title"> {
+    /** default · destructive · success · warning · info */
+    variant?: AlertVariant;
+    /** Leading icon. */
+    icon?: ReactNode;
+    /** Shorthand for a leading `<AlertTitle>`. */
+    title?: ReactNode;
+    /** Render a top-right ✕ that calls `onDismiss`. */
+    dismissible?: boolean;
+    onDismiss?: () => void;
+}
+declare const Alert: react.ForwardRefExoticComponent<Omit<AlertProps, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const AlertTitle: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const AlertDescription: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+
+interface SeparatorProps extends ComponentPropsWithoutRef<typeof Separator$1.Root> {
+    /** `solid` (default) or `dashed`. */
+    variant?: "solid" | "dashed";
+    /** Centered text inside the rule (horizontal only). */
+    children?: ReactNode;
+}
+declare const Separator: react.ForwardRefExoticComponent<SeparatorProps & react.RefAttributes<HTMLDivElement>>;
+
+interface TableProps extends ComponentProps<"table"> {
+    /** Cell padding. `md` (default) or `sm` (compact). `dense` is an alias for `sm`. */
+    size?: "sm" | "md";
+    dense?: boolean;
+}
+declare const Table: react.ForwardRefExoticComponent<Omit<TableProps, "ref"> & react.RefAttributes<HTMLTableElement>>;
+interface TableHeaderProps extends ComponentProps<"thead"> {
+    /** Stick the header to the top of the scroll container. */
+    sticky?: boolean;
+}
+declare const TableHeader: react.ForwardRefExoticComponent<Omit<TableHeaderProps, "ref"> & react.RefAttributes<HTMLTableSectionElement>>;
+declare const TableBody: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>, "ref"> & react.RefAttributes<HTMLTableSectionElement>>;
+declare const TableFooter: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>, "ref"> & react.RefAttributes<HTMLTableSectionElement>>;
+interface TableRowProps extends ComponentProps<"tr"> {
+    /** Highlight the row (maps to `data-state="selected"`). */
+    selected?: boolean;
+}
+declare const TableRow: react.ForwardRefExoticComponent<Omit<TableRowProps, "ref"> & react.RefAttributes<HTMLTableRowElement>>;
+declare const TableHead: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.ThHTMLAttributes<HTMLTableHeaderCellElement>, HTMLTableHeaderCellElement>, "ref"> & react.RefAttributes<HTMLTableCellElement>>;
+declare const TableCell: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.TdHTMLAttributes<HTMLTableDataCellElement>, HTMLTableDataCellElement>, "ref"> & react.RefAttributes<HTMLTableCellElement>>;
+declare const TableCaption: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & react.RefAttributes<HTMLTableCaptionElement>>;
+
+interface SwitchProps extends ComponentPropsWithoutRef<typeof Switch$1.Root> {
+    /** `sm` · `default` · `lg`. */
+    size?: "sm" | "default" | "lg";
+    /** Text beside the switch — wraps it in a `<label>` layout. */
+    label?: ReactNode;
+    /** Help text under the label. */
+    description?: ReactNode;
+    /** `end` (default) or `start`. */
+    labelPlacement?: "end" | "start";
+    /** Tiny text inside the track when on / off. */
+    onLabel?: ReactNode;
+    offLabel?: ReactNode;
+    /** Icon rendered inside the thumb. */
+    thumbIcon?: ReactNode;
+}
+declare const Switch: react.ForwardRefExoticComponent<SwitchProps & react.RefAttributes<HTMLButtonElement>>;
+
+interface TabsProps extends ComponentPropsWithoutRef<typeof Tabs$1.Root> {
+    /** `pill` (default, muted rounded bar) · `underline` · `enclosed` (folder tabs). */
+    variant?: "pill" | "underline" | "enclosed";
+    /** Trigger sizing. Default `md`. */
+    size?: "sm" | "md" | "lg";
+    /** Triggers stretch to fill the list width. */
+    fitted?: boolean;
+}
+declare const Tabs: react.ForwardRefExoticComponent<TabsProps & react.RefAttributes<HTMLDivElement>>;
+declare const TabsList: react.ForwardRefExoticComponent<Omit<Tabs$1.TabsListProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const TabsTrigger: react.ForwardRefExoticComponent<Omit<Tabs$1.TabsTriggerProps & react.RefAttributes<HTMLButtonElement>, "ref"> & react.RefAttributes<HTMLButtonElement>>;
+declare const TabsContent: react.ForwardRefExoticComponent<Omit<Tabs$1.TabsContentProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+
+declare const Dialog: (props: ComponentProps<typeof Dialog$1.Root>) => react.JSX.Element;
+declare const DialogTrigger: (props: ComponentProps<typeof Dialog$1.Trigger>) => react.JSX.Element;
+declare const DialogClose: (props: ComponentProps<typeof Dialog$1.Close>) => react.JSX.Element;
+declare const DialogPortal: react.FC<Dialog$1.DialogPortalProps>;
+interface DialogContentProps extends ComponentPropsWithoutRef<typeof Dialog$1.Content> {
+    /** Render the built-in top-right close button. Default `true`. */
+    showCloseButton?: boolean;
+    /** Max width. Default `lg`. */
+    size?: "sm" | "md" | "lg" | "xl" | "full";
+    /** Cap the height and scroll the body. */
+    scrollable?: boolean;
+    /** Override the portal container. */
+    container?: Element | DocumentFragment | null;
+}
+declare const DialogContent: react.ForwardRefExoticComponent<DialogContentProps & react.RefAttributes<HTMLDivElement>>;
+declare function DialogHeader({ className, ...props }: ComponentProps<"div">): react.JSX.Element;
+declare function DialogFooter({ className, ...props }: ComponentProps<"div">): react.JSX.Element;
+declare const DialogTitle: react.ForwardRefExoticComponent<Omit<Dialog$1.DialogTitleProps & react.RefAttributes<HTMLHeadingElement>, "ref"> & react.RefAttributes<HTMLHeadingElement>>;
+declare const DialogDescription: react.ForwardRefExoticComponent<Omit<Dialog$1.DialogDescriptionProps & react.RefAttributes<HTMLParagraphElement>, "ref"> & react.RefAttributes<HTMLParagraphElement>>;
+
+declare const Popover: (props: ComponentProps<typeof Popover$1.Root>) => react.JSX.Element;
+declare const PopoverTrigger: (props: ComponentProps<typeof Popover$1.Trigger>) => react.JSX.Element;
+declare const PopoverAnchor: (props: ComponentProps<typeof Popover$1.Anchor>) => react.JSX.Element;
+declare const PopoverClose: react.ForwardRefExoticComponent<Popover$1.PopoverCloseProps & react.RefAttributes<HTMLButtonElement>>;
+declare const PopoverArrow: (props: ComponentProps<typeof Popover$1.Arrow>) => react.JSX.Element;
+interface PopoverContentProps extends ComponentPropsWithoutRef<typeof Popover$1.Content> {
+    /** Show a pointing arrow. */
+    arrow?: boolean;
+    /** Override the portal container. */
+    container?: Element | DocumentFragment | null;
+}
+declare const PopoverContent: react.ForwardRefExoticComponent<PopoverContentProps & react.RefAttributes<HTMLDivElement>>;
+
+declare function TooltipProvider({ delayDuration, ...props }: ComponentPropsWithoutRef<typeof Tooltip$1.Provider>): react.JSX.Element;
+interface TooltipProps extends ComponentPropsWithoutRef<typeof Tooltip$1.Root> {
+    /** Hover delay before opening, ms. Default 0. */
+    delayDuration?: number;
+    /** Window after closing where the next tip opens instantly. */
+    skipDelayDuration?: number;
+    /** Don't keep the tip open while the pointer is over it. */
+    disableHoverableContent?: boolean;
+    /** Skip the auto-wrapped provider (a parent already renders one). */
+    disableProvider?: boolean;
+}
+declare function Tooltip({ delayDuration, skipDelayDuration, disableHoverableContent, disableProvider, ...props }: TooltipProps): react.JSX.Element;
+declare const TooltipTrigger: (props: ComponentPropsWithoutRef<typeof Tooltip$1.Trigger>) => react.JSX.Element;
+interface TooltipContentProps extends ComponentPropsWithoutRef<typeof Tooltip$1.Content> {
+    /** Show the pointing arrow. Default `true`. */
+    arrow?: boolean;
+    /** Arrow width in px (height is ~half). Default 11. */
+    arrowSize?: number;
+    /** Override the portal container. */
+    container?: Element | DocumentFragment | null;
+}
+declare const TooltipContent: react.ForwardRefExoticComponent<TooltipContentProps & react.RefAttributes<HTMLDivElement>>;
+
+declare const DropdownMenu: (props: ComponentProps<typeof DropdownMenu$1.Root>) => react.JSX.Element;
+declare const DropdownMenuTrigger: (props: ComponentProps<typeof DropdownMenu$1.Trigger>) => react.JSX.Element;
+declare const DropdownMenuGroup: react.ForwardRefExoticComponent<DropdownMenu$1.DropdownMenuGroupProps & react.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuPortal: react.FC<DropdownMenu$1.DropdownMenuPortalProps>;
+declare const DropdownMenuSub: react.FC<DropdownMenu$1.DropdownMenuSubProps>;
+declare const DropdownMenuRadioGroup: react.ForwardRefExoticComponent<DropdownMenu$1.DropdownMenuRadioGroupProps & react.RefAttributes<HTMLDivElement>>;
+interface DropdownMenuContentProps extends ComponentPropsWithoutRef<typeof DropdownMenu$1.Content> {
+    /** Override the portal container. */
+    container?: Element | DocumentFragment | null;
+}
+declare const DropdownMenuContent: react.ForwardRefExoticComponent<DropdownMenuContentProps & react.RefAttributes<HTMLDivElement>>;
+interface DropdownMenuItemProps extends ComponentPropsWithoutRef<typeof DropdownMenu$1.Item> {
+    inset?: boolean;
+    variant?: "default" | "destructive";
+    /** Leading icon. */
+    icon?: ReactNode;
+    /** Trailing shortcut hint (rendered right-aligned). */
+    shortcut?: ReactNode;
+}
+declare const DropdownMenuItem: react.ForwardRefExoticComponent<DropdownMenuItemProps & react.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuCheckboxItem: react.ForwardRefExoticComponent<Omit<DropdownMenu$1.DropdownMenuCheckboxItemProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuRadioItem: react.ForwardRefExoticComponent<Omit<DropdownMenu$1.DropdownMenuRadioItemProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+interface DropdownMenuLabelProps extends ComponentPropsWithoutRef<typeof DropdownMenu$1.Label> {
+    inset?: boolean;
+}
+declare const DropdownMenuLabel: react.ForwardRefExoticComponent<DropdownMenuLabelProps & react.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSeparator: react.ForwardRefExoticComponent<Omit<DropdownMenu$1.DropdownMenuSeparatorProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare function DropdownMenuShortcut({ className, ...props }: ComponentProps<"span">): react.JSX.Element;
+interface DropdownMenuSubTriggerProps extends ComponentPropsWithoutRef<typeof DropdownMenu$1.SubTrigger> {
+    inset?: boolean;
+}
+declare const DropdownMenuSubTrigger: react.ForwardRefExoticComponent<DropdownMenuSubTriggerProps & react.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubContent: react.ForwardRefExoticComponent<Omit<DropdownMenu$1.DropdownMenuSubContentProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+
+/** Built-in colour presets. Each maps to `[data-orynn-theme="…"]` in the stylesheet
+ *  and now recolours only the primary/ring — backgrounds stay neutral (shadcn style). */
+type OrynnPreset = "default" | "slate" | "teal" | "violet" | "rose" | "emerald";
+/** Vertical rhythm / sizing. Maps to `[data-orynn-density="…"]`. */
+type OrynnDensity = "compact" | "comfortable" | "spacious";
+type OrynnRadius = "none" | "sm" | "md" | "lg" | "xl" | "pill" | (string & {}) | number;
+/** Any `--orynn-*` custom property. */
+type OrynnVarOverrides = Partial<Record<`--orynn-${string}`, string | number>>;
+interface OrynnThemeConfig {
+    /** Colour preset. Defaults to `"default"` (neutral). */
+    preset?: OrynnPreset;
+    density?: OrynnDensity;
+    /** `"dark"` swaps the base palette to the dark token set (also sets the `.dark` class). */
+    colorScheme?: "light" | "dark";
+    /** The solid action colour (`--orynn-color-primary`). Any CSS colour. */
+    primary?: string;
+    /** Foreground to pair with a custom `primary`. Auto-derived from the lightness
+     *  of `primary` when omitted (understands hex, `oklch()`, `hsl()`). */
+    primaryForeground?: string;
+    /** @deprecated alias for `primary`. */
+    accent?: string;
+    /** @deprecated alias for `primaryForeground`. */
+    accentContrast?: string;
+    /** `--orynn-font-family`. */
+    font?: string;
+    /** Base font size, e.g. `"15px"` or `"0.95rem"`. */
+    fontSize?: string | number;
+    /** Corner radius base (`--orynn-radius`). Keyword, CSS length, or px number. */
+    radius?: OrynnRadius;
+    /** Default control width. `"100%"` by default. */
+    controlWidth?: string | number;
+    /** Cap on control width. `"450px"` by default; number = px; `"none"` to uncap. */
+    controlMaxWidth?: string | number;
+    /** Focus-ring colour (`--orynn-color-ring`). */
+    ring?: string;
+    /** Escape hatch: any `--orynn-*` variables verbatim. */
+    vars?: OrynnVarOverrides;
+}
+/** `theme` prop accepts a preset name shorthand or a full config. */
+type OrynnThemeInput = OrynnPreset | OrynnThemeConfig;
+/** Build the inline CSS-variable style object for a theme config. */
+declare function resolveThemeVars(config: OrynnThemeConfig): CSSProperties;
+
+interface OrynnContextValue {
+    preset: OrynnPreset;
+    density: OrynnDensity;
+    config: OrynnThemeConfig;
+    /**
+     * A themed `<div class="orynn-portal">` appended to `document.body` (or `null`
+     * before the mount effect / on the server). Radix `*.Portal`s and the internal
+     * `<Popover>` render into it so portalled content inherits this provider's
+     * theme even though it sits outside the provider's DOM subtree.
+     */
+    portalContainer: HTMLElement | null;
+}
+interface OrynnProviderProps {
+    /** Preset name (`"teal"`) or a full config object. */
+    theme?: OrynnThemeInput;
+    /** Render a `<div>` (default) or a different element / no wrapper (`"contents"`). */
+    as?: "div" | "span" | "contents";
+    className?: string;
+    children: ReactNode;
+}
+/**
+ * Scopes an Orynn theme to its subtree by setting `data-orynn-theme`,
+ * `data-orynn-density`, a `.dark` class and any custom `--orynn-*` variables on a
+ * wrapper element. Purely CSS custom properties — no runtime styling engine.
+ * Nesting is supported; an inner provider overrides only what it sets. Also
+ * mounts a matching `<div class="orynn-portal">` on `document.body` so portalled
+ * overlays (Dialog, Popover, Tooltip, menus) render with the same theme.
+ */
+declare function OrynnProvider({ theme, as, className, children }: OrynnProviderProps): react.JSX.Element;
+/** Read the nearest Orynn theme config. */
+declare function useOrynnTheme(): OrynnContextValue;
+/**
+ * The DOM node Radix portals / the internal `<Popover>` should render into so
+ * portalled content stays themed. Falls back to `document.body` when there is no
+ * `<OrynnProvider>` (the theme then lives on `:root` / `html` and body inherits
+ * it anyway). `null` only on the server.
+ */
+declare function usePortalContainer(): HTMLElement | null;
 
 /**
  * Create an isolated field registry. Use this to give a `<Fieldset>` its own set
@@ -374,21 +1376,29 @@ declare const defaultRegistry: FieldRegistry;
  */
 declare function registerField(type: string, registration: FieldRegistration): void;
 
-/** A synchronous resolver — the built-in resolver's precise return type. */
+/** A synchronous resolver — the built-in resolver's return type when no rule is async. */
 type SyncResolver = (values: Record<string, unknown>, config: FieldsetConfig, context: ValidationContext) => ValidationResult;
 /**
- * The default, rule-based {@link ValidationResolver}. For every field with a
- * `validation` block, each key (other than `messages`) is looked up in the rule
- * registry and run against the field's current value. All fields are validated
- * on every call; callers decide which errors to surface.
- *
- * Synchronous today. Async, schema-based, and cross-field resolvers plug in at
- * the same seam without an API change.
+ * The default, rule-based {@link ValidationResolver}. For every visible field
+ * with a `validation` block, each key (other than `messages`) is looked up in
+ * the rule registry and run against the field's current value. Fields whose
+ * `when` condition is false are skipped. Returns synchronously unless a rule
+ * (e.g. `validate`) resolves asynchronously.
  */
-declare function createRuleResolver(): SyncResolver;
+declare function createRuleResolver(): ValidationResolver;
 /** Shared default instance. */
 declare const defaultResolver: ValidationResolver;
 
+/**
+ * Built-in rules. Each returns a token (rule name) on failure or `null` on
+ * success; the resolver turns the token into a user-facing message. Rules other
+ * than `required` skip empty values so `required` owns that error.
+ *
+ * `validate` is special: its param is a function `(value, allValues) => string |
+ * boolean | null | Promise<…>`; a string is the message, `false` a generic
+ * failure, `true` / `null` a pass.
+ */
+declare const builtInRules: Record<string, RuleFn>;
 /**
  * Register a validation rule for the built-in resolver. A field opts in by
  * adding a key of the same name to its `validation` config.
@@ -397,4 +1407,44 @@ declare const defaultResolver: ValidationResolver;
  */
 declare function registerRule(name: string, fn: RuleFn): void;
 
-export { type BaseFieldConfig, type ColumnSpec, type ControlComponent, type ControlProps, Dropdown, type DropdownFieldConfig, type DropdownOption, type DropdownProps, type ErrorProp, FORM_ERROR_KEY, Field, type FieldConfig, type FieldConfigRegistry, type FieldError, type FieldProps, type FieldRegistration, type FieldRegistry, type FieldRenderContext, type FieldSlice, type FieldStatus, type FieldType, type FieldValidation, Fieldset, type FieldsetConfig, type FieldsetProps, type FieldsetState, Input, type InputFieldConfig, type InputProps, type NormalizedFieldsetConfig, type RuleFn, type SyncResolver, type UseFieldsetStateOptions, type UseFieldsetStateReturn, type ValidationContext, type ValidationResolver, type ValidationResult, type ValidationTrigger, createRegistry, createRuleResolver, defaultRegistry, defaultResolver, normalizeConfig, registerField, registerRule, useFieldsetState };
+/**
+ * Minimal shape of the [Standard Schema](https://standardschema.dev) `v1`
+ * contract — implemented by Zod 3.24+, Valibot 1.0+, ArkType 2+, and others.
+ * Inlined so Orynn needs no dependency.
+ */
+interface StandardSchemaV1<Output = unknown> {
+    readonly "~standard": {
+        readonly version: 1;
+        readonly vendor: string;
+        readonly validate: (value: unknown) => StandardResult<Output> | Promise<StandardResult<Output>>;
+    };
+}
+type StandardResult<Output> = {
+    readonly value: Output;
+    readonly issues?: undefined;
+} | {
+    readonly issues: ReadonlyArray<StandardIssue>;
+};
+interface StandardIssue {
+    readonly message: string;
+    readonly path?: ReadonlyArray<PropertyKey | {
+        readonly key: PropertyKey;
+    }>;
+}
+/**
+ * Turn a Standard Schema (Zod / Valibot / ArkType / …) into an Orynn
+ * {@link ValidationResolver}. Pass it to `<Fieldset resolver={…}>` or
+ * `useFieldsetState({ resolver })`.
+ *
+ * ```ts
+ * import { z } from "zod";
+ * const schema = z.object({ email: z.string().email(), age: z.number().min(18) });
+ * <Fieldset config={config} resolver={standardSchemaResolver(schema)} />
+ * ```
+ *
+ * Issues are keyed by the first path segment (the field name); path-less issues
+ * land under `"$form"`.
+ */
+declare function standardSchemaResolver(schema: StandardSchemaV1): ValidationResolver;
+
+export { Alert, AlertDescription, type AlertProps, AlertTitle, type AlertVariant, Badge, type BadgeProps, type BadgeVariant, type BaseControlProps, type BaseFieldConfig, Button, type ButtonProps, type ButtonSize, type ButtonVariant, Card, CardAction, CardContent, CardDescription, CardFooter, CardHeader, type CardProps, CardTitle, Checkbox, type CheckboxFieldConfig, CheckboxGroup, type CheckboxGroupFieldConfig, type CheckboxGroupProps, type CheckboxOption, type CheckboxProps, type ColumnSpec, type ControlComponent, type ControlProps, type ControlRadius, type ControlSize, type ControlVariant, type CustomValidator, type DateFieldConfig, DatePicker, type DatePickerProps, Dialog, DialogClose, DialogContent, type DialogContentProps, DialogDescription, DialogFooter, DialogHeader, DialogPortal, DialogTitle, DialogTrigger, Dropdown, type DropdownFieldConfig, DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, type DropdownMenuContentProps, DropdownMenuGroup, DropdownMenuItem, type DropdownMenuItemProps, DropdownMenuLabel, type DropdownMenuLabelProps, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, type DropdownMenuSubTriggerProps, DropdownMenuTrigger, type DropdownOption, type DropdownProps, type EqualsRule, type ErrorProp, FORM_ERROR_KEY, type Feedback, Field, FieldBox, type FieldBoxProps, type FieldCondition, type FieldConfig, type FieldConfigRegistry, type FieldError, type FieldProps, type FieldRegistration, type FieldRegistry, type FieldRenderContext, type FieldSlice, type FieldStatus, type FieldType, type FieldValidation, Fieldset, type FieldsetConfig, type FieldsetProps, type FieldsetState, FieldsetView, type FieldsetViewProps, Form, type FormProps, Input, type InputFieldConfig, type InputProps, Label, type LabelProps, type NormalizedFieldsetConfig, NumberField, type NumberFieldConfig, type NumberFieldProps, type OrynnDensity, type OrynnPreset, OrynnProvider, type OrynnProviderProps, type OrynnRadius, type OrynnThemeConfig, type OrynnThemeInput, type OrynnVarOverrides, type PatternRule, Popover, PopoverAnchor, PopoverArrow, PopoverClose, PopoverContent, type PopoverContentProps, PopoverTrigger, Radio, type RadioFieldConfig, RadioGroup, type RadioGroupProps, type RadioOption, type RadioProps, type RuleFn, Dropdown as Select, Separator, type SeparatorProps, type StandardSchemaV1, Switch, type SwitchProps, type SyncResolver, Table, TableBody, TableCaption, TableCell, TableFooter, TableHead, TableHeader, type TableHeaderProps, type TableProps, TableRow, type TableRowProps, Tabs, TabsContent, TabsList, type TabsProps, TabsTrigger, Textarea, type TextareaFieldConfig, type TextareaProps, Tooltip, TooltipContent, type TooltipContentProps, type TooltipProps, TooltipProvider, TooltipTrigger, type UseFieldsetStateOptions, type UseFieldsetStateReturn, type ValidationContext, type ValidationResolver, type ValidationResult, type ValidationTrigger, badgeClasses, builtInRules, buttonClasses, createRegistry, createRuleResolver, defaultRegistry, defaultResolver, normalizeConfig, registerField, registerRule, resolveThemeVars, standardSchemaResolver, useFieldsetState, useOrynnTheme, usePortalContainer };