import { EventEmitter } from '../../stencil-public-runtime';
import { ElementReference } from '../utils/element-reference';
import { FocusTrapOptions } from '../utils/focus/focus-trap';
import { CloseBehavior, DropdownInterface } from './dropdown-controller';
import { AlignedPlacement } from './placement';
declare const Dropdown_base: abstract new (...args: any[]) => {
    componentDidLoad(): void;
    disconnectedCallback(): void;
    hostElement?: import("@stencil/core/internal").HTMLStencilElement;
    connectedCallback?(): void;
    componentWillRender?(): Promise<void> | void;
    componentDidRender?(): void;
    componentWillLoad?(): Promise<void> | void;
    componentShouldUpdate?(newVal: any, oldVal: any, propName: string): boolean | void;
    componentWillUpdate?(): Promise<void> | void;
    componentDidUpdate?(): void;
    render?(): any;
} & import("../utils/internal/component").StencilLifecycle;
export declare class Dropdown extends Dropdown_base implements DropdownInterface {
    hostElement: HTMLIxDropdownElement;
    /**
     * Suppress the automatic placement of the dropdown.
     */
    suppressAutomaticPlacement: boolean;
    /**
     * Show dropdown
     */
    show: boolean;
    /**
     * Define an element that triggers the dropdown.
     * A trigger can either be a string that will be interpreted as id attribute or a DOM element.
     */
    trigger?: ElementReference;
    /**
     * Define an anchor element
     */
    anchor?: ElementReference;
    /**
     * Controls if the dropdown will be closed in response to a click event depending on the position of the event relative to the dropdown.
     * If the dropdown is a child of another one, it will be closed with the parent, regardless of its own close behavior.
     */
    closeBehavior: CloseBehavior;
    /**
     * Placement of the dropdown
     */
    placement: AlignedPlacement;
    /**
     * Position strategy
     */
    positioningStrategy: 'absolute' | 'fixed';
    /**
     * An optional header shown at the top of the dropdown
     */
    header?: string;
    /**
     * By default the dropdown gets closed if the trigger is not visible anymore (e.g. due to scrolling). Setting this property prevents that behavior.
     *
     * @since 5.0.0
     */
    suppressTriggerVisibilityCheck: boolean;
    /**
     * Suppress automatic focus when the dropdown is shown
     *
     * @since 4.3.0
     */
    disableFocusHandling: boolean;
    /**
     * Close dropdown when tabbing away, and do not trap focus inside dropdown
     *
     * @since 4.3.0
     */
    disableFocusTrap: boolean;
    /**
     * Enable Popover API rendering for top-layer positioning.
     *
     * @default false in v5.x, will default to true in v6.0.0
     * @since 4.3.0
     */
    enableTopLayer: boolean;
    /**
     * If true, the dropdown will try to focus checked items first when opened via keyboard, otherwise it will always focus the first focusable item.
     *
     * @since 5.0.0
     */
    focusCheckedItem: boolean;
    /**
     * Keys that will open the dropdown when the trigger is focused
     *
     * @internal
     */
    keyboardActivationKeys: string[];
    /**
     * Keys that will open the dropdown when the trigger is focused
     *
     * @internal
     */
    keyboardItemTriggerKeys: string[];
    /**
     * Move dropdown along main axis of alignment
     *
     * @internal
     */
    offset?: {
        mainAxis?: number;
        crossAxis?: number;
        alignmentAxis?: number;
    };
    /**
     * @internal
     */
    overwriteDropdownStyle?: (delegate: {
        dropdownRef: HTMLElement;
        triggerRef?: HTMLElement;
    }) => Promise<Partial<CSSStyleDeclaration>>;
    /**
     * @internal
     * If initialization of this dropdown is expected to be deferred submenu discovery will have to be re-run globally by the controller.
     * This property indicates the need for that to the controller.
     */
    discoverAllSubmenus: boolean;
    /** @internal */
    ignoreRelatedSubmenu: boolean;
    /** @internal */
    suppressOverflowBehavior: boolean;
    /** @internal */
    focusHost?: HTMLElement;
    /** @internal */
    focusTrapOptions?: FocusTrapOptions;
    /** @internal */
    hostRole?: string;
    /**
     * @internal
     * Called instead of the default focus-on-open logic when the dropdown is
     * opened via keyboard. When not set, default behavior is used.
     */
    callbackFocusElement?: (event: KeyboardEvent) => Promise<boolean | undefined>;
    /**
     * Fire event before visibility of dropdown has changed, preventing event will cancel showing dropdown
     */
    showChange: EventEmitter<boolean>;
    /**
     * Fire event after visibility of dropdown has changed
     */
    showChanged: EventEmitter<boolean>;
    fallbackPlacement?: AlignedPlacement;
    /**
     * Will be fired only after dropdown changed visibility to "true"
     *
     * @internal
     */
    experimentalRequestFocus: EventEmitter<{
        keyEvent: KeyboardEvent;
    }>;
    /**
     * @internal
     */
    experimentalFocusNextElement: EventEmitter<void>;
    private autoUpdateCleanup?;
    private readonly dialogRef;
    private intersectObserverTrigger?;
    private triggerElement?;
    private anchorElement?;
    private forwardQueryElement;
    private dropdownElementId;
    private assignedSubmenu;
    private keyboardNavigationCleanup?;
    private focusUtilities?;
    connectedCallback(): void;
    cacheSubmenuId(event: CustomEvent<string>): void;
    disconnectedCallback(): void;
    getAssignedSubmenuIds(): string[];
    isPresent(): boolean;
    present(): void;
    dismiss(): void;
    getId(): string;
    willDismiss(): boolean;
    willPresent(): boolean;
    get dropdownItems(): HTMLIxDropdownItemElement[];
    get slotElement(): HTMLSlotElement | null;
    private disposeClickListener?;
    private disposeKeyListener?;
    private toggleController;
    private readonly onTriggerClick;
    private handleTriggerClick;
    private readonly onTriggerKeydown;
    private handleTriggerKeydown;
    private addEventListenersFor;
    /** @internal */
    discoverSubmenu(): Promise<void>;
    private registerKeyListener;
    private registerListener;
    private addObserverForTriggerVisibility;
    private createFallbackPlacement;
    private resolveElement;
    private checkForSubmenuAnchor;
    private resolveAnchorElement;
    changedShow(newShow: boolean): Promise<void>;
    emitShowChanged(newShow: boolean): Promise<void>;
    changedTrigger(newTriggerValue: ElementReference, oldTriggerValue: ElementReference | undefined): void;
    private applyFallbackPosition;
    private hideDialog;
    private cleanupOnHide;
    private destroyAutoUpdate;
    private isAnchorSubmenu;
    private applyDropdownPosition;
    componentDidLoad(): Promise<void>;
    componentDidRender(): Promise<void>;
    private isTriggerElement;
    private onDropdownClick;
    /**
     * Update position of dropdown
     */
    updatePosition(): Promise<void>;
    openSubmenu(event: CustomEvent<{
        activeElement: HTMLElement;
    }>): void;
    closeSubmenu(): void;
    /**@internal */
    resetForwardQueryElement(): Promise<void>;
    render(): any;
}
export {};