@radix-ng/primitives 0.42.0 → 0.44.0

package/dismissable-layer/index.d.ts

@@ -0,0 +1,126 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, Signal, Provider } from '@angular/core';
+import { BooleanInput } from '@angular/cdk/coercion';
+
+/**
+ * Listens for when focus happens outside a DOM subtree.
+ * Returns props to pass to the root (node) of the subtree we want to check.
+ */
+declare class RdxFocusOutside {
+    #private;
+    readonly enabledInput: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    set enabled(value: boolean);
+    get enabled(): boolean;
+    readonly focusOutside: _angular_core.OutputEmitterRef<FocusEvent>;
+    private readonly isFocusInsideDOMTree;
+    private readonly focusCaptureHandler;
+    private readonly blurCaptureHandler;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxFocusOutside, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxFocusOutside, "[rdxFocusOutside]", ["rdxFocusOutside"], { "enabledInput": { "alias": "enabled"; "required": false; "isSignal": true; }; }, { "focusOutside": "focusOutside"; }, never, never, true, never>;
+}
+/**
+ * Listens for `pointerdown` outside a DOM subtree. We use `pointerdown` rather than `pointerup`
+ * to mimic layer dismissing behavior present in OS.
+ * Returns props to pass to the node we want to check for outside events.
+ */
+declare class RdxPointerDownOutside {
+    #private;
+    private readonly elementRef;
+    readonly enabledInput: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    set enabled(value: boolean);
+    get enabled(): boolean;
+    readonly pointerDownOutside: _angular_core.OutputEmitterRef<PointerEvent>;
+    private readonly isPointerInsideDOMTree;
+    private readonly handleAndDispatchPointerDownOutsideEvent;
+    private handleClick;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxPointerDownOutside, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxPointerDownOutside, "[rdxPointerDownOutside]", ["rdxPointerDownOutside"], { "enabledInput": { "alias": "enabled"; "required": false; "isSignal": true; }; }, { "pointerDownOutside": "pointerDownOutside"; }, never, never, true, never>;
+}
+declare class RdxEscapeKeyDown {
+    private readonly elementRef;
+    private readonly destroyRef;
+    readonly escapeKeyDown: _angular_core.OutputEmitterRef<KeyboardEvent>;
+    private readonly afterNextRender;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxEscapeKeyDown, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxEscapeKeyDown, "[rdxEscapeKeyDown]", ["rdxEscapeKeyDown"], {}, { "escapeKeyDown": "escapeKeyDown"; }, never, never, true, never>;
+}
+
+declare class RdxDismissableLayer {
+    private readonly elementRef;
+    private readonly injector;
+    private readonly destroyRef;
+    private readonly context;
+    private readonly config;
+    private readonly rdxPointerDownOutside;
+    private readonly rdxFocusOutside;
+    private readonly rdxEscapeKeyDown;
+    /**
+     * Event handler called when the escape key is down.
+     * Can be prevented.
+     */
+    readonly escapeKeyDown: _angular_core.OutputEmitterRef<KeyboardEvent>;
+    /**
+     * Event handler called when a `pointerdown` event happens outside of the `DismissableLayer`.
+     * Can be prevented.
+     */
+    readonly pointerDownOutside: _angular_core.OutputEmitterRef<PointerEvent>;
+    /**
+     * Event handler called when the focus moves outside of the `DismissableLayer`.
+     * Can be prevented.
+     */
+    readonly focusOutside: _angular_core.OutputEmitterRef<FocusEvent>;
+    /**
+     * Event handler called when an interaction happens outside the `DismissableLayer`.
+     * Specifically, when a `pointerdown` event happens outside or focus moves outside of it.
+     * Can be prevented.
+     */
+    readonly interactOutside: _angular_core.OutputEmitterRef<FocusEvent | PointerEvent>;
+    /**
+     * Handler called when the `DismissableLayer` should be dismissed
+     */
+    readonly dismiss: _angular_core.OutputEmitterRef<void>;
+    /**
+     * When `true`, hover/focus/click interactions will be disabled on elements outside
+     * the `DismissableLayer`. Users will need to click twice on outside elements to
+     * interact with them: once to close the `DismissableLayer`, and again to trigger the element.
+     */
+    readonly disableOutsidePointerEvents: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly layers: _angular_core.Signal<_angular_core.WritableSignal<RdxDismissableLayer[]>>;
+    protected readonly isBodyPointerEventsDisabled: _angular_core.Signal<boolean>;
+    protected readonly isPointerEventsEnabled: _angular_core.Signal<boolean>;
+    private readonly index;
+    private readonly afterNextRender;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxDismissableLayer, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxDismissableLayer, "[rdxDismissableLayer]", ["rdxDismissableLayer"], { "disableOutsidePointerEvents": { "alias": "disableOutsidePointerEvents"; "required": false; "isSignal": true; }; }, { "escapeKeyDown": "escapeKeyDown"; "pointerDownOutside": "pointerDownOutside"; "focusOutside": "focusOutside"; "interactOutside": "interactOutside"; "dismiss": "dismiss"; }, never, never, true, [{ directive: typeof RdxPointerDownOutside; inputs: {}; outputs: {}; }, { directive: typeof RdxFocusOutside; inputs: {}; outputs: {}; }, { directive: typeof RdxEscapeKeyDown; inputs: {}; outputs: {}; }]>;
+}
+
+declare class RdxDismissableLayerBranch {
+    private readonly elementRef;
+    private readonly destroyRef;
+    private readonly dismissableLayersContext;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxDismissableLayerBranch, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxDismissableLayerBranch, "[rdxDismissableLayerBranch]", never, {}, {}, never, never, true, never>;
+}
+
+declare const RdxDismissableLayersContextToken: InjectionToken<{
+    layersRoot: _angular_core.WritableSignal<RdxDismissableLayer[]>;
+    layersWithOutsidePointerEventsDisabled: Signal<RdxDismissableLayer[]>;
+    branches: _angular_core.WritableSignal<HTMLElement[]>;
+}>;
+type RdxDismissableLayerConfig = {
+    /**
+     * When `true`, hover/focus/click interactions will be disabled on elements outside
+     * the `DismissableLayer`. Users will need to click twice on outside elements to
+     * interact with them: once to close the `DismissableLayer`, and again to trigger the element.
+     */
+    disableOutsidePointerEvents: Signal<boolean>;
+};
+declare const RdxDismissableLayerConfigToken: InjectionToken<RdxDismissableLayerConfig>;
+declare function provideRdxDismissableLayerConfig(factory: () => RdxDismissableLayerConfig): Provider;
+
+export { RdxDismissableLayer, RdxDismissableLayerBranch, RdxDismissableLayerConfigToken, RdxDismissableLayersContextToken, RdxEscapeKeyDown, RdxFocusOutside, RdxPointerDownOutside, provideRdxDismissableLayerConfig };
+export type { RdxDismissableLayerConfig };

package/dropdown-menu/index.d.ts

@@ -1,26 +1,171 @@
-import * as i0 from "@angular/core";
-import * as i1 from "./src/dropdown-menu-trigger.directive";
-import * as i2 from "./src/dropdown-menu-content.directive";
-import * as i3 from "./src/dropdown-menu-item-checkbox.directive";
-import * as i4 from "./src/dropdown-menu-item-indicator.directive";
-import * as i5 from "./src/dropdown-menu-item-radio-group.directive";
-import * as i6 from "./src/dropdown-menu-item-radio.directive";
-import * as i7 from "./src/dropdown-menu-item-selectable";
-import * as i8 from "./src/dropdown-menu-item.directive";
-import * as i9 from "./src/dropdown-menu-label.directive";
-import * as i10 from "./src/dropdown-menu-separator.directive";
-export * from './src/dropdown-menu-content.directive';
-export * from './src/dropdown-menu-item-checkbox.directive';
-export * from './src/dropdown-menu-item-indicator.directive';
-export * from './src/dropdown-menu-item-radio-group.directive';
-export * from './src/dropdown-menu-item-radio.directive';
-export * from './src/dropdown-menu-item-selectable';
-export * from './src/dropdown-menu-item.directive';
-export * from './src/dropdown-menu-label.directive';
-export * from './src/dropdown-menu-separator.directive';
-export * from './src/dropdown-menu-trigger.directive';
-export declare class Rdx {
+import * as i0 from '@angular/core';
+import { TemplateRef, EventEmitter, AfterContentInit, OnDestroy } from '@angular/core';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { CdkMenuTrigger, CdkMenuItem, CdkMenu } from '@angular/cdk/menu';
+import { ConnectedPosition, OverlayRef } from '@angular/cdk/overlay';
+import { Subject } from 'rxjs';
+import * as i1 from '@radix-ng/primitives/menu';
+
+declare enum DropdownSide {
+    Top = "top",
+    Right = "right",
+    Bottom = "bottom",
+    Left = "left"
+}
+declare enum DropdownAlign {
+    Start = "start",
+    Center = "center",
+    End = "end"
+}
+declare const mapRdxAlignToCdkPosition: {
+    start: string;
+    center: string;
+    end: string;
+};
+/**
+ * @group Components
+ */
+declare class RdxDropdownMenuTriggerDirective extends CdkMenuTrigger {
+    readonly disabled: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    set rdxDropdownMenuTrigger(value: TemplateRef<unknown> | null);
+    /**
+     * The preferred side of the trigger to render against when open.
+     * Will be reversed when collisions occur and `avoidCollisions` is enabled.
+     *
+     * @group Props
+     * @defaultValue 'bottom'
+     */
+    set side(value: DropdownSide);
+    get side(): DropdownSide;
+    private _side;
+    /**
+     * The preferred alignment against the trigger. May change when collisions occur.
+     *
+     * @group Props
+     * @defaultValue 'center'
+     */
+    set align(value: DropdownAlign);
+    get align(): DropdownAlign;
+    private _align;
+    /**
+     * The distance in pixels from the trigger.
+     * @group Props
+     * @defaultValue 0
+     */
+    set sideOffset(value: number);
+    get sideOffset(): number;
+    private _sideOffset;
+    /**
+     * An offset in pixels from the "start" or "end" alignment options.
+     * @group Props
+     * @defaultValue 0
+     */
+    set alignOffset(value: number);
+    get alignOffset(): number;
+    private _alignOffset;
+    onOpenChange: i0.OutputRef<void>;
+    get isVertical(): boolean;
+    get defaultPosition(): ConnectedPosition;
+    constructor();
+    onPointerDown($event: MouseEvent): void;
+    getOverlayRef(): OverlayRef | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxDropdownMenuTriggerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxDropdownMenuTriggerDirective, "[rdxDropdownMenuTrigger]", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "rdxDropdownMenuTrigger": { "alias": "rdxDropdownMenuTrigger"; "required": false; }; "side": { "alias": "side"; "required": false; }; "align": { "alias": "align"; "required": false; }; "sideOffset": { "alias": "sideOffset"; "required": false; }; "alignOffset": { "alias": "alignOffset"; "required": false; }; }, { "onOpenChange": "onOpenChange"; }, never, never, true, never>;
+    static ngAcceptInputType_sideOffset: unknown;
+    static ngAcceptInputType_alignOffset: unknown;
+}
+
+declare class RdxDropdownMenuItemDirective extends CdkMenuItem {
+    protected readonly menu: RdxDropdownMenuContentDirective;
+    protected readonly nativeElement: any;
+    highlighted: boolean;
+    disabled: boolean;
+    readonly onSelect: EventEmitter<void>;
+    constructor();
+    protected onPointerMove(): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxDropdownMenuItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxDropdownMenuItemDirective, "[rdxDropdownMenuItem]", never, { "disabled": { "alias": "disabled"; "required": false; }; }, { "onSelect": "onSelect"; }, never, never, true, never>;
+    static ngAcceptInputType_disabled: unknown;
+}
+
+declare class RdxDropdownMenuContentDirective extends CdkMenu {
+    readonly highlighted: Subject<RdxDropdownMenuItemDirective>;
+    readonly menuTrigger: RdxDropdownMenuTriggerDirective | null;
+    onEscapeKeyDown: (event?: Event) => void;
+    closeOnEscape: boolean;
+    constructor();
+    updateActiveItem(item: CdkMenuItem): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxDropdownMenuContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxDropdownMenuContentDirective, "[rdxDropdownMenuContent]", never, { "onEscapeKeyDown": { "alias": "onEscapeKeyDown"; "required": false; }; "closeOnEscape": { "alias": "closeOnEscape"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/** Base class providing checked state for selectable DropdownMenuItems. */
+declare class RdxDropdownMenuSelectable extends RdxDropdownMenuItemDirective {
+    /** Whether the element is checked */
+    checked: boolean;
+    readonly checkedChange: EventEmitter<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxDropdownMenuSelectable, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxDropdownMenuSelectable, never, never, { "checked": { "alias": "checked"; "required": false; }; }, { "checkedChange": "checkedChange"; }, never, never, true, never>;
+    static ngAcceptInputType_checked: unknown;
+}
+
+declare class RdxDropdownMenuItemCheckboxDirective extends RdxDropdownMenuSelectable {
+    trigger(options?: {
+        keepOpen: boolean;
+    }): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxDropdownMenuItemCheckboxDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxDropdownMenuItemCheckboxDirective, "[rdxDropdownMenuItemCheckbox]", never, {}, {}, never, never, true, never>;
+}
+
+declare class RdxDropdownMenuItemIndicatorDirective {
+    item: RdxDropdownMenuSelectable;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxDropdownMenuItemIndicatorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxDropdownMenuItemIndicatorDirective, "[rdxDropdownMenuItemIndicator]", never, {}, {}, never, never, true, never>;
+}
+
+declare class RdxDropdownMenuItemRadioGroupDirective<T> implements AfterContentInit {
+    private readonly selectionDispatcher;
+    set value(id: T | null);
+    get value(): T | null;
+    private _value;
+    readonly valueChange: EventEmitter<any>;
+    ngAfterContentInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxDropdownMenuItemRadioGroupDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxDropdownMenuItemRadioGroupDirective<any>, "[rdxDropdownMenuItemRadioGroup]", never, { "value": { "alias": "value"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+declare class RdxDropdownMenuItemRadioDirective extends RdxDropdownMenuSelectable implements AfterContentInit, OnDestroy {
+    /** The unique selection dispatcher for this radio's `RdxDropdownMenuItemRadioGroupDirective`. */
+    private readonly selectionDispatcher;
+    private readonly group;
+    get value(): string;
+    set value(value: string);
+    private _value;
+    /** An ID to identify this radio item to the `UniqueSelectionDispatcher`. */
+    private id;
+    private removeDispatcherListener;
+    constructor();
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxDropdownMenuItemRadioDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxDropdownMenuItemRadioDirective, "[rdxDropdownMenuItemRadio]", never, { "value": { "alias": "value"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class RdxDropdownMenuLabelDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxDropdownMenuLabelDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxDropdownMenuLabelDirective, "[rdxDropdownMenuLabel]", never, {}, {}, never, never, true, [{ directive: typeof i1.RdxMenuLabelDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare class RdxDropdownMenuSeparatorDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxDropdownMenuSeparatorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxDropdownMenuSeparatorDirective, "[rdxDropdownMenuSeparator]", never, {}, {}, never, never, true, [{ directive: typeof i1.RdxMenuSeparatorDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare class Rdx {
     static ɵfac: i0.ɵɵFactoryDeclaration<Rdx, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<Rdx, never, [typeof i1.RdxDropdownMenuTriggerDirective, typeof i2.RdxDropdownMenuContentDirective, typeof i3.RdxDropdownMenuItemCheckboxDirective, typeof i4.RdxDropdownMenuItemIndicatorDirective, typeof i5.RdxDropdownMenuItemRadioGroupDirective, typeof i6.RdxDropdownMenuItemRadioDirective, typeof i7.RdxDropdownMenuSelectable, typeof i8.RdxDropdownMenuItemDirective, typeof i9.RdxDropdownMenuLabelDirective, typeof i10.RdxDropdownMenuSeparatorDirective, typeof i1.RdxDropdownMenuTriggerDirective], [typeof i1.RdxDropdownMenuTriggerDirective, typeof i2.RdxDropdownMenuContentDirective, typeof i3.RdxDropdownMenuItemCheckboxDirective, typeof i4.RdxDropdownMenuItemIndicatorDirective, typeof i5.RdxDropdownMenuItemRadioGroupDirective, typeof i6.RdxDropdownMenuItemRadioDirective, typeof i7.RdxDropdownMenuSelectable, typeof i8.RdxDropdownMenuItemDirective, typeof i9.RdxDropdownMenuLabelDirective, typeof i10.RdxDropdownMenuSeparatorDirective, typeof i1.RdxDropdownMenuTriggerDirective]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<Rdx, never, [typeof RdxDropdownMenuTriggerDirective, typeof RdxDropdownMenuContentDirective, typeof RdxDropdownMenuItemCheckboxDirective, typeof RdxDropdownMenuItemIndicatorDirective, typeof RdxDropdownMenuItemRadioGroupDirective, typeof RdxDropdownMenuItemRadioDirective, typeof RdxDropdownMenuSelectable, typeof RdxDropdownMenuItemDirective, typeof RdxDropdownMenuLabelDirective, typeof RdxDropdownMenuSeparatorDirective, typeof RdxDropdownMenuTriggerDirective], [typeof RdxDropdownMenuTriggerDirective, typeof RdxDropdownMenuContentDirective, typeof RdxDropdownMenuItemCheckboxDirective, typeof RdxDropdownMenuItemIndicatorDirective, typeof RdxDropdownMenuItemRadioGroupDirective, typeof RdxDropdownMenuItemRadioDirective, typeof RdxDropdownMenuSelectable, typeof RdxDropdownMenuItemDirective, typeof RdxDropdownMenuLabelDirective, typeof RdxDropdownMenuSeparatorDirective, typeof RdxDropdownMenuTriggerDirective]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<Rdx>;
 }
+
+export { DropdownAlign, DropdownSide, Rdx, RdxDropdownMenuContentDirective, RdxDropdownMenuItemCheckboxDirective, RdxDropdownMenuItemDirective, RdxDropdownMenuItemIndicatorDirective, RdxDropdownMenuItemRadioDirective, RdxDropdownMenuItemRadioGroupDirective, RdxDropdownMenuLabelDirective, RdxDropdownMenuSelectable, RdxDropdownMenuSeparatorDirective, RdxDropdownMenuTriggerDirective, mapRdxAlignToCdkPosition };

package/editable/index.d.ts

@@ -1 +1,70 @@
-export * from './src/editable-root';
+import * as _angular_core from '@angular/core';
+import { Signal, WritableSignal } from '@angular/core';
+import { BooleanInput, NumberInput } from '@angular/cdk/coercion';
+import * as i1 from '@radix-ng/primitives/dismissable-layer';
+import { RdxPointerDownOutside } from '@radix-ng/primitives/dismissable-layer';
+
+type EditableRootContext = {
+    disabled: Signal<boolean>;
+    value: Signal<string | null | undefined>;
+    inputValue: WritableSignal<string | undefined>;
+    placeholder: Signal<{
+        edit: string;
+        preview: string;
+    }>;
+    isEditing: Signal<boolean>;
+    submitMode: Signal<SubmitMode>;
+    activationMode: Signal<ActivationMode>;
+    edit: () => void;
+    cancel: () => void;
+    submit: () => void;
+    maxLength: Signal<number | undefined>;
+    startWithEditMode: Signal<boolean>;
+    isEmpty: Signal<boolean>;
+    readonly: Signal<boolean>;
+    selectOnFocus: Signal<boolean>;
+    autoResize: Signal<boolean>;
+    inputRef: WritableSignal<HTMLInputElement | undefined>;
+};
+declare const injectEditableRootContext: (optional?: boolean) => EditableRootContext | null;
+declare const provideEditableRootContext: (useFactory: () => EditableRootContext) => _angular_core.Provider;
+type ActivationMode = 'focus' | 'dblclick' | 'none';
+type SubmitMode = 'blur' | 'enter' | 'none' | 'both';
+/**
+ * @group Components
+ */
+declare class RdxEditableRoot {
+    private readonly focusOutside;
+    readonly pointerDownOutside: RdxPointerDownOutside;
+    readonly value: _angular_core.ModelSignal<string | undefined>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly readonly: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly selectOnFocus: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly submitMode: _angular_core.InputSignal<SubmitMode>;
+    readonly maxLength: _angular_core.InputSignalWithTransform<number | undefined, NumberInput>;
+    /**
+     * Whether to start with the edit mode active
+     */
+    readonly startWithEditMode: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly activationMode: _angular_core.InputSignal<ActivationMode>;
+    readonly autoResize: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly required: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly isEmpty: Signal<boolean>;
+    readonly $placeholder: Signal<string | {
+        edit: string;
+        preview: string;
+    }>;
+    readonly isEditing: WritableSignal<boolean>;
+    readonly inputValue: WritableSignal<string | undefined>;
+    readonly inputRef: WritableSignal<HTMLInputElement | undefined>;
+    constructor();
+    handleDismiss(): void;
+    submit(): void;
+    cancel(): void;
+    edit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxEditableRoot, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxEditableRoot, "[rdxEditableRoot]", ["rdxEditableRoot"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "selectOnFocus": { "alias": "selectOnFocus"; "required": false; "isSignal": true; }; "submitMode": { "alias": "submitMode"; "required": false; "isSignal": true; }; "maxLength": { "alias": "maxLength"; "required": false; "isSignal": true; }; "startWithEditMode": { "alias": "startWithEditMode"; "required": false; "isSignal": true; }; "activationMode": { "alias": "activationMode"; "required": false; "isSignal": true; }; "autoResize": { "alias": "autoResize"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, [{ directive: typeof i1.RdxFocusOutside; inputs: {}; outputs: {}; }, { directive: typeof i1.RdxPointerDownOutside; inputs: {}; outputs: {}; }]>;
+}
+
+export { RdxEditableRoot, injectEditableRootContext, provideEditableRootContext };

package/fesm2022/radix-ng-primitives-accordion.mjs

@@ -6,10 +6,10 @@ import { createContext, useArrowNavigation } from '@radix-ng/primitives/core';
 import { _IdGenerator } from '@angular/cdk/a11y';
 
 class RdxAccordionContentPresenceDirective {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: RdxAccordionContentPresenceDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.2.4", type: RdxAccordionContentPresenceDirective, isStandalone: true, selector: "ng-template[rdxAccordionContentPresence]", hostDirectives: [{ directive: i1.RdxCollapsibleContentPresenceDirective }], ngImport: i0 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: RdxAccordionContentPresenceDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "20.3.3", type: RdxAccordionContentPresenceDirective, isStandalone: true, selector: "ng-template[rdxAccordionContentPresence]", hostDirectives: [{ directive: i1.RdxCollapsibleContentPresenceDirective }], ngImport: i0 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: RdxAccordionContentPresenceDirective, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: RdxAccordionContentPresenceDirective, decorators: [{
             type: Directive,
             args: [{
                     selector: 'ng-template[rdxAccordionContentPresence]',
@@ -37,38 +37,38 @@ const rootContext = () => {
 class RdxAccordionRootDirective {
     constructor() {
         this.elementRef = inject(ElementRef);
-        this.id = input(inject(_IdGenerator).getId('rdx-accordion-'));
+        this.id = input(inject(_IdGenerator).getId('rdx-accordion-'), ...(ngDevMode ? [{ debugName: "id" }] : []));
         /**
          * The reading direction of the accordion when applicable. If omitted, assumes LTR (left-to-right) reading mode.
          *
          * @group Props
          */
-        this.dir = input('ltr');
+        this.dir = input('ltr', ...(ngDevMode ? [{ debugName: "dir" }] : []));
         /** Whether the Accordion is disabled.
          * @defaultValue false
          * @group Props
          */
-        this.disabled = input(false, { transform: booleanAttribute });
+        this.disabled = input(false, ...(ngDevMode ? [{ debugName: "disabled", transform: booleanAttribute }] : [{ transform: booleanAttribute }]));
         /**
          * The orientation of the accordion.
          *
          * @defaultValue 'vertical'
          * @group Props
          */
-        this.orientation = input('vertical');
+        this.orientation = input('vertical', ...(ngDevMode ? [{ debugName: "orientation" }] : []));
         /**
          * The default active value of the item(s).
          *
          * Use when you do not need to control the state of the item(s).
          * @group Props
          */
-        this.defaultValue = input();
+        this.defaultValue = input(...(ngDevMode ? [undefined, { debugName: "defaultValue" }] : []));
         /**
          * The controlled value of the item to expand.
          *
          * @group Props
          */
-        this.value = model();
+        this.value = model(...(ngDevMode ? [undefined, { debugName: "value" }] : []));
         /**
          * When type is "single", allows closing content when clicking trigger for an open item.
          * When type is "multiple", this prop has no effect.
@@ -76,20 +76,20 @@ class RdxAccordionRootDirective {
          * @defaultValue false
          * @group Props
          */
-        this.collapsible = input(false, { transform: booleanAttribute });
+        this.collapsible = input(false, ...(ngDevMode ? [{ debugName: "collapsible", transform: booleanAttribute }] : [{ transform: booleanAttribute }]));
         /**
          * Determines whether a "single" or "multiple" items can be selected at a time.
          *
          * @defaultValue 'single'
          * @group Props
          */
-        this.type = input('single');
+        this.type = input('single', ...(ngDevMode ? [{ debugName: "type" }] : []));
         /**
          * Event handler called when the expanded state of an item changes and type is "multiple".
          * @group Emits
          */
         this.onValueChange = output();
-        this.isSingle = computed(() => this.type() === 'single');
+        this.isSingle = computed(() => this.type() === 'single', ...(ngDevMode ? [{ debugName: "isSingle" }] : []));
         this.changeModelValue = (newValue) => {
             if (this.type() === 'single') {
                 this.value.set(this.isEqual(newValue, this.value()) ? undefined : newValue);
@@ -127,10 +127,10 @@ class RdxAccordionRootDirective {
     isEqual(a, b) {
         return JSON.stringify(a) === JSON.stringify(b);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: RdxAccordionRootDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "19.2.4", type: RdxAccordionRootDirective, isStandalone: true, selector: "[rdxAccordionRoot]", inputs: { id: { classPropertyName: "id", publicName: "id", isSignal: true, isRequired: false, transformFunction: null }, dir: { classPropertyName: "dir", publicName: "dir", isSignal: true, isRequired: false, transformFunction: null }, disabled: { classPropertyName: "disabled", publicName: "disabled", isSignal: true, isRequired: false, transformFunction: null }, orientation: { classPropertyName: "orientation", publicName: "orientation", isSignal: true, isRequired: false, transformFunction: null }, defaultValue: { classPropertyName: "defaultValue", publicName: "defaultValue", isSignal: true, isRequired: false, transformFunction: null }, value: { classPropertyName: "value", publicName: "value", isSignal: true, isRequired: false, transformFunction: null }, collapsible: { classPropertyName: "collapsible", publicName: "collapsible", isSignal: true, isRequired: false, transformFunction: null }, type: { classPropertyName: "type", publicName: "type", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { value: "valueChange", onValueChange: "onValueChange" }, host: { properties: { "attr.data-orientation": "orientation()" } }, providers: [provideAccordionRootContext(rootContext)], exportAs: ["rdxAccordionRoot"], ngImport: i0 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: RdxAccordionRootDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "20.3.3", type: RdxAccordionRootDirective, isStandalone: true, selector: "[rdxAccordionRoot]", inputs: { id: { classPropertyName: "id", publicName: "id", isSignal: true, isRequired: false, transformFunction: null }, dir: { classPropertyName: "dir", publicName: "dir", isSignal: true, isRequired: false, transformFunction: null }, disabled: { classPropertyName: "disabled", publicName: "disabled", isSignal: true, isRequired: false, transformFunction: null }, orientation: { classPropertyName: "orientation", publicName: "orientation", isSignal: true, isRequired: false, transformFunction: null }, defaultValue: { classPropertyName: "defaultValue", publicName: "defaultValue", isSignal: true, isRequired: false, transformFunction: null }, value: { classPropertyName: "value", publicName: "value", isSignal: true, isRequired: false, transformFunction: null }, collapsible: { classPropertyName: "collapsible", publicName: "collapsible", isSignal: true, isRequired: false, transformFunction: null }, type: { classPropertyName: "type", publicName: "type", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { value: "valueChange", onValueChange: "onValueChange" }, host: { properties: { "attr.data-orientation": "orientation()" } }, providers: [provideAccordionRootContext(rootContext)], exportAs: ["rdxAccordionRoot"], ngImport: i0 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: RdxAccordionRootDirective, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: RdxAccordionRootDirective, decorators: [{
             type: Directive,
             args: [{
                     selector: '[rdxAccordionRoot]',
@@ -168,20 +168,20 @@ class RdxAccordionItemDirective {
          * A string value for the accordion item. All items within an accordion should use a unique value.
          * @group Props
          */
-        this.value = input();
+        this.value = input(...(ngDevMode ? [undefined, { debugName: "value" }] : []));
         /**
          * Whether or not an accordion item is disabled from user interaction.
          * When `true`, prevents the user from interacting with the item.
          * @group Props
          */
-        this.disabled = input(false, { transform: booleanAttribute });
+        this.disabled = input(false, ...(ngDevMode ? [{ debugName: "disabled", transform: booleanAttribute }] : [{ transform: booleanAttribute }]));
         this.isDisabled = computed(() => {
             return this.rootContext.disabled() || this.disabled();
-        });
+        }, ...(ngDevMode ? [{ debugName: "isDisabled" }] : []));
         this.open = computed(() => this.rootContext.isSingle()
             ? this.value() === this.rootContext.value()
-            : Array.isArray(this.rootContext.value()) && this.rootContext.value().includes(this.value()));
-        this.dataState = computed(() => (this.open() ? 'open' : 'closed'));
+            : Array.isArray(this.rootContext.value()) && this.rootContext.value().includes(this.value()), ...(ngDevMode ? [{ debugName: "open" }] : []));
+        this.dataState = computed(() => (this.open() ? 'open' : 'closed'), ...(ngDevMode ? [{ debugName: "dataState" }] : []));
         this.updateOpen = () => {
             this.collapsibleContext.open.set(this.open());
         };
@@ -201,10 +201,10 @@ class RdxAccordionItemDirective {
             focus: true
         });
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: RdxAccordionItemDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "19.2.4", type: RdxAccordionItemDirective, isStandalone: true, selector: "[rdxAccordionItem]", inputs: { value: { classPropertyName: "value", publicName: "value", isSignal: true, isRequired: false, transformFunction: null }, disabled: { classPropertyName: "disabled", publicName: "disabled", isSignal: true, isRequired: false, transformFunction: null } }, host: { listeners: { "keydown.arrowDown": "handleArrowKey($event)", "keydown.arrowUp": "handleArrowKey($event)", "keydown.arrowLeft": "handleArrowKey($event)", "keydown.arrowRight": "handleArrowKey($event)", "keydown.home": "handleArrowKey($event)", "keydown.end": "handleArrowKey($event)" }, properties: { "attr.data-orientation": "rootContext.orientation()", "attr.data-disabled": "disabled() ? \"\" : undefined", "attr.data-state": "dataState()" } }, providers: [provideAccordionItemContext(itemContext)], exportAs: ["rdxAccordionItem"], hostDirectives: [{ directive: i1.RdxCollapsibleRootDirective, inputs: ["disabled", "disabled", "open", "open"] }], ngImport: i0 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: RdxAccordionItemDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "20.3.3", type: RdxAccordionItemDirective, isStandalone: true, selector: "[rdxAccordionItem]", inputs: { value: { classPropertyName: "value", publicName: "value", isSignal: true, isRequired: false, transformFunction: null }, disabled: { classPropertyName: "disabled", publicName: "disabled", isSignal: true, isRequired: false, transformFunction: null } }, host: { listeners: { "keydown.arrowDown": "handleArrowKey($event)", "keydown.arrowUp": "handleArrowKey($event)", "keydown.arrowLeft": "handleArrowKey($event)", "keydown.arrowRight": "handleArrowKey($event)", "keydown.home": "handleArrowKey($event)", "keydown.end": "handleArrowKey($event)" }, properties: { "attr.data-orientation": "rootContext.orientation()", "attr.data-disabled": "disabled() ? \"\" : undefined", "attr.data-state": "dataState()" } }, providers: [provideAccordionItemContext(itemContext)], exportAs: ["rdxAccordionItem"], hostDirectives: [{ directive: i1.RdxCollapsibleRootDirective, inputs: ["disabled", "disabled", "open", "open"] }], ngImport: i0 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: RdxAccordionItemDirective, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: RdxAccordionItemDirective, decorators: [{
             type: Directive,
             args: [{
                     selector: '[rdxAccordionItem]',
@@ -235,10 +235,10 @@ class RdxAccordionContentDirective {
         this.rootContext = injectAccordionRootContext();
         this.itemContext = injectAccordionItemContext();
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: RdxAccordionContentDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.2.4", type: RdxAccordionContentDirective, isStandalone: true, selector: "[rdxAccordionContent]", host: { attributes: { "role": "region" }, properties: { "attr.aria-labelledby": "itemContext.triggerId", "attr.data-state": "itemContext.dataState()", "attr.data-disabled": "itemContext.dataDisabled()", "attr.data-orientation": "rootContext.orientation()", "style": "{\n            '--radix-accordion-content-height': 'var(--radix-collapsible-content-height)',\n            '--radix-accordion-content-width': 'var(--radix-collapsible-content-width)',\n          }" } }, hostDirectives: [{ directive: i1.RdxCollapsibleContentDirective }], ngImport: i0 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: RdxAccordionContentDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "20.3.3", type: RdxAccordionContentDirective, isStandalone: true, selector: "[rdxAccordionContent]", host: { attributes: { "role": "region" }, properties: { "attr.aria-labelledby": "itemContext.triggerId", "attr.data-state": "itemContext.dataState()", "attr.data-disabled": "itemContext.dataDisabled()", "attr.data-orientation": "rootContext.orientation()", "style": "{\n            '--radix-accordion-content-height': 'var(--radix-collapsible-content-height)',\n            '--radix-accordion-content-width': 'var(--radix-collapsible-content-width)',\n          }" } }, hostDirectives: [{ directive: i1.RdxCollapsibleContentDirective }], ngImport: i0 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: RdxAccordionContentDirective, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: RdxAccordionContentDirective, decorators: [{
             type: Directive,
             args: [{
                     selector: '[rdxAccordionContent]',
@@ -262,10 +262,10 @@ class RdxAccordionHeaderDirective {
         this.rootContext = injectAccordionRootContext();
         this.itemContext = injectAccordionItemContext();
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: RdxAccordionHeaderDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.2.4", type: RdxAccordionHeaderDirective, isStandalone: true, selector: "[rdxAccordionHeader]", host: { properties: { "attr.data-state": "itemContext.dataState()", "attr.data-disabled": "itemContext.dataDisabled()", "attr.data-orientation": "rootContext.orientation()" } }, ngImport: i0 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: RdxAccordionHeaderDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "20.3.3", type: RdxAccordionHeaderDirective, isStandalone: true, selector: "[rdxAccordionHeader]", host: { properties: { "attr.data-state": "itemContext.dataState()", "attr.data-disabled": "itemContext.dataDisabled()", "attr.data-orientation": "rootContext.orientation()" } }, ngImport: i0 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: RdxAccordionHeaderDirective, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: RdxAccordionHeaderDirective, decorators: [{
             type: Directive,
             args: [{
                     selector: '[rdxAccordionHeader]',
@@ -291,10 +291,10 @@ class RdxAccordionTriggerDirective {
         }
         this.rootContext.changeModelValue(this.itemContext.value());
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: RdxAccordionTriggerDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.2.4", type: RdxAccordionTriggerDirective, isStandalone: true, selector: "[rdxAccordionTrigger]", host: { listeners: { "click": "changeItem()" }, properties: { "id": "itemContext.triggerId", "attr.data-rdx-collection-item": "\"\"", "attr.role": "\"button\"", "attr.aria-disabled": "itemContext.open() && !rootContext.collapsible() ? \"true\" : undefined", "attr.data-orientation": "rootContext.orientation()", "disabled": "itemContext.disabled()" } }, hostDirectives: [{ directive: i1.RdxCollapsibleTriggerDirective }], ngImport: i0 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: RdxAccordionTriggerDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "20.3.3", type: RdxAccordionTriggerDirective, isStandalone: true, selector: "[rdxAccordionTrigger]", host: { listeners: { "click": "changeItem()" }, properties: { "id": "itemContext.triggerId", "attr.data-rdx-collection-item": "\"\"", "attr.role": "\"button\"", "attr.aria-disabled": "itemContext.open() && !rootContext.collapsible() ? \"true\" : undefined", "attr.data-orientation": "rootContext.orientation()", "disabled": "itemContext.disabled()" } }, hostDirectives: [{ directive: i1.RdxCollapsibleTriggerDirective }], ngImport: i0 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: RdxAccordionTriggerDirective, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: RdxAccordionTriggerDirective, decorators: [{
             type: Directive,
             args: [{
                     selector: '[rdxAccordionTrigger]',
@@ -320,8 +320,8 @@ const _imports = [
     RdxAccordionContentPresenceDirective
 ];
 class RdxAccordionModule {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: RdxAccordionModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.2.4", ngImport: i0, type: RdxAccordionModule, imports: [RdxAccordionContentDirective,
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: RdxAccordionModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.3", ngImport: i0, type: RdxAccordionModule, imports: [RdxAccordionContentDirective,
             RdxAccordionHeaderDirective,
             RdxAccordionItemDirective,
             RdxAccordionRootDirective,
@@ -332,9 +332,9 @@ class RdxAccordionModule {
             RdxAccordionRootDirective,
             RdxAccordionTriggerDirective,
             RdxAccordionContentPresenceDirective] }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: RdxAccordionModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: RdxAccordionModule }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: RdxAccordionModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: RdxAccordionModule, decorators: [{
             type: NgModule,
             args: [{
                     imports: [..._imports],