@radix-ng/primitives 0.50.0 → 1.0.0-beta.0

package/{date-field/index.d.ts → types/radix-ng-primitives-date-field.d.ts}

@@ -1,13 +1,10 @@
 import * as _angular_core from '@angular/core';
-import { OnInit, AfterViewInit, InputSignal, ModelSignal, Signal, WritableSignal, InjectionToken } from '@angular/core';
+import { Signal, InjectionToken, InputSignal, ModelSignal, WritableSignal } from '@angular/core';
 import * as _radix_ng_primitives_core from '@radix-ng/primitives/core';
-import { DateMatcher, HourCycle, Granularity, DateStep, Formatter, SegmentValueObj, SegmentPart } from '@radix-ng/primitives/core';
-import { Direction } from '@angular/cdk/bidi';
-import { BooleanInput } from '@angular/cdk/coercion';
+import { DateMatcher, HourCycle, Granularity, Direction, BooleanInput, DateStep, Formatter, SegmentValueObj, SegmentPart } from '@radix-ng/primitives/core';
 import { DateValue } from '@internationalized/date';
 
-declare class RdxDateFieldRootDirective implements OnInit, AfterViewInit {
-    private readonly elementRef;
+declare class RdxDateFieldRootDirective {
     /**
      * The controlled checked state of the calendar.
      */
@@ -51,43 +48,57 @@ declare class RdxDateFieldRootDirective implements OnInit, AfterViewInit {
      * The stepping interval for the time fields. Defaults to 1
      */
     readonly step: _angular_core.InputSignal<DateStep | undefined>;
-    readonly step$: _angular_core.Signal<DateStep>;
+    readonly step$: Signal<DateStep>;
+    /**
+     * Locale- and hour-cycle-aware formatter. Recomputed whenever `locale` or
+     * `hourCycle` change so segments always render with the current settings.
+     * @ignore
+     */
+    readonly formatter: Signal<Formatter>;
     /**
      * @ignore
      */
-    readonly defaultDate: _angular_core.Signal<DateValue>;
+    readonly defaultDate: Signal<DateValue>;
     /**
      * The placeholder date, which is used to determine what month to display when no date is selected. This updates as the user navigates the calendar and can be used to programmatically control the calendar view
      */
     readonly placeholder: _angular_core.ModelSignal<DateValue | undefined>;
     /**
+     * Segment input parts, collected from the projected content in DOM order. This
+     * stays in sync with `segmentContents()` (granularity / locale / value changes
+     * add or remove segments) instead of being captured once after view init.
      * @ignore
      */
-    readonly segmentElements: _angular_core.WritableSignal<Set<HTMLElement>>;
+    private readonly segmentInputs;
     /**
+     * The focusable (non-literal) segment elements, in DOM order.
      * @ignore
      */
-    readonly currentFocusedElement: _angular_core.WritableSignal<HTMLElement | null>;
+    readonly segmentElements: Signal<HTMLElement[]>;
     /**
      * @ignore
      */
-    formatter: Formatter;
+    readonly currentFocusedElement: _angular_core.WritableSignal<HTMLElement | null>;
     /**
      * @ignore
      */
-    readonly segmentValues: _angular_core.WritableSignal<SegmentValueObj>;
+    readonly inferredGranularity: Signal<Granularity | undefined>;
     /**
+     * The per-segment values. Writable so segment editing (via `useDateField`) can
+     * update individual parts, but re-synced from the model whenever the value,
+     * granularity or formatter change — so a controlled `value` set after init is
+     * reflected, and an empty field re-initializes when granularity changes.
      * @ignore
      */
-    readonly inferredGranularity: _angular_core.Signal<Granularity | undefined>;
+    readonly segmentValues: _angular_core.WritableSignal<SegmentValueObj>;
     /**
      * @ignore
      */
-    readonly isInvalid: _angular_core.Signal<boolean>;
+    readonly isInvalid: Signal<boolean>;
     /**
      * @ignore
      */
-    readonly allSegmentContent: _angular_core.Signal<{
+    readonly allSegmentContent: Signal<{
         obj: _radix_ng_primitives_core.SegmentContentObj;
         arr: {
             part: _radix_ng_primitives_core.SegmentPart;
@@ -97,43 +108,47 @@ declare class RdxDateFieldRootDirective implements OnInit, AfterViewInit {
     /**
      * An array of segments that should be readonly, which prevent user input on them.
      */
-    readonly segmentContents: _angular_core.Signal<{
+    readonly segmentContents: Signal<{
         part: _radix_ng_primitives_core.SegmentPart;
         value: string;
     }[]>;
     /**
      * @ignore
      */
-    readonly currentSegmentIndex: _angular_core.Signal<number>;
+    readonly currentSegmentIndex: Signal<number>;
     /**
      * @ignore
      */
-    readonly prevFocusableSegment: _angular_core.Signal<HTMLElement | null>;
+    readonly prevFocusableSegment: Signal<HTMLElement | null>;
     /**
      * @ignore
      */
-    readonly nextFocusableSegment: _angular_core.Signal<HTMLElement | null>;
+    readonly nextFocusableSegment: Signal<HTMLElement | null>;
     /**
      * @ignore
      */
     readonly focusNext: () => void;
     constructor();
-    ngOnInit(): void;
-    ngAfterViewInit(): void;
     /**
      * @ignore
      */
-    onKeydown(event: KeyboardEvent): void;
+    onKeydown(event: Event): void;
     /**
      * @ignore
      */
     setFocusedElement(el: HTMLElement): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxDateFieldRootDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxDateFieldRootDirective, "[rdxDateFieldRoot]", ["rdxDateFieldRoot"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "isDateUnavailable": { "alias": "isDateUnavailable"; "required": false; "isSignal": true; }; "hourCycle": { "alias": "hourCycle"; "required": false; "isSignal": true; }; "granularity": { "alias": "granularity"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "dir": { "alias": "dir"; "required": false; "isSignal": true; }; "minValue": { "alias": "minValue"; "required": false; "isSignal": true; }; "maxValue": { "alias": "maxValue"; "required": false; "isSignal": true; }; "hideTimeZone": { "alias": "hideTimeZone"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "placeholder": "placeholderChange"; }, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxDateFieldRootDirective, "[rdxDateFieldRoot]", ["rdxDateFieldRoot"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "isDateUnavailable": { "alias": "isDateUnavailable"; "required": false; "isSignal": true; }; "hourCycle": { "alias": "hourCycle"; "required": false; "isSignal": true; }; "granularity": { "alias": "granularity"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "dir": { "alias": "dir"; "required": false; "isSignal": true; }; "minValue": { "alias": "minValue"; "required": false; "isSignal": true; }; "maxValue": { "alias": "maxValue"; "required": false; "isSignal": true; }; "hideTimeZone": { "alias": "hideTimeZone"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "placeholder": "placeholderChange"; }, ["segmentInputs"], never, true, never>;
 }
 
 declare class RdxDateFieldInputDirective {
     private readonly elementRef;
+    /**
+     * The host element of this segment. Consumed by the root to collect focusable
+     * segments in DOM order.
+     * @ignore
+     */
+    readonly element: HTMLElement;
     private readonly rootContext;
     /**
      * The part of the date to render
@@ -165,16 +180,16 @@ declare class RdxDateFieldInputDirective {
     /**
      * @ignore
      */
-    handleSegmentClick: (e: MouseEvent) => void;
+    handleSegmentClick: (e: Event) => void;
     /**
      * @ignore
      */
-    handleSegmentKeydown: (e: KeyboardEvent) => void;
+    handleSegmentKeydown: (e: Event) => void;
     constructor();
     /**
      * @ignore
      */
-    onFocus(e: FocusEvent): void;
+    onFocus(e: Event): void;
     /**
      * @ignore
      */
@@ -192,7 +207,7 @@ interface DateFieldContextToken {
     placeholder: ModelSignal<DateValue>;
     hourCycle: InputSignal<HourCycle>;
     step$: Signal<DateStep>;
-    formatter: Formatter;
+    formatter: Signal<Formatter>;
     segmentValues: WritableSignal<SegmentValueObj>;
     focusNext: () => void;
     setFocusedElement: (el: HTMLElement) => void;

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

@@ -0,0 +1,323 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, Provider, Signal, ElementRef } from '@angular/core';
+import * as i1 from '@radix-ng/primitives/presence';
+import { RdxTransitionStatus, BooleanInput } from '@radix-ng/primitives/core';
+import * as _radix_ng_primitives_dialog from '@radix-ng/primitives/dialog';
+import * as i1$1 from '@radix-ng/primitives/portal';
+import { RdxPortalContainer } from '@radix-ng/primitives/portal';
+import * as i1$2 from '@radix-ng/primitives/dismissable-layer';
+import * as i2 from '@radix-ng/primitives/focus-scope';
+
+/**
+ * Mounts the portal while the dialog is open and waits for CSS exit keyframes before unmounting.
+ */
+declare class RdxDialogPortalPresence {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxDialogPortalPresence, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxDialogPortalPresence, "ng-template[rdxDialogPortalPresence]", never, {}, {}, never, never, true, [{ directive: typeof i1.RdxPresenceDirective; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * Connects a dialog root with trigger elements rendered elsewhere in the DOM, and exposes
+ * imperative `open`/`close`/`toggle` methods.
+ */
+declare class RdxDialogHandle<Payload = unknown> {
+    private readonly rootContext;
+    private readonly triggers;
+    private readonly rootTriggerCleanups;
+    readonly isOpen: _angular_core.Signal<boolean>;
+    open(triggerId: string): void;
+    close(): void;
+    toggle(triggerId: string, event?: Event): void;
+    registerRoot(rootContext: RdxDialogRootContext): () => void;
+    registerTrigger(id: string, trigger: HTMLElement, payload: () => Payload | undefined): () => void;
+    context(): RdxDialogRootContext | undefined;
+}
+declare function createRdxDialogHandle<Payload = unknown>(): RdxDialogHandle<Payload>;
+
+type RdxDialogRole = 'dialog' | 'alertdialog';
+/**
+ * Behavioral profile for a dialog, supplied by a composing root (e.g. alert-dialog, drawer) to
+ * specialize the shared Dialog without new public dialog inputs.
+ *
+ * These are *force-only* overrides: a variant uses them to pin behavior regardless of the public
+ * inputs (as alert-dialog does). A variant that wants a configurable default instead simply leaves
+ * the flags off and lets the composing root proxy the `modal` / `disablePointerDismissal` inputs —
+ * that is how Drawer stays modal-by-default while remaining user-overridable.
+ *
+ * The three concerns are kept independent on purpose so future variants can mix them freely
+ * (e.g. a modal, non-dismissable drawer that is still `role="dialog"`):
+ * - `role` — ARIA role rendered on the popup.
+ * - `forceModal` — pin modality to `true` regardless of the `modal` input.
+ * - `forcePointerDismissalDisabled` — disable outside-press / focus-out dismissal (Escape still closes).
+ */
+interface RdxDialogVariant {
+    role: RdxDialogRole;
+    forceModal: boolean;
+    forcePointerDismissalDisabled: boolean;
+}
+declare const RDX_DIALOG_VARIANT: InjectionToken<RdxDialogVariant>;
+declare function provideRdxDialogVariant(variant: Partial<RdxDialogVariant>): Provider;
+
+type RdxDialogModal = boolean | 'trap-focus';
+type RdxDialogOpenChangeReason = 'trigger-press' | 'close-press' | 'outside-press' | 'focus-out' | 'escape-key' | 'swipe' | 'imperative-action' | 'none';
+interface RdxDialogOpenChange {
+    open: boolean;
+    triggerId: string | null;
+    trigger: HTMLElement | undefined;
+    reason: RdxDialogOpenChangeReason;
+    event: Event;
+}
+interface RdxDialogRootContext {
+    contentId: string;
+    titleId: Signal<string | undefined>;
+    descriptionId: Signal<string | undefined>;
+    isOpen: Signal<boolean>;
+    /** Effective modality (the variant can pin this to `true`). */
+    modal: Signal<RdxDialogModal>;
+    /** Effective outside-press / focus-out dismissal flag (the variant can force it on). */
+    disablePointerDismissal: Signal<boolean>;
+    /** ARIA role for the popup; constant, fixed by the variant at construction. */
+    role: RdxDialogRole;
+    transitionStatus: Signal<RdxTransitionStatus>;
+    trigger: Signal<HTMLElement | undefined>;
+    triggers: Signal<HTMLElement[]>;
+    payload: Signal<unknown>;
+    /** Whether this dialog is nested in another; constant, fixed at construction. */
+    nested: boolean;
+    nestedDialogOpen: Signal<boolean>;
+    setTitleId: (id: string | undefined) => void;
+    setDescriptionId: (id: string | undefined) => void;
+    registerTransitionElement: (element: HTMLElement) => () => void;
+    registerTrigger: (id: string, trigger: HTMLElement, payload: () => unknown) => () => void;
+    open: (trigger?: HTMLElement, payload?: unknown, triggerId?: string, reason?: RdxDialogOpenChangeReason, event?: Event) => void;
+    close: (reason?: RdxDialogOpenChangeReason, event?: Event) => void;
+    toggle: (triggerId: string, trigger: HTMLElement, payload?: unknown, event?: Event) => void;
+}
+declare const injectRdxDialogRootContext: (optional?: boolean) => RdxDialogRootContext | null;
+declare const provideRdxDialogRootContext: (useFactory: () => RdxDialogRootContext) => _angular_core.Provider;
+/**
+ * Groups all parts of the dialog.
+ */
+declare class RdxDialogRoot {
+    private readonly destroyRef;
+    private readonly parentRoot;
+    private readonly variant;
+    private hasAppliedDefaultOpen;
+    private hasAppliedDefaultTriggerId;
+    private readonly registeredTriggers;
+    private readonly transition;
+    readonly transitionStatus: Signal<RdxTransitionStatus>;
+    readonly registerTransitionElement: (element: HTMLElement) => () => void;
+    /**
+     * Whether the dialog is currently open.
+     */
+    readonly open: _angular_core.ModelSignal<boolean>;
+    /**
+     * Whether the dialog is initially open.
+     */
+    readonly defaultOpen: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * ID of the trigger associated with a controlled dialog.
+     */
+    readonly triggerId: _angular_core.ModelSignal<string | null>;
+    /**
+     * ID of the trigger associated with an initially open uncontrolled dialog.
+     */
+    readonly defaultTriggerId: _angular_core.InputSignal<string | null>;
+    /**
+     * Determines if the dialog enters a modal state when open.
+     * - `true`: focus is trapped, page scroll is locked, outside pointer events are disabled.
+     * - `false`: interaction with the rest of the document is allowed.
+     * - `'trap-focus'`: focus is trapped, but scroll is not locked and outside pointer events remain enabled.
+     */
+    readonly modal: _angular_core.InputSignalWithTransform<RdxDialogModal, BooleanInput>;
+    /**
+     * Determines whether the dialog should close on outside clicks.
+     */
+    readonly disablePointerDismissal: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Associates this root with detached trigger elements rendered outside of it.
+     */
+    readonly handle: _angular_core.InputSignal<RdxDialogHandle<any> | undefined>;
+    /**
+     * Event handler called when the dialog is opened or closed.
+     */
+    readonly onOpenChange: _angular_core.OutputEmitterRef<RdxDialogOpenChange>;
+    /**
+     * Event handler called after any animations complete when the dialog is opened or closed.
+     */
+    readonly onOpenChangeComplete: _angular_core.OutputEmitterRef<boolean>;
+    readonly contentId: string;
+    readonly titleId: _angular_core.WritableSignal<string | undefined>;
+    readonly descriptionId: _angular_core.WritableSignal<string | undefined>;
+    readonly trigger: _angular_core.WritableSignal<HTMLElement | undefined>;
+    readonly triggers: _angular_core.WritableSignal<HTMLElement[]>;
+    readonly payload: _angular_core.WritableSignal<unknown>;
+    readonly nestedOpenCount: _angular_core.WritableSignal<number>;
+    /** Whether this dialog is rendered inside another dialog. Fixed at construction. */
+    readonly nested: boolean;
+    readonly nestedDialogOpen: Signal<boolean>;
+    /** ARIA role, fixed at construction by the dialog variant (`alertdialog` for alert dialogs). */
+    readonly role: RdxDialogRole;
+    /** Effective modality: the variant can pin it to `true` regardless of the `modal` input. */
+    readonly effectiveModal: Signal<RdxDialogModal>;
+    /** Effective dismissal flag: disabled when the input asks, or when the variant forces it (alerts). */
+    readonly effectiveDisablePointerDismissal: Signal<boolean>;
+    constructor();
+    show(trigger?: HTMLElement | undefined, payload?: unknown, triggerId?: string, reason?: RdxDialogOpenChangeReason, event?: Event): void;
+    close(reason?: RdxDialogOpenChangeReason, event?: Event): void;
+    toggle(triggerId: string, trigger: HTMLElement, payload?: unknown, event?: Event): void;
+    registerTrigger(id: string, trigger: HTMLElement, payload: () => unknown): () => void;
+    /** Increments the nested-open counter and returns a release callback that decrements it. */
+    openNestedChild(): () => void;
+    private syncTriggerId;
+    private emitOpenChange;
+    private emitOpenChangeComplete;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxDialogRoot, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxDialogRoot, "[rdxDialogRoot]", ["rdxDialogRoot"], { "open": { "alias": "open"; "required": false; "isSignal": true; }; "defaultOpen": { "alias": "defaultOpen"; "required": false; "isSignal": true; }; "triggerId": { "alias": "triggerId"; "required": false; "isSignal": true; }; "defaultTriggerId": { "alias": "defaultTriggerId"; "required": false; "isSignal": true; }; "modal": { "alias": "modal"; "required": false; "isSignal": true; }; "disablePointerDismissal": { "alias": "disablePointerDismissal"; "required": false; "isSignal": true; }; "handle": { "alias": "handle"; "required": false; "isSignal": true; }; }, { "open": "openChange"; "triggerId": "triggerIdChange"; "onOpenChange": "onOpenChange"; "onOpenChangeComplete": "onOpenChangeComplete"; }, never, never, true, never>;
+}
+
+/**
+ * A button that opens the dialog.
+ */
+declare class RdxDialogTrigger {
+    private readonly parentRootContext;
+    readonly elementRef: ElementRef<HTMLElement>;
+    /**
+     * Associates this trigger with a detached dialog root.
+     */
+    readonly handle: _angular_core.InputSignal<RdxDialogHandle<any> | undefined>;
+    /**
+     * Data associated with this trigger while it is active.
+     */
+    readonly payload: _angular_core.InputSignal<unknown>;
+    /**
+     * ID used to identify this trigger when opening a detached or controlled dialog.
+     */
+    readonly id: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Whether the trigger should ignore user interaction.
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private readonly generatedId;
+    protected readonly triggerId: _angular_core.Signal<string>;
+    protected readonly rootContext: _angular_core.Signal<_radix_ng_primitives_dialog.RdxDialogRootContext | null>;
+    protected readonly isOpen: _angular_core.Signal<boolean>;
+    constructor();
+    protected handleClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxDialogTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxDialogTrigger, "button[rdxDialogTrigger]", ["rdxDialogTrigger"], { "handle": { "alias": "handle"; "required": false; "isSignal": true; }; "payload": { "alias": "payload"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Moves the dialog to a different part of the DOM.
+ */
+declare class RdxDialogPortal {
+    protected readonly rootContext: _radix_ng_primitives_dialog.RdxDialogRootContext;
+    /**
+     * Optional container to portal the content into. Defaults to `document.body`.
+     */
+    readonly container: _angular_core.InputSignal<RdxPortalContainer | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxDialogPortal, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxDialogPortal, "[rdxDialogPortal]", ["rdxDialogPortal"], { "container": { "alias": "container"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$1.RdxPortal; inputs: { "container": "container"; }; outputs: {}; }]>;
+}
+
+/**
+ * An overlay displayed beneath the dialog popup.
+ */
+declare class RdxDialogBackdrop {
+    protected readonly rootContext: _radix_ng_primitives_dialog.RdxDialogRootContext;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxDialogBackdrop, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxDialogBackdrop, "[rdxDialogBackdrop]", ["rdxDialogBackdrop"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * A positioning container for the dialog popup that can be made scrollable.
+ *
+ * Place it inside the portal, around the popup, to scroll the popup when it is taller than the
+ * viewport (outside scroll). Pointer events pass through while the dialog is closed.
+ */
+declare class RdxDialogViewport {
+    protected readonly rootContext: _radix_ng_primitives_dialog.RdxDialogRootContext;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxDialogViewport, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxDialogViewport, "[rdxDialogViewport]", ["rdxDialogViewport"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * A container for the dialog contents.
+ */
+declare class RdxDialogPopup {
+    protected readonly rootContext: _radix_ng_primitives_dialog.RdxDialogRootContext;
+    private readonly dismissableLayer;
+    private readonly focusScope;
+    private dismissDetails;
+    /**
+     * Event handler called when the escape key is down. Can be prevented.
+     */
+    readonly escapeKeyDown: _angular_core.OutputRef<KeyboardEvent>;
+    /**
+     * Event handler called when a pointerdown event happens outside of the popup. Can be prevented.
+     */
+    readonly pointerDownOutside: _angular_core.OutputRef<PointerEvent>;
+    /**
+     * Event handler called when focus moves outside of the popup. Can be prevented.
+     */
+    readonly focusOutside: _angular_core.OutputRef<FocusEvent>;
+    /**
+     * Event handler called when an interaction happens outside of the popup. Can be prevented.
+     */
+    readonly interactOutside: _angular_core.OutputRef<PointerEvent | FocusEvent>;
+    /**
+     * Event handler called before focus moves into the popup. Can be prevented.
+     */
+    readonly openAutoFocus: _angular_core.OutputRef<Event>;
+    /**
+     * Event handler called before focus returns after the popup is removed. Can be prevented.
+     */
+    readonly closeAutoFocus: _angular_core.OutputRef<Event>;
+    constructor();
+    private isEventOnTrigger;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxDialogPopup, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxDialogPopup, "[rdxDialogPopup]", ["rdxDialogPopup"], {}, { "escapeKeyDown": "escapeKeyDown"; "pointerDownOutside": "pointerDownOutside"; "focusOutside": "focusOutside"; "interactOutside": "interactOutside"; "openAutoFocus": "openAutoFocus"; "closeAutoFocus": "closeAutoFocus"; }, never, never, true, [{ directive: typeof i1$2.RdxDismissableLayer; inputs: {}; outputs: {}; }, { directive: typeof i2.RdxFocusScope; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * An accessible title for the dialog.
+ */
+declare class RdxDialogTitle {
+    private readonly rootContext;
+    readonly id: string;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxDialogTitle, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxDialogTitle, "[rdxDialogTitle]", ["rdxDialogTitle"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * An accessible description for the dialog.
+ */
+declare class RdxDialogDescription {
+    private readonly rootContext;
+    readonly id: string;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxDialogDescription, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxDialogDescription, "[rdxDialogDescription]", ["rdxDialogDescription"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * A button that closes the dialog.
+ */
+declare class RdxDialogClose {
+    protected readonly rootContext: _radix_ng_primitives_dialog.RdxDialogRootContext;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxDialogClose, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxDialogClose, "button[rdxDialogClose]", ["rdxDialogClose"], {}, {}, never, never, true, never>;
+}
+
+declare const dialogImports: (typeof RdxDialogPortalPresence)[];
+declare class RdxDialogModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxDialogModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<RdxDialogModule, never, [typeof RdxDialogRoot, typeof RdxDialogTrigger, typeof RdxDialogPortalPresence, typeof RdxDialogPortal, typeof RdxDialogBackdrop, typeof RdxDialogViewport, typeof RdxDialogPopup, typeof RdxDialogTitle, typeof RdxDialogDescription, typeof RdxDialogClose], [typeof RdxDialogRoot, typeof RdxDialogTrigger, typeof RdxDialogPortalPresence, typeof RdxDialogPortal, typeof RdxDialogBackdrop, typeof RdxDialogViewport, typeof RdxDialogPopup, typeof RdxDialogTitle, typeof RdxDialogDescription, typeof RdxDialogClose]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<RdxDialogModule>;
+}
+
+export { RDX_DIALOG_VARIANT, RdxDialogBackdrop, RdxDialogClose, RdxDialogDescription, RdxDialogHandle, RdxDialogModule, RdxDialogPopup, RdxDialogPortal, RdxDialogPortalPresence, RdxDialogRoot, RdxDialogTitle, RdxDialogTrigger, RdxDialogViewport, createRdxDialogHandle, dialogImports, injectRdxDialogRootContext, provideRdxDialogRootContext, provideRdxDialogVariant };
+export type { RdxDialogModal, RdxDialogOpenChange, RdxDialogOpenChangeReason, RdxDialogRole, RdxDialogRootContext, RdxDialogVariant };

package/{dismissable-layer/index.d.ts → types/radix-ng-primitives-dismissable-layer.d.ts}

@@ -1,6 +1,6 @@
 import * as _angular_core from '@angular/core';
-import { InjectionToken, Signal, Provider } from '@angular/core';
-import { BooleanInput } from '@angular/cdk/coercion';
+import { Signal, InjectionToken, Provider } from '@angular/core';
+import { BooleanInput } from '@radix-ng/primitives/core';
 
 /**
  * Listens for when focus happens outside a DOM subtree.
@@ -33,7 +33,7 @@ declare class RdxPointerDownOutside {
     readonly pointerDownOutside: _angular_core.OutputEmitterRef<PointerEvent>;
     private readonly isPointerInsideDOMTree;
     private readonly handleAndDispatchPointerDownOutsideEvent;
-    private handleClick;
+    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>;
@@ -42,7 +42,7 @@ declare class RdxEscapeKeyDown {
     private readonly elementRef;
     private readonly destroyRef;
     readonly escapeKeyDown: _angular_core.OutputEmitterRef<KeyboardEvent>;
-    private readonly afterNextRender;
+    constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxEscapeKeyDown, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxEscapeKeyDown, "[rdxEscapeKeyDown]", ["rdxEscapeKeyDown"], {}, { "escapeKeyDown": "escapeKeyDown"; }, never, never, true, never>;
 }
@@ -86,13 +86,21 @@ declare class RdxDismissableLayer {
      * 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[]>>;
+    readonly disableOutsidePointerEvents: _angular_core.InputSignalWithTransform<boolean | undefined, BooleanInput>;
+    readonly isOutsidePointerEventsDisabled: _angular_core.Signal<boolean>;
     protected readonly isBodyPointerEventsDisabled: _angular_core.Signal<boolean>;
     protected readonly isPointerEventsEnabled: _angular_core.Signal<boolean>;
     private readonly index;
-    private readonly afterNextRender;
+    /** The topmost layer in the stack — the only one that should react to the Escape key. */
+    private readonly isHighestLayer;
     constructor();
+    /**
+     * Toggles `pointer-events: none` on the document body while any layer has
+     * `disableOutsidePointerEvents`. Ownership is shared across all layers via
+     * {@link originalBodyPointerEvents}: the original value is saved only on the global
+     * `0 -> >0` transition and restored only when the count returns to `0`.
+     */
+    private setupBodyPointerEvents;
     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: {}; }]>;
 }