@radix-ng/primitives 0.51.0 → 1.0.0-beta.1

package/types/radix-ng-primitives-toggle-group.d.ts

@@ -1,195 +1,117 @@
 import * as _angular_core from '@angular/core';
-import { InjectionToken } from '@angular/core';
-import * as _radix_ng_primitives_toggle_group from '@radix-ng/primitives/toggle-group';
-import { BooleanInput } from '@angular/cdk/coercion';
+import { Signal } from '@angular/core';
+import * as _radix_ng_primitives_core from '@radix-ng/primitives/core';
+import { DataOrientation, BooleanInput } from '@radix-ng/primitives/core';
 import * as i1 from '@radix-ng/primitives/roving-focus';
-import * as i2 from '@radix-ng/primitives/toggle';
+import { Direction } from '@radix-ng/primitives/roving-focus';
 import { ControlValueAccessor } from '@angular/forms';
-import { AcceptableValue } from '@radix-ng/primitives/core';
 
 /**
- * @group Components
+ * Shared state a {@link RdxToggle} reads when it participates in a toggle group.
  */
-declare class RdxToggleGroupItemDirective {
-    private readonly rdxToggleDirective;
-    private readonly rdxRovingFocusItemDirective;
-    /**
-     * Access the toggle group.
-     * @ignore
-     */
-    protected readonly rootContext: _radix_ng_primitives_toggle_group.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: {}; }]>;
+interface RdxToggleGroupContext {
+    /** The currently pressed values. */
+    readonly value: Signal<string[]>;
+    /** Whether the whole group is disabled. */
+    readonly disabled: Signal<boolean>;
+    /** Whether more than one item can be pressed at a time. */
+    readonly multiple: Signal<boolean>;
+    /** The orientation of the group. */
+    readonly orientation: Signal<DataOrientation>;
+    /** Toggle the pressed state of `value` within the group. */
+    toggle(value: string): void;
 }
+declare const injectToggleGroupContext: _radix_ng_primitives_core.InjectContext<RdxToggleGroupContext>;
+declare const provideToggleGroupContext: (useFactory: () => RdxToggleGroupContext) => _angular_core.Provider;
 
-declare const RdxToggleGroupItemToken: InjectionToken<RdxToggleGroupItemDirective>;
-declare function injectToggleGroupItem(): RdxToggleGroupItemDirective;
-
-declare class RdxToggleGroupWithoutFocusDirective implements ControlValueAccessor {
-    /**
-     * @ignore
-     */
-    readonly id: string;
+/** Builds the shared context a {@link RdxToggle} reads when it belongs to this group. */
+declare function toggleGroupContext(instance: RdxToggleGroupBase): RdxToggleGroupContext;
+/**
+ * Shared state and behavior for the toggle group. Concrete directives add the roving-focus group
+ * ({@link RdxToggleGroup}) or omit it when an ancestor already owns focus, e.g. a toolbar
+ * ({@link RdxToggleGroupWithoutFocus}).
+ */
+declare abstract class RdxToggleGroupBase implements ControlValueAccessor {
     /**
-     * @group Props
+     * The pressed values. Always an array — a single value is `[value]`. Use with `(onValueChange)`
+     * for controlled state.
      */
-    readonly value: _angular_core.ModelSignal<string | string[] | undefined>;
+    readonly value: _angular_core.ModelSignal<string[] | undefined>;
+    /** The values pressed when the group is initially rendered (uncontrolled). */
+    readonly defaultValue: _angular_core.InputSignal<string[] | undefined>;
     /**
-     * @group Props
+     * Whether multiple items can be pressed at the same time.
+     *
+     * @default false
      */
-    readonly type: _angular_core.InputSignal<"single" | "multiple">;
+    readonly multiple: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
     /**
-     * Whether the toggle group is disabled.
-     * @defaultValue false
-     * @group Props
+     * Whether the whole group is disabled.
+     *
+     * @default false
      */
     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.
-     */
+     * The orientation of the group, controlling arrow-key navigation.
+     *
+     * @default 'horizontal'
+     */
+    readonly orientation: _angular_core.InputSignal<DataOrientation>;
+    /** Event emitted when the pressed values change. */
+    readonly onValueChange: _angular_core.OutputEmitterRef<string[]>;
+    /** @ignore */
+    readonly pressedValues: _angular_core.Signal<string[]>;
+    protected readonly accessorDisabled: _angular_core.WritableSignal<boolean>;
+    /** @ignore */
+    readonly isDisabled: _angular_core.Signal<boolean>;
     private onChange?;
-    /**
-     * onTouch function registered via registerOnTouch (ControlValueAccessor).
-     */
     protected onTouched?: () => void;
-    /**
-     * Toggle a value.
-     * @param value The value to toggle.
-     * @ignore
-     */
+    constructor();
+    /** @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
-     */
+    /** @ignore */
+    writeValue(value: string[] | string | null): void;
+    /** @ignore */
+    registerOnChange(fn: (value: string[]) => void): void;
+    /** @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
-     */
+    /** @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>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxToggleGroupBase, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxToggleGroupBase, never, never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "onValueChange": "onValueChange"; }, never, never, true, never>;
 }
 
 /**
- * @group Components
+ * A set of two-state buttons that can be toggled on or off. Owns roving keyboard focus over its
+ * `[rdxToggle]` children.
+ *
+ * @see https://base-ui.com/react/components/toggle-group
  */
-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;
+declare class RdxToggleGroup extends RdxToggleGroupBase {
+    /** Text direction for arrow-key navigation. */
+    readonly dir: _angular_core.InputSignal<Direction>;
     /**
-     * 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
+     * Whether keyboard navigation should loop from the last item back to the first.
+     *
+     * @default true
      */
-    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: {}; }]>;
+    readonly loopFocus: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    private readonly rovingFocusGroup;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxToggleGroup, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxToggleGroup, "[rdxToggleGroup]", ["rdxToggleGroup"], { "dir": { "alias": "dir"; "required": false; "isSignal": true; }; "loopFocus": { "alias": "loopFocus"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.RdxRovingFocusGroupDirective; inputs: {}; outputs: {}; }]>;
 }
 
-interface IRdxToggleGroup {
-    toggle(value: string): void;
-    disabled: any;
-    value: any;
-    type: any;
-    accessorDisabled: any;
+/**
+ * A toggle group that does NOT create its own roving-focus group, for use inside a container that
+ * already owns keyboard focus (e.g. a toolbar). The `[rdxToggle]` children register with the nearest
+ * ancestor roving-focus group instead. Mirrors Base UI's behavior of skipping its composite root
+ * when nested in a toolbar.
+ */
+declare class RdxToggleGroupWithoutFocus extends RdxToggleGroupBase {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxToggleGroupWithoutFocus, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxToggleGroupWithoutFocus, "[rdxToggleGroupWithoutFocus]", ["rdxToggleGroupWithoutFocus"], {}, {}, never, never, true, never>;
 }
-declare const RdxToggleGroupToken: InjectionToken<IRdxToggleGroup>;
-declare function injectToggleGroup(): IRdxToggleGroup;
 
-export { RdxToggleGroupDirective, RdxToggleGroupItemDirective, RdxToggleGroupItemToken, RdxToggleGroupToken, RdxToggleGroupWithoutFocusDirective, injectToggleGroup, injectToggleGroupItem };
-export type { IRdxToggleGroup };
+export { RdxToggleGroup, RdxToggleGroupBase, RdxToggleGroupWithoutFocus, injectToggleGroupContext, provideToggleGroupContext, toggleGroupContext };
+export type { RdxToggleGroupContext };

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

@@ -1,75 +1,65 @@
 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';
+import { BooleanInput } from '@radix-ng/primitives/core';
+import * as i1 from '@radix-ng/primitives/roving-focus';
+import * as i1$1 from '@radix-ng/primitives/visually-hidden';
 
-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
+ * A two-state button that can be either on (pressed) or off.
+ *
+ * Works standalone or as an item of a `[rdxToggleGroup]`: inside a group it derives its pressed
+ * state from the group's value (matched by `value`) and participates in the group's roving focus.
+ *
+ * @see https://base-ui.com/react/components/toggle
  */
-declare class RdxToggleDirective {
+declare class RdxToggle {
+    private readonly group;
+    private readonly rovingItem;
     /**
-     * @ignore
+     * A value identifying this toggle inside a `[rdxToggleGroup]`. Required when used in a group.
      */
-    readonly cva: RdxControlValueAccessor<any>;
+    readonly value: _angular_core.InputSignal<string | undefined>;
     /**
-     * The pressed state of the toggle when it is initially rendered.
-     * Use when you do not need to control its pressed state.
+     * The pressed state when initially rendered (uncontrolled, standalone only).
      *
-     * @group Props
+     * @default false
      */
     readonly defaultPressed: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
     /**
-     * The controlled pressed state of the toggle.
-     * Must be used in conjunction with `onPressedChange`.
-     *
-     * @group Props
+     * The controlled pressed state (standalone). Use with `(onPressedChange)` or two-way `[(pressed)]`.
      */
-    readonly pressed: _angular_core.ModelSignal<boolean>;
+    readonly pressed: _angular_core.ModelSignal<boolean | undefined>;
     /**
-     * When true, prevents the user from interacting with the toggle.
+     * Whether the toggle is disabled.
      *
-     * @group Props
+     * @default false
      */
     readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
     /**
-     * Event handler called when the pressed state of the toggle changes.
+     * Whether the host is a native `<button>`. When `false`, the toggle adds `role="button"` and
+     * handles Enter/Space itself.
      *
-     * @group Emits
+     * @default true
      */
-    readonly onPressedChange: _angular_core.OutputRef<any>;
+    readonly nativeButton: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Event emitted when the pressed state changes (standalone). */
+    readonly onPressedChange: _angular_core.OutputEmitterRef<boolean>;
+    private readonly internalPressed;
+    /** @ignore Whether the toggle is currently pressed (from the group when grouped). */
+    readonly pressedState: _angular_core.Signal<boolean>;
+    /** @ignore */
+    readonly isDisabled: _angular_core.Signal<boolean>;
+    constructor();
+    /** @ignore */
     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: {}; }]>;
+    /** @ignore */
+    protected onKeyDown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxToggle, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxToggle, "[rdxToggle]", ["rdxToggle"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "defaultPressed": { "alias": "defaultPressed"; "required": false; "isSignal": true; }; "pressed": { "alias": "pressed"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "nativeButton": { "alias": "nativeButton"; "required": false; "isSignal": true; }; }, { "pressed": "pressedChange"; "onPressedChange": "onPressedChange"; }, never, never, true, [{ directive: typeof i1.RdxRovingFocusItemDirective; inputs: {}; outputs: {}; }]>;
+}
+
+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$1.RdxVisuallyHiddenInputBubbleDirective; inputs: { "name": "name"; "required": "required"; "value": "value"; "disabled": "disabled"; }; outputs: {}; }]>;
 }
 
-export { RdxToggleDirective, RdxToggleVisuallyHiddenInputDirective };
-export type { DataState, ToggleProps };
+export { RdxToggle, RdxToggleVisuallyHiddenInputDirective };

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

@@ -1,55 +1,181 @@
-import * as i0 from '@angular/core';
-import { InjectionToken, Provider } from '@angular/core';
-import * as i1 from '@radix-ng/primitives/roving-focus';
-import { BooleanInput } from '@angular/cdk/coercion';
-import * as i1$1 from '@radix-ng/primitives/toggle-group';
-import * as i1$2 from '@radix-ng/primitives/separator';
+import * as _angular_core from '@angular/core';
+import { Signal } from '@angular/core';
+import * as i1 from '@radix-ng/primitives/separator';
+import * as _radix_ng_primitives_core from '@radix-ng/primitives/core';
+import { DataOrientation, BooleanInput } from '@radix-ng/primitives/core';
+import * as i1$1 from '@radix-ng/primitives/roving-focus';
+import { Direction } from '@radix-ng/primitives/roving-focus';
+import * as _radix_ng_primitives_toolbar from '@radix-ng/primitives/toolbar';
 
-declare class RdxToolbarRootDirective {
-    readonly orientation: i0.InputSignal<"horizontal" | "vertical">;
-    readonly dir: i0.InputSignal<"ltr" | "rtl">;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxToolbarRootDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxToolbarRootDirective, "[rdxToolbarRoot]", never, { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "dir": { "alias": "dir"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.RdxRovingFocusGroupDirective; inputs: { "dir": "dir"; "orientation": "orientation"; "loop": "loop"; }; outputs: {}; }]>;
+/**
+ * A separator between toolbar items or groups.
+ *
+ * @see https://base-ui.com/react/components/toolbar
+ */
+declare class RdxToolbarSeparator {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxToolbarSeparator, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxToolbarSeparator, "[rdxToolbarSeparator]", ["rdxToolbarSeparator"], {}, {}, never, never, true, [{ directive: typeof i1.RdxSeparatorRootDirective; inputs: { "orientation": "orientation"; }; outputs: {}; }]>;
 }
 
-declare class RdxToolbarButtonDirective {
-    #private;
-    private readonly rdxRovingFocusItemDirective;
-    readonly disabled: i0.InputSignalWithTransform<boolean, BooleanInput>;
-    private readonly isDisabled;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxToolbarButtonDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxToolbarButtonDirective, "[rdxToolbarButton]", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.RdxRovingFocusItemDirective; inputs: { "focusable": "focusable"; }; outputs: {}; }]>;
+/**
+ * A container for grouping a set of controls, such as buttons, toggle groups or menus.
+ * Owns roving keyboard focus over its items.
+ *
+ * @see https://base-ui.com/react/components/toolbar
+ */
+declare class RdxToolbarRoot {
+    /**
+     * The orientation of the toolbar.
+     *
+     * @default 'horizontal'
+     */
+    readonly orientation: _angular_core.InputSignal<DataOrientation>;
+    /** Text direction for arrow-key navigation. */
+    readonly dir: _angular_core.InputSignal<Direction>;
+    /**
+     * Whether keyboard navigation should loop from the last item back to the first.
+     *
+     * @default true
+     */
+    readonly loopFocus: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Whether the whole toolbar is disabled.
+     *
+     * @default false
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    private readonly rovingFocusGroup;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxToolbarRoot, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxToolbarRoot, "[rdxToolbarRoot]", ["rdxToolbarRoot"], { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "dir": { "alias": "dir"; "required": false; "isSignal": true; }; "loopFocus": { "alias": "loopFocus"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$1.RdxRovingFocusGroupDirective; inputs: {}; outputs: {}; }]>;
 }
 
-declare class RdxToolbarLinkDirective {
-    onKeyDown($event: KeyboardEvent): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxToolbarLinkDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxToolbarLinkDirective, "[rdxToolbarLink]", never, {}, {}, never, never, true, [{ directive: typeof i1.RdxRovingFocusItemDirective; inputs: { "focusable": "focusable"; }; outputs: {}; }]>;
+/**
+ * A button within a toolbar.
+ *
+ * @see https://base-ui.com/react/components/toolbar
+ */
+declare class RdxToolbarButton {
+    protected readonly rootContext: _radix_ng_primitives_toolbar.RdxToolbarRootContext;
+    private readonly groupContext;
+    private readonly rovingItem;
+    /**
+     * Whether the button is disabled.
+     *
+     * @default false
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Whether the button stays focusable while disabled (so it remains discoverable for keyboard
+     * and screen-reader users).
+     *
+     * @default true
+     */
+    readonly focusableWhenDisabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Whether the host is a native `<button>`. When `false`, adds `role="button"`.
+     *
+     * @default true
+     */
+    readonly nativeButton: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** @ignore Effective disabled state, combining the button, group and toolbar. */
+    readonly isDisabled: _angular_core.Signal<boolean>;
+    constructor();
+    /** @ignore */
+    protected onClick(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxToolbarButton, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxToolbarButton, "[rdxToolbarButton]", ["rdxToolbarButton"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "focusableWhenDisabled": { "alias": "focusableWhenDisabled"; "required": false; "isSignal": true; }; "nativeButton": { "alias": "nativeButton"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$1.RdxRovingFocusItemDirective; inputs: {}; outputs: {}; }]>;
 }
 
-declare class RdxToolbarToggleGroupDirective {
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxToolbarToggleGroupDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxToolbarToggleGroupDirective, "[rdxToolbarToggleGroup]", never, {}, {}, never, never, true, [{ directive: typeof i1$1.RdxToggleGroupWithoutFocusDirective; inputs: { "value": "value"; "type": "type"; "disabled": "disabled"; }; outputs: {}; }]>;
+/**
+ * A link within a toolbar.
+ *
+ * @see https://base-ui.com/react/components/toolbar
+ */
+declare class RdxToolbarLink {
+    protected readonly rootContext: _radix_ng_primitives_toolbar.RdxToolbarRootContext;
+    /** @ignore Space activates a link, matching native button behavior in a toolbar. */
+    protected onKeyDown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxToolbarLink, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxToolbarLink, "[rdxToolbarLink]", ["rdxToolbarLink"], {}, {}, never, never, true, [{ directive: typeof i1$1.RdxRovingFocusItemDirective; inputs: {}; outputs: {}; }]>;
 }
 
-declare class RdxToolbarToggleItemDirective {
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxToolbarToggleItemDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxToolbarToggleItemDirective, "[rdxToolbarToggleItem]", never, {}, {}, never, never, true, [{ directive: typeof i1$1.RdxToggleGroupItemDirective; inputs: { "value": "value"; "disabled": "disabled"; }; outputs: {}; }]>;
+/**
+ * A native input within a toolbar. Participates in the toolbar's roving focus while keeping native
+ * text-editing: the arrow keys move the caret within the text and only move focus to the
+ * neighbouring toolbar item once the caret is at the corresponding edge (Base UI "composite" input).
+ *
+ * @see https://base-ui.com/react/components/toolbar
+ */
+declare class RdxToolbarInput {
+    protected readonly rootContext: _radix_ng_primitives_toolbar.RdxToolbarRootContext;
+    private readonly groupContext;
+    private readonly rovingItem;
+    private readonly elementRef;
+    private readonly isBrowser;
+    /** The initial value of the uncontrolled input. */
+    readonly defaultValue: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Whether the input is disabled.
+     *
+     * @default false
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Whether the input stays focusable while disabled.
+     *
+     * @default true
+     */
+    readonly focusableWhenDisabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** @ignore */
+    readonly isDisabled: _angular_core.Signal<boolean>;
+    private appliedDefault;
+    constructor();
+    private handleCaretKeydown;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxToolbarInput, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxToolbarInput, "input[rdxToolbarInput]", ["rdxToolbarInput"], { "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "focusableWhenDisabled": { "alias": "focusableWhenDisabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$1.RdxRovingFocusItemDirective; inputs: {}; outputs: {}; }]>;
 }
 
-declare class RdxToolbarSeparatorDirective {
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxToolbarSeparatorDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxToolbarSeparatorDirective, "[rdxToolbarSeparator]", never, {}, {}, never, never, true, [{ directive: typeof i1$2.RdxSeparatorRootDirective; inputs: { "orientation": "orientation"; "decorative": "decorative"; }; outputs: {}; }]>;
+/**
+ * Groups several toolbar items together. Disabling the group disables all of its items.
+ *
+ * @see https://base-ui.com/react/components/toolbar
+ */
+declare class RdxToolbarGroup {
+    protected readonly rootContext: _radix_ng_primitives_toolbar.RdxToolbarRootContext;
+    /**
+     * Whether the group is disabled.
+     *
+     * @default false
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** @ignore Effective disabled state, combining the group and the toolbar. */
+    readonly isDisabled: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxToolbarGroup, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxToolbarGroup, "[rdxToolbarGroup]", ["rdxToolbarGroup"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-declare const RDX_TOOLBAR_ROOT_TOKEN: InjectionToken<RdxToolbarRootDirective>;
-declare function injectRootContext(): RdxToolbarRootDirective;
-declare function provideRootContext(): Provider;
+interface RdxToolbarRootContext {
+    /** The orientation of the toolbar. */
+    readonly orientation: Signal<DataOrientation>;
+    /** Whether the whole toolbar is disabled. */
+    readonly disabled: Signal<boolean>;
+}
+declare const injectToolbarRootContext: _radix_ng_primitives_core.InjectContext<RdxToolbarRootContext>;
+declare const provideToolbarRootContext: (useFactory: () => RdxToolbarRootContext) => _angular_core.Provider;
+interface RdxToolbarGroupContext {
+    /** Whether the group (and therefore its items) is disabled. */
+    readonly disabled: Signal<boolean>;
+}
+declare const injectToolbarGroupContext: _radix_ng_primitives_core.InjectContext<RdxToolbarGroupContext>;
+declare const provideToolbarGroupContext: (useFactory: () => RdxToolbarGroupContext) => _angular_core.Provider;
 
+declare const toolbarImports: (typeof RdxToolbarSeparator)[];
 declare class RdxToolbarModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxToolbarModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxToolbarModule, never, [typeof RdxToolbarRootDirective, typeof RdxToolbarButtonDirective, typeof RdxToolbarLinkDirective, typeof RdxToolbarToggleGroupDirective, typeof RdxToolbarToggleItemDirective, typeof RdxToolbarSeparatorDirective], [typeof RdxToolbarRootDirective, typeof RdxToolbarButtonDirective, typeof RdxToolbarLinkDirective, typeof RdxToolbarToggleGroupDirective, typeof RdxToolbarToggleItemDirective, typeof RdxToolbarSeparatorDirective]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<RdxToolbarModule>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxToolbarModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<RdxToolbarModule, never, [typeof RdxToolbarRoot, typeof RdxToolbarButton, typeof RdxToolbarLink, typeof RdxToolbarInput, typeof RdxToolbarGroup, typeof RdxToolbarSeparator], [typeof RdxToolbarRoot, typeof RdxToolbarButton, typeof RdxToolbarLink, typeof RdxToolbarInput, typeof RdxToolbarGroup, typeof RdxToolbarSeparator]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<RdxToolbarModule>;
 }
 
-export { RDX_TOOLBAR_ROOT_TOKEN, RdxToolbarButtonDirective, RdxToolbarLinkDirective, RdxToolbarModule, RdxToolbarRootDirective, RdxToolbarSeparatorDirective, RdxToolbarToggleGroupDirective, RdxToolbarToggleItemDirective, injectRootContext, provideRootContext };
+export { RdxToolbarButton, RdxToolbarGroup, RdxToolbarInput, RdxToolbarLink, RdxToolbarModule, RdxToolbarRoot, RdxToolbarSeparator, injectToolbarGroupContext, injectToolbarRootContext, provideToolbarGroupContext, provideToolbarRootContext, toolbarImports };
+export type { RdxToolbarGroupContext, RdxToolbarRootContext };