@radix-ng/primitives 0.42.0 → 0.44.0

package/popper/index.d.ts

@@ -0,0 +1,206 @@
+import * as _angular_core from '@angular/core';
+import { ElementRef } from '@angular/core';
+import { NumberInput, BooleanInput } from '@angular/cdk/coercion';
+import { Middleware, Placement } from '@floating-ui/dom';
+
+declare class RdxPopperAnchor {
+    readonly elementRef: ElementRef<HTMLElement>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxPopperAnchor, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxPopperAnchor, "[rdxPopperAnchor]", never, {}, {}, never, never, true, never>;
+}
+
+declare class RdxPopper {
+    readonly anchor: _angular_core.Signal<RdxPopperAnchor>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxPopper, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxPopper, "[rdxPopperRoot]", never, {}, {}, ["anchor"], never, true, never>;
+}
+
+declare class RdxPopperContent {
+    protected readonly popperContentWrapper: {
+        placedSide: _angular_core.Signal<"top" | "right" | "bottom" | "left" | undefined>;
+        placedAlign: _angular_core.Signal<"start" | "center" | "end" | undefined>;
+        arrowX: _angular_core.Signal<number | undefined>;
+        arrowY: _angular_core.Signal<number | undefined>;
+        shouldHideArrow: _angular_core.Signal<boolean>;
+        isPositioned: _angular_core.Signal<boolean>;
+    };
+    /**
+     * if the PopperContent hasn't been placed yet (not all measurements done)
+     * we prevent animations so that users's animation don't kick in too early referring wrong sides
+     */
+    protected readonly style: _angular_core.Signal<{
+        animation: string | undefined;
+    }>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxPopperContent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxPopperContent, "[rdxPopperContent]", never, {}, {}, never, never, true, never>;
+}
+
+declare const SIDE_OPTIONS: readonly ["top", "right", "bottom", "left"];
+declare const ALIGN_OPTIONS: readonly ["start", "center", "end"];
+type Side = (typeof SIDE_OPTIONS)[number];
+type Align = (typeof ALIGN_OPTIONS)[number];
+declare function isNotNull<T>(value: T | null): value is T;
+declare function transformOrigin(options: {
+    arrowWidth: number;
+    arrowHeight: number;
+}): Middleware;
+declare function getSideAndAlignFromPlacement(placement: Placement): readonly ["top" | "right" | "bottom" | "left", "start" | "center" | "end"];
+
+declare const context: () => {
+    placedSide: _angular_core.Signal<"top" | "right" | "bottom" | "left" | undefined>;
+    placedAlign: _angular_core.Signal<"start" | "center" | "end" | undefined>;
+    arrowX: _angular_core.Signal<number | undefined>;
+    arrowY: _angular_core.Signal<number | undefined>;
+    shouldHideArrow: _angular_core.Signal<boolean>;
+    isPositioned: _angular_core.Signal<boolean>;
+};
+type PopperContentWrapperContext = ReturnType<typeof context>;
+declare const injectPopperContentWrapperContext: (optional?: boolean) => {
+    placedSide: _angular_core.Signal<"top" | "right" | "bottom" | "left" | undefined>;
+    placedAlign: _angular_core.Signal<"start" | "center" | "end" | undefined>;
+    arrowX: _angular_core.Signal<number | undefined>;
+    arrowY: _angular_core.Signal<number | undefined>;
+    shouldHideArrow: _angular_core.Signal<boolean>;
+    isPositioned: _angular_core.Signal<boolean>;
+} | null;
+declare const providePopperContentWrapperContext: (useFactory: () => {
+    placedSide: _angular_core.Signal<"top" | "right" | "bottom" | "left" | undefined>;
+    placedAlign: _angular_core.Signal<"start" | "center" | "end" | undefined>;
+    arrowX: _angular_core.Signal<number | undefined>;
+    arrowY: _angular_core.Signal<number | undefined>;
+    shouldHideArrow: _angular_core.Signal<boolean>;
+    isPositioned: _angular_core.Signal<boolean>;
+}) => _angular_core.Provider;
+declare class RdxPopperContentWrapper {
+    private readonly elementRef;
+    private readonly destroyRef;
+    private readonly injector;
+    private readonly context;
+    private readonly isBrowser;
+    /**
+     * The preferred side of the anchor to render against when open.
+     * Will be reversed when collisions occur and avoidCollisions is enabled.
+     */
+    readonly side: _angular_core.InputSignal<"top" | "right" | "bottom" | "left">;
+    /**
+     * Distance between the anchor and the popup in pixels.
+     */
+    readonly sideOffset: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    /**
+     * How to align the popup relative to the specified side. May change when collisions occur.
+     */
+    readonly align: _angular_core.InputSignal<"start" | "center" | "end">;
+    /** An offset in pixels from the `start` or `end` alignment options. */
+    readonly alignOffset: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    /**
+     * Minimum distance to maintain between the arrow and the edges of the popup.
+     * If your content has border-radius, this will prevent it from overflowing the corners.
+     */
+    readonly arrowPadding: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    /** When `true`, overrides the `side` and `align` preferences to prevent collisions with boundary edges. */
+    readonly avoidCollisions: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * The element used as the collision boundary.
+     * By default this is the viewport, though you can provide additional element(s) to be included in this check.
+     */
+    readonly collisionBoundary: _angular_core.InputSignal<ElementRef<HTMLElement> | ElementRef<HTMLElement>[] | undefined>;
+    /**
+     * The distance in pixels from the boundary edges where collision detection should occur.
+     * Accepts a number (same for all sides), or a partial padding object, for example: `{ top: 20, left: 20 }`.
+     */
+    readonly collisionPadding: _angular_core.InputSignal<number | Partial<Record<"top" | "right" | "bottom" | "left", number>>>;
+    /**
+     * The sticky behavior on the align axis. `partial` will keep the
+     * content in the boundary as long as the trigger is at least partially
+     * in the boundary whilst "always" will keep the content in the boundary
+     * regardless.
+     */
+    readonly sticky: _angular_core.InputSignal<"partial" | "always">;
+    /**
+     * Whether to hide the content when the trigger becomes fully occluded.
+     */
+    readonly hideWhenDetached: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     *  The type of CSS position property to use.
+     */
+    readonly positionStrategy: _angular_core.InputSignal<"fixed" | "absolute">;
+    /**
+     * Strategy to update the position of the floating element on every animation frame.
+     */
+    readonly updatePositionStrategy: _angular_core.InputSignal<"always" | "optimized">;
+    /**
+     * Emits when the element is placed.
+     */
+    readonly placed: _angular_core.OutputEmitterRef<void>;
+    readonly arrow: _angular_core.Signal<any>;
+    readonly shouldHideArrow: _angular_core.Signal<boolean>;
+    readonly arrowX: _angular_core.Signal<number | undefined>;
+    readonly arrowY: _angular_core.Signal<number | undefined>;
+    private readonly desiredPlacement;
+    private readonly arrowSize;
+    private readonly boundary;
+    private readonly hasExplicitBoundaries;
+    private readonly detectOverflowOptions;
+    private readonly position;
+    /**
+     * Whether the panel is positioned.
+     */
+    readonly isPositioned: _angular_core.Signal<boolean>;
+    /**
+     * The current placement of the panel.
+     */
+    readonly placement: _angular_core.Signal<{
+        side: Side;
+        align: Align;
+    } | undefined>;
+    /**
+     * The side the panel is currently placed against.
+     */
+    readonly placedSide: _angular_core.Signal<"top" | "right" | "bottom" | "left" | undefined>;
+    /**
+     * The current alignment of the panel.
+     */
+    readonly placedAlign: _angular_core.Signal<"start" | "center" | "end" | undefined>;
+    private readonly contentElementRef;
+    protected readonly contentZIndex: _angular_core.Signal<string | 0>;
+    protected readonly style: _angular_core.Signal<{
+        visibility: string;
+        pointerEvents: string;
+        position: "fixed" | "absolute";
+        transform: string;
+        minWidth: string;
+        zIndex: string | number;
+        top: string;
+        left: string;
+        '--radix-popper-transform-origin': string;
+    }>;
+    private readonly afterNextRender;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxPopperContentWrapper, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxPopperContentWrapper, "[rdxPopperContentWrapper]", never, { "side": { "alias": "side"; "required": false; "isSignal": true; }; "sideOffset": { "alias": "sideOffset"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "alignOffset": { "alias": "alignOffset"; "required": false; "isSignal": true; }; "arrowPadding": { "alias": "arrowPadding"; "required": false; "isSignal": true; }; "avoidCollisions": { "alias": "avoidCollisions"; "required": false; "isSignal": true; }; "collisionBoundary": { "alias": "collisionBoundary"; "required": false; "isSignal": true; }; "collisionPadding": { "alias": "collisionPadding"; "required": false; "isSignal": true; }; "sticky": { "alias": "sticky"; "required": false; "isSignal": true; }; "hideWhenDetached": { "alias": "hideWhenDetached"; "required": false; "isSignal": true; }; "positionStrategy": { "alias": "positionStrategy"; "required": false; "isSignal": true; }; "updatePositionStrategy": { "alias": "updatePositionStrategy"; "required": false; "isSignal": true; }; }, { "placed": "placed"; }, ["arrow", "contentElementRef"], never, true, never>;
+}
+
+declare class RdxPopperArrow {
+    private readonly popperContentContext;
+    private readonly environmentInjector;
+    readonly elementRef: ElementRef<HTMLElement>;
+    readonly width: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly height: _angular_core.InputSignalWithTransform<number, unknown>;
+    baseSide: _angular_core.Signal<"top" | "right" | "bottom" | "left">;
+    protected readonly style: _angular_core.Signal<{
+        [x: string]: string | number | undefined;
+        position: string;
+        left: string | undefined;
+        top: string | undefined;
+        transformOrigin: string;
+        transform: string;
+        visibility: string | undefined;
+    }>;
+    private onCleanup;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxPopperArrow, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxPopperArrow, "[rdxPopperArrow]", never, { "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const popperImports: (typeof RdxPopperAnchor | typeof RdxPopper | typeof RdxPopperContent | typeof RdxPopperContentWrapper)[];
+
+export { RdxPopper, RdxPopperAnchor, RdxPopperArrow, RdxPopperContent, RdxPopperContentWrapper, getSideAndAlignFromPlacement, injectPopperContentWrapperContext, isNotNull, popperImports, providePopperContentWrapperContext, transformOrigin };
+export type { Align, PopperContentWrapperContext, Side };

package/portal/README.md

@@ -0,0 +1 @@
+# @radix-ng/primitives/portal

package/portal/index.d.ts

@@ -0,0 +1,22 @@
+import * as _angular_core from '@angular/core';
+import { ElementRef } from '@angular/core';
+
+declare class RdxPortal {
+    private readonly elementRef;
+    private readonly platformId;
+    private readonly document;
+    private readonly destroyRef;
+    /**
+     * Specify a container element to portal the content into.
+     */
+    readonly container: _angular_core.InputSignal<ElementRef<HTMLElement> | undefined>;
+    private _computedContainer;
+    readonly computedContainer: _angular_core.WritableSignal<ElementRef<HTMLElement> | undefined>;
+    private readonly elementContainer;
+    constructor();
+    setContainer(container: ElementRef<HTMLElement>): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxPortal, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxPortal, "[rdxPortal]", never, { "container": { "alias": "container"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { RdxPortal };

package/presence/index.d.ts

@@ -1,5 +1,103 @@
-export * from './src/presence';
-export * from './src/presence.directive';
-export * from './src/transitions/transition.collapse';
-export * from './src/transitions/transition.toast';
-export * from './src/types';
+import * as i0 from '@angular/core';
+import { NgZone, Signal, InjectionToken, Provider } from '@angular/core';
+import { Subject, Observable } from 'rxjs';
+
+type TransitionOptions<T> = {
+    context?: T;
+    animation: boolean;
+    state?: 'continue' | 'stop';
+    transitionTimerDelayMs?: number;
+};
+type TransitionContext<T> = {
+    transition$: Subject<any>;
+    complete: () => void;
+    context: T;
+};
+type TransitionStartFn<T = any> = (element: HTMLElement, animation: boolean, context: T) => TransitionEndFn | void;
+type TransitionEndFn = () => void;
+
+/**
+ * Manages the presence of an element with optional transition animation.
+ *
+ * @template T - The type of the context object used in the transition.
+ * @param {NgZone} zone - The Angular zone to control the change detection context.
+ * @param {HTMLElement} element - The target HTML element to apply the transition.
+ * @param {TransitionOptions<T>} options - Options for controlling the transition behavior.
+ *   @param {T} [options.context] - An optional context object to pass through the transition.
+ *   @param {boolean} options.animation - A flag indicating if the transition should be animated.
+ *   @param {'start' | 'continue' | 'stop'} options.state - The desired state of the transition.
+ * @param {TransitionStartFn<T>} startFn - A function to start the transition.
+ * @returns {Observable<void>} - An observable that emits when the transition completes.
+ *
+ * The `usePresence` function is designed to manage the presence and visibility of an HTML element,
+ * optionally applying a transition animation. It utilizes Angular's NgZone for efficient change
+ * detection management and allows for different states of transitions ('start', 'continue', 'stop').
+ * The function takes a start function to handle the beginning of the transition and returns an
+ * observable that completes when the transition ends.
+ *
+ * Example usage:
+ *
+ * const options: TransitionOptions<MyContext> = {
+ *   context: {}, // your context object
+ *   animation: true,
+ *   state: 'start'
+ * };
+ *
+ * const startFn: TransitionStartFn<MyContext> = (el, animation, context) => {
+ *   el.classList.add('active');
+ *   return () => el.classList.remove('active');
+ * };
+ *
+ * usePresence(zone, element, startFn, options).subscribe(() => {
+ *   console.log('Transition completed');
+ * });
+ */
+declare const usePresence: <T>(zone: NgZone, element: HTMLElement, startFn: TransitionStartFn<T>, options: TransitionOptions<T>) => Observable<void>;
+declare const completeTransition: (element: HTMLElement) => void;
+
+/**
+ * Context interface for RdxPresence directive
+ * Contains a Signal that indicates whether the content should be present in the DOM
+ */
+type RdxPresenceContext = {
+    present: Signal<boolean>;
+};
+declare const RDX_PRESENCE_CONTEXT: InjectionToken<RdxPresenceContext>;
+/**
+ * Factory provider helper.
+ * In your parent component/directive you can write:
+ *
+ *   providers: [
+ *     provideRdxPresenceContext(() => ({ present: myBooleanSignal }))
+ *   ]
+ */
+declare function provideRdxPresenceContext(contextFactory: () => RdxPresenceContext): Provider;
+declare class RdxPresenceDirective {
+    private readonly context;
+    private readonly viewContainerRef;
+    private readonly templateRef;
+    private effectRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxPresenceDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxPresenceDirective, never, never, {}, {}, never, never, true, never>;
+}
+
+type CollapseContext = {
+    direction: 'show' | 'hide';
+    dimension: 'width' | 'height';
+    maxSize?: string;
+};
+/**
+ * Function to handle the start of a collapsing transition.
+ *
+ * @param element - The HTML element to animate.
+ * @param animation - Whether to use animation or not.
+ * @param context - The context containing direction and dimension information.
+ * @returns A function to clean up the animation.
+ */
+declare const transitionCollapsing: TransitionStartFn<CollapseContext>;
+
+declare const toastFadeInTransition: TransitionStartFn;
+declare const toastFadeOutTransition: TransitionStartFn;
+
+export { RDX_PRESENCE_CONTEXT, RdxPresenceDirective, completeTransition, provideRdxPresenceContext, toastFadeInTransition, toastFadeOutTransition, transitionCollapsing, usePresence };
+export type { CollapseContext, RdxPresenceContext, TransitionContext, TransitionEndFn, TransitionOptions, TransitionStartFn };

package/progress/index.d.ts

@@ -1,11 +1,79 @@
-import * as i0 from "@angular/core";
-import * as i1 from "./src/progress-root.directive";
-import * as i2 from "./src/progress-indicator.directive";
-export * from './src/progress-indicator.directive';
-export * from './src/progress-root.directive';
-export type { ProgressProps } from './src/progress-root.directive';
-export declare class RdxProgressModule {
+import * as i0 from '@angular/core';
+import { InjectionToken } from '@angular/core';
+
+declare const RdxProgressToken: InjectionToken<RdxProgressRootDirective>;
+/**
+ * Injects the current instance of RdxProgressRootDirective.
+ * @returns The instance of RdxProgressRootDirective.
+ */
+declare function injectProgress(): RdxProgressRootDirective;
+type ProgressState = 'indeterminate' | 'complete' | 'loading';
+interface ProgressProps {
+    value?: number | null;
+    max?: number;
+    /**
+     * A function to get the accessible label text representing the current value in a human-readable format.
+     *
+     *  If not provided, the value label will be read as the numeric value as a percentage of the max value.
+     */
+    getValueLabel?: (value: number, max: number) => string;
+}
+/**
+ * Directive to manage progress bar state and attributes.
+ *
+ * This directive provides a way to create a progress bar with customizable value and max attributes.
+ * It handles aria attributes for accessibility and provides different states like 'indeterminate', 'complete', and 'loading'.
+ *
+ * @group Components
+ */
+declare class RdxProgressRootDirective {
+    /**
+     * The current value of the progress bar.
+     * @group Props
+     * @defaultValue 0
+     */
+    readonly value: i0.ModelSignal<number>;
+    /**
+     * The maximum value of the progress bar.
+     * @defaultValue 100
+     * @group Props
+     */
+    readonly max: i0.ModelSignal<number>;
+    /**
+     * Function to generate the value label.
+     * @group Props
+     */
+    readonly valueLabel: i0.InputSignal<(value: number, max: number) => string>;
+    protected readonly label: i0.Signal<string>;
+    readonly progressState: i0.Signal<ProgressState>;
+    constructor();
+    private validateValue;
+    private validateMax;
+    private defaultGetValueLabel;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxProgressRootDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxProgressRootDirective, "[rdxProgressRoot]", ["rdxProgressRoot"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "valueLabel": { "alias": "valueLabel"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "max": "maxChange"; }, never, never, true, never>;
+}
+
+/**
+ * Directive to manage progress indicator state and attributes.
+ *
+ * This directive is used to display the progress indicator inside the progress bar.
+ * It inherits the state and value from the `RdxProgressRootDirective`.
+ */
+declare class RdxProgressIndicatorDirective {
+    /**
+     * This allows the directive to access the progress bar state and values.
+     */
+    protected readonly progress: RdxProgressRootDirective;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxProgressIndicatorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxProgressIndicatorDirective, "[rdxProgressIndicator]", ["rdxProgressIndicator"], {}, {}, never, never, true, never>;
+}
+
+declare class RdxProgressModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<RdxProgressModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxProgressModule, never, [typeof i1.RdxProgressRootDirective, typeof i2.RdxProgressIndicatorDirective], [typeof i1.RdxProgressRootDirective, typeof i2.RdxProgressIndicatorDirective]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxProgressModule, never, [typeof RdxProgressRootDirective, typeof RdxProgressIndicatorDirective], [typeof RdxProgressRootDirective, typeof RdxProgressIndicatorDirective]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<RdxProgressModule>;
 }
+
+export { RdxProgressIndicatorDirective, RdxProgressModule, RdxProgressRootDirective, RdxProgressToken, injectProgress };
+export type { ProgressProps, ProgressState };

package/radio/index.d.ts

@@ -1,4 +1,118 @@
-export * from './src/radio-root.directive';
-export * from './src/radio-indicator.directive';
-export * from './src/radio-item-input.directive';
-export * from './src/radio-item.directive';
+import * as _angular_core from '@angular/core';
+import { InputSignalWithTransform, ModelSignal, Signal, OnInit, InjectionToken } from '@angular/core';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { ControlValueAccessor } from '@angular/forms';
+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>;
+}
+interface RadioGroupDirective extends RadioGroupProps {
+    select(value: string | null): void;
+    onTouched(): void;
+}
+
+declare class RdxRadioGroupDirective implements RadioGroupProps, RadioGroupDirective, ControlValueAccessor {
+    readonly value: _angular_core.ModelSignal<string | null>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    defaultValue?: string;
+    readonly required: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly orientation: _angular_core.InputSignal<Orientation | undefined>;
+    /**
+     * Event handler called when the value changes.
+     */
+    readonly onValueChange: _angular_core.OutputEmitterRef<string>;
+    private readonly disable;
+    readonly disableState: _angular_core.Signal<boolean>;
+    /**
+     * The callback function to call when the value of the radio group changes.
+     */
+    private onChange;
+    /**
+     * The callback function to call when the radio group is touched.
+     * @ignore
+     */
+    onTouched: () => void;
+    /**
+     * Select a radio item.
+     * @param value The value of the radio item to select.
+     * @ignore
+     */
+    select(value: string): void;
+    /**
+     * Update the value of the radio group.
+     * @param value The new value of the radio group.
+     * @ignore
+     */
+    writeValue(value: string): 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;
+    /** @ignore */
+    registerOnTouched(fn: () => void): void;
+    /**
+     * Set the disabled state of the radio group.
+     * @param isDisabled Whether the radio group is disabled.
+     * @ignore
+     */
+    setDisabledState(isDisabled: boolean): void;
+    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: {}; }]>;
+}
+
+declare const RdxRadioItemToken: InjectionToken<RdxRadioItemDirective>;
+declare function injectRadioItem(): RdxRadioItemDirective;
+declare class RdxRadioItemDirective implements OnInit {
+    private readonly radioGroup;
+    private readonly elementRef;
+    readonly value: _angular_core.InputSignal<string>;
+    readonly id: _angular_core.InputSignal<string | undefined>;
+    readonly required: _angular_core.InputSignal<boolean | undefined>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    protected readonly disabledState: _angular_core.Signal<boolean>;
+    readonly checkedState: _angular_core.Signal<boolean>;
+    private readonly ARROW_KEYS;
+    private readonly isArrowKeyPressedSignal;
+    /** @ignore */
+    ngOnInit(): void;
+    /** @ignore */
+    onClick(): void;
+    /** @ignore */
+    onKeyDown(event: KeyboardEvent): void;
+    /** @ignore */
+    onKeyUp(): void;
+    /** @ignore */
+    onFocus(): void;
+    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: {}; }]>;
+}
+
+declare class RdxRadioIndicatorDirective {
+    protected readonly radioGroup: RadioGroupDirective;
+    protected readonly radioItem: RdxRadioItemDirective;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxRadioIndicatorDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxRadioIndicatorDirective, "[rdxRadioIndicator]", ["rdxRadioIndicator"], {}, {}, never, never, true, never>;
+}
+
+declare class RdxRadioItemInputDirective {
+    private readonly radioItem;
+    readonly name: _angular_core.InputSignal<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>;
+    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: {}; }]>;
+}
+
+export { RdxRadioGroupDirective, RdxRadioIndicatorDirective, RdxRadioItemDirective, RdxRadioItemInputDirective, RdxRadioItemToken, injectRadioItem };