@radix-ng/primitives 0.50.0 → 1.0.0-beta.0

package/types/radix-ng-primitives-number-field.d.ts

@@ -0,0 +1,464 @@
+import * as _angular_core from '@angular/core';
+import { Signal } from '@angular/core';
+import * as i1 from '@radix-ng/primitives/core';
+import { RdxFormValueControl, RdxControlValueAccessor, NumberInput, BooleanInput } from '@radix-ng/primitives/core';
+import * as _radix_ng_primitives_number_field from '@radix-ng/primitives/number-field';
+import { NumberFormatter, NumberParser } from '@internationalized/number';
+import * as i1$1 from '@radix-ng/primitives/portal';
+
+/**
+ * The software keyboard hint shown on touch devices, mapped to the input's `inputmode` attribute.
+ */
+type InputMode = 'numeric' | 'decimal' | 'text';
+/**
+ * Direction of a step-based value change (`1` to increase, `-1` to decrease).
+ */
+type Direction = 1 | -1;
+/**
+ * Why a value change happened. Mirrors Base UI's change reasons and is used
+ * internally to decide whether a change should be clamped (step interactions
+ * always clamp; direct text entry may go out of range when `allowOutOfRange`).
+ *
+ * @see https://base-ui.com/react/components/number-field
+ */
+type NumberFieldChangeReason = 'input-change' | 'input-clear' | 'input-blur' | 'input-paste' | 'keyboard' | 'increment-press' | 'decrement-press' | 'wheel' | 'scrub' | 'none';
+declare const REASONS: {
+    readonly inputChange: "input-change";
+    readonly inputClear: "input-clear";
+    readonly inputBlur: "input-blur";
+    readonly inputPaste: "input-paste";
+    readonly keyboard: "keyboard";
+    readonly incrementPress: "increment-press";
+    readonly decrementPress: "decrement-press";
+    readonly wheel: "wheel";
+    readonly scrub: "scrub";
+    readonly none: "none";
+};
+
+/**
+ * Groups all parts of the number field and manages its state, parsing/formatting
+ * and value-change logic. A single directive drives the whole family — parts read
+ * signals and call methods off it through the root context.
+ *
+ * @see https://base-ui.com/react/components/number-field
+ */
+declare class RdxNumberFieldRoot implements RdxFormValueControl<number | null> {
+    /** @ignore */
+    protected readonly cva: RdxControlValueAccessor<number | null>;
+    /** The id of the input element. */
+    readonly id: _angular_core.InputSignal<string>;
+    /** The minimum value of the field. */
+    readonly min: _angular_core.InputSignalWithTransform<number | undefined, NumberInput>;
+    /** The maximum value of the field. */
+    readonly max: _angular_core.InputSignalWithTransform<number | undefined, NumberInput>;
+    /**
+     * Amount to increment and decrement with the buttons, arrow keys and scrub area.
+     * @default 1
+     */
+    readonly step: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    /**
+     * The step used when incrementing while the Alt key is held. Snaps to multiples of this value.
+     * @default 0.1
+     */
+    readonly smallStep: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    /**
+     * The step used when incrementing while the Shift key is held. Snaps to multiples of this value.
+     * @default 10
+     */
+    readonly largeStep: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    /**
+     * Whether the value should snap to the nearest step when incrementing or decrementing.
+     * @default false
+     */
+    readonly snapOnStep: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * When `true`, direct text entry may go outside the `min`/`max` range without clamping.
+     * Step interactions (arrow keys, buttons, wheel, scrub) still clamp.
+     * @default false
+     */
+    readonly allowOutOfRange: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Whether the value can be changed with the mouse wheel while the input is focused.
+     * @default false
+     */
+    readonly allowWheelScrub: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Options used to format the input value (forwarded to `Intl.NumberFormat`). */
+    readonly format: _angular_core.InputSignal<Intl.NumberFormatOptions | undefined>;
+    /** The locale used to parse and format the value. */
+    readonly locale: _angular_core.InputSignal<string>;
+    /**
+     * When `true`, the user cannot interact with the field.
+     * @default false
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * When `true`, the field is focusable but its value cannot be changed.
+     * @default false
+     */
+    readonly readonly: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * When `true`, the user must enter a value before the owning form can be submitted.
+     * @default false
+     */
+    readonly required: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Name of the hidden input rendered by `[rdxNumberFieldHiddenInput]`, for form submission. */
+    readonly name: _angular_core.InputSignal<string | undefined>;
+    /** Id of the form the hidden input belongs to. Useful when it is rendered outside the form. */
+    readonly form: _angular_core.InputSignal<string | undefined>;
+    /** The uncontrolled value of the field when it is initially rendered. */
+    readonly defaultValue: _angular_core.InputSignal<number | undefined>;
+    /** The controlled value of the field. Use with `(onValueChange)` or two-way `[(value)]`. */
+    readonly value: _angular_core.ModelSignal<number | null>;
+    /** Emitted when the value changes (during interaction or programmatically). */
+    readonly onValueChange: _angular_core.OutputEmitterRef<number | null>;
+    /**
+     * Emitted when the value is committed: on blur after typing, or when a pointer is released
+     * after scrubbing or pressing a button. Fires together with `onValueChange` for keyboard input.
+     */
+    readonly onValueCommitted: _angular_core.OutputEmitterRef<number | null>;
+    /** @ignore The formatted text shown in the input element. */
+    readonly inputValue: _angular_core.WritableSignal<string>;
+    /** @ignore Whether a scrub gesture is in progress. */
+    readonly isScrubbing: _angular_core.WritableSignal<boolean>;
+    /** @ignore The native input element, registered by `[rdxNumberFieldInput]`. */
+    readonly inputEl: _angular_core.WritableSignal<HTMLInputElement | undefined>;
+    /**
+     * @ignore Gate that prevents the formatted value from overwriting in-progress typing.
+     * Plain field (not a signal): it is toggled imperatively inside event handlers.
+     */
+    allowInputSync: boolean;
+    /** @ignore Last value produced by `setValue`, used to report the committed value. */
+    lastChangedValue: number | null;
+    /** @ignore Whether a programmatic change is awaiting a commit. */
+    hasPendingCommit: boolean;
+    /** @ignore */
+    readonly isDisabled: _angular_core.Signal<boolean>;
+    private readonly formatter;
+    private readonly parser;
+    /** @ignore The current numeric value (`null` when empty). */
+    readonly currentValue: _angular_core.Signal<number | null>;
+    /** @ignore */
+    readonly minWithDefault: _angular_core.Signal<number>;
+    /** @ignore */
+    readonly maxWithDefault: _angular_core.Signal<number>;
+    /** @ignore */
+    readonly minWithZeroDefault: _angular_core.Signal<number>;
+    /** @ignore Whether incrementing further is a no-op (value already at max). */
+    readonly isIncrementDisabled: _angular_core.Signal<boolean>;
+    /** @ignore Whether decrementing further is a no-op (value already at min). */
+    readonly isDecrementDisabled: _angular_core.Signal<boolean>;
+    /** @ignore Software-keyboard hint based on whether the format allows fractional digits. */
+    readonly inputMode: _angular_core.Signal<InputMode>;
+    constructor();
+    /** @ignore Formats a numeric value to its display string (empty for `null`/`NaN`). */
+    formatNumber(value: number | null): string;
+    /** @ignore Parses a display string to a number, returning `null` when not parseable. */
+    parseNumber(text: string): number | null;
+    /** @ignore Whether `text` is a valid partial number for the current locale and bounds. */
+    isValidPartial(text: string): boolean;
+    /** @ignore The step magnitude for an interaction, honouring Alt (small) and Shift (large). */
+    getStepAmount(event?: {
+        altKey?: boolean;
+        shiftKey?: boolean;
+    }): number;
+    /** @ignore Registers the native input element. */
+    registerInput(el: HTMLInputElement): void;
+    /** @ignore Sets the displayed text without changing the numeric value. */
+    setInputValue(text: string): void;
+    /** @ignore */
+    markAsTouched(): void;
+    /**
+     * @ignore
+     * Validates and applies a candidate value, emitting `onValueChange` when it changes.
+     * Returns whether a change was fired.
+     */
+    setValue(unvalidatedValue: number | null, reason: NumberFieldChangeReason, event?: Event, direction?: Direction): boolean;
+    /**
+     * @ignore
+     * Increments (or decrements) the value by `amount * direction`, starting from `currentValue`
+     * when supplied (the live, possibly-dirty input value) or the committed value otherwise.
+     */
+    incrementValue(amount: number, params: {
+        direction: Direction;
+        currentValue?: number | null;
+        event?: Event;
+        reason: NumberFieldChangeReason;
+    }): boolean;
+    /** @ignore Emits the committed value at the end of an interaction. */
+    commitValue(value: number | null): void;
+    private applyValue;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxNumberFieldRoot, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxNumberFieldRoot, "div[rdxNumberFieldRoot]", ["rdxNumberFieldRoot"], { "id": { "alias": "id"; "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; }; "smallStep": { "alias": "smallStep"; "required": false; "isSignal": true; }; "largeStep": { "alias": "largeStep"; "required": false; "isSignal": true; }; "snapOnStep": { "alias": "snapOnStep"; "required": false; "isSignal": true; }; "allowOutOfRange": { "alias": "allowOutOfRange"; "required": false; "isSignal": true; }; "allowWheelScrub": { "alias": "allowWheelScrub"; "required": false; "isSignal": true; }; "format": { "alias": "format"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "form": { "alias": "form"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "onValueChange": "onValueChange"; "onValueCommitted": "onValueCommitted"; }, never, never, true, [{ directive: typeof i1.RdxControlValueAccessor; inputs: { "value": "value"; "disabled": "disabled"; }; outputs: {}; }]>;
+}
+
+/**
+ * Groups the input with the increment and decrement buttons.
+ *
+ * @see https://base-ui.com/react/components/number-field
+ */
+declare class RdxNumberFieldGroup {
+    protected readonly rootContext: _radix_ng_primitives_number_field.RdxNumberFieldRoot;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxNumberFieldGroup, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxNumberFieldGroup, "div[rdxNumberFieldGroup]", ["rdxNumberFieldGroup"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * The native text input that displays the formatted value and accepts typed input.
+ *
+ * @see https://base-ui.com/react/components/number-field
+ */
+declare class RdxNumberFieldInput {
+    private readonly elementRef;
+    protected readonly rootContext: _radix_ng_primitives_number_field.RdxNumberFieldRoot;
+    /** Browsers place the caret at the start; we move it to the end on the first focus. */
+    private hasTouchedInput;
+    constructor();
+    onFocus(event: FocusEvent): void;
+    onBeforeInput(event: InputEvent): void;
+    onInput(event: Event): void;
+    onKeydown(event: KeyboardEvent): void;
+    onPaste(event: ClipboardEvent): void;
+    onBlur(event: FocusEvent): void;
+    onWheel(event: WheelEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxNumberFieldInput, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxNumberFieldInput, "input[rdxNumberFieldInput]", ["rdxNumberFieldInput"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * The hidden native `input[type=number]` that mirrors the field value for native form submission
+ * and browser constraint validation (min/max/step/required). Place it inside the root, alongside
+ * the visible `[rdxNumberFieldInput]`.
+ *
+ * @see https://base-ui.com/react/components/number-field
+ */
+declare class RdxNumberFieldHiddenInput {
+    protected readonly rootContext: _radix_ng_primitives_number_field.RdxNumberFieldRoot;
+    /** Move focus to the visible input when the hidden one is focused (e.g. via form validation). */
+    onFocus(): void;
+    /** Handle browser autofill, which writes directly to the hidden numeric input. */
+    onChange(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxNumberFieldHiddenInput, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxNumberFieldHiddenInput, "input[rdxNumberFieldHiddenInput]", ["rdxNumberFieldHiddenInput"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Coerces an optional numeric input, returning `undefined` for nullish/empty/non-numeric values.
+ * Unlike `numberAttribute`, `numberOrUndefined(undefined)` is `undefined` (not `NaN`), so an unset
+ * `[min]`/`[max]` does not poison clamping.
+ */
+declare function numberOrUndefined(value: NumberInput): number | undefined;
+/** Default step used when no `step` is provided. */
+declare const DEFAULT_STEP = 1;
+/** Delay between auto-repeat ticks while holding an increment/decrement button. */
+declare const CHANGE_VALUE_TICK_DELAY = 60;
+/** Delay before auto-repeat starts while holding an increment/decrement button. */
+declare const START_AUTO_CHANGE_DELAY = 400;
+/** Pointer travel (px) that cancels a hold, treating the gesture as a scroll. */
+declare const SCROLLING_POINTER_MOVE_DISTANCE = 8;
+/** Reactive `Intl`-backed formatter built from the current locale and format options. */
+declare function useNumberFormatter(locale: Signal<string>, options?: Signal<Intl.NumberFormatOptions | undefined>): Signal<NumberFormatter>;
+/** Reactive `Intl`-backed parser built from the current locale and format options. */
+declare function useNumberParser(locale: Signal<string>, options?: Signal<Intl.NumberFormatOptions | undefined>): Signal<NumberParser>;
+/** Whether the format options would cause `Intl.NumberFormat` to round the value. */
+declare function hasNumberFormatRoundingOptions(format?: Intl.NumberFormatOptions): boolean;
+/**
+ * Strips floating-point representation errors (e.g. `0.1 + 0.2`) using the format's
+ * rounding options when present, otherwise rounding to {@link DEFAULT_DIGITS} digits.
+ */
+declare function removeFloatingPointErrors(value: number, locale: string, format?: Intl.NumberFormatOptions): number;
+interface ValidateOptions {
+    step: number | undefined;
+    minWithDefault: number;
+    maxWithDefault: number;
+    minWithZeroDefault: number;
+    format: Intl.NumberFormatOptions | undefined;
+    locale: string;
+    snapOnStep: boolean;
+    small: boolean;
+    clamp: boolean;
+}
+/**
+ * Snaps (optionally), clamps (optionally) and rounds an unvalidated value, mirroring
+ * Base UI's `toValidatedNumber`. Snapping happens before clamping so non-step-aligned
+ * boundaries stay reachable.
+ */
+declare function toValidatedNumber(value: number | null, options: ValidateOptions): number | null;
+interface PressAndHoldOptions {
+    /** Whether interaction is currently blocked (disabled or read-only). */
+    disabled: () => boolean;
+    /** Delay before the first auto-repeat tick. */
+    startDelay: number;
+    /** Delay between subsequent auto-repeat ticks. */
+    tickDelay: number;
+    /** Pointer travel (px) that cancels the hold as a scroll. */
+    scrollDistance: number;
+    /** Runs on each tick; return `false` to stop auto-repeating (e.g. a bound was hit). */
+    tick: (event: PointerEvent) => boolean | void;
+    /** Runs once when the press ends (pointerup / cancel / scroll). */
+    onStop?: (event: PointerEvent) => void;
+}
+interface PressAndHold {
+    readonly isPressing: Signal<boolean>;
+    onPointerDown(event: PointerEvent): void;
+    /** Whether the following synthetic `click` should be ignored (a hold already ticked). */
+    shouldSkipClick(): boolean;
+}
+/**
+ * Pointer press-and-hold with auto-repeat, modelled on Base UI's `usePressAndHold`.
+ * Must be called in an injection context — it registers cleanup via `DestroyRef`.
+ */
+declare function createPressAndHold(options: PressAndHoldOptions): PressAndHold;
+
+/**
+ * Shared behaviour for the increment and decrement stepper buttons: single-press,
+ * press-and-hold auto-repeat, and committing a dirty (typed-but-not-blurred) input
+ * value before stepping.
+ *
+ * @see https://base-ui.com/react/components/number-field
+ */
+declare abstract class RdxNumberFieldButton {
+    protected readonly rootContext: _radix_ng_primitives_number_field.RdxNumberFieldRoot;
+    /** Whether this is the increment (`+1`) button; `false` for decrement (`-1`). */
+    protected abstract readonly isIncrement: boolean;
+    /**
+     * When `true`, the button is disabled in addition to inheriting the root's disabled state.
+     * @default false
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** @ignore Disabled for display/focus purposes (own state, root disabled, or bound reached). */
+    readonly buttonDisabled: _angular_core.Signal<boolean>;
+    /** @ignore Disabled for interaction purposes (also blocked while read-only). */
+    private readonly interactionDisabled;
+    private get direction();
+    private get pressReason();
+    /** @ignore */
+    readonly press: PressAndHold;
+    constructor();
+    onClick(event: MouseEvent): void;
+    onPointerDown(event: PointerEvent): void;
+    /** Commits a typed-but-not-yet-blurred input value so stepping starts from it. */
+    private commitDirtyValue;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxNumberFieldButton, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxNumberFieldButton, never, never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * A stepper button that increases the field value when clicked or held.
+ *
+ * @see https://base-ui.com/react/components/number-field
+ */
+declare class RdxNumberFieldIncrement extends RdxNumberFieldButton {
+    protected readonly isIncrement = true;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxNumberFieldIncrement, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxNumberFieldIncrement, "button[rdxNumberFieldIncrement]", ["rdxNumberFieldIncrement"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * A stepper button that decreases the field value when clicked or held.
+ *
+ * @see https://base-ui.com/react/components/number-field
+ */
+declare class RdxNumberFieldDecrement extends RdxNumberFieldButton {
+    protected readonly isIncrement = false;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxNumberFieldDecrement, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxNumberFieldDecrement, "button[rdxNumberFieldDecrement]", ["rdxNumberFieldDecrement"], {}, {}, never, never, true, never>;
+}
+
+interface RdxNumberFieldScrubAreaContext {
+    /** Whether a scrub gesture is currently in progress. */
+    readonly isScrubbing: Signal<boolean>;
+    /** Whether the active scrub was started with touch input. */
+    readonly isTouchInput: Signal<boolean>;
+    /** Whether the browser denied the Pointer Lock request. */
+    readonly isPointerLockDenied: Signal<boolean>;
+    /** Registers (or clears) the virtual cursor element so the scrub area can move it. */
+    registerCursor(element: HTMLElement | null): void;
+}
+/**
+ * Context shared from the scrub area to its virtual cursor child.
+ *
+ * @see https://base-ui.com/react/components/number-field
+ */
+declare const injectNumberFieldScrubAreaContext: (optional?: boolean) => RdxNumberFieldScrubAreaContext | null;
+declare const provideNumberFieldScrubAreaContext: (useFactory: () => RdxNumberFieldScrubAreaContext) => _angular_core.Provider;
+
+type ScrubDirection = 'horizontal' | 'vertical';
+/**
+ * An interactive area where the user can click and drag to change the field value.
+ * Uses the Pointer Lock API for continuous dragging (disabled in Safari to avoid layout shift).
+ *
+ * @see https://base-ui.com/react/components/number-field
+ */
+declare class RdxNumberFieldScrubArea {
+    protected readonly rootContext: _radix_ng_primitives_number_field.RdxNumberFieldRoot;
+    /**
+     * The direction the cursor must move to change the value.
+     * @default 'horizontal'
+     */
+    readonly direction: _angular_core.InputSignal<ScrubDirection>;
+    /**
+     * How many pixels the cursor must move before the value changes. Higher is less sensitive.
+     * @default 2
+     */
+    readonly pixelSensitivity: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    /**
+     * If set, the distance the cursor may move from the scrub area center before it loops back.
+     */
+    readonly teleportDistance: _angular_core.InputSignalWithTransform<number | undefined, NumberInput>;
+    protected readonly isScrubbing: _angular_core.WritableSignal<boolean>;
+    private readonly isTouchInput;
+    private readonly isPointerLockDenied;
+    private readonly cursorEl;
+    private readonly scrubAreaEl;
+    private isScrubbingRef;
+    private didMove;
+    private pointerDownTarget;
+    private virtualCursorCoords;
+    private visualScale;
+    /** @ignore Exposed to the scrub-area context provider. */
+    readonly context: RdxNumberFieldScrubAreaContext;
+    private readonly canScrub;
+    constructor();
+    onPointerDown(event: PointerEvent): Promise<void>;
+    onTouchStart(event: TouchEvent): void;
+    private onScrub;
+    private onScrubbingChange;
+    private updateCursorTransform;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxNumberFieldScrubArea, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxNumberFieldScrubArea, "[rdxNumberFieldScrubArea]", ["rdxNumberFieldScrubArea"], { "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "pixelSensitivity": { "alias": "pixelSensitivity"; "required": false; "isSignal": true; }; "teleportDistance": { "alias": "teleportDistance"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * A custom element shown instead of the native cursor while scrubbing. It is portaled to the
+ * document body and positioned with the Pointer Lock API. Hidden in Safari (which would shift
+ * layout with the native pointer-lock notification) and for touch input.
+ *
+ * @see https://base-ui.com/react/components/number-field
+ */
+declare class RdxNumberFieldScrubAreaCursor {
+    private readonly elementRef;
+    private readonly scrubContext;
+    protected readonly shouldRender: _angular_core.Signal<boolean>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxNumberFieldScrubAreaCursor, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxNumberFieldScrubAreaCursor, "[rdxNumberFieldScrubAreaCursor]", ["rdxNumberFieldScrubAreaCursor"], {}, {}, never, never, true, [{ directive: typeof i1$1.RdxPortal; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * The Number Field context exposes the root directive instance to every child part.
+ * The root owns all state, parsing/formatting and value-change logic; parts read
+ * signals and call methods off it.
+ *
+ * @see https://base-ui.com/react/components/number-field
+ */
+declare const injectNumberFieldRootContext: (optional?: boolean) => RdxNumberFieldRoot | null;
+declare const provideNumberFieldRootContext: (useFactory: () => RdxNumberFieldRoot) => _angular_core.Provider;
+
+declare class RdxNumberFieldModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxNumberFieldModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<RdxNumberFieldModule, never, [typeof RdxNumberFieldRoot, typeof RdxNumberFieldGroup, typeof RdxNumberFieldInput, typeof RdxNumberFieldHiddenInput, typeof RdxNumberFieldIncrement, typeof RdxNumberFieldDecrement, typeof RdxNumberFieldScrubArea, typeof RdxNumberFieldScrubAreaCursor], [typeof RdxNumberFieldRoot, typeof RdxNumberFieldGroup, typeof RdxNumberFieldInput, typeof RdxNumberFieldHiddenInput, typeof RdxNumberFieldIncrement, typeof RdxNumberFieldDecrement, typeof RdxNumberFieldScrubArea, typeof RdxNumberFieldScrubAreaCursor]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<RdxNumberFieldModule>;
+}
+
+export { CHANGE_VALUE_TICK_DELAY, DEFAULT_STEP, REASONS, RdxNumberFieldButton, RdxNumberFieldDecrement, RdxNumberFieldGroup, RdxNumberFieldHiddenInput, RdxNumberFieldIncrement, RdxNumberFieldInput, RdxNumberFieldModule, RdxNumberFieldRoot, RdxNumberFieldScrubArea, RdxNumberFieldScrubAreaCursor, SCROLLING_POINTER_MOVE_DISTANCE, START_AUTO_CHANGE_DELAY, createPressAndHold, hasNumberFormatRoundingOptions, injectNumberFieldRootContext, injectNumberFieldScrubAreaContext, numberOrUndefined, provideNumberFieldRootContext, provideNumberFieldScrubAreaContext, removeFloatingPointErrors, toValidatedNumber, useNumberFormatter, useNumberParser };
+export type { Direction, InputMode, NumberFieldChangeReason, PressAndHold, PressAndHoldOptions, RdxNumberFieldScrubAreaContext, ValidateOptions };

package/{pagination/index.d.ts → types/radix-ng-primitives-pagination.d.ts}

@@ -1,6 +1,6 @@
 import * as i0 from '@angular/core';
-import { model, computed, InjectionToken } from '@angular/core';
-import { NumberInput, BooleanInput } from '@angular/cdk/coercion';
+import { InjectionToken, model, computed } from '@angular/core';
+import { NumberInput, BooleanInput } from '@radix-ng/primitives/core';
 
 declare class RdxPaginationRootDirective {
     readonly defaultPage: i0.InputSignalWithTransform<number, NumberInput>;