@radix-ng/primitives 0.42.0 → 0.44.0

package/roving-focus/index.d.ts

@@ -1,3 +1,174 @@
-export * from './src/roving-focus-group.directive';
-export * from './src/roving-focus-item.directive';
-export type { Direction, Orientation } from './src/utils';
+import * as _angular_core from '@angular/core';
+import { BooleanInput } from '@angular/cdk/coercion';
+
+type Orientation = 'horizontal' | 'vertical';
+type Direction = 'ltr' | 'rtl';
+
+declare const rootContext: () => {
+    loop: _angular_core.Signal<boolean>;
+    dir: _angular_core.Signal<Direction>;
+    orientation: _angular_core.Signal<Orientation>;
+    currentTabStopId: _angular_core.ModelSignal<string | undefined>;
+    focusableItems: _angular_core.WritableSignal<HTMLElement[]>;
+    onItemFocus: (tabStopId: string) => void;
+    onItemShiftTab: () => void;
+    onFocusableItemAdd: () => void;
+    onFocusableItemRemove: () => void;
+    registerItem: (item: HTMLElement) => void;
+    unregisterItem: (item: HTMLElement) => void;
+};
+type RovingFocusGroupContext = ReturnType<typeof rootContext>;
+declare const injectRovingFocusGroupContext: (optional?: boolean) => {
+    loop: _angular_core.Signal<boolean>;
+    dir: _angular_core.Signal<Direction>;
+    orientation: _angular_core.Signal<Orientation>;
+    currentTabStopId: _angular_core.ModelSignal<string | undefined>;
+    focusableItems: _angular_core.WritableSignal<HTMLElement[]>;
+    onItemFocus: (tabStopId: string) => void;
+    onItemShiftTab: () => void;
+    onFocusableItemAdd: () => void;
+    onFocusableItemRemove: () => void;
+    registerItem: (item: HTMLElement) => void;
+    unregisterItem: (item: HTMLElement) => void;
+} | null;
+declare const provideRovingFocusGroupContext: (useFactory: () => {
+    loop: _angular_core.Signal<boolean>;
+    dir: _angular_core.Signal<Direction>;
+    orientation: _angular_core.Signal<Orientation>;
+    currentTabStopId: _angular_core.ModelSignal<string | undefined>;
+    focusableItems: _angular_core.WritableSignal<HTMLElement[]>;
+    onItemFocus: (tabStopId: string) => void;
+    onItemShiftTab: () => void;
+    onFocusableItemAdd: () => void;
+    onFocusableItemRemove: () => void;
+    registerItem: (item: HTMLElement) => void;
+    unregisterItem: (item: HTMLElement) => void;
+}) => _angular_core.Provider;
+/**
+ * @group Components
+ */
+declare class RdxRovingFocusGroupDirective {
+    private readonly isBrowser;
+    private readonly elementRef;
+    /**
+     * The orientation of the group. Mainly so arrow navigation is done accordingly (left & right vs. up & down)
+     */
+    readonly orientationInput: _angular_core.InputSignal<Orientation>;
+    /**
+     * The direction of navigation between items.
+     */
+    readonly dirInput: _angular_core.InputSignal<Direction>;
+    /**
+     * Whether keyboard navigation should loop around
+     */
+    readonly loopInput: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * When `true`, will prevent scrolling to the focus item when focused.
+     * @group Props
+     */
+    readonly preventScrollOnEntryFocus: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * The value of the current stop item.
+     *
+     * Use when you do not need to control the state of the stop item.
+     * @group Props
+     */
+    readonly defaultCurrentTabStopId: _angular_core.InputSignal<string | undefined>;
+    /**
+     * The controlled value of the current stop item. Can be binded as `model`.
+     * @group Props
+     */
+    readonly currentTabStopId: _angular_core.ModelSignal<string | undefined>;
+    /**
+     * Event handler called when container is being focused. Can be prevented.
+     * @group Emits
+     */
+    readonly entryFocus: _angular_core.OutputEmitterRef<Event>;
+    private readonly _orientation;
+    readonly orientation: _angular_core.Signal<Orientation>;
+    private readonly _dir;
+    readonly dir: _angular_core.Signal<Direction>;
+    private readonly _loop;
+    readonly loop: _angular_core.Signal<boolean>;
+    readonly focusableItems: _angular_core.WritableSignal<HTMLElement[]>;
+    protected readonly isClickFocus: _angular_core.WritableSignal<boolean>;
+    readonly isTabbingBackOut: _angular_core.WritableSignal<boolean>;
+    readonly focusableItemsCount: _angular_core.WritableSignal<number>;
+    constructor();
+    setOrientation(value: Orientation): void;
+    setDir(value: Direction): void;
+    setLoop(value: boolean): void;
+    /** @ignore */
+    handleMouseUp(): void;
+    /** @ignore */
+    handleFocus(event: FocusEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxRovingFocusGroupDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxRovingFocusGroupDirective, "[rdxRovingFocusGroup]", never, { "orientationInput": { "alias": "orientation"; "required": false; "isSignal": true; }; "dirInput": { "alias": "dir"; "required": false; "isSignal": true; }; "loopInput": { "alias": "loop"; "required": false; "isSignal": true; }; "preventScrollOnEntryFocus": { "alias": "preventScrollOnEntryFocus"; "required": false; "isSignal": true; }; "defaultCurrentTabStopId": { "alias": "defaultCurrentTabStopId"; "required": false; "isSignal": true; }; "currentTabStopId": { "alias": "currentTabStopId"; "required": false; "isSignal": true; }; }, { "currentTabStopId": "currentTabStopIdChange"; "entryFocus": "entryFocus"; }, never, never, true, never>;
+}
+
+/**
+ * @group Components
+ */
+declare class RdxRovingFocusItemDirective {
+    private readonly isBrowser;
+    private readonly destroyRef;
+    private readonly elementRef;
+    protected readonly rootContext: {
+        loop: _angular_core.Signal<boolean>;
+        dir: _angular_core.Signal<Direction>;
+        orientation: _angular_core.Signal<Orientation>;
+        currentTabStopId: _angular_core.ModelSignal<string | undefined>;
+        focusableItems: _angular_core.WritableSignal<HTMLElement[]>;
+        onItemFocus: (tabStopId: string) => void;
+        onItemShiftTab: () => void;
+        onFocusableItemAdd: () => void;
+        onFocusableItemRemove: () => void;
+        registerItem: (item: HTMLElement) => void;
+        unregisterItem: (item: HTMLElement) => void;
+    };
+    /**
+     * When false, item will not be focusable.
+     * @group Props
+     */
+    readonly focusableInput: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * When `true`, item will be initially focused.
+     * @group Props
+     */
+    readonly activeInput: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * @group Props
+     */
+    readonly tabStopIdInput: _angular_core.InputSignal<string | undefined>;
+    /**
+     * When true, shift + arrow key will allow focusing on next/previous item.
+     * @group Props
+     */
+    readonly allowShiftKey: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    protected readonly id: _angular_core.Signal<string>;
+    protected readonly isCurrentTabStop: _angular_core.Signal<boolean>;
+    protected readonly focusable: _angular_core.WritableSignal<boolean>;
+    protected readonly active: _angular_core.WritableSignal<boolean>;
+    private readonly tabStopId;
+    constructor();
+    setFocusable(value: boolean): void;
+    setActive(value: boolean): void;
+    setTabStopId(value: string): void;
+    /** @ignore */
+    handleMouseDown(event: MouseEvent): void;
+    /**
+     * Handles the `keydown` event for keyboard navigation within the roving focus group.
+     * Supports navigation based on orientation and direction, and focuses appropriate elements.
+     *
+     * @param event The `KeyboardEvent` object.
+     * @ignore
+     */
+    handleKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxRovingFocusItemDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxRovingFocusItemDirective, "[rdxRovingFocusItem]", never, { "focusableInput": { "alias": "focusable"; "required": false; "isSignal": true; }; "activeInput": { "alias": "active"; "required": false; "isSignal": true; }; "tabStopIdInput": { "alias": "tabStopId"; "required": false; "isSignal": true; }; "allowShiftKey": { "alias": "allowShiftKey"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const rovingFocusImports: (typeof RdxRovingFocusGroupDirective | typeof RdxRovingFocusItemDirective)[];
+
+export { RdxRovingFocusGroupDirective, RdxRovingFocusItemDirective, injectRovingFocusGroupContext, provideRovingFocusGroupContext, rovingFocusImports };
+export type { Direction, Orientation, RovingFocusGroupContext };

package/select/index.d.ts

@@ -1,26 +1,214 @@
-import * as i0 from "@angular/core";
-import * as i1 from "./src/select-content.directive";
-import * as i2 from "./src/select-group.directive";
-import * as i3 from "./src/select-item.directive";
-import * as i4 from "./src/select-item-indicator.directive";
-import * as i5 from "./src/select-label.directive";
-import * as i6 from "./src/select.component";
-import * as i7 from "./src/select-separator.directive";
-import * as i8 from "./src/select-trigger.directive";
-import * as i9 from "./src/select-value.directive";
-import * as i10 from "./src/select-icon.directive";
-export * from './src/select-content.directive';
-export * from './src/select-group.directive';
-export * from './src/select-icon.directive';
-export * from './src/select-item-indicator.directive';
-export * from './src/select-item.directive';
-export * from './src/select-label.directive';
-export * from './src/select-separator.directive';
-export * from './src/select-trigger.directive';
-export * from './src/select-value.directive';
-export * from './src/select.component';
-export declare class RdxSelectModule {
+import * as i0 from '@angular/core';
+import { AfterViewInit, OnDestroy, NgZone, OnInit, AfterContentInit, ElementRef, ChangeDetectorRef, EventEmitter, DestroyRef, QueryList } from '@angular/core';
+import { ActiveDescendantKeyManager, Highlightable } from '@angular/cdk/a11y';
+import { Directionality } from '@angular/cdk/bidi';
+import { Observable, Subject } from 'rxjs';
+import { SelectionModel } from '@angular/cdk/collections';
+import { Overlay, CdkConnectedOverlay, ConnectedPosition } from '@angular/cdk/overlay';
+
+declare class RdxSelectValueDirective {
+    select: RdxSelectComponent;
+    placeholder: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxSelectValueDirective, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RdxSelectValueDirective, "[rdxSelectValue]", ["rdxSelectValue"], { "placeholder": { "alias": "placeholder"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class RdxSelectTriggerDirective implements AfterViewInit, OnDestroy {
+    readonly ngZone: NgZone;
+    protected nativeElement: any;
+    protected select: RdxSelectComponent;
+    protected readonly value: i0.Signal<RdxSelectValueDirective>;
+    private resizeObserver;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    focus(): void;
+    private observeTriggerResize;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxSelectTriggerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxSelectTriggerDirective, "[rdxSelectTrigger]", never, {}, {}, ["value"], never, true, never>;
+}
+
+declare class RdxSelectComponent implements OnInit, AfterContentInit {
+    protected overlay: Overlay;
+    protected elementRef: ElementRef<any>;
+    protected changeDetectorRef: ChangeDetectorRef;
+    private readonly destroyRef;
+    private readonly ngZone;
+    protected readonly trigger: i0.Signal<RdxSelectTriggerDirective>;
+    protected readonly content: i0.Signal<RdxSelectContentDirective>;
+    readonly items: i0.Signal<readonly RdxSelectItemDirective[]>;
+    readonly overlayDir: i0.Signal<CdkConnectedOverlay>;
+    /**
+     * Tuple type for the trigger element size. Set by the trigger element itself.
+     * The first element is the width and the second element is the height.
+     * @returns The size of the trigger element.
+     */
+    readonly triggerSize: i0.WritableSignal<[number, number]>;
+    /**
+     * The width of the trigger element.
+     * @returns The width of the trigger element.
+     */
+    readonly triggerWidth: i0.Signal<number>;
+    /** Deals with the selection logic. */
+    selectionModel: SelectionModel<RdxSelectItemDirective>;
+    /**
+     * This position config ensures that the top "start" corner of the overlay
+     * is aligned with the top "start" of the origin by default (overlapping
+     * the trigger completely). If the panel cannot fit below the trigger, it
+     * will fall back to a position above the trigger.
+     */
+    positions: ConnectedPosition[];
+    private closeSubscription;
+    /**
+     * @ignore
+     */
+    readonly dir: Directionality | null;
+    /**
+     * @ignore
+     */
+    protected keyManager: ActiveDescendantKeyManager<RdxSelectItemDirective>;
+    /**
+     * @ignore
+     */
+    readonly id: string;
+    defaultValue: string;
+    name: string;
+    defaultOpen: boolean;
+    open: boolean;
+    /** Whether the Select is disabled. */
+    disabled: boolean;
+    required: boolean;
+    /**
+     * The overlay width will be set to the trigger width if this is true.
+     * Otherwise, the overlay width will be set to the width of the content.
+     */
+    matchTriggerWidth: boolean;
+    /**
+     * The controlled value of the item to expand
+     */
+    set value(value: string);
+    get value(): string | null;
+    private _value?;
+    readonly onValueChange: EventEmitter<string>;
+    readonly onOpenChange: EventEmitter<boolean>;
+    readonly optionSelectionChanges: Observable<RdxSelectItemChange>;
+    get selected(): string | null;
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    /**
+     * Callback that is invoked when the overlay panel has been attached.
+     */
+    onAttached(): void;
+    onDetach(): void;
+    /** Toggles the overlay panel open or closed. */
+    toggle(): void;
+    openPanel(): void;
+    close(): void;
+    updateActiveItem(item: RdxSelectItemDirective): void;
+    private selectDefaultValue;
+    private selectValue;
+    private closingActions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxSelectComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RdxSelectComponent, "[rdxSelect]", never, { "defaultValue": { "alias": "defaultValue"; "required": false; }; "name": { "alias": "name"; "required": false; }; "defaultOpen": { "alias": "defaultOpen"; "required": false; }; "open": { "alias": "open"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "required": { "alias": "required"; "required": false; }; "matchTriggerWidth": { "alias": "matchTriggerWidth"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "onValueChange": "onValueChange"; "onOpenChange": "onOpenChange"; }, ["trigger", "content", "items"], ["[rdxSelectTrigger]", "[rdxSelectContent]"], true, never>;
+    static ngAcceptInputType_defaultOpen: unknown;
+    static ngAcceptInputType_open: unknown;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_required: unknown;
+    static ngAcceptInputType_matchTriggerWidth: unknown;
+}
+
+declare class RdxSelectItemChange<T = RdxSelectItemDirective> {
+    source: T;
+    constructor(source: T);
+}
+declare class RdxSelectItemDirective implements Highlightable {
+    protected readonly select: RdxSelectComponent;
+    protected readonly content: RdxSelectContentDirective;
+    readonly onSelectionChange: EventEmitter<RdxSelectItemChange<RdxSelectItemDirective>>;
+    protected readonly nativeElement: any;
+    highlighted: boolean;
+    selected: boolean;
+    get dataState(): string;
+    /**
+     * The unique SelectItem id.
+     * @ignore
+     */
+    readonly id: string;
+    set value(value: string);
+    get value(): string;
+    private _value?;
+    textValue: string | null;
+    /** Whether the SelectItem is disabled. */
+    set disabled(value: boolean);
+    get disabled(): boolean;
+    private _disabled;
+    get viewValue(): string;
+    constructor();
+    /** Gets the label to be used when determining whether the option should be focused.
+     * @ignore
+     */
+    getLabel(): string;
+    /**
+     * `Selects the option while indicating the selection came from the user. Used to
+     * determine if the select's view -> model callback should be invoked.`
+     * @ignore
+     */
+    selectViaInteraction(): void;
+    /** @ignore */
+    handleKeydown(event: KeyboardEvent): void;
+    /** @ignore */
+    setActiveStyles(): void;
+    /** @ignore */
+    setInactiveStyles(): void;
+    protected onPointerMove(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxSelectItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxSelectItemDirective, "[rdxSelectItem]", ["rdxSelectItem"], { "value": { "alias": "value"; "required": false; }; "textValue": { "alias": "textValue"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_disabled: unknown;
+}
+
+declare class RdxSelectContentDirective implements AfterContentInit {
+    protected readonly destroyRef: DestroyRef;
+    protected readonly dir: Directionality | null;
+    protected select: RdxSelectComponent;
+    readonly highlighted: Subject<RdxSelectItemDirective>;
+    keyManager: ActiveDescendantKeyManager<RdxSelectItemDirective>;
+    options: QueryList<RdxSelectItemDirective>;
+    constructor();
+    initKeyManager(): ActiveDescendantKeyManager<RdxSelectItemDirective>;
+    ngAfterContentInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxSelectContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxSelectContentDirective, "[rdxSelectContent]", ["rdxSelectContent"], {}, {}, ["options"], never, true, never>;
+}
+
+declare class RdxSelectGroupDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxSelectGroupDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxSelectGroupDirective, "[rdxSelectGroup]", ["rdxSelectGroup"], {}, {}, never, never, true, never>;
+}
+
+declare class RdxSelectItemIndicatorDirective {
+    protected item: RdxSelectItemDirective;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxSelectItemIndicatorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxSelectItemIndicatorDirective, "[rdxSelectItemIndicator]", ["rdxSelectItemIndicator"], {}, {}, never, never, true, never>;
+}
+
+declare class RdxSelectLabelDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxSelectLabelDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxSelectLabelDirective, "[rdxSelectLabel]", ["rdxSelectLabel"], {}, {}, never, never, true, never>;
+}
+
+declare class RdxSelectSeparatorDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxSelectSeparatorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxSelectSeparatorDirective, "[rdxSelectSeparator]", ["rdxSelectSeparator"], {}, {}, never, never, true, never>;
+}
+
+declare class RdxSelectIconDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxSelectIconDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxSelectIconDirective, "[rdxSelectIcon]", ["rdxSelectIcon"], {}, {}, never, never, true, never>;
+}
+
+declare class RdxSelectModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<RdxSelectModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxSelectModule, never, [typeof i1.RdxSelectContentDirective, typeof i2.RdxSelectGroupDirective, typeof i3.RdxSelectItemDirective, typeof i4.RdxSelectItemIndicatorDirective, typeof i5.RdxSelectLabelDirective, typeof i6.RdxSelectComponent, typeof i7.RdxSelectSeparatorDirective, typeof i8.RdxSelectTriggerDirective, typeof i9.RdxSelectValueDirective, typeof i10.RdxSelectIconDirective], [typeof i1.RdxSelectContentDirective, typeof i2.RdxSelectGroupDirective, typeof i3.RdxSelectItemDirective, typeof i4.RdxSelectItemIndicatorDirective, typeof i5.RdxSelectLabelDirective, typeof i6.RdxSelectComponent, typeof i7.RdxSelectSeparatorDirective, typeof i8.RdxSelectTriggerDirective, typeof i9.RdxSelectValueDirective, typeof i10.RdxSelectIconDirective]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxSelectModule, never, [typeof RdxSelectContentDirective, typeof RdxSelectGroupDirective, typeof RdxSelectItemDirective, typeof RdxSelectItemIndicatorDirective, typeof RdxSelectLabelDirective, typeof RdxSelectComponent, typeof RdxSelectSeparatorDirective, typeof RdxSelectTriggerDirective, typeof RdxSelectValueDirective, typeof RdxSelectIconDirective], [typeof RdxSelectContentDirective, typeof RdxSelectGroupDirective, typeof RdxSelectItemDirective, typeof RdxSelectItemIndicatorDirective, typeof RdxSelectLabelDirective, typeof RdxSelectComponent, typeof RdxSelectSeparatorDirective, typeof RdxSelectTriggerDirective, typeof RdxSelectValueDirective, typeof RdxSelectIconDirective]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<RdxSelectModule>;
 }
+
+export { RdxSelectComponent, RdxSelectContentDirective, RdxSelectGroupDirective, RdxSelectIconDirective, RdxSelectItemChange, RdxSelectItemDirective, RdxSelectItemIndicatorDirective, RdxSelectLabelDirective, RdxSelectModule, RdxSelectSeparatorDirective, RdxSelectTriggerDirective, RdxSelectValueDirective };

package/separator/index.d.ts

@@ -1 +1,63 @@
-export * from './src/separator.directive';
+import * as _angular_core from '@angular/core';
+import { BooleanInput } from '@angular/cdk/coercion';
+
+declare const ORIENTATIONS: readonly ["horizontal", "vertical"];
+type Orientation = (typeof ORIENTATIONS)[number];
+interface SeparatorProps {
+    /**
+     * Either `vertical` or `horizontal`. Defaults to `horizontal`.
+     */
+    orientation?: Orientation;
+    /**
+     * Whether the component is purely decorative. When true, accessibility-related attributes
+     * are updated so that the rendered element is removed from the accessibility tree.
+     */
+    decorative?: boolean;
+}
+/**
+ * Directive that adds accessible and configurable separator element to the DOM.
+ * This can be either horizontal or vertical and optionally decorative (which removes
+ * it from the accessibility tree).
+ *
+ * @group Components
+ */
+declare class RdxSeparatorRootDirective {
+    /**
+     * Orientation of the separator, can be either 'horizontal' or 'vertical'.
+     *
+     * @defaultValue 'horizontal'
+     * @group Props
+     */
+    readonly orientation: _angular_core.InputSignal<"horizontal" | "vertical">;
+    /**
+     * If true, the separator will be considered decorative and removed from
+     * the accessibility tree. Defaults to false.
+     *
+     * @defaultValue false
+     * @group Props
+     */
+    readonly decorative: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Computes the `role` attribute for the separator. If `decorative` is true,
+     * the role is set to "none", otherwise it is "separator".
+     *
+     * @ignore
+     */
+    protected readonly decorativeEffect: _angular_core.WritableSignal<boolean>;
+    protected readonly orientationEffect: _angular_core.WritableSignal<"horizontal" | "vertical">;
+    /**
+     * Computes the `aria-orientation` attribute. It is set to "vertical" only if
+     * the separator is not decorative and the orientation is set to "vertical".
+     * For horizontal orientation, the attribute is omitted.
+     *
+     * @ignore
+     */
+    protected readonly computedAriaOrientation: _angular_core.Signal<"vertical" | undefined>;
+    updateOrientation(value: Orientation): void;
+    updateDecorative(value: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxSeparatorRootDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxSeparatorRootDirective, "div[rdxSeparatorRoot]", never, { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "decorative": { "alias": "decorative"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { RdxSeparatorRootDirective };
+export type { Orientation, SeparatorProps };