@uni-design-system/uni-angular 9.0.0 → 10.0.0

package/types/uni-design-system-uni-angular.d.ts

@@ -187,6 +187,382 @@ declare const splitDateTime: (value?: UniDateTime) => {
 /** One combined value only when both parts are present. */
 declare const joinDateTime: (date?: UniDate, time?: UniTime) => UniDateTime | undefined;
 
+/**
+ * Canonical numeric value shapes shared by `uni-number-input`,
+ * `uni-quantity-stepper`, `uni-number-range-input` and `uni-slider`.
+ *
+ * The components' internal source of truth is a **canonical decimal string** —
+ * optional sign, digits, an optional `.`, no grouping and no affix:
+ * `'-1234.56'`. The bound `number` is its projection, emitted on commit.
+ *
+ * Nothing numeric passes through a float, because floats give wrong answers to
+ * questions people ask of money: `0.1 + 0.2` is `0.30000000000000004`, and
+ * `(1.15).toFixed(1)` is `'1.1'` — 1.15 is really 1.1499999999999999, so the
+ * platform rounds a tie that isn't there. See `decimal.helper.ts`.
+ */
+/** A start–end numeric range. Either end alone is a valid value. */
+interface UniNumberRange {
+    start?: number;
+    end?: number;
+}
+/**
+ * How a tie is resolved when rounding to a fraction-digit count.
+ *
+ * `half-up` is the invoice default (ties away from zero: `1.15` → `1.2`);
+ * `half-even` is banker's rounding, which removes the upward bias across a
+ * column of figures (`1.25` → `1.2`, `1.35` → `1.4`).
+ */
+type UniRoundingMode = 'half-up' | 'half-even' | 'ceil' | 'floor' | 'trunc';
+/** Format archetype. Supplies decimals, grouping, affix and `inputmode`. */
+type UniNumberPreset = 'decimal' | 'integer' | 'currency' | 'percent';
+/**
+ * Thousands-separator policy, mapped onto `Intl`'s `useGrouping`.
+ *
+ * `min2` — the default — groups only from five integer digits, so a year
+ * renders `2026` rather than `2,026` while a price still renders `10,000`.
+ */
+type UniNumberGrouping = 'auto' | 'always' | 'min2' | false;
+/** Why a typed commit was refused. The raw text stays in the field. */
+type UniNumberRejectReason = 'unparseable' | 'min' | 'max' | 'step' | 'precision' | 'not-integer';
+/** Fences and snap grid for `stepDecimal`. */
+interface UniNumberStepConfig {
+    /** Grid spacing. Steps land on `origin + n · step`. Default `1`. */
+    step?: number | string;
+    min?: number | string;
+    max?: number | string;
+    /**
+     * Snap-grid anchor. `'min'` matches the platform's `<input type="number">`
+     * (a field with `min=5, step=10` steps 5 → 15 → 25); `'zero'` anchors the
+     * grid at 0 regardless of the fence.
+     */
+    stepOrigin?: 'min' | 'zero';
+    /**
+     * Cycle past a fence instead of stopping at it — for genuinely cyclic
+     * fields only (23 → 0 hours, 359 → 0 degrees). Needs both `min` and `max`.
+     */
+    wrap?: boolean;
+}
+/** The outcome of clamping a value to its fences. */
+interface UniNumberClamp {
+    /** The clamped canonical decimal. */
+    value: string;
+    /** Which fence was hit, or `null` when the value was already in range. */
+    hit: 'min' | 'max' | null;
+}
+/**
+ * Separators, currency placement and fraction digits read out of `Intl` for a
+ * locale. Nothing here is hardcoded per language — `1.234,56` is German input,
+ * not malformed input, and only the locale knows that.
+ */
+interface UniLocaleNumberParts {
+    /** Thousands separator: `','` (en), `'.'` (de), a narrow no-break space (fr). */
+    group: string;
+    /** Decimal separator: `'.'` (en), `','` (de). */
+    decimal: string;
+    /** Currency symbol, when a currency was given: `'$'`, `'€'`, `'¥'`. */
+    currencySymbol: string;
+    /** True when the locale writes the symbol before the number. */
+    currencyLeading: boolean;
+    /** Fraction digits `Intl` uses for the currency — JPY 0, USD 2. */
+    currencyDecimals: number;
+}
+/**
+ * What a component knows about its own formatting, before resolution. Mirrors
+ * the component inputs so a control can forward its signals almost verbatim.
+ */
+interface UniNumberFormatConfig {
+    preset?: UniNumberPreset;
+    /** ISO 4217 code, e.g. `'USD'`. Implies the `currency` preset. */
+    currency?: string;
+    /** BCP 47 tag. Defaults to `'en-US'`; components pass the document's. */
+    locale?: string;
+    /** Fixed fraction digits, or `[min, max]`. Overrides the preset. */
+    decimals?: number | [min: number, max: number];
+    grouping?: UniNumberGrouping;
+    /** Static adornment, rendered outside the editable text. */
+    prefix?: string;
+    suffix?: string;
+    roundingMode?: UniRoundingMode;
+    /**
+     * The model is a fraction: `0.15` displays as `15`. Without it, a percent
+     * field displays `15` for `15` and never divides behind the user's back.
+     */
+    valueIsFraction?: boolean;
+    /** Escape hatch, merged over the preset. Only `notation` is read today. */
+    numberFormat?: Intl.NumberFormatOptions;
+    /** Read only to decide `inputmode` — a field that can go negative needs `-`. */
+    min?: number;
+    /** Spoken long form of an abbreviated suffix, for `aria-valuetext`. */
+    unitAnnouncement?: string;
+}
+/** A format config with every preset and locale default filled in. */
+interface UniResolvedNumberFormat {
+    locale: string;
+    parts: UniLocaleNumberParts;
+    prefix: string;
+    suffix: string;
+    minimumFractionDigits: number;
+    maximumFractionDigits: number;
+    grouping: UniNumberGrouping;
+    /** `1.5k` in, `1.5K` out. */
+    compact: boolean;
+    /** Fraction entry is refused outright rather than rounded away. */
+    isInteger: boolean;
+    /** Display value is the model value × `10^shift`. */
+    shift: number;
+    roundingMode: UniRoundingMode;
+    /** `numeric` only when negatives and decimals are both impossible. */
+    inputMode: 'decimal' | 'numeric';
+    unitAnnouncement?: string;
+}
+/**
+ * The outcome of reading a user's text. Refused text is never swallowed: the
+ * caller keeps it in the field and flags it, so nobody loses their work to a
+ * silently emptied box.
+ */
+type UniNumberParseResult = {
+    status: 'empty';
+} | {
+    status: 'ok';
+    value: string;
+    viaExpression: boolean;
+} | {
+    status: 'error';
+    reason: UniNumberRejectReason;
+};
+
+/**
+ * Exact decimal arithmetic over canonical decimal strings, using scaled
+ * `BigInt`s. No number library — `BigInt` is the platform's own exact integer
+ * type, and every operation here is integer arithmetic with a remembered
+ * decimal point.
+ *
+ * A **canonical decimal** is `/^-?\d+(\.\d+)?$/`: optional sign, digits, an
+ * optional fraction, no grouping, no affix, no exponent. Everything in this
+ * file takes and returns that shape.
+ *
+ * Why not floats, concretely:
+ *
+ * ```
+ * 0.1 + 0.2                → 0.30000000000000004    // IEEE 754
+ * scaled: 1n + 2n = 3n, ÷10 → '0.3'                  // here
+ *
+ * (1.15).toFixed(1)        → '1.1'   // 1.15 is really 1.1499999999999999,
+ *                                    // so the platform breaks a tie that
+ *                                    // does not exist in the decimal value
+ * roundDecimal('1.15', 1)  → '1.2'   // what an invoice expects
+ * ```
+ *
+ * The scale (fraction-digit count) is carried alongside the integer rather
+ * than inferred, so `'1.50'` and `'1.5'` compare equal but a value's own
+ * precision survives a round trip.
+ */
+
+/** True when `text` is already a canonical decimal (leading/trailing space allowed). */
+declare const isCanonicalDecimal: (text: string) => boolean;
+/** Fraction-digit count. `'1.250'` → 3, `'12'` → 0, `'5.'` → 0. */
+declare const decimalScale: (value: string) => number;
+/**
+ * Canonical decimal → integer scaled by `10^scale`. Fraction digits beyond
+ * `scale` are truncated, so callers that must not lose them pass a `scale` at
+ * least `decimalScale(value)`.
+ */
+declare const toScaled: (value: string, scale: number) => bigint;
+/** Scaled integer → canonical decimal, with trailing fraction zeros trimmed. */
+declare const fromScaled: (scaled: bigint, scale: number) => string;
+/**
+ * Strip a leading `+`, leading zeros and trailing fraction zeros: `'+01.50'`
+ * → `'1.5'`. Requires a canonical decimal; guard with `isCanonicalDecimal`.
+ */
+declare const normalizeDecimal: (value: string) => string;
+/**
+ * Any numeric input → canonical decimal, expanding the exponential notation
+ * `String(number)` produces outside 1e-7…1e21. A `step` of `1e-7` would
+ * otherwise reach the arithmetic as the literal text `'1e-7'`.
+ *
+ * Throws on text that is not numeric at all — every caller here passes either
+ * a `number` input or text already cleared by the parser.
+ */
+declare const toDecimal: (value: number | string) => string;
+/** `-1` when `a < b`, `1` when `a > b`, `0` when equal. `'1.50'` equals `'1.5'`. */
+declare const compareDecimal: (a: string, b: string) => -1 | 0 | 1;
+/**
+ * Round to `fractionDigits`, breaking ties per `mode`. Exact where
+ * `Number.prototype.toFixed` is not — see the file header.
+ */
+declare const roundDecimal: (value: string, fractionDigits: number, mode?: UniRoundingMode) => string;
+/**
+ * Multiply by `10^places`, exactly. Used for the percent preset's
+ * fraction ⇄ display shift (`0.15` ⇄ `15`) and for deriving a default
+ * large step of `step × 10` without touching a float.
+ */
+declare const shiftDecimal: (value: string, places: number) => string;
+/**
+ * Hold a value inside its fences, reporting which one it hit so the caller can
+ * announce it. Clamping belongs on commit, never per keystroke: a `min=10`
+ * field that clamps live can never be typed into, because the `1` becomes `10`
+ * before the `5` arrives.
+ */
+declare const clampDecimal: (value: string, min?: number | string, max?: number | string) => UniNumberClamp;
+/**
+ * One step from `current`, in `direction` (`1` up, `-1` down).
+ *
+ * Steps land on the grid `origin + n · step`, where `origin` is `min` by
+ * default. A value that is *off* the grid snaps to the nearest grid point **in
+ * the direction of travel** rather than jumping past it: with `min=5, step=10`
+ * the grid is 5, 15, 25, and stepping up from 7 gives 15, not 17.
+ *
+ * Fences stop the value; they never wrap unless `wrap` is set and both bounds
+ * are defined. Returns `current` unchanged when `step` is zero.
+ */
+declare const stepDecimal: (current: string, direction: 1 | -1, config?: UniNumberStepConfig) => string;
+
+/**
+ * Locale separators plus, when a currency is given, its symbol, side and
+ * fraction digits. Memoized: constructing an `Intl.NumberFormat` is expensive
+ * and a field re-resolves this on every keystroke.
+ */
+declare const localeNumberParts: (locale: string, currency?: string) => UniLocaleNumberParts;
+/**
+ * Map localized digits and Arabic separators to ASCII, so `١٢٣٤٫٥` parses in
+ * `ar` and `१२३४.५` in `hi`.
+ */
+declare const toAsciiDigits: (text: string) => string;
+/**
+ * Evaluate `+ − × ÷ ( )` over decimal literals — shunting-yard, roughly thirty
+ * lines, and **never `eval`**. Returns a canonical decimal, or `null` when the
+ * text is not a well-formed expression.
+ *
+ * Floats are acceptable here in a way they are not elsewhere: this is a
+ * convenience path for spreadsheet muscle memory (`12*3`, `100/4+5`), and the
+ * result is settled to ten decimals before re-entering exact arithmetic.
+ * Division is the only operation that can produce a non-terminating decimal,
+ * and no exact representation would help there either.
+ */
+declare const evaluateExpression: (text: string) => string | null;
+/** Fill in every preset, locale and currency default. */
+declare const resolveNumberFormat: (config?: UniNumberFormatConfig) => UniResolvedNumberFormat;
+/**
+ * Read a user's text into a canonical decimal in **model units**.
+ *
+ * Accepted, in order: canonical/ASCII (always, whatever the locale — it is
+ * what agents and APIs write), locale-grouped, affixed, localized digits,
+ * compact (`1.5k`), accounting negatives (`(1,234.56)` → `-1234.56`), and
+ * expressions when `allowExpressions` is set.
+ */
+declare const parseNumber: (raw: string, format: UniResolvedNumberFormat, options?: {
+    allowExpressions?: boolean;
+    currency?: string;
+}) => UniNumberParseResult;
+/**
+ * Canonical decimal (model units) → the display number, without affixes.
+ *
+ * `min2` grouping — the default — starts at five integer digits, so a year
+ * renders `2026` rather than `2,026` while a price still renders `10,000`.
+ */
+declare const formatNumber: (canonical: string, format: UniResolvedNumberFormat) => string;
+/**
+ * The plain text the field shows while focused: the display number with no
+ * grouping and no affixes, so the caret never has to walk over a separator
+ * that appears and vanishes mid-word.
+ */
+declare const rawNumberText: (canonical: string, format: UniResolvedNumberFormat) => string;
+/** Round a committed value to the field's precision, in model units. */
+declare const settleNumber: (canonical: string, format: UniResolvedNumberFormat) => string;
+/**
+ * The `aria-valuetext` string: the formatted number with its affixes spoken.
+ * `aria-valuenow` alone announces "1234.56", which is the one thing about a
+ * money field that is not the point. An empty field says "Empty" per APG.
+ */
+declare const speakNumber: (canonical: string | null, format: UniResolvedNumberFormat, emptyText?: string) => string;
+/** Model-units canonical decimal → the bound `number`. */
+declare const toNumber: (canonical: string) => number;
+/**
+ * True when a value cannot survive the trip through `number` — the reason the
+ * components also expose an exact `valueAsString` model, and the trigger for
+ * the dev-mode warning. Silent precision loss is the whole point of that
+ * second model, so it is worth saying out loud once.
+ *
+ * A `number` can only be checked for magnitude, since it has already lost
+ * whatever it was going to lose. A canonical string can be checked properly:
+ * `'9007199254740993'` comes back as `'9007199254740992'`.
+ */
+declare const losesPrecision: (value: number | string) => boolean;
+
+/**
+ * Hold-to-repeat for stepper buttons: press once to step once, hold to keep
+ * stepping, faster the longer you hold. Getting a quantity from 1 to 200 is
+ * otherwise 199 clicks.
+ *
+ * Like the other cdk helpers this owns **no DOM and attaches no listeners to
+ * an element** — the component's template hands it the events, which keeps the
+ * ARIA and the markup where they belong:
+ *
+ * ```html
+ * <button
+ *   type="button"
+ *   tabindex="-1"
+ *   [disabled]="atMax()"
+ *   (pointerdown)="increment.press($event)"
+ *   (pointerup)="increment.release()"
+ *   (pointercancel)="increment.cancel()"
+ *   (lostpointercapture)="increment.release()"
+ * >
+ * ```
+ *
+ * It does register one `window` blur listener, because a hold that survives
+ * the window losing focus is a value that keeps climbing while the user is
+ * somewhere else. That listener is torn down with the injection context, so
+ * `createPressRepeat` must be called from one — a field initializer, as with
+ * `useTimer()`.
+ */
+
+/** Repeat timings, normally sourced from a component's theme options. */
+interface PressRepeatTiming {
+    delayMs?: number;
+    intervalMs?: number;
+    fastIntervalMs?: number;
+    rampMs?: number;
+}
+interface PressRepeatConfig {
+    /**
+     * Perform one step. `repeat` is `false` for the initial press and `true` for
+     * every automatic repeat, so a caller can stay silent during the run.
+     */
+    onStep: (repeat: boolean) => void;
+    /**
+     * The hold ended. `repeated` says whether it ever auto-repeated, which is
+     * the cue to announce the final value: a screen reader narrating two hundred
+     * intermediate values is a denial of service, so announcing belongs here and
+     * not in `onStep`.
+     */
+    onRelease?: (repeated: boolean) => void;
+    /** Consulted on press; a disabled button must not start a run. */
+    disabled?: () => boolean;
+    /**
+     * When this returns `false`, a press steps exactly once and the repeat timer
+     * is never armed — `onRelease` still fires, with `repeated: false`. Lets a
+     * caller turn hold-to-repeat off without a second set of event bindings.
+     */
+    repeat?: () => boolean;
+    timing?: () => PressRepeatTiming;
+}
+interface PressRepeat {
+    /** True while a press is in flight — bind it to the button's pressed state. */
+    readonly holding: Signal<boolean>;
+    /**
+     * Begin a hold and step once immediately. Given a pointer event, it also
+     * takes pointer capture, so sliding off the button mid-hold neither strands
+     * the repeat nor drops the release.
+     */
+    press(event?: PointerEvent): void;
+    /** End a hold normally, firing `onRelease`. */
+    release(): void;
+    /** End a hold without firing `onRelease` — for `Escape` and `pointercancel`. */
+    cancel(): void;
+}
+declare function createPressRepeat(config: PressRepeatConfig): PressRepeat;
+
 interface ListboxNavigationConfig {
     /** How many options are currently navigable. Read reactively. */
     count: () => number;
@@ -1066,7 +1442,7 @@ declare class UniDateInputComponent extends BaseComponent<UniDateInputOptions> i
     maxDate: _angular_core.InputSignal<string>;
     disabledDates: _angular_core.InputSignal<string[] | ((date: UniDate) => boolean)>;
     markers: _angular_core.InputSignal<UniCalendarMarker[]>;
-    weekStart: _angular_core.InputSignal<0 | 1 | 2 | 3 | 4 | 6 | 5>;
+    weekStart: _angular_core.InputSignal<0 | 1 | 2 | 3 | 4 | 5 | 6>;
     /** Popup shown. */
     opened: _angular_core.OutputEmitterRef<void>;
     /** Popup hidden. */
@@ -1160,7 +1536,7 @@ declare class UniDateTimeInputComponent extends BaseComponent<UniDateTimeInputOp
     slots: _angular_core.InputSignal<string[]>;
     minuteStep: _angular_core.InputSignal<number>;
     hour12: _angular_core.InputSignal<boolean>;
-    weekStart: _angular_core.InputSignal<0 | 1 | 2 | 3 | 4 | 6 | 5>;
+    weekStart: _angular_core.InputSignal<0 | 1 | 2 | 3 | 4 | 5 | 6>;
     locale: _angular_core.InputSignal<string>;
     /** Scheduling: the day's available times. Gates the time part on a date. */
     slotsFor: _angular_core.InputSignal<(date: UniDate) => UniTime[]>;
@@ -1230,12 +1606,26 @@ declare class UniInputBoxComponent extends BaseComponent<UniInputBoxOptions> {
     width: _angular_core.InputSignal<string | number>;
     fullWidth: _angular_core.InputSignal<boolean>;
     grow: _angular_core.InputSignal<number>;
+    /**
+     * Stop applying the themed leading inset to the inner control, for fields
+     * that place it themselves.
+     *
+     * The inset normally rides the `<input>`, which is right while the text is
+     * the field's leading edge. It is wrong the moment an adornment sits in
+     * front: a currency prefix would hug the border while the number it belongs
+     * to is indented past it. A field with adornments takes the inset over and
+     * puts it on whichever element is actually first.
+     */
+    managedInset: _angular_core.InputSignal<boolean>;
+    /** Auto-height fields (tag input, textarea) still keep the themed height as
+        a floor, so a single-line field lines up with every other input. */
+    protected readonly minHeight: _angular_core.Signal<string | number>;
     protected readonly color: _angular_core.Signal<_uni_design_system_uni_core.ContainerColorToken>;
     protected readonly border: _angular_core.Signal<string>;
     protected readonly shadow: _angular_core.Signal<string>;
     protected readonly inputBoxClass: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<UniInputBoxComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniInputBoxComponent, "uni-input-box", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; "minWidth": { "alias": "minWidth"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; "grow": { "alias": "grow"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniInputBoxComponent, "uni-input-box", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; "minWidth": { "alias": "minWidth"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; "grow": { "alias": "grow"; "required": false; "isSignal": true; }; "managedInset": { "alias": "managedInset"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
 /**
@@ -1770,51 +2160,798 @@ declare class UniSelectComponent<T> implements FormValueControl<T | null> {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniSelectComponent<any>, "uni-select", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "dirty": { "alias": "dirty"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "ariaDescribedBy": { "alias": "ariaDescribedBy"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; "grow": { "alias": "grow"; "required": false; "isSignal": true; }; "compareWith": { "alias": "compareWith"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touched": "touchedChange"; }, never, never, true, never>;
 }
 
-/** Theme-level options for `uni-slider`, resolved by token name. */
+/** A labelled stop on the track. `label` folds into `aria-valuetext` at that value. */
+interface UniSliderMark {
+    value: number;
+    /** Shown under the track and spoken instead of the number, e.g. `'Medium'`. */
+    label?: string;
+}
+/** Which thumb a range slider is reporting on. */
+type UniSliderThumb = 'start' | 'end';
+/**
+ * Theme-level options for `uni-slider`.
+ *
+ * Fill and thumb colour are deliberately **not** here — they are the `variant`
+ * role pair, the same rule every other component follows, so `variant="warn"`
+ * recolours a slider without a theme edit. The track is a groove rather than an
+ * accent, so it stays a token.
+ */
 interface UniSliderOptions {
-    /** Fill and thumb color. */
-    color?: ColorKey;
-    /** Unfilled track color. */
-    trackColor?: ColorKey;
-    /** Track and thumb radius token. */
-    borderRadius?: Radius;
-    /** Track height in px. */
+    /** Track thickness in px. */
     trackHeight?: number;
-    /** Thumb diameter in px. */
+    /** Unfilled track colour. */
+    trackColor?: ContainerColorToken;
+    /** Track radius token. */
+    borderRadius?: Radius;
+    /** Visual thumb diameter in px. The hit area is padded to `minTouchTarget`. */
     thumbSize?: number;
+    /** Thumb radius token. */
+    thumbBorderRadius?: Radius;
+    /**
+     * Minimum pointer target for a thumb, in px — WCAG 2.2 SC 2.5.8 floor. The
+     * visual dot stays `thumbSize`; the transparent hit area grows to this.
+     */
+    minTouchTarget?: number;
+    /** Mark dot diameter in px. */
+    markSize?: number;
+    /** Mark dot colour. */
+    markColor?: ColorKey;
+    /** Typography role for the mark labels and the inline readout. */
+    labelTypeface?: Typeface;
+    /** Colour of the mark labels and inline readout. */
+    labelColor?: ColorKey;
+    /** Tooltip background, for `valueDisplay="tooltip"`. */
+    tooltipColor?: ContainerColorToken;
+    /** Tooltip text colour. */
+    tooltipTextColor?: ColorKey;
+    tooltipShadow?: Shadow;
+    tooltipBorderRadius?: Radius;
+    /**
+     * Click-to-jump transition in ms. A drag is never animated — a transition on
+     * a dragged thumb reads as lag — so this applies to keyboard and track
+     * presses only.
+     */
+    transitionMs?: number;
+}
+
+/** Index into the thumb pair. `0` is the `start` thumb, `1` the `end` thumb. */
+type ThumbIndex = 0 | 1;
+/**
+ * Bounded numeric input by pointer, for values where the *position* is the
+ * information: volume, opacity, weightings, price filters.
+ *
+ * Custom thumbs rather than `<input type="range">`, which the previous version
+ * used: one native range input cannot carry two thumbs, marks or a tooltip, and
+ * a second component for the range case would mean two keyboard maps to keep in
+ * step. The step model and the keyboard map are the cdk's, shared with the
+ * numeric fields, so nothing new is learned moving between them.
+ *
+ * All arithmetic on values runs through the cdk's exact decimal helpers —
+ * stepping `0.1` never yields `0.30000000000000004`. Only pointer *positions*
+ * use floats, and they are snapped to the grid before becoming a value.
+ */
+declare class UniSliderComponent extends BaseComponent<UniSliderOptions> implements FormValueControl<number | UniNumberRange | null> {
+    /** Shape follows `mode`: a number when `single`, a `UniNumberRange` when `range`. */
+    readonly value: _angular_core.ModelSignal<number | UniNumberRange>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly touched: _angular_core.ModelSignal<boolean>;
+    readonly invalid: _angular_core.InputSignal<boolean>;
+    readonly dirty: _angular_core.InputSignal<boolean>;
+    readonly required: _angular_core.InputSignal<boolean>;
+    readonly ariaDescribedBy: _angular_core.InputSignal<string>;
+    /** Accessible name, e.g. "Opacity". Names the group in range mode. */
+    label: _angular_core.InputSignal<string>;
+    mode: _angular_core.InputSignal<"range" | "single">;
+    min: _angular_core.InputSignal<number>;
+    max: _angular_core.InputSignal<number>;
+    step: _angular_core.InputSignal<number>;
+    /** `PageUp`/`PageDown` and `Shift+Arrow`. Default: a tenth of the range. */
+    largeStep: _angular_core.InputSignal<number>;
+    /** Fill anchor. Defaults to `min`; set `0` for a slider that spans ±. */
+    origin: _angular_core.InputSignal<number>;
+    marks: _angular_core.InputSignal<UniSliderMark[]>;
+    /** Marks become the only valid stops — t-shirt sizing, Likert scales. */
+    snapToMarks: _angular_core.InputSignal<boolean>;
+    /**
+     * Where the current value is shown. `tooltip` appears on hover, focus and
+     * drag; `inline` sits at the trailing edge of the track; `input` seats a
+     * compact `uni-number-input` there, two-way bound to the same value — drag
+     * for the ballpark, type for the exact figure, which is the pairing that
+     * makes bounded numeric input actually usable.
+     *
+     * `input` applies to `single` mode only; a range would need two fields, and
+     * `inline` already reads well for two ends.
+     */
+    valueDisplay: _angular_core.InputSignal<"input" | "none" | "tooltip" | "inline">;
+    /** Overrides how a value is rendered and spoken. */
+    formatValue: _angular_core.InputSignal<(value: number) => string>;
+    /** Enforced distance between the two ends, in range mode. */
+    minGap: _angular_core.InputSignal<number>;
+    variant: _angular_core.InputSignal<Variant>;
+    /** Continuous, during a drag or a held key. Bind this for a live preview. */
+    sliding: _angular_core.OutputEmitterRef<number | UniNumberRange>;
+    /**
+     * Committed — on pointer release and key-up. **A form should bind this**:
+     * piping a 60 Hz stream into a model is how sliders get blamed for jank.
+     */
+    changed: _angular_core.OutputEmitterRef<number | UniNumberRange>;
+    private readonly trackRef;
+    private readonly thumbRefs;
+    protected readonly srOnly: string;
+    /** Fences and swaps only — `aria-valuetext` already narrates movement. */
+    protected readonly announcer: _uni_design_system_uni_angular.Announcer;
+    protected readonly groupId: string;
+    /** True from pointerdown until release, to suppress the jump transition. */
+    protected readonly dragging: _angular_core.WritableSignal<boolean>;
+    private draggingThumb;
+    /** Set by keydown, consumed by keyup, so one commit follows a key run. */
+    private keyed;
+    protected readonly isRange: _angular_core.Signal<boolean>;
+    protected readonly resolvedMin: _angular_core.Signal<number>;
+    protected readonly resolvedMax: _angular_core.Signal<number>;
+    private derivePair;
+    /**
+     * The two thumb positions, by **identity** rather than by order: thumb 0 is
+     * whichever thumb the user grabbed first, not necessarily the lower one.
+     *
+     * A `linkedSignal` so an external write to `value` resets them, while a drag
+     * moves them without writing the model on every frame. The computation
+     * deliberately keeps the existing order when the incoming value describes the
+     * same two positions — a commit writes the range back *sorted*, and
+     * re-deriving from that would un-cross a crossed pair and yank the dragged
+     * thumb out from under the pointer mid-drag.
+     */
+    private readonly thumbs;
+    protected readonly thumbIndexes: _angular_core.Signal<ThumbIndex[]>;
+    protected readonly showError: _angular_core.Signal<boolean>;
+    /** Default large step: a tenth of the range, snapped to the step grid. */
+    private readonly resolvedLargeStep;
+    private readonly numberFormat;
+    protected formatted(value: number): string;
+    /** A mark's label speaks for its value, so a marks-only slider says "Medium". */
+    private markLabel;
+    protected valueText(value: number): string;
+    protected percentOf(value: number): number;
+    protected readonly lowValue: _angular_core.Signal<number>;
+    protected readonly highValue: _angular_core.Signal<number>;
+    /** The fill spans between the ends in range mode, or origin → value. */
+    protected readonly fillStart: _angular_core.Signal<number>;
+    protected readonly fillEnd: _angular_core.Signal<number>;
+    protected readonly hasMarkLabels: _angular_core.Signal<boolean>;
+    /** The number-field readout only makes sense for a single value. */
+    protected readonly showReadoutField: _angular_core.Signal<boolean>;
+    /** Fraction digits the readout should accept, taken from the step. */
+    protected readonly readoutDecimals: _angular_core.Signal<[number, number]>;
+    /**
+     * The readout drives the thumb. Guarded against the write-back cycle: the
+     * field is fed from `value`, so a commit here would otherwise bounce.
+     */
+    protected onReadoutValue(next: number | null): void;
+    protected thumbValue(index: ThumbIndex): number;
+    /**
+     * Each thumb's bound is the *other thumb's* position, so a screen-reader user
+     * is told where the wall actually is rather than where the track ends.
+     */
+    protected thumbMin(index: ThumbIndex): number;
+    protected thumbMax(index: ThumbIndex): number;
+    /** Thumbs may cross; which one is "minimum" follows position, not identity. */
+    private isLower;
+    protected thumbLabel(index: ThumbIndex): string;
+    private currentValue;
+    /** Exact `min + n · step`, so a snapped position never carries float drift. */
+    private snapToGrid;
+    private clamp;
+    /**
+     * Move a thumb. `commit` writes the model and emits `changed`; without it the
+     * move is visual and only emits `sliding`.
+     */
+    private setThumb;
+    private commit;
+    private announceValue;
+    /** True when the track is laid out right-to-left. */
+    private isRtl;
+    /** Pointer x → a raw value. The track's visual direction flips in RTL; the value's does not. */
+    private valueFromPointer;
+    private nearestThumb;
+    protected onTrackPointerDown(event: PointerEvent): void;
+    protected onTrackPointerMove(event: PointerEvent): void;
+    protected onTrackPointerUp(): void;
+    /** Adjacent mark, when marks are the only stops. */
+    private markStep;
+    private stepFrom;
+    protected onThumbKeydown(event: KeyboardEvent, index: ThumbIndex): void;
+    /** One commit and one announcement per key run, not per repeat. */
+    protected onThumbKeyup(index: ThumbIndex): void;
+    protected onThumbBlur(): void;
+    protected readonly className: _angular_core.Signal<string>;
+    private readonly fillColor;
+    protected readonly rootClass: _angular_core.Signal<string>;
+    protected readonly rowClass: _angular_core.Signal<string>;
+    protected readonly trackClass: _angular_core.Signal<string>;
+    protected readonly fillClass: _angular_core.Signal<string>;
+    protected readonly markClass: _angular_core.Signal<string>;
+    protected readonly thumbClass: _angular_core.Signal<string>;
+    protected readonly tooltipClass: _angular_core.Signal<string>;
+    protected readonly labelsClass: _angular_core.Signal<string>;
+    protected readonly labelClass: _angular_core.Signal<string>;
+    /** Narrow enough that the track keeps most of the row. */
+    protected readonly readoutFieldClass: _angular_core.Signal<string>;
+    protected readonly readoutClass: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UniSliderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniSliderComponent, "uni-slider, Slider", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "dirty": { "alias": "dirty"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "ariaDescribedBy": { "alias": "ariaDescribedBy"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": true; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "largeStep": { "alias": "largeStep"; "required": false; "isSignal": true; }; "origin": { "alias": "origin"; "required": false; "isSignal": true; }; "marks": { "alias": "marks"; "required": false; "isSignal": true; }; "snapToMarks": { "alias": "snapToMarks"; "required": false; "isSignal": true; }; "valueDisplay": { "alias": "valueDisplay"; "required": false; "isSignal": true; }; "formatValue": { "alias": "formatValue"; "required": false; "isSignal": true; }; "minGap": { "alias": "minGap"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touched": "touchedChange"; "sliding": "sliding"; "changed": "changed"; }, never, never, true, never>;
+}
+
+/**
+ * Where the stepper buttons sit.
+ *
+ * `stacked` is the dense desktop default; `split` (− … +) is the touch and
+ * quantity language; `trailing` puts − and + together at the end; `none` hides
+ * them, leaving the arrow keys as the only step route.
+ */
+type UniStepperLayout = 'stacked' | 'split' | 'trailing' | 'none';
+/** A refused commit. The raw text stays in the field rather than being dropped. */
+interface UniNumberRejection {
+    raw: string;
+    reason: UniNumberRejectReason;
+}
+/** A committed step, for callers that need to distinguish it from typing. */
+interface UniNumberStepped {
+    from: number | null;
+    to: number;
+    /** The signed amount applied, e.g. `-10` for a large step down. */
+    by: number;
+}
+/**
+ * Theme-level options for `uni-number-input`.
+ *
+ * Field chrome — colour, border, radius, focus outline — is **not** duplicated
+ * here. It comes from the shared `input` options via `uni-input-box`, exactly
+ * like tag-input, date-input and combobox, so a number field restyles with
+ * every other field.
+ */
+interface UniNumberInputOptions {
+    stepperLayout?: UniStepperLayout;
+    /** Glyph for the `+` button in the split and trailing layouts. */
+    incrementIcon?: IconName;
+    /** Glyph for the `−` button in the split and trailing layouts. */
+    decrementIcon?: IconName;
+    /** Glyph for the upper arrow in the stacked layout. */
+    stepUpIcon?: IconName;
+    /** Glyph for the lower arrow in the stacked layout. */
+    stepDownIcon?: IconName;
+    /** Width of a stepper column in px. */
+    stepperWidth?: number;
+    /**
+     * Minimum pointer target for a stepper button, in px — WCAG 2.2 SC 2.5.8.
+     * Applies to the `split` and `trailing` layouts; the two `stacked` arrows
+     * share the field height instead, which is why a coarse pointer switches to
+     * `split`.
+     */
+    minTouchTarget?: number;
+    /** Colour of the prefix/suffix adornments. */
+    affixColor?: ColorKey;
+    /** Space between an adornment and the editable text. */
+    affixGap?: NullableSize;
+    /** Default text alignment; the `align` input overrides it per instance. */
+    align?: 'start' | 'end' | 'center';
+    /** `font-variant-numeric: tabular-nums`, so held stepping does not jitter. */
+    tabularNumerals?: boolean;
+    /** Hold this long before the stepper starts repeating. */
+    repeatDelayMs?: number;
+    /** Repeat period once it starts. */
+    repeatIntervalMs?: number;
+    /** Repeat period at full speed. */
+    repeatFastIntervalMs?: number;
+    /** Hold this long before the repeat begins accelerating. */
+    repeatRampMs?: number;
 }
 
 /**
- * Range slider on a native `<input type="range">` — keyboard interaction and
- * the ARIA slider contract come from the platform. Fill, track, thumb and
- * radii resolve from `slider` theme tokens; the fill percentage rides a CSS
- * custom property so dragging never regenerates styles.
+ * Numeric field with locale-aware parsing, `Intl` formatting on commit,
+ * prefix/suffix adornments and steppers that hold to repeat.
+ *
+ * Not `<input type="number">`, and the first reason is a data-loss bug: per the
+ * HTML value sanitization algorithm, a number input whose text is not a valid
+ * floating-point number reports `value === ''`. Type `12,50` as most of Europe
+ * does, or paste `1,234.56` from a spreadsheet, and the app reads an empty
+ * field. This is `type="text"` with `role="spinbutton"`, which is the only way
+ * to keep the user's malformed text on screen and tell them about it.
+ *
+ * Chrome comes from `uni-input-box`, so error, disabled and focus states match
+ * every other field. All arithmetic runs on the cdk's exact decimal helpers.
  */
-declare class UniSliderComponent extends BaseComponent<UniSliderOptions> implements FormValueControl<number> {
+declare class UniNumberInputComponent extends BaseComponent<UniNumberInputOptions> implements FormValueControl<number | null> {
     readonly value: _angular_core.ModelSignal<number>;
     readonly disabled: _angular_core.InputSignal<boolean>;
     readonly touched: _angular_core.ModelSignal<boolean>;
     readonly invalid: _angular_core.InputSignal<boolean>;
     readonly dirty: _angular_core.InputSignal<boolean>;
-    /** Synced from required() validators by the Signal Forms [field] directive. */
     readonly required: _angular_core.InputSignal<boolean>;
+    readonly ariaDescribedBy: _angular_core.InputSignal<string>;
     /**
-     * Id(s) of external element(s) describing this control — typically your
-     * app-rendered value or error text — exposed as aria-describedby.
+     * Exact binding, as a canonical decimal string. Bind this instead of `value`
+     * where a cent in the fifth decimal place matters; both stay in sync, so it
+     * is a one-word change from the ordinary case.
+     */
+    readonly valueAsString: _angular_core.ModelSignal<string>;
+    /** Accessible name, e.g. "Unit price". */
+    label: _angular_core.InputSignal<string>;
+    placeholder: _angular_core.InputSignal<string>;
+    preset: _angular_core.InputSignal<UniNumberPreset>;
+    /** ISO 4217 code, e.g. `'USD'`. Implies `preset="currency"`. */
+    currency: _angular_core.InputSignal<string>;
+    /** BCP 47 tag. Defaults to the document language, then the browser's. */
+    locale: _angular_core.InputSignal<string>;
+    /** Static adornment before the number, e.g. `'$'`. Never parseable input. */
+    prefix: _angular_core.InputSignal<string>;
+    /** Static adornment after the number, e.g. `'kg'`, `'/mo'`. */
+    suffix: _angular_core.InputSignal<string>;
+    decimals: _angular_core.InputSignal<number | [min: number, max: number]>;
+    grouping: _angular_core.InputSignal<false | "auto" | "always" | "min2">;
+    /** Escape hatch, merged over the preset. */
+    numberFormat: _angular_core.InputSignal<Intl.NumberFormatOptions>;
+    roundingMode: _angular_core.InputSignal<UniRoundingMode>;
+    align: _angular_core.InputSignal<"center" | "start" | "end">;
+    /** The model is a fraction: `0.15` displays as `15%`. */
+    valueIsFraction: _angular_core.InputSignal<boolean>;
+    /** Spoken long form of an abbreviated suffix, e.g. `'kilograms'` for `kg`. */
+    unitAnnouncement: _angular_core.InputSignal<string>;
+    readOnly: _angular_core.InputSignal<boolean>;
+    /** Renders without its own input-box chrome, for composers like uni-slider. */
+    embedded: _angular_core.InputSignal<boolean>;
+    min: _angular_core.InputSignal<number>;
+    max: _angular_core.InputSignal<number>;
+    step: _angular_core.InputSignal<number>;
+    /** `PageUp`/`PageDown` and `Shift+Arrow`. Default: `step × 10`. */
+    largeStep: _angular_core.InputSignal<number>;
+    /** `Alt+Arrow`, Figma's fine-nudge convention. Unset disables it. */
+    smallStep: _angular_core.InputSignal<number>;
+    stepOrigin: _angular_core.InputSignal<"min" | "zero">;
+    /** Cyclic fields only — 23 → 0 hours, 359 → 0 degrees. */
+    wrap: _angular_core.InputSignal<boolean>;
+    /** `false` refuses an out-of-range commit instead of clamping it. */
+    clampOnCommit: _angular_core.InputSignal<boolean>;
+    /** What ↑ commits on an empty field. Default: `min ?? 0`. */
+    emptyStepValue: _angular_core.InputSignal<number>;
+    commitOnBlur: _angular_core.InputSignal<boolean>;
+    selectOnFocus: _angular_core.InputSignal<boolean>;
+    /** `12*3` → 36. Off by default: a parser in a form field is a real cost. */
+    allowExpressions: _angular_core.InputSignal<boolean>;
+    /** Scroll-to-step. Off by default — see `onWheel`. */
+    wheel: _angular_core.InputSignal<boolean>;
+    repeat: _angular_core.InputSignal<boolean>;
+    /** Custom parser, replacing the built-in locale parsing. */
+    parse: _angular_core.InputSignal<(raw: string, locale: string) => string | null>;
+    /** Overrides the themed layout for this instance. */
+    stepperLayout: _angular_core.InputSignal<_uni_design_system_uni_angular.UniStepperLayout>;
+    stepped: _angular_core.OutputEmitterRef<UniNumberStepped>;
+    /** A commit was refused; the raw text stays in the field. */
+    rejected: _angular_core.OutputEmitterRef<UniNumberRejection>;
+    private readonly inputRef;
+    protected readonly srOnly: string;
+    /** Clamps, fences, rejections and expression results are otherwise silent. */
+    protected readonly announcer: _uni_design_system_uni_angular.Announcer;
+    protected readonly hintId: string;
+    /** Uncommitted text. `null` means "show the committed value". */
+    private readonly draft;
+    /** A commit that failed — styles the field until the text is edited. */
+    protected readonly draftInvalid: _angular_core.WritableSignal<boolean>;
+    protected readonly focused: _angular_core.WritableSignal<boolean>;
+    /**
+     * The canonical decimal behind both models — the field's source of truth.
+     *
+     * Two models that each accept writes need a rule for which one won, and
+     * "whichever the app touched last" is the only one that does not surprise
+     * somebody. A `linkedSignal` over both gives us that: the model whose value
+     * differs from the previous source is the one that changed.
+     *
+     * The subtlety is the echo. Committing writes both models, and the `value`
+     * projection of a 17-digit exact string is lossy — so on the next pass
+     * `value` looks changed, and naively adopting it would clobber the very
+     * precision `valueAsString` exists to keep. A changed `value` that already
+     * matches `Number(exact)` is our own projection coming back, not a write.
+     */
+    private readonly canonical;
+    constructor();
+    protected readonly resolvedLocale: _angular_core.Signal<string>;
+    protected readonly format: _angular_core.Signal<_uni_design_system_uni_angular.UniResolvedNumberFormat>;
+    /**
+     * Two stacked arrows cannot both be 24px tall inside a 32px field, so on a
+     * coarse pointer the stacked layout becomes `split`, where each button is a
+     * full-height square and clears the WCAG 2.2 SC 2.5.8 floor. Two 12px
+     * targets under a fingertip is a coin toss.
+     */
+    private readonly coarsePointer;
+    protected readonly layout: _angular_core.Signal<_uni_design_system_uni_angular.UniStepperLayout>;
+    protected readonly showSteppers: _angular_core.Signal<boolean>;
+    protected readonly showError: _angular_core.Signal<boolean>;
+    /** Raw while focused, formatted once committed — no caret arithmetic ever. */
+    protected readonly displayText: _angular_core.Signal<string>;
+    protected readonly valueTextForAria: _angular_core.Signal<string>;
+    /**
+     * `aria-valuenow` is omitted entirely on an empty field, per APG — a
+     * spinbutton reporting 0 for "nothing yet" is a wrong answer, not a missing
+     * one. `aria-valuetext` carries the localized "Empty" instead.
+     */
+    protected readonly canonicalForAria: _angular_core.Signal<string>;
+    protected readonly describedBy: _angular_core.Signal<string>;
+    private atFence;
+    protected readonly atMin: _angular_core.Signal<boolean>;
+    protected readonly atMax: _angular_core.Signal<boolean>;
+    /** Set the source of truth; the constructor's effect pushes it to both models. */
+    private write;
+    /**
+     * Turn the draft into a value. Out-of-range either clamps (announced) or is
+     * refused, per `clampOnCommit`; unreadable text stays in the field, flagged.
+     */
+    protected commitDraft(): void;
+    private acceptValue;
+    private reject;
+    private rejectionMessage;
+    private stepSize;
+    /**
+     * Apply one step. An empty field commits `emptyStepValue ?? min ?? 0`, so ↑
+     * on a blank quantity gives 1 rather than NaN.
+     */
+    protected applyStep(direction: 1 | -1, magnitude?: 'small' | 'normal' | 'large', announce?: boolean): void;
+    private announceValue;
+    private announceFence;
+    private readonly repeatTiming;
+    /**
+     * The live region announces on release only — a screen reader narrating two
+     * hundred intermediate values is a denial of service.
+     */
+    protected readonly increment: _uni_design_system_uni_angular.PressRepeat;
+    protected readonly decrement: _uni_design_system_uni_angular.PressRepeat;
+    protected onInput(text: string): void;
+    protected onFocus(): void;
+    protected onBlur(): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    /**
+     * Scroll-to-step, off by default. A *focused* `<input type="number">` changes
+     * value on the wheel, which silently corrupts forms people are merely
+     * scrolling past. When enabled this needs focus **and** hover, and it only
+     * calls `preventDefault` when the value actually moved, so a page does not
+     * get scroll-trapped on a field sitting at its max.
      */
+    protected onWheel(event: WheelEvent): void;
+    protected readonly className: _angular_core.Signal<string>;
+    protected readonly fieldRowClass: _angular_core.Signal<string>;
+    /** The shared field inset, reused on the trailing side so the two match. */
+    private readonly trailingInset;
+    protected readonly inputClass: _angular_core.Signal<string>;
+    /**
+     * The shared field chrome, read from the `input` theme entry — the same entry
+     * `uni-input-box` resolves. Not a duplicate token: the inset has to be the
+     * one every other field uses, or a money field stops lining up with the text
+     * field above it.
+     */
+    private readonly fieldChrome;
+    /**
+     * The leading inset for a prefix adornment. When there is a prefix the field
+     * tells the box to stop insetting the `<input>` (`managedInset`) and puts the
+     * inset here instead, so the `$` sits at the field's leading edge with the
+     * number right after it. With no prefix the box keeps doing it — the text is
+     * the leading edge then, and the box's rule outranks this class anyway.
+     * `embedded` fields have no chrome, so they get no inset either.
+     */
+    private readonly leadingInset;
+    private affixBase;
+    /** Carries the field's leading inset, being the first thing in the row. */
+    protected readonly prefixClass: _angular_core.Signal<string>;
+    protected readonly suffixClass: _angular_core.Signal<string>;
+    /** Shared chrome for every stepper button, in any layout. */
+    private stepperButton;
+    /** Split and trailing layouts: one square button per direction. */
+    protected readonly stepperClass: _angular_core.Signal<string>;
+    /** Stacked layout: two half-height arrows sharing one column. */
+    protected readonly stackedColumnClass: _angular_core.Signal<string>;
+    protected readonly stackedButtonClass: _angular_core.Signal<string>;
+    protected readonly glyphSize: _angular_core.Signal<12 | 18>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UniNumberInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniNumberInputComponent, "uni-number-input, NumberInput", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "dirty": { "alias": "dirty"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "ariaDescribedBy": { "alias": "ariaDescribedBy"; "required": false; "isSignal": true; }; "valueAsString": { "alias": "valueAsString"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": true; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "preset": { "alias": "preset"; "required": false; "isSignal": true; }; "currency": { "alias": "currency"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "prefix": { "alias": "prefix"; "required": false; "isSignal": true; }; "suffix": { "alias": "suffix"; "required": false; "isSignal": true; }; "decimals": { "alias": "decimals"; "required": false; "isSignal": true; }; "grouping": { "alias": "grouping"; "required": false; "isSignal": true; }; "numberFormat": { "alias": "numberFormat"; "required": false; "isSignal": true; }; "roundingMode": { "alias": "roundingMode"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "valueIsFraction": { "alias": "valueIsFraction"; "required": false; "isSignal": true; }; "unitAnnouncement": { "alias": "unitAnnouncement"; "required": false; "isSignal": true; }; "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; "embedded": { "alias": "embedded"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "largeStep": { "alias": "largeStep"; "required": false; "isSignal": true; }; "smallStep": { "alias": "smallStep"; "required": false; "isSignal": true; }; "stepOrigin": { "alias": "stepOrigin"; "required": false; "isSignal": true; }; "wrap": { "alias": "wrap"; "required": false; "isSignal": true; }; "clampOnCommit": { "alias": "clampOnCommit"; "required": false; "isSignal": true; }; "emptyStepValue": { "alias": "emptyStepValue"; "required": false; "isSignal": true; }; "commitOnBlur": { "alias": "commitOnBlur"; "required": false; "isSignal": true; }; "selectOnFocus": { "alias": "selectOnFocus"; "required": false; "isSignal": true; }; "allowExpressions": { "alias": "allowExpressions"; "required": false; "isSignal": true; }; "wheel": { "alias": "wheel"; "required": false; "isSignal": true; }; "repeat": { "alias": "repeat"; "required": false; "isSignal": true; }; "parse": { "alias": "parse"; "required": false; "isSignal": true; }; "stepperLayout": { "alias": "stepperLayout"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touched": "touchedChange"; "valueAsString": "valueAsStringChange"; "stepped": "stepped"; "rejected": "rejected"; }, never, never, true, never>;
+}
+
+/** Which end of the range a rejection or a change came from. */
+type UniNumberRangePart = 'start' | 'end';
+/** A refused commit on one end. The raw text stays in that part. */
+interface UniNumberRangeRejection {
+    part: UniNumberRangePart;
+    raw: string;
+    reason: 'unparseable' | 'not-integer';
+}
+/**
+ * Theme-level options for `uni-number-range-input`.
+ *
+ * Field chrome — colour, border, radius, focus outline — is not duplicated
+ * here; it comes from the shared `input` options via `uni-input-box`, so a
+ * range field restyles with every other field. These are the composer's own.
+ */
+interface UniNumberRangeInputOptions {
+    /** Space between each part and the divider. */
+    partGap?: NullableSize;
+    /**
+     * Text between the two ends. Literal punctuation, not an icon token — an en
+     * dash between two numbers is not a glyph a theme swaps artwork for.
+     */
+    dividerText?: string;
+    dividerColor?: ColorKey;
+    /** Colour of each part's prefix/suffix adornment. */
+    affixColor?: ColorKey;
+    /** Space between an adornment and its number. */
+    affixGap?: NullableSize;
+}
+
+/**
+ * Two linked numeric fields in one chrome, with one `{ start, end }` value —
+ * price filters, thresholds, tolerances.
+ *
+ * `start`/`end` deliberately match `UniDateRange`, so the library has one range
+ * vocabulary, and they avoid colliding with the `min`/`max` **inputs**, which
+ * mean the fence rather than the value.
+ *
+ * It owns its commit path rather than nesting two `uni-number-input`s, because
+ * the two behaviours the spec asks for need *different* bounds: a stepper must
+ * be fenced at the other end, while a typed commit must reach the parent
+ * un-clamped so a backwards range can be swapped instead of destroyed. A child
+ * field applies one bound pair to both. The arithmetic, parsing and formatting
+ * are still the cdk's, shared with every other numeric control.
+ */
+declare class UniNumberRangeInputComponent extends BaseComponent<UniNumberRangeInputOptions> implements FormValueControl<UniNumberRange | null> {
+    readonly value: _angular_core.ModelSignal<UniNumberRange>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly touched: _angular_core.ModelSignal<boolean>;
+    readonly invalid: _angular_core.InputSignal<boolean>;
+    readonly dirty: _angular_core.InputSignal<boolean>;
+    readonly required: _angular_core.InputSignal<boolean>;
     readonly ariaDescribedBy: _angular_core.InputSignal<string>;
+    /** Names the group, e.g. "Price range". */
     label: _angular_core.InputSignal<string>;
+    startLabel: _angular_core.InputSignal<string>;
+    endLabel: _angular_core.InputSignal<string>;
+    preset: _angular_core.InputSignal<UniNumberPreset>;
+    currency: _angular_core.InputSignal<string>;
+    locale: _angular_core.InputSignal<string>;
+    prefix: _angular_core.InputSignal<string>;
+    suffix: _angular_core.InputSignal<string>;
+    decimals: _angular_core.InputSignal<number | [min: number, max: number]>;
+    grouping: _angular_core.InputSignal<false | "auto" | "always" | "min2">;
+    roundingMode: _angular_core.InputSignal<UniRoundingMode>;
+    placeholderStart: _angular_core.InputSignal<string>;
+    placeholderEnd: _angular_core.InputSignal<string>;
     min: _angular_core.InputSignal<number>;
     max: _angular_core.InputSignal<number>;
     step: _angular_core.InputSignal<number>;
+    /** Enforced distance between the two ends. */
+    minGap: _angular_core.InputSignal<number>;
+    /** The ends were entered backwards and have been exchanged. */
+    swapped: _angular_core.OutputEmitterRef<UniNumberRange>;
+    /** A typed commit on one end could not be read; its text stays in place. */
+    rejected: _angular_core.OutputEmitterRef<UniNumberRangeRejection>;
+    private readonly inputRefs;
+    protected readonly srOnly: string;
+    protected readonly announcer: _uni_design_system_uni_angular.Announcer;
+    protected readonly hintId: string;
+    protected readonly groupId: string;
+    /** Uncommitted text per part. `null` means "show the committed value". */
+    private readonly drafts;
+    private readonly focusedPart;
+    private readonly invalidPart;
+    protected readonly parts: readonly UniNumberRangePart[];
+    private readonly fieldChrome;
+    protected readonly format: _angular_core.Signal<_uni_design_system_uni_angular.UniResolvedNumberFormat>;
+    /** Form-level error, which belongs to both ends. */
+    protected readonly formError: _angular_core.Signal<boolean>;
+    /**
+     * Box-level error. A refused draft in *one* end flags the shared chrome, but
+     * must not flag the other end's input — that end is fine.
+     */
+    protected readonly showError: _angular_core.Signal<boolean>;
+    protected readonly describedBy: _angular_core.Signal<string>;
+    /** The committed canonical decimal for a part, or `null` when that end is open. */
+    private canonicalOf;
+    protected valueOf(part: UniNumberRangePart): number | null;
+    protected displayText(part: UniNumberRangePart): string;
+    protected partLabel(part: UniNumberRangePart): string;
+    protected valueTextOf(part: UniNumberRangePart): string;
+    protected isInvalid(part: UniNumberRangePart): boolean;
+    /** Exact `a ± b` without a float, for the gap arithmetic. */
+    private shiftBy;
+    /**
+     * The fence a part's **stepping** and its ARIA see: the other end, held off
+     * by `minGap`, intersected with the outer bounds. This is deliberately
+     * tighter than what a typed commit is measured against — the steppers must
+     * not walk one end through the other, while typing a backwards range should
+     * be swapped rather than clamped away.
+     */
+    protected stepFence(part: UniNumberRangePart): {
+        min?: number;
+        max?: number;
+    };
+    private writeRange;
+    protected onInput(part: UniNumberRangePart, text: string): void;
+    /**
+     * Commit one part. Out-of-range clamps to the **outer** bounds only, so the
+     * other end never destroys what was typed; the ends are then reconciled.
+     */
+    protected commitPart(part: UniNumberRangePart): void;
+    /**
+     * Put the two ends in order. A backwards pair is **swapped**, not refused —
+     * the same rule `uni-calendar` applies to a backwards date range, because the
+     * user pointed at the range they meant. Otherwise `minGap` is honoured by
+     * pushing the end that was just edited back to the boundary, which is what
+     * makes stepping behave as a fence rather than dragging the other end along.
+     */
+    private reconcile;
+    protected applyStep(part: UniNumberRangePart, direction: 1 | -1, large?: boolean): void;
+    private announceValue;
+    protected onFocus(part: UniNumberRangePart): void;
+    protected onBlur(part: UniNumberRangePart): void;
+    protected onKeydown(event: KeyboardEvent, part: UniNumberRangePart): void;
+    protected readonly className: _angular_core.Signal<string>;
+    protected readonly rowClass: _angular_core.Signal<string>;
+    /** Each end is its own `[prefix][number][suffix]` group. */
+    protected readonly partWrapClass: _angular_core.Signal<string>;
+    protected readonly affixClass: _angular_core.Signal<string>;
+    protected readonly partClass: _angular_core.Signal<string>;
+    private partBase;
+    protected readonly invalidClass: _angular_core.Signal<string>;
+    protected readonly dividerClass: _angular_core.Signal<string>;
+    protected readonly dividerText: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UniNumberRangeInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniNumberRangeInputComponent, "uni-number-range-input, NumberRangeInput", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "dirty": { "alias": "dirty"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "ariaDescribedBy": { "alias": "ariaDescribedBy"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": true; "isSignal": true; }; "startLabel": { "alias": "startLabel"; "required": false; "isSignal": true; }; "endLabel": { "alias": "endLabel"; "required": false; "isSignal": true; }; "preset": { "alias": "preset"; "required": false; "isSignal": true; }; "currency": { "alias": "currency"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "prefix": { "alias": "prefix"; "required": false; "isSignal": true; }; "suffix": { "alias": "suffix"; "required": false; "isSignal": true; }; "decimals": { "alias": "decimals"; "required": false; "isSignal": true; }; "grouping": { "alias": "grouping"; "required": false; "isSignal": true; }; "roundingMode": { "alias": "roundingMode"; "required": false; "isSignal": true; }; "placeholderStart": { "alias": "placeholderStart"; "required": false; "isSignal": true; }; "placeholderEnd": { "alias": "placeholderEnd"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "minGap": { "alias": "minGap"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touched": "touchedChange"; "swapped": "swapped"; "rejected": "rejected"; }, never, never, true, never>;
+}
+
+/**
+ * Theme-level options for `uni-quantity-stepper`.
+ *
+ * Unlike the other numeric controls this does **not** inherit the shared
+ * `input` chrome — it is not a field, has no label and no error border — so it
+ * carries its own container tokens. They default to the same values `input`
+ * uses, so a cart stepper and a form field look related out of the box, and a
+ * theme can part them without editing every field.
+ *
+ * Height comes from the `sizes` block (`sm` 24 / `md` 32 / `lg` 40) rather than
+ * an option, and it is the *outer* height, so an `md` stepper lines up with a
+ * 32px field. The buttons are square at it: `md` and `lg` clear the 24×24
+ * pointer target of WCAG 2.2 SC 2.5.8, while `sm` leaves 22px inside its border
+ * and is therefore the dense desktop option.
+ */
+interface UniQuantityStepperOptions {
+    color?: ContainerColorToken;
+    border?: Border;
+    borderRadius?: Radius;
+    /**
+     * Colour override for the rules between the buttons and the value. Unset —
+     * the default — means they take `border`, so the frame reads as one weight
+     * and the dividers follow the focus border. Set this only for a deliberately
+     * distinct divider.
+     */
+    dividerColor?: ColorKey;
+    incrementIcon?: IconName;
+    decrementIcon?: IconName;
+    /** Replaces the decrement glyph at `min` when `deleteAtMin` is set. */
+    deleteIcon?: IconName;
+    /** `font-variant-numeric: tabular-nums`, so held stepping does not jitter. */
+    tabularNumerals?: boolean;
+    /** Minimum width of the value, e.g. `'3ch'`. Stops a step reflowing the row. */
+    valueWidth?: string | number;
+}
+
+/**
+ * `− 3 +` for cart lines, table cells and seat counts: the numeric core with no
+ * field chrome, no label and no room for either.
+ *
+ * A separate component rather than a `chrome="bare"` flag on
+ * `uni-number-input`, because this control is defined by what it does *not*
+ * have — presets, affixes, expressions, four stepper layouts — and eight inputs
+ * are easier to write correctly than forty with a list of which ones to leave
+ * alone. The arithmetic, parsing and hold-to-repeat are the cdk's, shared with
+ * the field, so `1,200` and the keyboard map behave identically in both.
+ *
+ * The middle stays a real input by default: typing `12` beats tapping `+`
+ * eleven times. `editable=false` is for read-mostly tables.
+ */
+declare class UniQuantityStepperComponent extends BaseComponent<UniQuantityStepperOptions> implements FormValueControl<number | null> {
+    readonly value: _angular_core.ModelSignal<number>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly touched: _angular_core.ModelSignal<boolean>;
+    readonly invalid: _angular_core.InputSignal<boolean>;
+    readonly dirty: _angular_core.InputSignal<boolean>;
+    readonly required: _angular_core.InputSignal<boolean>;
+    readonly ariaDescribedBy: _angular_core.InputSignal<string>;
+    /**
+     * Accessible name. Never visible and always needed — a cart with six of these
+     * needs "Quantity, Blue T-shirt (M)", not six controls called "Quantity".
+     */
+    label: _angular_core.InputSignal<string>;
+    min: _angular_core.InputSignal<number>;
+    max: _angular_core.InputSignal<number>;
+    step: _angular_core.InputSignal<number>;
+    size: _angular_core.InputSignal<Size>;
+    /** `false` renders the number as text: read-mostly tables. */
+    editable: _angular_core.InputSignal<boolean>;
+    /**
+     * The cart pattern in one attribute: at `min` the decrement button becomes a
+     * remove affordance and emits `removed` rather than stepping. Without it
+     * every shop reimplements the same `value === 1 ? remove() : step(-1)` branch
+     * outside the component.
+     */
+    deleteAtMin: _angular_core.InputSignal<boolean>;
+    /**
+     * The remove affordance was activated — the row should come out.
+     *
+     * Named `removed`, not the spec's `emptied`: that word is a native
+     * `HTMLMediaElement` event, which `@angular-eslint/no-output-native` bans for
+     * good reason, and `removed` is already what `uni-tag` calls this same
+     * request.
+     */
+    removed: _angular_core.OutputEmitterRef<void>;
+    private readonly inputRef;
+    protected readonly srOnly: string;
+    protected readonly announcer: _uni_design_system_uni_angular.Announcer;
+    protected readonly hintId: string;
+    /** Uncommitted text. `null` means "show the committed value". */
+    private readonly draft;
+    private readonly canonical;
+    /** Quantities are plain numbers; precision follows the step. */
+    protected readonly format: _angular_core.Signal<_uni_design_system_uni_angular.UniResolvedNumberFormat>;
+    protected readonly displayText: _angular_core.Signal<string>;
+    protected readonly showError: _angular_core.Signal<boolean>;
+    protected readonly describedBy: _angular_core.Signal<string>;
+    /** A quantity has a floor even when a validator has not supplied one. */
     protected readonly resolvedMin: _angular_core.Signal<number>;
-    protected readonly resolvedMax: _angular_core.Signal<number>;
-    markAsTouched(): void;
-    handleInput(event: Event): void;
-    protected readonly fillPercent: _angular_core.Signal<string>;
+    protected readonly atMin: _angular_core.Signal<boolean>;
+    protected readonly atMax: _angular_core.Signal<boolean>;
+    /** At the floor with `deleteAtMin`, the − is a remove control instead. */
+    protected readonly showDelete: _angular_core.Signal<boolean>;
+    protected readonly decrementIcon: _angular_core.Signal<_uni_design_system_uni_core.IconName>;
+    protected readonly decrementLabel: _angular_core.Signal<string>;
+    protected onInput(text: string): void;
+    /**
+     * The same parse path as the field, so `1,200` commits as 1200 here too.
+     * Unreadable text reverts rather than being kept: this control has no room to
+     * show an error, and no `rejected` output to report one through.
+     */
+    protected commitDraft(): void;
+    protected applyStep(direction: 1 | -1, announce?: boolean): void;
+    /**
+     * The decrement button has two jobs. Below the floor with `deleteAtMin` it is
+     * a remove control — a single click, with nothing to hold and repeat — so the
+     * press/repeat machinery is skipped entirely in that state.
+     */
+    protected onDecrementPress(event: PointerEvent): void;
+    protected onDecrementClick(): void;
+    private announceValue;
+    private announceFence;
+    /** Announced on release only; narrating every intermediate value is noise. */
+    protected readonly increment: _uni_design_system_uni_angular.PressRepeat;
+    protected readonly decrement: _uni_design_system_uni_angular.PressRepeat;
+    protected onKeydown(event: KeyboardEvent): void;
+    protected onBlur(): void;
+    protected focusField(): void;
+    protected readonly className: _angular_core.Signal<string>;
+    /** Overall height, from the theme's `sizes` block. */
+    private readonly height;
+    /**
+     * The shared field chrome, read from the same `input` theme entry
+     * `uni-input-box` resolves. This control has its own container tokens, but the
+     * **focus indicator** has to be the one every other field uses — a stepper
+     * that highlights differently from the field beside it reads as a bug.
+     */
+    private readonly fieldChrome;
+    protected readonly rootClass: _angular_core.Signal<string>;
+    /** Square at the field height, so the pointer target is legal at every size. */
+    protected readonly buttonClass: _angular_core.Signal<string>;
+    /** The rules either side of the value, matching the frame around it. */
+    private readonly dividerBorder;
+    private valueBase;
     protected readonly inputClass: _angular_core.Signal<string>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UniSliderComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniSliderComponent, "uni-slider", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "dirty": { "alias": "dirty"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "ariaDescribedBy": { "alias": "ariaDescribedBy"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": true; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touched": "touchedChange"; }, never, never, true, never>;
+    /** Read-only presentation: centred text on the same grid as the input. */
+    protected readonly readoutClass: _angular_core.Signal<string>;
+    protected readonly glyphSize: _angular_core.Signal<number>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UniQuantityStepperComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniQuantityStepperComponent, "uni-quantity-stepper, QuantityStepper", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "dirty": { "alias": "dirty"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "ariaDescribedBy": { "alias": "ariaDescribedBy"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": true; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "editable": { "alias": "editable"; "required": false; "isSignal": true; }; "deleteAtMin": { "alias": "deleteAtMin"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touched": "touchedChange"; "removed": "removed"; }, never, never, true, never>;
 }
 
 /**
@@ -1951,6 +3088,13 @@ declare class UniTagInputComponent extends BaseComponent<UniTagInputOptions> imp
         has the same geometry but is only the fallback's positioning context. */
     protected readonly className: _angular_core.Signal<string>;
     protected readonly wrapperClass: _angular_core.Signal<string>;
+    /**
+     * The shared field chrome, from the same `input` theme entry
+     * `uni-input-box` resolves — not a duplicate token, because the inset has to
+     * match every other field or a chip field stops lining up with the text
+     * field above it.
+     */
+    private readonly fieldChrome;
     protected readonly fieldClass: _angular_core.Signal<string>;
     protected readonly inputClass: _angular_core.Signal<string>;
     protected readonly listClass: _angular_core.Signal<string>;
@@ -2182,7 +3326,7 @@ declare class UniToggleComponent extends BaseComponent<UniToggleOptions> impleme
  */
 declare const UNI_LAYOUT: readonly [typeof UniBoxDirective, typeof UniRowDirective, typeof UniStackDirective, typeof UniCenterDirective, typeof UniWrapDirective, typeof UniGridDirective, typeof UniGridAreaDirective, typeof UniTextDirective];
 /** Every form control, for `imports: [...UNI_FORMS]`. */
-declare const UNI_FORMS: readonly [typeof UniInputComponent, typeof UniInputBoxComponent, typeof UniTextareaComponent, typeof UniSelectComponent, typeof UniCheckboxComponent, typeof UniRadioComponent, typeof UniToggleComponent, typeof UniComboboxComponent, typeof UniMultiSelectComponent, typeof UniMultiSelectDropdownComponent, typeof UniSearchInputComponent, typeof UniTagInputComponent, typeof UniSliderComponent, typeof UniDateInputComponent, typeof UniTimeInputComponent, typeof UniDateTimeInputComponent];
+declare const UNI_FORMS: readonly [typeof UniInputComponent, typeof UniInputBoxComponent, typeof UniTextareaComponent, typeof UniSelectComponent, typeof UniCheckboxComponent, typeof UniRadioComponent, typeof UniToggleComponent, typeof UniComboboxComponent, typeof UniMultiSelectComponent, typeof UniMultiSelectDropdownComponent, typeof UniSearchInputComponent, typeof UniTagInputComponent, typeof UniNumberInputComponent, typeof UniNumberRangeInputComponent, typeof UniQuantityStepperComponent, typeof UniSliderComponent, typeof UniDateInputComponent, typeof UniTimeInputComponent, typeof UniDateTimeInputComponent];
 
 /** Theme-level options for `uni-app-bar`, resolved by token name. */
 interface UniAppBarOptions {
@@ -2448,7 +3592,7 @@ declare class UniCalendarComponent extends BaseComponent<UniCalendarOptions> imp
     /** BCP 47 tag; defaults to the document language, then the browser's. */
     locale: _angular_core.InputSignal<string>;
     /** First day of week, 0 = Sunday; defaults from the locale's week info. */
-    weekStart: _angular_core.InputSignal<0 | 1 | 2 | 3 | 4 | 6 | 5>;
+    weekStart: _angular_core.InputSignal<0 | 1 | 2 | 3 | 4 | 5 | 6>;
     /** Names the grid when it stands alone (otherwise the heading names it). */
     ariaLabel: _angular_core.InputSignal<string>;
     /** Day geometry token; `sm`/`md`/`lg` map to the theme's `calendar` sizes. */
@@ -4456,5 +5600,5 @@ declare class DragAndDropDirective {
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DragAndDropDirective, "[uni-drag-n-drop], [dragAndDrop]", never, {}, { "fileDropped": "fileDropped"; }, never, never, true, never>;
 }
 
-export { BodyRenderDirective, ConfirmationDialogComponent, DragAndDropDirective, FOCUSABLE_SELECTOR, ListboxNavigation, LocalStorageService, NotificationService, NotificationsComponent, RippleDirective, TRANSFORM_ORIGINS, ThemeService, UNI_FORMS, UNI_LAYOUT, UNI_THEMES, UniAlertComponent, UniAppBarComponent, UniAvatarComponent, UniAvatarGroupComponent, UniBackgroundComponent, UniBadgeComponent, UniBaseDatasource, UniBoxDirective, UniBreadcrumbComponent, UniButtonComponent, UniButtonGroupComponent, UniCalendarComponent, UniCalloutComponent, UniCardComponent, UniCardContentComponent, UniCardHeaderComponent, UniCenterDirective, UniCheckboxComponent, UniComboboxComponent, UniDataSearchComponent, UniDataTableComponent, UniDateInputComponent, UniDateTimeInputComponent, UniDebounceInputComponent, UniDialogButtonsComponent, UniDialogComponent, UniDialogHeaderComponent, UniDividerComponent, UniDrawerComponent, UniDropdownComponent, UniExpandAreaComponent, UniExpandComponent, UniExpandToggleComponent, UniFileDropZoneComponent, UniGridAreaDirective, UniGridDirective, UniIconButtonComponent, UniIconComponent, UniInputBoxComponent, UniInputComponent, UniJsonViewComponent, UniMenuComponent, UniMultiSelectComponent, UniMultiSelectDropdownComponent, UniNotificationBadgeComponent, UniPaginatorComponent, UniPopoverComponent, UniProgressBarComponent, UniProgressGaugeComponent, UniRadioComponent, UniRecordDatasource, UniRowDirective, UniScrollAreaComponent, UniSearchInputComponent, UniSelectComponent, UniServerSideDatasource, UniSkeletonComponent, UniSliderComponent, UniSnackbarComponent, UniSortHeaderComponent, UniStackDirective, UniStatComponent, UniSymbolComponent, UniTabComponent, UniTabsComponent, UniTagComponent, UniTagInputComponent, UniTextDirective, UniTextareaComponent, UniThemeBuilderComponent, UniThemeSwitchComponent, UniTimeInputComponent, UniToggleComponent, UniTooltipComponent, UniTourComponent, UniWrapDirective, acceptableFile, addDays, addMonths, anchorArrowStyles, anchorStyles, buildMonthGrid, clearAnchorName, createAnnouncer, createListboxNavigation, dayOfWeek, daysInMonth, discreteOverlayTransition, focusableElements, formatDate, formatMonthHeading, formatTime, getFileExtension, inclusiveDayCount, isDivider, isToggleOpen, isValidDate, isoDate, joinDateTime, listboxPopupAttr, listboxPopupStyles, localeDatePlaceholder, localeDefaultHour12, localeFieldOrder, localeMonthNames, localeWeekStart, monthOf, motionSafe, newAnchorName, newListboxAnchor, parseDateText, parseTimeText, promoteListboxPopup, resolveElement, resolveFocusTarget, restoreOverlayFocus, setAnchorName, splitDateTime, spotlightStyles, supportsAnchoredPopup, timeSlots, todayIso, transformOriginFor, uniqueId, useTimer, visuallyHidden, weekdayNames };
-export type { Alert, AnchorOffset, AnchorRect, Announcer, BrandPaletteConfig, BreadcrumbItem, ButtonGroupConfig, ButtonGroupItem, ColumnDefinition, Confirmation, DataLoader, DrawerMode, DrawerPosition, ImagePosition, ListboxNavigationConfig, MenuDivider, MenuItem, MenuItemWithLabel, MenuItemWithTemplate, Option, Options, PageRequest, PageResponse, Placement, ScrollbarAppearance, SkeletonShape, SkeletonSweepDirection, Snackbar, Sort, SortDirection, SpotlightOptions, SpotlightStyles, UniAppBarOptions, UniAvatarGroupOptions, UniAvatarOptions, UniBreadcrumbOptions, UniCalendarMarker, UniCalendarMode, UniCalendarOptions, UniCalendarValue, UniCalloutDismissal, UniCalloutOptions, UniCheckboxOptions, UniComboboxOptions, UniComboboxRejection, UniDataSearchOptions, UniDataTableOptions, UniDatasource, UniDate, UniDateInputOptions, UniDateInputRejection, UniDateRange, UniDateTime, UniDateTimeInputOptions, UniDrawerOptions, UniExpandOptions, UniInputBoxOptions, UniInputMode, UniInputType, UniListboxPopupOptions, UniMenuItemOptions, UniMenuOptions, UniMonthGridCell, UniMultiSelectDropdownOptions, UniNotificationBadgeOptions, UniPaginatorOptions, UniPopoverOptions, UniRadioOption, UniRadioOptions, UniSearchInputOptions, UniSkeletonOptions, UniSliderOptions, UniStatOptions, UniTabsOptions, UniTagInputOptions, UniTagItem, UniTagOptions, UniTagRejection, UniTagSuggestion, UniTagValue, UniTextareaOptions, UniTime, UniTimeInputOptions, UniTimeInputRejection, UniToggleOptions, UniTourAdvance, UniTourOptions, UniTourStep, UniWeekdayName };
+export { BodyRenderDirective, ConfirmationDialogComponent, DragAndDropDirective, FOCUSABLE_SELECTOR, ListboxNavigation, LocalStorageService, NotificationService, NotificationsComponent, RippleDirective, TRANSFORM_ORIGINS, ThemeService, UNI_FORMS, UNI_LAYOUT, UNI_THEMES, UniAlertComponent, UniAppBarComponent, UniAvatarComponent, UniAvatarGroupComponent, UniBackgroundComponent, UniBadgeComponent, UniBaseDatasource, UniBoxDirective, UniBreadcrumbComponent, UniButtonComponent, UniButtonGroupComponent, UniCalendarComponent, UniCalloutComponent, UniCardComponent, UniCardContentComponent, UniCardHeaderComponent, UniCenterDirective, UniCheckboxComponent, UniComboboxComponent, UniDataSearchComponent, UniDataTableComponent, UniDateInputComponent, UniDateTimeInputComponent, UniDebounceInputComponent, UniDialogButtonsComponent, UniDialogComponent, UniDialogHeaderComponent, UniDividerComponent, UniDrawerComponent, UniDropdownComponent, UniExpandAreaComponent, UniExpandComponent, UniExpandToggleComponent, UniFileDropZoneComponent, UniGridAreaDirective, UniGridDirective, UniIconButtonComponent, UniIconComponent, UniInputBoxComponent, UniInputComponent, UniJsonViewComponent, UniMenuComponent, UniMultiSelectComponent, UniMultiSelectDropdownComponent, UniNotificationBadgeComponent, UniNumberInputComponent, UniNumberRangeInputComponent, UniPaginatorComponent, UniPopoverComponent, UniProgressBarComponent, UniProgressGaugeComponent, UniQuantityStepperComponent, UniRadioComponent, UniRecordDatasource, UniRowDirective, UniScrollAreaComponent, UniSearchInputComponent, UniSelectComponent, UniServerSideDatasource, UniSkeletonComponent, UniSliderComponent, UniSnackbarComponent, UniSortHeaderComponent, UniStackDirective, UniStatComponent, UniSymbolComponent, UniTabComponent, UniTabsComponent, UniTagComponent, UniTagInputComponent, UniTextDirective, UniTextareaComponent, UniThemeBuilderComponent, UniThemeSwitchComponent, UniTimeInputComponent, UniToggleComponent, UniTooltipComponent, UniTourComponent, UniWrapDirective, acceptableFile, addDays, addMonths, anchorArrowStyles, anchorStyles, buildMonthGrid, clampDecimal, clearAnchorName, compareDecimal, createAnnouncer, createListboxNavigation, createPressRepeat, dayOfWeek, daysInMonth, decimalScale, discreteOverlayTransition, evaluateExpression, focusableElements, formatDate, formatMonthHeading, formatNumber, formatTime, fromScaled, getFileExtension, inclusiveDayCount, isCanonicalDecimal, isDivider, isToggleOpen, isValidDate, isoDate, joinDateTime, listboxPopupAttr, listboxPopupStyles, localeDatePlaceholder, localeDefaultHour12, localeFieldOrder, localeMonthNames, localeNumberParts, localeWeekStart, losesPrecision, monthOf, motionSafe, newAnchorName, newListboxAnchor, normalizeDecimal, parseDateText, parseNumber, parseTimeText, promoteListboxPopup, rawNumberText, resolveElement, resolveFocusTarget, resolveNumberFormat, restoreOverlayFocus, roundDecimal, setAnchorName, settleNumber, shiftDecimal, speakNumber, splitDateTime, spotlightStyles, stepDecimal, supportsAnchoredPopup, timeSlots, toAsciiDigits, toDecimal, toNumber, toScaled, todayIso, transformOriginFor, uniqueId, useTimer, visuallyHidden, weekdayNames };
+export type { Alert, AnchorOffset, AnchorRect, Announcer, BrandPaletteConfig, BreadcrumbItem, ButtonGroupConfig, ButtonGroupItem, ColumnDefinition, Confirmation, DataLoader, DrawerMode, DrawerPosition, ImagePosition, ListboxNavigationConfig, MenuDivider, MenuItem, MenuItemWithLabel, MenuItemWithTemplate, Option, Options, PageRequest, PageResponse, Placement, PressRepeat, PressRepeatConfig, PressRepeatTiming, ScrollbarAppearance, SkeletonShape, SkeletonSweepDirection, Snackbar, Sort, SortDirection, SpotlightOptions, SpotlightStyles, UniAppBarOptions, UniAvatarGroupOptions, UniAvatarOptions, UniBreadcrumbOptions, UniCalendarMarker, UniCalendarMode, UniCalendarOptions, UniCalendarValue, UniCalloutDismissal, UniCalloutOptions, UniCheckboxOptions, UniComboboxOptions, UniComboboxRejection, UniDataSearchOptions, UniDataTableOptions, UniDatasource, UniDate, UniDateInputOptions, UniDateInputRejection, UniDateRange, UniDateTime, UniDateTimeInputOptions, UniDrawerOptions, UniExpandOptions, UniInputBoxOptions, UniInputMode, UniInputType, UniListboxPopupOptions, UniLocaleNumberParts, UniMenuItemOptions, UniMenuOptions, UniMonthGridCell, UniMultiSelectDropdownOptions, UniNotificationBadgeOptions, UniNumberClamp, UniNumberFormatConfig, UniNumberGrouping, UniNumberInputOptions, UniNumberParseResult, UniNumberPreset, UniNumberRange, UniNumberRangeInputOptions, UniNumberRangePart, UniNumberRangeRejection, UniNumberRejectReason, UniNumberRejection, UniNumberStepConfig, UniNumberStepped, UniPaginatorOptions, UniPopoverOptions, UniQuantityStepperOptions, UniRadioOption, UniRadioOptions, UniResolvedNumberFormat, UniRoundingMode, UniSearchInputOptions, UniSkeletonOptions, UniSliderMark, UniSliderOptions, UniSliderThumb, UniStatOptions, UniStepperLayout, UniTabsOptions, UniTagInputOptions, UniTagItem, UniTagOptions, UniTagRejection, UniTagSuggestion, UniTagValue, UniTextareaOptions, UniTime, UniTimeInputOptions, UniTimeInputRejection, UniToggleOptions, UniTourAdvance, UniTourOptions, UniTourStep, UniWeekdayName };