import * as _angular_core from '@angular/core';
import { InjectionToken, Signal, Provider } from '@angular/core';
import * as forty_cdk_popover from 'forty-cdk/popover';
import { VetoableNativeEvent, VetoableEvent } from 'forty-cdk/core';
import { AnchoredPositioningContext, AnchoredOverlayPositioningBase, AnchoredPositioningSeedDefaults, FloatingSide, FloatingAlign } from 'forty-cdk/core-overlay';

/**
 * Why a popover requested close. The popover is non-modal, so there is no
 * `'tab'` reason (Tab is allowed to leave the surface and surfaces as
 * `'focusOutside'`) and no selection reason. `'programmatic'` covers
 * `[forPopoverClose]` and the trigger toggle-close.
 */
type ForPopoverCloseReason = 'escape' | 'pointerDownOutside' | 'focusOutside' | 'programmatic';
/**
 * Coordination contract owned by `ForPopover`. Trigger / Content register
 * their elements (for floating-ui positioning, dismissible-layer exemptions,
 * and focus return). Title / Description register their generated ids so
 * the content wires `aria-labelledby` / `aria-describedby` reactively.
 *
 * The popover's "openness" lives on the root directive (`open` model) and
 * is published here so descendant pieces can react without each subscribing
 * to the directive instance directly.
 */
interface ForPopoverContext extends AnchoredPositioningContext {
    /**
     * Whether the popover is open, as a read-only signal. Mutate it through
     * `toggle` / `close` / `requestClose` or the root's `[(open)]` binding — a
     * direct write would bypass the root's `disabled` guard.
     */
    readonly open: Signal<boolean>;
    readonly disabled: Signal<boolean>;
    readonly dismissible: Signal<boolean>;
    readonly returnFocus: Signal<boolean>;
    readonly initialFocus: Signal<'first' | 'container'>;
    /**
     * Reason of the most recent close, or `null` while the popover is open / has
     * never closed. Reset to `null` on open. `[forPopoverContent]` reads it to
     * skip its trigger return-focus when the close came from an outside
     * interaction (`'pointerDownOutside'` / `'focusOutside'`) — leaving focus
     * where the user just clicked / focused instead of ripping it back to the
     * trigger (matching `[forDropdownMenu]`).
     */
    readonly lastCloseReason: Signal<ForPopoverCloseReason | null>;
    readonly triggerId: Signal<string>;
    readonly contentId: Signal<string>;
    readonly ariaLabel: Signal<string | null>;
    /** Whether `prefers-reduced-motion: reduce` is active — reflected as `data-reduced-motion`. */
    readonly reducedMotion: Signal<boolean>;
    readonly labelledBy: Signal<string | null>;
    readonly describedBy: Signal<string | null>;
    readonly trigger: Signal<HTMLElement | null>;
    readonly anchor: Signal<HTMLElement | null>;
    /**
     * Element used as the floating-ui reference. When `[forPopoverAnchor]`
     * is registered, this is the anchor; otherwise it falls back to the
     * trigger. Decoupled from `trigger` so the trigger can keep driving
     * `aria-controls`, click toggle, and focus return regardless of where
     * the popover paints.
     */
    readonly reference: Signal<HTMLElement | null>;
    registerTrigger(el: HTMLElement): void;
    unregisterTrigger(el: HTMLElement): void;
    /** Adopts a consumer-set static `id` on the content host into `contentId`. */
    adoptContentId(el: HTMLElement): void;
    registerAnchor(el: HTMLElement): void;
    unregisterAnchor(el: HTMLElement): void;
    registerArrow(el: HTMLElement): void;
    unregisterArrow(el: HTMLElement): void;
    registerLabel(id: string): void;
    unregisterLabel(id: string): void;
    registerDescription(id: string): void;
    unregisterDescription(id: string): void;
    /** Toggle from a trigger click. Honours `disabled`. */
    toggle(): void;
    /**
     * Close the popover. Honored regardless of `dismissible` — used by
     * `[forPopoverClose]` and available to custom close pieces. Prefer this over
     * writing `open` directly so the close routes through the root.
     */
    close(): void;
    /**
     * Escape is consumer-owned (its close differs per primitive); Content
     * forwards the raw `KeyboardEvent` so the root emits `(escapeKeyDown)` and
     * runs its own close decision.
     */
    emitEscapeKeyDown(event: KeyboardEvent): void;
    /**
     * Outside-interaction emit forwarders. The specific and composite channels
     * observe the same veto, so `preventDefault()` from either one suppresses the
     * close that otherwise follows.
     */
    emitPointerDownOutside(veto: VetoableNativeEvent<PointerEvent>): void;
    emitFocusOutside(veto: VetoableNativeEvent<FocusEvent>): void;
    emitInteractOutside(veto: VetoableNativeEvent<PointerEvent | FocusEvent>): void;
    /**
     * Implicit close requested by the shell after an un-vetoed outside
     * interaction. Records the channel's reason as `lastCloseReason` so the
     * content can skip its trigger return-focus, then closes.
     */
    requestClose(reason: 'pointerDownOutside' | 'focusOutside'): void;
    /**
     * Hooks into the auto-focus pipeline. Content fires these just before
     * its imperative `.focus()` (open) or the trigger return-focus (close);
     * `event.preventDefault()` skips the move. Returns `true` when the
     * consumer vetoed.
     */
    emitAutoFocusOnOpen(): boolean;
    emitAutoFocusOnClose(): boolean;
}
declare const FOR_POPOVER_CONTEXT: InjectionToken<ForPopoverContext>;

/**
 * Headless implementation of the [WAI-ARIA Modeless Dialog pattern](https://www.w3.org/WAI/ARIA/apg/patterns/dialog-modal/),
 * positioned against an internal trigger via `@floating-ui/dom`.
 *
 * Apply `[forPopover]` on a wrapper (the trigger and the content's `@if`
 * live inside it). The directive owns open state, ids, and the registries
 * that wire trigger / content / title / description / arrow together.
 *
 * Mount/unmount of the visible content is the consumer's responsibility —
 * wrap `[forPopoverContent]` with `@if (open())` and let `animate.enter` /
 * `animate.leave` handle transitions:
 *
 * ```html
 * <div forPopover [(open)]="isOpen">
 *   <button forPopoverTrigger>Open</button>
 *   @if (isOpen()) {
 *     <div forPopoverContent animate.leave="fade-out">…</div>
 *   }
 * </div>
 * ```
 *
 * Non-modal: focus is sent into the popover on open and returned to the
 * trigger on close, but Tab is allowed to leave the surface (use Dialog
 * if you need a focus trap).
 */
declare class ForPopover extends AnchoredOverlayPositioningBase implements ForPopoverContext {
    #private;
    protected readonly positioningDefaults: forty_cdk_popover.ForPopoverDefaults;
    /**
     * Two-way bindable. Whether the popover is currently shown. The `model()`
     * change emitter (`(openChange)`) fires only on internal transitions
     * (trigger click, Escape, outside dismissal), never on consumer writes
     * via `[(open)]` — observe state changes without binding back.
     */
    readonly open: _angular_core.ModelSignal<boolean>;
    /**
     * Padding (px) keeping `[forPopoverArrow]` that far from the edges of the
     * content. Only consulted when an arrow is registered, since floating-ui
     * installs the `arrow` middleware only then — which is why the input is
     * declared here rather than on the shared positioning base. The default is
     * read from `provideForPopoverDefaults` for the surrounding scope, since arrow
     * geometry is a design-system-wide decision rather than a per-popover one.
     */
    readonly arrowPadding: _angular_core.InputSignalWithTransform<number, unknown>;
    /**
     * When true, trigger interaction is ignored and any open popover stays
     * open until the consumer flips `open` themselves. Disable on the trigger
     * side; the content side keeps its dismissible behavior unaffected.
     */
    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * When true (default), Escape, pointer-down outside, and focus outside
     * close the popover. Disable for confirm flows that must be answered
     * via `[forPopoverClose]` (or by setting `open` programmatically).
     */
    readonly dismissible: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /** When true (default), focus returns to the trigger on close. */
    readonly returnFocus: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * Where to send focus when content mounts. `'first'` (default) finds
     * the first focusable descendant; `'container'` focuses the content
     * box itself (useful when there's nothing focusable inside).
     */
    readonly initialFocus: _angular_core.InputSignal<"first" | "container">;
    /** Manual `aria-label` on the content. Use this when no visible title element exists. */
    readonly ariaLabel: _angular_core.InputSignal<string | null>;
    /**
     * Whether the user has requested reduced motion via the OS
     * `prefers-reduced-motion: reduce` media query. Reflected as the boolean
     * `data-reduced-motion` attribute on the root and content so consumers can
     * disable their own `animate.enter` / `animate.leave` and CSS transitions
     * without re-deriving the media query. The popover toggles open / closed
     * synchronously on trigger click, so it has no JS-coordinated timing to skip.
     */
    readonly reducedMotion: _angular_core.Signal<boolean>;
    /**
     * Fires when the user presses Escape while this popover is the topmost
     * dismissible layer. Call `preventDefault()` on the emitted veto to
     * suppress the automatic close. The native `KeyboardEvent` is
     * available on `.event`.
     */
    readonly escapeKeyDown: _angular_core.OutputEmitterRef<VetoableNativeEvent<KeyboardEvent>>;
    /**
     * Fires when a pointer goes down outside the popover (and outside the
     * trigger). Call `preventDefault()` on the veto to suppress the
     * automatic close. The native `PointerEvent` is on `.event`.
     */
    readonly pointerDownOutside: _angular_core.OutputEmitterRef<VetoableNativeEvent<PointerEvent>>;
    /**
     * Fires when focus moves outside the popover and trigger. Call
     * `preventDefault()` on the veto to suppress the automatic close.
     */
    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 automatic close.
     */
    readonly interactOutside: _angular_core.OutputEmitterRef<VetoableNativeEvent<PointerEvent | FocusEvent>>;
    /**
     * Fires just before the popover sends focus into itself on mount.
     * Call `preventDefault()` on the veto to skip the imperative focus
     * move — useful when opening a popover from an input you want to
     * keep focused.
     */
    readonly autoFocusOnOpen: _angular_core.OutputEmitterRef<VetoableEvent>;
    /**
     * Fires just before focus returns to the trigger on unmount. Call
     * `preventDefault()` on the veto to suppress the return-focus.
     */
    readonly autoFocusOnClose: _angular_core.OutputEmitterRef<VetoableEvent>;
    readonly triggerId: _angular_core.WritableSignal<string>;
    readonly contentId: _angular_core.WritableSignal<string>;
    readonly trigger: _angular_core.Signal<HTMLElement | null>;
    readonly anchor: _angular_core.Signal<HTMLElement | null>;
    /**
     * The element floating-ui anchors against. Prefers `[forPopoverAnchor]`
     * when registered, otherwise falls back to the trigger so existing
     * popovers without an anchor keep their behavior.
     */
    readonly reference: _angular_core.Signal<HTMLElement | null>;
    readonly arrow: _angular_core.Signal<HTMLElement | null>;
    readonly labelledBy: _angular_core.Signal<string | null>;
    readonly describedBy: _angular_core.Signal<string | null>;
    /**
     * Reason of the most recent close, or `null` while open / before any close.
     * Reset on open, set on every close path — the content reads it to skip its
     * trigger return-focus on an outside-interaction close.
     */
    readonly lastCloseReason: _angular_core.Signal<ForPopoverCloseReason | null>;
    registerTrigger(el: HTMLElement): void;
    unregisterTrigger(el: HTMLElement): void;
    /**
     * Adopts a consumer-set static `id` on the `[forPopoverContent]` host into
     * `contentId` (preserving anchors / external `aria-labelledby` references)
     * instead of letting the `[id]` host binding clobber it.
     */
    adoptContentId(el: HTMLElement): void;
    registerAnchor(el: HTMLElement): void;
    unregisterAnchor(el: HTMLElement): void;
    registerArrow(el: HTMLElement): void;
    unregisterArrow(el: HTMLElement): void;
    registerLabel(id: string): void;
    unregisterLabel(id: string): void;
    registerDescription(id: string): void;
    unregisterDescription(id: string): void;
    toggle(): void;
    /**
     * Close the popover. Honored regardless of `dismissible` — an explicit close
     * is always applied. Used by `[forPopoverClose]`.
     */
    close(): void;
    emitEscapeKeyDown(event: KeyboardEvent): void;
    /**
     * Outside-interaction emit forwarders. The specific and composite channels
     * observe the same veto, so `preventDefault()` from either one suppresses the
     * close that otherwise follows.
     */
    emitPointerDownOutside(veto: VetoableNativeEvent<PointerEvent>): void;
    emitFocusOutside(veto: VetoableNativeEvent<FocusEvent>): void;
    emitInteractOutside(veto: VetoableNativeEvent<PointerEvent | FocusEvent>): void;
    /**
     * Implicit close requested by the shell after an un-vetoed outside
     * interaction. Records the channel's reason so the content skips its trigger
     * return-focus, then closes.
     */
    requestClose(reason: 'pointerDownOutside' | 'focusOutside'): void;
    emitAutoFocusOnOpen(): boolean;
    emitAutoFocusOnClose(): boolean;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForPopover, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForPopover, "[forPopover]", ["forPopover"], { "open": { "alias": "open"; "required": false; "isSignal": true; }; "arrowPadding": { "alias": "arrowPadding"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "dismissible": { "alias": "dismissible"; "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; }; }, { "open": "openChange"; "escapeKeyDown": "escapeKeyDown"; "pointerDownOutside": "pointerDownOutside"; "focusOutside": "focusOutside"; "interactOutside": "interactOutside"; "autoFocusOnOpen": "autoFocusOnOpen"; "autoFocusOnClose": "autoFocusOnClose"; }, never, never, true, never>;
}

/**
 * Button that toggles the popover when clicked. Apply on a focusable
 * element — preferably a `<button>` — so keyboard users can reach it.
 *
 * Wires `aria-expanded`, `aria-controls`, and `aria-haspopup="dialog"`,
 * registers the host as the floating-ui anchor, and toggles the open
 * state on click. The trigger is exempt from the dismissible layer's
 * outside-pointer / outside-focus checks so its own click never
 * spuriously closes the popover.
 *
 * Disabling: the trigger merges its own `disabled` input OR the root's
 * `disabled` into `effectiveDisabled`, which drives the native `disabled`
 * attribute, `data-disabled`, and the click guard. The native attribute is the
 * single reflection channel — no `aria-disabled` is emitted, because on a real
 * single-purpose `<button>` trigger the native attribute already conveys the
 * state to assistive technology.
 *
 * The root is normally resolved via DI from the enclosing `[forPopover]`.
 * When the trigger is declared inside an `ng-template` stamped into the root
 * (e.g. via `ngTemplateOutlet`), DI resolves at the template's declaration
 * site and misses the root — pass it explicitly through the selector input,
 * `routerLink`-style: `[forPopoverTrigger]="root"` with `#root="forPopover"`.
 */
declare class ForPopoverTrigger {
    #private;
    protected readonly buttonType: _angular_core.Signal<string | null>;
    /**
     * Optional explicit reference to the `[forPopover]` root, named after the
     * selector `routerLink`-style. The bare valueless attribute keeps resolving
     * the enclosing root via DI; pass the root explicitly
     * (`[forPopoverTrigger]="root"`, with `#root="forPopover"`) when the trigger
     * is declared in an `ng-template` stamped inside the root — DI resolves at
     * the template's declaration site, so the enclosing root is invisible there.
     * The empty string (what the valueless attribute yields) is treated as unset.
     */
    readonly forPopoverTrigger: _angular_core.InputSignal<"" | ForPopoverContext>;
    protected readonly ctx: _angular_core.Signal<ForPopoverContext>;
    /** 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<ForPopoverTrigger, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForPopoverTrigger, "[forPopoverTrigger]", ["forPopoverTrigger"], { "forPopoverTrigger": { "alias": "forPopoverTrigger"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Optional positioning anchor. When present, the popover is positioned
 * against this element instead of `[forPopoverTrigger]` — useful when
 * "what opens it" and "where it appears" are different elements (a button
 * opens the popover but it's anchored to a row, a text-selection range,
 * a cursor follower, etc.).
 *
 * Only positioning changes: the trigger still owns `aria-controls`,
 * `aria-expanded`, the click toggle, and focus return on close. If no
 * anchor is registered the popover falls back to anchoring against the
 * trigger, so existing usages are unaffected.
 *
 * ```html
 * <div forPopover [(open)]="open">
 *   <button forPopoverTrigger>Help</button>
 *   <span [forPopoverAnchor]>Anchored phrase</span>
 *   @if (open()) {
 *     <div forPopoverContent>…</div>
 *   }
 * </div>
 * ```
 */
declare class ForPopoverAnchor {
    #private;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForPopoverAnchor, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForPopoverAnchor, "[forPopoverAnchor]", ["forPopoverAnchor"], {}, {}, never, never, true, never>;
}

/**
 * The popover surface. Carries `role="dialog"` (non-modal — `aria-modal` is absent per APG), is
 * portaled to `document.body`, and is positioned by `@floating-ui/dom`
 * against the registered `[forPopoverTrigger]`.
 *
 * The directive does not manage DOM presence — wrap with
 * `@if (popoverOpen())` so `animate.enter` / `animate.leave` fire on
 * the natural mount / unmount cycle. While mounted the directive
 * dismisses on Escape, pointer-down outside or focus outside, and sends
 * focus to the configured `initialFocus` target; on unmount it returns
 * focus to the trigger if `returnFocus` is on.
 *
 * The trigger is exempt from the outside checks, so clicking
 * it again just toggles via the trigger directive — no double-close
 * race.
 *
 */
declare class ForPopoverContent {
    protected readonly ctx: forty_cdk_popover.ForPopoverContext;
    protected readonly resolvedAriaLabel: _angular_core.Signal<string | null>;
    protected readonly labelledBy: _angular_core.Signal<string | null>;
    protected readonly describedBy: _angular_core.Signal<string | null>;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForPopoverContent, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForPopoverContent, "[forPopoverContent]", ["forPopoverContent"], {}, {}, never, never, true, never>;
}

/**
 * Convenience: gives the host element a stable id and registers it as the
 * popover's accessible name (`aria-labelledby`). Apply on a heading element
 * (`<h2>`, `<h3>`...) inside `[forPopoverContent]`.
 *
 * If you don't render a visible title, omit this and pass `ariaLabel` on
 * the popover root instead.
 */
declare class ForPopoverTitle {
    protected readonly id: string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForPopoverTitle, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForPopoverTitle, "[forPopoverTitle]", ["forPopoverTitle"], {}, {}, never, never, true, never>;
}

/**
 * Convenience: gives the host element a stable id and registers it as the
 * popover's accessible description (`aria-describedby`). Apply on a paragraph
 * or similar text element inside `[forPopoverContent]`.
 */
declare class ForPopoverDescription {
    protected readonly id: string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForPopoverDescription, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForPopoverDescription, "[forPopoverDescription]", ["forPopoverDescription"], {}, {}, never, never, true, never>;
}

/**
 * Button that closes the surrounding popover when clicked. Apply on a
 * `<button>` inside `[forPopoverContent]`. Bypasses `dismissible` — an
 * explicit close button is always honored.
 */
declare class ForPopoverClose {
    #private;
    protected readonly buttonType: _angular_core.Signal<string | null>;
    protected onClick(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForPopoverClose, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForPopoverClose, "[forPopoverClose]", ["forPopoverClose"], {}, {}, never, never, true, never>;
}

/**
 * Optional visual arrow inside `ForPopoverContent`. Registers itself with
 * the popover context so floating-ui's `arrow` middleware can position it
 * along the surface edge that points at the trigger. Style size and color
 * yourself — the directive only sets `position`, `left`/`top`, and the
 * opposite-side offset.
 */
declare class ForPopoverArrow {
    #private;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForPopoverArrow, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForPopoverArrow, "[forPopoverArrow]", ["forPopoverArrow"], {}, {}, never, never, true, never>;
}

/**
 * Defaults inherited by descendant popovers in the surrounding injector
 * scope. Configure with `provideForPopoverDefaults` at the app root or in
 * any component's `providers`; partial overrides merge with the parent scope.
 */
interface ForPopoverDefaults extends AnchoredPositioningSeedDefaults {
    /**
     * Side the popover is anchored to for popovers that don't override `side`
     * locally. Library fallback `'bottom'`.
     */
    side: FloatingSide;
    /**
     * Alignment along the chosen `side` for popovers that don't override
     * `align` locally. Library fallback `'center'`.
     */
    align: FloatingAlign;
    /**
     * Gap (px) between trigger and content along the main axis for popovers
     * that don't override `sideOffset` locally.
     * Library fallback `8`.
     */
    sideOffset: number;
    /**
     * Padding (px) applied uniformly to the `flip`, `shift`, and `size`
     * middlewares for popovers that don't override `collisionPadding` locally.
     * Library fallback `8`.
     */
    collisionPadding: number;
    /**
     * Padding (px) keeping the `[forPopoverArrow]` element that far from the
     * edges of the content, for popovers that don't override `arrowPadding`
     * locally. Only consulted when an arrow is registered — floating-ui installs
     * the `arrow` middleware only then. Library fallback `0`.
     */
    arrowPadding: number;
}
/** Token holding the resolved popover defaults for the current scope. */
declare const FOR_POPOVER_DEFAULTS: _angular_core.InjectionToken<ForPopoverDefaults>;
/**
 * Configures forty-cdk popover defaults for this injector scope. Partial
 * overrides inherit unspecified keys from the parent scope (or library
 * defaults at the root).
 */
declare function provideForPopoverDefaults(defaults?: Partial<ForPopoverDefaults>): Provider[];

export { FOR_POPOVER_CONTEXT, FOR_POPOVER_DEFAULTS, ForPopover, ForPopoverAnchor, ForPopoverArrow, ForPopoverClose, ForPopoverContent, ForPopoverDescription, ForPopoverTitle, ForPopoverTrigger, provideForPopoverDefaults };
export type { ForPopoverCloseReason, ForPopoverContext, ForPopoverDefaults };