orynn 0.2.0 → 0.6.0

package/dist/index.d.cts

@@ -1,5 +1,6 @@
 import * as react from 'react';
-import { ReactNode, HTMLAttributes, InputHTMLAttributes, ChangeEvent, ComponentType, SyntheticEvent, TextareaHTMLAttributes, CSSProperties, FormEvent } from 'react';
+import { ReactNode, HTMLAttributes, InputHTMLAttributes, ChangeEvent, ComponentType, SyntheticEvent, TextareaHTMLAttributes, FormEvent, FormHTMLAttributes, ComponentPropsWithoutRef, ComponentProps, MouseEvent, CSSProperties } from 'react';
+import { Accordion as Accordion$1, Slider as Slider$1, Progress as Progress$1, 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";
@@ -22,6 +23,10 @@ interface FieldBoxOwnProps {
     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;
 }
@@ -98,6 +103,8 @@ interface CheckboxOption {
     label: ReactNode;
     value: string;
     description?: ReactNode;
+    /** Leading icon shown before the label. */
+    icon?: ReactNode;
     disabled?: boolean;
 }
 interface CheckboxGroupProps {
@@ -113,10 +120,15 @@ interface CheckboxGroupProps {
     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;
@@ -125,47 +137,159 @@ interface CheckboxGroupProps {
 }
 declare function CheckboxGroup(props: CheckboxGroupProps): react.JSX.Element;
 
-interface DatePickerProps extends Omit<BaseControlProps, "startContent" | "endContent" | "loading"> {
-    value?: Date | string | null;
-    defaultValue?: Date | string | null;
-    onChange?: (value: Date | null) => void;
-    /** Display / parse pattern (`yyyy MM dd M d MMM MMMM`). Default `"yyyy-MM-dd"`. */
-    format?: string;
+/** 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 `"dd-MMM-yyyy"` (renders e.g.
+     * `12-Jan-2020`); pass `"yyyy-MM-dd"` for ISO.
+     */
+    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;
+    /**
+     * Lower bound for the calendar's width (`--orynn-calendar-min-width`). The
+     * calendar otherwise fills the popover, which tracks the trigger width.
+     * Number = px.
+     */
+    calendarWidth?: number | string;
+    /** 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. Default true. */
+    /** 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;
 }
 /**
@@ -183,17 +307,17 @@ 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 for `Dropdown` / a {@link DropdownFieldConfig}. */
 interface DropdownOption {
@@ -213,6 +337,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. */
@@ -224,20 +360,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;
+}
+/** 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;
 }
-/** Native `<select>` field. */
+/** 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
@@ -253,7 +512,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];
@@ -264,13 +529,27 @@ 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;
@@ -279,7 +558,7 @@ interface OptionState {
     query: string;
 }
 interface DropdownProps extends Omit<BaseControlProps, "startContent" | "endContent"> {
-    options: DropdownOption[];
+    options: DropdownOption[] | DropdownOptionGroup[];
     value?: string | string[] | null;
     defaultValue?: string | string[] | null;
     onChange?: (value: string | string[] | null) => void;
@@ -292,15 +571,40 @@ interface DropdownProps extends Omit<BaseControlProps, "startContent" | "endCont
     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>>;
 
@@ -325,12 +629,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. */
@@ -423,6 +740,11 @@ interface FieldsetProps<TValues extends Record<string, unknown> = Record<string,
 declare function Field(props: FieldProps): react.JSX.Element;
 
 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;
@@ -434,41 +756,91 @@ interface InputProps extends BaseControlProps, NativeInput {
     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;
-    /** Show a live character counter. Pairs well with `maxLength`. */
-    showCount?: 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">;
+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;
-    /** Decimal places to keep. */
+    /** 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;
-    /** ISO currency code — renders as currency. */
+    /** 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;
-    /** Clamp to `[min, max]` on blur. Default true. */
+    /** 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>>;
 
@@ -488,6 +860,8 @@ interface RadioOption {
     label: ReactNode;
     value: string;
     description?: ReactNode;
+    /** Leading icon shown before the label. */
+    icon?: ReactNode;
     disabled?: boolean;
 }
 interface RadioGroupProps {
@@ -504,6 +878,8 @@ interface RadioGroupProps {
     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;
@@ -512,17 +888,22 @@ interface RadioGroupProps {
 declare function RadioGroup(props: RadioGroupProps): react.JSX.Element;
 
 type NativeTextarea = Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, "value" | "defaultValue" | "onChange" | "rows" | "cols">;
-interface TextareaProps extends Omit<BaseControlProps, "startContent" | "endContent" | "loading">, NativeTextarea {
+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";
-    showCount?: boolean;
+    /** Live counter — `true`, or `{ max?, formatter?(count, max) }`. */
+    showCount?: ShowCount;
 }
 declare const Textarea: react.ForwardRefExoticComponent<TextareaProps & react.RefAttributes<HTMLTextAreaElement>>;
 
@@ -530,66 +911,10 @@ declare const Textarea: react.ForwardRefExoticComponent<TextareaProps & react.Re
  * 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;
 
-/** Built-in colour presets. Each maps to `[data-orynn-theme="…"]` in the stylesheet. */
-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" | "pill" | (string & {}) | number;
-/** Any `--orynn-*` custom property. */
-type OrynnVarOverrides = Partial<Record<`--orynn-${string}`, string | number>>;
-interface OrynnThemeConfig {
-    /** Colour preset. Defaults to `"default"` (indigo). */
-    preset?: OrynnPreset;
-    density?: OrynnDensity;
-    /** Highlight / accent colour. Any CSS colour — overrides the preset's accent. */
-    accent?: string;
-    /** Foreground colour to pair with a custom `accent` (auto-picked from luminance if omitted). */
-    accentContrast?: string;
-    /** `--orynn-font-family`. */
-    font?: string;
-    /** Base font size, e.g. `"15px"` or `"0.95rem"`. */
-    fontSize?: string | number;
-    /** Corner radius applied to controls. Keyword, CSS length, or px number. */
-    radius?: OrynnRadius;
-    /** Default control width. `"100%"` by default; e.g. `"20rem"` or `320`. */
-    controlWidth?: string | number;
-    /** Focus-ring colour. */
-    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;
-}
-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` 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.
- */
-declare function OrynnProvider({ theme, as, className, children }: OrynnProviderProps): react.JSX.Element;
-/** Read the nearest Orynn theme config. */
-declare function useOrynnTheme(): OrynnContextValue;
-
 /** Form-level validation roll-up. */
 type FieldStatus = "idle" | "validating" | "valid" | "invalid";
 /** The complete state a fieldset tracks. New keys must be additive. */
@@ -607,6 +932,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;
@@ -622,8 +949,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>;
@@ -645,7 +972,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;
@@ -666,7 +993,615 @@ 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 AccordionVariant = "bordered" | "separated" | "ghost";
+type AccordionSize = "sm" | "md" | "lg";
+type RootProps$2 = ComponentPropsWithoutRef<typeof Accordion$1.Root>;
+type AccordionProps = RootProps$2 & {
+    /** `bordered` (default, dividers) · `separated` (each item a card) · `ghost` (no chrome). */
+    variant?: AccordionVariant;
+    /** Trigger padding + type scale. Default `md`. */
+    size?: AccordionSize;
+};
+/**
+ * A stack of collapsible sections. Thin wrapper over Radix Accordion — every
+ * Root prop (`type`, `collapsible`, `value` / `defaultValue`, `onValueChange`,
+ * `disabled`, `orientation`, `dir`) passes straight through.
+ */
+declare const Accordion: react.ForwardRefExoticComponent<AccordionProps & react.RefAttributes<HTMLDivElement>>;
+declare const AccordionItem: react.ForwardRefExoticComponent<Omit<Accordion$1.AccordionItemProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+interface AccordionTriggerProps extends ComponentPropsWithoutRef<typeof Accordion$1.Trigger> {
+    /** Indicator icon. Defaults to a chevron that rotates on open. */
+    icon?: ReactNode;
+    /** Which side the icon sits on. Default `end`. */
+    iconPosition?: "start" | "end";
+    /** Drop the indicator entirely. */
+    hideIcon?: boolean;
+}
+declare const AccordionTrigger: react.ForwardRefExoticComponent<AccordionTriggerProps & react.RefAttributes<HTMLButtonElement>>;
+declare const AccordionContent: react.ForwardRefExoticComponent<Omit<Accordion$1.AccordionContentProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+
+type ButtonVariant = "default" | "secondary" | "destructive" | "outline" | "ghost" | "link";
+type ButtonSize = "default" | "sm" | "lg" | "icon";
+type ButtonHoverEffect = "darken" | "lift" | "glow" | "outline-fill" | "none";
+type ButtonFocusStyle = "ring" | "solid" | "ring-inset" | "none";
+type ButtonCursor = "pointer" | "default" | "auto";
+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;
+    /**
+     * Hover treatment. `"darken"` (default) shades the fill; `"lift"` adds a
+     * raise + shadow; `"glow"` adds a soft ring; `"outline-fill"` floods the
+     * fill on hover (nice on `ghost` / `outline`); `"none"` disables the hover
+     * change. Retune via `--orynn-button-hover-*` / `--orynn-button-glow`.
+     */
+    hoverEffect?: ButtonHoverEffect;
+    /**
+     * Focus-visible treatment. `"ring"` (default) = border + soft ring halo;
+     * `"solid"` = a crisp outline; `"ring-inset"` = the halo drawn inside the
+     * edge; `"none"` = no focus styling (supply your own).
+     */
+    focusStyle?: ButtonFocusStyle;
+    /**
+     * Pressed / active state — a token-styled toggle look. Also sets
+     * `aria-pressed`. Retune via `--orynn-button-selected-*`.
+     */
+    selected?: boolean;
+    /** Idle cursor. `"pointer"` (default) · `"default"` · `"auto"`. */
+    cursor?: ButtonCursor;
+}
+declare const Button: react.ForwardRefExoticComponent<Omit<ButtonProps, "ref"> & react.RefAttributes<HTMLButtonElement>>;
+
+type RootProps$1 = ComponentPropsWithoutRef<typeof Slider$1.Root>;
+interface SliderMark {
+    value: number;
+    label?: ReactNode;
+}
+interface SliderProps extends Omit<RootProps$1, "value" | "defaultValue" | "asChild"> {
+    /** Controlled value. A scalar is treated as a single-thumb slider. */
+    value?: number | number[];
+    /** Uncontrolled initial value. Scalar → one thumb. Default `min`. */
+    defaultValue?: number | number[];
+    /** Track / thumb scale. Default `md`. */
+    size?: "sm" | "md" | "lg";
+    /** Ticks + labels pinned under the track at these values. */
+    marks?: SliderMark[];
+    /** Render a tick at every `step` (skipped when that would be > 60 ticks). */
+    showTicks?: boolean;
+    /** Value bubble over the thumb. Default `"none"`. */
+    tooltip?: "always" | "hover" | "none";
+    /** Format the tooltip / aria value text. */
+    formatValue?: (value: number) => ReactNode;
+}
+declare const Slider: react.ForwardRefExoticComponent<SliderProps & react.RefAttributes<HTMLSpanElement>>;
+
+type RootProps = ComponentPropsWithoutRef<typeof Progress$1.Root>;
+interface ProgressProps extends Omit<RootProps, "value" | "getValueLabel"> {
+    /** 0–`max`, or `null` / omitted for an indeterminate bar. */
+    value?: number | null;
+    max?: number;
+    /** `line` (default) or `circle`. */
+    shape?: "line" | "circle";
+    /** Thickness / diameter scale. Default `md`. */
+    size?: "sm" | "md" | "lg";
+    /** Colour role. Default `default` (primary). */
+    variant?: "default" | "success" | "warning" | "destructive";
+    /** Render the percentage (line: trailing; circle: centred). */
+    showValue?: boolean;
+    /** Text shown alongside the bar (line only). */
+    label?: ReactNode;
+    /** Diagonal stripes (line only). */
+    striped?: boolean;
+    /** Animate the stripes (implies `striped`, line only). */
+    animated?: boolean;
+    /** Corner radius override for the line track. */
+    radius?: string | number;
+    /** Ring stroke width, px (circle only). Default 4 / 5 / 6 by size. */
+    circleThickness?: number;
+    /** Ring diameter, px (circle only). Default 40 / 56 / 72 by size. */
+    circleSize?: number;
+    /** Format the value text. */
+    formatValue?: (value: number, max: number) => ReactNode;
+}
+declare const Progress: react.ForwardRefExoticComponent<ProgressProps & react.RefAttributes<HTMLDivElement>>;
+
+type ToastVariant = "default" | "success" | "error" | "warning" | "info" | "loading";
+interface ToastAction {
+    label: ReactNode;
+    onClick: () => void;
+    /** Screen-reader text for the action (Radix requires it). Defaults to the label if it's a string. */
+    altText?: string;
+}
+interface ToastOptions {
+    id?: string;
+    title?: ReactNode;
+    description?: ReactNode;
+    variant?: ToastVariant;
+    /** ms before auto-dismiss. `0` / `Infinity` = sticky. Falls back to the Toaster's `duration`. */
+    duration?: number;
+    action?: ToastAction;
+    /** Custom leading icon. `null` hides the default variant icon. */
+    icon?: ReactNode | null;
+    /** Show the close button for this toast (defaults to the Toaster setting). */
+    dismissible?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}
+interface ToastRecord extends ToastOptions {
+    id: string;
+    createdAt: number;
+}
+type ToastInput = ReactNode | ToastOptions;
+interface ToastFn {
+    (message: ToastInput, opts?: ToastOptions): string;
+    success: (message: ToastInput, opts?: ToastOptions) => string;
+    error: (message: ToastInput, opts?: ToastOptions) => string;
+    warning: (message: ToastInput, opts?: ToastOptions) => string;
+    info: (message: ToastInput, opts?: ToastOptions) => string;
+    loading: (message: ToastInput, opts?: ToastOptions) => string;
+    dismiss: (id?: string) => void;
+    promise: <T>(promise: Promise<T>, msgs: {
+        loading: ToastInput;
+        success: ToastInput | ((value: T) => ToastInput);
+        error: ToastInput | ((err: unknown) => ToastInput);
+    }, opts?: ToastOptions) => Promise<T>;
+}
+declare const toast: ToastFn;
+
+type ToastPosition = "top-left" | "top-center" | "top-right" | "bottom-left" | "bottom-center" | "bottom-right";
+interface ToasterProps {
+    /** Corner / edge the stack lives in. Default `"bottom-right"`. */
+    position?: ToastPosition;
+    /** Default auto-dismiss in ms. Default `4000`. */
+    duration?: number;
+    /** Max toasts shown at once (older ones wait). Default `4`. */
+    visibleToasts?: number;
+    /** Show a close button on every toast. Default `true`. */
+    closeButton?: boolean;
+    /** Tint the whole toast by variant instead of just the icon. Default `false`. */
+    richColors?: boolean;
+    /** Gap between stacked toasts, px. Default `12`. */
+    gap?: number;
+    /** Offset from the viewport edge, px. Default `24`. */
+    offset?: number;
+    className?: string;
+}
+/**
+ * Drop one `<Toaster />` near the app root. Fire toasts imperatively from
+ * anywhere with `toast("Saved")`, `toast.success(...)`, `toast.promise(...)`.
+ */
+declare function Toaster({ position, duration, visibleToasts, closeButton, richColors, gap, offset, className, }: ToasterProps): react.JSX.Element;
+/** Hook form of the imperative API, plus the live toast list. */
+declare function useToast(): {
+    toast: ToastFn;
+    dismiss: (id?: string) => void;
+    toasts: ToastRecord[];
+};
+
+interface UsePaginationOptions {
+    /** 1-based current page. */
+    page: number;
+    /** Total number of pages. Or give `total` + `pageSize`. */
+    count?: number;
+    /** Total item count — used with `pageSize` when `count` is absent. */
+    total?: number;
+    /** Items per page — used with `total`. Default 10. */
+    pageSize?: number;
+    /** Pages shown either side of the current one. Default 1. */
+    siblingCount?: number;
+    /** Pages pinned at each end. Default 1. */
+    boundaryCount?: number;
+}
+type PaginationSlot = number | "ellipsis-start" | "ellipsis-end";
+interface UsePaginationResult {
+    /** Resolved total page count (>= 1). */
+    pageCount: number;
+    /** Clamped current page. */
+    page: number;
+    hasPrev: boolean;
+    hasNext: boolean;
+    /** The row to render: page numbers with `"ellipsis-*"` gaps. */
+    slots: PaginationSlot[];
+}
+/**
+ * Pure model for a pagination control — the page numbers to show, where the
+ * gaps go, and whether prev/next are live. UI-agnostic; drive any markup with it.
+ */
+declare function usePagination({ page, count, total, pageSize, siblingCount, boundaryCount, }: UsePaginationOptions): UsePaginationResult;
+
+type PaginationSize = "sm" | "md" | "lg";
+type PaginationVariant = "outline" | "ghost" | "solid";
+declare const PaginationContent: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & react.RefAttributes<HTMLUListElement>>;
+declare const PaginationItem: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & react.RefAttributes<HTMLLIElement>>;
+interface PaginationLinkProps extends ComponentProps<"button"> {
+    /** Marks the current page. */
+    isActive?: boolean;
+    /** Corner treatment for the item. */
+    size?: PaginationSize;
+}
+declare const PaginationLink: react.ForwardRefExoticComponent<Omit<PaginationLinkProps, "ref"> & react.RefAttributes<HTMLButtonElement>>;
+declare const PaginationEllipsis: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & react.RefAttributes<HTMLSpanElement>>;
+interface PaginationLabels {
+    previous?: string;
+    next?: string;
+    first?: string;
+    last?: string;
+    page?: (n: number) => string;
+    ariaLabel?: string;
+}
+interface PaginationProps extends Omit<ComponentProps<"nav">, "onChange">, UsePaginationOptions {
+    onPageChange: (page: number) => void;
+    /** Show jump-to-first / jump-to-last controls. Default `false`. */
+    showFirstLast?: boolean;
+    /** Show the prev / next controls. Default `true`. */
+    showPrevNext?: boolean;
+    /** Render prev/next as bare arrows (no text). Default `false`. */
+    iconOnly?: boolean;
+    size?: PaginationSize;
+    variant?: PaginationVariant;
+    disabled?: boolean;
+    labels?: PaginationLabels;
+    /** Custom prev / next glyphs. */
+    prevIcon?: ReactNode;
+    nextIcon?: ReactNode;
+}
+declare const Pagination: react.ForwardRefExoticComponent<Omit<PaginationProps, "ref"> & react.RefAttributes<HTMLElement>>;
+
+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
@@ -692,21 +1627,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.
@@ -715,4 +1658,44 @@ declare const defaultResolver: ValidationResolver;
  */
 declare function registerRule(name: string, fn: RuleFn): void;
 
-export { type BaseControlProps, type BaseFieldConfig, Checkbox, CheckboxGroup, type CheckboxGroupProps, type CheckboxOption, type CheckboxProps, type ColumnSpec, type ControlComponent, type ControlProps, type ControlRadius, type ControlSize, type ControlVariant, DatePicker, type DatePickerProps, Dropdown, type DropdownFieldConfig, type DropdownOption, type DropdownProps, type ErrorProp, FORM_ERROR_KEY, type Feedback, Field, FieldBox, type FieldBoxProps, 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, NumberField, type NumberFieldProps, type OrynnDensity, type OrynnPreset, OrynnProvider, type OrynnProviderProps, type OrynnRadius, type OrynnThemeConfig, type OrynnThemeInput, type OrynnVarOverrides, Radio, RadioGroup, type RadioGroupProps, type RadioOption, type RadioProps, type RuleFn, Dropdown as Select, type SyncResolver, Textarea, type TextareaProps, type UseFieldsetStateOptions, type UseFieldsetStateReturn, type ValidationContext, type ValidationResolver, type ValidationResult, type ValidationTrigger, createRegistry, createRuleResolver, defaultRegistry, defaultResolver, normalizeConfig, registerField, registerRule, resolveThemeVars, useFieldsetState, useOrynnTheme };
+/**
+ * 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 { Accordion, AccordionContent, AccordionItem, type AccordionProps, type AccordionSize, AccordionTrigger, type AccordionTriggerProps, type AccordionVariant, Alert, AlertDescription, type AlertProps, AlertTitle, type AlertVariant, Badge, type BadgeProps, type BadgeVariant, type BaseControlProps, type BaseFieldConfig, Button, type ButtonCursor, type ButtonFocusStyle, type ButtonHoverEffect, 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, Pagination, PaginationContent, PaginationEllipsis, PaginationItem, type PaginationLabels, PaginationLink, type PaginationLinkProps, type PaginationProps, type PaginationSize, type PaginationSlot, type PaginationVariant, type PatternRule, Popover, PopoverAnchor, PopoverArrow, PopoverClose, PopoverContent, type PopoverContentProps, PopoverTrigger, Progress, type ProgressProps, Radio, type RadioFieldConfig, RadioGroup, type RadioGroupProps, type RadioOption, type RadioProps, type RuleFn, Dropdown as Select, Separator, type SeparatorProps, Slider, type SliderMark, type SliderProps, 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, type ToastAction, type ToastFn, type ToastOptions, type ToastPosition, type ToastRecord, type ToastVariant, Toaster, type ToasterProps, Tooltip, TooltipContent, type TooltipContentProps, type TooltipProps, TooltipProvider, TooltipTrigger, type UseFieldsetStateOptions, type UseFieldsetStateReturn, type UsePaginationOptions, type UsePaginationResult, type ValidationContext, type ValidationResolver, type ValidationResult, type ValidationTrigger, badgeClasses, builtInRules, buttonClasses, createRegistry, createRuleResolver, defaultRegistry, defaultResolver, normalizeConfig, registerField, registerRule, resolveThemeVars, standardSchemaResolver, toast, useFieldsetState, useOrynnTheme, usePagination, usePortalContainer, useToast };