@uni-design-system/uni-angular 9.0.1 → 10.1.0

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

@@ -25,9 +25,23 @@ declare function resolveFocusTarget(element: HTMLElement): HTMLElement;
 /**
  * Visually hides content while keeping it available to screen readers.
  * Use for text alternatives (e.g. badge counts, icon-only affordances).
+ *
+ * `fixed`, not `absolute`, and that is load-bearing. An absolutely positioned
+ * box resolves its containing block to the nearest *positioned* ancestor —
+ * which, since the controls emitting these spans are `position: static`, is
+ * whatever positioned box happens to be above them in the consumer's layout,
+ * often several scroll containers up. The span then skips every intervening
+ * `overflow: auto` and lands in that distant ancestor's scrollable overflow,
+ * turning 1x1 of invisible text into real scrollable distance in a box that
+ * never opted into scrolling. A fixed box's containing block is the viewport,
+ * so it joins no ancestor's scrollable overflow at all.
+ *
+ * Caveat: inside a `transform`ed (or `filter`ed/`contain`ed) ancestor a fixed
+ * box re-anchors to that ancestor. Harmless here — the element is 1x1 and
+ * clipped to nothing, so where it lands never matters, only what it overflows.
  */
 declare const visuallyHidden: {
-    readonly position: "absolute";
+    readonly position: "fixed";
     readonly width: 1;
     readonly height: 1;
     readonly padding: 0;
@@ -187,6 +201,391 @@ 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;
+    /**
+     * Put focus where it belongs for this control — normally its text field, the
+     * way a native spinner does. Called on press, because taking pointer capture
+     * means preventing the default, which would otherwise leave focus nowhere.
+     *
+     * Receives the pressed button, as a fallback for controls with no field to
+     * focus.
+     */
+    focus?: (button: HTMLElement | null) => void;
+    /**
+     * 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;
@@ -806,7 +1205,7 @@ declare class UniCheckboxComponent extends BaseComponent<UniCheckboxOptions> imp
     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. */
+    /** Synced from required() validators by the Signal Forms [formField] directive. */
     readonly required: _angular_core.InputSignal<boolean>;
     /**
      * Id(s) of external element(s) describing this control — typically your
@@ -1066,7 +1465,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 +1559,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 +1629,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>;
 }
 
 /**
@@ -1258,7 +1671,7 @@ declare class UniInputComponent implements FormValueControl<string> {
     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. */
+    /** Synced from required() validators by the Signal Forms [formField] directive. */
     readonly required: _angular_core.InputSignal<boolean>;
     /**
      * Id(s) of external element(s) describing this control — typically your
@@ -1481,7 +1894,7 @@ declare class UniMultiSelectDropdownComponent<T = unknown> extends BaseComponent
     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. */
+    /** Synced from required() validators by the Signal Forms [formField] directive. */
     readonly required: _angular_core.InputSignal<boolean>;
     /**
      * Id(s) of external element(s) describing this control — typically your
@@ -1596,7 +2009,7 @@ declare class UniRadioComponent extends BaseComponent<UniRadioOptions> implement
     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. */
+    /** Synced from required() validators by the Signal Forms [formField] directive. */
     readonly required: _angular_core.InputSignal<boolean>;
     /**
      * Id(s) of external element(s) describing this control — typically your
@@ -1734,7 +2147,7 @@ declare class UniSelectComponent<T> implements FormValueControl<T | null> {
     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. */
+    /** Synced from required() validators by the Signal Forms [formField] directive. */
     readonly required: _angular_core.InputSignal<boolean>;
     /**
      * Id(s) of external element(s) describing this control — typically your
@@ -1770,51 +2183,833 @@ 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`.
+ *
+ * It is not a field — no label, no error border, no `uni-input-box` — but it
+ * sits beside fields in carts and table rows, so its container **defaults to
+ * the shared `input` chrome**: colour, border, radius and the focus indicator
+ * all follow whatever a theme does to its fields. The options below are
+ * per-component overrides, for parting them deliberately.
+ *
+ * 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 {
+    /** Container fill. Unset — the default — takes `input`'s. */
+    color?: ContainerColorToken;
+    /** Frame, and the rules either side of the value. Unset takes `input`'s. */
+    border?: Border;
+    /** Corner radius. Unset takes `input`'s. */
+    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;
+    /**
+     * Floor for the value cell, e.g. `'3ch'` — headroom so stepping 9 → 10 does
+     * not reflow the row. Beyond it the cell grows with the digits, because the
+     * input is sized from its content rather than the browser's 20-character
+     * default.
+     */
+    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;
+    /**
+     * Focus the field a stepper press should land in. With `editable=false` there
+     * is no field and the buttons are the tab stops, so the pressed button takes
+     * it instead.
+     */
+    protected focusField(fallback?: HTMLElement | null): 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>;
+    /**
+     * Container chrome, defaulting to the shared `input` entry rather than to
+     * hardcoded tokens. It is not a field, but it sits beside them in carts and
+     * table rows, so a theme that restyles `input` must carry it along — the
+     * options below stay as per-component overrides for a deliberately different
+     * look.
+     */
+    private readonly containerColor;
+    private readonly containerBorder;
+    private readonly containerRadius;
+    /** The rules either side of the value, matching the frame around it. */
+    private readonly dividerBorder;
+    /**
+     * Characters the value cell asks the browser to size itself for.
+     *
+     * Load-bearing: a bare `<input>` defaults to `size="20"`, and `flex-basis:
+     * auto` resolves to that intrinsic width — so the control claimed ~230px
+     * instead of the ~100px its buttons and `valueWidth` need, and stole track
+     * width from anything beside it in a grid (`1fr` is `minmax(auto, 1fr)`, and
+     * the `auto` floor includes this). Tracking the content keeps the cell honest
+     * while still letting it grow with the digits, which a fixed `width` would
+     * not. `valueWidth` remains the floor, via `min-width`.
+     */
+    protected readonly valueSize: _angular_core.Signal<number>;
+    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 +3146,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>;
@@ -1997,7 +3199,7 @@ declare class UniTextareaComponent implements FormValueControl<string> {
     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. */
+    /** Synced from required() validators by the Signal Forms [formField] directive. */
     readonly required: _angular_core.InputSignal<boolean>;
     /**
      * Id(s) of external element(s) describing this control — typically your
@@ -2138,13 +3340,26 @@ declare class UniTimeInputComponent extends BaseComponent<UniTimeInputOptions> i
 
 interface UniToggleOptions {
     /**
-     * The size of the toggle switch
+     * @deprecated Track height in px, from before the toggle had a `sizes` block.
+     * Still honoured — and still wins when set, since a theme carrying it opted
+     * into the old derived-ratio geometry (width = 2x, knob = 0.8x) — but it
+     * applies to every instance regardless of the `size` input. Prefer the
+     * theme's `toggle.sizes` block, which gives each size token its own
+     * `width` / `height` / `padding`.
      */
     size?: number;
     /** Off-state track color token. */
     trackColor?: ColorKey;
     /** Knob color token. */
     knobColor?: ColorKey;
+    /**
+     * Checked-state track color token. Falls back to the instance's `variant`,
+     * which is where this color lived before it had a theme home. The matching
+     * `checkedColor` input overrides it per instance.
+     */
+    checkedColor?: ColorKey;
+    /** Motion token for the knob slide and track color change. */
+    motion?: Motion;
 }
 
 declare class UniToggleComponent extends BaseComponent<UniToggleOptions> implements FormCheckboxControl {
@@ -2153,7 +3368,7 @@ declare class UniToggleComponent extends BaseComponent<UniToggleOptions> impleme
     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. */
+    /** Synced from required() validators by the Signal Forms [formField] directive. */
     readonly required: _angular_core.InputSignal<boolean>;
     /**
      * Id(s) of external element(s) describing this control — typically your
@@ -2161,15 +3376,37 @@ declare class UniToggleComponent extends BaseComponent<UniToggleOptions> impleme
      */
     readonly ariaDescribedBy: _angular_core.InputSignal<string>;
     readonly label: _angular_core.InputSignal<string>;
+    /**
+     * Checked-state track color token, overriding the theme's
+     * `toggle.behavior.checkedColor`.
+     *
+     * This exists alongside the theme option because `variant` — where this color
+     * used to live exclusively — defaults to `'primary'`, so the component cannot
+     * tell "set to primary" from "not set". Without an input, a theme-level
+     * `checkedColor` would silently make per-instance `variant` inert.
+     */
+    readonly checkedColor: _angular_core.InputSignal<string>;
     protected readonly showError: _angular_core.Signal<boolean>;
     markAsTouched(): void;
     handleChange(event: Event): void;
+    /**
+     * Track and knob geometry for the active `size`, read out of the theme's
+     * `sizes` block as data — `width`, `height` and the knob's inset `padding`.
+     *
+     * Read rather than spread: `padding` must not reach the track as real CSS or
+     * it would double up with the knob's own `top`/`left` offsets. `uni-calendar`
+     * treats its size block the same way.
+     */
     private readonly metrics;
+    /** The resolved checked/accent color: input, then theme option, then variant. */
+    private readonly accent;
+    /** Knob slide and track color change, as a motion token — never `all`. */
+    private readonly transitions;
     protected readonly toggleLabel: _angular_core.Signal<string>;
     protected readonly toggleInput: _angular_core.Signal<string>;
     getThemeColor(token: ColorToken): string;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<UniToggleComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniToggleComponent, "uni-toggle", never, { "checked": { "alias": "checked"; "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": false; "isSignal": true; }; }, { "checked": "checkedChange"; "touched": "touchedChange"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniToggleComponent, "uni-toggle", never, { "checked": { "alias": "checked"; "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": false; "isSignal": true; }; "checkedColor": { "alias": "checkedColor"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; "touched": "touchedChange"; }, never, never, true, never>;
 }
 
 /**
@@ -2182,7 +3419,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 +3685,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. */
@@ -2934,10 +4171,147 @@ declare class UniDividerComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniDividerComponent, "uni-divider", never, { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "border": { "alias": "border"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
+/**
+ * Theme-level options for the drawer's pinned footer action row. Inputs on the
+ * component override these per instance; the theme sets the default posture.
+ *
+ * Mirrors `UniDialogButtonsOptions` knob for knob, with a panel's posture
+ * rather than a dialog's: trailing actions instead of centered ones, and a
+ * divider against the scrolling body above.
+ */
+interface UniDrawerButtonsOptions {
+    /** Space between the action buttons, as a spacing token. */
+    gap?: NullableSize;
+    /** Padding around the row, as a spacing token. */
+    padding?: NullableSize;
+    justifyContent?: JustifyContent;
+    confirmButtonVariant?: Variant;
+    cancelButtonVariant?: Variant;
+    /** Size passed to both buttons. */
+    buttonSize?: Size;
+    /** Rule separating the footer from the scrolling body, as a border primitive. */
+    divider?: Border;
+    /** When true the two actions share the full row width as equal halves. */
+    stretch?: boolean;
+    /** Render cancel before confirm (confirm ends up on the trailing edge). */
+    reverseOrder?: boolean;
+}
+
+/**
+ * The drawer's pinned footer action row — the save bar of an editor panel.
+ *
+ * Sits outside the scrolling body, so the actions stay reachable however long
+ * the form is. Mirrors `[dialog-buttons]`; the difference is posture, which
+ * lives in the `drawerButtons` theme options rather than here.
+ */
+declare class UniDrawerButtonsComponent extends BaseComponent<UniDrawerButtonsOptions> {
+    private readonly drawer;
+    confirmButtonText: _angular_core.InputSignal<string>;
+    confirmButtonVariant: _angular_core.InputSignal<Variant>;
+    cancelButtonText: _angular_core.InputSignal<string>;
+    cancelButtonVariant: _angular_core.InputSignal<Variant>;
+    disableConfirm: _angular_core.InputSignal<boolean>;
+    padding: _angular_core.InputSignal<NullableSize>;
+    justifyContent: _angular_core.InputSignal<JustifyContent>;
+    confirmed: _angular_core.OutputEmitterRef<void>;
+    protected confirmVariant: _angular_core.Signal<Variant>;
+    protected cancelVariant: _angular_core.Signal<Variant>;
+    protected paddingValue: _angular_core.Signal<NullableSize>;
+    protected justifyContentValue: _angular_core.Signal<JustifyContent>;
+    protected gapValue: _angular_core.Signal<NullableSize>;
+    protected buttonSize: _angular_core.Signal<Size>;
+    /** A pinned row, sized by its content rather than by the body beside it. */
+    protected readonly hostClass: _angular_core.Signal<string>;
+    protected readonly className: _angular_core.Signal<string>;
+    /**
+     * Cancel routes through the drawer's own close decision, so a panel with
+     * unsaved changes can veto it exactly as it vetoes Escape.
+     */
+    protected closeDrawer(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UniDrawerButtonsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniDrawerButtonsComponent, "[uni-drawer-buttons], [drawer-buttons]", never, { "confirmButtonText": { "alias": "confirmButtonText"; "required": false; "isSignal": true; }; "confirmButtonVariant": { "alias": "confirmButtonVariant"; "required": false; "isSignal": true; }; "cancelButtonText": { "alias": "cancelButtonText"; "required": false; "isSignal": true; }; "cancelButtonVariant": { "alias": "cancelButtonVariant"; "required": false; "isSignal": true; }; "disableConfirm": { "alias": "disableConfirm"; "required": false; "isSignal": true; }; "padding": { "alias": "padding"; "required": false; "isSignal": true; }; "justifyContent": { "alias": "justifyContent"; "required": false; "isSignal": true; }; }, { "confirmed": "confirmed"; }, never, never, true, never>;
+}
+
+/**
+ * Theme-level options for the drawer's pinned header row. Deliberately a
+ * separate entry from `dialogHeader`: the two rows look alike but read
+ * differently — a panel headline labels a region beside the page, where a
+ * dialog's titles an interruption — so they want different defaults.
+ */
+interface UniDrawerHeaderOptions {
+    /** Row surface. Undefined inherits the drawer's own surface. */
+    color?: ContainerColorToken;
+    /** Fixed row height in px. */
+    height?: number;
+    /** Padding around the row, as a spacing token. */
+    padding?: NullableSize;
+    textRole?: TextRole;
+    textColor?: ContentColorToken;
+    textAlign?: 'left' | 'center' | 'right';
+    /** Rule separating the header from the scrolling body, as a border primitive. */
+    divider?: Border;
+    closeButtonIcon?: IconName;
+    closeButtonSymbol?: string;
+    closeButtonSize?: Size;
+}
+
+/**
+ * The drawer's pinned header row: a title, and optionally a close button.
+ *
+ * Sits outside the scrolling body, so it stays put while the form beneath it
+ * moves. Reached either by projecting it — `<div uni-drawer-header>` — or
+ * implicitly, by giving `uni-drawer` a `headline`, in which case the drawer
+ * renders one of these itself.
+ */
+declare class UniDrawerHeaderComponent extends BaseComponent<UniDrawerHeaderOptions> {
+    private readonly drawer;
+    /** Title text. Falls back to the drawer's `headline`; projected content wins over both. */
+    headline: _angular_core.InputSignal<string>;
+    /** Attached to the title so the drawer is labelled by it. */
+    protected readonly titleId: string;
+    protected readonly title: _angular_core.Signal<string>;
+    protected readonly showClose: _angular_core.Signal<boolean>;
+    constructor();
+    /** Never a bare close: the drawer decides, so a veto is honoured here too. */
+    protected closeDrawer(): void;
+    protected readonly className: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UniDrawerHeaderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniDrawerHeaderComponent, "[uni-drawer-header]", never, { "headline": { "alias": "headline"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
 /** How the drawer coexists with page content. */
 type DrawerMode = 'side' | 'over';
 /** Which edge the drawer attaches to (logical: start = left in LTR). */
 type DrawerPosition = 'start' | 'end';
+/** Surface treatment of the panel behind its content. */
+type DrawerBackground = 'solid' | 'glass' | 'gradient';
+/** Why the drawer is asking to close. */
+type DrawerCloseReason = 'close-button' | 'escape' | 'backdrop';
+/**
+ * Emitted by `closeRequest` before the drawer closes. The drawer is *asking*;
+ * with `disableAutoClose` set it will not act on its own, leaving the consumer
+ * free to run an async confirmation and set `open` when it resolves.
+ */
+interface UniDrawerCloseRequest {
+    reason: DrawerCloseReason;
+}
+/**
+ * The slice of the drawer its header and footer rows need.
+ *
+ * A token rather than the component class on purpose: the drawer renders a
+ * `[uni-drawer-header]` itself when given a `headline`, so importing the
+ * component class in both directions would be a cycle.
+ */
+interface UniDrawerPanel {
+    readonly headline: Signal<string | undefined>;
+    readonly defaultCloseButton: Signal<boolean>;
+    readonly titleId: string;
+    readonly hasHeader: {
+        set(value: boolean): void;
+    };
+    requestClose(reason: DrawerCloseReason): void;
+}
+declare const DRAWER_PANEL: InjectionToken<UniDrawerPanel>;
 /** Theme-level options for `uni-drawer`, resolved by token name. */
 interface UniDrawerOptions {
     /** Panel surface color token (with its paired on-color). */
@@ -2946,16 +4320,27 @@ interface UniDrawerOptions {
     width?: number;
     /** Edge rule separating a side drawer from content, as a border primitive. */
     divider?: Border;
-    /** Elevation shadow token for the overlay mode. */
+    /** Elevation shadow token. Overlay mode only — see `background`. */
     elevation?: Elevation;
-    /** Inner padding, as a spacing token. */
+    /**
+     * Inner padding of the *body* row, as a spacing token. The panel itself is
+     * unpadded so that header and footer rows can pin flush to its edges.
+     */
     padding?: OptionalSize;
-    /** Backdrop styling for the overlay mode. */
+    /** Backdrop styling for the overlay mode. Ignored when `scrim` is false. */
     backdrop?: StyleExpression;
+    /**
+     * Whether the overlay mode dims the page behind it. False leaves
+     * `::backdrop` transparent — the drawer still traps focus and is still
+     * modal, it simply does not darken what it covers.
+     */
+    scrim?: boolean;
+    /** Surface treatment of the panel. */
+    background?: DrawerBackground;
 }
 
 /**
- * Navigation drawer with two modes sharing one content slot:
+ * Drawer with two modes sharing one three-row layout:
  *
  * - `side` — an in-flow `<aside>` that pushes content (dashboard sidenav);
  *   opening/closing animates its width, and the divider border primitive
@@ -2964,19 +4349,86 @@ interface UniDrawerOptions {
  *   scrim backdrop come from the platform (same machinery as `uni-dialog`),
  *   sliding in from its edge.
  *
- * Surface, width, divider, elevation, padding and backdrop all resolve from
- * `drawer` theme tokens.
+ * **The panel is never the scroll container.** It is a flex column of three
+ * rows — an optional `[uni-drawer-header]`, the projected body, an optional
+ * `[uni-drawer-buttons]` — and only the body scrolls. The panel itself is
+ * `overflow: clip` on both axes. That is what lets a header and a save bar pin
+ * while a long form scrolls between them, and it is why the theme's `padding`
+ * option lands on the body row rather than the panel: padding on a scrolling
+ * box scrolls away with its content.
+ *
+ * Surface, width, divider, elevation, padding, backdrop, scrim and background
+ * all resolve from `drawer` theme tokens.
  */
 declare class UniDrawerComponent extends BaseComponent<UniDrawerOptions> {
     /** Two-way bindable open state: [(open)]. */
     readonly open: _angular_core.ModelSignal<boolean>;
     mode: _angular_core.InputSignal<DrawerMode>;
     position: _angular_core.InputSignal<DrawerPosition>;
-    /** Accessible name for the overlay mode's dialog. */
+    /**
+     * Accessible name for the overlay mode. Only consulted when the drawer has
+     * no header to be labelled by.
+     *
+     * There is deliberately no default. A drawer used as an editor panel that
+     * inherited the literal "Navigation" would announce itself as something it
+     * is not, and a wrong accessible name is worse than a missing one — the
+     * missing one is at least caught by any audit.
+     */
     ariaLabel: _angular_core.InputSignal<string>;
-    protected readonly contentTemplate: _angular_core.Signal<TemplateRef<unknown>>;
+    /**
+     * Title for the drawer's header row. Shorthand for projecting a
+     * `[uni-drawer-header]`; project one instead when the header needs more
+     * than a title (a record counter, prev/next navigation).
+     */
+    headline: _angular_core.InputSignal<string>;
+    /** Whether the header row renders a close button. */
+    defaultCloseButton: _angular_core.InputSignal<boolean>;
+    /** Panel width in px, overriding the theme's `drawer.behavior.width`. */
+    width: _angular_core.InputSignal<number>;
+    /**
+     * Whether the overlay dims the page behind it, overriding the theme's
+     * `drawer.behavior.scrim`. False leaves the backdrop transparent so the page
+     * stays legible while the panel is open — an editor panel beside a board the
+     * user is still reading.
+     *
+     * This does not make the drawer non-modal: focus is still trapped and the
+     * page behind is still inert. It is a visibility choice, not a modality one.
+     */
+    scrim: _angular_core.InputSignal<boolean>;
+    /**
+     * CSS selector for the element to focus when the overlay opens. The native
+     * default is the first focusable element, which in an editor panel is
+     * usually the close button rather than the first field.
+     */
+    initialFocus: _angular_core.InputSignal<string>;
+    /**
+     * The drawer is *asking* to close — Escape, the backdrop, or a close/cancel
+     * button. Pair with `disableAutoClose` to hold the panel open while an async
+     * confirmation runs.
+     */
+    closeRequest: _angular_core.OutputEmitterRef<UniDrawerCloseRequest>;
+    /**
+     * When true the drawer never closes itself; it only emits `closeRequest` and
+     * waits for the consumer to set `open`. Off by default, so a drawer that
+     * ignores `closeRequest` behaves exactly as it always has.
+     */
+    disableAutoClose: _angular_core.InputSignal<boolean>;
+    /** Set by a projected `[uni-drawer-header]` so it can pin flush to the top. */
+    readonly hasHeader: _angular_core.WritableSignal<boolean>;
+    /** Id referenced by aria-labelledby; the header row attaches it to its title. */
+    readonly titleId: string;
+    protected readonly labelledBy: _angular_core.Signal<string>;
+    protected readonly headerTemplate: _angular_core.Signal<TemplateRef<unknown>>;
+    protected readonly bodyTemplate: _angular_core.Signal<TemplateRef<unknown>>;
+    protected readonly footerTemplate: _angular_core.Signal<TemplateRef<unknown>>;
     private readonly overlay;
     constructor();
+    /**
+     * The one place a close is decided, so every route in — Escape, the
+     * backdrop, the header's close button, the footer's cancel — behaves
+     * identically and is equally vetoable.
+     */
+    requestClose(reason: DrawerCloseReason): void;
     protected onBackdropClick(event: Event): void;
     /** Route Escape through the animated close, keeping `open` in sync. */
     protected onCancel(event: Event): void;
@@ -2984,10 +4436,23 @@ declare class UniDrawerComponent extends BaseComponent<UniDrawerOptions> {
     private readonly edge;
     private readonly slideIn;
     private readonly slideOut;
+    /** Input wins over the theme option; the literal is the last-resort default. */
+    private readonly panelWidth;
+    private readonly showScrim;
+    /**
+     * The panel's surface. `solid` is the plain color pair; `glass` and
+     * `gradient` derive from it, so a theme swaps treatment without restating
+     * the color.
+     */
+    private readonly surface;
+    /** The shared flex column: three rows, and never a scroll container itself. */
+    private readonly shell;
     protected readonly sideClass: _angular_core.Signal<string>;
     protected readonly overClass: _angular_core.Signal<string>;
+    /** The only scrolling row, and the only padded one. */
+    protected readonly bodyClass: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<UniDrawerComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniDrawerComponent, "uni-drawer", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "open": "openChange"; }, never, ["*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UniDrawerComponent, "uni-drawer", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "headline": { "alias": "headline"; "required": false; "isSignal": true; }; "defaultCloseButton": { "alias": "defaultCloseButton"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "scrim": { "alias": "scrim"; "required": false; "isSignal": true; }; "initialFocus": { "alias": "initialFocus"; "required": false; "isSignal": true; }; "disableAutoClose": { "alias": "disableAutoClose"; "required": false; "isSignal": true; }; }, { "open": "openChange"; "closeRequest": "closeRequest"; }, never, ["[uni-drawer-header]", "[uni-drawer-buttons], [drawer-buttons]", "*"], true, never>;
 }
 
 interface UniDropdownOptions {
@@ -4456,5 +5921,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, DRAWER_PANEL, 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, UniDrawerButtonsComponent, UniDrawerComponent, UniDrawerHeaderComponent, 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, DrawerBackground, DrawerCloseReason, 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, UniDrawerButtonsOptions, UniDrawerCloseRequest, UniDrawerHeaderOptions, UniDrawerOptions, UniDrawerPanel, 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 };