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

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

@@ -1,206 +1,323 @@
-import * as i0 from '@angular/core';
-import { TemplateRef, EnvironmentProviders, Provider } from '@angular/core';
-import { AutoFocusTarget, DialogConfig, DialogRef } from '@angular/cdk/dialog';
-import { ComponentType } from '@angular/cdk/overlay';
-import { Observable } from 'rxjs';
+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';
 
-declare const ɵdialogData: unique symbol;
-declare const ɵdialogResult: unique symbol;
-type ɵDialogDataFlag = {
-    [ɵdialogData]: unknown;
-};
-type ɵDialogResultFlag<R> = {
-    [ɵdialogResult]: R;
-};
-type RdxDialogData<T> = {
-    [K in keyof T]: T[K] extends ɵDialogDataFlag ? Omit<T[K], typeof ɵdialogData> : never;
-}[keyof T];
-type DialogRefProps<C> = {
-    [K in keyof C]: C[K] extends ɵDialogResultFlag<unknown> ? K : never;
-}[keyof C] & keyof C;
-type RdxDialogResult<C> = DialogRefProps<C> extends never ? void : C[DialogRefProps<C>] extends ɵDialogResultFlag<infer T> ? T : void;
-type RdxDialogMode = 'default' | 'sheet' | 'sheet-bottom' | 'sheet-top' | 'sheet-left' | 'sheet-right';
-type RdxBaseDialogConfig<C> = {
-    content: ComponentType<C> | TemplateRef<C>;
-    data: RdxDialogData<C>;
-    modal?: boolean;
-    ariaLabel?: string;
-    autoFocus?: AutoFocusTarget | 'first-input' | string;
-    canClose?: (comp: C) => boolean | Observable<boolean>;
-    canCloseWithBackdrop?: boolean;
-    closeDelay?: number;
-    cdkConfigOverride?: Partial<DialogConfig<C>>;
-    mode?: RdxDialogMode;
-    backdropClass?: string | string[];
-    panelClasses?: string[];
-    isAlert?: boolean;
-};
-type RdxDialogConfig<T> = RdxDialogData<T> extends never ? Omit<RdxBaseDialogConfig<T>, 'data'> : RdxBaseDialogConfig<T> & {
-    data: Required<RdxDialogData<T>>;
-};
-type RdxDialogState = 'open' | 'closed';
-declare function getState(open: boolean): RdxDialogState;
+/**
+ * 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;
 /**
- * @group Components
+ * Groups all parts of the dialog.
  */
-declare class RdxDialogTriggerDirective {
-    private readonly dialogService;
+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;
     /**
-     * @group Props
+     * Whether the dialog is currently open.
      */
-    readonly id: i0.InputSignal<string>;
-    readonly dialogId: i0.Signal<string>;
+    readonly open: _angular_core.ModelSignal<boolean>;
     /**
-     * @group Props
+     * Whether the dialog is initially open.
      */
-    dialog: TemplateRef<void>;
+    readonly defaultOpen: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
     /**
-     * @group Props
+     * ID of the trigger associated with a controlled dialog.
      */
-    dialogConfig: RdxDialogConfig<unknown>;
-    readonly isOpen: i0.WritableSignal<boolean>;
-    readonly state: i0.Signal<RdxDialogState>;
-    private currentDialogRef;
-    protected onClick(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxDialogTriggerDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxDialogTriggerDirective, "[rdxDialogTrigger]", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "dialog": { "alias": "rdxDialogTrigger"; "required": true; }; "dialogConfig": { "alias": "rdxDialogConfig"; "required": false; }; }, {}, never, never, true, never>;
-}
-
-declare class RdxDialogContentDirective<C = unknown> {
-    private readonly dialogRef;
-    private readonly destroyRef;
-    private readonly isOpen;
-    readonly state: i0.Signal<_radix_ng_primitives_dialog.RdxDialogState>;
-    constructor();
+    readonly triggerId: _angular_core.ModelSignal<string | null>;
     /**
-     * Closes the dialog with a specified result.
-     *
-     * @param result The result to be passed back when closing the dialog
+     * ID of the trigger associated with an initially open uncontrolled dialog.
      */
-    close(result: RdxDialogResult<C>): void;
+    readonly defaultTriggerId: _angular_core.InputSignal<string | null>;
     /**
-     * Dismisses the dialog without a result.
+     * 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.
      */
-    dismiss(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxDialogContentDirective<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxDialogContentDirective<any>, "[rdxDialogContent]", never, {}, {}, never, never, true, never>;
-}
-
-declare class RdxDialogTitleDirective {
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxDialogTitleDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxDialogTitleDirective, "[rdxDialogTitle]", never, {}, {}, never, never, true, never>;
+    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>;
 }
 
-declare class RdxDialogCloseDirective {
-    private readonly ref;
-    protected onClick(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxDialogCloseDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxDialogCloseDirective, "[rdxDialogClose]", never, {}, {}, 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>;
 }
 
-declare class RdxDialogDescriptionDirective {
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxDialogDescriptionDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxDialogDescriptionDirective, "[rdxDialogDescription]", never, {}, {}, 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: {}; }]>;
 }
 
-declare class RdxDialogDismissDirective {
-    private readonly ref;
-    protected onClick(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxDialogDismissDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxDialogDismissDirective, "button[rdxDialogDismiss]", never, {}, {}, never, never, true, never>;
+/**
+ * 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>;
 }
 
-declare const DISMISSED_VALUE: {};
 /**
- * Represents a reference to an open dialog.
- * Provides methods and observables to interact with and monitor the dialog's state.
- * @template C - The type of the dialog's content component
+ * 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 RdxDialogRef<C = unknown> {
-    readonly cdkRef: DialogRef<RdxDialogResult<C> | typeof DISMISSED_VALUE, C>;
-    readonly config: RdxDialogConfig<C>;
-    private _previousTimeout;
-    private readonly _openSignal;
-    readonly state: i0.Signal<"open" | "closed">;
-    closed$: Observable<RdxDialogResult<C> | undefined>;
-    dismissed$: Observable<void>;
-    result$: Observable<RdxDialogResult<C>>;
-    /**
-     * @param cdkRef - Reference to the underlying CDK dialog
-     * @param config - Configuration options for the dialog
-     */
-    constructor(cdkRef: DialogRef<RdxDialogResult<C> | typeof DISMISSED_VALUE, C>, config: RdxDialogConfig<C>);
-    get instance(): C | null;
-    /**
-     * Attempts to dismiss the dialog
-     * Checks the canClose condition before dismissing
-     */
-    dismiss(): void;
-    close(result: RdxDialogResult<C>): void;
+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>;
 }
+
 /**
- * Represents a simplified interface for dialog interaction
- * Typically used by dialog content components
- * @template R - The type of the result when closing the dialog
+ * A container for the dialog contents.
  */
-type RdxDialogSelfRef<R> = {
-    dismiss(): void;
-    close(res: R): void;
-};
-
-declare function injectDialogData<TData>(): TData & ɵDialogDataFlag;
-declare function injectDialogRef<R = void>(): RdxDialogSelfRef<R> & ɵDialogResultFlag<R>;
+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: {}; }]>;
+}
 
 /**
- * Configures the RdxDialog module by providing necessary dependencies.
- *
- * This function sets up the environment providers required for the RdxDialog to function,
- * specifically importing the Angular CDK's DialogModule.
- *
- * @returns {EnvironmentProviders} An EnvironmentProviders instance containing the DialogModule.
+ * An accessible title for the dialog.
  */
-declare function provideRdxDialogConfig(): EnvironmentProviders;
+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>;
+}
+
 /**
- * Provides the RdxDialogService for dependency injection.
- *
- * This function is used to make the RdxDialogService available for injection
- * in components, directives, or other services that require dialog functionality.
- *
- * @returns {Provider} A provider for the RdxDialogService.
+ * An accessible description for the dialog.
  */
-declare function provideRdxDialog(): Provider;
+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>;
+}
 
 /**
- * Modality control: When `isModal` is set to `true`, the dialog will:
- *
- * - Have a backdrop that blocks interaction with the rest of the page
- * - Disable closing by clicking outside or pressing Escape
- * - Set `aria-modal="true"` for screen readers
- * - Automatically focus the first tabbable element in the dialog
- * - Restore focus to the element that opened the dialog when it's closed
- *
- *
- * When `isModal` is `false`, the dialog will:
- *
- * - Not have a backdrop, allowing interaction with the rest of the page
- * - Allow closing by clicking outside or pressing Escape
- * - Not set `aria-modal` attribute
- * - Not automatically manage focus
+ * A button that closes the dialog.
  */
-declare class RdxDialogService {
-    #private;
-    open<C>(config: RdxDialogConfig<C>): RdxDialogRef<C>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxDialogService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<RdxDialogService>;
+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: i0.ɵɵFactoryDeclaration<RdxDialogModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxDialogModule, never, [typeof RdxDialogTriggerDirective, typeof RdxDialogContentDirective, typeof RdxDialogTitleDirective, typeof RdxDialogCloseDirective, typeof RdxDialogDescriptionDirective, typeof RdxDialogDismissDirective], [typeof RdxDialogTriggerDirective, typeof RdxDialogContentDirective, typeof RdxDialogTitleDirective, typeof RdxDialogCloseDirective, typeof RdxDialogDescriptionDirective, typeof RdxDialogDismissDirective]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<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 { DISMISSED_VALUE, RdxDialogCloseDirective, RdxDialogContentDirective, RdxDialogDescriptionDirective, RdxDialogDismissDirective, RdxDialogModule, RdxDialogRef, RdxDialogService, RdxDialogTitleDirective, RdxDialogTriggerDirective, getState, injectDialogData, injectDialogRef, provideRdxDialog, provideRdxDialogConfig };
-export type { RdxDialogConfig, RdxDialogData, RdxDialogResult, RdxDialogSelfRef, RdxDialogState, ɵDialogDataFlag, ɵDialogResultFlag };
+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/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: {}; }]>;
 }