@radix-ng/primitives 0.42.0 → 0.44.0

package/tabs/index.d.ts

@@ -1,14 +1,112 @@
-import * as i0 from "@angular/core";
-import * as i1 from "./src/tabs-root.directive";
-import * as i2 from "./src/tabs-content.directive";
-import * as i3 from "./src/tabs-list.directive";
-import * as i4 from "./src/tabs-trigger.directive";
-export * from './src/tabs-content.directive';
-export * from './src/tabs-list.directive';
-export * from './src/tabs-root.directive';
-export * from './src/tabs-trigger.directive';
-export declare class RdxTabsModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxTabsModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxTabsModule, never, [typeof i1.RdxTabsRootDirective, typeof i2.RdxTabsContentDirective, typeof i3.RdxTabsListDirective, typeof i4.RdxTabsTriggerDirective], [typeof i1.RdxTabsRootDirective, typeof i2.RdxTabsContentDirective, typeof i3.RdxTabsListDirective, typeof i4.RdxTabsTriggerDirective]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<RdxTabsModule>;
+import * as _angular_core from '@angular/core';
+import { OnInit, InjectionToken, InputSignalWithTransform } from '@angular/core';
+import * as i1 from '@radix-ng/primitives/roving-focus';
+import { BooleanInput } from '@angular/cdk/coercion';
+
+interface TabsProps {
+    /** The value for the selected tab, if controlled */
+    value?: string;
+    /** The value of the tab to select by default, if uncontrolled */
+    defaultValue?: string;
+    /** A function called when a new tab is selected */
+    onValueChange?: (value: string) => void;
+    /**
+     * The orientation the tabs are layed out.
+     * Mainly so arrow navigation is done accordingly (left & right vs. up & down)
+     * @defaultValue horizontal
+     */
+    orientation?: string;
+    /**
+     * The direction of navigation between toolbar items.
+     */
+    dir?: string;
+    /**
+     * Whether a tab is activated automatically or manually.
+     * @defaultValue automatic
+     * */
+    activationMode?: 'automatic' | 'manual';
 }
+type DataOrientation = 'vertical' | 'horizontal';
+declare const RDX_TABS_ROOT_TOKEN: InjectionToken<RdxTabsRootDirective>;
+declare class RdxTabsRootDirective implements OnInit {
+    /**
+     * The controlled value of the tab to activate. Should be used in conjunction with `onValueChange`.
+     */
+    readonly value: _angular_core.ModelSignal<string | undefined>;
+    readonly defaultValue: _angular_core.InputSignal<string | undefined>;
+    /**
+     * When automatic, tabs are activated when receiving focus. When manual, tabs are activated when clicked.
+     */
+    readonly activationMode: _angular_core.InputSignal<"automatic" | "manual">;
+    /**
+     * The orientation of the component.
+     */
+    readonly orientation: _angular_core.InputSignal<DataOrientation>;
+    readonly dir: _angular_core.InputSignal<string>;
+    /**
+     * Event handler called when the value changes.
+     */
+    readonly onValueChange: _angular_core.OutputEmitterRef<string>;
+    ngOnInit(): void;
+    select(value: string): void;
+    /** @ignore */
+    getBaseId(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxTabsRootDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxTabsRootDirective, "[rdxTabsRoot]", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "activationMode": { "alias": "activationMode"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "dir": { "alias": "dir"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "onValueChange": "onValueChange"; }, never, never, true, never>;
+}
+
+declare class RdxTabsContentDirective {
+    protected readonly tabsContext: RdxTabsRootDirective;
+    /**
+     * A unique value that associates the content with a trigger.
+     */
+    readonly value: _angular_core.InputSignal<string>;
+    protected readonly contentId: _angular_core.Signal<string>;
+    protected readonly triggerId: _angular_core.Signal<string>;
+    protected readonly selected: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxTabsContentDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxTabsContentDirective, "[rdxTabsContent]", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface TabsListProps {
+    loop?: boolean;
+}
+declare class RdxTabsListDirective {
+    protected readonly tabsContext: RdxTabsRootDirective;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxTabsListDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxTabsListDirective, "[rdxTabsList]", never, {}, {}, never, never, true, [{ directive: typeof i1.RdxRovingFocusGroupDirective; inputs: { "dir": "dir"; "orientation": "orientation"; "loop": "loop"; }; outputs: {}; }]>;
+}
+
+interface TabsTriggerProps {
+    disabled: InputSignalWithTransform<boolean, BooleanInput>;
+}
+declare class RdxTabsTriggerDirective implements TabsTriggerProps {
+    private readonly rdxRovingFocusItemDirective;
+    protected readonly tabsContext: RdxTabsRootDirective;
+    /**
+     * A unique value that associates the trigger with a content.
+     */
+    readonly value: _angular_core.InputSignal<string>;
+    /**
+     * When true, prevents the user from interacting with the tab.
+     */
+    readonly disabled: InputSignalWithTransform<boolean, BooleanInput>;
+    protected readonly contentId: _angular_core.Signal<string>;
+    protected readonly triggerId: _angular_core.Signal<string>;
+    protected readonly isSelected: _angular_core.Signal<boolean>;
+    constructor();
+    protected onMouseDown(event: MouseEvent): void;
+    protected onKeyDown(event: KeyboardEvent): void;
+    protected onFocus(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxTabsTriggerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxTabsTriggerDirective, "[rdxTabsTrigger]", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.RdxRovingFocusItemDirective; inputs: { "focusable": "focusable"; "active": "active"; "allowShiftKey": "allowShiftKey"; }; outputs: {}; }]>;
+}
+
+declare class RdxTabsModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxTabsModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<RdxTabsModule, never, [typeof RdxTabsRootDirective, typeof RdxTabsContentDirective, typeof RdxTabsListDirective, typeof RdxTabsTriggerDirective], [typeof RdxTabsRootDirective, typeof RdxTabsContentDirective, typeof RdxTabsListDirective, typeof RdxTabsTriggerDirective]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<RdxTabsModule>;
+}
+
+export { RDX_TABS_ROOT_TOKEN, RdxTabsContentDirective, RdxTabsListDirective, RdxTabsModule, RdxTabsRootDirective, RdxTabsTriggerDirective };
+export type { DataOrientation, TabsListProps, TabsProps };

package/time-field/index.d.ts

@@ -1,11 +1,212 @@
-import * as i0 from "@angular/core";
-import * as i1 from "./src/time-field-root.directive";
-import * as i2 from "./src/time-field-input.directive";
-export * from './src/time-field-context.token';
-export * from './src/time-field-input.directive';
-export * from './src/time-field-root.directive';
-export declare class RdxTimeFieldModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxTimeFieldModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxTimeFieldModule, never, [typeof i1.RdxTimeFieldRootDirective, typeof i2.RdxTimeFieldInputDirective], [typeof i1.RdxTimeFieldRootDirective, typeof i2.RdxTimeFieldInputDirective]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<RdxTimeFieldModule>;
+import * as _angular_core from '@angular/core';
+import { OnInit, AfterViewInit, WritableSignal, InputSignal, ModelSignal, Signal, InjectionToken } from '@angular/core';
+import * as _radix_ng_primitives_core from '@radix-ng/primitives/core';
+import { TimeValue, HourCycle, Granularity, DateStep, Formatter, SegmentValueObj, SegmentPart } from '@radix-ng/primitives/core';
+import * as _internationalized_date from '@internationalized/date';
+import { Direction } from '@angular/cdk/bidi';
+import { BooleanInput } from '@angular/cdk/coercion';
+
+declare class RdxTimeFieldRootDirective implements OnInit, AfterViewInit {
+    private readonly elementRef;
+    /**
+     * The controlled checked state of the calendar.
+     */
+    readonly value: _angular_core.ModelSignal<TimeValue | undefined>;
+    /**
+     * The hour cycle to use for formatting times. Defaults to the locale preference
+     */
+    readonly hourCycle: _angular_core.InputSignal<HourCycle>;
+    /**
+     * The granularity to use for formatting the field. Defaults to 'day' if a CalendarDate is provided, otherwise defaults to 'minute'.
+     * The field will render segments for each part of the date up to and including the specified granularity.
+     */
+    readonly granularity: _angular_core.InputSignal<Granularity | undefined>;
+    /**
+     * The locale to use for formatting dates.
+     */
+    readonly locale: _angular_core.InputSignal<string>;
+    readonly dir: _angular_core.InputSignal<Direction>;
+    /**
+     * The minimum valid date that can be entered.
+     */
+    readonly minValue: _angular_core.InputSignal<TimeValue | undefined>;
+    /**
+     * The maximum valid date that can be entered.
+     */
+    readonly maxValue: _angular_core.InputSignal<TimeValue | undefined>;
+    /**
+     * Whether or not to hide the time zone segment of the field.
+     */
+    readonly hideTimeZone: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Whether or not the field is readonly.
+     */
+    readonly readonly: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * The stepping interval for the time fields. Defaults to 1
+     */
+    readonly step: _angular_core.InputSignal<DateStep | undefined>;
+    readonly step$: _angular_core.Signal<DateStep>;
+    /**
+     * @ignore
+     */
+    readonly defaultDate: _angular_core.Signal<TimeValue>;
+    /**
+     * The placeholder date, which is used to determine what month to display when no date is selected. This updates as the user navigates the calendar and can be used to programmatically control the calendar view
+     */
+    readonly placeholder: _angular_core.ModelSignal<TimeValue | undefined>;
+    /**
+     * @ignore
+     */
+    readonly segmentElements: _angular_core.WritableSignal<Set<HTMLElement>>;
+    /**
+     * @ignore
+     */
+    readonly currentFocusedElement: _angular_core.WritableSignal<HTMLElement | null>;
+    /**
+     * @ignore
+     */
+    formatter: Formatter;
+    /**
+     * @ignore
+     */
+    readonly segmentValues: _angular_core.WritableSignal<SegmentValueObj>;
+    /**
+     * @ignore
+     */
+    readonly inferredGranularity: _angular_core.Signal<Granularity | undefined>;
+    readonly convertedMinValue: _angular_core.Signal<_internationalized_date.CalendarDateTime | _internationalized_date.ZonedDateTime | undefined>;
+    readonly convertedMaxValue: _angular_core.Signal<_internationalized_date.CalendarDateTime | _internationalized_date.ZonedDateTime | undefined>;
+    readonly convertedModelValue: _angular_core.WritableSignal<TimeValue | undefined>;
+    readonly convertedPlaceholder: _angular_core.WritableSignal<TimeValue>;
+    /**
+     * @ignore
+     */
+    readonly isInvalid: _angular_core.Signal<boolean>;
+    /**
+     * @ignore
+     */
+    readonly allSegmentContent: _angular_core.Signal<{
+        obj: _radix_ng_primitives_core.SegmentContentObj;
+        arr: {
+            part: _radix_ng_primitives_core.SegmentPart;
+            value: string;
+        }[];
+    }>;
+    /**
+     * An array of segments that should be readonly, which prevent user input on them.
+     */
+    readonly segmentContents: _angular_core.Signal<{
+        part: _radix_ng_primitives_core.SegmentPart;
+        value: string;
+    }[]>;
+    /**
+     * @ignore
+     */
+    readonly currentSegmentIndex: _angular_core.Signal<number>;
+    /**
+     * @ignore
+     */
+    readonly prevFocusableSegment: _angular_core.Signal<HTMLElement | null>;
+    /**
+     * @ignore
+     */
+    readonly nextFocusableSegment: _angular_core.Signal<HTMLElement | null>;
+    /**
+     * @ignore
+     */
+    readonly focusNext: () => void;
+    constructor();
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    /**
+     * @ignore
+     */
+    onKeydown(event: KeyboardEvent): void;
+    /**
+     * @ignore
+     */
+    setFocusedElement(el: HTMLElement): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxTimeFieldRootDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxTimeFieldRootDirective, "[rdxTimeFieldRoot]", ["rdxTimeFieldRoot"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "hourCycle": { "alias": "hourCycle"; "required": false; "isSignal": true; }; "granularity": { "alias": "granularity"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "dir": { "alias": "dir"; "required": false; "isSignal": true; }; "minValue": { "alias": "minValue"; "required": false; "isSignal": true; }; "maxValue": { "alias": "maxValue"; "required": false; "isSignal": true; }; "hideTimeZone": { "alias": "hideTimeZone"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "placeholder": "placeholderChange"; }, never, never, true, never>;
 }
+
+declare class RdxTimeFieldInputDirective {
+    private readonly el;
+    private readonly rootContext;
+    /**
+     * The part of the date to render
+     * `'hour' | 'minute' | 'second' | 'dayPeriod' | 'literal' | 'timeZoneName'`
+     */
+    readonly part: _angular_core.InputSignal<SegmentPart | undefined>;
+    /**
+     * @ignore
+     */
+    readonly disabled: _angular_core.Signal<boolean>;
+    /**
+     * @ignore
+     */
+    readonly readonly: _angular_core.Signal<boolean>;
+    /**
+     * @ignore
+     */
+    readonly isInvalid: _angular_core.Signal<boolean>;
+    /**
+     * @ignore
+     */
+    readonly hasLeftFocus: WritableSignal<boolean>;
+    /**
+     * @ignore
+     */
+    readonly lastKeyZero: WritableSignal<boolean>;
+    private readonly fieldData;
+    private readonly attributes;
+    /**
+     * @ignore
+     */
+    handleSegmentClick: (e: MouseEvent) => void;
+    /**
+     * @ignore
+     */
+    handleSegmentKeydown: (e: KeyboardEvent) => void;
+    constructor();
+    /**
+     * @ignore
+     */
+    onFocus(e: FocusEvent): void;
+    /**
+     * @ignore
+     */
+    onFocusOut(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxTimeFieldInputDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxTimeFieldInputDirective, "[rdxTimeFieldInput]", never, { "part": { "alias": "part"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface TimeFieldContextToken {
+    locale: InputSignal<string>;
+    value: ModelSignal<TimeValue | undefined>;
+    placeholder: ModelSignal<TimeValue>;
+    isInvalid: Signal<boolean>;
+    disabled: InputSignal<boolean>;
+    readonly: InputSignal<boolean>;
+    formatter: Formatter;
+    hourCycle: InputSignal<HourCycle>;
+    segmentValues: WritableSignal<SegmentValueObj>;
+    focusNext: () => void;
+    setFocusedElement: (el: HTMLElement) => void;
+    convertedModelValue: WritableSignal<TimeValue | undefined>;
+    convertedPlaceholder: WritableSignal<TimeValue>;
+    step$: Signal<DateStep>;
+}
+declare const TIME_FIELDS_ROOT_CONTEXT: InjectionToken<TimeFieldContextToken>;
+declare function injectTimeFieldsRootContext(): TimeFieldContextToken;
+
+declare class RdxTimeFieldModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxTimeFieldModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<RdxTimeFieldModule, never, [typeof RdxTimeFieldRootDirective, typeof RdxTimeFieldInputDirective], [typeof RdxTimeFieldRootDirective, typeof RdxTimeFieldInputDirective]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<RdxTimeFieldModule>;
+}
+
+export { RdxTimeFieldInputDirective, RdxTimeFieldModule, RdxTimeFieldRootDirective, TIME_FIELDS_ROOT_CONTEXT, injectTimeFieldsRootContext };
+export type { TimeFieldContextToken };

package/toggle/index.d.ts

@@ -1,3 +1,75 @@
-export * from './src/toggle-visually-hidden-input.directive';
-export * from './src/toggle.directive';
-export type { DataState, ToggleProps } from './src/toggle.directive';
+import * as _angular_core from '@angular/core';
+import { OutputEmitterRef } from '@angular/core';
+import * as i1 from '@radix-ng/primitives/visually-hidden';
+import { BooleanInput } from '@angular/cdk/coercion';
+import * as i1$1 from '@radix-ng/primitives/core';
+import { RdxControlValueAccessor } from '@radix-ng/primitives/core';
+
+declare class RdxToggleVisuallyHiddenInputDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxToggleVisuallyHiddenInputDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxToggleVisuallyHiddenInputDirective, "input[rdxToggleVisuallyHiddenInput]", ["rdxToggleVisuallyHiddenInput"], {}, {}, never, never, true, [{ directive: typeof i1.RdxVisuallyHiddenInputDirective; inputs: { "name": "name"; "required": "required"; "value": "value"; "disabled": "disabled"; }; outputs: {}; }]>;
+}
+
+interface ToggleProps {
+    /**
+     * The controlled state of the toggle.
+     */
+    pressed?: boolean;
+    /**
+     * The state of the toggle when initially rendered. Use `defaultPressed`
+     * if you do not need to control the state of the toggle.
+     * @defaultValue false
+     */
+    defaultPressed?: boolean;
+    /**
+     * The callback that fires when the state of the toggle changes.
+     */
+    onPressedChange?: OutputEmitterRef<boolean>;
+    /**
+     * Whether the toggle is disabled.
+     * @defaultValue false
+     */
+    disabled?: boolean;
+}
+type DataState = 'on' | 'off';
+/**
+ * @group Components
+ */
+declare class RdxToggleDirective {
+    /**
+     * @ignore
+     */
+    readonly cva: RdxControlValueAccessor<any>;
+    /**
+     * The pressed state of the toggle when it is initially rendered.
+     * Use when you do not need to control its pressed state.
+     *
+     * @group Props
+     */
+    readonly defaultPressed: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * The controlled pressed state of the toggle.
+     * Must be used in conjunction with `onPressedChange`.
+     *
+     * @group Props
+     */
+    readonly pressed: _angular_core.ModelSignal<boolean>;
+    /**
+     * When true, prevents the user from interacting with the toggle.
+     *
+     * @group Props
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Event handler called when the pressed state of the toggle changes.
+     *
+     * @group Emits
+     */
+    readonly onPressedChange: _angular_core.OutputRef<any>;
+    protected onClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxToggleDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxToggleDirective, "[rdxToggle]", ["rdxToggle"], { "defaultPressed": { "alias": "defaultPressed"; "required": false; "isSignal": true; }; "pressed": { "alias": "pressed"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "pressed": "pressedChange"; "onPressedChange": "onPressedChange"; }, never, never, true, [{ directive: typeof i1$1.RdxControlValueAccessor; inputs: { "value": "pressed"; "disabled": "disabled"; }; outputs: {}; }]>;
+}
+
+export { RdxToggleDirective, RdxToggleVisuallyHiddenInputDirective };
+export type { DataState, ToggleProps };

package/toggle-group/index.d.ts

@@ -1,5 +1,194 @@
-export * from './src/toggle-group-item.directive';
-export * from './src/toggle-group-item.token';
-export * from './src/toggle-group-without-focus.directive';
-export * from './src/toggle-group.directive';
-export * from './src/toggle-group.token';
+import * as _angular_core from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import { BooleanInput } from '@angular/cdk/coercion';
+import * as i1 from '@radix-ng/primitives/roving-focus';
+import * as i2 from '@radix-ng/primitives/toggle';
+import { ControlValueAccessor } from '@angular/forms';
+import { AcceptableValue } from '@radix-ng/primitives/core';
+
+interface IRdxToggleGroup {
+    toggle(value: string): void;
+    disabled: any;
+    value: any;
+    type: any;
+    accessorDisabled: any;
+}
+declare const RdxToggleGroupToken: InjectionToken<IRdxToggleGroup>;
+declare function injectToggleGroup(): IRdxToggleGroup;
+
+/**
+ * @group Components
+ */
+declare class RdxToggleGroupItemDirective {
+    private readonly rdxToggleDirective;
+    private readonly rdxRovingFocusItemDirective;
+    /**
+     * Access the toggle group.
+     * @ignore
+     */
+    protected readonly rootContext: IRdxToggleGroup;
+    /**
+     * The value of this toggle button.
+     *
+     * @group Props
+     */
+    readonly value: _angular_core.InputSignal<string>;
+    /**
+     * Whether this toggle button is disabled.
+     * @defaultValue false
+     * @group Props
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    private readonly isPressed;
+    private readonly isDisabled;
+    constructor();
+    /**
+     * @ignore
+     */
+    toggle(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxToggleGroupItemDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxToggleGroupItemDirective, "[rdxToggleGroupItem]", ["rdxToggleGroupItem"], { "value": { "alias": "value"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.RdxRovingFocusItemDirective; inputs: { "focusable": "focusable"; "active": "active"; "allowShiftKey": "allowShiftKey"; }; outputs: {}; }, { directive: typeof i2.RdxToggleDirective; inputs: { "pressed": "pressed"; "disabled": "disabled"; }; outputs: {}; }]>;
+}
+
+declare const RdxToggleGroupItemToken: InjectionToken<RdxToggleGroupItemDirective>;
+declare function injectToggleGroupItem(): RdxToggleGroupItemDirective;
+
+declare class RdxToggleGroupWithoutFocusDirective implements ControlValueAccessor {
+    /**
+     * @ignore
+     */
+    readonly id: string;
+    /**
+     * @group Props
+     */
+    readonly value: _angular_core.ModelSignal<string | string[] | undefined>;
+    /**
+     * @group Props
+     */
+    readonly type: _angular_core.InputSignal<"single" | "multiple">;
+    /**
+     * Whether the toggle group is disabled.
+     * @defaultValue false
+     * @group Props
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Event emitted when the selected toggle button changes.
+     * @group Emits
+     */
+    readonly onValueChange: _angular_core.OutputEmitterRef<string | string[] | undefined>;
+    /**
+     * The value change callback.
+     */
+    private onChange?;
+    /**
+     * onTouch function registered via registerOnTouch (ControlValueAccessor).
+     */
+    protected onTouched?: () => void;
+    /**
+     * Toggle a value.
+     * @param value The value to toggle.
+     * @ignore
+     */
+    toggle(value: string): void;
+    /**
+     * Select a value from Angular forms.
+     * @param value The value to select.
+     * @ignore
+     */
+    writeValue(value: string): void;
+    /**
+     * Register a callback to be called when the value changes.
+     * @param fn The callback to register.
+     * @ignore
+     */
+    registerOnChange(fn: (value: string | string[] | undefined) => void): void;
+    /**
+     * Register a callback to be called when the toggle group is touched.
+     * @param fn The callback to register.
+     * @ignore
+     */
+    registerOnTouched(fn: () => void): void;
+    private readonly accessorDisabled;
+    /**
+     * Set the disabled state of the toggle group.
+     * @param isDisabled Whether the toggle group is disabled.
+     * @ignore
+     */
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxToggleGroupWithoutFocusDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxToggleGroupWithoutFocusDirective, "[rdxToggleGroupWithoutFocus]", ["rdxToggleGroupWithoutFocus"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "onValueChange": "onValueChange"; }, never, never, true, never>;
+}
+
+/**
+ * @group Components
+ */
+declare class RdxToggleGroupDirective implements ControlValueAccessor {
+    /**
+     * @ignore
+     */
+    readonly id: string;
+    /**
+     * @group Props
+     */
+    readonly value: _angular_core.ModelSignal<AcceptableValue | AcceptableValue[] | undefined>;
+    /**
+     * @group Props
+     */
+    readonly type: _angular_core.InputSignal<"single" | "multiple">;
+    /**
+     * Whether the toggle group is disabled.
+     * @defaultValue false
+     * @group Props
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Event emitted when the selected toggle button changes.
+     * @group Emits
+     */
+    readonly onValueChange: _angular_core.OutputEmitterRef<AcceptableValue | AcceptableValue[] | undefined>;
+    /**
+     * The value change callback.
+     */
+    private onChange?;
+    /**
+     * onTouch function registered via registerOnTouch (ControlValueAccessor).
+     */
+    protected onTouched?: () => void;
+    /**
+     * Toggle a value.
+     * @param value The value to toggle.
+     * @ignore
+     */
+    toggle(value: AcceptableValue): void;
+    /**
+     * Select a value from Angular forms.
+     * @param value The value to select.
+     * @ignore
+     */
+    writeValue(value: string): void;
+    /**
+     * Register a callback to be called when the value changes.
+     * @param fn The callback to register.
+     * @ignore
+     */
+    registerOnChange(fn: (value: AcceptableValue | AcceptableValue[] | undefined) => void): void;
+    /**
+     * Register a callback to be called when the toggle group is touched.
+     * @param fn The callback to register.
+     * @ignore
+     */
+    registerOnTouched(fn: () => void): void;
+    readonly accessorDisabled: _angular_core.WritableSignal<boolean>;
+    /**
+     * Set the disabled state of the toggle group.
+     * @param isDisabled Whether the toggle group is disabled.
+     * @ignore
+     */
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxToggleGroupDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxToggleGroupDirective, "[rdxToggleGroup]", ["rdxToggleGroup"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "onValueChange": "onValueChange"; }, never, never, true, [{ directive: typeof i1.RdxRovingFocusGroupDirective; inputs: { "dir": "dir"; "orientation": "orientation"; "loop": "loop"; }; outputs: {}; }]>;
+}
+
+export { RdxToggleGroupDirective, RdxToggleGroupItemDirective, RdxToggleGroupItemToken, RdxToggleGroupToken, RdxToggleGroupWithoutFocusDirective, injectToggleGroup, injectToggleGroupItem };
+export type { IRdxToggleGroup };