ng-primitives 0.89.0 → 0.90.0

package/portal/index.d.ts

@@ -1,6 +1,389 @@
-export { createOverlay, injectOverlay, NgpOverlay, NgpOverlayConfig, NgpOverlayContent, NgpOverlayTemplateContext, } from './overlay';
-export { setupOverlayArrow } from './overlay-arrow';
-export { injectOverlayContext, provideOverlayContext } from './overlay-token';
-export { createPortal, NgpComponentPortal, NgpPortal, NgpTemplatePortal } from './portal';
-export { BlockScrollStrategy, NoopScrollStrategy, ScrollStrategy } from './scroll-strategy';
-export { NgpOffset, NgpOffsetInput, NgpOffsetOptions, coerceOffset } from './offset';
+import * as _angular_core from '@angular/core';
+import { TemplateRef, Type, Injector, ViewContainerRef, Signal, Provider, ValueProvider, ApplicationRef } from '@angular/core';
+import { FocusOrigin } from '@angular/cdk/a11y';
+import { Placement, Strategy, Middleware } from '@floating-ui/dom';
+import { Subject } from 'rxjs';
+import { ViewportRuler } from '@angular/cdk/overlay';
+
+/**
+ * Options for configuring offset between a floating element and its reference element.
+ * Can be a single number for uniform offset or an object for axis-specific control.
+ */
+interface NgpOffsetOptions {
+    /**
+     * The offset along the main axis (the axis that runs along the side of the floating element).
+     * Represents the distance between the floating element and the reference element.
+     * @default 0
+     */
+    mainAxis?: number;
+    /**
+     * The offset along the cross axis (the axis that runs along the alignment of the floating element).
+     * Represents the skidding between the floating element and the reference element.
+     * @default 0
+     */
+    crossAxis?: number;
+    /**
+     * Same axis as crossAxis but applies only to aligned placements and inverts the end alignment.
+     * When set to a number, it overrides the crossAxis value.
+     * @default null
+     */
+    alignmentAxis?: number | null;
+}
+/**
+ * Type representing all valid offset values.
+ * Can be a number (applies to mainAxis) or an object with axis-specific offsets.
+ */
+type NgpOffset = number | NgpOffsetOptions;
+/**
+ * Input type for offset that also accepts string representations of numbers
+ */
+type NgpOffsetInput = NgpOffset | string;
+/**
+ * Transform function to coerce offset input values to the correct type
+ * @param value The input value to coerce
+ * @returns The coerced offset value
+ */
+declare function coerceOffset(value: NgpOffsetInput | null | undefined): NgpOffset;
+
+/**
+ * Configuration options for creating an overlay
+ * @internal
+ */
+interface NgpOverlayConfig<T = unknown> {
+    /** Content to display in the overlay (component or template) */
+    content: NgpOverlayContent<T>;
+    /** The element that triggers the overlay */
+    triggerElement: HTMLElement;
+    /** The element to use for positioning the overlay (if different from trigger) */
+    anchorElement?: HTMLElement | null;
+    /** The injector to use for creating the portal */
+    injector: Injector;
+    /** ViewContainerRef to use for creating the portal */
+    viewContainerRef: ViewContainerRef;
+    /** Context data to pass to the overlay content */
+    context?: Signal<T | undefined>;
+    /** Container element or selector to attach the overlay to (defaults to document.body) */
+    container?: HTMLElement | string | null;
+    /** Preferred placement of the overlay relative to the trigger. */
+    placement?: Signal<Placement>;
+    /** Offset distance between the overlay and trigger. Can be a number or an object with axis-specific offsets */
+    offset?: NgpOffset;
+    /** Whether to enable flip behavior when space is limited */
+    flip?: boolean;
+    /** Delay before showing the overlay in milliseconds */
+    showDelay?: number;
+    /** Delay before hiding the overlay in milliseconds */
+    hideDelay?: number;
+    /** Whether the overlay should be positioned with fixed or absolute strategy */
+    strategy?: Strategy;
+    /** The scroll strategy to use for the overlay */
+    scrollBehaviour?: 'reposition' | 'block';
+    /** Whether to close the overlay when clicking outside */
+    closeOnOutsideClick?: boolean;
+    /** Whether to close the overlay when pressing escape */
+    closeOnEscape?: boolean;
+    /** Whether to restore focus to the trigger element when hiding the overlay */
+    restoreFocus?: boolean;
+    /** Additional middleware for floating UI positioning */
+    additionalMiddleware?: Middleware[];
+    /** Additional providers */
+    providers?: Provider[];
+}
+/** Type for overlay content which can be either a template or component */
+type NgpOverlayContent<T> = TemplateRef<NgpOverlayTemplateContext<T>> | Type<unknown>;
+/** Context for template-based overlays */
+type NgpOverlayTemplateContext<T> = {
+    $implicit: T;
+};
+/**
+ * NgpOverlay manages the lifecycle and positioning of overlay UI elements.
+ * It abstracts the common behavior shared by tooltips, popovers, menus, etc.
+ * @internal
+ */
+declare class NgpOverlay<T = unknown> {
+    private config;
+    private readonly disposables;
+    private readonly document;
+    private readonly destroyRef;
+    private readonly viewContainerRef;
+    private readonly viewportRuler;
+    private readonly focusMonitor;
+    /** Access any parent overlays */
+    private readonly parentOverlay;
+    /** Signal tracking the portal instance */
+    private readonly portal;
+    /** Signal tracking the overlay position */
+    readonly position: _angular_core.WritableSignal<{
+        x: number | undefined;
+        y: number | undefined;
+    }>;
+    /**
+     * Determine if the overlay has been positioned
+     * @internal
+     */
+    readonly isPositioned: Signal<boolean>;
+    /** Signal tracking the trigger element width */
+    readonly triggerWidth: _angular_core.WritableSignal<number | null>;
+    /** The transform origin for the overlay */
+    readonly transformOrigin: _angular_core.WritableSignal<string>;
+    /** Signal tracking the final placement of the overlay */
+    readonly finalPlacement: _angular_core.WritableSignal<Placement | undefined>;
+    /** Function to dispose the positioning auto-update */
+    private disposePositioning?;
+    /** Timeout handle for showing the overlay */
+    private openTimeout?;
+    /** Timeout handle for hiding the overlay */
+    private closeTimeout?;
+    /** Signal tracking whether the overlay is open */
+    readonly isOpen: _angular_core.WritableSignal<boolean>;
+    /** A unique id for the overlay */
+    readonly id: _angular_core.WritableSignal<string>;
+    /** The aria-describedby attribute for accessibility */
+    readonly ariaDescribedBy: Signal<string | undefined>;
+    /** The scroll strategy */
+    private scrollStrategy;
+    /** An observable that emits when the overlay is closing */
+    readonly closing: Subject<void>;
+    /** Store the arrow element */
+    private arrowElement;
+    /** @internal The position of the arrow */
+    readonly arrowPosition: _angular_core.WritableSignal<{
+        x: number | undefined;
+        y: number | undefined;
+    }>;
+    /**
+     * Creates a new overlay instance
+     * @param config Initial configuration for the overlay
+     * @param destroyRef Reference for automatic cleanup
+     */
+    constructor(config: NgpOverlayConfig<T>);
+    /**
+     * Show the overlay with the specified delay
+     * @param showDelay Optional delay to override the configured showDelay
+     */
+    show(): Promise<void>;
+    /**
+     * Stop any pending close operation. This is useful for example, if we move the mouse from the tooltip trigger to the tooltip itself.
+     * This will prevent the tooltip from closing immediately when the mouse leaves the trigger.
+     * @internal
+     */
+    cancelPendingClose(): void;
+    /**
+     * Hide the overlay with the specified delay
+     * @param options Optional options for hiding the overlay
+     */
+    hide(options?: OverlayTriggerOptions): void;
+    /**
+     * Update the configuration of this overlay
+     * @param config New configuration (partial)
+     */
+    updateConfig(config: Partial<NgpOverlayConfig<T>>): void;
+    /**
+     * Immediately hide the overlay without any delay
+     */
+    hideImmediate(): void;
+    /**
+     * Toggle the overlay open/closed state
+     */
+    toggle(): void;
+    /**
+     * Force update the position of the overlay
+     */
+    updatePosition(): void;
+    /**
+     * Completely destroy this overlay instance
+     */
+    destroy(): void;
+    /**
+     * Get the elements of the overlay
+     */
+    getElements(): HTMLElement[];
+    /**
+     * Internal method to create the overlay
+     */
+    private createOverlay;
+    /**
+     * Internal method to setup positioning of the overlay
+     */
+    private setupPositioning;
+    /**
+     * Compute the overlay position using floating-ui
+     */
+    private computePosition;
+    /**
+     * Internal method to destroy the overlay portal
+     */
+    private destroyOverlay;
+    /**
+     * Get the transform origin for the overlay
+     */
+    private getTransformOrigin;
+    /**
+     * Register the arrow element for positioning
+     * @internal
+     */
+    registerArrow(arrowElement: HTMLElement | null): void;
+    /**
+     * Remove the registered arrow element
+     * @internal
+     */
+    unregisterArrow(): void;
+    /**
+     * Resolve the container element from the configuration
+     * @internal
+     */
+    private resolveContainer;
+}
+/**
+ * Helper function to create an overlay in a single call
+ * @internal
+ */
+declare function createOverlay<T>(config: NgpOverlayConfig<T>): NgpOverlay<T>;
+/**
+ * Helper function to inject the NgpOverlay instance
+ * @internal
+ */
+declare function injectOverlay<T>(): NgpOverlay<T>;
+interface OverlayTriggerOptions {
+    /**
+     * Whether the visibility change should be immediate.
+     */
+    immediate?: boolean;
+    /**
+     * The origin of the focus event that triggered the visibility change.
+     */
+    origin?: FocusOrigin;
+}
+
+declare function setupOverlayArrow(): void;
+
+/**
+ * Injects the context for the overlay.
+ * @internal
+ */
+declare function injectOverlayContext<T>(): Signal<T>;
+/**
+ * Provides the context for the overlay.
+ * @param value The value to provide as the context.
+ * @internal
+ */
+declare function provideOverlayContext<T>(value: Signal<T | undefined> | undefined): ValueProvider;
+
+declare abstract class NgpPortal {
+    protected readonly viewContainerRef: ViewContainerRef;
+    protected readonly injector: Injector;
+    constructor(viewContainerRef: ViewContainerRef, injector: Injector);
+    /**
+     * Get the elements of the portal.
+     */
+    abstract getElements(): HTMLElement[];
+    /**
+     * Detect changes in the portal.
+     */
+    abstract detectChanges(): void;
+    /**
+     * Whether the portal is attached to a DOM element.
+     */
+    abstract getAttached(): boolean;
+    /**
+     * Attach the portal to a DOM element.
+     * @param container The DOM element to attach the portal to.
+     */
+    abstract attach(container: HTMLElement): this;
+    /**
+     * Detach the portal from the DOM.
+     */
+    abstract detach(): Promise<void>;
+    /**
+     * Angular v20 removes `_unusedComponentFactoryResolver` and `_document` from DomPortalOutlet's
+     * constructor signature as they have been deprecated since v18, and replaced with optional
+     * `_appRef` and `_defaultInjector` params.
+     * This temporary change ensures consistent behaviour for consumers using ng v20+.
+     * @see {@link https://github.com/angular/components/pull/24504 The implementing PR} for the new implementation.
+     * @see {@link https://github.com/angular/components/blob/732a0d7ab69ec25925cc06a0fb17b0fb16a4b0ae/src/cdk/portal/dom-portal-outlet.ts#L27 The latest v20 version comments}
+     * describe the importance of passing the `_appRef` and `_defaultInjector` when it comes to component portals
+     */
+    protected _getDomPortalOutletCtorParamsCompat(): (ApplicationRef | Injector | undefined | any)[];
+}
+declare class NgpComponentPortal<T> extends NgpPortal {
+    private readonly componentPortal;
+    private viewRef;
+    private isDestroying;
+    private exitAnimationRef;
+    constructor(component: Type<T>, viewContainerRef: ViewContainerRef, injector: Injector);
+    /**
+     * Attach the portal to a DOM element.
+     * @param container The DOM element to attach the portal to.
+     */
+    attach(container: HTMLElement): this;
+    /**
+     * Get the root elements of the portal.
+     */
+    getElements(): HTMLElement[];
+    /**
+     * Detect changes in the portal.
+     */
+    detectChanges(): void;
+    /**
+     * Whether the portal is attached to a DOM element.
+     */
+    getAttached(): boolean;
+    /**
+     * Detach the portal from the DOM.
+     */
+    detach(): Promise<void>;
+}
+declare class NgpTemplatePortal<T> extends NgpPortal {
+    private readonly templatePortal;
+    private viewRef;
+    private exitAnimationRefs;
+    private isDestroying;
+    constructor(template: TemplateRef<T>, viewContainerRef: ViewContainerRef, injector: Injector, context?: T);
+    /**
+     * Attach the portal to a DOM element.
+     * @param container The DOM element to attach the portal to.
+     */
+    attach(container: HTMLElement): this;
+    /**
+     * Get the root elements of the portal.
+     */
+    getElements(): HTMLElement[];
+    /**
+     * Detect changes in the portal.
+     */
+    detectChanges(): void;
+    /**
+     * Whether the portal is attached to a DOM element.
+     */
+    getAttached(): boolean;
+    /**
+     * Detach the portal from the DOM.
+     */
+    detach(): Promise<void>;
+}
+declare function createPortal<T>(componentOrTemplate: Type<T> | TemplateRef<T>, viewContainerRef: ViewContainerRef, injector: Injector, context?: T): NgpPortal;
+
+interface ScrollStrategy {
+    enable(): void;
+    disable(): void;
+}
+declare class BlockScrollStrategy implements ScrollStrategy {
+    private readonly viewportRuler;
+    private readonly document;
+    private readonly previousHTMLStyles;
+    private previousScrollPosition;
+    private isEnabled;
+    constructor(viewportRuler: ViewportRuler, document: Document);
+    /** Blocks page-level scroll while the attached overlay is open. */
+    enable(): void;
+    /** Unblocks page-level scroll while the attached overlay is open. */
+    disable(): void;
+    private canBeEnabled;
+}
+declare class NoopScrollStrategy implements ScrollStrategy {
+    enable(): void;
+    disable(): void;
+}
+
+export { BlockScrollStrategy, NgpComponentPortal, NgpOverlay, NgpPortal, NgpTemplatePortal, NoopScrollStrategy, coerceOffset, createOverlay, createPortal, injectOverlay, injectOverlayContext, provideOverlayContext, setupOverlayArrow };
+export type { NgpOffset, NgpOffsetInput, NgpOffsetOptions, NgpOverlayConfig, NgpOverlayContent, NgpOverlayTemplateContext, ScrollStrategy };

package/progress/index.d.ts

@@ -1,6 +1,124 @@
-export { NgpProgressIndicator } from './progress-indicator/progress-indicator';
-export { NgpProgressLabel } from './progress-label/progress-label';
-export { NgpProgressTrack } from './progress-track/progress-track';
-export { NgpProgressValue } from './progress-value/progress-value';
-export { NgpProgress, NgpProgressValueTextFn } from './progress/progress';
-export { injectProgressState, provideProgressState } from './progress/progress-state';
+import * as _angular_core from '@angular/core';
+import * as ng_primitives_state from 'ng-primitives/state';
+import * as ng_primitives_progress from 'ng-primitives/progress';
+import { NumberInput } from '@angular/cdk/coercion';
+
+/**
+ * Apply the `ngpProgressIndicator` directive to an element that represents the current progress.
+ * The width of this element can be set to the percentage of the progress value.
+ */
+declare class NgpProgressIndicator {
+    /**
+     * Access the progress state.
+     */
+    protected readonly state: _angular_core.Signal<ng_primitives_state.State<ng_primitives_progress.NgpProgress>>;
+    /**
+     * Get the percentage of the progress value.
+     */
+    protected readonly percentage: _angular_core.Signal<number | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpProgressIndicator, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpProgressIndicator, "[ngpProgressIndicator]", never, {}, {}, never, never, true, never>;
+}
+
+declare class NgpProgressLabel {
+    /**
+     * Access the progress state.
+     */
+    protected readonly state: _angular_core.Signal<ng_primitives_state.State<ng_primitives_progress.NgpProgress>>;
+    /**
+     * The unique identifier for the progress label.
+     */
+    readonly id: _angular_core.InputSignal<string>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpProgressLabel, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpProgressLabel, "[ngpProgressLabel]", ["ngpProgressLabel"], { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class NgpProgressTrack {
+    /**
+     * Access the progress state.
+     */
+    protected readonly state: _angular_core.Signal<ng_primitives_state.State<ng_primitives_progress.NgpProgress>>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpProgressTrack, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpProgressTrack, "[ngpProgressTrack]", ["ngpProgressTrack"], {}, {}, never, never, true, never>;
+}
+
+declare class NgpProgressValue {
+    /**
+     * Access the progress state.
+     */
+    protected readonly state: _angular_core.Signal<ng_primitives_state.State<ng_primitives_progress.NgpProgress>>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpProgressValue, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpProgressValue, "[ngpProgressValue]", ["ngpProgressValue"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Apply the `ngpProgress` directive to an element that represents the progress bar.
+ */
+declare class NgpProgress {
+    /**
+     * Define the progress value.
+     */
+    readonly value: _angular_core.InputSignalWithTransform<number | null, NumberInput>;
+    /**
+     * Define the progress min value.
+     * @default '0'
+     */
+    readonly min: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    /**
+     * Define the progress max value.
+     * @default 100
+     */
+    readonly max: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    /**
+     * Define a function that returns the progress value label.
+     * @param value The current value
+     * @param max The maximum value
+     * @returns The value label
+     */
+    readonly valueLabel: _angular_core.InputSignal<NgpProgressValueTextFn>;
+    /**
+     * Determine if the progress is indeterminate.
+     * @internal
+     */
+    readonly indeterminate: _angular_core.Signal<boolean>;
+    /**
+     * Determine if the progress is in a progressing state.
+     * @internal
+     */
+    readonly progressing: _angular_core.Signal<boolean>;
+    /**
+     * Determine if the progress is complete.
+     * @internal
+     */
+    readonly complete: _angular_core.Signal<boolean>;
+    /**
+     * Get the progress value text.
+     */
+    protected readonly valueText: _angular_core.Signal<string>;
+    /**
+     * The label associated with the progress bar.
+     * @internal
+     */
+    readonly label: _angular_core.WritableSignal<NgpProgressLabel | null>;
+    /**
+     * The state of the progress bar.
+     * @internal
+     */
+    protected readonly state: ng_primitives_state.CreatedState<NgpProgress>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpProgress, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpProgress, "[ngpProgress]", never, { "value": { "alias": "ngpProgressValue"; "required": false; "isSignal": true; }; "min": { "alias": "ngpProgressMin"; "required": false; "isSignal": true; }; "max": { "alias": "ngpProgressMax"; "required": false; "isSignal": true; }; "valueLabel": { "alias": "ngpProgressValueLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+type NgpProgressValueTextFn = (value: number, max: number) => string;
+
+/**
+ * Provides the Progress state.
+ */
+declare const provideProgressState: (options?: ng_primitives_state.CreateStateProviderOptions) => _angular_core.FactoryProvider;
+/**
+ * Injects the Progress state.
+ */
+declare const injectProgressState: <U = NgpProgress>(injectOptions?: _angular_core.InjectOptions) => _angular_core.Signal<ng_primitives_state.State<U>>;
+
+export { NgpProgress, NgpProgressIndicator, NgpProgressLabel, NgpProgressTrack, NgpProgressValue, injectProgressState, provideProgressState };
+export type { NgpProgressValueTextFn };

package/radio/index.d.ts

@@ -1,5 +1,140 @@
-export { NgpRadioGroup } from './radio-group/radio-group';
-export { injectRadioGroupState, provideRadioGroupState } from './radio-group/radio-group-state';
-export { NgpRadioIndicator } from './radio-indicator/radio-indicator';
-export { NgpRadioItem } from './radio-item/radio-item';
-export { injectRadioItemState, provideRadioItemState } from './radio-item/radio-item-state';
+import * as ng_primitives_state from 'ng-primitives/state';
+import { InjectedState } from 'ng-primitives/state';
+import * as _angular_core from '@angular/core';
+import { OnInit } from '@angular/core';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { NgpOrientation } from 'ng-primitives/common';
+import * as i1 from 'ng-primitives/roving-focus';
+import * as ng_primitives_radio from 'ng-primitives/radio';
+import * as i2 from 'ng-primitives/interactions';
+
+/**
+ * Apply the `ngpRadioGroup` directive to an element that represents the group of radio items.
+ */
+declare class NgpRadioGroup<T> implements OnInit {
+    /**
+     * Access the roving focus group state.
+     */
+    private readonly rovingFocusGroupState;
+    /**
+     * The id of the radio group. If not provided, a unique id will be generated.
+     */
+    readonly id: _angular_core.InputSignal<string>;
+    /**
+     * The value of the radio group.
+     */
+    readonly value: _angular_core.InputSignal<T | null>;
+    /**
+     * Event emitted when the radio group value changes.
+     */
+    readonly valueChange: _angular_core.OutputEmitterRef<T | null>;
+    /**
+     * Whether the radio group is disabled.
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * The orientation of the radio group.
+     * @default 'horizontal'
+     */
+    readonly orientation: _angular_core.InputSignal<NgpOrientation>;
+    /**
+     * The comparator function for the radio group. This is useful if values are objects and you want to compare them by value, not by reference.
+     * @default (a, b) => a === b
+     */
+    readonly compareWith: _angular_core.InputSignal<(a: T | null, b: T | null) => boolean>;
+    /**
+     * The state of the radio group.
+     * @internal
+     */
+    protected readonly state: ng_primitives_state.CreatedState<NgpRadioGroup<T>>;
+    constructor();
+    ngOnInit(): void;
+    /**
+     * Select a radio item.
+     * @param value The value of the radio item to select.
+     */
+    select(value: T): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpRadioGroup<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpRadioGroup<any>, "[ngpRadioGroup]", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "value": { "alias": "ngpRadioGroupValue"; "required": false; "isSignal": true; }; "disabled": { "alias": "ngpRadioGroupDisabled"; "required": false; "isSignal": true; }; "orientation": { "alias": "ngpRadioGroupOrientation"; "required": false; "isSignal": true; }; "compareWith": { "alias": "ngpRadioGroupCompareWith"; "required": false; "isSignal": true; }; }, { "valueChange": "ngpRadioGroupValueChange"; }, never, never, true, [{ directive: typeof i1.NgpRovingFocusGroup; inputs: { "ngpRovingFocusGroupOrientation": "ngpRadioGroupOrientation"; "ngpRovingFocusGroupDisabled": "ngpRadioGroupDisabled"; }; outputs: {}; }]>;
+}
+
+/**
+ * Provides the RadioGroup state.
+ */
+declare const provideRadioGroupState: (options?: ng_primitives_state.CreateStateProviderOptions) => _angular_core.FactoryProvider;
+/**
+ * Injects the RadioGroup state.
+ */
+declare const injectRadioGroupState: <T>() => InjectedState<NgpRadioGroup<T>>;
+
+/**
+ * Apply the `ngpRadioIndicator` directive to an element that represents the radio indicator (i.e. the dot).
+ */
+declare class NgpRadioIndicator<T> {
+    /**
+     * Access the radio group state.
+     */
+    protected readonly radioGroupState: ng_primitives_state.InjectedState<ng_primitives_radio.NgpRadioGroup<T>>;
+    /**
+     * Access the radio group item state
+     */
+    protected readonly radioItemState: ng_primitives_state.InjectedState<ng_primitives_radio.NgpRadioItem<T>>;
+    /**
+     * Determine if the radio indicator is checked.
+     */
+    protected readonly checked: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpRadioIndicator<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpRadioIndicator<any>, "[ngpRadioIndicator]", never, {}, {}, never, never, true, [{ directive: typeof i2.NgpHover; inputs: {}; outputs: {}; }, { directive: typeof i2.NgpPress; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * Apply the `ngpRadioItem` directive to an element that represents a radio item. This would typically be a `button` element.
+ */
+declare class NgpRadioItem<T> implements OnInit {
+    /**
+     * Access the radio group state.
+     */
+    private readonly radioGroupState;
+    /**
+     * The value of the radio item.
+     * @required
+     */
+    readonly value: _angular_core.InputSignal<T | undefined>;
+    /**
+     * Whether the radio item is disabled.
+     * @default false
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Whether the radio item is checked.
+     */
+    readonly checked: _angular_core.Signal<boolean>;
+    /**
+     * The state of the radio item.
+     */
+    protected readonly state: ng_primitives_state.CreatedState<NgpRadioItem<T>>;
+    ngOnInit(): void;
+    /**
+     * When the item receives focus, select it.
+     * @internal
+     */
+    protected onFocus(): void;
+    /**
+     * When the item receives a click, select it.
+     * @internal
+     */
+    protected onClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpRadioItem<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpRadioItem<any>, "[ngpRadioItem]", never, { "value": { "alias": "ngpRadioItemValue"; "required": false; "isSignal": true; }; "disabled": { "alias": "ngpRadioItemDisabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.NgpRovingFocusItem; inputs: {}; outputs: {}; }, { directive: typeof i2.NgpHover; inputs: {}; outputs: {}; }, { directive: typeof i2.NgpFocusVisible; inputs: {}; outputs: {}; }, { directive: typeof i2.NgpPress; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * Provides the RadioItem state.
+ */
+declare const provideRadioItemState: (options?: ng_primitives_state.CreateStateProviderOptions) => _angular_core.FactoryProvider;
+/**
+ * Injects the RadioItem state.
+ */
+declare const injectRadioItemState: <T>() => InjectedState<NgpRadioItem<T>>;
+
+export { NgpRadioGroup, NgpRadioIndicator, NgpRadioItem, injectRadioGroupState, injectRadioItemState, provideRadioGroupState, provideRadioItemState };