import * as _angular_core from '@angular/core';
import { TemplateRef, ElementRef, AfterContentChecked, AfterViewInit, AfterContentInit, OnDestroy, ViewContainerRef, OnInit, InjectionToken, ModelSignal, EventEmitter, Signal } from '@angular/core';
import { ConnectionPositionPair, ConnectedPosition, CdkOverlayOrigin, ScrollStrategy } from '@angular/cdk/overlay';
import { Nullable } from '@fundamental-ngx/cdk/utils';
import { Placement, PopoverFillMode } from '@fundamental-ngx/core/shared';
import { MobileModeConfig, MobileMode, MobileModeBase } from '@fundamental-ngx/core/mobile-mode';
import { CdkTrapFocus } from '@angular/cdk/a11y';
import { ContentDensityObserver } from '@fundamental-ngx/core/content-density';
import { ScrollbarDirective } from '@fundamental-ngx/core/scrollbar';
import { Subject } from 'rxjs';
import * as i1 from '@fundamental-ngx/core/dialog';
import { DialogConfig } from '@fundamental-ngx/core/dialog';
import * as i2 from '@fundamental-ngx/core/button';

declare class PopoverBodyDirective {
    /**
     * The template to be used as the popover's body.
     **/
    readonly templateRef: TemplateRef<void>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PopoverBodyDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<PopoverBodyDirective, "[fdPopoverBody]", never, {}, {}, never, never, true, never>;
}

/**
 * A component used to enforce a certain layout for the popover.
 * ```html
 * <fd-popover>
 *     <fd-popover-control>Control Element</fd-popover-control>
 *     <fd-popover-body>Popover Body</fd-popover-body>
 * </fd-popover>
 * ```
 */
declare class PopoverBodyComponent {
    /** Minimum width of the popover body element. */
    readonly minWidth: _angular_core.InputSignal<Nullable<string>>;
    /** Maximum width of the popover body element. */
    readonly maxWidth: _angular_core.InputSignal<Nullable<string>>;
    /** Minimum height of the popover body element. */
    readonly minHeight: _angular_core.InputSignal<Nullable<string>>;
    /** Maximum height of the popover body element. */
    readonly maxHeight: _angular_core.InputSignal<Nullable<string>>;
    /** @hidden */
    readonly _cdkTrapFocus: _angular_core.Signal<CdkTrapFocus | undefined>;
    /** @hidden */
    readonly _scrollbar: _angular_core.Signal<ScrollbarDirective | undefined>;
    /** @hidden Whether to wrap content with fd-scrollbar directive. */
    readonly _disableScrollbar: _angular_core.WritableSignal<boolean>;
    /** @hidden Whether the popover should have an arrow. */
    readonly _noArrow: _angular_core.WritableSignal<boolean>;
    /** @hidden Whether the popover container needs an extra class for styling. */
    readonly _additionalBodyClass: _angular_core.WritableSignal<Nullable<string>>;
    /** @hidden Whether the popover should be focusTrapped. */
    readonly _focusTrapped: _angular_core.WritableSignal<boolean>;
    /**
     * @hidden
     * Whether the popover should automatically move focus into the trapped region upon
     * initialization and return focus to the previous activeElement upon destruction.
     */
    readonly _focusAutoCapture: _angular_core.WritableSignal<boolean>;
    /** @hidden Property bind to popover's body. */
    readonly _popoverBodyWidth: _angular_core.WritableSignal<number | undefined>;
    /** @hidden Property bind to popover's body. */
    readonly _popoverBodyMinWidth: _angular_core.WritableSignal<number | undefined>;
    /** @hidden Property bind to popover's body. */
    readonly _maxWidth: _angular_core.WritableSignal<Nullable<number>>;
    /** @hidden Property bind to popover's body. */
    readonly _closeOnEscapeKey: _angular_core.WritableSignal<boolean>;
    /** @hidden Aria role for the popover body. */
    readonly _bodyRole: _angular_core.WritableSignal<Nullable<string>>;
    /** @hidden Aria label for the popover body. */
    readonly _bodyAriaLabel: _angular_core.WritableSignal<Nullable<string>>;
    /** @hidden ID of the element that labels the popover body. */
    readonly _bodyAriaLabelledBy: _angular_core.WritableSignal<string | null>;
    /** @hidden ID for the popover body. */
    readonly _bodyId: _angular_core.WritableSignal<string | null>;
    /** @hidden Classes added to arrow element. */
    readonly _arrowClasses: _angular_core.WritableSignal<string>;
    /** @hidden text rendered inside popover's body. */
    readonly text: _angular_core.WritableSignal<Nullable<string>>;
    /** @hidden template rendered inside popover's body. */
    readonly _templateToDisplay: _angular_core.WritableSignal<TemplateRef<any> | undefined>;
    /** @hidden Whether the popover body is resizable. */
    readonly _resizable: _angular_core.WritableSignal<boolean>;
    /** @hidden */
    readonly _resizeHandleLocation: _angular_core.WritableSignal<"top-right" | "top-left" | "bottom-right" | "bottom-left">;
    /** Event emitted when popover body requests to be closed (e.g., Escape key press) */
    readonly onClose: _angular_core.OutputEmitterRef<void>;
    /** @hidden */
    readonly _elementRef: ElementRef<any>;
    /** @hidden */
    readonly _contentDensityObserver: ContentDensityObserver;
    /** @hidden */
    private readonly _renderer;
    /** @hidden */
    private _bodyComponentClasses;
    /** @hidden */
    constructor();
    /** Handler escape keydown */
    bodyKeyupHandler(event: KeyboardEvent): void;
    /** @hidden */
    _setBodyComponentClasses(classes: string | null): void;
    /** @hidden */
    _setArrowStyles(position: ConnectionPositionPair, rtl: 'rtl' | 'ltr'): void;
    /** @hidden */
    _focusFirstTabbableElement(forced?: boolean): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PopoverBodyComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PopoverBodyComponent, "fd-popover-body", never, { "minWidth": { "alias": "minWidth"; "required": false; "isSignal": true; }; "maxWidth": { "alias": "maxWidth"; "required": false; "isSignal": true; }; "minHeight": { "alias": "minHeight"; "required": false; "isSignal": true; }; "maxHeight": { "alias": "maxHeight"; "required": false; "isSignal": true; }; }, { "onClose": "onClose"; }, never, ["[fd-popover-body-header]", "[fd-popover-body-subheader]", "*", "[fd-popover-body-footer]"], true, never>;
}

/**
 * A component used to enforce a certain layout for the popover.
 * ```html
 * <fd-popover>
 *     <fd-popover-control>Control Element</fd-popover-control>
 *     <fd-popover-body>Popover Body</fd-popover-body>
 * </fd-popover>
 * ```
 */
declare class PopoverControlComponent implements AfterContentChecked {
    elRef: ElementRef;
    /** @hidden */
    _tabbable: boolean;
    /** @hidden */
    constructor(elRef: ElementRef);
    /** @hidden */
    ngAfterContentChecked(): void;
    /** @hidden */
    makeTabbable(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PopoverControlComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PopoverControlComponent, "fd-popover-control, [fdPopoverControl]", never, {}, {}, never, ["*"], true, never>;
}

/**
 * ARIA role values commonly used for popover bodies. Provides autocomplete for
 * the most frequent cases while allowing any valid ARIA role via the string escape hatch.
 */
type PopoverBodyRole = 'dialog' | 'region' | 'menu' | 'listbox' | 'tooltip' | 'alertdialog';
declare const SELECT_CLASS_NAMES: {
    selectControl: string;
};
/**
 * The popover is a wrapping component that accepts a *control* as well as a *body*.
 * The control is what will trigger the opening of the actual popover, which is called the body.
 * By default, popovers are triggered by click. This can be customized through the *triggers* input.
 */
declare class PopoverComponent implements AfterViewInit, AfterContentInit, OnDestroy {
    /**
     * Configuration object for popover settings.
     * When provided, these settings will be merged with individual input properties.
     * Individual inputs take precedence over config object values.
     */
    readonly config: _angular_core.InputSignal<PopoverConfig>;
    /** Tooltip for popover */
    readonly title: _angular_core.InputSignal<string>;
    /** Reference to popover trigger element */
    readonly trigger: _angular_core.ModelSignal<ElementRef<any> | HTMLElement | null>;
    /** Id of the popover. If none is provided, one will be generated. */
    readonly id: _angular_core.InputSignal<string>;
    /** Whether the popover component should be displayed in mobile mode. */
    readonly mobile: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /** Config for the popover in mobile mode */
    readonly mobileConfig: _angular_core.InputSignal<MobileModeConfig>;
    /**
     * Whether the popover should prevent page scrolling when space key is pressed.
     **/
    readonly preventSpaceKeyScroll: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /** Popover placement */
    readonly placement: _angular_core.InputSignal<Placement>;
    /** Maximum width of popover body in px, prevents from overextending body by `fillControlMode` */
    readonly maxWidth: _angular_core.InputSignal<number | null>;
    /**
     * Preset options for the popover body width.
     * * `at-least` will apply a minimum width to the body equivalent to the width of the control.
     * * `equal` will apply a width to the body equivalent to the width of the control.
     * * Leave blank for no effect.
     */
    readonly fillControlMode: _angular_core.InputSignal<PopoverFillMode | null>;
    /** Whether clicking outside popover should close it */
    readonly closeOnOutsideClick: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /** Whether escape key should close the popover */
    readonly closeOnEscapeKey: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /** Whether the popover is disabled */
    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /** Popover trigger events configuration */
    readonly triggers: _angular_core.InputSignal<(string | TriggerConfig)[]>;
    /** Whether the popover should trap focus */
    readonly focusTrapped: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /** Whether focus should be automatically captured when popover opens */
    readonly focusAutoCapture: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * Whether to move the focus after popover is closed to the last focused element before popover was opened.
     */
    readonly restoreFocusOnClose: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /** Whether the arrow should be hidden */
    readonly noArrow: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /** Whether scrollbar should be disabled */
    readonly disableScrollbar: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /** The element to which the overlay is attached. By default it is body */
    readonly appendTo: _angular_core.InputSignal<ElementRef<any> | Element | null>;
    /** Placement of the popover element */
    readonly placementContainer: _angular_core.InputSignal<ElementRef<any> | Element | null>;
    /** Scroll strategy for the overlay */
    readonly scrollStrategy: _angular_core.InputSignal<any>;
    /** List of position options for CDK overlay */
    readonly cdkPositions: _angular_core.InputSignal<ConnectedPosition[] | null>;
    /** Whether to apply a background overlay */
    readonly applyOverlay: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /** Additional CSS class for the popover body container */
    readonly additionalBodyClass: _angular_core.InputSignal<string | null>;
    /** Additional CSS class for the popover trigger element */
    readonly additionalTriggerClass: _angular_core.InputSignal<string | null>;
    /** Whether to close the popover on router navigation start */
    readonly closeOnNavigation: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /** Whether position shouldn't change when popover approaches the corner of page */
    readonly fixedPosition: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /** Whether the popover body is resizable */
    readonly resizable: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /** ARIA label for the popover body */
    readonly bodyAriaLabel: _angular_core.InputSignal<string | null>;
    /**
     * ARIA role for the popover body. Default: 'dialog' (back-compat).
     *
     * When 'dialog', WCAG requires an accessible name — provide one via
     * [bodyAriaLabel] or [bodyAriaLabelledBy]. Without a name, axe-core
     * raises aria-dialog-name violations.
     *
     * Set to null when the popover is a non-modal disclosure widget and
     * the trigger's aria-haspopup already carries the relationship (no role
     * attribute is rendered). Other valid values: 'region', 'menu', 'listbox',
     * 'tooltip', 'alertdialog' — match the role to the popover's actual semantics.
     * Any valid ARIA role is accepted; the type provides autocomplete for common cases.
     *
     * @remarks When set via this input (including when unbound — defaults to 'dialog'),
     * the PopoverConfig object's `bodyRole` field is ignored. Config-only usage
     * is not supported for `bodyRole` because the input has a concrete default.
     * To override, bind the input explicitly: `[bodyRole]="'region'"` or `[bodyRole]="null"`.
     *
     * See https://www.w3.org/WAI/ARIA/apg/patterns/dialog-modal/ for guidance.
     */
    readonly bodyRole: _angular_core.InputSignal<PopoverBodyRole | (string & {}) | null>;
    /**
     * ID of the element that labels the popover body. Alternative to
     * [bodyAriaLabel] when the label already exists in the DOM (e.g. the
     * trigger's text). Sets aria-labelledby on the popover body.
     */
    readonly bodyAriaLabelledBy: _angular_core.InputSignal<string | null>;
    /** Two-way binding for popover open state */
    readonly isOpen: _angular_core.ModelSignal<boolean>;
    /** Event emitted when the state of the isOpen property changes. */
    readonly isOpenChange: _angular_core.OutputEmitterRef<boolean>;
    /** Event emitted right before the popover is being opened. */
    readonly beforeOpen: _angular_core.OutputEmitterRef<void>;
    /** @hidden */
    readonly templateRef: _angular_core.Signal<TemplateRef<any> | undefined>;
    /** @hidden */
    readonly container: _angular_core.Signal<ViewContainerRef | undefined>;
    /** @hidden */
    readonly triggerOrigin: _angular_core.Signal<CdkOverlayOrigin | undefined>;
    /** @hidden */
    readonly popoverBody: _angular_core.Signal<PopoverBodyComponent | undefined>;
    /** @hidden */
    readonly popoverBodyDirective: _angular_core.Signal<PopoverBodyDirective | undefined>;
    /** @hidden */
    readonly popoverControl: _angular_core.Signal<PopoverControlComponent | undefined>;
    /** @hidden - template for Dialog body content */
    readonly popoverBodyContentTemplate: _angular_core.Signal<TemplateRef<any> | undefined>;
    /** @hidden - template for Dialog footer content */
    readonly popoverFooterContentTemplate: _angular_core.Signal<TemplateRef<any> | undefined>;
    /** @hidden */
    get _triggerElement(): HTMLElement | null;
    /** @hidden */
    private readonly _popoverService;
    /** @hidden */
    private readonly _renderer;
    /** @hidden */
    private readonly _viewContainerRef;
    /** @hidden */
    private readonly _injector;
    /** @hidden */
    private readonly _dynamicComponentService;
    /** @hidden */
    private readonly _destroyRef;
    /** @hidden */
    private _clickEventListener;
    /** @hidden */
    private _mobileModeComponentRef;
    /** @hidden Flag to prevent circular sync between component and service */
    private _syncingIsOpen;
    /** @hidden Computed signal that merges config with individual inputs */
    private readonly _effectiveConfig;
    /** @hidden */
    constructor();
    /** @hidden */
    ngAfterViewInit(): void;
    /** @hidden */
    ngAfterContentInit(): void;
    /** @hidden */
    ngOnDestroy(): void;
    /** Toggles menu open/close state */
    toggle(): void;
    /** Opens the popover. */
    open(): void;
    /** Closes the popover. */
    close(focusActiveElement?: boolean): void;
    /** Temporary sets the ignoring of the event triggers. */
    setIgnoreTriggers(ignore: boolean): void;
    /**
     * Method called to change position of popover,
     * recommended to be used only when popover is opened, otherwise change position or cdkPlacement
     */
    applyNewPosition(positions: ConnectedPosition[]): void;
    /** Method called to refresh position of opened popover */
    refreshPosition(): void;
    /** Handler for alt + arrow down keydown */
    triggerKeyDownHandler(event: KeyboardEvent): void;
    /** Handler escape keydown */
    protected _onEscapeKey(event: Event): void;
    /** @hidden */
    protected _onKeyDown(event: Event): void;
    /** @hidden - Sync all input signals to the service */
    private _syncToService;
    /** @hidden Select and instantiate popover view mode */
    private _setupView;
    /**
     * Depending on a used popover body type, returns a popover body content
     **/
    private _getPopoverBodyContent;
    /** @hidden Open Popover in mobile mode */
    private _setupMobileMode;
    /** @hidden - Listen on popover trigger ref clicks */
    private _listenOnTriggerRefClicks;
    /**
     * @hidden
     * This is going to be removed in feature, on dialog and dynamic service component refactor
     */
    private _destroyEventListeners;
    /** @hidden */
    private _destroyMobileComponent;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PopoverComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PopoverComponent, "fd-popover", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "trigger": { "alias": "trigger"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "mobile": { "alias": "mobile"; "required": false; "isSignal": true; }; "mobileConfig": { "alias": "mobileConfig"; "required": false; "isSignal": true; }; "preventSpaceKeyScroll": { "alias": "preventSpaceKeyScroll"; "required": false; "isSignal": true; }; "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "maxWidth": { "alias": "maxWidth"; "required": false; "isSignal": true; }; "fillControlMode": { "alias": "fillControlMode"; "required": false; "isSignal": true; }; "closeOnOutsideClick": { "alias": "closeOnOutsideClick"; "required": false; "isSignal": true; }; "closeOnEscapeKey": { "alias": "closeOnEscapeKey"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "triggers": { "alias": "triggers"; "required": false; "isSignal": true; }; "focusTrapped": { "alias": "focusTrapped"; "required": false; "isSignal": true; }; "focusAutoCapture": { "alias": "focusAutoCapture"; "required": false; "isSignal": true; }; "restoreFocusOnClose": { "alias": "restoreFocusOnClose"; "required": false; "isSignal": true; }; "noArrow": { "alias": "noArrow"; "required": false; "isSignal": true; }; "disableScrollbar": { "alias": "disableScrollbar"; "required": false; "isSignal": true; }; "appendTo": { "alias": "appendTo"; "required": false; "isSignal": true; }; "placementContainer": { "alias": "placementContainer"; "required": false; "isSignal": true; }; "scrollStrategy": { "alias": "scrollStrategy"; "required": false; "isSignal": true; }; "cdkPositions": { "alias": "cdkPositions"; "required": false; "isSignal": true; }; "applyOverlay": { "alias": "applyOverlay"; "required": false; "isSignal": true; }; "additionalBodyClass": { "alias": "additionalBodyClass"; "required": false; "isSignal": true; }; "additionalTriggerClass": { "alias": "additionalTriggerClass"; "required": false; "isSignal": true; }; "closeOnNavigation": { "alias": "closeOnNavigation"; "required": false; "isSignal": true; }; "fixedPosition": { "alias": "fixedPosition"; "required": false; "isSignal": true; }; "resizable": { "alias": "resizable"; "required": false; "isSignal": true; }; "bodyAriaLabel": { "alias": "bodyAriaLabel"; "required": false; "isSignal": true; }; "bodyRole": { "alias": "bodyRole"; "required": false; "isSignal": true; }; "bodyAriaLabelledBy": { "alias": "bodyAriaLabelledBy"; "required": false; "isSignal": true; }; "isOpen": { "alias": "isOpen"; "required": false; "isSignal": true; }; }, { "trigger": "triggerChange"; "isOpen": "isOpenChange"; "isOpenChange": "isOpenChange"; "beforeOpen": "beforeOpen"; }, ["popoverBody", "popoverBodyDirective", "popoverControl", "popoverBodyContentTemplate", "popoverFooterContentTemplate"], ["fd-popover-control, [fdPopoverControl]", "fd-popover-body", "*"], true, never>;
}

/**
 * Configuration object for popover trigger events.
 * Allows specifying whether an event should apply for open and/or close actions.
 */
interface TriggerConfig {
    /** The DOM event trigger name */
    trigger: string;
    /** Whether this trigger should open the popover */
    openAction: boolean;
    /** Whether this trigger should close the popover */
    closeAction: boolean;
    /** Whether to stop event propagation */
    stopPropagation?: boolean;
}
/**
 * Comprehensive configuration interface for popover components.
 * This interface replaces the deprecated BasePopoverClass approach with a cleaner composition pattern.
 *
 * All properties are optional to support partial configuration.
 * Components can accept this config object via an input signal and merge it with individual inputs.
 */
interface PopoverConfig {
    /** Whether to close the popover on router navigation start. */
    closeOnNavigation?: boolean;
    /** Whether the popover is disabled. */
    disabled?: boolean;
    /** Maximum width of popover body in px, prevents from overextending body by `fillControlMode`. */
    maxWidth?: Nullable<number>;
    /** Whether the popover should have an arrow. */
    noArrow?: boolean;
    /** Additional CSS classes for the popover body container. */
    additionalBodyClass?: string | null;
    /** Classes applied directly to fd-popover-body component. */
    additionalBodyComponentClasses?: string | null;
    /** Additional CSS classes for the trigger element. */
    additionalTriggerClass?: string | null;
    /** Whether the popover should close when the escape key is pressed. */
    closeOnEscapeKey?: boolean;
    /** Whether to wrap content with fd-scrollbar directive. */
    disableScrollbar?: boolean;
    /**
     * The placement of the popover.
     * Options: top, top-start, top-end, bottom, bottom-start, bottom-end,
     * right, right-start, right-end, left, left-start, left-end.
     */
    placement?: Placement | null;
    /**
     * Trigger events that open/close the popover.
     * Accepts HTML DOM Events or TriggerConfig objects.
     *
     * - Single event: treated as toggle (both open and close)
     * - Multiple events: odd events open, even events close
     *
     * Examples:
     * ```
     * ['click'] // Toggle on click
     * ['mouseenter', 'mouseleave'] // Open on mouseenter, close on mouseleave
     * [{ trigger: 'focus', openAction: true, closeAction: false }] // Only opens on focus
     * ```
     */
    triggers?: (string | TriggerConfig)[];
    /** Whether the popover is open. */
    isOpen?: boolean;
    /** Whether the popover should close when a click is made outside its boundaries. */
    closeOnOutsideClick?: boolean;
    /** Whether to apply a background overlay. */
    applyOverlay?: boolean;
    /** Whether the popover should trap focus within its boundaries. */
    focusTrapped?: boolean;
    /**
     * Whether to automatically move focus into the trapped region upon
     * initialization and return focus to the previous activeElement upon destruction.
     */
    focusAutoCapture?: boolean;
    /**
     * Whether to move focus back to the last focused element before popover was opened
     * when the popover is closed.
     */
    restoreFocusOnClose?: boolean;
    /**
     * Scroll strategy for the CDK overlay.
     * Options:
     * - CloseScrollStrategy: Closes popover on scroll
     * - NoopScrollStrategy: No action on scroll
     * - BlockScrollStrategy: Blocks scrolling
     * - RepositionScrollStrategy: Repositions popover on scroll (default)
     */
    scrollStrategy?: ScrollStrategy | null;
    /**
     * List of position options for CDK overlay.
     * Positions are tried in order until one fits.
     * See: https://material.angular.io/cdk/overlay/api
     */
    cdkPositions?: ConnectedPosition[] | null;
    /**
     * Preset options for popover body width.
     * - `at-least`: Minimum width equals control width
     * - `equal`: Width equals control width
     * - `null`: No width constraint
     */
    fillControlMode?: Nullable<PopoverFillMode>;
    /** The element to which the overlay is attached. Defaults to document body. */
    appendTo?: Nullable<ElementRef | Element>;
    /** Container element for positioning the popover. */
    placementContainer?: Nullable<ElementRef | Element>;
    /** Whether position should remain fixed when approaching page corners. */
    fixedPosition?: boolean;
    /** Whether the popover body is resizable. */
    resizable?: boolean;
    /** ARIA role for the popover body. Common values: 'dialog', 'region', 'menu', 'listbox', 'tooltip', 'alertdialog'. */
    bodyRole?: PopoverBodyRole | (string & {}) | null;
    /** ARIA label for the popover body. */
    bodyAriaLabel?: string | null;
    /** ID of the element that labels the popover body. */
    bodyAriaLabelledBy?: string | null;
    /** ID for the popover body. */
    bodyId?: string | null;
}

/**
 * @deprecated Use the {@link PopoverConfig} interface instead of extending this class.
 * This class will be removed in a future major version.
 *
 * Migration guide:
 * - For components: Use regular `input()` signal properties and pass configuration to PopoverService
 * - For services: Use the PopoverConfig interface to define configuration objects
 * - See {@link PopoverComponent} and {@link MenuComponent} for modern implementation examples
 *
 * Configuration object for popover settings.
 * This is used by PopoverService and was extended by PopoverComponent and MenuComponent.
 *
 * **For Components:** Use signal inputs with the `input()` function to declare these properties.
 * Components should also define their own `isOpenChange = output<boolean>()` and `beforeOpen = output<void>()` outputs.
 *
 * **For Services:** Use regular signal instances to store these values.
 */
declare class BasePopoverClass {
    /** Whether to close the popover on router navigation start. */
    closeOnNavigation: _angular_core.WritableSignal<boolean>;
    /** Whether the popover is disabled. */
    disabled: _angular_core.WritableSignal<boolean>;
    /** Maximum width of popover body in px, prevents from overextending body by `fillControlMode`  */
    maxWidth: _angular_core.WritableSignal<Nullable<number>>;
    /** Whether the popover should have an arrow. */
    noArrow: _angular_core.WritableSignal<boolean>;
    /** Whether the popover container needs an extra class for styling. */
    additionalBodyClass: _angular_core.WritableSignal<string | null>;
    /** Classes that should be applied to fd-popover-body component directly. */
    additionalBodyComponentClasses: _angular_core.WritableSignal<string | null>;
    /** Whether the popover container needs an extra class for styling. */
    additionalTriggerClass: _angular_core.WritableSignal<string | null>;
    /** Whether the popover should close when the escape key is pressed. */
    closeOnEscapeKey: _angular_core.WritableSignal<boolean>;
    /** Whether to wrap content with fd-scrollbar directive. */
    disableScrollbar: _angular_core.WritableSignal<boolean>;
    /**
     * The placement of the popover.
     * It can be one of:
     * top, top-start, top-end, bottom, bottom-start, bottom-end,
     * right, right-start, right-end, left, left-start, left-end.
     */
    placement: _angular_core.WritableSignal<Placement | null>;
    /**
     * The trigger events that will open/close the popover.
     * Accepts any [HTML DOM Events](https://www.w3schools.com/jsref/dom_obj_event.asp) or a config object for the corresponding event.
     * Using the config object allows to specify whether an event should apply both for open and close actions or only some of them.
     *
     * If array of triggers consists only of one event, it will be treated at a toggle event (open and close)
     * If array of trigger consists of more than one event, each odd event will be treated as an open event for the popover,
     * and each even event will be treated as closing event for the popover.
     *
     * Consider the following value for `triggers`:
     * ```
     * [
     *  'click' // basically it's an alias for "{ trigger: 'click', openAction: true, closeAction: true }"
     * ]
     * ```
     * ```
     * [
     *  'mouseenter' // Shortcut for "{ trigger: 'mouseenter', openAction: true, closeAction: false }", and will only open the popover.
     *  'mouseleave' // Shortcut for "{ trigger: 'mouseleave', openAction: false, closeAction: true }" and will only close the popover.
     * ]
     * ```
     * ```
     * [
     *  { trigger: 'mouseenter', openAction: true, closeAction: true }, // "mouseenter" will toggle the popover.
     *  { trigger: 'mouseleave', openAction: true, closeAction: true } // "mouseleave" will toggle the popover.
     * ]
     * ```
     *
     * @default ['click']
     */
    triggers: _angular_core.WritableSignal<(string | TriggerConfig)[]>;
    /** Whether the popover is open. Can be used through two-way binding. */
    isOpen: _angular_core.WritableSignal<boolean>;
    /** Whether the popover should close when a click is made outside its boundaries. */
    closeOnOutsideClick: _angular_core.WritableSignal<boolean>;
    /** Wether to apply a background overlay */
    applyOverlay: _angular_core.WritableSignal<boolean>;
    /** Whether the popover should be focusTrapped. */
    focusTrapped: _angular_core.WritableSignal<boolean>;
    /**
     * Whether the popover should automatically move focus into the trapped region upon
     * initialization and return focus to the previous activeElement upon destruction.
     */
    focusAutoCapture: _angular_core.WritableSignal<boolean>;
    /**
     * Whether to move the focus after popover is closed to the last focused element before popover was opened.
     */
    restoreFocusOnClose: _angular_core.WritableSignal<boolean>;
    /**
     * Scroll strategy, there are 4 accepted
     * - CloseScrollStrategy
     * - NoopScrollStrategy
     * - BlockScrollStrategy
     * - RepositionScrollStrategy ( default )
     */
    scrollStrategy: _angular_core.WritableSignal<ScrollStrategy | null>;
    /**
     * List of positions options for overlay defined by angular CDK.
     * Positions will be taken in order, same like on array. If first position provided doesn't fit to window,
     * another will be used
     * More information can be found in https://material.angular.io/cdk/overlay/api
     */
    cdkPositions: _angular_core.WritableSignal<ConnectedPosition[] | null>;
    /**
     * Preset options for the popover body width.
     * * `at-least` will apply a minimum width to the body equivalent to the width of the control.
     * * `equal` will apply a width to the body equivalent to the width of the control.
     * * Leave blank for no effect.
     */
    fillControlMode: _angular_core.WritableSignal<Nullable<PopoverFillMode>>;
    /** The element to which  the overlay is attached. By default it is body */
    appendTo: _angular_core.WritableSignal<Nullable<ElementRef<any> | Element>>;
    /** Placement of the popover element. */
    placementContainer: _angular_core.WritableSignal<Nullable<ElementRef<any> | Element>>;
    /** Whether position shouldn't change, when popover approach the corner of page */
    fixedPosition: _angular_core.WritableSignal<boolean>;
    /** Whether the popover body is resizable. */
    resizable: _angular_core.WritableSignal<boolean>;
    /** @hidden Aria role for the popover body. */
    protected _bodyRole: string | null;
    /** @hidden ID for the popover body. */
    protected readonly _bodyId: _angular_core.WritableSignal<string | null>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BasePopoverClass, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BasePopoverClass, never, never, {}, {}, never, never, true, never>;
}

declare class PopoverBodyFooterDirective {
    /** @hidden */
    fdPopoverBodyFooterClass: boolean;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PopoverBodyFooterDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<PopoverBodyFooterDirective, "[fdPopoverBodyFooter], [fd-popover-body-footer]", never, {}, {}, never, never, true, never>;
}

declare class PopoverBodyHeaderDirective {
    /** @hidden */
    fdPopoverBodyHeaderClass: boolean;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PopoverBodyHeaderDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<PopoverBodyHeaderDirective, "[fdPopoverBodyHeader], [fd-popover-body-header]", never, {}, {}, never, never, true, never>;
}

interface PopoverChildContent {
    popoverBodyContentTemplate: TemplateRef<any>;
    popoverFooterContentTemplate: TemplateRef<any>;
}

declare class PopoverContainerDirective implements OnInit {
    private _elmRef;
    /** Subject which emits when popover position refresh is required. */
    refreshPosition$: Subject<void>;
    /** @hidden */
    private readonly _destroyRef;
    /** @hidden */
    constructor(_elmRef: ElementRef<HTMLElement>);
    /** @hidden */
    ngOnInit(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PopoverContainerDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<PopoverContainerDirective, "[fdPopoverContainer]", never, {}, {}, never, never, true, never>;
}

declare const POPOVER_COMPONENT: InjectionToken<PopoverInterface>;
/**
 * Popover Interface to have typing and avoid circular dependency between
 * PopoverComponent <==> PopoverMobileComponent
 */
interface PopoverInterface extends MobileMode {
    dialogConfig: DialogConfig;
    isOpen: ModelSignal<boolean>;
    isOpenChange: EventEmitter<boolean>;
    close(): void;
}

declare class PopoverMobileComponent extends MobileModeBase<PopoverInterface> implements OnInit, OnDestroy {
    /** @hidden */
    _dialogTemplate: TemplateRef<any>;
    /** @hidden Cannot use _ prefix due to mobile class build constraints. */
    childContent?: PopoverChildContent;
    /** Current popover title */
    title: string;
    /** Dialog body content */
    viewBody: TemplateRef<any> | null;
    /** Dialog footer content */
    viewFooter: TemplateRef<any> | null;
    /** @hidden */
    readonly id: string;
    /** @hidden */
    get titleId(): string;
    /** @hidden */
    constructor();
    /** @hidden */
    ngOnInit(): void;
    /** @hidden */
    ngOnDestroy(): void;
    /** Closes the dialog and popover. */
    close(): void;
    /** @hidden Opens the dialog. */
    private _openDialog;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PopoverMobileComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PopoverMobileComponent, "fd-popover-mobile", never, {}, {}, never, never, true, never>;
}

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class PopoverMobileModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PopoverMobileModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<PopoverMobileModule, never, [typeof i1.DialogModule, typeof i2.ButtonComponent, typeof PopoverMobileComponent], [typeof PopoverMobileComponent]>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<PopoverMobileModule>;
}

interface PopoverTemplate {
    container: ViewContainerRef;
    popoverBody: PopoverBodyComponent;
    template: TemplateRef<any>;
}
declare class PopoverService {
    /** Whether to close the popover on router navigation start. */
    readonly closeOnNavigation: _angular_core.WritableSignal<boolean>;
    /** Whether the popover is disabled. */
    readonly disabled: _angular_core.WritableSignal<boolean>;
    /** Maximum width of popover body in px */
    readonly maxWidth: _angular_core.WritableSignal<Nullable<number>>;
    /** Whether the popover should have an arrow. */
    readonly noArrow: _angular_core.WritableSignal<boolean>;
    /** Whether the popover container needs an extra class for styling. */
    readonly additionalBodyClass: _angular_core.WritableSignal<string | null>;
    /** Classes that should be applied to fd-popover-body component directly. */
    readonly additionalBodyComponentClasses: _angular_core.WritableSignal<string | null>;
    /** Whether the popover container needs an extra class for styling. */
    readonly additionalTriggerClass: _angular_core.WritableSignal<string | null>;
    /** Whether the popover should close when the escape key is pressed. */
    readonly closeOnEscapeKey: _angular_core.WritableSignal<boolean>;
    /** Whether to wrap content with fd-scrollbar directive. */
    readonly disableScrollbar: _angular_core.WritableSignal<boolean>;
    /** The placement of the popover. */
    readonly placement: _angular_core.WritableSignal<Placement | null>;
    /** The trigger events that will open/close the popover. */
    readonly triggers: _angular_core.WritableSignal<(string | TriggerConfig)[]>;
    /** Whether the popover is open. */
    readonly isOpen: _angular_core.WritableSignal<boolean>;
    /** Whether the popover should close when a click is made outside its boundaries. */
    readonly closeOnOutsideClick: _angular_core.WritableSignal<boolean>;
    /** Whether to apply a background overlay */
    readonly applyOverlay: _angular_core.WritableSignal<boolean>;
    /** Whether the popover should be focusTrapped. */
    readonly focusTrapped: _angular_core.WritableSignal<boolean>;
    /** Whether to automatically move focus into the trapped region. */
    readonly focusAutoCapture: _angular_core.WritableSignal<boolean>;
    /** Whether to move focus back after popover is closed. */
    readonly restoreFocusOnClose: _angular_core.WritableSignal<boolean>;
    /** Scroll strategy */
    readonly scrollStrategy: _angular_core.WritableSignal<ScrollStrategy | null>;
    /** List of positions options for overlay. */
    readonly cdkPositions: _angular_core.WritableSignal<ConnectedPosition[] | null>;
    /** Preset options for the popover body width. */
    readonly fillControlMode: _angular_core.WritableSignal<Nullable<PopoverFillMode>>;
    /** The element to which the overlay is attached. */
    readonly appendTo: _angular_core.WritableSignal<Nullable<ElementRef<any> | Element>>;
    /** Placement of the popover element. */
    readonly placementContainer: _angular_core.WritableSignal<Nullable<ElementRef<any> | Element>>;
    /** Whether position shouldn't change when popover approach the corner of page */
    readonly fixedPosition: _angular_core.WritableSignal<boolean>;
    /** Whether the popover body is resizable. */
    readonly resizable: _angular_core.WritableSignal<boolean>;
    /** Emits when popover open state changes */
    readonly isOpenChange: EventEmitter<boolean>;
    /** String content displayed inside popover body */
    stringContent: Nullable<string>;
    /** Template content displayed inside popover body */
    templateContent: Nullable<TemplateRef<any>>;
    /** @hidden */
    _onLoad: Subject<ElementRef<any>>;
    /** @hidden */
    _mobile: boolean;
    /** @hidden Aria role for the popover body. */
    protected _bodyRole: string | null;
    /** @hidden Aria label for the popover body. */
    protected _bodyAriaLabel: string | null;
    /** @hidden ID of the element that labels the popover body. */
    protected _bodyAriaLabelledBy: string | null;
    /** @hidden ID for the popover body. */
    protected readonly _bodyId: _angular_core.WritableSignal<string | null>;
    /** @hidden */
    private _eventRef;
    /** @hidden */
    private _overlayRef;
    /** @hidden */
    private _refresh$;
    /** @hidden */
    private _stopCloseListening$;
    /** @hidden */
    private readonly _placementRefresh$;
    /** @hidden */
    private _popoverBody;
    /** @hidden */
    private _triggerElement;
    /** @hidden */
    private _lastActiveElement;
    /** @hidden */
    private _templateData;
    /** @hidden */
    private _placementContainerValue;
    /** @hidden */
    private _ignoreTriggers;
    /** @hidden Timer for delayed hover close, allows mouse to travel from trigger to overlay body. */
    private _hoverCloseTimer;
    /** @hidden Listeners for mouseenter/mouseleave on the overlay element. */
    private _overlayHoverListeners;
    /** @hidden */
    private _modalBodyClass;
    /** @hidden */
    private _modalTriggerClass;
    /** @hidden */
    private _isModal;
    /** An RxJS Subject that will kill the data stream upon component's destruction (for unsubscribing)  */
    private readonly _destroyRef;
    /** @hidden */
    private readonly _rtlService;
    /** @hidden */
    private readonly _popoverContainer;
    /** @hidden */
    private readonly _overlay;
    /** @hidden */
    private readonly _renderer;
    /** @hidden */
    private readonly _viewportRuler;
    /** @hidden */
    private readonly _injector;
    /** @hidden Watches DOM mutations within the scroll container when the popover is open to reposition after layout shifts (e.g. display:none on siblings). */
    private _ancestorMutationObserver;
    /** @hidden */
    private get _triggerHtmlElement();
    /** @hidden Flag to prevent infinite loop when programmatically opening/closing */
    private _programmaticChange;
    /** @hidden Computed signal for body-related config to track dependencies */
    private readonly _bodyConfig;
    /** @hidden */
    constructor();
    /**
     * Method initialising the popover service - should be called, after view is initialised, params:
     * - triggerElement - element, which is equivalent for cdkOverlayOrigin, or fd-popover-control,
     *   by default to this element the popover body will lbe appended and events on this element will trigger
     *   popover's  toggle
     * - config - configuration object using PopoverConfig interface
     * - templateData - in case of having already PopoverBodyComponent, there is way to pass container, template containing
     *   PopoverComponent and PopoverComponent instance
     */
    initialise(triggerElement: ElementRef | HTMLElement, config?: PopoverConfig, templateData?: PopoverTemplate | TemplateRef<void> | null): void;
    /** Closes the popover. */
    close(focusActiveElement?: boolean): void;
    /** Opens the popover. */
    open(): void;
    /** method updating template or text inside rendered PopoverBody */
    updateContent(stringContent: Nullable<string> | Nullable<TemplateRef<any>>, templateContent: Nullable<TemplateRef<any>>): void;
    /** Changes background theming when modal */
    /** @hidden */
    checkModalBackground(): void;
    /** Toggles the popover open state */
    toggle(openAction?: boolean, closeAction?: boolean, focusActiveElement?: boolean): void;
    /**
     * Method called to change position of popover,
     * recommended to be used only when popover is opened, otherwise change position or cdkPlacement
     */
    applyNewPosition(positions: ConnectedPosition[]): void;
    /** Method called to refresh position of opened popover */
    refreshPosition(): void;
    /** Temporary sets the ignoring of the event triggers. */
    setIgnoreTriggers(ignore: boolean): void;
    /**
     * Method that sets configuration/options, it detects if there is something changed and overwrites them
     */
    refreshConfiguration(config: PopoverConfig): void;
    /**
     * This method is intended to be called in order
     * to postpone the main functionality but be able
     * to enable it back in the future by initialise()
     */
    deactivate(): void;
    /** Refresh listeners on trigger element events */
    _refreshTriggerListeners(): void;
    /**
     * Updates trigger element and refreshes the listeners.
     * @param trigger Trigger element ref.
     */
    updateTriggerElement(trigger: ElementRef | HTMLElement): void;
    /**
     * @hidden
     * Safely sets isOpen signal, deferring if called during Angular's render cycle.
     * This prevents NG0600 errors when focus events fire during template evaluation.
     */
    private _safeSetIsOpen;
    /** @hidden Whether the current triggers include mouseenter or mouseleave. */
    private _hasHoverTriggers;
    /** @hidden Clears any pending delayed hover close. */
    private _clearHoverCloseTimer;
    /** @hidden Schedules a delayed close to allow mouse to travel from trigger to overlay body. */
    private _scheduleHoverClose;
    /** @hidden Adds mouseenter/mouseleave listeners on the overlay element when hover triggers are active. */
    private _setupOverlayHoverListeners;
    /** @hidden Removes overlay hover listeners. */
    private _removeOverlayHoverListeners;
    /** @hidden */
    private _normalizeTriggers;
    /** @hidden */
    private _getOverlayConfig;
    /** @hidden */
    private _listenOnResize;
    /** @hidden */
    private _getDirection;
    /** @hidden */
    private _getPositionStrategy;
    /** remove listeners from trigger element events */
    private _removeTriggerListeners;
    private _addModalOverlay;
    private _removeOverlay;
    /** Attach template containing popover body to overlay */
    private _attachTemplate;
    /** Create PopoverBodyComponent and attach it into overlay */
    private _attachBodyComponent;
    /** @hidden */
    private _listenForPositionChange;
    /** Subscribe to close events from CDK Overlay, to throw proper events, change values */
    private _listenOnClose;
    /** Listener for click events */
    private _outsideClicks$;
    /** Listener for Escape keydown via CDK overlay's document-level keyboard dispatcher. */
    private _escapeKeydowns$;
    /** @hidden */
    private _shouldClose;
    /** @hidden */
    private _targetIsPopoverMobileDialog;
    /** @hidden */
    private _getEventTarget;
    /** @hidden */
    private _triggerContainsTarget;
    /** @hidden */
    private _getPositions;
    /** @hidden */
    private _applyWidthOverlay;
    /** @hidden */
    private _passVariablesToBody;
    /** @hidden */
    private _getTriggerWidth;
    /** @hidden */
    private _getPopoverBody;
    /** @hidden */
    private _focusFirstTabbableElement;
    /** @hidden */
    private _focusLastActiveElementBeforeOpen;
    /**
     * @hidden
     * Starts a MutationObserver on the nearest scrollable ancestor of the trigger element (falling
     * back to document.body) to detect layout shifts that would invalidate the overlay position.
     * Two mutation types are observed within the subtree:
     *  - `childList`: catches elements being added to or removed from the DOM (e.g. a banner/toast
     *    that is fully removed after its timer expires).
     *  - `attributes` with `attributeFilter: ['style', 'class']`: catches visibility toggling via
     *    CSS (e.g. `display: none` applied inline or through a utility class, as the
     *    `fd-message-strip` autoDismiss directive does).
     * The callback is debounced through `requestAnimationFrame` so that rapid batched mutations
     * (Angular rendering a whole subtree at once) only trigger a single `updatePosition()` call.
     */
    private _startAncestorResizeObserver;
    /**
     * @hidden
     * Returns the nearest scrollable ancestor, or document.body when none is found.
     */
    private _findScrollableAncestor;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PopoverService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PopoverService>;
}

declare class PopoverTriggerDirective implements OnDestroy {
    private _elementRef;
    /** Set reference to Popover Component */
    set popover(popover: Nullable<PopoverComponent>);
    /** @hidden */
    ariaHasPopup: Nullable<boolean>;
    /** @hidden */
    ariaControls: Nullable<string>;
    /** @hidden */
    ariaExpanded: Nullable<boolean>;
    /** @hidden */
    private _isExpandedSubscription;
    /** @hidden */
    private readonly _injector;
    /** @hidden */
    constructor(_elementRef: ElementRef);
    /** @hidden */
    ngOnDestroy(): void;
    /** @hidden */
    private _listenOnExpanded;
    /** @hidden */
    private _setAriaAttributes;
    /** @hidden */
    private _unsubscribeExpandedListener;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PopoverTriggerDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<PopoverTriggerDirective, "[fdPopoverTrigger], [fd-popover-trigger]", never, { "popover": { "alias": "fdPopoverTrigger"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class PopoverModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PopoverModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<PopoverModule, never, [typeof PopoverControlComponent, typeof PopoverBodyComponent, typeof PopoverBodyHeaderDirective, typeof PopoverBodyFooterDirective, typeof PopoverComponent, typeof PopoverTriggerDirective, typeof PopoverContainerDirective, typeof PopoverBodyDirective], [typeof PopoverControlComponent, typeof PopoverBodyComponent, typeof PopoverBodyHeaderDirective, typeof PopoverBodyFooterDirective, typeof PopoverComponent, typeof PopoverTriggerDirective, typeof PopoverContainerDirective, typeof PopoverBodyDirective]>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<PopoverModule>;
}

declare const FD_POPOVER_COMPONENT: InjectionToken<unknown>;

/**
 * Maps each PopoverConfig property to a signal accessor.
 * Components pass their input signals (or inline lambdas for fixed values).
 * All properties are optional — components only provide what they declare.
 */
type PopoverConfigSignals = {
    [K in keyof PopoverConfig]?: () => PopoverConfig[K];
};
/**
 * Builds a computed PopoverConfig from individual signal accessors.
 * Reads all provided accessors reactively and assembles a config object.
 *
 * @example
 * ```typescript
 * readonly popoverConfig = buildPopoverConfig({
 *     placement: () => this.placement() ?? 'bottom',
 *     triggers: this.triggers,
 *     disabled: this.disabled,
 * });
 * ```
 */
declare function buildPopoverConfig(signals: PopoverConfigSignals): Signal<PopoverConfig>;

export { BasePopoverClass, FD_POPOVER_COMPONENT, POPOVER_COMPONENT, PopoverBodyComponent, PopoverBodyDirective, PopoverBodyFooterDirective, PopoverBodyHeaderDirective, PopoverComponent, PopoverContainerDirective, PopoverControlComponent, PopoverMobileComponent, PopoverMobileModule, PopoverModule, PopoverService, PopoverTriggerDirective, SELECT_CLASS_NAMES, buildPopoverConfig };
export type { PopoverBodyRole, PopoverChildContent, PopoverConfig, PopoverConfigSignals, PopoverInterface, PopoverTemplate, TriggerConfig };
