import { ScrollStrategy, ConnectedPosition, ConnectionPositionPair, Overlay, ViewportRuler, CdkOverlayOrigin } from '@angular/cdk/overlay';
import * as i0 from '@angular/core';
import { ElementRef, EventEmitter, TemplateRef, AfterViewInit, ChangeDetectorRef, Renderer2, OnInit, AfterContentChecked, InjectionToken, OnDestroy, ViewContainerRef, Injector, AfterContentInit, OnChanges, SimpleChanges } from '@angular/core';
import { Nullable, RtlService, DynamicComponentService } from '@fundamental-ngx/cdk/utils';
import { Placement, PopoverFillMode } from '@fundamental-ngx/core/shared';
import { CdkTrapFocus } from '@angular/cdk/a11y';
import { Subject } from 'rxjs';
import { ContentDensityObserver } from '@fundamental-ngx/core/content-density';
import { ScrollbarDirective } from '@fundamental-ngx/core/scrollbar';
import { MobileMode, MobileModeBase, MobileModeConfig } from '@fundamental-ngx/core/mobile-mode';
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 BasePopoverClass {
    /** 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;
    /** Whether the popover container needs an extra class for styling. */
    additionalBodyClass: string | null;
    /** Classes that should be applied to fd-popover-body component directly. */
    additionalBodyComponentClasses: string | null;
    /** Whether the popover container needs an extra class for styling. */
    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.
     * 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: 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: (string | TriggerConfig)[];
    /** Whether the popover is open. Can be used through two-way binding. */
    isOpen: boolean;
    /** Whether the popover should close when a click is made outside its boundaries. */
    closeOnOutsideClick: boolean;
    /** Wether to apply a background overlay */
    applyOverlay: boolean;
    /** Whether the popover should be focusTrapped. */
    focusTrapped: boolean;
    /**
     * Whether the popover should automatically move focus into the trapped region upon
     * initialization and return focus to the previous activeElement upon destruction.
     */
    focusAutoCapture: boolean;
    /**
     * Whether to move the focus after popover is closed to the last focused element before popover was opened.
     */
    restoreFocusOnClose: boolean;
    /**
     * Scroll strategy, there are 4 accepted
     * - CloseScrollStrategy
     * - NoopScrollStrategy
     * - BlockScrollStrategy
     * - RepositionScrollStrategy ( default )
     */
    scrollStrategy: 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: 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: Nullable<PopoverFillMode>;
    /** The element to which  the overlay is attached. By default it is body */
    appendTo: Nullable<ElementRef | Element>;
    /** Placement of the popover element. */
    placementContainer: Nullable<ElementRef | Element>;
    /** Whether position shouldn't change, when popover approach the corner of page */
    fixedPosition: boolean;
    /** Whether the popover body is resizable. */
    resizable: boolean;
    /** Event emitted when the state of the isOpen property changes. */
    isOpenChange: EventEmitter<boolean>;
    /** Event emitted right before the popover is being opened.
     * Useful for cases when component inside popover body needs to be initialized right BEFORE the opening of the popover. */
    beforeOpen: EventEmitter<any>;
    /** @hidden Aria role for the popover body. */
    _bodyRole: string | null;
    /** @hidden ID for the popover body. */
    _bodyId: string | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<BasePopoverClass, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BasePopoverClass, never, never, { "closeOnNavigation": { "alias": "closeOnNavigation"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "maxWidth": { "alias": "maxWidth"; "required": false; }; "noArrow": { "alias": "noArrow"; "required": false; }; "additionalBodyClass": { "alias": "additionalBodyClass"; "required": false; }; "additionalBodyComponentClasses": { "alias": "additionalBodyComponentClasses"; "required": false; }; "additionalTriggerClass": { "alias": "additionalTriggerClass"; "required": false; }; "closeOnEscapeKey": { "alias": "closeOnEscapeKey"; "required": false; }; "disableScrollbar": { "alias": "disableScrollbar"; "required": false; }; "placement": { "alias": "placement"; "required": false; }; "triggers": { "alias": "triggers"; "required": false; }; "isOpen": { "alias": "isOpen"; "required": false; }; "closeOnOutsideClick": { "alias": "closeOnOutsideClick"; "required": false; }; "applyOverlay": { "alias": "applyOverlay"; "required": false; }; "focusTrapped": { "alias": "focusTrapped"; "required": false; }; "focusAutoCapture": { "alias": "focusAutoCapture"; "required": false; }; "restoreFocusOnClose": { "alias": "restoreFocusOnClose"; "required": false; }; "scrollStrategy": { "alias": "scrollStrategy"; "required": false; }; "cdkPositions": { "alias": "cdkPositions"; "required": false; }; "fillControlMode": { "alias": "fillControlMode"; "required": false; }; "appendTo": { "alias": "appendTo"; "required": false; }; "placementContainer": { "alias": "placementContainer"; "required": false; }; "fixedPosition": { "alias": "fixedPosition"; "required": false; }; "resizable": { "alias": "resizable"; "required": false; }; }, { "isOpenChange": "isOpenChange"; "beforeOpen": "beforeOpen"; }, never, never, true, never>;
}
/**
 * Config for the trigger event, which allows to specify
 * whether an event should apply both for open and close actions or only some of them
 */
interface TriggerConfig {
    trigger: string;
    openAction: boolean;
    closeAction: boolean;
    stopPropagation?: boolean;
}

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

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

declare class PopoverBodyHeaderDirective {
    /** @hidden */
    fdPopoverBodyHeaderClass: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<PopoverBodyHeaderDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<PopoverBodyHeaderDirective, "[fdPopoverBodyHeader], [fd-popover-body-header]", 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 implements AfterViewInit {
    readonly _elementRef: ElementRef;
    private _changeDetectorRef;
    private readonly _renderer;
    readonly _contentDensityObserver: ContentDensityObserver;
    /** Minimum width of the popover body element. */
    minWidth: Nullable<string>;
    /** Maximum width of the popover body element. */
    maxWidth: Nullable<string>;
    /** Minimum height of the popover body element. */
    minHeight: Nullable<string>;
    /** Maximum height of the popover body element. */
    maxHeight: Nullable<string>;
    /** @hidden */
    _cdkTrapFocus: CdkTrapFocus;
    /** @hidden */
    _scrollbar: ScrollbarDirective;
    /** Whether to wrap content with fd-scrollbar directive. */
    _disableScrollbar: boolean;
    /** Whether the popover should have an arrow. */
    _noArrow: boolean;
    /** Whether the popover container needs an extra class for styling. */
    _additionalBodyClass: Nullable<string>;
    /** Whether the popover should be focusTrapped. */
    _focusTrapped: boolean;
    /**
     * Whether the popover should automatically move focus into the trapped region upon
     * initialization and return focus to the previous activeElement upon destruction.
     */
    _focusAutoCapture: boolean;
    /** @hidden Property bind to popover's body. */
    _popoverBodyWidth: number;
    /** @hidden Property bind to popover's body. */
    _popoverBodyMinWidth: number;
    /** @hidden Property bind to popover's body. */
    _maxWidth: Nullable<number>;
    /** @hidden Property bind to popover's body. */
    _closeOnEscapeKey: boolean;
    /** @hidden Aria role for the popover body. */
    _bodyRole: Nullable<string>;
    /** @hidden Aria role for the popover body. */
    _bodyId: Nullable<string>;
    /** Classes added to arrow element. */
    _arrowClasses: string;
    /** @hidden text rendered inside popover's body. */
    text: Nullable<string>;
    /** @hidden template rendered inside popover's body. */
    _templateToDisplay: TemplateRef<any>;
    /** @hidden Whether the popover body is resizable. */
    _resizable: boolean;
    /** @hidden */
    _resizeHandleLocation: 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left';
    /** Close event from popover body */
    onClose: Subject<void>;
    /** @hidden */
    private _bodyComponentClasses;
    /** @hidden */
    constructor(_elementRef: ElementRef, _changeDetectorRef: ChangeDetectorRef, _renderer: Renderer2, _contentDensityObserver: ContentDensityObserver);
    /** Handler escape keydown */
    bodyKeyupHandler(event: KeyboardEvent): void;
    /** @hidden */
    ngAfterViewInit(): void;
    /** @hidden */
    _setBodyComponentClasses(classes: string | null): void;
    /** @hidden */
    _setArrowStyles(position: ConnectionPositionPair, rtl: 'rtl' | 'ltr'): void;
    /** @hidden */
    detectChanges(): void;
    /** @hidden */
    _focusFirstTabbableElement(forced?: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PopoverBodyComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PopoverBodyComponent, "fd-popover-body", never, { "minWidth": { "alias": "minWidth"; "required": false; }; "maxWidth": { "alias": "maxWidth"; "required": false; }; "minHeight": { "alias": "minHeight"; "required": false; }; "maxHeight": { "alias": "maxHeight"; "required": false; }; }, {}, never, ["[fd-popover-body-header]", "[fd-popover-body-subheader]", "*", "[fd-popover-body-footer]"], 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: i0.ɵɵFactoryDeclaration<PopoverContainerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<PopoverContainerDirective, "[fdPopoverContainer]", 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 PopoverControlComponent implements AfterContentChecked {
    elRef: ElementRef;
    /** @hidden */
    _tabbable: boolean;
    /** @hidden */
    constructor(elRef: ElementRef);
    /** @hidden */
    ngAfterContentChecked(): void;
    /** @hidden */
    makeTabbable(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PopoverControlComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PopoverControlComponent, "fd-popover-control, [fdPopoverControl]", 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;
    isOpenChange: EventEmitter<boolean>;
    close(): void;
}

declare class PopoverMobileComponent extends MobileModeBase<PopoverInterface> implements OnInit, OnDestroy {
    private _changeDetectorref;
    /** @hidden */
    _dialogTemplate: TemplateRef<any>;
    /** @hidden
     * from mobile class can not prefix _,
     * to avoid build issues
     */
    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 */
    private _subscriptions;
    /** @hidden */
    get titleId(): string;
    /** @hidden */
    constructor(_changeDetectorref: ChangeDetectorRef, _popoverComponent: PopoverInterface);
    /** @hidden */
    ngOnInit(): void;
    /** @hidden */
    ngOnDestroy(): void;
    /** Closes the Dialog and Popover component */
    close(): void;
    /** @hidden Opens/closes the Dialog based on Popover isOpenChange events */
    private _listenOnPopoverOpenChange;
    /** @hidden Opens the Dialog */
    private _openDialog;
    static ɵfac: i0.ɵɵFactoryDeclaration<PopoverMobileComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PopoverMobileComponent, "fd-popover-mobile", never, {}, {}, never, never, true, never>;
}

declare class PopoverMobileModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PopoverMobileModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PopoverMobileModule, never, [typeof i1.DialogModule, typeof i2.ButtonComponent, typeof PopoverMobileComponent], [typeof PopoverMobileComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PopoverMobileModule>;
}

interface PopoverTemplate {
    container: ViewContainerRef;
    popoverBody: PopoverBodyComponent;
    template: TemplateRef<any>;
}
declare class PopoverService extends BasePopoverClass {
    private _overlay;
    private _renderer;
    private _viewportRuler;
    private _injector;
    private _rtlService;
    private readonly _popoverContainer;
    /** 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 */
    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 _placementContainer;
    /** @hidden */
    private _ignoreTriggers;
    /** @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 get _triggerHtmlElement();
    /** @hidden */
    constructor(_overlay: Overlay, _renderer: Renderer2, _viewportRuler: ViewportRuler, _injector: Injector, _rtlService: RtlService, _popoverContainer: PopoverContainerDirective);
    /**
     * 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 - in this case the intention is to use inheritance of BasePopoverClass in component
     * - templateData - in case of having already PopoverBodyComponent, there is way to pass container, template containing
     *   PopoverComponent and PopoverComponent instance
     */
    initialise(triggerElement: ElementRef | HTMLElement, config?: BasePopoverClass, 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): 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: BasePopoverClass): 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 */
    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$;
    /** @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 _detectChanges;
    /** @hidden */
    private _focusFirstTabbableElement;
    /** @hidden */
    private _focusLastActiveElementBeforeOpen;
    static ɵfac: i0.ɵɵFactoryDeclaration<PopoverService, [null, null, null, null, { optional: true; }, { optional: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PopoverService>;
}

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 extends BasePopoverClass implements AfterViewInit, AfterContentInit, OnDestroy, OnChanges {
    private readonly _popoverService;
    private readonly _cdr;
    private readonly _rendered;
    private readonly _viewContainerRef;
    private readonly _injector;
    private readonly _dynamicComponentService;
    /** Tooltip for popover */
    title: string;
    /** Reference to popover trigger element */
    set trigger(trigger: ElementRef | HTMLElement);
    get trigger(): ElementRef | HTMLElement;
    /** Whether position shouldn't change, when popover approach the corner of page */
    fixedPosition: boolean;
    /** Id of the popover. If none is provided, one will be generated. */
    id: string;
    /** Whether the popover component should be displayed in mobile mode. */
    mobile: boolean;
    /** Config for the popover in mobile mode */
    mobileConfig: MobileModeConfig;
    /**
     * Whether the popover should prevent page scrolling when space key is pressed.
     **/
    preventSpaceKeyScroll: boolean;
    /** @hidden */
    templateRef: TemplateRef<any>;
    /** @hidden */
    container: ViewContainerRef;
    /** @hidden */
    triggerOrigin: CdkOverlayOrigin;
    /** @hidden */
    popoverBody: PopoverBodyComponent;
    /** @hidden */
    popoverBodyDirective: PopoverBodyDirective;
    /** @hidden */
    popoverControl: PopoverControlComponent;
    /** @hidden - template for Dialog body content */
    popoverBodyContentTemplate: TemplateRef<any>;
    /** @hidden - template for Dialog footer content */
    popoverFooterContentTemplate: TemplateRef<any>;
    /** @hidden */
    private get _triggerElement();
    /** @hidden */
    private _trigger;
    /** @hidden */
    private _clickEventListener;
    /** @hidden */
    private _mobileModeComponentRef;
    /** @hidden */
    constructor(_popoverService: PopoverService, _cdr: ChangeDetectorRef, _rendered: Renderer2, _viewContainerRef: ViewContainerRef, _injector: Injector, _dynamicComponentService: DynamicComponentService);
    /** Handler escape keydown */
    escapeKeydownHandler(event: KeyboardEvent): void;
    /** @hidden */
    onKeyDown(event: KeyboardEvent): void;
    /** @hidden */
    ngAfterViewInit(): void;
    /** @hidden */
    ngAfterContentInit(): void;
    /** @hidden */
    ngOnChanges(changes: SimpleChanges): 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;
    /** @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: i0.ɵɵFactoryDeclaration<PopoverComponent, [null, null, null, null, null, { optional: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PopoverComponent, "fd-popover", never, { "title": { "alias": "title"; "required": false; }; "trigger": { "alias": "trigger"; "required": false; }; "fixedPosition": { "alias": "fixedPosition"; "required": false; }; "id": { "alias": "id"; "required": false; }; "mobile": { "alias": "mobile"; "required": false; }; "mobileConfig": { "alias": "mobileConfig"; "required": false; }; "preventSpaceKeyScroll": { "alias": "preventSpaceKeyScroll"; "required": false; }; }, {}, ["popoverBody", "popoverBodyDirective", "popoverControl", "popoverBodyContentTemplate", "popoverFooterContentTemplate"], ["fd-popover-control, [fdPopoverControl]", "fd-popover-body", "*"], true, never>;
}

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 */
    constructor(_elementRef: ElementRef);
    /** @hidden */
    ngOnDestroy(): void;
    /** @hidden */
    private _listenOnExpanded;
    /** @hidden */
    private _setAriaAttributes;
    /** @hidden */
    private _unsubscribeExpandedListener;
    static ɵfac: i0.ɵɵFactoryDeclaration<PopoverTriggerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<PopoverTriggerDirective, "[fdPopoverTrigger], [fd-popover-trigger]", never, { "popover": { "alias": "fdPopoverTrigger"; "required": false; }; }, {}, never, never, true, never>;
}

declare class PopoverModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PopoverModule, never>;
    static ɵmod: i0.ɵɵ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: i0.ɵɵInjectorDeclaration<PopoverModule>;
}

declare const FD_POPOVER_COMPONENT: InjectionToken<unknown>;

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