@radix-ng/primitives 0.51.0 → 1.0.0-beta.1

package/types/radix-ng-primitives-radio.d.ts

@@ -1,27 +1,36 @@
 import * as _angular_core from '@angular/core';
-import { InputSignalWithTransform, ModelSignal, Signal, OnInit, InjectionToken } from '@angular/core';
-import { BooleanInput } from '@angular/cdk/coercion';
+import { ModelSignal, InputSignal, InputSignalWithTransform, Signal, InjectionToken } from '@angular/core';
 import { ControlValueAccessor } from '@angular/forms';
+import { BooleanInput, RdxFormValueControl } from '@radix-ng/primitives/core';
 import * as i1 from '@radix-ng/primitives/roving-focus';
 import { Orientation } from '@radix-ng/primitives/roving-focus';
 import * as i1$1 from '@radix-ng/primitives/visually-hidden';
 
 interface RadioGroupProps {
-    name?: string;
-    disabled?: InputSignalWithTransform<boolean, BooleanInput>;
-    defaultValue?: string;
     value: ModelSignal<string | null>;
-    disableState: Signal<boolean>;
+    defaultValue: InputSignal<string | undefined>;
+    name: InputSignal<string | undefined>;
+    form: InputSignal<string | undefined>;
+    disabled: InputSignalWithTransform<boolean, BooleanInput>;
+    readonly: InputSignalWithTransform<boolean, BooleanInput>;
+    required: InputSignalWithTransform<boolean, BooleanInput>;
+    orientation: InputSignal<Orientation | undefined>;
+    disabledState: Signal<boolean>;
 }
 interface RadioGroupDirective extends RadioGroupProps {
     select(value: string | null): void;
     onTouched(): void;
+    setArrowNavigation(value: boolean): void;
+    isArrowNavigation(): boolean;
 }
 
-declare class RdxRadioGroupDirective implements RadioGroupProps, RadioGroupDirective, ControlValueAccessor {
+declare class RdxRadioGroupDirective implements RadioGroupProps, RadioGroupDirective, ControlValueAccessor, RdxFormValueControl<string | null> {
     readonly value: _angular_core.ModelSignal<string | null>;
+    readonly defaultValue: _angular_core.InputSignal<string | undefined>;
+    readonly name: _angular_core.InputSignal<string | undefined>;
+    readonly form: _angular_core.InputSignal<string | undefined>;
     readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
-    defaultValue?: string;
+    readonly readonly: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
     readonly required: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
     readonly orientation: _angular_core.InputSignal<Orientation | undefined>;
     /**
@@ -29,7 +38,8 @@ declare class RdxRadioGroupDirective implements RadioGroupProps, RadioGroupDirec
      */
     readonly onValueChange: _angular_core.OutputEmitterRef<string>;
     private readonly disable;
-    readonly disableState: _angular_core.Signal<boolean>;
+    readonly disabledState: _angular_core.Signal<boolean>;
+    private readonly arrowNavigation;
     /**
      * The callback function to call when the value of the radio group changes.
      */
@@ -39,24 +49,25 @@ declare class RdxRadioGroupDirective implements RadioGroupProps, RadioGroupDirec
      * @ignore
      */
     onTouched: () => void;
+    constructor();
     /**
      * Select a radio item.
      * @param value The value of the radio item to select.
      * @ignore
      */
-    select(value: string): void;
+    select(value: string | null): void;
     /**
      * Update the value of the radio group.
      * @param value The new value of the radio group.
      * @ignore
      */
-    writeValue(value: string): void;
+    writeValue(value: string | null): void;
     /**
      * Register a callback function to call when the value of the radio group changes.
      * @param fn The callback function to call when the value of the radio group changes.
      * @ignore
      */
-    registerOnChange(fn: (value: string) => void): void;
+    registerOnChange(fn: (value: string | null) => void): void;
     /** @ignore */
     registerOnTouched(fn: () => void): void;
     /**
@@ -65,26 +76,36 @@ declare class RdxRadioGroupDirective implements RadioGroupProps, RadioGroupDirec
      * @ignore
      */
     setDisabledState(isDisabled: boolean): void;
+    setArrowNavigation(value: boolean): void;
+    isArrowNavigation(): boolean;
     protected onKeydown(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxRadioGroupDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxRadioGroupDirective, "[rdxRadioRoot]", ["rdxRadioRoot"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "onValueChange": "onValueChange"; }, never, never, true, [{ directive: typeof i1.RdxRovingFocusGroupDirective; inputs: { "dir": "dir"; "orientation": "orientation"; "loop": "loop"; }; outputs: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxRadioGroupDirective, "[rdxRadioRoot]", ["rdxRadioRoot"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "form": { "alias": "form"; "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; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "onValueChange": "onValueChange"; }, never, never, true, [{ directive: typeof i1.RdxRovingFocusGroupDirective; inputs: { "dir": "dir"; "orientation": "orientation"; "loop": "loop"; }; outputs: {}; }]>;
 }
 
 declare const RdxRadioItemToken: InjectionToken<RdxRadioItemDirective>;
 declare function injectRadioItem(): RdxRadioItemDirective;
-declare class RdxRadioItemDirective implements OnInit {
+declare class RdxRadioItemDirective {
     private readonly radioGroup;
     private readonly elementRef;
+    private readonly renderer;
+    private readonly rovingFocusItem;
+    private readonly destroyRef;
+    private readonly inputElement;
+    private previousCheckedState;
     readonly value: _angular_core.InputSignal<string>;
     readonly id: _angular_core.InputSignal<string | undefined>;
-    readonly required: _angular_core.InputSignal<boolean | undefined>;
+    readonly required: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
     readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
-    protected readonly disabledState: _angular_core.Signal<boolean>;
+    readonly readonly: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly nativeButton: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly nativeButtonState: _angular_core.Signal<boolean>;
+    readonly disabledState: _angular_core.Signal<boolean>;
+    readonly readonlyState: _angular_core.Signal<boolean>;
+    readonly requiredState: _angular_core.Signal<boolean>;
     readonly checkedState: _angular_core.Signal<boolean>;
     private readonly ARROW_KEYS;
-    private readonly isArrowKeyPressedSignal;
-    /** @ignore */
-    ngOnInit(): void;
+    constructor();
     /** @ignore */
     onClick(): void;
     /** @ignore */
@@ -93,8 +114,13 @@ declare class RdxRadioItemDirective implements OnInit {
     onKeyUp(): void;
     /** @ignore */
     onFocus(): void;
+    private isAllowedArrowKey;
+    private createHiddenInput;
+    private syncHiddenInput;
+    private setOptionalAttribute;
+    private setBooleanAttribute;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxRadioItemDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxRadioItemDirective, "[rdxRadioItem]", ["rdxRadioItem"], { "value": { "alias": "value"; "required": true; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.RdxRovingFocusItemDirective; inputs: { "tabStopId": "id"; "focusable": "focusable"; "active": "active"; "allowShiftKey": "allowShiftKey"; }; outputs: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxRadioItemDirective, "[rdxRadioItem]", ["rdxRadioItem"], { "value": { "alias": "value"; "required": true; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "nativeButton": { "alias": "nativeButton"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.RdxRovingFocusItemDirective; inputs: { "tabStopId": "id"; "focusable": "focusable"; "active": "active"; "allowShiftKey": "allowShiftKey"; }; outputs: {}; }]>;
 }
 
 declare class RdxRadioIndicatorDirective {
@@ -106,13 +132,17 @@ declare class RdxRadioIndicatorDirective {
 
 declare class RdxRadioItemInputDirective {
     private readonly radioItem;
-    readonly name: _angular_core.InputSignal<string | undefined>;
+    private readonly radioGroup;
+    private readonly input;
+    readonly name: _angular_core.Signal<string | undefined>;
+    readonly form: _angular_core.Signal<string | undefined>;
     readonly value: _angular_core.Signal<string | undefined>;
-    readonly checked: _angular_core.Signal<true | undefined>;
-    readonly required: _angular_core.InputSignal<boolean | undefined>;
-    readonly disabled: _angular_core.InputSignal<boolean | undefined>;
+    readonly checked: _angular_core.Signal<boolean>;
+    readonly required: _angular_core.Signal<boolean>;
+    readonly disabled: _angular_core.Signal<boolean>;
+    constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxRadioItemInputDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxRadioItemInputDirective, "[rdxRadioItemInput]", ["rdxRadioItemInput"], { "name": { "alias": "name"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$1.RdxVisuallyHiddenDirective; inputs: { "feature": "feature"; }; outputs: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxRadioItemInputDirective, "input[rdxRadioItemInput]", ["rdxRadioItemInput"], {}, {}, never, never, true, [{ directive: typeof i1$1.RdxVisuallyHiddenDirective; inputs: { "feature": "feature"; }; outputs: {}; }]>;
 }
 
 export { RdxRadioGroupDirective, RdxRadioIndicatorDirective, RdxRadioItemDirective, RdxRadioItemInputDirective, RdxRadioItemToken, injectRadioItem };

package/types/radix-ng-primitives-roving-focus.d.ts

@@ -1,5 +1,6 @@
+import * as _radix_ng_primitives_core from '@radix-ng/primitives/core';
+import { BooleanInput } from '@radix-ng/primitives/core';
 import * as _angular_core from '@angular/core';
-import { BooleanInput } from '@angular/cdk/coercion';
 import * as _radix_ng_primitives_roving_focus from '@radix-ng/primitives/roving-focus';
 
 type Orientation = 'horizontal' | 'vertical';
@@ -14,13 +15,11 @@ declare const rootContext: () => {
     focusableItems: _angular_core.WritableSignal<HTMLElement[]>;
     onItemFocus: (tabStopId: string) => void;
     onItemShiftTab: () => void;
-    onFocusableItemAdd: () => void;
-    onFocusableItemRemove: () => void;
-    registerItem: (item: HTMLElement) => void;
-    unregisterItem: (item: HTMLElement) => void;
+    registerItem: (item: HTMLElement, tabStopId: string) => void;
+    unregisterItem: (item: HTMLElement, tabStopId: string) => void;
 };
 type RovingFocusGroupContext = ReturnType<typeof rootContext>;
-declare const injectRovingFocusGroupContext: (optional?: boolean) => {
+declare const injectRovingFocusGroupContext: _radix_ng_primitives_core.InjectContext<{
     loop: _angular_core.Signal<boolean>;
     dir: _angular_core.Signal<Direction>;
     orientation: _angular_core.Signal<Orientation>;
@@ -28,11 +27,9 @@ declare const injectRovingFocusGroupContext: (optional?: boolean) => {
     focusableItems: _angular_core.WritableSignal<HTMLElement[]>;
     onItemFocus: (tabStopId: string) => void;
     onItemShiftTab: () => void;
-    onFocusableItemAdd: () => void;
-    onFocusableItemRemove: () => void;
-    registerItem: (item: HTMLElement) => void;
-    unregisterItem: (item: HTMLElement) => void;
-} | null;
+    registerItem: (item: HTMLElement, tabStopId: string) => void;
+    unregisterItem: (item: HTMLElement, tabStopId: string) => void;
+}>;
 declare const provideRovingFocusGroupContext: (useFactory: () => {
     loop: _angular_core.Signal<boolean>;
     dir: _angular_core.Signal<Direction>;
@@ -41,10 +38,8 @@ declare const provideRovingFocusGroupContext: (useFactory: () => {
     focusableItems: _angular_core.WritableSignal<HTMLElement[]>;
     onItemFocus: (tabStopId: string) => void;
     onItemShiftTab: () => void;
-    onFocusableItemAdd: () => void;
-    onFocusableItemRemove: () => void;
-    registerItem: (item: HTMLElement) => void;
-    unregisterItem: (item: HTMLElement) => void;
+    registerItem: (item: HTMLElement, tabStopId: string) => void;
+    unregisterItem: (item: HTMLElement, tabStopId: string) => void;
 }) => _angular_core.Provider;
 /**
  * @group Components
@@ -52,6 +47,7 @@ declare const provideRovingFocusGroupContext: (useFactory: () => {
 declare class RdxRovingFocusGroupDirective {
     private readonly isBrowser;
     private readonly elementRef;
+    private readonly destroyRef;
     /**
      * The orientation of the group. Mainly so arrow navigation is done accordingly (left & right vs. up & down)
      */
@@ -95,12 +91,17 @@ declare class RdxRovingFocusGroupDirective {
     readonly focusableItems: _angular_core.WritableSignal<HTMLElement[]>;
     protected readonly isClickFocus: _angular_core.WritableSignal<boolean>;
     readonly isTabbingBackOut: _angular_core.WritableSignal<boolean>;
-    readonly focusableItemsCount: _angular_core.WritableSignal<number>;
+    private readonly itemIds;
+    private isDestroyed;
     constructor();
     setOrientation(value: Orientation): void;
     setDir(value: Direction): void;
     setLoop(value: boolean): void;
     /** @ignore */
+    registerItem(item: HTMLElement, tabStopId: string): void;
+    /** @ignore */
+    unregisterItem(item: HTMLElement, tabStopId: string): void;
+    /** @ignore */
     handleMouseUp(): void;
     /** @ignore */
     handleFocus(event: Event): void;
@@ -113,8 +114,11 @@ declare class RdxRovingFocusGroupDirective {
  */
 declare class RdxRovingFocusItemDirective {
     private readonly isBrowser;
-    private readonly destroyRef;
     private readonly elementRef;
+    /**
+     * The enclosing roving-focus group. Optional: when the item is used outside a group
+     * (e.g. a standalone Toggle), it degrades to a plain element and does not manage focus.
+     */
     protected readonly rootContext: {
         loop: _angular_core.Signal<boolean>;
         dir: _angular_core.Signal<_radix_ng_primitives_roving_focus.Direction>;
@@ -123,18 +127,16 @@ declare class RdxRovingFocusItemDirective {
         focusableItems: _angular_core.WritableSignal<HTMLElement[]>;
         onItemFocus: (tabStopId: string) => void;
         onItemShiftTab: () => void;
-        onFocusableItemAdd: () => void;
-        onFocusableItemRemove: () => void;
-        registerItem: (item: HTMLElement) => void;
-        unregisterItem: (item: HTMLElement) => void;
-    };
+        registerItem: (item: HTMLElement, tabStopId: string) => void;
+        unregisterItem: (item: HTMLElement, tabStopId: string) => void;
+    } | null;
     /**
      * When false, item will not be focusable.
      * @group Props
      */
     readonly focusableInput: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
     /**
-     * When `true`, item will be initially focused.
+     * When `true`, marks the item as the active one, so it is preferred when focus enters the group.
      * @group Props
      */
     readonly activeInput: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
@@ -147,16 +149,24 @@ declare class RdxRovingFocusItemDirective {
      * @group Props
      */
     readonly allowShiftKey: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    private readonly generatedId;
     protected readonly id: _angular_core.Signal<string>;
     protected readonly isCurrentTabStop: _angular_core.Signal<boolean>;
     protected readonly focusable: _angular_core.WritableSignal<boolean>;
     protected readonly active: _angular_core.WritableSignal<boolean>;
     private readonly tabStopId;
+    /**
+     * The roving tabindex. Without a group the item keeps its natural tab order (`null`); inside a
+     * group exactly one focusable item is a tab stop (`0`), the rest are reachable only via arrows (`-1`).
+     */
+    protected readonly tabindex: _angular_core.Signal<-1 | 0 | null>;
     constructor();
     setFocusable(value: boolean): void;
     setActive(value: boolean): void;
     setTabStopId(value: string): void;
     /** @ignore */
+    onFocus(): void;
+    /** @ignore */
     handleMouseDown(event: Event): void;
     /**
      * Handles the `keydown` event for keyboard navigation within the roving focus group.

package/types/radix-ng-primitives-scroll-area.d.ts

@@ -0,0 +1,253 @@
+import * as _angular_core from '@angular/core';
+import { Signal } from '@angular/core';
+import * as _radix_ng_primitives_core from '@radix-ng/primitives/core';
+import { Direction, BooleanInput } from '@radix-ng/primitives/core';
+import * as _radix_ng_primitives_scroll_area from '@radix-ng/primitives/scroll-area';
+
+type Size = {
+    width: number;
+    height: number;
+};
+type Coords = {
+    x: number;
+    y: number;
+};
+type OverflowEdges = {
+    xStart: boolean;
+    xEnd: boolean;
+    yStart: boolean;
+    yEnd: boolean;
+};
+type HiddenState = {
+    x: boolean;
+    y: boolean;
+    corner: boolean;
+};
+/** A minimal, React-`ref`-like mutable holder shared through context. */
+type MutableRef<T> = {
+    current: T | null;
+};
+type OverflowEdgeThreshold = number | Partial<{
+    xStart: number;
+    xEnd: number;
+    yStart: number;
+    yEnd: number;
+}>;
+interface ScrollAreaRootContext {
+    readonly rootId: string;
+    readonly direction: Signal<Direction>;
+    readonly overflowEdgeThreshold: Signal<{
+        xStart: number;
+        xEnd: number;
+        yStart: number;
+        yEnd: number;
+    }>;
+    readonly hovering: Signal<boolean>;
+    readonly scrollingX: Signal<boolean>;
+    readonly scrollingY: Signal<boolean>;
+    readonly touchModality: Signal<boolean>;
+    readonly hasMeasuredScrollbar: Signal<boolean>;
+    readonly cornerSize: Signal<Size>;
+    readonly thumbSize: Signal<Size>;
+    readonly hiddenState: Signal<HiddenState>;
+    readonly overflowEdges: Signal<OverflowEdges>;
+    readonly rootRef: MutableRef<HTMLElement>;
+    readonly viewportRef: MutableRef<HTMLElement>;
+    readonly scrollbarYRef: MutableRef<HTMLElement>;
+    readonly scrollbarXRef: MutableRef<HTMLElement>;
+    readonly thumbYRef: MutableRef<HTMLElement>;
+    readonly thumbXRef: MutableRef<HTMLElement>;
+    readonly cornerRef: MutableRef<HTMLElement>;
+    setHovering(value: boolean): void;
+    setHasMeasuredScrollbar(value: boolean): void;
+    setScrollingX(value: boolean): void;
+    setScrollingY(value: boolean): void;
+    setThumbSize(value: Size): void;
+    setCornerSize(value: Size): void;
+    setHiddenState(value: HiddenState): void;
+    setOverflowEdges(value: OverflowEdges): void;
+    handleScroll(position: Coords): void;
+    handlePointerDown(event: PointerEvent): void;
+    handlePointerMove(event: PointerEvent): void;
+    handlePointerUp(event: PointerEvent): void;
+}
+declare const injectScrollAreaRootContext: _radix_ng_primitives_core.InjectContext<ScrollAreaRootContext>;
+declare const provideScrollAreaRootContext: (useFactory: () => ScrollAreaRootContext) => _angular_core.Provider;
+/**
+ * Groups all parts of the scroll area.
+ * Renders a `<div>` element.
+ *
+ * @group Components
+ */
+declare class RdxScrollAreaRoot {
+    private readonly destroyRef;
+    readonly rootId: string;
+    /** Text direction of the scroll area. Affects horizontal (RTL) scroll math. */
+    readonly dir: _angular_core.InputSignal<Direction>;
+    readonly direction: Signal<Direction>;
+    /**
+     * The threshold in pixels that must be passed before the overflow edge attributes are applied.
+     * Accepts a single number for all edges or an object to configure them individually.
+     */
+    readonly overflowEdgeThreshold: _angular_core.InputSignal<OverflowEdgeThreshold>;
+    readonly normalizedThreshold: Signal<{
+        xStart: number;
+        xEnd: number;
+        yStart: number;
+        yEnd: number;
+    }>;
+    readonly hovering: _angular_core.WritableSignal<boolean>;
+    readonly scrollingX: _angular_core.WritableSignal<boolean>;
+    readonly scrollingY: _angular_core.WritableSignal<boolean>;
+    readonly touchModality: _angular_core.WritableSignal<boolean>;
+    readonly hasMeasuredScrollbar: _angular_core.WritableSignal<boolean>;
+    readonly cornerSize: _angular_core.WritableSignal<Size>;
+    readonly thumbSize: _angular_core.WritableSignal<Size>;
+    readonly hiddenState: _angular_core.WritableSignal<HiddenState>;
+    readonly overflowEdges: _angular_core.WritableSignal<OverflowEdges>;
+    readonly rootRef: MutableRef<HTMLElement>;
+    readonly viewportRef: MutableRef<HTMLElement>;
+    readonly scrollbarYRef: MutableRef<HTMLElement>;
+    readonly scrollbarXRef: MutableRef<HTMLElement>;
+    readonly thumbYRef: MutableRef<HTMLElement>;
+    readonly thumbXRef: MutableRef<HTMLElement>;
+    readonly cornerRef: MutableRef<HTMLElement>;
+    private thumbDragging;
+    private startY;
+    private startX;
+    private startScrollTop;
+    private startScrollLeft;
+    private currentOrientation;
+    private scrollPosition;
+    private scrollYTimer;
+    private scrollXTimer;
+    constructor();
+    setScrollingX(value: boolean): void;
+    setScrollingY(value: boolean): void;
+    setThumbSize(value: Size): void;
+    setCornerSize(value: Size): void;
+    setHiddenState(value: HiddenState): void;
+    setOverflowEdges(value: OverflowEdges): void;
+    handleScroll(scrollPosition: Coords): void;
+    handlePointerDown(event: PointerEvent): void;
+    handlePointerMove(event: PointerEvent): void;
+    handlePointerUp(event: PointerEvent): void;
+    onTouchModalityChange(event: PointerEvent): void;
+    onPointerEnterOrMove(event: PointerEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxScrollAreaRoot, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxScrollAreaRoot, "[rdxScrollAreaRoot]", ["rdxScrollAreaRoot"], { "dir": { "alias": "dir"; "required": false; "isSignal": true; }; "overflowEdgeThreshold": { "alias": "overflowEdgeThreshold"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface ScrollAreaViewportContext {
+    /** Re-measures the viewport and repositions the thumbs. Called by the content's ResizeObserver. */
+    computeThumbPosition(): void;
+}
+declare const injectScrollAreaViewportContext: _radix_ng_primitives_core.InjectContext<ScrollAreaViewportContext>;
+declare const provideScrollAreaViewportContext: (useFactory: () => ScrollAreaViewportContext) => _angular_core.Provider;
+/**
+ * The actual scrollable container of the scroll area.
+ * Renders a `<div>` element.
+ *
+ * @group Components
+ */
+declare class RdxScrollAreaViewport {
+    protected readonly rootContext: _radix_ng_primitives_scroll_area.ScrollAreaRootContext;
+    private readonly element;
+    private readonly destroyRef;
+    private readonly isBrowser;
+    private programmaticScroll;
+    private lastMeasuredMetrics;
+    private scrollEndTimer;
+    private animationsTimer;
+    constructor();
+    computeThumbPosition(): void;
+    onScroll(): void;
+    onUserInteraction(): void;
+    private observeViewport;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxScrollAreaViewport, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxScrollAreaViewport, "[rdxScrollAreaViewport]", ["rdxScrollAreaViewport"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * A container for the content of the scroll area.
+ * Renders a `<div>` element.
+ *
+ * @group Components
+ */
+declare class RdxScrollAreaContent {
+    protected readonly rootContext: _radix_ng_primitives_scroll_area.ScrollAreaRootContext;
+    private readonly viewportContext;
+    private readonly element;
+    private readonly destroyRef;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxScrollAreaContent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxScrollAreaContent, "[rdxScrollAreaContent]", ["rdxScrollAreaContent"], {}, {}, never, never, true, never>;
+}
+
+type ScrollbarOrientation = 'vertical' | 'horizontal';
+interface ScrollAreaScrollbarContext {
+    orientation: () => ScrollbarOrientation;
+}
+declare const injectScrollAreaScrollbarContext: _radix_ng_primitives_core.InjectContext<ScrollAreaScrollbarContext>;
+declare const provideScrollAreaScrollbarContext: (useFactory: () => ScrollAreaScrollbarContext) => _angular_core.Provider;
+/**
+ * A vertical or horizontal scrollbar for the scroll area.
+ * Renders a `<div>` element.
+ *
+ * @group Components
+ */
+declare class RdxScrollAreaScrollbar {
+    protected readonly rootContext: _radix_ng_primitives_scroll_area.ScrollAreaRootContext;
+    private readonly element;
+    /** Whether the scrollbar controls vertical or horizontal scroll. */
+    readonly orientation: _angular_core.InputSignal<ScrollbarOrientation>;
+    /** Whether to keep the element rendered when the viewport isn't scrollable. */
+    readonly keepMounted: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    protected readonly scrolling: _angular_core.Signal<boolean>;
+    private readonly isHidden;
+    protected readonly shouldRender: _angular_core.Signal<boolean>;
+    protected readonly hideTrackUntilMeasured: _angular_core.Signal<boolean>;
+    constructor();
+    onWheel(event: WheelEvent): void;
+    onPointerDown(event: PointerEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxScrollAreaScrollbar, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxScrollAreaScrollbar, "[rdxScrollAreaScrollbar]", ["rdxScrollAreaScrollbar"], { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "keepMounted": { "alias": "keepMounted"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * The draggable part of the scrollbar that indicates the current scroll position.
+ * Renders a `<div>` element.
+ *
+ * @group Components
+ */
+declare class RdxScrollAreaThumb {
+    protected readonly rootContext: _radix_ng_primitives_scroll_area.ScrollAreaRootContext;
+    protected readonly scrollbarContext: _radix_ng_primitives_scroll_area.ScrollAreaScrollbarContext;
+    private readonly element;
+    constructor();
+    endDrag(event: PointerEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxScrollAreaThumb, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxScrollAreaThumb, "[rdxScrollAreaThumb]", ["rdxScrollAreaThumb"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * A small rectangular area that appears at the intersection of horizontal and vertical scrollbars.
+ * Renders a `<div>` element.
+ *
+ * @group Components
+ */
+declare class RdxScrollAreaCorner {
+    protected readonly rootContext: _radix_ng_primitives_scroll_area.ScrollAreaRootContext;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxScrollAreaCorner, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxScrollAreaCorner, "[rdxScrollAreaCorner]", ["rdxScrollAreaCorner"], {}, {}, never, never, true, never>;
+}
+
+declare class RdxScrollAreaModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxScrollAreaModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<RdxScrollAreaModule, never, [typeof RdxScrollAreaRoot, typeof RdxScrollAreaViewport, typeof RdxScrollAreaContent, typeof RdxScrollAreaScrollbar, typeof RdxScrollAreaThumb, typeof RdxScrollAreaCorner], [typeof RdxScrollAreaRoot, typeof RdxScrollAreaViewport, typeof RdxScrollAreaContent, typeof RdxScrollAreaScrollbar, typeof RdxScrollAreaThumb, typeof RdxScrollAreaCorner]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<RdxScrollAreaModule>;
+}
+
+export { RdxScrollAreaContent, RdxScrollAreaCorner, RdxScrollAreaModule, RdxScrollAreaRoot, RdxScrollAreaScrollbar, RdxScrollAreaThumb, RdxScrollAreaViewport, injectScrollAreaRootContext, injectScrollAreaScrollbarContext, injectScrollAreaViewportContext, provideScrollAreaRootContext, provideScrollAreaScrollbarContext, provideScrollAreaViewportContext };
+export type { Coords, HiddenState, MutableRef, OverflowEdgeThreshold, OverflowEdges, ScrollAreaRootContext, ScrollAreaScrollbarContext, ScrollAreaViewportContext, ScrollbarOrientation, Size };