forty-cdk 0.2.0 → 0.3.0

package/types/forty-cdk-dialog.d.ts

@@ -0,0 +1,546 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, Signal, Type, Injector, Provider } from '@angular/core';
+import { VetoableNativeEvent, VetoableEvent, OverlayRef, OverlayManagerEntry, OverlayManagerCore } from 'forty-cdk/core';
+import * as forty_cdk_dialog from 'forty-cdk/dialog';
+
+type ForDialogCloseReason = 'escape' | 'backdrop' | 'pointerDownOutside' | 'focusOutside' | 'closeButton' | 'programmatic';
+/**
+ * Coordination contract owned by `ForDialog` (declarative) or by the
+ * programmatic `ForDialogManager.open()` machinery. Title / Description register
+ * their generated ids so the dialog wires `aria-labelledby` /
+ * `aria-describedby` reactively. Close button and backdrop request close
+ * via `requestClose` — the implementation decides whether to honor the
+ * request based on `dismissible` and on programmatic semantics.
+ *
+ * The dialog's "openness" isn't part of this contract: the directive is
+ * mounted iff the dialog is open, so descendants don't need an open
+ * signal to coordinate.
+ */
+interface ForDialogContext {
+    readonly dismissible: Signal<boolean>;
+    readonly modal: Signal<boolean>;
+    readonly alert: Signal<boolean>;
+    readonly labelledBy: Signal<string | null>;
+    readonly describedBy: Signal<string | null>;
+    /**
+     * Portal target shared with the backdrop so both resolve the same
+     * container. `null` ⇒ `document.body`. Set via the dialog's `container`
+     * input; read once per mount.
+     */
+    readonly container: Signal<HTMLElement | null>;
+    registerLabel(id: string): void;
+    unregisterLabel(id: string): void;
+    registerDescription(id: string): void;
+    unregisterDescription(id: string): void;
+    /**
+     * Request that the dialog close. Reasons:
+     * - `'escape'` / `'backdrop'` / `'pointerDownOutside'` / `'focusOutside'`:
+     *   honored only when `dismissible()` is true.
+     * - `'closeButton'`: always honored.
+     * - `'programmatic'`: always honored, used by `ForDialogManager.open()` consumers
+     *   that drive close imperatively from a child component.
+     *
+     * `value` is the close result, propagated to `ForDialogRef.close(value)`
+     * in programmatic mode. Ignored in declarative mode.
+     */
+    requestClose(reason: ForDialogCloseReason, value?: unknown): void;
+}
+declare const FOR_DIALOG_CONTEXT: InjectionToken<ForDialogContext>;
+
+/**
+ * Headless implementation of the [WAI-ARIA Modal Dialog pattern](https://www.w3.org/WAI/ARIA/apg/patterns/dialog-modal/).
+ *
+ * Apply `[forDialog]` on the dialog box itself — not on a wrapper. The
+ * directive moves the host to `document.body` (portal), traps focus, locks
+ * body scroll, and listens for Escape while mounted. `aria-labelledby`
+ * and `aria-describedby` wire automatically via `[forDialogTitle]` /
+ * `[forDialogDescription]`; pass `ariaLabel` instead if you don't render
+ * a visible title.
+ *
+ * Mount/unmount is the consumer's responsibility — the directive does
+ * not manage `[hidden]`. Wrap with `@if (open())` and let
+ * `animate.enter` / `animate.leave` handle transitions:
+ *
+ * ```html
+ * @if (dialogOpen()) {
+ *   <div forDialog (dismiss)="dialogOpen.set(false)" animate.leave="fade-out">
+ *     <h2 forDialogTitle>Confirm</h2>
+ *     <button forDialogClose>Cancel</button>
+ *   </div>
+ * }
+ * ```
+ *
+ * For programmatic use (open arbitrary components imperatively), see
+ * `ForDialogManager.open()`.
+ *
+ * `data-state` is a static `"open"`: because mount is the consumer's
+ * responsibility (the host only exists inside `@if (open())`), the element is
+ * present iff the dialog is open, so the attribute can never be `"closed"`.
+ * This is a deliberate choice: rather than keeping the node mounted and
+ * flipping `data-state="closed"` to drive an exit transition, exit styling
+ * is the consumer's `animate.leave` (see the usage example above), not a
+ * `data-state="closed"` selector — so a `[data-state="closed"]` rule would
+ * never match and is not a bug.
+ */
+declare class ForDialog implements ForDialogContext {
+    #private;
+    /**
+     * When true (default), Escape, backdrop click, pointer-down outside, and
+     * focus outside emit `(dismiss)`. Disable for critical confirm flows that
+     * must be answered explicitly via `[forDialogClose]`.
+     */
+    readonly dismissible: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * When true (default), sets `aria-modal="true"`, locks body scroll, and
+     * traps focus. Set to `false` for non-modal popups (rare for dialogs).
+     */
+    readonly modal: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** When true, role becomes `alertdialog` (interrupts assistive tech). */
+    readonly alert: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** When true (default), focus returns to the previously focused element on close. */
+    readonly returnFocus: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Where to send focus on mount. `'first'` (default) finds the first
+     * focusable descendant; `'container'` focuses the dialog box itself
+     * (useful when there's nothing focusable inside).
+     */
+    readonly initialFocus: _angular_core.InputSignal<"first" | "container">;
+    /** Manual `aria-label`. Use this when no visible title element exists. */
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
+    /**
+     * Portal target for the dialog surface. Defaults to `document.body`. Pair
+     * with `[modal]="false"` for a dialog scoped to a positioned region
+     * instead of the viewport. Read once at mount. The backdrop portals to the
+     * same container.
+     */
+    readonly container: _angular_core.InputSignal<HTMLElement | null>;
+    /**
+     * Emitted when the dialog wants to close. Consumers wire this to flip
+     * the signal that gates the surrounding `@if`. Reasons: `'escape'`,
+     * `'backdrop'`, `'pointerDownOutside'`, `'focusOutside'`,
+     * `'closeButton'`, `'programmatic'`.
+     */
+    readonly dismiss: _angular_core.OutputEmitterRef<ForDialogCloseReason>;
+    /**
+     * Fires when the user presses Escape while this dialog is the topmost
+     * dismissable layer. Call `preventDefault()` on the emitted veto to
+     * suppress the subsequent `(dismiss)` emission (e.g. to ask for
+     * confirmation first). The original `KeyboardEvent` is available on
+     * `.event` for inspection.
+     */
+    readonly escapeKeyDown: _angular_core.OutputEmitterRef<VetoableNativeEvent<KeyboardEvent>>;
+    /**
+     * Fires when a pointer goes down outside the dialog. Call
+     * `preventDefault()` on the emitted veto to suppress the auto `(dismiss)`.
+     * The native `PointerEvent` is available on `.event`.
+     */
+    readonly pointerDownOutside: _angular_core.OutputEmitterRef<VetoableNativeEvent<PointerEvent>>;
+    /**
+     * Fires when focus moves outside the dialog (e.g. user tabs out of a
+     * non-modal dialog). `preventDefault()` on the veto suppresses the auto
+     * `(dismiss)`. The native `FocusEvent` is available on `.event`.
+     */
+    readonly focusOutside: _angular_core.OutputEmitterRef<VetoableNativeEvent<FocusEvent>>;
+    /**
+     * Composite event: fires alongside `pointerDownOutside` and
+     * `focusOutside` and shares their veto state — `preventDefault()` on
+     * either one suppresses the auto `(dismiss)`.
+     */
+    readonly interactOutside: _angular_core.OutputEmitterRef<VetoableNativeEvent<PointerEvent | FocusEvent>>;
+    /**
+     * Callback invoked just before the dialog moves focus into itself on
+     * mount. Receives a `VetoableEvent`; call `event.preventDefault()` to
+     * skip the imperative focus move — useful when opening a dialog from
+     * an input you want to keep focused. The focus trap (modal mode) still
+     * cycles Tab inside the dialog once focus enters it.
+     *
+     * Bound as a function reference (`[autoFocusOnOpen]="onOpen"`), not as
+     * an event binding. Symmetric with `ForDialogManager`'s
+     * `config.autoFocusOnOpen`. The callback shape (rather than an
+     * `output()`) lets the directive invoke it during the destroy hook
+     * without depending on Angular's `OutputEmitterRef` lifecycle.
+     */
+    readonly autoFocusOnOpen: _angular_core.InputSignal<((event: VetoableEvent) => void) | undefined>;
+    /**
+     * Callback invoked just before focus returns to the previously
+     * focused element on unmount. Receives a `VetoableEvent`; call
+     * `event.preventDefault()` to skip the return-focus — useful when
+     * the consumer wants to send focus elsewhere imperatively (e.g. a
+     * confirmation toast).
+     *
+     * Bound as a function reference (`[autoFocusOnClose]="onClose"`), not
+     * as an event binding. Fires reliably on both close paths: the
+     * `(dismiss)` output flow AND a direct `open.set(false)` from the
+     * consumer. Symmetric with `ForDialogManager`'s
+     * `config.autoFocusOnClose`.
+     */
+    readonly autoFocusOnClose: _angular_core.InputSignal<((event: VetoableEvent) => void) | undefined>;
+    readonly labelledBy: _angular_core.Signal<string | null>;
+    readonly describedBy: _angular_core.Signal<string | null>;
+    constructor();
+    registerLabel(id: string): void;
+    unregisterLabel(id: string): void;
+    registerDescription(id: string): void;
+    unregisterDescription(id: string): void;
+    requestClose(reason: ForDialogCloseReason, value?: unknown): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForDialog, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForDialog, "[forDialog]", ["forDialog"], { "dismissible": { "alias": "dismissible"; "required": false; "isSignal": true; }; "modal": { "alias": "modal"; "required": false; "isSignal": true; }; "alert": { "alias": "alert"; "required": false; "isSignal": true; }; "returnFocus": { "alias": "returnFocus"; "required": false; "isSignal": true; }; "initialFocus": { "alias": "initialFocus"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "container": { "alias": "container"; "required": false; "isSignal": true; }; "autoFocusOnOpen": { "alias": "autoFocusOnOpen"; "required": false; "isSignal": true; }; "autoFocusOnClose": { "alias": "autoFocusOnClose"; "required": false; "isSignal": true; }; }, { "dismiss": "dismiss"; "escapeKeyDown": "escapeKeyDown"; "pointerDownOutside": "pointerDownOutside"; "focusOutside": "focusOutside"; "interactOutside": "interactOutside"; }, never, never, true, never>;
+}
+
+/**
+ * Button that toggles the dialog when clicked. Apply on a focusable element —
+ * preferably a `<button>` — so keyboard users can reach it.
+ *
+ * Wires `aria-haspopup="dialog"`, `aria-expanded`, `aria-controls`, and
+ * `data-state` on the host. Two-way bind `[(open)]` to the same signal that
+ * gates the surrounding `@if` around `[forDialog]`. Focus return on close is
+ * handled by `[forDialog]` automatically — its focus trap captures the
+ * previously-focused element on mount and restores it on destroy, which is
+ * the trigger when the user clicked it.
+ *
+ * ```html
+ * <button forDialogTrigger [(open)]="dialogOpen" controls="my-dialog">Open</button>
+ * @if (dialogOpen()) {
+ *   <div forDialog id="my-dialog" (dismiss)="dialogOpen.set(false)">…</div>
+ * }
+ * ```
+ */
+declare class ForDialogTrigger {
+    #private;
+    /**
+     * Two-way bindable. Bind to the same signal that gates the surrounding
+     * `@if` around `[forDialog]`. The `model()` change emitter (`(openChange)`)
+     * fires only on internal transitions (trigger click), never on consumer
+     * writes via `[(open)]`.
+     */
+    readonly open: _angular_core.ModelSignal<boolean>;
+    /**
+     * Id of the controlled dialog box. Mirrored to `aria-controls` while the
+     * dialog is open. The consumer is responsible for setting the same `id` on
+     * `[forDialog]`. Has no effect on focus or behavior — purely the
+     * accessibility relationship between trigger and box. Leaving it unset when
+     * the dialog opens drops `aria-controls` silently; a dev-mode warning fires
+     * so the missing linkage is visible during development.
+     */
+    readonly controls: _angular_core.InputSignal<string | null>;
+    /**
+     * When true, click is ignored and the host reflects `data-disabled=""`,
+     * `aria-disabled="true"`, and the native `disabled` attribute so the
+     * trigger is announced as disabled by assistive tech and dropped from
+     * the tab order.
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    constructor();
+    protected onClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForDialogTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForDialogTrigger, "[forDialogTrigger]", ["forDialogTrigger"], { "open": { "alias": "open"; "required": false; "isSignal": true; }; "controls": { "alias": "controls"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "open": "openChange"; }, never, never, true, never>;
+}
+
+/**
+ * Convenience: gives the host element a stable id and registers it as the
+ * dialog's accessible name (`aria-labelledby`). Apply on a heading element
+ * (`<h2>`, `<h3>`...) inside `[forDialog]`.
+ *
+ * If you don't render visible title text, omit this and pass `ariaLabel`
+ * on the dialog itself instead.
+ */
+declare class ForDialogTitle {
+    protected readonly id: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForDialogTitle, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForDialogTitle, "[forDialogTitle]", ["forDialogTitle"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Convenience: gives the host element a stable id and registers it as the
+ * dialog's accessible description (`aria-describedby`). Apply on a `<p>` or
+ * other element inside `[forDialog]`. Optional — only use when there's
+ * non-title supporting copy (the question of a confirm, the rationale of
+ * an alert).
+ */
+declare class ForDialogDescription {
+    protected readonly id: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForDialogDescription, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForDialogDescription, "[forDialogDescription]", ["forDialogDescription"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Button that closes the surrounding dialog when clicked. Apply on a
+ * `<button>` inside `[forDialog]`. Pass `[closeWith]` to propagate a return
+ * value to `ForDialogRef.close()` in programmatic usage; ignored in
+ * declarative usage.
+ */
+declare class ForDialogClose {
+    #private;
+    /** Optional value passed to `ForDialogRef.close()` (programmatic mode). */
+    readonly closeWith: _angular_core.InputSignal<unknown>;
+    protected onClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForDialogClose, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForDialogClose, "[forDialogClose]", ["forDialogClose"], { "closeWith": { "alias": "closeWith"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Optional backdrop overlay. Portaled to the dialog's `container` (the same
+ * target the surface uses) — `document.body` by default. While mounted the
+ * backdrop is visible; mount/unmount it alongside the dialog with the same
+ * `@if` so `animate.enter` / `animate.leave` works on both.
+ *
+ * The directive applies no visual styles — set `position: fixed; inset: 0;
+ * background: rgba(0,0,0,0.5)` (or whatever) yourself. For a backdrop inside a
+ * scoped `container`, use `position: absolute` so it is bounded to that box.
+ */
+declare class ForDialogBackdrop {
+    protected readonly ctx: forty_cdk_dialog.ForDialogContext;
+    /**
+     * Per-instance dialog id when opened through `ForDialogManager` (reflected
+     * as `data-for-dialog-id` so the manager can pair this portaled backdrop
+     * with its dialog and drive its exit animation). `null` in the declarative
+     * path, where the host binding emits no attribute.
+     */
+    protected readonly instanceId: string | null;
+    constructor();
+    protected onClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForDialogBackdrop, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForDialogBackdrop, "[forDialogBackdrop]", ["forDialogBackdrop"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Handle returned by `ForDialogManager.open()`. Inject inside the opened
+ * component to drive close imperatively. Both reactive (`isClosed`, `result`)
+ * and awaitable (`closed`) APIs are exposed — pick what fits the call site.
+ *
+ * `R` is the close-result type. Default `unknown`; specify it on
+ * `manager.open<C, R>(...)` to get type safety.
+ */
+declare class ForDialogRef<R = unknown> extends OverlayRef<R> {
+}
+
+/**
+ * Shape of a single open dialog entry stored in the manager.
+ *
+ * Internal — not re-exported from `public-api.ts`.
+ */
+interface ForDialogEntry extends OverlayManagerEntry {
+    readonly component: Type<unknown>;
+    readonly hostClass: string;
+    readonly dismissible: boolean | undefined;
+    readonly modal: boolean | undefined;
+    readonly alert: boolean | undefined;
+    readonly returnFocus: boolean | undefined;
+    readonly initialFocus: 'first' | 'container' | undefined;
+    readonly ariaLabel: string | undefined;
+    readonly container: HTMLElement | null | undefined;
+    readonly animateEnter: string | undefined;
+    readonly autoFocusOnOpen: ((e: VetoableEvent) => void) | undefined;
+    readonly autoFocusOnClose: ((e: VetoableEvent) => void) | undefined;
+    readonly escapeKeyDown: ((e: VetoableNativeEvent<KeyboardEvent>) => void) | undefined;
+    readonly pointerDownOutside: ((e: VetoableNativeEvent<PointerEvent>) => void) | undefined;
+    readonly focusOutside: ((e: VetoableNativeEvent<FocusEvent>) => void) | undefined;
+    readonly interactOutside: ((e: VetoableNativeEvent<PointerEvent | FocusEvent>) => void) | undefined;
+    handleClose(value: unknown): void;
+    injectorFor(parent: Injector): Injector;
+}
+
+/**
+ * Injection token for the `data` payload passed to `ForDialogManager.open(component, { data })`.
+ * The manager always provides this token, falling back to `null` when no `data`
+ * was configured, so inject it inside the opened component:
+ *
+ * ```ts
+ * readonly data = inject(FOR_DIALOG_DATA) as MyShape | null;
+ * ```
+ *
+ * Prefer `injectDialogData<T>()` for typed access without manual casts.
+ */
+declare const FOR_DIALOG_DATA: InjectionToken<unknown>;
+/**
+ * Typed accessor for the `data` payload. Returns `T | null` because the manager
+ * provides `null` when `open()` is called without `data` — guard for `null`
+ * before dereferencing the payload.
+ */
+declare function injectDialogData<T = unknown>(): T | null;
+interface ForDialogOpenConfig<D = unknown> {
+    /** Payload available inside the dialog component via `injectDialogData<T>()`. */
+    data?: D;
+    /** When true (default), Escape closes the dialog. */
+    dismissible?: boolean;
+    /** When true (default), set `aria-modal`, lock body scroll, trap focus. */
+    modal?: boolean;
+    /** When true, role becomes `alertdialog` instead of `dialog`. Default `false`. */
+    alert?: boolean;
+    /** When true (default), focus returns to the previously focused element on close. */
+    returnFocus?: boolean;
+    /** Where to send focus on open. Default `'first'`. */
+    initialFocus?: 'first' | 'container';
+    /** Manual `aria-label`. Use when no visible title element is rendered. */
+    ariaLabel?: string;
+    /**
+     * Portal target for the surface + backdrop. Defaults to `document.body`.
+     * Pair with `modal: false` for a dialog scoped to a positioned region
+     * instead of the viewport.
+     */
+    container?: HTMLElement | null;
+    /**
+     * CSS class applied (via `animate.enter`) to the overlay root the moment it
+     * mounts, so a programmatic dialog plays an enter animation just like a
+     * declarative `<div forDialog animate.enter="…">`. The class lands on the
+     * same `[forDialog]` host as {@link class}. Falls back to
+     * `provideForDialogDefaults({ animateEnter })`.
+     */
+    animateEnter?: string;
+    /**
+     * CSS class applied to the overlay root when `close()` is called. The
+     * manager keeps the host mounted with this class until its CSS animations /
+     * transitions finish, then tears the dialog down — so a programmatic dialog
+     * plays an exit animation. `close()` still resolves its promise and flips
+     * `isClosed()` immediately; only the visual teardown waits. With no class (or
+     * no animation, or under `prefers-reduced-motion`), close is immediate. Falls
+     * back to `provideForDialogDefaults({ animateLeave })`.
+     */
+    animateLeave?: string;
+    /**
+     * Exit-animation class for the portaled `[forDialogBackdrop]`: the manager
+     * adds it when `close()` is called and keeps the backdrop mounted until the
+     * animation finishes, so the backdrop fades out in lockstep with the host.
+     *
+     * The split with the enter animation is intentional, not an oversight.
+     * Declare the backdrop's **enter** with `animate.enter="…"` on the element
+     * itself — it fires on mount, which Angular runs normally even inside the
+     * manager's `ngComponentOutlet` — and declare only its **leave** here. A
+     * template `animate.leave` on the backdrop never fires under the manager:
+     * Angular does not run leave animations across the `ngComponentOutlet` the
+     * opened component is mounted through. (The host box is symmetric — both
+     * `animateEnter` and `animateLeave` are config, since the manager owns that
+     * element.) Falls back to `provideForDialogDefaults({ backdropAnimateLeave })`.
+     */
+    backdropAnimateLeave?: string;
+    /**
+     * Consumer CSS class(es) applied to the overlay root (the `[forDialog]`
+     * host). Pass a single class (`'my-dialog'`) or a space-separated string
+     * (`'my-dialog my-dialog--pop'`). Merged with the directive's own host
+     * attributes — it never clobbers `data-state` / `role` / `aria-modal`.
+     *
+     * Use this to carry design-system classes onto a programmatic dialog: the
+     * host is created class-less and the literal `[forDialog]` attribute is
+     * absent, so without this the consumer has no node to style. For multiple
+     * classes as an array, prefer {@link classList}.
+     */
+    class?: string;
+    /**
+     * Consumer CSS class(es) applied to the overlay root, as an array
+     * (`['my-dialog', 'my-dialog--pop']`) or a space-separated string. Merged
+     * with {@link class} and with the directive's own host attributes.
+     */
+    classList?: string | readonly string[];
+    /** Extra providers for the opened component's injector (alongside `FOR_DIALOG_DATA` + `ForDialogRef`). */
+    providers?: Provider[];
+    /**
+     * Fires just before the dialog moves focus into itself on mount.
+     * Call `event.preventDefault()` to skip the imperative focus move
+     * — useful when opening a dialog from an input you want to keep
+     * focused. The focus trap (modal mode) still cycles Tab once focus
+     * enters the dialog.
+     */
+    autoFocusOnOpen?: (event: VetoableEvent) => void;
+    /**
+     * Fires just before focus returns to the previously focused element
+     * on unmount. Call `event.preventDefault()` to skip the return-focus.
+     */
+    autoFocusOnClose?: (event: VetoableEvent) => void;
+    /**
+     * Per-channel dismiss hook mirroring the declarative `(escapeKeyDown)`
+     * output. Fires when Escape is pressed while this dialog is the topmost
+     * dismissable layer. Call `event.preventDefault()` on the veto to suppress
+     * the implicit close while keeping the other dismiss channels live — the
+     * programmatic equivalent of `(escapeKeyDown)="$event.preventDefault()"`.
+     * The original `KeyboardEvent` is on `.event`.
+     */
+    escapeKeyDown?: (event: VetoableNativeEvent<KeyboardEvent>) => void;
+    /**
+     * Per-channel dismiss hook mirroring the declarative `(pointerDownOutside)`
+     * output. Fires when a pointer goes down outside the dialog. Call
+     * `event.preventDefault()` on the veto to suppress the implicit close. The
+     * native `PointerEvent` is on `.event`.
+     */
+    pointerDownOutside?: (event: VetoableNativeEvent<PointerEvent>) => void;
+    /**
+     * Per-channel dismiss hook mirroring the declarative `(focusOutside)`
+     * output. Fires when focus moves outside the dialog. Call
+     * `event.preventDefault()` on the veto to suppress the implicit close. The
+     * native `FocusEvent` is on `.event`.
+     */
+    focusOutside?: (event: VetoableNativeEvent<FocusEvent>) => void;
+    /**
+     * Composite dismiss hook mirroring the declarative `(interactOutside)`
+     * output. Fires alongside `pointerDownOutside` / `focusOutside` and shares
+     * their veto state — `event.preventDefault()` on either suppresses the
+     * implicit close. Use this to keep a programmatic floater open on outside
+     * interaction while leaving Escape live (set `dismissible: true` and veto
+     * here). The native `PointerEvent | FocusEvent` is on `.event`.
+     */
+    interactOutside?: (event: VetoableNativeEvent<PointerEvent | FocusEvent>) => void;
+}
+/**
+ * Programmatic dialog opener — open a component as a modal dialog from
+ * TypeScript. Inject anywhere, call `open(MyComponent, { data, ... })` and get a
+ * `ForDialogRef<R>` back. Internally the manager renders the user component
+ * inside a manager-owned `@for` outlet, so Angular's control-flow unmount
+ * fires `animate.leave` before the node leaves the DOM — identical to the
+ * declarative `@if (open()) { <div forDialog animate.leave="…"> }` path.
+ *
+ * Inside the opened component the usual dialog pieces work without any extra
+ * wiring: `[forDialogTitle]`, `[forDialogDescription]`, `[forDialogBackdrop]`,
+ * `[forDialogClose]`. `[forDialogClose] [closeWith]` propagates through to
+ * `ForDialogRef.close(value)`.
+ *
+ * Inject `ForDialogRef` to drive close imperatively and `FOR_DIALOG_DATA` (or
+ * `injectDialogData<T>()`) for the payload.
+ */
+declare class ForDialogManager extends OverlayManagerCore<ForDialogEntry> {
+    #private;
+    constructor();
+    open<C, R = unknown, D = unknown>(component: Type<C>, config?: ForDialogOpenConfig<D>): ForDialogRef<R>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForDialogManager, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ForDialogManager>;
+}
+
+/**
+ * Defaults inherited by descendant dialogs in the surrounding injector
+ * scope. Configure with `provideForDialogDefaults`. Applies to both
+ * declarative dialogs and `ForDialogManager.open()`; the manager resolves
+ * `config[key] ?? defaults[key]` so a per-`open()` value always wins over the
+ * scope default.
+ */
+interface ForDialogDefaults {
+    /**
+     * CSS class applied (via `animate.enter`) to the programmatic overlay host
+     * when it mounts, so it plays an enter animation. The class lands on the
+     * `[forDialog]` host that also carries the consumer `class`. No default.
+     */
+    animateEnter?: string;
+    /**
+     * CSS class applied to the programmatic overlay host when `close()` is
+     * called, kept on the still-mounted host until its CSS animations finish so
+     * an exit transition plays before teardown. No default (close is immediate).
+     */
+    animateLeave?: string;
+    /**
+     * CSS class applied to the portaled `[forDialogBackdrop]` when `close()` is
+     * called, so the backdrop plays an exit animation in lockstep with the
+     * host. Needed because a backdrop declared inside the opened component plays
+     * its `animate.enter` on mount but cannot run its template `animate.leave` —
+     * Angular does not process leave animations across the `ngComponentOutlet`
+     * boundary the manager mounts the component through. No default.
+     */
+    backdropAnimateLeave?: string;
+}
+/** Token holding the resolved dialog defaults for the current scope. */
+declare const FOR_DIALOG_DEFAULTS: _angular_core.InjectionToken<ForDialogDefaults>;
+/**
+ * Configures forty-cdk dialog defaults for this injector scope. Partial
+ * overrides inherit unspecified keys from the parent scope (or library
+ * defaults at the root).
+ */
+declare function provideForDialogDefaults(defaults?: Partial<ForDialogDefaults>): Provider[];
+
+export { FOR_DIALOG_CONTEXT, FOR_DIALOG_DATA, FOR_DIALOG_DEFAULTS, ForDialog, ForDialogBackdrop, ForDialogClose, ForDialogDescription, ForDialogManager, ForDialogRef, ForDialogTitle, ForDialogTrigger, injectDialogData, provideForDialogDefaults };
+export type { ForDialogCloseReason, ForDialogContext, ForDialogDefaults, ForDialogOpenConfig };

package/types/forty-cdk-disclosure.d.ts

@@ -0,0 +1,127 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, Signal, Provider } from '@angular/core';
+import * as forty_cdk_disclosure from 'forty-cdk/disclosure';
+
+/**
+ * Shared state contract between the pieces of a Disclosure primitive.
+ * Provided by `ForDisclosure`, consumed by `ForDisclosureTrigger` and
+ * `ForDisclosureContent`.
+ */
+interface ForDisclosureContext {
+    readonly open: Signal<boolean>;
+    readonly disabled: Signal<boolean>;
+    readonly triggerId: Signal<string>;
+    readonly contentId: Signal<string>;
+    /** Adopts a consumer-set static `id` on the trigger host into `triggerId`. */
+    adoptTriggerId(el: HTMLElement): void;
+    /** Adopts a consumer-set static `id` on the content host into `contentId`. */
+    adoptContentId(el: HTMLElement): void;
+    toggle(): void;
+}
+declare const FOR_DISCLOSURE_CONTEXT: InjectionToken<ForDisclosureContext>;
+
+/**
+ * Root of the Disclosure primitive. Holds the open/disabled state and
+ * the IDs that wire the trigger to its content.
+ *
+ * Implements the [WAI-ARIA Disclosure pattern](https://www.w3.org/WAI/ARIA/apg/patterns/disclosure/).
+ *
+ * Compose it on any wrapper element with `[forDisclosureTrigger]` and
+ * `[forDisclosureContent]` as descendants.
+ *
+ * @example
+ * ```html
+ * <div forDisclosure [(open)]="isOpen">
+ *   <button type="button" forDisclosureTrigger>Toggle</button>
+ *   <div forDisclosureContent>...</div>
+ * </div>
+ * ```
+ */
+declare class ForDisclosure implements ForDisclosureContext {
+    #private;
+    /**
+     * Two-way bindable open state. Use `[(open)]` for both read & write, or
+     * `(openChange)` alone to observe transitions when the directive itself
+     * toggles state (trigger click). The `model()` change emitter does NOT fire
+     * for consumer-driven writes via `[(open)]`, so subscribing to
+     * `(openChange)` is safe and only sees internal transitions.
+     */
+    readonly open: _angular_core.ModelSignal<boolean>;
+    /** When true, click on the trigger is ignored and `data-disabled` is reflected. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly triggerId: _angular_core.Signal<string>;
+    readonly contentId: _angular_core.Signal<string>;
+    /**
+     * Adopts a consumer-set static `id` on the `[forDisclosureTrigger]` host into
+     * `triggerId` (preserving anchors / external `aria-labelledby` references /
+     * label `for`) instead of letting the `[id]` host binding clobber it.
+     */
+    adoptTriggerId(el: HTMLElement): void;
+    /** Adopts a consumer-set static `id` on the content host into `contentId`. */
+    adoptContentId(el: HTMLElement): void;
+    toggle(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForDisclosure, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForDisclosure, "[forDisclosure]", ["forDisclosure"], { "open": { "alias": "open"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "open": "openChange"; }, never, never, true, never>;
+}
+
+/**
+ * Trigger button for a `ForDisclosure`. Apply on a `<button>` so Enter/Space
+ * toggling come from native button behavior. The directive host-binds
+ * `type="button"` so a trigger inside a `<form>` never submits it on toggle.
+ *
+ * `aria-controls` is emitted only while open — mirroring the overlay triggers'
+ * open-only gating — so the reference never dangles at an unmounted panel
+ * under the recommended `@if (open())` mount pattern.
+ *
+ * Disabling: the trigger merges its own `disabled` input OR the root's
+ * `disabled` into `effectiveDisabled`, which drives the native `disabled`
+ * attribute, `aria-disabled`, `data-disabled`, and the click guard.
+ */
+declare class ForDisclosureTrigger {
+    protected readonly ctx: forty_cdk_disclosure.ForDisclosureContext;
+    /** Disables this trigger only, in addition to the root's `disabled`. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the trigger is disabled — its own `disabled` input OR the root's. */
+    readonly effectiveDisabled: _angular_core.Signal<boolean>;
+    constructor();
+    protected onClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForDisclosureTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForDisclosureTrigger, "[forDisclosureTrigger]", ["forDisclosureTrigger"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Disclosed content panel for a `ForDisclosure`. The directive does not
+ * manage DOM presence — wrap with `@if (open())` so the panel mounts and
+ * unmounts with the disclosure state, and use `animate.enter` /
+ * `animate.leave` for transitions if desired. If the consumer prefers to
+ * keep the panel mounted (for CSS-only transitions or to preserve internal
+ * state), the directive reflects `aria-hidden="true"` and `inert` while
+ * closed so the panel is removed from the accessibility tree and focus
+ * order automatically.
+ */
+declare class ForDisclosureContent {
+    protected readonly ctx: forty_cdk_disclosure.ForDisclosureContext;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForDisclosureContent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForDisclosureContent, "[forDisclosureContent]", ["forDisclosureContent"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Defaults inherited by descendant disclosures in the surrounding injector
+ * scope. Configure with `provideForDisclosureDefaults`. The shape is a stub
+ * today — present so future per-scope tuning can land without churning the
+ * public surface.
+ */
+interface ForDisclosureDefaults {
+}
+/** Token holding the resolved disclosure defaults for the current scope. */
+declare const FOR_DISCLOSURE_DEFAULTS: _angular_core.InjectionToken<ForDisclosureDefaults>;
+/**
+ * Configures forty-cdk disclosure defaults for this injector scope. Partial
+ * overrides inherit unspecified keys from the parent scope (or library
+ * defaults at the root).
+ */
+declare function provideForDisclosureDefaults(defaults?: Partial<ForDisclosureDefaults>): Provider[];
+
+export { FOR_DISCLOSURE_CONTEXT, FOR_DISCLOSURE_DEFAULTS, ForDisclosure, ForDisclosureContent, ForDisclosureTrigger, provideForDisclosureDefaults };
+export type { ForDisclosureContext, ForDisclosureDefaults };