@ansh-ui/vue 0.2.0

package/dist/form.d.ts

@@ -0,0 +1,2639 @@
+import * as vue from 'vue';
+import { PropType, ComputedRef } from 'vue';
+import { S as SlotContent } from './utils-IKPG3zcC.js';
+
+/**
+ * The label / description / error scaffolding every form control shares — the Vue counterpart of
+ * `@ansh-ui/react`'s `Field`.
+ *
+ * Wiring this by hand is where forms lose their accessibility. The control needs `id` matching the
+ * label's `for`, `aria-describedby` pointing at *both* the hint and the error, and `aria-invalid`
+ * when it's wrong. Six attributes across four elements, per field — so in practice some fields get
+ * it and some don't.
+ *
+ * `Field` generates the ids and distributes them through `provide`/`inject`, so a control only has
+ * to spread what `useFieldControl()` returns.
+ *
+ * ```vue
+ * <Field label="Work email" description="We'll never share it." :error="errors.email">
+ *   <Input type="email" v-model="email" />
+ * </Field>
+ * ```
+ */
+interface FieldContextValue {
+    id: string;
+    describedBy: string | undefined;
+    invalid: boolean;
+    required: boolean;
+    disabled: boolean;
+}
+interface FieldControlAttrs {
+    id?: string;
+    'aria-describedby'?: string;
+    'aria-invalid'?: true;
+    'aria-required'?: true;
+    disabled?: boolean;
+}
+/**
+ * Props a control should spread onto its interactive element.
+ *
+ * Returns an empty object outside a `Field`, so every control works standalone — a control that
+ * throws without a wrapper is a control people stop using.
+ *
+ * **Returns a `ComputedRef`, not a plain object — read `.value` inside your render function, never
+ * destructure it in `setup()`.** `inject()` may only be called during `setup()`, which runs once per
+ * instance, so the lookup itself happens once; but `Field`'s `error`/`disabled`/`description` are
+ * reactive props that can change after that. Wrapping the derived attrs in `computed()` means the
+ * getters on the injected context (which close over `Field`'s own reactive props) are re-evaluated
+ * — and correctly tracked — every time this control re-renders. Returning a plain object built with
+ * a one-time spread would freeze the very first render's values forever, which is a real bug this
+ * exact shape produced during development: a field that started valid and then failed validation
+ * never gained `aria-invalid` because the snapshot was taken before the error existed.
+ */
+declare function useFieldControl(): ComputedRef<FieldControlAttrs>;
+/** The raw context, for controls that need the ids rather than the spreadable props. */
+declare function useFieldContext(): FieldContextValue | null;
+declare const Field: vue.DefineComponent<vue.ExtractPropTypes<{
+    label: {
+        type: PropType<SlotContent>;
+        default: undefined;
+    };
+    /** Helper text below the label. Announced as part of the control's description. */
+    description: {
+        type: PropType<SlotContent>;
+        default: undefined;
+    };
+    /** Error message. Its presence sets `aria-invalid` on the control. */
+    error: {
+        type: PropType<SlotContent>;
+        default: undefined;
+    };
+    /** Marks the field required and appends an asterisk to the label. */
+    required: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Label to the side rather than above — denser, for settings screens. */
+    orientation: {
+        type: PropType<"vertical" | "horizontal">;
+        default: string;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    label: {
+        type: PropType<SlotContent>;
+        default: undefined;
+    };
+    /** Helper text below the label. Announced as part of the control's description. */
+    description: {
+        type: PropType<SlotContent>;
+        default: undefined;
+    };
+    /** Error message. Its presence sets `aria-invalid` on the control. */
+    error: {
+        type: PropType<SlotContent>;
+        default: undefined;
+    };
+    /** Marks the field required and appends an asterisk to the label. */
+    required: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Label to the side rather than above — denser, for settings screens. */
+    orientation: {
+        type: PropType<"vertical" | "horizontal">;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    description: SlotContent;
+    error: SlotContent;
+    label: SlotContent;
+    disabled: boolean;
+    required: boolean;
+    orientation: "horizontal" | "vertical";
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+declare const Fieldset: vue.DefineComponent<vue.ExtractPropTypes<{
+    legend: {
+        type: PropType<SlotContent>;
+        required: true;
+    };
+    description: {
+        type: PropType<SlotContent>;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    legend: {
+        type: PropType<SlotContent>;
+        required: true;
+    };
+    description: {
+        type: PropType<SlotContent>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    description: SlotContent;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+/**
+ * Visually hidden, still announced.
+ *
+ * The clip-path technique rather than `display: none` or `visibility: hidden`, both of which remove
+ * the element from the accessibility tree entirely — which is the opposite of the intent.
+ */
+declare const VisuallyHidden: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+type InputSize = 'sm' | 'md' | 'lg';
+/**
+ * A text input — the Vue counterpart of `@ansh-ui/react`'s `Input`.
+ *
+ * `v-model` for two-way binding (backed by `modelValue`/`update:modelValue`), or leave it
+ * unbound for an uncontrolled field seeded from `defaultValue`. Both modes flow through the same
+ * `useControllableState`, so there's no separate uncontrolled code path to drift from the
+ * controlled one.
+ *
+ * Native attributes not declared as props (`type`, `placeholder`, `maxlength`, `autocomplete`, …)
+ * fall through automatically via Vue's attribute inheritance — `inheritAttrs: false` plus an
+ * explicit bind is only needed here because the *grouped* layout (a prefix, suffix or clear button)
+ * renders a wrapper `<div>` and the attributes must land on the inner `<input>`, not the wrapper.
+ *
+ * The affordance most inputs get wrong is the click target: with an icon inside the field, clicking
+ * the icon should focus the input. That works here because the wrapper forwards the click, rather
+ * than the icon being an absolutely positioned sibling that swallows it.
+ */
+declare const Input: vue.DefineComponent<vue.ExtractPropTypes<{
+    modelValue: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    defaultValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    size: {
+        type: PropType<InputSize>;
+        default: string;
+    };
+    /** Content inside the field, before the text — an icon or a currency symbol. */
+    prefix: {
+        type: PropType<SlotContent>;
+        default: undefined;
+    };
+    /** Content inside the field, after the text — a unit, or a button. */
+    suffix: {
+        type: PropType<SlotContent>;
+        default: undefined;
+    };
+    /** Show a clear button when non-empty. */
+    clearable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Force the error style outside a `Field`. */
+    invalid: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    readonly: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Class for the outer wrapper, when there is a prefix or suffix. */
+    wrapperClassName: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, ("clear" | "change" | "input" | "update:modelValue")[], "clear" | "change" | "input" | "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    modelValue: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    defaultValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    size: {
+        type: PropType<InputSize>;
+        default: string;
+    };
+    /** Content inside the field, before the text — an icon or a currency symbol. */
+    prefix: {
+        type: PropType<SlotContent>;
+        default: undefined;
+    };
+    /** Content inside the field, after the text — a unit, or a button. */
+    suffix: {
+        type: PropType<SlotContent>;
+        default: undefined;
+    };
+    /** Show a clear button when non-empty. */
+    clearable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Force the error style outside a `Field`. */
+    invalid: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    readonly: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Class for the outer wrapper, when there is a prefix or suffix. */
+    wrapperClassName: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{
+    onChange?: ((...args: any[]) => any) | undefined;
+    onInput?: ((...args: any[]) => any) | undefined;
+    onClear?: ((...args: any[]) => any) | undefined;
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}>, {
+    size: InputSize;
+    invalid: boolean;
+    disabled: boolean;
+    modelValue: string;
+    defaultValue: string;
+    prefix: SlotContent;
+    suffix: SlotContent;
+    clearable: boolean;
+    readonly: boolean;
+    wrapperClassName: string;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+/** A multi-line text input, optionally growing with its content. */
+declare const Textarea: vue.DefineComponent<vue.ExtractPropTypes<{
+    modelValue: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    defaultValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    /** Grow with the content instead of scrolling. */
+    autoResize: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Upper bound for `autoResize`, in rows. Default `12`. */
+    maxRows: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /** Show a live character count. Needs `maxlength` (passed through as a native attribute). */
+    showCount: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    invalid: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, ("change" | "input" | "update:modelValue")[], "change" | "input" | "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    modelValue: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    defaultValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    /** Grow with the content instead of scrolling. */
+    autoResize: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Upper bound for `autoResize`, in rows. Default `12`. */
+    maxRows: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /** Show a live character count. Needs `maxlength` (passed through as a native attribute). */
+    showCount: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    invalid: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    onChange?: ((...args: any[]) => any) | undefined;
+    onInput?: ((...args: any[]) => any) | undefined;
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}>, {
+    invalid: boolean;
+    modelValue: string;
+    defaultValue: string;
+    autoResize: boolean;
+    maxRows: number;
+    showCount: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+/**
+ * A numeric input with steppers — the Vue counterpart of `@ansh-ui/react`'s `NumberInput`.
+ *
+ * Deliberately `type="text"` with `inputmode="decimal"` rather than `type="number"`. Native number
+ * inputs silently discard invalid intermediate text (typing "1e" clears the field), scroll-wheel
+ * over a focused field changes the value by accident, and the spinner cannot be styled consistently
+ * across browsers. All three are real bugs users hit on data-entry screens.
+ */
+declare const NumberInput: vue.DefineComponent<vue.ExtractPropTypes<{
+    modelValue: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    defaultValue: {
+        type: NumberConstructor;
+        default: number;
+    };
+    min: {
+        type: NumberConstructor;
+        default: number;
+    };
+    max: {
+        type: NumberConstructor;
+        default: number;
+    };
+    step: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /** Decimal places to display. Default: inferred from `step`. */
+    precision: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    size: {
+        type: PropType<InputSize>;
+        default: string;
+    };
+    /** Unit shown after the number — "kg", "%", "days". */
+    unit: {
+        type: PropType<SlotContent>;
+        default: undefined;
+    };
+    /** Show the stepper buttons. Default `true`. */
+    steppers: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, ("change" | "update:modelValue")[], "change" | "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    modelValue: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    defaultValue: {
+        type: NumberConstructor;
+        default: number;
+    };
+    min: {
+        type: NumberConstructor;
+        default: number;
+    };
+    max: {
+        type: NumberConstructor;
+        default: number;
+    };
+    step: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /** Decimal places to display. Default: inferred from `step`. */
+    precision: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    size: {
+        type: PropType<InputSize>;
+        default: string;
+    };
+    /** Unit shown after the number — "kg", "%", "days". */
+    unit: {
+        type: PropType<SlotContent>;
+        default: undefined;
+    };
+    /** Show the stepper buttons. Default `true`. */
+    steppers: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    onChange?: ((...args: any[]) => any) | undefined;
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}>, {
+    size: InputSize;
+    disabled: boolean;
+    max: number;
+    modelValue: number;
+    defaultValue: number;
+    min: number;
+    step: number;
+    precision: number;
+    unit: SlotContent;
+    steppers: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+/**
+ * Binary and single-choice controls — the Vue counterpart of `@ansh-ui/react`'s `toggles.tsx`.
+ *
+ * All three wrap a **real** `<input>` rather than painting a div. That decision carries a lot: form
+ * submission works, `:checked` styling works, the label association works, autofill works, password
+ * managers and browser translation work, and every assistive technology already knows what the
+ * control is. The visual is a sibling element the input drives via `:checked + .indicator`.
+ *
+ * The input is not `display: none` — that removes it from the accessibility tree and the tab order.
+ * It is transparent and stretched over the control, so it stays focusable and clickable.
+ */
+type ChoiceSize = 'sm' | 'md';
+/**
+ * A binary control that submits with a form.
+ *
+ * `v-model` binds `checked`. `indeterminate` has no HTML attribute — it exists only as a DOM
+ * property, so it is set imperatively via a `watch` each time it changes, the same reason React's
+ * counterpart needs an effect for it.
+ */
+declare const Checkbox: vue.DefineComponent<vue.ExtractPropTypes<{
+    modelValue: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    defaultValue: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Neither checked nor unchecked — a parent whose children are partly selected. */
+    indeterminate: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    label: {
+        type: PropType<SlotContent>;
+        default: undefined;
+    };
+    description: {
+        type: PropType<SlotContent>;
+        default: undefined;
+    };
+    size: {
+        type: PropType<ChoiceSize>;
+        default: string;
+    };
+    invalid: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    modelValue: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    defaultValue: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Neither checked nor unchecked — a parent whose children are partly selected. */
+    indeterminate: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    label: {
+        type: PropType<SlotContent>;
+        default: undefined;
+    };
+    description: {
+        type: PropType<SlotContent>;
+        default: undefined;
+    };
+    size: {
+        type: PropType<ChoiceSize>;
+        default: string;
+    };
+    invalid: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}>, {
+    size: ChoiceSize;
+    description: SlotContent;
+    invalid: boolean;
+    label: SlotContent;
+    disabled: boolean;
+    modelValue: boolean;
+    defaultValue: boolean;
+    indeterminate: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+/**
+ * An on/off toggle.
+ *
+ * `role="switch"` rather than a plain checkbox: it makes a screen reader announce "on"/"off" instead
+ * of "checked"/"not checked", which is the difference between a setting and a selection.
+ *
+ * A switch applies immediately; a checkbox applies on submit. If the change needs a Save button, the
+ * control should be a checkbox.
+ */
+declare const Switch: vue.DefineComponent<vue.ExtractPropTypes<{
+    modelValue: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    defaultValue: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    label: {
+        type: PropType<SlotContent>;
+        default: undefined;
+    };
+    description: {
+        type: PropType<SlotContent>;
+        default: undefined;
+    };
+    /** Where the label sits. Default `'end'`; `'start'` suits settings rows. */
+    labelPosition: {
+        type: PropType<"start" | "end">;
+        default: string;
+    };
+    size: {
+        type: PropType<ChoiceSize>;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    modelValue: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    defaultValue: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    label: {
+        type: PropType<SlotContent>;
+        default: undefined;
+    };
+    description: {
+        type: PropType<SlotContent>;
+        default: undefined;
+    };
+    /** Where the label sits. Default `'end'`; `'start'` suits settings rows. */
+    labelPosition: {
+        type: PropType<"start" | "end">;
+        default: string;
+    };
+    size: {
+        type: PropType<ChoiceSize>;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}>, {
+    size: ChoiceSize;
+    description: SlotContent;
+    label: SlotContent;
+    disabled: boolean;
+    modelValue: boolean;
+    defaultValue: boolean;
+    labelPosition: "start" | "end";
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+interface RadioGroupProps {
+    modelValue?: string;
+    defaultValue?: string;
+    /** Shared `name`. Generated when omitted, which is fine outside a native form. */
+    name?: string;
+    label?: string;
+    orientation?: 'vertical' | 'horizontal';
+    disabled?: boolean;
+}
+/**
+ * A group of mutually exclusive choices.
+ *
+ * Native radios already implement roving focus: arrow keys move between them and Tab enters and
+ * leaves the group as a unit. That behaviour is free as long as every input shares a `name`, which
+ * is what this context distributes — and it is why this doesn't reimplement key handling.
+ */
+declare const RadioGroup: vue.DefineComponent<vue.ExtractPropTypes<{
+    modelValue: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    defaultValue: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    name: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    label: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    orientation: {
+        type: PropType<"vertical" | "horizontal">;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    modelValue: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    defaultValue: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    name: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    label: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    orientation: {
+        type: PropType<"vertical" | "horizontal">;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}>, {
+    name: string;
+    label: string;
+    disabled: boolean;
+    orientation: "horizontal" | "vertical";
+    modelValue: string;
+    defaultValue: string;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+declare const Radio: vue.DefineComponent<vue.ExtractPropTypes<{
+    value: {
+        type: StringConstructor;
+        required: true;
+    };
+    label: {
+        type: PropType<SlotContent>;
+        default: undefined;
+    };
+    description: {
+        type: PropType<SlotContent>;
+        default: undefined;
+    };
+    size: {
+        type: PropType<ChoiceSize>;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    value: {
+        type: StringConstructor;
+        required: true;
+    };
+    label: {
+        type: PropType<SlotContent>;
+        default: undefined;
+    };
+    description: {
+        type: PropType<SlotContent>;
+        default: undefined;
+    };
+    size: {
+        type: PropType<ChoiceSize>;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    size: ChoiceSize;
+    description: SlotContent;
+    label: SlotContent;
+    disabled: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+/**
+ * A radio rendered as a selectable card — plan pickers, onboarding branches.
+ *
+ * Still a radio underneath, so keyboard and screen-reader behaviour is identical to the plain one.
+ * Selection is marked by a border *and* a check, never colour alone: WCAG 1.4.1 requires that colour
+ * not be the sole carrier of information, and roughly 1 in 12 men cannot rely on it.
+ */
+declare const ChoiceCard: vue.DefineComponent<vue.ExtractPropTypes<{
+    value: {
+        type: StringConstructor;
+        required: true;
+    };
+    label: {
+        type: PropType<SlotContent>;
+        default: undefined;
+    };
+    description: {
+        type: PropType<SlotContent>;
+        default: undefined;
+    };
+    icon: {
+        type: PropType<SlotContent>;
+        default: undefined;
+    };
+    size: {
+        type: PropType<ChoiceSize>;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    value: {
+        type: StringConstructor;
+        required: true;
+    };
+    label: {
+        type: PropType<SlotContent>;
+        default: undefined;
+    };
+    description: {
+        type: PropType<SlotContent>;
+        default: undefined;
+    };
+    icon: {
+        type: PropType<SlotContent>;
+        default: undefined;
+    };
+    size: {
+        type: PropType<ChoiceSize>;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    size: ChoiceSize;
+    description: SlotContent;
+    label: SlotContent;
+    disabled: boolean;
+    icon: SlotContent;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+/**
+ * Shared machinery for `Select` and `Combobox` — the Vue counterpart of `@ansh-ui/react`'s
+ * `listbox.tsx`.
+ *
+ * Both are listboxes: same option shape, same grouping, same active-descendant navigation, same
+ * "skip disabled items" rule. What differs is only how the query is entered — a hidden typeahead
+ * buffer versus a visible text input. Sharing this is what keeps the two consistent; the alternative
+ * is a `Select` whose Home key works and a `Combobox` whose doesn't.
+ */
+interface SelectOption {
+    value: string;
+    label: string;
+    /** Secondary line under the label. */
+    description?: string;
+    icon?: SlotContent;
+    disabled?: boolean;
+    /** Options sharing a group render under one heading. */
+    group?: string;
+    /** Extra text matched by search but never displayed. */
+    keywords?: string;
+}
+/** Move `active` by `delta`, skipping disabled options and stopping at the ends. */
+declare function stepActive(options: readonly SelectOption[], active: number, delta: number, loop?: boolean): number;
+/** First enabled option at or after `from`. */
+declare function firstEnabled(options: readonly SelectOption[], from?: number): number;
+/**
+ * Type-ahead over a listbox with no text input.
+ *
+ * Typing "ca" jumps to "Canada". The buffer resets after a pause, so typing "c", waiting, then "a"
+ * moves to the first "c" and then the first "a" — which is what the native `<select>` does and what
+ * users have internalised over three decades.
+ *
+ * `getOptions` is a function rather than a snapshot array: unlike a React hook (recreated every
+ * render, so it always closes over the render's own props), this runs once in `setup()`, so it has
+ * to read the *current* options itself on every keystroke rather than close over a stale list.
+ */
+declare function useTypeahead(getOptions: () => readonly SelectOption[], onMatch: (index: number) => void, timeout?: number): (key: string) => boolean;
+/**
+ * Subsequence match with a relevance score. `-1` means no match.
+ *
+ * Subsequence rather than substring because that is what users of a modern picker expect: typing
+ * "nds" should find "**N**ew **D**ata**s**ource".
+ */
+declare function scoreOption(query: string, option: SelectOption): number;
+/** Filter and rank options against a query, preserving order when the query is empty. */
+declare function filterOptions(options: readonly SelectOption[], query: string): readonly SelectOption[];
+interface OptionListProps {
+    options: readonly SelectOption[];
+    active: number;
+    selected: readonly string[];
+    listId: string;
+    multiple?: boolean;
+    emptyMessage?: SlotContent;
+    onSelect: (option: SelectOption) => void;
+    onActiveChange: (index: number) => void;
+    /** Highlight the matched characters. */
+    query?: string;
+}
+/** Render the option rows, with group headings emitted on change. */
+declare const OptionList: vue.DefineComponent<vue.ExtractPropTypes<{
+    options: {
+        type: PropType<readonly SelectOption[]>;
+        required: true;
+    };
+    active: {
+        type: NumberConstructor;
+        required: true;
+    };
+    selected: {
+        type: PropType<readonly string[]>;
+        required: true;
+    };
+    listId: {
+        type: StringConstructor;
+        required: true;
+    };
+    multiple: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    emptyMessage: {
+        type: PropType<SlotContent>;
+        default: string;
+    };
+    onSelect: {
+        type: PropType<(option: SelectOption) => void>;
+        required: true;
+    };
+    onActiveChange: {
+        type: PropType<(index: number) => void>;
+        required: true;
+    };
+    query: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}> | vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>[], {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    options: {
+        type: PropType<readonly SelectOption[]>;
+        required: true;
+    };
+    active: {
+        type: NumberConstructor;
+        required: true;
+    };
+    selected: {
+        type: PropType<readonly string[]>;
+        required: true;
+    };
+    listId: {
+        type: StringConstructor;
+        required: true;
+    };
+    multiple: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    emptyMessage: {
+        type: PropType<SlotContent>;
+        default: string;
+    };
+    onSelect: {
+        type: PropType<(option: SelectOption) => void>;
+        required: true;
+    };
+    onActiveChange: {
+        type: PropType<(index: number) => void>;
+        required: true;
+    };
+    query: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    multiple: boolean;
+    emptyMessage: SlotContent;
+    query: string;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+/**
+ * A single-choice select — the Vue counterpart of `@ansh-ui/react`'s `Select`.
+ *
+ * Follows the ARIA 1.2 collapsed-listbox pattern: the trigger is a `button` with
+ * `aria-haspopup="listbox"`, and while open, focus moves to the listbox with a virtual cursor
+ * carried by `aria-activedescendant`.
+ *
+ * A custom select is only justified when the native one can't do the job — option descriptions,
+ * icons, grouping with custom rendering. When a plain list of strings will do, `<select>` is still
+ * better: it gets the platform's own picker on mobile, which no custom implementation matches. This
+ * exists because CRM and admin screens genuinely need the richer version.
+ *
+ * ```vue
+ * <Select v-model="country" :options="countries" label="Country" />
+ * ```
+ */
+declare const Select: vue.DefineComponent<vue.ExtractPropTypes<{
+    options: {
+        type: PropType<readonly SelectOption[]>;
+        required: true;
+    };
+    modelValue: {
+        type: PropType<string | null>;
+        default: undefined;
+    };
+    defaultValue: {
+        type: PropType<string | null>;
+        default: null;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    invalid: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    size: {
+        type: PropType<"sm" | "md" | "lg">;
+        default: string;
+    };
+    /** Show a clear button once something is selected. */
+    clearable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Accessible name when there is no wrapping `Field`. */
+    label: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    /** Emit a hidden input so the value posts in a native form submit. */
+    name: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    /** Max height of the popup before it scrolls. Default `'18rem'`. */
+    maxHeight: {
+        type: StringConstructor;
+        default: string;
+    };
+    emptyMessage: {
+        type: PropType<SlotContent>;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    options: {
+        type: PropType<readonly SelectOption[]>;
+        required: true;
+    };
+    modelValue: {
+        type: PropType<string | null>;
+        default: undefined;
+    };
+    defaultValue: {
+        type: PropType<string | null>;
+        default: null;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    invalid: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    size: {
+        type: PropType<"sm" | "md" | "lg">;
+        default: string;
+    };
+    /** Show a clear button once something is selected. */
+    clearable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Accessible name when there is no wrapping `Field`. */
+    label: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    /** Emit a hidden input so the value posts in a native form submit. */
+    name: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    /** Max height of the popup before it scrolls. Default `'18rem'`. */
+    maxHeight: {
+        type: StringConstructor;
+        default: string;
+    };
+    emptyMessage: {
+        type: PropType<SlotContent>;
+        default: undefined;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}>, {
+    size: "sm" | "md" | "lg";
+    name: string;
+    invalid: boolean;
+    label: string;
+    disabled: boolean;
+    maxHeight: string;
+    modelValue: string | null;
+    defaultValue: string | null;
+    clearable: boolean;
+    emptyMessage: SlotContent;
+    placeholder: string;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+/**
+ * A searchable select, single or multiple — the Vue counterpart of `@ansh-ui/react`'s `Combobox`.
+ *
+ * This is the ARIA 1.2 combobox pattern, and the distinguishing detail is that **focus never leaves
+ * the input**. Arrow keys move a virtual cursor announced through `aria-activedescendant`, so the
+ * user can keep typing to narrow the list while navigating it. Implementations that move DOM focus
+ * into the list break that: the next keystroke goes to the list, not the query. (`Select`, next
+ * door, is the one that does move focus into its listbox — the two patterns differ for exactly this
+ * reason.)
+ *
+ * Shares `SelectOption`, `OptionList`, `filterOptions`, `firstEnabled` and `stepActive` with `Select`
+ * via `./listbox`, same as the React source shares them with its own `Select` via `listbox.tsx`.
+ *
+ * ```vue
+ * <Combobox multiple :options="owners" v-model="selected" />
+ * ```
+ */
+declare const Combobox: vue.DefineComponent<vue.ExtractPropTypes<{
+    options: {
+        type: PropType<readonly SelectOption[]>;
+        required: true;
+    };
+    /** Selected values. Single-select uses a one-element array. */
+    modelValue: {
+        type: PropType<readonly string[]>;
+        default: undefined;
+    };
+    defaultValue: {
+        type: PropType<readonly string[]>;
+        default: () => never[];
+    };
+    multiple: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    invalid: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    size: {
+        type: PropType<"sm" | "md" | "lg">;
+        default: string;
+    };
+    label: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    maxHeight: {
+        type: StringConstructor;
+        default: string;
+    };
+    emptyMessage: {
+        type: PropType<SlotContent>;
+        default: undefined;
+    };
+    /**
+     * Offer the typed text as a new option. Returns the created option's value.
+     *
+     * Kept as a plain callback prop rather than a Vue `emit` (unlike `search`, below): the returned
+     * value feeds straight back into what gets selected, and `emit` has no return channel for a
+     * parent to hand a value back synchronously.
+     */
+    onCreate: {
+        type: PropType<(label: string) => string>;
+        default: undefined;
+    };
+    /** Text for the create row. Receives the current query. */
+    createLabel: {
+        type: PropType<(query: string) => string>;
+        default: (query: string) => string;
+    };
+    /** Skip local filtering, e.g. when a `search` listener already returns filtered options. */
+    filter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Cap on how many chips render before collapsing to "+N". Default `Infinity`. */
+    maxVisibleChips: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, ("search" | "update:modelValue")[], "search" | "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    options: {
+        type: PropType<readonly SelectOption[]>;
+        required: true;
+    };
+    /** Selected values. Single-select uses a one-element array. */
+    modelValue: {
+        type: PropType<readonly string[]>;
+        default: undefined;
+    };
+    defaultValue: {
+        type: PropType<readonly string[]>;
+        default: () => never[];
+    };
+    multiple: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    invalid: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    size: {
+        type: PropType<"sm" | "md" | "lg">;
+        default: string;
+    };
+    label: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    maxHeight: {
+        type: StringConstructor;
+        default: string;
+    };
+    emptyMessage: {
+        type: PropType<SlotContent>;
+        default: undefined;
+    };
+    /**
+     * Offer the typed text as a new option. Returns the created option's value.
+     *
+     * Kept as a plain callback prop rather than a Vue `emit` (unlike `search`, below): the returned
+     * value feeds straight back into what gets selected, and `emit` has no return channel for a
+     * parent to hand a value back synchronously.
+     */
+    onCreate: {
+        type: PropType<(label: string) => string>;
+        default: undefined;
+    };
+    /** Text for the create row. Receives the current query. */
+    createLabel: {
+        type: PropType<(query: string) => string>;
+        default: (query: string) => string;
+    };
+    /** Skip local filtering, e.g. when a `search` listener already returns filtered options. */
+    filter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Cap on how many chips render before collapsing to "+N". Default `Infinity`. */
+    maxVisibleChips: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+    onSearch?: ((...args: any[]) => any) | undefined;
+}>, {
+    size: "sm" | "md" | "lg";
+    filter: boolean;
+    invalid: boolean;
+    label: string;
+    disabled: boolean;
+    maxHeight: string;
+    modelValue: readonly string[];
+    defaultValue: readonly string[];
+    multiple: boolean;
+    emptyMessage: SlotContent;
+    placeholder: string;
+    onCreate: (label: string) => string;
+    createLabel: (query: string) => string;
+    maxVisibleChips: number;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+interface SliderMark {
+    value: number;
+    label?: SlotContent;
+}
+/**
+ * A single-value slider — the Vue counterpart of `@ansh-ui/react`'s `Slider`.
+ *
+ * The thumb is the focusable element and carries `role="slider"` with the full value triple, so a
+ * screen reader announces "40, slider, minimum 0, maximum 100". Dragging writes the position via
+ * `useControllableState` on every pointer move and only fires `commit` (React's `onCommit`) on
+ * release — a re-render per pointer move is what makes hand-rolled sliders feel sticky.
+ */
+declare const Slider: vue.DefineComponent<vue.ExtractPropTypes<{
+    modelValue: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    defaultValue: {
+        type: NumberConstructor;
+        default: number;
+    };
+    min: {
+        type: NumberConstructor;
+        default: number;
+    };
+    max: {
+        type: NumberConstructor;
+        default: number;
+    };
+    step: {
+        type: NumberConstructor;
+        default: number;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Vertical sliders are for mixers and volume; default is horizontal. */
+    orientation: {
+        type: PropType<"horizontal" | "vertical">;
+        default: string;
+    };
+    marks: {
+        type: PropType<readonly SliderMark[]>;
+        default: undefined;
+    };
+    /** Show the value in a bubble above the thumb while dragging. */
+    showValue: {
+        type: PropType<boolean | "always">;
+        default: boolean;
+    };
+    /**
+     * Format the bubble and the screen-reader announcement.
+     *
+     * `String` itself as the default — not a factory returning it. Vue never invokes a `Function`-
+     * typed prop's `default` to resolve it (unlike `Object`/`Array`, where a factory is required);
+     * it is used as-is. Wrapping it (`() => String`) would make `formatValue` itself resolve to that
+     * wrapper, so calling `formatValue(current.value)` returns the `String` constructor instead of a
+     * formatted string.
+     */
+    formatValue: {
+        type: PropType<(value: number) => string>;
+        default: StringConstructor;
+    };
+    label: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    name: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, ("update:modelValue" | "commit")[], "update:modelValue" | "commit", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    modelValue: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    defaultValue: {
+        type: NumberConstructor;
+        default: number;
+    };
+    min: {
+        type: NumberConstructor;
+        default: number;
+    };
+    max: {
+        type: NumberConstructor;
+        default: number;
+    };
+    step: {
+        type: NumberConstructor;
+        default: number;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Vertical sliders are for mixers and volume; default is horizontal. */
+    orientation: {
+        type: PropType<"horizontal" | "vertical">;
+        default: string;
+    };
+    marks: {
+        type: PropType<readonly SliderMark[]>;
+        default: undefined;
+    };
+    /** Show the value in a bubble above the thumb while dragging. */
+    showValue: {
+        type: PropType<boolean | "always">;
+        default: boolean;
+    };
+    /**
+     * Format the bubble and the screen-reader announcement.
+     *
+     * `String` itself as the default — not a factory returning it. Vue never invokes a `Function`-
+     * typed prop's `default` to resolve it (unlike `Object`/`Array`, where a factory is required);
+     * it is used as-is. Wrapping it (`() => String`) would make `formatValue` itself resolve to that
+     * wrapper, so calling `formatValue(current.value)` returns the `String` constructor instead of a
+     * formatted string.
+     */
+    formatValue: {
+        type: PropType<(value: number) => string>;
+        default: StringConstructor;
+    };
+    label: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    name: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+    onCommit?: ((...args: any[]) => any) | undefined;
+}>, {
+    name: string;
+    label: string;
+    disabled: boolean;
+    max: number;
+    orientation: "horizontal" | "vertical";
+    modelValue: number;
+    defaultValue: number;
+    min: number;
+    step: number;
+    marks: readonly SliderMark[];
+    showValue: boolean | "always";
+    formatValue: (value: number) => string;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+/**
+ * A two-thumb range slider — the Vue counterpart of `@ansh-ui/react`'s `RangeSlider`. Price filters,
+ * date windows, numeric facets.
+ *
+ * The thumbs are allowed to pass each other, swapping roles when they do. Blocking the crossing is
+ * the more common implementation and it is worse: a user dragging the lower thumb to the right hits
+ * an invisible wall and has to work out that they need to grab the other one instead.
+ *
+ * The React `RangeSliderProps` type technically inherits an `orientation` field from `SliderProps`
+ * via `Omit`, but the implementation never reads it — every drag and layout calculation is
+ * horizontal-only. That field is dropped here rather than carried over as a prop that would do
+ * nothing.
+ */
+declare const RangeSlider: vue.DefineComponent<vue.ExtractPropTypes<{
+    modelValue: {
+        type: PropType<readonly [number, number]>;
+        default: undefined;
+    };
+    defaultValue: {
+        type: PropType<readonly [number, number]>;
+        default: () => readonly [number, number];
+    };
+    min: {
+        type: NumberConstructor;
+        default: number;
+    };
+    max: {
+        type: NumberConstructor;
+        default: number;
+    };
+    step: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /** Smallest allowed gap between the two thumbs. Default `0`. */
+    minDistance: {
+        type: NumberConstructor;
+        default: number;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    marks: {
+        type: PropType<readonly SliderMark[]>;
+        default: undefined;
+    };
+    showValue: {
+        type: PropType<boolean | "always">;
+        default: boolean;
+    };
+    formatValue: {
+        type: PropType<(value: number) => string>;
+        default: StringConstructor;
+    };
+    label: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, ("update:modelValue" | "commit")[], "update:modelValue" | "commit", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    modelValue: {
+        type: PropType<readonly [number, number]>;
+        default: undefined;
+    };
+    defaultValue: {
+        type: PropType<readonly [number, number]>;
+        default: () => readonly [number, number];
+    };
+    min: {
+        type: NumberConstructor;
+        default: number;
+    };
+    max: {
+        type: NumberConstructor;
+        default: number;
+    };
+    step: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /** Smallest allowed gap between the two thumbs. Default `0`. */
+    minDistance: {
+        type: NumberConstructor;
+        default: number;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    marks: {
+        type: PropType<readonly SliderMark[]>;
+        default: undefined;
+    };
+    showValue: {
+        type: PropType<boolean | "always">;
+        default: boolean;
+    };
+    formatValue: {
+        type: PropType<(value: number) => string>;
+        default: StringConstructor;
+    };
+    label: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+    onCommit?: ((...args: any[]) => any) | undefined;
+}>, {
+    label: string;
+    disabled: boolean;
+    max: number;
+    modelValue: readonly [number, number];
+    defaultValue: readonly [number, number];
+    min: number;
+    step: number;
+    marks: readonly SliderMark[];
+    showValue: boolean | "always";
+    formatValue: (value: number) => string;
+    minDistance: number;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+/**
+ * A one-time-code input — the Vue counterpart of `@ansh-ui/react`'s `PinInput`.
+ *
+ * The details that make or break this component are all about paste and autofill:
+ *
+ *  - `autocomplete="one-time-code"` on the first cell is what triggers iOS and Android to offer the
+ *    code from the SMS. Without it users retype a six-digit code by hand.
+ *  - Pasting into any cell distributes across all of them. Users paste from their SMS app
+ *    constantly, and a per-cell input that only accepts the first character is infuriating. Each
+ *    cell's `maxlength` is deliberately the *full* code length, not `1` — the browser would truncate
+ *    a paste to one character before this component's own `input` handler ever saw the rest.
+ *  - Backspace on an empty cell moves back *and* clears, so holding it wipes the field.
+ *
+ * A single input styled to look segmented would be simpler, but the caret cannot be positioned per
+ * segment and mobile keyboards behave inconsistently with it.
+ */
+declare const PinInput: vue.DefineComponent<vue.ExtractPropTypes<{
+    /** Number of cells. Default `6`. */
+    length: {
+        type: NumberConstructor;
+        default: number;
+    };
+    modelValue: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    defaultValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    /** Restrict input. Default `'numeric'`. */
+    type: {
+        type: PropType<"numeric" | "alphanumeric">;
+        default: string;
+    };
+    /** Render as password dots. */
+    mask: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    invalid: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Focus the first cell on mount. Native `autofocus`, spelled lower-case to match the attribute. */
+    autofocus: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, ("complete" | "update:modelValue")[], "complete" | "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    /** Number of cells. Default `6`. */
+    length: {
+        type: NumberConstructor;
+        default: number;
+    };
+    modelValue: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    defaultValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    /** Restrict input. Default `'numeric'`. */
+    type: {
+        type: PropType<"numeric" | "alphanumeric">;
+        default: string;
+    };
+    /** Render as password dots. */
+    mask: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    invalid: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Focus the first cell on mount. Native `autofocus`, spelled lower-case to match the attribute. */
+    autofocus: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{
+    onComplete?: ((...args: any[]) => any) | undefined;
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}>, {
+    length: number;
+    type: "numeric" | "alphanumeric";
+    invalid: boolean;
+    label: string;
+    disabled: boolean;
+    mask: boolean;
+    modelValue: string;
+    defaultValue: string;
+    autofocus: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+/**
+ * Free-text tags — the Vue counterpart of `@ansh-ui/react`'s `TagsInput`. Recipients, labels,
+ * keywords.
+ *
+ * Distinct from a multi-`Combobox`: there is no option list, any text is valid. The two are often
+ * conflated, and the giveaway is a "tags" component that forces you to pick from a list.
+ *
+ * Each tag is a real button so it can be reached with Tab and removed with Enter. Removing a tag
+ * moves focus to the next one rather than to the document, which is what stops keyboard users
+ * losing their place after deleting three in a row.
+ */
+declare const TagsInput: vue.DefineComponent<vue.ExtractPropTypes<{
+    modelValue: {
+        type: PropType<readonly string[]>;
+        default: undefined;
+    };
+    defaultValue: {
+        type: PropType<readonly string[]>;
+        default: () => never[];
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: string;
+    };
+    /** Maximum number of tags. The input hides once reached. */
+    max: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /** Keys that commit the current text. Default Enter, Tab and comma. */
+    delimiters: {
+        type: PropType<readonly string[]>;
+        default: () => string[];
+    };
+    /** Reject a value — return an error string, or `null` to accept. */
+    validate: {
+        type: PropType<(value: string) => string | null>;
+        default: undefined;
+    };
+    /** Fold duplicates silently instead of flagging them. Default `true`. */
+    dedupe: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    invalid: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    modelValue: {
+        type: PropType<readonly string[]>;
+        default: undefined;
+    };
+    defaultValue: {
+        type: PropType<readonly string[]>;
+        default: () => never[];
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: string;
+    };
+    /** Maximum number of tags. The input hides once reached. */
+    max: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /** Keys that commit the current text. Default Enter, Tab and comma. */
+    delimiters: {
+        type: PropType<readonly string[]>;
+        default: () => string[];
+    };
+    /** Reject a value — return an error string, or `null` to accept. */
+    validate: {
+        type: PropType<(value: string) => string | null>;
+        default: undefined;
+    };
+    /** Fold duplicates silently instead of flagging them. Default `true`. */
+    dedupe: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    invalid: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}>, {
+    invalid: boolean;
+    label: string;
+    disabled: boolean;
+    max: number;
+    modelValue: readonly string[];
+    defaultValue: readonly string[];
+    delimiters: readonly string[];
+    placeholder: string;
+    validate: (value: string) => string | null;
+    dedupe: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+type RatingSize = 'sm' | 'md' | 'lg';
+/**
+ * A star rating — the Vue counterpart of `@ansh-ui/react`'s `Rating`.
+ *
+ * Interactive ratings are a **radio group**, not a set of buttons: exactly one of N is chosen, which
+ * is what a radio group means, and it gets arrow-key navigation and correct announcements for free.
+ * Read-only ratings are `role="img"` with a text label instead — "4.2 out of 5" is the entire
+ * content, and exposing five separate radios that can't be changed is noise.
+ *
+ * `v-model` for two-way binding, same as every other control here. The React `readOnly` prop is
+ * spelled `readonly` — lower-case, one word — to match the native HTML attribute it mirrors and the
+ * convention `Input`'s own `readonly` prop already set in this package.
+ */
+declare const Rating: vue.DefineComponent<vue.ExtractPropTypes<{
+    modelValue: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    defaultValue: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /** Number of symbols. Default `5`. */
+    max: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /** Allow halves. Default `false`. */
+    allowHalf: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Display only — no interaction, no focus. */
+    readonly: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    size: {
+        type: PropType<RatingSize>;
+        default: string;
+    };
+    /** Custom symbol. Defaults to a star. */
+    icon: {
+        type: PropType<SlotContent>;
+        default: undefined;
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+    name: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    modelValue: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    defaultValue: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /** Number of symbols. Default `5`. */
+    max: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /** Allow halves. Default `false`. */
+    allowHalf: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Display only — no interaction, no focus. */
+    readonly: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    size: {
+        type: PropType<RatingSize>;
+        default: string;
+    };
+    /** Custom symbol. Defaults to a star. */
+    icon: {
+        type: PropType<SlotContent>;
+        default: undefined;
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+    name: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}>, {
+    size: RatingSize;
+    name: string;
+    label: string;
+    disabled: boolean;
+    max: number;
+    modelValue: number;
+    defaultValue: number;
+    readonly: boolean;
+    icon: SlotContent;
+    allowHalf: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+interface DropzoneFile {
+    file: File;
+    id: string;
+    /** Object URL for image previews. Revoked automatically on removal. */
+    preview?: string;
+    error?: string;
+}
+/**
+ * A file dropzone with previews and validation — the Vue counterpart of `@ansh-ui/react`'s
+ * `Dropzone`.
+ *
+ * Two things distinguish a working dropzone from a broken one:
+ *
+ *  1. **Drag counting.** `dragleave` fires when the pointer crosses onto a *child* element, so the
+ *     naive implementation flickers the highlight constantly while you move across it. A depth
+ *     counter incremented on enter and decremented on leave fixes it.
+ *  2. **A real `<input type="file">` underneath.** Drag-and-drop is unusable with a keyboard, a
+ *     screen reader, or on a phone. The input is the actual control; the drop surface is an
+ *     enhancement layered on top.
+ *
+ * Object URLs are revoked when a file is removed. Skipping that leaks the entire file into memory
+ * for the page's lifetime, which is invisible in testing and obvious after a user uploads forty
+ * photos.
+ *
+ * There is no `modelValue` here — the React source doesn't expose the file list as a controllable
+ * prop either, only the `files` event (React's `onFiles`) to observe it. The list is owned
+ * internally, same as upstream.
+ */
+declare const Dropzone: vue.DefineComponent<vue.ExtractPropTypes<{
+    /** `accept` attribute, e.g. `'image/*,.pdf'`. */
+    accept: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    multiple: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Per-file size cap, in bytes. */
+    maxSize: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    /** Maximum number of files. */
+    maxFiles: {
+        type: NumberConstructor;
+        default: number;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Show thumbnails for images. Default `true`. */
+    previews: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    label: {
+        type: PropType<SlotContent>;
+        default: string;
+    };
+    hint: {
+        type: PropType<SlotContent>;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "files"[], "files", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    /** `accept` attribute, e.g. `'image/*,.pdf'`. */
+    accept: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    multiple: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Per-file size cap, in bytes. */
+    maxSize: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    /** Maximum number of files. */
+    maxFiles: {
+        type: NumberConstructor;
+        default: number;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Show thumbnails for images. Default `true`. */
+    previews: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    label: {
+        type: PropType<SlotContent>;
+        default: string;
+    };
+    hint: {
+        type: PropType<SlotContent>;
+        default: undefined;
+    };
+}>> & Readonly<{
+    onFiles?: ((...args: any[]) => any) | undefined;
+}>, {
+    label: SlotContent;
+    disabled: boolean;
+    maxSize: number;
+    multiple: boolean;
+    accept: string;
+    maxFiles: number;
+    previews: boolean;
+    hint: SlotContent;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+/** Documents the shape of `ColorPicker`'s props. Not consumed by `defineComponent` directly. */
+interface ColorPickerProps {
+    /** Any CSS colour — hex, rgb, hsl, oklch, or a named colour. */
+    modelValue?: string;
+    defaultValue?: string;
+    /** Output format. Default `'hex'`. */
+    format?: 'hex' | 'rgb' | 'hsl' | 'oklch';
+    /** Show the alpha slider. Default `false`. */
+    alpha?: boolean;
+    /** Swatches shown under the picker. */
+    presets?: readonly string[];
+    /** Report the contrast ratio against this colour, live. */
+    contrastAgainst?: string;
+    disabled?: boolean;
+    label?: string;
+}
+/**
+ * A colour picker built on the engine's colour system — the Vue counterpart of `@ansh-ui/react`'s
+ * `ColorPicker`.
+ *
+ * The saturation/value plane, hue rail and alpha rail are the conventional layout. What's less
+ * conventional, and the reason this is worth shipping over a generic picker:
+ *
+ *  - **It speaks every format the engine does.** Paste `oklch(62% 0.2 264)` into the text field and
+ *    it parses. Most pickers accept hex and nothing else.
+ *  - **It can report contrast live.** On a theme editor — which is what colour pickers in admin
+ *    tools are usually for — picking a brand colour without seeing that it fails WCAG against your
+ *    background is how inaccessible products get built one reasonable decision at a time.
+ *
+ * State is held as HSV, not as the output string. Round-tripping through hex on every pointer move
+ * loses information: dragging into the black corner would discard the hue, so releasing and
+ * dragging back out returns red instead of the colour you started from.
+ */
+declare const ColorPicker: vue.DefineComponent<vue.ExtractPropTypes<{
+    modelValue: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    defaultValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    format: {
+        type: PropType<"hex" | "rgb" | "hsl" | "oklch">;
+        default: string;
+    };
+    alpha: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    presets: {
+        type: PropType<readonly string[]>;
+        default: undefined;
+    };
+    contrastAgainst: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    modelValue: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    defaultValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    format: {
+        type: PropType<"hex" | "rgb" | "hsl" | "oklch">;
+        default: string;
+    };
+    alpha: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    presets: {
+        type: PropType<readonly string[]>;
+        default: undefined;
+    };
+    contrastAgainst: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}>, {
+    label: string;
+    disabled: boolean;
+    modelValue: string;
+    defaultValue: string;
+    format: "oklch" | "hsl" | "hex" | "rgb";
+    alpha: boolean;
+    presets: readonly string[];
+    contrastAgainst: string;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+/**
+ * A month calendar — the Vue counterpart of `@ansh-ui/react`'s `Calendar`.
+ *
+ * Dates are plain `Date` objects normalised to local midnight. No date library: the whole surface
+ * this needs is "add days", "same day?" and "days in month", and pulling in a 70 KB dependency for
+ * that is how component libraries end up heavier than the app using them.
+ *
+ * Local midnight, specifically. Working in UTC makes a date shift by a day for anyone west of
+ * Greenwich — the bug where a birthday saved on the 14th displays as the 13th, which is the single
+ * most reported issue in every date picker ever shipped.
+ *
+ * Keyboard support is the WAI-ARIA date grid pattern: arrows by day, PageUp/PageDown by month,
+ * Shift+PageUp/PageDown by year, Home/End to the week's ends. A calendar without these is
+ * mouse-only, and entering a date of birth by clicking back 300 months is not a real option.
+ */
+/** Strip the time, in local time. */
+declare function startOfDay(date: Date): Date;
+declare function addDays(date: Date, days: number): Date;
+declare function addMonths(date: Date, months: number): Date;
+declare function isSameDay(a: Date | null | undefined, b: Date | null | undefined): boolean;
+type DateRange = {
+    start: Date | null;
+    end: Date | null;
+};
+/** Documents the shape of `Calendar`'s props. Not consumed by `defineComponent` directly. */
+interface CalendarProps {
+    /** `'single'` picks one date; `'range'` picks a start and an end. */
+    mode?: 'single' | 'range';
+    modelValue?: Date | null | DateRange;
+    defaultValue?: Date | null | DateRange;
+    min?: Date;
+    max?: Date;
+    /** Disable specific dates — weekends, holidays, booked days. */
+    isDateDisabled?: (date: Date) => boolean;
+    /** 0 = Sunday, 1 = Monday. Default: inferred from the locale. */
+    weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+    locale?: string;
+    /** Months shown side by side. Default `1`; `2` suits range pickers. */
+    months?: number;
+    /** Show ISO week numbers down the left. */
+    showWeekNumbers?: boolean;
+}
+declare const Calendar: vue.DefineComponent<vue.ExtractPropTypes<{
+    mode: {
+        type: PropType<"single" | "range">;
+        default: string;
+    };
+    modelValue: {
+        type: PropType<Date | null | DateRange>;
+        default: undefined;
+    };
+    defaultValue: {
+        type: PropType<Date | null | DateRange>;
+        default: undefined;
+    };
+    min: {
+        type: DateConstructor;
+        default: undefined;
+    };
+    max: {
+        type: DateConstructor;
+        default: undefined;
+    };
+    isDateDisabled: {
+        type: PropType<(date: Date) => boolean>;
+        default: undefined;
+    };
+    weekStartsOn: {
+        type: PropType<0 | 1 | 2 | 3 | 4 | 5 | 6>;
+        default: undefined;
+    };
+    locale: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    months: {
+        type: NumberConstructor;
+        default: number;
+    };
+    showWeekNumbers: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    mode: {
+        type: PropType<"single" | "range">;
+        default: string;
+    };
+    modelValue: {
+        type: PropType<Date | null | DateRange>;
+        default: undefined;
+    };
+    defaultValue: {
+        type: PropType<Date | null | DateRange>;
+        default: undefined;
+    };
+    min: {
+        type: DateConstructor;
+        default: undefined;
+    };
+    max: {
+        type: DateConstructor;
+        default: undefined;
+    };
+    isDateDisabled: {
+        type: PropType<(date: Date) => boolean>;
+        default: undefined;
+    };
+    weekStartsOn: {
+        type: PropType<0 | 1 | 2 | 3 | 4 | 5 | 6>;
+        default: undefined;
+    };
+    locale: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    months: {
+        type: NumberConstructor;
+        default: number;
+    };
+    showWeekNumbers: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}>, {
+    mode: "range" | "single";
+    max: Date;
+    modelValue: Date | DateRange | null;
+    defaultValue: Date | DateRange | null;
+    min: Date;
+    isDateDisabled: (date: Date) => boolean;
+    weekStartsOn: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+    locale: string;
+    months: number;
+    showWeekNumbers: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+/** Documents the shape of `DatePicker`'s props. Not consumed by `defineComponent` directly. */
+interface DatePickerProps {
+    modelValue?: Date | null;
+    defaultValue?: Date | null;
+    placeholder?: string;
+    disabled?: boolean;
+    invalid?: boolean;
+    /** Show a clear button once a date is chosen. */
+    clearable?: boolean;
+    /** Format the displayed date. Defaults to the locale's medium date. */
+    format?: (date: Date) => string;
+    label?: string;
+    name?: string;
+    min?: Date;
+    max?: Date;
+    isDateDisabled?: (date: Date) => boolean;
+    weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+    locale?: string;
+    months?: number;
+    showWeekNumbers?: boolean;
+}
+/**
+ * A date field with a calendar popover — the Vue counterpart of `@ansh-ui/react`'s `DatePicker`.
+ *
+ * The text input is editable, not just a display. Typing "14/03/2026" is faster than clicking
+ * through a calendar for anyone who knows the date they want, and a picker that forces the calendar
+ * is a picker people complain about. The calendar is the fallback for "some Thursday next month",
+ * which is the case typing can't serve.
+ *
+ * Parsing is deliberately forgiving of separators and order within a locale, but never guesses
+ * between `03/04` as March 4th and April 3rd — it follows the locale's own order. Guessing is how
+ * date fields silently record the wrong day.
+ */
+declare const DatePicker: vue.DefineComponent<vue.ExtractPropTypes<{
+    min: {
+        type: DateConstructor;
+        default: undefined;
+    };
+    max: {
+        type: DateConstructor;
+        default: undefined;
+    };
+    isDateDisabled: {
+        type: PropType<(date: Date) => boolean>;
+        default: undefined;
+    };
+    weekStartsOn: {
+        type: PropType<0 | 1 | 2 | 3 | 4 | 5 | 6>;
+        default: undefined;
+    };
+    locale: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    showWeekNumbers: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    modelValue: {
+        type: PropType<Date | null>;
+        default: undefined;
+    };
+    defaultValue: {
+        type: PropType<Date | null>;
+        default: undefined;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    invalid: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    clearable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    format: {
+        type: PropType<(date: Date) => string>;
+        default: undefined;
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+    name: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    months: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    min: {
+        type: DateConstructor;
+        default: undefined;
+    };
+    max: {
+        type: DateConstructor;
+        default: undefined;
+    };
+    isDateDisabled: {
+        type: PropType<(date: Date) => boolean>;
+        default: undefined;
+    };
+    weekStartsOn: {
+        type: PropType<0 | 1 | 2 | 3 | 4 | 5 | 6>;
+        default: undefined;
+    };
+    locale: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    showWeekNumbers: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    modelValue: {
+        type: PropType<Date | null>;
+        default: undefined;
+    };
+    defaultValue: {
+        type: PropType<Date | null>;
+        default: undefined;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    invalid: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    clearable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    format: {
+        type: PropType<(date: Date) => string>;
+        default: undefined;
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+    name: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    months: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}>, {
+    name: string;
+    invalid: boolean;
+    label: string;
+    disabled: boolean;
+    max: Date;
+    modelValue: Date | null;
+    defaultValue: Date | null;
+    clearable: boolean;
+    min: Date;
+    placeholder: string;
+    format: (date: Date) => string;
+    isDateDisabled: (date: Date) => boolean;
+    weekStartsOn: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+    locale: string;
+    months: number;
+    showWeekNumbers: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+/** Documents the shape of `DateRangePicker`'s props. Not consumed by `defineComponent` directly. */
+interface DateRangePickerProps {
+    modelValue?: DateRange;
+    defaultValue?: DateRange;
+    disabled?: boolean;
+    invalid?: boolean;
+    label?: string;
+    /** Months shown side by side. Default `2`. */
+    months?: number;
+    min?: Date;
+    max?: Date;
+    isDateDisabled?: (date: Date) => boolean;
+    weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+    locale?: string;
+    showWeekNumbers?: boolean;
+}
+/**
+ * A start/end date range — the Vue counterpart of `@ansh-ui/react`'s `DateRangePicker`.
+ *
+ * Two months by default: choosing a range that crosses a month boundary with one month visible
+ * means paging back and forth to compare, which is where users lose track of what they picked.
+ */
+declare const DateRangePicker: vue.DefineComponent<vue.ExtractPropTypes<{
+    min: {
+        type: DateConstructor;
+        default: undefined;
+    };
+    max: {
+        type: DateConstructor;
+        default: undefined;
+    };
+    isDateDisabled: {
+        type: PropType<(date: Date) => boolean>;
+        default: undefined;
+    };
+    weekStartsOn: {
+        type: PropType<0 | 1 | 2 | 3 | 4 | 5 | 6>;
+        default: undefined;
+    };
+    locale: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    showWeekNumbers: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    modelValue: {
+        type: PropType<DateRange>;
+        default: undefined;
+    };
+    defaultValue: {
+        type: PropType<DateRange>;
+        default: undefined;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    invalid: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+    months: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    min: {
+        type: DateConstructor;
+        default: undefined;
+    };
+    max: {
+        type: DateConstructor;
+        default: undefined;
+    };
+    isDateDisabled: {
+        type: PropType<(date: Date) => boolean>;
+        default: undefined;
+    };
+    weekStartsOn: {
+        type: PropType<0 | 1 | 2 | 3 | 4 | 5 | 6>;
+        default: undefined;
+    };
+    locale: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    showWeekNumbers: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    modelValue: {
+        type: PropType<DateRange>;
+        default: undefined;
+    };
+    defaultValue: {
+        type: PropType<DateRange>;
+        default: undefined;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    invalid: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+    months: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}>, {
+    invalid: boolean;
+    label: string;
+    disabled: boolean;
+    max: Date;
+    modelValue: DateRange;
+    defaultValue: DateRange;
+    min: Date;
+    isDateDisabled: (date: Date) => boolean;
+    weekStartsOn: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+    locale: string;
+    months: number;
+    showWeekNumbers: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+export { Calendar, type CalendarProps, Checkbox, ChoiceCard, ColorPicker, type ColorPickerProps, Combobox, DatePicker, type DatePickerProps, type DateRange, DateRangePicker, type DateRangePickerProps, Dropzone, type DropzoneFile, Field, type FieldContextValue, type FieldControlAttrs, Fieldset, Input, type InputSize, NumberInput, OptionList, type OptionListProps, PinInput, Radio, RadioGroup, type RadioGroupProps, RangeSlider, Rating, type RatingSize, Select, type SelectOption, Slider, type SliderMark, Switch, TagsInput, Textarea, VisuallyHidden, addDays, addMonths, filterOptions, firstEnabled, isSameDay, scoreOption, startOfDay, stepActive, useFieldContext, useFieldControl, useTypeahead };