@ngneers/controls 0.0.1-next.0

package/types/ngneers-controls-number-input.d.ts

@@ -0,0 +1,146 @@
+import * as _angular_core from '@angular/core';
+import * as _ngneers_controls_api_ng from '@ngneers/controls/api/ng';
+import * as _ngneers_controls_themes from '@ngneers/controls-themes';
+import { ValueControlBase } from '@ngneers/controls/base';
+
+/**
+ * Turns a native `<input>` into a locale-aware number input with a
+ * `number | null` value model:
+ *
+ * - Free typing while focused; the value is committed on blur/Enter
+ *   (unparseable text reverts, out-of-range values are clamped — no wrapping).
+ * - Display is formatted via `Intl.NumberFormat` while blurred; while focused
+ *   the text is the raw, ungrouped edit form.
+ * - `ArrowUp`/`ArrowDown` step by `step`, with `Shift` by `bigStep`.
+ *   Results are rounded to the operands' precision so float drift never shows.
+ * - Exposes the {@link NgnBase.stepValue}/{@link NgnBase.canStepValue} hooks,
+ *   so `ngn-spin-buttons` (or a surrounding field) can step the value.
+ *
+ * @category control
+ */
+declare class NgnNumberInput extends ValueControlBase<'numberInput', number | null> {
+    readonly isFieldControl = true;
+    protected readonly theme: _ngneers_controls_api_ng.ControlTemplateInfo<_ngneers_controls_themes.ControlTemplate<"input", ["root", "invalid", "empty"], readonly []>>;
+    /**
+     * The minimum allowed value (inclusive). Typed values below are clamped on
+     * commit; stepping stops here.
+     */
+    readonly min: _angular_core.InputSignalWithTransform<number | undefined, unknown>;
+    /**
+     * The maximum allowed value (inclusive). Typed values above are clamped on
+     * commit; stepping stops here.
+     */
+    readonly max: _angular_core.InputSignalWithTransform<number | undefined, unknown>;
+    /**
+     * The step amount applied by the spin buttons and `ArrowUp`/`ArrowDown`.
+     * Non-finite or non-positive values fall back to `1`.
+     * @default 1
+     */
+    readonly step: _angular_core.InputSignalWithTransform<number, unknown>;
+    /**
+     * The step amount applied with `Shift+ArrowUp`/`Shift+ArrowDown`.
+     * Non-finite or non-positive values fall back to `appliedStep * 10`.
+     * @default step * 10
+     */
+    readonly bigStep: _angular_core.InputSignalWithTransform<number | undefined, unknown>;
+    /**
+     * The locale used for formatting and parsing.
+     * @default LOCALE_ID
+     */
+    readonly locale: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Additional `Intl.NumberFormat` options for the blurred display format only
+     * (e.g. `{ minimumFractionDigits: 2 }`). While focused the input shows the
+     * plain, ungrouped edit form, so display options never round or reshape the
+     * value the user is typing.
+     */
+    readonly formatOptions: _angular_core.InputSignal<Intl.NumberFormatOptions | undefined>;
+    private readonly _input;
+    private readonly _localeId;
+    protected readonly appliedLocale: _angular_core.Signal<string>;
+    /** Sanitized step — a finite positive number, defaulting to `1`. */
+    protected readonly appliedStep: _angular_core.Signal<number>;
+    protected readonly appliedBigStep: _angular_core.Signal<number>;
+    private readonly _localeInfo;
+    private readonly _displayFormat;
+    private readonly _editFormat;
+    /** Whether the input currently holds focus (raw edit format while focused). */
+    protected readonly focused: _angular_core.WritableSignal<boolean>;
+    /** Mirror of the input element's current text (drives the `empty` class). */
+    private readonly _text;
+    /**
+     * The last value applied by an internal mutation (step/commit/clear) that
+     * already set the edit text itself. Lets the value→text effect ignore those
+     * changes while focused, so a deferred flush can't clobber text the user
+     * typed right after (`undefined` = nothing applied internally yet).
+     */
+    private readonly _appliedValue;
+    /** Whether the input holds no text at all. */
+    readonly empty: _angular_core.Signal<boolean>;
+    constructor();
+    /**
+     * Steps the value by `step` (or `bigStep`) without wrapping. Uncommitted
+     * typed text is parsed and used as the base; an empty value seeds at `min`
+     * (increment) or `max` (decrement), falling back to `0` on open bounds.
+     */
+    stepValue(direction: 1 | -1, big?: boolean): boolean;
+    /** Whether stepping in `direction` is currently possible (bound not reached). */
+    canStepValue(direction: 1 | -1): boolean;
+    /** Clears value and text (invoked by a surrounding field's clear button). */
+    clearValue(): boolean;
+    /**
+     * Parses the current text and commits it to the value model: empty → `null`,
+     * out-of-range → clamped, unparseable → reverted to the last committed value.
+     */
+    private _commit;
+    private _setText;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgnNumberInput, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgnNumberInput, "input[ngnNumberInput]", ["ngnNumberInput"], { "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "bigStep": { "alias": "bigStep"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "formatOptions": { "alias": "formatOptions"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** Locale-specific separators derived from `Intl.NumberFormat`. */
+type LocaleNumberInfo = {
+    /** The decimal separator, e.g. `.` (en) or `,` (de). */
+    decimal: string;
+    /** The grouping (thousands) separator, e.g. `,` (en) or `.` (de). */
+    group: string;
+    /**
+     * The locale's digit glyphs indexed by value (`digits[0]` … `digits[9]`).
+     * Non-Latin numbering systems (e.g. `ar-EG` → `٠…٩`) are mapped back to
+     * ASCII before parsing. `null` when the locale already uses ASCII digits.
+     */
+    digits: readonly string[] | null;
+};
+/** Derives the decimal/grouping separators and digit glyphs for a locale. */
+declare function localeNumberInfo(locale: string): LocaleNumberInfo;
+type ParsedNumber = {
+    kind: 'empty';
+} | {
+    kind: 'invalid';
+} | {
+    kind: 'value';
+    value: number;
+};
+/**
+ * Parses user-typed text into a number using the locale's separators:
+ * grouping separators (and non-breaking spaces used as such) are stripped,
+ * the locale decimal separator is normalized to `.`. Exponent notation is
+ * accepted; anything else non-numeric is `invalid`.
+ */
+declare function parseLocaleNumber(text: string, info: LocaleNumberInfo): ParsedNumber;
+/** Number of decimal places of `value` (bounded to 20, exponent-safe). */
+declare function decimalPlaces(value: number): number;
+/** Rounds `value` to `decimals` decimal places (float-drift cleanup). */
+declare function roundToPrecision(value: number, decimals: number): number;
+/** Clamps `value` into `[min, max]`; open bounds when `null`/`undefined`. */
+declare function clampValue(value: number, min?: number | null, max?: number | null): number;
+/**
+ * Steps `current` by `amount` in `direction`, clamped into `[min, max]` (no
+ * wrapping). The result is rounded to the combined precision of the operands
+ * so float drift (`0.1 + 0.2`) never surfaces. Stepping from `null` seeds at
+ * `min` (increment) or `max` (decrement), falling back to `0` on open bounds.
+ */
+declare function stepNumberValue(current: number | null, direction: 1 | -1, amount: number, min?: number | null, max?: number | null): number;
+
+export { NgnNumberInput, clampValue, decimalPlaces, localeNumberInfo, parseLocaleNumber, roundToPrecision, stepNumberValue };
+export type { LocaleNumberInfo, ParsedNumber };

package/types/ngneers-controls-paginator.d.ts

@@ -0,0 +1,255 @@
+import * as _angular_core from '@angular/core';
+import * as _ngneers_signal_translate from '@ngneers/signal-translate';
+import * as _ngneers_controls_api_ng from '@ngneers/controls/api/ng';
+import * as _ngneers_controls_themes from '@ngneers/controls-themes';
+import { NgnBase } from '@ngneers/controls/base';
+import { NgnItem } from '@ngneers/controls/api';
+
+/**
+ * Defines the pagination state including current page and slice information.
+ * Depending on the context or API design, you can choose to use either page-based or slice-based pagination.
+ */
+type PaginationState = {
+    /**
+     * The current pagination state in terms of page size and current page index.
+     */
+    page: {
+        size: number;
+        current: number;
+    };
+    /**
+     * The slice of items to be displayed based on the current page and page size.
+     */
+    slice: {
+        skip: number;
+        take: number;
+    };
+};
+
+/**
+ * @category control
+ */
+declare class NgnPaginator extends NgnBase<'paginator'> {
+    protected readonly theme: _ngneers_controls_api_ng.ControlTemplateInfo<_ngneers_controls_themes.ControlTemplate<"paginator", ["root", "page-size-options", "active-page"], readonly [{
+        readonly class: "previous";
+        readonly template: _ngneers_controls_themes.ControlTemplate<"button", ["root", "inline", "loading", `kind-${string}`, `color-${string}`], readonly []>;
+    }, {
+        readonly class: "next";
+        readonly template: _ngneers_controls_themes.ControlTemplate<"button", ["root", "inline", "loading", `kind-${string}`, `color-${string}`], readonly []>;
+    }, {
+        readonly class: "page-number";
+        readonly template: _ngneers_controls_themes.ControlTemplate<"button", ["root", "inline", "loading", `kind-${string}`, `color-${string}`], readonly []>;
+    }, {
+        readonly class: "overflow";
+        readonly template: _ngneers_controls_themes.ControlTemplate<"button", ["root", "inline", "loading", `kind-${string}`, `color-${string}`], readonly []>;
+    }, {
+        readonly class: "item-view";
+        readonly template: _ngneers_controls_themes.ControlTemplate<"item-view", ["root", "item", "item-overflowing", "more-items", "more-items-hidden", "more-items-default", "hidden-separator"], readonly []>;
+    }]>>;
+    protected readonly i18n: _ngneers_signal_translate.TranslationsSignal<{
+        calendar: {
+            today: string;
+            input: string;
+            selectYear: string;
+            selectMonth: string;
+            previousMonth: string;
+            nextMonth: string;
+            weekdays: {
+                monday: string;
+                tuesday: string;
+                wednesday: string;
+                thursday: string;
+                friday: string;
+                saturday: string;
+                sunday: string;
+            };
+            weekdaysShort: {
+                monday: string;
+                tuesday: string;
+                wednesday: string;
+                thursday: string;
+                friday: string;
+                saturday: string;
+                sunday: string;
+            };
+            months: {
+                january: string;
+                february: string;
+                march: string;
+                april: string;
+                may: string;
+                june: string;
+                july: string;
+                august: string;
+                september: string;
+                october: string;
+                november: string;
+                december: string;
+            };
+        };
+        editInplace: {
+            placeholder: string;
+            confirm: string;
+        };
+        filter: {
+            noFilter: string;
+            addCondition: string;
+            removeCondition: string;
+            operator: string;
+            value: string;
+            clear: string;
+            apply: string;
+            cancel: string;
+            matchModeLabel: string;
+            match: {
+                all: string;
+                any: string;
+                and: string;
+                or: string;
+            };
+            selected: string;
+            conditions: string;
+            operators: {
+                isEqual: string;
+                isNotEqual: string;
+                contains: string;
+                startsWith: string;
+                endsWith: string;
+                in: string;
+                isEmpty: string;
+                isNotEmpty: string;
+                greaterThan: string;
+                greaterThanOrEqual: string;
+                lessThan: string;
+                lessThanOrEqual: string;
+                after: string;
+                onOrAfter: string;
+                before: string;
+                onOrBefore: string;
+                isTrue: string;
+                isFalse: string;
+                custom: string;
+            };
+        };
+        splitter: {
+            handleLabel: string;
+        };
+        inputField: {
+            clearInput: string;
+        };
+        maskInput: {
+            roleDescription: string;
+            segmentRange: string;
+            optionSeparator: string;
+        };
+        drawer: {
+            close: string;
+        };
+        dialog: {
+            close: string;
+        };
+        chip: {
+            close: string;
+        };
+        breadcrumb: {
+            overflow: string;
+        };
+        toast: {
+            close: string;
+            region: string;
+        };
+        snackbar: {
+            close: string;
+            region: string;
+            severity: {
+                error: string;
+                warning: string;
+                success: string;
+                info: string;
+            };
+        };
+        upload: {
+            upload: string;
+            uploadNamed: string;
+            retryNamed: string;
+            cancelNamed: string;
+            removeNamed: string;
+            progressNamed: string;
+        };
+        select: {
+            filterOptions: string;
+        };
+        paginator: {
+            previousPage: string;
+            nextPage: string;
+        };
+        listBox: {
+            noItemsFound: string;
+        };
+        tree: {
+            noItemsFound: string;
+        };
+        table: {
+            selectAllRows: string;
+            selectRow: string;
+            sortedBy: string;
+            sortAscending: string;
+            sortDescending: string;
+            sortCleared: string;
+            selectedCount: string;
+            page: string;
+            resultCount: string;
+        };
+        state: {
+            loading: string;
+            success: string;
+            warning: string;
+            error: string;
+            cancelled: string;
+        };
+    }, "_">;
+    /**
+     * Total number of items to paginate.
+     */
+    readonly totalItems: _angular_core.InputSignal<number>;
+    /**
+     * Number of items per page. If not set, the first value from {@link possiblePageSizes} is used.
+     */
+    readonly pageSize: _angular_core.ModelSignal<number | undefined>;
+    /**
+     * Possible page sizes to choose from.
+     * @default [5, 10, 25, 50]
+     */
+    readonly possiblePageSizes: _angular_core.InputSignalWithTransform<number[], number[]>;
+    /**
+     * If set to `true`, the page size selector will be hidden and the page size cannot be changed by the user.
+     * @default false
+     */
+    readonly fixedPageSize: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected readonly appliedPageSize: _angular_core.Signal<number>;
+    protected readonly pageCount: _angular_core.Signal<number>;
+    protected readonly pages: _angular_core.Signal<{
+        page: number;
+    }[]>;
+    protected readonly pageSizeOptions: _angular_core.Signal<NgnItem[]>;
+    /**
+     * Emits the current pagination state whenever the page or page size changes.
+     */
+    readonly value: _angular_core.OutputEmitterRef<PaginationState>;
+    /**
+     * Current page index (zero-based).
+     * @default 0
+     */
+    readonly page: _angular_core.ModelSignal<number>;
+    constructor();
+    protected previousPage(event: PointerEvent): void;
+    protected nextPage(event: PointerEvent): void;
+    protected getButtonFontStyles(page: number): {
+        [klass: string]: string;
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgnPaginator, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgnPaginator, "ngn-paginator", never, { "totalItems": { "alias": "totalItems"; "required": true; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "possiblePageSizes": { "alias": "possiblePageSizes"; "required": false; "isSignal": true; }; "fixedPageSize": { "alias": "fixedPageSize"; "required": false; "isSignal": true; }; "page": { "alias": "page"; "required": false; "isSignal": true; }; }, { "pageSize": "pageSizeChange"; "value": "value"; "page": "pageChange"; }, never, never, true, never>;
+}
+
+export { NgnPaginator };
+export type { PaginationState };

package/types/ngneers-controls-popover.d.ts

@@ -0,0 +1,116 @@
+import * as _floating_ui_dom from '@floating-ui/dom';
+import { Placement } from '@floating-ui/dom';
+import * as _angular_core from '@angular/core';
+import { TemplateRef, ElementRef } from '@angular/core';
+import * as _ngneers_controls_api_ng from '@ngneers/controls/api/ng';
+import { PositioningSizeConstraints, Openable, Anchor, PopoverCloseBy } from '@ngneers/controls/api/ng';
+import * as _ngneers_controls_themes from '@ngneers/controls-themes';
+import { NgnBase } from '@ngneers/controls/base';
+
+/**
+ * Template projection for {@link NgnPopover}, extracted into a dedicated base class so the
+ * component itself stays focused on positioning and open/close behavior.
+ */
+declare abstract class PopoverTemplates extends NgnBase<'popover'> {
+    /**
+     * User-provided lazy content, projected via an `<ng-template #lazy>` inside the popover.
+     * Rendered only once the popover first opens.
+     */
+    protected readonly lazyContent: _angular_core.Signal<TemplateRef<unknown> | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PopoverTemplates, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<PopoverTemplates, never, never, {}, {}, ["lazyContent"], never, true, never>;
+}
+
+type PopoverOptions = {
+    /**
+     * Constraints for the size of the popover.
+     */
+    sizeConstraints?: PositioningSizeConstraints;
+    /**
+     * If true, the content of the popover will be cached and not recreated on each open.
+     * This is useful for performance when the content is expensive to create.
+     */
+    cache?: boolean;
+    /**
+     * The placement of the popover relative to the anchor element.
+     */
+    placement?: Placement;
+    /**
+     * The padding of the popover content.
+     */
+    padding?: number;
+};
+
+/**
+ * @category control
+ */
+declare class NgnPopover extends PopoverTemplates implements Openable {
+    protected readonly theme: _ngneers_controls_api_ng.ControlTemplateInfo<_ngneers_controls_themes.ControlTemplate<"popover", ["root", "content", "content-closing"], readonly []>>;
+    /**
+     * Emits when the popover has fully closed.
+     */
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    /**
+     * Emits when the popover is closed.
+     */
+    readonly closing: _angular_core.OutputEmitterRef<void>;
+    /**
+     * Shows or hides the popover.
+     *
+     * You probably want to react to openChange events from outside to update your variable accordingly.
+     */
+    readonly open: _angular_core.ModelSignal<boolean>;
+    /**
+     * The element to which the popover is anchored.
+     */
+    readonly anchor: _angular_core.InputSignal<Anchor>;
+    /**
+     * The popover options.
+     */
+    readonly options: _angular_core.InputSignal<PopoverOptions | undefined>;
+    /**
+     * Set to true for scrollable/shrink-able content
+     */
+    readonly hasShrinkableContent: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * How the popover closes depending on user interaction.
+     * @default any
+     */
+    readonly closeBy: _angular_core.InputSignal<PopoverCloseBy>;
+    protected readonly _content: _angular_core.Signal<ElementRef<HTMLElement>>;
+    protected readonly closeByPopover: _angular_core.Signal<"auto" | "manual">;
+    protected readonly isFullyClosed: _angular_core.WritableSignal<boolean>;
+    private _skipEmitCloseEvent;
+    private _triggeredByInput;
+    private _internalToggle;
+    protected readonly appliedOptions: _angular_core.Signal<{
+        sizeConstraints?: _ngneers_controls_api_ng.PositioningSizeConstraints;
+        cache: boolean;
+        placement?: _floating_ui_dom.Placement;
+        padding?: number;
+    }>;
+    private readonly _injector;
+    private readonly _cdr;
+    private readonly _popoverRef;
+    private readonly _popover;
+    private readonly _autoPos;
+    constructor();
+    /**
+     * Opens the popover. Alternatively, you can also set the {@link open} input to `true`.
+     */
+    show(): void;
+    /**
+     * Closes the popover. Alternatively, you can also set the {@link open} input to `false`.
+     */
+    hide(emitCloseEvent?: boolean): void;
+    /**
+     * Toggles the popover open or closed. Alternatively, you can also set the {@link open} input accordingly.
+     */
+    toggle(): void;
+    protected onToggle(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgnPopover, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgnPopover, "ngn-popover", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "anchor": { "alias": "anchor"; "required": true; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "hasShrinkableContent": { "alias": "hasShrinkableContent"; "required": false; "isSignal": true; }; "closeBy": { "alias": "closeBy"; "required": false; "isSignal": true; }; }, { "closed": "closed"; "closing": "closing"; "open": "openChange"; }, never, ["*"], true, never>;
+}
+
+export { NgnPopover };
+export type { PopoverOptions };

package/types/ngneers-controls-progress.d.ts

@@ -0,0 +1,49 @@
+import * as _angular_core from '@angular/core';
+import * as _ngneers_controls_api_ng from '@ngneers/controls/api/ng';
+import * as _ngneers_controls_themes from '@ngneers/controls-themes';
+import { NgnBase } from '@ngneers/controls/base';
+
+/**
+ * @category control
+ */
+declare class NgnProgress extends NgnBase<'progress'> {
+    protected readonly theme: _ngneers_controls_api_ng.ControlTemplateInfo<_ngneers_controls_themes.ControlTemplate<"progress", ["root", "svg", "track", "indeterminate", "circular", "fill", "fill2"], readonly []>>;
+    /**
+     * The current progress value, clamped to the 0-100 range.
+     * @default 0
+     */
+    readonly value: _angular_core.InputSignal<number>;
+    /**
+     * Whether the progress indicator is indeterminate (animated, no fixed value).
+     * @default false
+     */
+    readonly indeterminate: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Whether the progress indicator renders as a circle instead of a bar.
+     * @default false
+     */
+    readonly circular: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Radius of the circular progress indicator, in px. Only applies when {@link circular} is `true`.
+     * @default 40
+     */
+    readonly radius: _angular_core.InputSignal<number>;
+    /**
+     * Thickness of the circular progress indicator stroke, in px. Only applies when {@link circular} is `true`.
+     * @default 8
+     */
+    readonly thickness: _angular_core.InputSignal<number>;
+    protected readonly safeValue: _angular_core.Signal<number>;
+    protected readonly safeRadius: _angular_core.Signal<number>;
+    protected readonly safeThickness: _angular_core.Signal<number>;
+    protected readonly svgSize: _angular_core.Signal<number>;
+    protected readonly svgCenter: _angular_core.Signal<number>;
+    protected readonly circumference: _angular_core.Signal<number>;
+    protected readonly strokeDasharray: _angular_core.Signal<string>;
+    protected readonly strokeDashoffset: _angular_core.Signal<string>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgnProgress, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgnProgress, "ngn-progress", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "indeterminate": { "alias": "indeterminate"; "required": false; "isSignal": true; }; "circular": { "alias": "circular"; "required": false; "isSignal": true; }; "radius": { "alias": "radius"; "required": false; "isSignal": true; }; "thickness": { "alias": "thickness"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { NgnProgress };

package/types/ngneers-controls-radio.d.ts

@@ -0,0 +1,91 @@
+import * as _ngneers_controls_api_ng from '@ngneers/controls/api/ng';
+import * as _ngneers_controls_themes from '@ngneers/controls-themes';
+import { ValueControlBase, NgnBase } from '@ngneers/controls/base';
+import * as i1 from '@ngneers/controls/roving-focus';
+import { NgnRovingGroup } from '@ngneers/controls/roving-focus';
+import * as _angular_core from '@angular/core';
+import { InjectionToken, Signal } from '@angular/core';
+
+/**
+ * A single radio option registered with its enclosing group. The group keys
+ * selection and keyboard coordination off these refs; `element` correlates a
+ * roving-focus item back to its payload `value`.
+ */
+interface NgnRadioRef<V> {
+    readonly element: HTMLElement;
+    /** The option payload this radio contributes to the group value. */
+    readonly value: Signal<V>;
+    /** Effective disabled state (own disabled OR the group being disabled). */
+    readonly disabled: Signal<boolean>;
+}
+/**
+ * The slice of the radio group that child `ngn-radio`s consume. Kept as a
+ * token + interface (rather than the concrete class) so the child never imports
+ * the group component — avoiding a circular dependency between the two files.
+ */
+interface NgnRadioGroupApi<V> {
+    /** The currently selected group value. */
+    readonly value: Signal<V>;
+    /** Whether the whole group is disabled. */
+    readonly disabled: Signal<boolean>;
+    /** Whether the group is read-only (navigable, but selection is frozen). */
+    readonly readonly: Signal<boolean>;
+    register(ref: NgnRadioRef<V>): void;
+    unregister(ref: NgnRadioRef<V>): void;
+}
+declare const NGN_RADIO_GROUP: InjectionToken<NgnRadioGroupApi<unknown>>;
+
+/**
+ * A themed radio group. Owns the selected {@link value}; the individual
+ * `ngn-radio` children projected inside are presentational and report their
+ * payload up through {@link register}.
+ *
+ * Keyboard handling and roving tab order are delegated to `NgnRovingGroup`
+ * (applied as a host directive). Selection follows focus: moving the roving
+ * active item (arrows / Home / End / pointer) selects it, matching native
+ * radio-group behavior.
+ *
+ * @category control
+ */
+declare class NgnRadioGroup<V> extends ValueControlBase<'radioGroup', V> implements NgnRadioGroupApi<V> {
+    protected readonly theme: _ngneers_controls_api_ng.ControlTemplateInfo<_ngneers_controls_themes.ControlTemplate<"radio-group", ["root", "invalid"], readonly []>>;
+    /** The roving-focus host directive that drives keyboard/tab coordination. */
+    protected readonly roving: NgnRovingGroup;
+    private readonly _radios;
+    register(ref: NgnRadioRef<V>): void;
+    unregister(ref: NgnRadioRef<V>): void;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgnRadioGroup<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgnRadioGroup<any>, "ngn-radio-group", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.NgnRovingGroup; inputs: { "orientation": "orientation"; "rovingWrap": "rovingWrap"; }; outputs: {}; }]>;
+}
+
+/**
+ * A single radio option. Must be projected inside an `ngn-radio-group`, which
+ * owns the selected value — this control only contributes its {@link value}
+ * payload and renders the themed dot. The label is authored via content
+ * projection (`<ngn-radio [value]="…">Label</ngn-radio>`) with an optional
+ * {@link label} input fallback.
+ *
+ * @category control
+ */
+declare class NgnRadio<V> extends NgnBase<'radio'> {
+    protected readonly theme: _ngneers_controls_api_ng.ControlTemplateInfo<_ngneers_controls_themes.ControlTemplate<"radio", ["root", "circle", "circle-checked", "dot", "label"], readonly []>>;
+    /** The payload this radio selects into the enclosing group. */
+    readonly value: _angular_core.InputSignal<V>;
+    /** Disables this individual option. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Optional accessible label; overrides projected content for the a11y name. */
+    readonly label: _angular_core.InputSignal<string | null>;
+    private readonly _group;
+    private readonly _rovingItem;
+    /** Whether this radio is the currently selected option in its group. */
+    protected readonly checked: _angular_core.Signal<boolean>;
+    /** Disabled if this option or the whole group is disabled. */
+    protected readonly effectiveDisabled: _angular_core.Signal<boolean>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgnRadio<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgnRadio<any>, "ngn-radio", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.NgnRovingItem; inputs: {}; outputs: {}; }]>;
+}
+
+export { NGN_RADIO_GROUP, NgnRadio, NgnRadioGroup };
+export type { NgnRadioGroupApi, NgnRadioRef };