import * as i0 from '@angular/core';
import { InjectionToken, Signal, Type, Injector, Provider } from '@angular/core';
import { ModalSurfaceBase, OverlayRef, OverlayManagerEntry, OverlayManagerCore } from 'forty-cdk/core-overlay';
import * as forty_cdk_dialog from 'forty-cdk/dialog';
import { VetoableEvent, VetoableNativeEvent } from 'forty-cdk/core';

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;
    /**
     * Register the backdrop element so the dismissible layer treats it as
     * part of the dialog surface (`exemptElements`) — without this, a
     * `pointerdown` on the portaled backdrop (a body sibling of the dialog
     * host, outside `host.contains()`) fires `pointerDownOutside` and closes
     * with reason `'pointerDownOutside'`, then the backdrop's own `click`
     * emits a second `(dismiss)` with reason `'backdrop'` — a double dismiss
     * with the wrong first reason, and a veto on either channel fails to stop
     * the other. Exempting the backdrop routes the interaction solely through
     * the backdrop's `click` → `requestClose('backdrop')`. Pass `null` to
     * unregister.
     */
    registerBackdrop(el: HTMLElement | null): 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 extends ModalSurfaceBase<ForDialogCloseReason> 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: i0.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: i0.InputSignalWithTransform<boolean, unknown>;
    /** When true (default), focus returns to the previously focused element on close. */
    readonly returnFocus: i0.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: i0.InputSignal<"first" | "container">;
    protected readonly entryPoint = "dialog";
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<ForDialog, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ForDialog, "[forDialog]", ["forDialog"], { "dismissible": { "alias": "dismissible"; "required": false; "isSignal": true; }; "modal": { "alias": "modal"; "required": false; "isSignal": true; }; "returnFocus": { "alias": "returnFocus"; "required": false; "isSignal": true; }; "initialFocus": { "alias": "initialFocus"; "required": false; "isSignal": true; }; }, {}, 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;
    protected readonly buttonType: i0.Signal<string | null>;
    /**
     * 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: i0.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: i0.InputSignal<string | null>;
    /**
     * When true, click is ignored and the host reflects `data-disabled=""` plus
     * the native `disabled` attribute so the trigger is announced as disabled by
     * assistive tech and dropped from the tab order. The native attribute is the
     * single reflection channel — no `aria-disabled` is emitted, because on a
     * real single-purpose `<button>` trigger it already conveys the state.
     */
    readonly disabled: i0.InputSignalWithTransform<boolean, unknown>;
    constructor();
    protected onClick(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ForDialogTrigger, never>;
    static ɵdir: i0.ɵɵ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: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<ForDialogTitle, never>;
    static ɵdir: i0.ɵɵ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: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<ForDialogDescription, never>;
    static ɵdir: i0.ɵɵ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;
    protected readonly buttonType: i0.Signal<string | null>;
    /** Optional value passed to `ForDialogRef.close()` (programmatic mode). */
    readonly closeWith: i0.InputSignal<unknown>;
    protected onClick(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ForDialogClose, never>;
    static ɵdir: i0.ɵɵ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 {
    #private;
    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: i0.ɵɵFactoryDeclaration<ForDialogBackdrop, never>;
    static ɵdir: i0.ɵɵ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. `closed` resolves with
 * `{ reason, result }` — the `reason` is a `ForDialogCloseReason` telling
 * apart an imperative `close()` (`'programmatic'`) from Escape / backdrop /
 * outside / close-button dismissals.
 */
declare class ForDialogRef<R = unknown> extends OverlayRef<R, ForDialogCloseReason> {
}

/**
 * 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;
    readonly modal: boolean;
    readonly alert: boolean | undefined;
    readonly returnFocus: boolean;
    readonly returnFocusTarget: HTMLElement | null | undefined;
    readonly initialFocus: 'first' | 'container';
    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(reason: ForDialogCloseReason, 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;
    /**
     * Explicit element focus returns to on close. Omit it (the default) and the
     * manager resolves the true origin automatically — the trigger that opened
     * the modal chain, threaded across a close→open swap so a confirm dialog
     * replacing a form dialog restores focus to the original trigger rather than
     * dropping it to `<body>`. Pass an element to override that
     * resolution, or `null` to opt out entirely and fall back to the element the
     * dialog captures at construction.
     */
    returnFocusTarget?: HTMLElement | null;
    /** 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[];
    /**
     * Caller scope for this `open()`. When supplied, `ForDialogManager` resolves
     * `provideForDialogDefaults` from this injector (instead of the root injector
     * it was constructed in) and parents the opened component on it — so a scoped
     * defaults configuration and any other scoped providers (a lazy route, a
     * component `providers`) reach the programmatic dialog. Per-`open()` config
     * values still win over the resolved scoped defaults. Omit it to keep today's
     * root-scope behavior. Pass the ambient `inject(Injector)` from the caller —
     * `open()` is normally invoked outside an injection context, so an explicit
     * handle is the predictable contract.
     */
    injector?: Injector;
    /**
     * 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
     * dismissible 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. `animate.leave` on the opened component runs 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.
 *
 * **When the overlay DOM is available.** In the common case the dialog mounts
 * synchronously, so a `document.querySelector('[role="dialog"]')` right after
 * `open()` finds it. When `open()` is called from within change detection — an
 * `effect`, `ngOnInit`, or an `afterNextRender` callback — the synchronous
 * mount is deferred to the next render (a nested change-detection tick is
 * illegal), so query the DOM after the next render. The returned
 * `ForDialogRef` is usable immediately in both cases.
 */
declare class ForDialogManager extends OverlayManagerCore<ForDialogEntry> {
    #private;
    constructor();
    open<C, R = unknown, D = unknown>(component: Type<C>, config?: ForDialogOpenConfig<D>): ForDialogRef<R>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ForDialogManager, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ForDialogManager>;
}

/**
 * Defaults inherited by dialogs in the surrounding injector scope. Configure
 * with `provideForDialogDefaults`. Keys map 1:1 to the `[forDialog]` inputs of
 * the same name; the resolver picks `consumerInput ?? defaults[key] ?? hardcoded
 * fallback` per key.
 *
 * **Scope caveat (declarative vs. programmatic).** Declarative `[forDialog]`
 * instances read this token from their own injector, so a scoped
 * `provideForDialogDefaults` (a lazy route, a component `providers`) reaches
 * every dialog rendered under that scope. `ForDialogManager` is
 * `providedIn: 'root'` and resolves the token **once, from the root injector**,
 * so by default only application-root `provideForDialogDefaults` affects
 * `ForDialogManager.open()` — a scoped override does not. To honor a caller's
 * scope, pass its injector on the `open()` config
 * (`open(Cmp, { injector: inject(Injector) })`): the manager then resolves
 * these defaults from that injector. Either way, a per-`open()` config value
 * always wins. This asymmetry is shared with `ForDrawerDefaults`.
 */
interface ForDialogDefaults {
    /** Default `true`. Sets `aria-modal`, locks body scroll, traps focus. */
    modal?: boolean;
    /** Default `true`. Whether Escape / backdrop / outside close the dialog. */
    dismissible?: boolean;
    /** Default `true`. Restore focus to the previously focused element on close. */
    returnFocus?: boolean;
    /** Default `'first'`. Where to send focus on mount. */
    initialFocus?: 'first' | 'container';
    /**
     * 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: i0.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).
 *
 * Declarative `[forDialog]` reads the nearest scope; `ForDialogManager.open()`
 * (root-provided) only sees an application-root configuration unless the caller
 * passes its `injector` on the `open()` config — see the scope caveat on
 * {@link ForDialogDefaults}.
 */
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 };