@radix-ng/primitives 1.0.0-beta.4 → 1.0.0-beta.5

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

@@ -4,9 +4,10 @@ import * as i1 from '@radix-ng/primitives/portal';
 import { RdxPortalContainer } from '@radix-ng/primitives/portal';
 import * as _radix_ng_primitives_core from '@radix-ng/primitives/core';
 import { RdxTransitionStatus, BooleanInput, RdxCancelableChangeEventDetails, RdxFloatingRootContext } from '@radix-ng/primitives/core';
+import * as _radix_ng_primitives_floating_focus_manager from '@radix-ng/primitives/floating-focus-manager';
+import { RdxInteractionType } from '@radix-ng/primitives/floating-focus-manager';
 import * as _radix_ng_primitives_dialog from '@radix-ng/primitives/dialog';
 import { RdxOutsidePressDomEvent } from '@radix-ng/primitives/dismissable-layer';
-import * as i2 from '@radix-ng/primitives/floating-focus-manager';
 
 /**
  * Structural directive that teleports the dialog content (backdrop + popup) into a container (default
@@ -106,6 +107,8 @@ interface RdxDialogRootContext {
     trigger: Signal<HTMLElement | undefined>;
     triggers: Signal<HTMLElement[]>;
     payload: Signal<unknown>;
+    openInteractionType: Signal<RdxInteractionType>;
+    closeInteractionType: Signal<RdxInteractionType>;
     /** Whether this dialog is nested in another; constant, fixed at construction. */
     nested: boolean;
     nestedDialogOpen: Signal<boolean>;
@@ -113,6 +116,7 @@ interface RdxDialogRootContext {
     setDescriptionId: (id: string | undefined) => void;
     registerTransitionElement: (element: HTMLElement) => () => void;
     registerTrigger: (id: string, trigger: HTMLElement, payload: () => unknown) => () => void;
+    setTriggerOpenInteractionType: (type: RdxInteractionType) => void;
     open: (trigger?: HTMLElement, payload?: unknown, triggerId?: string, reason?: RdxDialogOpenChangeReason, event?: Event) => void;
     close: (reason?: RdxDialogOpenChangeReason, event?: Event) => void;
     toggle: (triggerId: string, trigger: HTMLElement, payload?: unknown, event?: Event) => void;
@@ -178,7 +182,10 @@ declare class RdxDialogRoot {
     readonly triggers: _angular_core.WritableSignal<HTMLElement[]>;
     readonly payload: _angular_core.WritableSignal<unknown>;
     readonly nestedOpenCount: _angular_core.WritableSignal<number>;
+    readonly openInteractionType: _angular_core.WritableSignal<RdxInteractionType>;
+    readonly closeInteractionType: _angular_core.WritableSignal<RdxInteractionType>;
     private readonly preventUnmountOnClose;
+    private readonly pendingTriggerOpenInteractionType;
     readonly present: Signal<boolean>;
     /** Whether this dialog is rendered inside another dialog. Fixed at construction. */
     readonly nested: boolean;
@@ -199,12 +206,14 @@ declare class RdxDialogRoot {
     show(trigger?: HTMLElement | undefined, payload?: unknown, triggerId?: string, reason?: RdxDialogOpenChangeReason, event?: Event): void;
     close(reason?: RdxDialogOpenChangeReason, event?: Event): void;
     toggle(triggerId: string, trigger: HTMLElement, payload?: unknown, event?: Event): void;
+    setTriggerOpenInteractionType(type: RdxInteractionType): void;
     registerTrigger(id: string, trigger: HTMLElement, payload: () => unknown): () => void;
     /** Increments the nested-open counter and returns a release callback that decrements it. */
     openNestedChild(): () => void;
     private syncTriggerId;
     private createOpenChangeEvent;
     private emitOpenChangeComplete;
+    private consumeOpenInteractionType;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxDialogRoot, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxDialogRoot, "[rdxDialogRoot]", ["rdxDialogRoot"], { "open": { "alias": "open"; "required": false; "isSignal": true; }; "defaultOpen": { "alias": "defaultOpen"; "required": false; "isSignal": true; }; "triggerId": { "alias": "triggerId"; "required": false; "isSignal": true; }; "defaultTriggerId": { "alias": "defaultTriggerId"; "required": false; "isSignal": true; }; "modal": { "alias": "modal"; "required": false; "isSignal": true; }; "disablePointerDismissal": { "alias": "disablePointerDismissal"; "required": false; "isSignal": true; }; "handle": { "alias": "handle"; "required": false; "isSignal": true; }; }, { "open": "openChange"; "triggerId": "triggerIdChange"; "onOpenChange": "onOpenChange"; "onOpenChangeComplete": "onOpenChangeComplete"; }, never, never, true, never>;
 }
@@ -235,8 +244,10 @@ declare class RdxDialogTrigger {
     protected readonly triggerId: _angular_core.Signal<string>;
     protected readonly rootContext: _angular_core.Signal<_radix_ng_primitives_dialog.RdxDialogRootContext | null>;
     protected readonly isOpen: _angular_core.Signal<boolean>;
+    protected readonly triggerInteraction: _radix_ng_primitives_floating_focus_manager.RdxTriggerInteraction;
     constructor();
     protected handleClick(event: MouseEvent): void;
+    protected handlePointerDown(event: PointerEvent): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxDialogTrigger, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxDialogTrigger, "button[rdxDialogTrigger]", ["rdxDialogTrigger"], { "handle": { "alias": "handle"; "required": false; "isSignal": true; }; "payload": { "alias": "payload"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
@@ -331,7 +342,7 @@ declare class RdxDialogPopup {
      */
     protected onKeyDown(event: KeyboardEvent): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxDialogPopup, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxDialogPopup, "[rdxDialogPopup]", ["rdxDialogPopup"], {}, { "escapeKeyDown": "escapeKeyDown"; "pointerDownOutside": "pointerDownOutside"; "focusOutside": "focusOutside"; "interactOutside": "interactOutside"; "openAutoFocus": "openAutoFocus"; "closeAutoFocus": "closeAutoFocus"; }, never, never, true, [{ directive: typeof _radix_ng_primitives_core.RdxFloatingNodeRegistration; inputs: {}; outputs: {}; }, { directive: typeof i2.RdxFloatingFocusManager; inputs: {}; outputs: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxDialogPopup, "[rdxDialogPopup]", ["rdxDialogPopup"], {}, { "escapeKeyDown": "escapeKeyDown"; "pointerDownOutside": "pointerDownOutside"; "focusOutside": "focusOutside"; "interactOutside": "interactOutside"; "openAutoFocus": "openAutoFocus"; "closeAutoFocus": "closeAutoFocus"; }, never, never, true, [{ directive: typeof _radix_ng_primitives_core.RdxFloatingNodeRegistration; inputs: {}; outputs: {}; }, { directive: typeof _radix_ng_primitives_floating_focus_manager.RdxFloatingFocusManager; inputs: {}; outputs: {}; }]>;
 }
 
 /**

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

@@ -1,12 +1,18 @@
 import * as _angular_core from '@angular/core';
 import { Signal, WritableSignal } from '@angular/core';
 import * as _radix_ng_primitives_core from '@radix-ng/primitives/core';
-import { BooleanInput, NumberInput } from '@radix-ng/primitives/core';
+import { BooleanInput, NumberInput, RdxCancelableChangeEventDetails } from '@radix-ng/primitives/core';
 import * as i1 from '@radix-ng/primitives/dismissable-layer';
 import * as _radix_ng_primitives_editable from '@radix-ng/primitives/editable';
 
 type EditableActivationMode = 'focus' | 'dblclick' | 'none';
 type EditableSubmitMode = 'blur' | 'enter' | 'none' | 'both';
+type RdxEditableValueChangeReason = 'submit' | 'none';
+type RdxEditableValueChangeEventDetails = RdxCancelableChangeEventDetails<RdxEditableValueChangeReason>;
+interface RdxEditableValueChangeEvent {
+    value: string;
+    eventDetails: RdxEditableValueChangeEventDetails;
+}
 type EditableRootContext = {
     disabled: Signal<boolean>;
     value: Signal<string | undefined>;
@@ -20,7 +26,7 @@ type EditableRootContext = {
     activationMode: Signal<EditableActivationMode>;
     edit: () => void;
     cancel: () => void;
-    submit: () => void;
+    submit: (event?: Event) => void;
     maxLength: Signal<number | undefined>;
     required: Signal<boolean>;
     startWithEditMode: Signal<boolean>;
@@ -57,7 +63,7 @@ declare class RdxEditableRoot {
     readonly autoResize: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
     readonly required: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
     /** Emitted when the value is committed (on submit). */
-    readonly onValueChange: _angular_core.OutputEmitterRef<string>;
+    readonly onValueChange: _angular_core.OutputEmitterRef<RdxEditableValueChangeEvent>;
     readonly isEmpty: Signal<boolean>;
     readonly $placeholder: Signal<{
         edit: string;
@@ -75,7 +81,7 @@ declare class RdxEditableRoot {
     constructor();
     canActivateOnFocus(): boolean;
     handleDismiss(): void;
-    submit(): void;
+    submit(event?: Event): void;
     cancel(): void;
     edit(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxEditableRoot, never>;
@@ -144,4 +150,4 @@ declare class RdxEditableModule {
 }
 
 export { RdxEditableArea, RdxEditableCancelTrigger, RdxEditableEditTrigger, RdxEditableInput, RdxEditableModule, RdxEditablePreview, RdxEditableRoot, RdxEditableSubmitTrigger, injectEditableRootContext, provideEditableRootContext };
-export type { EditableActivationMode, EditableRootContext, EditableSubmitMode };
+export type { EditableActivationMode, EditableRootContext, EditableSubmitMode, RdxEditableValueChangeEvent, RdxEditableValueChangeEventDetails, RdxEditableValueChangeReason };

package/types/radix-ng-primitives-floating-focus-manager.d.ts

@@ -1,6 +1,6 @@
 import * as _angular_core from '@angular/core';
-import { InjectionToken, Provider } from '@angular/core';
-import { BooleanInput } from '@radix-ng/primitives/core';
+import { InjectionToken, Provider, Signal } from '@angular/core';
+import { RdxFloatingTree, BooleanInput } from '@radix-ng/primitives/core';
 import * as i1 from '@radix-ng/primitives/focus-scope';
 
 /**
@@ -9,25 +9,25 @@ import * as i1 from '@radix-ng/primitives/focus-scope';
  * (Base UI keys `preferPreviousFocus = openInteractionType == null` off exactly this).
  */
 type RdxInteractionType = 'mouse' | 'touch' | 'pen' | 'keyboard' | '' | null;
-/** A focus target: an element, a getter, or `null`. */
-type RdxFocusTarget = HTMLElement | (() => HTMLElement | null) | null;
+/** A focus target: an element, a getter, `null`, or `undefined` from a policy callback. */
+type RdxFocusTarget = HTMLElement | (() => HTMLElement | null) | null | undefined;
 /** `initialFocus` policy (ADR 0017 §2) — a target, `false`, or an open-interaction callback. */
 type RdxInitialFocus = RdxFocusTarget | false | ((openInteractionType: RdxInteractionType) => RdxFocusTarget | false);
 /** `returnFocus` policy (ADR 0017 §2) — a target/boolean or a callback receiving the **close** interaction type. */
-type RdxReturnFocus = RdxFocusTarget | boolean | ((closeInteractionType: RdxInteractionType) => RdxFocusTarget | boolean);
+type RdxReturnFocus = RdxFocusTarget | boolean | ((closeInteractionType: RdxInteractionType) => RdxFocusTarget | boolean | undefined);
 /** Normalizes a DOM event into Base UI-like interaction intent for focus policy decisions. */
 declare function getInteractionTypeFromEvent(event?: Event): RdxInteractionType;
 /** Resolves an {@link RdxFocusTarget} (element | getter | null) to a concrete element. */
-declare function resolveFocusTarget(target: RdxFocusTarget): HTMLElement | null;
+declare function resolveFocusTarget(target: RdxFocusTarget): HTMLElement | null | undefined;
 /**
  * Resolves an {@link RdxInitialFocus} policy against how the popup opened.
  */
-declare function resolveInitialFocus(policy: RdxInitialFocus, openInteractionType: RdxInteractionType): HTMLElement | null | false;
+declare function resolveInitialFocus(policy: RdxInitialFocus, openInteractionType: RdxInteractionType): HTMLElement | null | false | undefined;
 /**
  * Resolves an {@link RdxReturnFocus} policy against how the popup closed. `false` = do not return focus;
  * `true` = the default (return to the previously-focused element); an element = return there.
  */
-declare function resolveReturnFocus(policy: RdxReturnFocus, closeInteractionType: RdxInteractionType): HTMLElement | boolean | null;
+declare function resolveReturnFocus(policy: RdxReturnFocus, closeInteractionType: RdxInteractionType): HTMLElement | boolean | null | undefined;
 /**
  * DI seam for a **composing primitive** (Dialog / Popover / Menu) to drive the manager's gates from its
  * own root context instead of template-bound inputs (which a primitive cannot set). Each field falls
@@ -40,9 +40,18 @@ interface RdxFloatingFocusManagerConfig {
     closeOnFocusOut?: () => boolean;
     initialFocus?: () => RdxInitialFocus;
     returnFocus?: () => RdxReturnFocus;
+    restoreFocus?: () => boolean | 'popup';
+    previousFocusableElement?: () => RdxFocusTarget;
+    nextFocusableElement?: () => RdxFocusTarget;
+    beforeContentFocusGuardRef?: () => RdxFocusGuardRef | null | undefined;
+    externalTree?: () => RdxFloatingTree | null | undefined;
+    getInsideElements?: () => Array<Element | null | undefined>;
     openInteractionType?: () => RdxInteractionType;
     closeInteractionType?: () => RdxInteractionType;
 }
+type RdxFocusGuardRef = ((element: HTMLSpanElement | null) => void) | {
+    set: (element: HTMLSpanElement | null) => void;
+};
 declare const RDX_FLOATING_FOCUS_MANAGER_CONFIG: InjectionToken<RdxFloatingFocusManagerConfig>;
 /** Provides a {@link RdxFloatingFocusManagerConfig} for an enclosing primitive's focus manager. */
 declare function provideFloatingFocusManagerConfig(factory: () => RdxFloatingFocusManagerConfig): Provider;
@@ -61,8 +70,7 @@ declare function provideFloatingFocusManagerConfig(factory: () => RdxFloatingFoc
  * - `loop` is forwarded to `RdxFocusScope`.
  * - `initialFocus` / `returnFocus` are **orchestrated** here (the §2 policy contract, incl. the
  *   interaction-type callback forms): `initialFocus` via the scope's `mountAutoFocus` hook, `returnFocus`
- *   via the scope's `returnFocus` config seam (resolved at the scope's queued post-unmount frame). The
- *   portal-focus bridge remains a later-phase dependency.
+ *   via the scope's `returnFocus` config seam (resolved at the scope's queued post-unmount frame).
  */
 declare class RdxFloatingFocusManager {
     /** Manager active-ness (ADR 0017 §2): the popup is mounted **and** not hover-opened. */
@@ -75,9 +83,25 @@ declare class RdxFloatingFocusManager {
      */
     readonly inert: _angular_core.InputSignalWithTransform<boolean | undefined, BooleanInput>;
     /** Where focus goes when the popup opens (ADR 0017 §2). */
-    readonly initialFocus: _angular_core.InputSignal<RdxInitialFocus | undefined>;
+    readonly initialFocus: _angular_core.InputSignal<RdxInitialFocus>;
     /** Where focus returns when the popup closes (ADR 0017 §2). */
-    readonly returnFocus: _angular_core.InputSignal<RdxReturnFocus | undefined>;
+    readonly returnFocus: _angular_core.InputSignal<RdxReturnFocus>;
+    /**
+     * Restores focus inside the floating tree when the currently focused inside element is removed and
+     * the browser drops focus onto `<body>` (Base UI `restoreFocus`). `true` restores to the last
+     * available tabbable candidate, `'popup'` restores to the popup container.
+     */
+    readonly restoreFocus: _angular_core.InputSignal<boolean | "popup" | undefined>;
+    /** Overrides where backward tabbing out of a non-modal portaled popup lands. */
+    readonly previousFocusableElement: _angular_core.InputSignal<RdxFocusTarget>;
+    /** Overrides where forward tabbing out of a non-modal portaled popup lands. */
+    readonly nextFocusableElement: _angular_core.InputSignal<RdxFocusTarget>;
+    /** Optional callback/signal that receives the leading content focus guard. */
+    readonly beforeContentFocusGuardRef: _angular_core.InputSignal<RdxFocusGuardRef | null | undefined>;
+    /** Explicit floating tree for detached sibling composition (Base UI `externalTree`). */
+    readonly externalTree: _angular_core.InputSignal<RdxFloatingTree | null | undefined>;
+    /** Additional elements treated as inside the floating subtree (Base UI `getInsideElements`). */
+    readonly getInsideElements: _angular_core.InputSignal<(() => Array<Element | null | undefined>) | undefined>;
     /**
      * Whether a **non-modal** popup closes when focus leaves to an unrelated node (Base UI
      * `closeOnFocusOut`, default `true`; Dialog sets it to `!disablePointerDismissal`). Modal popups
@@ -98,7 +122,13 @@ declare class RdxFloatingFocusManager {
     readonly effectiveInert: _angular_core.Signal<boolean>;
     readonly effectiveCloseOnFocusOut: _angular_core.Signal<boolean>;
     readonly effectiveInitialFocus: _angular_core.Signal<false | HTMLElement | ((openInteractionType: RdxInteractionType) => RdxFocusTarget | false) | null>;
-    readonly effectiveReturnFocus: _angular_core.Signal<boolean | HTMLElement | ((closeInteractionType: RdxInteractionType) => RdxFocusTarget | boolean)>;
+    readonly effectiveReturnFocus: _angular_core.Signal<boolean | HTMLElement | ((closeInteractionType: RdxInteractionType) => RdxFocusTarget | boolean | undefined)>;
+    readonly effectiveRestoreFocus: _angular_core.Signal<boolean | "popup">;
+    readonly effectivePreviousFocusableElement: _angular_core.Signal<RdxFocusTarget>;
+    readonly effectiveNextFocusableElement: _angular_core.Signal<RdxFocusTarget>;
+    readonly effectiveBeforeContentFocusGuardRef: _angular_core.Signal<RdxFocusGuardRef | null | undefined>;
+    readonly effectiveExternalTree: _angular_core.Signal<RdxFloatingTree | null>;
+    readonly insideElements: _angular_core.Signal<Element[]>;
     readonly effectiveOpenInteractionType: _angular_core.Signal<RdxInteractionType>;
     readonly effectiveCloseInteractionType: _angular_core.Signal<RdxInteractionType>;
     /** The effective trap state the composed `RdxFocusScope` reads via its config token. */
@@ -155,6 +185,17 @@ declare class RdxFloatingFocusManager {
      * `FloatingFocusManager` `!modal` branch (`movedToUnrelatedNode`).
      */
     private wireCloseOnFocusOut;
+    /**
+     * Restore focus when an inside focused element disappears and the document focus falls back to
+     * `<body>`. This mirrors the practical Base UI `restoreFocus` path used by Select while keeping the
+     * broader portal-guard navigation separate.
+     */
+    private wireRestoreFocus;
+    /**
+     * Portal focus bridge (Base UI inside guards): when focus reaches the hidden guards around portaled
+     * content, redirect it either back inside the popup or to the configured neighboring tabbable node.
+     */
+    private wirePortalFocusBridge;
     /**
      * The marker keep-set is intentionally narrow: the popup/focus host only. Own sibling roots such as a
      * user backdrop are DOM-footprint bookkeeping, not marker keep-set members.
@@ -164,12 +205,68 @@ declare class RdxFloatingFocusManager {
     /** Whether `relatedTarget` is inside the popup, its trigger(s), or an ancestor / descendant popup. */
     private isRelatedTargetInside;
     private contextContains;
+    private currentFloatingNode;
+    private getTabbableContent;
+    private portalFocusContainer;
+    private defaultPreviousFocusable;
+    private defaultNextFocusable;
+    private setBeforeContentFocusGuardRef;
+    private isFromOutsideFocusGuard;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxFloatingFocusManager, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxFloatingFocusManager, "[rdxFloatingFocusManager]", ["rdxFloatingFocusManager"], { "enabled": { "alias": "enabled"; "required": false; "isSignal": true; }; "modal": { "alias": "modal"; "required": false; "isSignal": true; }; "inert": { "alias": "inert"; "required": false; "isSignal": true; }; "initialFocus": { "alias": "initialFocus"; "required": false; "isSignal": true; }; "returnFocus": { "alias": "returnFocus"; "required": false; "isSignal": true; }; "closeOnFocusOut": { "alias": "closeOnFocusOut"; "required": false; "isSignal": true; }; }, { "focusOut": "focusOut"; }, never, never, true, [{ directive: typeof i1.RdxFocusScope; inputs: { "loop": "loop"; }; outputs: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxFloatingFocusManager, "[rdxFloatingFocusManager]", ["rdxFloatingFocusManager"], { "enabled": { "alias": "enabled"; "required": false; "isSignal": true; }; "modal": { "alias": "modal"; "required": false; "isSignal": true; }; "inert": { "alias": "inert"; "required": false; "isSignal": true; }; "initialFocus": { "alias": "initialFocus"; "required": false; "isSignal": true; }; "returnFocus": { "alias": "returnFocus"; "required": false; "isSignal": true; }; "restoreFocus": { "alias": "restoreFocus"; "required": false; "isSignal": true; }; "previousFocusableElement": { "alias": "previousFocusableElement"; "required": false; "isSignal": true; }; "nextFocusableElement": { "alias": "nextFocusableElement"; "required": false; "isSignal": true; }; "beforeContentFocusGuardRef": { "alias": "beforeContentFocusGuardRef"; "required": false; "isSignal": true; }; "externalTree": { "alias": "externalTree"; "required": false; "isSignal": true; }; "getInsideElements": { "alias": "getInsideElements"; "required": false; "isSignal": true; }; "closeOnFocusOut": { "alias": "closeOnFocusOut"; "required": false; "isSignal": true; }; }, { "focusOut": "focusOut"; }, never, never, true, [{ directive: typeof i1.RdxFocusScope; inputs: { "loop": "loop"; }; outputs: {}; }]>;
 }
 
 /** The neutral "outside the active floating layer" marker (Base UI `data-base-ui-inert`). */
 declare const RDX_FLOATING_MARKER = "data-rdx-floating-inert";
 
-export { RDX_FLOATING_FOCUS_MANAGER_CONFIG, RDX_FLOATING_MARKER, RdxFloatingFocusManager, getInteractionTypeFromEvent, provideFloatingFocusManagerConfig, resolveFocusTarget, resolveInitialFocus, resolveReturnFocus };
-export type { RdxFloatingFocusManagerConfig, RdxFocusTarget, RdxInitialFocus, RdxInteractionType, RdxReturnFocus };
+interface RdxTriggerInteractionOptions {
+    trigger: () => HTMLElement;
+    open: () => boolean;
+    activeTrigger?: () => HTMLElement | null | undefined;
+    disabled?: () => boolean;
+    contentId?: () => string | null | undefined;
+}
+interface RdxTriggerInteraction {
+    readonly lastPointerType: Signal<string>;
+    readonly isActive: Signal<boolean>;
+    readonly isInactive: Signal<boolean>;
+    readonly dataState: Signal<'open' | 'closed'>;
+    readonly dataPopupOpen: Signal<'' | undefined>;
+    readonly ariaControls: Signal<string | undefined>;
+    readonly ariaExpanded: Signal<boolean>;
+    readonly disabled: Signal<boolean>;
+    recordPointerDown: (event: PointerEvent) => void;
+    clickInteractionType: (event: MouseEvent) => RdxInteractionType;
+}
+interface RdxTriggerFocusGuardOptions {
+    trigger: () => HTMLElement;
+    close: (event: FocusEvent) => void;
+    beforeContentFocusGuard?: () => HTMLElement | null | undefined;
+    contentId?: () => string | null | undefined;
+    enabled?: () => boolean;
+    popupElement?: () => HTMLElement | null | undefined;
+}
+interface RdxTriggerFocusGuardAnchorOptions {
+    trigger: () => HTMLElement;
+    contentId: () => string | null | undefined;
+    enabled?: () => boolean;
+}
+/**
+ * Shared trigger state for floating primitives. It intentionally stays small: each primitive still owns
+ * its open/close business rules, while this layer normalizes active-trigger state and the open method
+ * signal that must be captured before the popup/focus manager mounts.
+ */
+declare function createRdxTriggerInteraction(options: RdxTriggerInteractionOptions): RdxTriggerInteraction;
+/**
+ * Adds Base UI's trigger-side focus guards for portaled content. The content guards remain owned by
+ * `RdxFloatingFocusManager`; these guards bridge tab order from the trigger into the portal and close the
+ * popup when focus leaves past either trigger-side boundary.
+ */
+declare function useTriggerFocusGuards(options: RdxTriggerFocusGuardOptions): void;
+/**
+ * Backwards-compatible aria-owns-only bridge for modal popups that do not need trigger-side tab guards.
+ */
+declare function useTriggerFocusGuardAnchor(options: RdxTriggerFocusGuardAnchorOptions): void;
+
+export { RDX_FLOATING_FOCUS_MANAGER_CONFIG, RDX_FLOATING_MARKER, RdxFloatingFocusManager, createRdxTriggerInteraction, getInteractionTypeFromEvent, provideFloatingFocusManagerConfig, resolveFocusTarget, resolveInitialFocus, resolveReturnFocus, useTriggerFocusGuardAnchor, useTriggerFocusGuards };
+export type { RdxFloatingFocusManagerConfig, RdxFocusGuardRef, RdxFocusTarget, RdxInitialFocus, RdxInteractionType, RdxReturnFocus, RdxTriggerFocusGuardAnchorOptions, RdxTriggerFocusGuardOptions, RdxTriggerInteraction, RdxTriggerInteractionOptions };

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

@@ -2,7 +2,7 @@ import * as _angular_core from '@angular/core';
 import { Signal, WritableSignal } from '@angular/core';
 import * as _radix_ng_primitives_core from '@radix-ng/primitives/core';
 import { RdxFloatingRootContext, BooleanInput, Direction, RdxCancelableChangeEventDetails, NumberInput } from '@radix-ng/primitives/core';
-import * as i3 from '@radix-ng/primitives/floating-focus-manager';
+import * as _radix_ng_primitives_floating_focus_manager from '@radix-ng/primitives/floating-focus-manager';
 import { RdxInteractionType } from '@radix-ng/primitives/floating-focus-manager';
 import * as i1 from '@radix-ng/primitives/popper';
 import { RdxPopperContentWrapper } from '@radix-ng/primitives/popper';
@@ -71,6 +71,7 @@ interface RdxMenuRootContext {
     trigger: Signal<HTMLElement | undefined>;
     /** The popup element, once mounted. Used by submenu safe-polygon geometry. */
     popupElement: Signal<HTMLElement | undefined>;
+    beforeContentFocusGuard: Signal<HTMLElement | null>;
     transitionStatus: Signal<RdxMenuTransitionStatus>;
     close: (reason?: RdxMenuOpenChangeReason, event?: Event) => void;
     /** Close this menu and every ancestor — used by item selection (the whole menu dismisses). */
@@ -81,6 +82,7 @@ interface RdxMenuRootContext {
     showWithoutAutoFocus: (reason?: RdxMenuOpenChangeReason, event?: Event) => void;
     registerTrigger: (el: HTMLElement) => () => void;
     registerPopup: (el: HTMLElement) => () => void;
+    setBeforeContentFocusGuard: (element: HTMLElement | null) => void;
     registerTransitionElement: (element: HTMLElement) => () => void;
     registerPopupArrowNavigationHandler: (handler: (offset: 1 | -1) => boolean) => () => void;
     registerTriggerInteractionHandler: (handler: RdxMenuTriggerInteractionHandler) => () => void;
@@ -174,6 +176,7 @@ declare class RdxMenuRoot {
     readonly onOpenChangeComplete: _angular_core.OutputEmitterRef<boolean>;
     readonly trigger: _angular_core.WritableSignal<HTMLElement | undefined>;
     readonly popupElement: _angular_core.WritableSignal<HTMLElement | undefined>;
+    readonly beforeContentFocusGuard: _angular_core.WritableSignal<HTMLElement | null>;
     readonly transitionStatus: Signal<_radix_ng_primitives_core.RdxTransitionStatus>;
     /** Whether the popup grabs focus when it opens. Set false for menubar hover-switching. */
     readonly autoFocus: _angular_core.WritableSignal<RdxMenuAutoFocus>;
@@ -214,6 +217,7 @@ declare class RdxMenuRoot {
     closeEntireMenu(reason?: RdxMenuOpenChangeReason, event?: Event): void;
     registerTrigger(el: HTMLElement): () => void;
     registerPopup(el: HTMLElement): () => void;
+    setBeforeContentFocusGuard(element: HTMLElement | null): void;
     registerTransitionElement(element: HTMLElement): () => void;
     registerPopupArrowNavigationHandler(handler: (offset: 1 | -1) => boolean): () => void;
     handlePopupArrowNavigation(offset: 1 | -1): boolean;
@@ -253,8 +257,10 @@ declare class RdxMenuTrigger {
     readonly closeDelay: _angular_core.InputSignalWithTransform<number | undefined, NumberInput>;
     protected readonly nativeButtonState: _angular_core.Signal<boolean>;
     protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly triggerInteraction: _radix_ng_primitives_floating_focus_manager.RdxTriggerInteraction;
     constructor();
     protected handleMouseDown(event: MouseEvent): void;
+    protected handlePointerDown(event: PointerEvent): void;
     protected handleClick(event: MouseEvent): void;
     protected handleArrowDown(event: Event): void;
     protected handleArrowUp(event: Event): void;
@@ -416,7 +422,7 @@ declare class RdxMenuPopup {
     private scheduleSubmenuKeyboardFocus;
     private applySubmenuKeyboardFocus;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxMenuPopup, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxMenuPopup, "[rdxMenuPopup]", ["rdxMenuPopup"], {}, { "escapeKeyDown": "escapeKeyDown"; "pointerDownOutside": "pointerDownOutside"; "focusOutside": "focusOutside"; "interactOutside": "interactOutside"; "openAutoFocus": "openAutoFocus"; "closeAutoFocus": "closeAutoFocus"; }, never, never, true, [{ directive: typeof i1.RdxPopperContent; inputs: {}; outputs: {}; }, { directive: typeof _radix_ng_primitives_core.RdxFloatingNodeRegistration; inputs: {}; outputs: {}; }, { directive: typeof i3.RdxFloatingFocusManager; inputs: {}; outputs: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxMenuPopup, "[rdxMenuPopup]", ["rdxMenuPopup"], {}, { "escapeKeyDown": "escapeKeyDown"; "pointerDownOutside": "pointerDownOutside"; "focusOutside": "focusOutside"; "interactOutside": "interactOutside"; "openAutoFocus": "openAutoFocus"; "closeAutoFocus": "closeAutoFocus"; }, never, never, true, [{ directive: typeof i1.RdxPopperContent; inputs: {}; outputs: {}; }, { directive: typeof _radix_ng_primitives_core.RdxFloatingNodeRegistration; inputs: {}; outputs: {}; }, { directive: typeof _radix_ng_primitives_floating_focus_manager.RdxFloatingFocusManager; inputs: {}; outputs: {}; }]>;
 }
 
 /**

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

@@ -1,7 +1,7 @@
 import * as _angular_core from '@angular/core';
 import { Signal } from '@angular/core';
 import * as _radix_ng_primitives_core from '@radix-ng/primitives/core';
-import { RdxFormValueControl, RdxControlValueAccessor, NumberInput, BooleanInput } from '@radix-ng/primitives/core';
+import { RdxFormValueControl, RdxControlValueAccessor, NumberInput, BooleanInput, RdxCancelableChangeEventDetails } 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 from '@radix-ng/primitives/portal';
@@ -35,6 +35,11 @@ declare const REASONS: {
     readonly none: "none";
 };
 
+type RdxNumberFieldValueChangeEventDetails = RdxCancelableChangeEventDetails<NumberFieldChangeReason>;
+interface RdxNumberFieldValueChangeEvent {
+    value: number | null;
+    eventDetails: RdxNumberFieldValueChangeEventDetails;
+}
 /**
  * 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
@@ -110,7 +115,7 @@ declare class RdxNumberFieldRoot implements RdxFormValueControl<number | null> {
     /** 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>;
+    readonly onValueChange: _angular_core.OutputEmitterRef<RdxNumberFieldValueChangeEvent>;
     /**
      * 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.
@@ -461,4 +466,4 @@ declare class 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 };
+export type { Direction, InputMode, NumberFieldChangeReason, PressAndHold, PressAndHoldOptions, RdxNumberFieldScrubAreaContext, RdxNumberFieldValueChangeEvent, RdxNumberFieldValueChangeEventDetails, ValidateOptions };

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

@@ -3,11 +3,12 @@ import { Signal, ElementRef } from '@angular/core';
 import * as i1 from '@radix-ng/primitives/portal';
 import * as _radix_ng_primitives_core from '@radix-ng/primitives/core';
 import { RdxTransitionStatus, RdxFloatingRootContext, BooleanInput, RdxCancelableChangeEventDetails, NumberInput } from '@radix-ng/primitives/core';
+import * as _radix_ng_primitives_floating_focus_manager from '@radix-ng/primitives/floating-focus-manager';
+import { RdxInteractionType } from '@radix-ng/primitives/floating-focus-manager';
 import * as i1$1 from '@radix-ng/primitives/popper';
 import { RdxPopperContentWrapper } from '@radix-ng/primitives/popper';
 import * as _radix_ng_primitives_popover from '@radix-ng/primitives/popover';
 import { RdxOutsidePressDomEvent } from '@radix-ng/primitives/dismissable-layer';
-import * as i3 from '@radix-ng/primitives/floating-focus-manager';
 
 /**
  * Structural directive that teleports the popover content into a container (default `document.body`)
@@ -73,6 +74,8 @@ interface RdxPopoverRootContext {
     isPointerDownOnTrigger: Signal<boolean>;
     /** Whether the current open was initiated by touch (ADR 0016 §3 — gates the anchored scroll lock). */
     openedByTouch: Signal<boolean>;
+    openInteractionType: Signal<RdxInteractionType>;
+    closeInteractionType: Signal<RdxInteractionType>;
     close: (reason?: RdxPopoverOpenChangeReason, event?: Event) => void;
     cancelHoverClose: () => void;
     cancelHoverOpen: () => void;
@@ -85,11 +88,14 @@ interface RdxPopoverRootContext {
     setTitleId: (id: string | undefined) => void;
     setPointerDownOnTrigger: (pointerDown: boolean) => void;
     setOpenedByTouch: (value: boolean) => void;
+    setTriggerOpenInteractionType: (type: RdxInteractionType) => void;
     setHoverDelays: (delay: number, closeDelay: number) => void;
     registerPopupClose: () => () => void;
     registerTransitionElement: (element: HTMLElement) => () => void;
     transitionStatus: Signal<RdxPopoverTransitionStatus>;
+    beforeContentFocusGuard: Signal<HTMLElement | null>;
     registerViewport: (onTriggerChange: (previous: HTMLElement, next: HTMLElement) => void) => () => void;
+    setBeforeContentFocusGuard: (element: HTMLElement | null) => void;
     toggle: (triggerId: string, trigger: HTMLElement, payload?: unknown, event?: Event) => void;
 }
 declare const injectRdxPopoverRootContext: _radix_ng_primitives_core.InjectContext<RdxPopoverRootContext>;
@@ -140,6 +146,7 @@ declare class RdxPopoverRoot {
      */
     readonly handle: _angular_core.InputSignal<RdxPopoverHandle<any> | undefined>;
     readonly contentId: string;
+    readonly beforeContentFocusGuard: _angular_core.WritableSignal<HTMLElement | null>;
     readonly descriptionId: _angular_core.WritableSignal<string | undefined>;
     readonly titleId: _angular_core.WritableSignal<string | undefined>;
     readonly trigger: _angular_core.WritableSignal<HTMLElement | undefined>;
@@ -148,8 +155,11 @@ declare class RdxPopoverRoot {
     readonly isPointerDownOnTrigger: _angular_core.WritableSignal<boolean>;
     /** Whether the current open was initiated by touch (ADR 0016 §3 — gates the anchored scroll lock). */
     readonly openedByTouch: _angular_core.WritableSignal<boolean>;
+    readonly openInteractionType: _angular_core.WritableSignal<RdxInteractionType>;
+    readonly closeInteractionType: _angular_core.WritableSignal<RdxInteractionType>;
     readonly popupCloseCount: _angular_core.WritableSignal<number>;
     private readonly preventUnmountOnClose;
+    private readonly pendingTriggerOpenInteractionType;
     readonly onOpenChange: _angular_core.OutputEmitterRef<RdxPopoverOpenChange>;
     readonly onOpenChangeComplete: _angular_core.OutputEmitterRef<boolean>;
     private readonly registeredTriggers;
@@ -165,8 +175,10 @@ declare class RdxPopoverRoot {
     cancelHoverClose(): void;
     cancelHoverOpen(): void;
     setHoverDelays(delay: number, closeDelay: number): void;
+    setTriggerOpenInteractionType(type: RdxInteractionType): void;
     registerTrigger(id: string, trigger: HTMLElement, payload: () => unknown): () => void;
     registerViewport(onTriggerChange: (previous: HTMLElement, next: HTMLElement) => void): () => boolean;
+    setBeforeContentFocusGuard(element: HTMLElement | null): void;
     registerTransitionElement(element: HTMLElement): () => void;
     private syncTriggerId;
     private createOpenChangeEvent;
@@ -174,6 +186,7 @@ declare class RdxPopoverRoot {
     private clearOpenTimer;
     private clearCloseTimer;
     private scheduleInstantReset;
+    private consumeOpenInteractionType;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxPopoverRoot, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxPopoverRoot, "[rdxPopoverRoot]", ["rdxPopoverRoot"], { "open": { "alias": "open"; "required": false; "isSignal": true; }; "defaultOpen": { "alias": "defaultOpen"; "required": false; "isSignal": true; }; "triggerId": { "alias": "triggerId"; "required": false; "isSignal": true; }; "defaultTriggerId": { "alias": "defaultTriggerId"; "required": false; "isSignal": true; }; "modal": { "alias": "modal"; "required": false; "isSignal": true; }; "handle": { "alias": "handle"; "required": false; "isSignal": true; }; }, { "open": "openChange"; "triggerId": "triggerIdChange"; "onOpenChange": "onOpenChange"; "onOpenChangeComplete": "onOpenChangeComplete"; }, never, never, true, [{ directive: typeof i1$1.RdxPopper; inputs: {}; outputs: {}; }]>;
 }
@@ -184,8 +197,6 @@ declare class RdxPopoverRoot {
 declare class RdxPopoverTrigger {
     private readonly parentRootContext;
     readonly elementRef: ElementRef<HTMLElement>;
-    /** Pointer type of the most recent `pointerdown`, used to detect a touch open (ADR 0016 §3). */
-    private lastPointerType;
     /**
      * Associates this trigger with a detached popover root.
      */
@@ -217,6 +228,7 @@ declare class RdxPopoverTrigger {
     protected readonly triggerId: _angular_core.Signal<string>;
     protected readonly rootContext: _angular_core.Signal<_radix_ng_primitives_popover.RdxPopoverRootContext | null>;
     protected readonly isOpen: _angular_core.Signal<boolean>;
+    protected readonly triggerInteraction: _radix_ng_primitives_floating_focus_manager.RdxTriggerInteraction;
     protected readonly isPressed: _angular_core.Signal<boolean>;
     private readonly generatedId;
     constructor();
@@ -272,8 +284,8 @@ declare class RdxPopoverPositioner extends RdxPopperContentWrapper {
  * - No `disablePointerDismissal` — outside-press + focus-out always close.
  *
  * Note: a positioned popover does **not** auto-focus into the popup on open (pre-existing — the legacy
- * behaved the same; verified). The trap holds focus once it is inside. Auto-focus-on-open + redirecting a
- * Tab from the trigger into the popup needs the deferred portal-focus bridge / guards (ADR 0017 §6a).
+ * behaved the same; verified). The trap holds focus once it is inside; portal tab-order handoff is owned
+ * by `RdxFloatingFocusManager` and anchored to the active trigger below.
  */
 declare class RdxPopoverPopup {
     protected readonly rootContext: _radix_ng_primitives_popover.RdxPopoverRootContext;
@@ -299,7 +311,7 @@ declare class RdxPopoverPopup {
     readonly closeAutoFocus: _angular_core.OutputRef<Event>;
     constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxPopoverPopup, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxPopoverPopup, "[rdxPopoverPopup]", never, {}, { "escapeKeyDown": "escapeKeyDown"; "pointerDownOutside": "pointerDownOutside"; "focusOutside": "focusOutside"; "interactOutside": "interactOutside"; "openAutoFocus": "openAutoFocus"; "closeAutoFocus": "closeAutoFocus"; }, never, never, true, [{ directive: typeof i1$1.RdxPopperContent; inputs: {}; outputs: {}; }, { directive: typeof _radix_ng_primitives_core.RdxFloatingNodeRegistration; inputs: {}; outputs: {}; }, { directive: typeof i3.RdxFloatingFocusManager; inputs: {}; outputs: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxPopoverPopup, "[rdxPopoverPopup]", never, {}, { "escapeKeyDown": "escapeKeyDown"; "pointerDownOutside": "pointerDownOutside"; "focusOutside": "focusOutside"; "interactOutside": "interactOutside"; "openAutoFocus": "openAutoFocus"; "closeAutoFocus": "closeAutoFocus"; }, never, never, true, [{ directive: typeof i1$1.RdxPopperContent; inputs: {}; outputs: {}; }, { directive: typeof _radix_ng_primitives_core.RdxFloatingNodeRegistration; inputs: {}; outputs: {}; }, { directive: typeof _radix_ng_primitives_floating_focus_manager.RdxFloatingFocusManager; inputs: {}; outputs: {}; }]>;
 }
 
 /**

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

@@ -1,7 +1,7 @@
 import * as _angular_core from '@angular/core';
 import { ModelSignal, InputSignal, InputSignalWithTransform, Signal, InjectionToken } from '@angular/core';
 import { ControlValueAccessor } from '@angular/forms';
-import { BooleanInput, RdxFormValueControl } from '@radix-ng/primitives/core';
+import { BooleanInput, RdxFormValueControl, RdxCancelableChangeEventDetails } 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';
@@ -18,12 +18,18 @@ interface RadioGroupProps {
     disabledState: Signal<boolean>;
 }
 interface RadioGroupDirective extends RadioGroupProps {
-    select(value: string | null): void;
+    select(value: string | null, event?: Event, reason?: string): void;
     onTouched(): void;
     setArrowNavigation(value: boolean): void;
     isArrowNavigation(): boolean;
 }
 
+type RdxRadioValueChangeReason = 'trigger-press' | 'keyboard' | 'focus' | 'none';
+type RdxRadioValueChangeEventDetails = RdxCancelableChangeEventDetails<RdxRadioValueChangeReason>;
+interface RdxRadioValueChangeEvent {
+    value: string;
+    eventDetails: RdxRadioValueChangeEventDetails;
+}
 declare class RdxRadioGroupDirective implements RadioGroupProps, RadioGroupDirective, ControlValueAccessor, RdxFormValueControl<string | null> {
     readonly value: _angular_core.ModelSignal<string | null>;
     readonly defaultValue: _angular_core.InputSignal<string | undefined>;
@@ -36,7 +42,7 @@ declare class RdxRadioGroupDirective implements RadioGroupProps, RadioGroupDirec
     /**
      * Event handler called when the value changes.
      */
-    readonly onValueChange: _angular_core.OutputEmitterRef<string>;
+    readonly onValueChange: _angular_core.OutputEmitterRef<RdxRadioValueChangeEvent>;
     private readonly disable;
     readonly disabledState: _angular_core.Signal<boolean>;
     private readonly arrowNavigation;
@@ -55,7 +61,7 @@ declare class RdxRadioGroupDirective implements RadioGroupProps, RadioGroupDirec
      * @param value The value of the radio item to select.
      * @ignore
      */
-    select(value: string | null): void;
+    select(value: string | null, event?: Event, reason?: RdxRadioValueChangeReason): void;
     /**
      * Update the value of the radio group.
      * @param value The new value of the radio group.
@@ -107,13 +113,13 @@ declare class RdxRadioItemDirective {
     private readonly ARROW_KEYS;
     constructor();
     /** @ignore */
-    onClick(): void;
+    onClick(event?: Event): void;
     /** @ignore */
     onKeyDown(event: Event): void;
     /** @ignore */
     onKeyUp(): void;
     /** @ignore */
-    onFocus(): void;
+    onFocus(event?: FocusEvent): void;
     private isAllowedArrowKey;
     private createHiddenInput;
     private syncHiddenInput;
@@ -146,3 +152,4 @@ declare class RdxRadioItemInputDirective {
 }
 
 export { RdxRadioGroupDirective, RdxRadioIndicatorDirective, RdxRadioItemDirective, RdxRadioItemInputDirective, RdxRadioItemToken, injectRadioItem };
+export type { RdxRadioValueChangeEvent, RdxRadioValueChangeEventDetails, RdxRadioValueChangeReason };