/**
 * @fileoverview added by tsickle
 * Generated from: dropdown/dropdown.component.ts
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
/*!
 * Copyright 2020 VMware, Inc.
 * SPDX-License-Identifier: BSD-2-Clause
 */
import { Component, ElementRef, EventEmitter, HostListener, Input, Optional, Output, QueryList, Renderer2, SkipSelf, ViewChild, ViewChildren, } from '@angular/core';
import { ClrDropdown, ClrDropdownMenu, ClrDropdownTrigger } from '@clr/angular';
import { TextIcon } from '../common/interfaces';
import { TooltipSize } from '../lib/directives';
import { CommonUtil } from '../utils';
import { DropdownFocusHandlerService } from './dropdown-focus-handler.service';
/** @type {?} */
var NESTED_DROPDOWN_TRIGGER_SELECTOR = 'clr-dropdown clr-dropdown > button';
/** @type {?} */
var DROPDOWN_ITEM_SELECTOR = 'clr-dropdown-menu > button';
/** @type {?} */
export var NESTED_MENU_HIDE_DELAY = 400;
/**
 * @param {?} renderer
 * @param {?} existing
 * @return {?}
 */
export function dropdownFocusHandlerServiceFactory(renderer, existing) {
    return existing || new DropdownFocusHandlerService(renderer);
}
/** @type {?} */
export var DROPDOWN_FOCUS_HANDLER_PROVIDER = {
    provide: DropdownFocusHandlerService,
    useFactory: dropdownFocusHandlerServiceFactory,
    deps: [Renderer2, [new Optional(), new SkipSelf(), DropdownFocusHandlerService]],
};
/**
 * Component used for displaying nested drop downs
 */
var DropdownComponent = /** @class */ (function () {
    function DropdownComponent(parentVcdDropdown, focusHandler) {
        this.parentVcdDropdown = parentVcdDropdown;
        this.focusHandler = focusHandler;
        this._dropdownItemContents = TextIcon.TEXT;
        this.dropdownMenuUpdated = new EventEmitter();
        /**
         * If a icon should be displayed inside contextual buttons
         */
        this.shouldShowIcon = (TextIcon.ICON & this.dropdownItemContents) === TextIcon.ICON;
        /**
         * If a text should be displayed inside contextual buttons
         */
        this.shouldShowText = (TextIcon.TEXT & this.dropdownItemContents) === TextIcon.TEXT;
        /**
         * If the contextual buttons with icons should have a tooltip
         */
        this.shouldShowTooltip = this.dropdownItemContents === TextIcon.ICON;
        /**
         * Default configuration for vcdShowClippedText directive
         */
        this.clipTextConfig = {
            mouseoutDelay: 0,
            size: TooltipSize.md,
            disabled: false,
        };
        /**
         * Text Content of the button that opens the root dropdown when clicked
         */
        this.dropdownTriggerBtnTxt = 'vcd.cc.action.menu.other.actions';
        /**
         * Icon shown in the button that opens the root dropdown when clicked
         */
        this.dropdownTriggerBtnIcon = 'ellipsis-horizontal';
        /**
         * The position of all the nested dropdowns {\@link clrPosition}. Default is 'bottom-left'
         */
        this.nestedDropdownPosition = 'right-top';
        /**
         * Used for displaying different button contents in the root dropdown trigger button vs nested dropdown trigger button
         */
        this.isNestedDropdown = false;
    }
    Object.defineProperty(DropdownComponent.prototype, "dropdownItemContents", {
        get: /**
         * @return {?}
         */
        function () {
            return this._dropdownItemContents;
        },
        /**
         * Decides what goes into the action buttons
         * @param textIcon An enum that describes the possible ways to display the button title
         */
        set: /**
         * Decides what goes into the action buttons
         * @param {?} textIcon An enum that describes the possible ways to display the button title
         * @return {?}
         */
        function (textIcon) {
            this._dropdownItemContents = textIcon;
            this.shouldShowIcon = (TextIcon.ICON & textIcon) === TextIcon.ICON;
            this.shouldShowText = (TextIcon.TEXT & textIcon) === TextIcon.TEXT;
            this.shouldShowTooltip = textIcon === TextIcon.ICON;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(DropdownComponent.prototype, "items", {
        get: /**
         * @return {?}
         */
        function () {
            return this._items;
        },
        /**
         * Nested list of dropdown objects
         */
        set: /**
         * Nested list of dropdown objects
         * @param {?} items
         * @return {?}
         */
        function (items) {
            this._items = this.flattenNestedItemsWithSingleChild(items);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(DropdownComponent.prototype, "clrDropdownMenu", {
        set: /**
         * @param {?} val
         * @return {?}
         */
        function (val) {
            this._clrDropdownMenu = val;
            if (!val) {
                return;
            }
            // Disable Claritys focus handling logic
            this._clrDropdownMenu.items.reset([]);
            this._clrDropdownMenu.items.notifyOnChanges();
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(DropdownComponent.prototype, "dropdownTriggerEl", {
        set: /**
         * @param {?} val
         * @return {?}
         */
        function (val) {
            this._dropdownTriggerEl = val ? val.nativeElement : null;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(DropdownComponent.prototype, "clrDropdownMenuEl", {
        set: /**
         * @param {?} val
         * @return {?}
         */
        function (val) {
            if (!val) {
                this.dropdownMenuUpdated.emit(null);
                return;
            }
            this._clrDropdownMenuEl = val.nativeElement;
            this.dropdownMenuUpdated.emit({
                menu: this._clrDropdownMenuEl,
            });
        },
        enumerable: true,
        configurable: true
    });
    /**
     * @private
     * @param {?} items
     * @return {?}
     */
    DropdownComponent.prototype.flattenNestedItemsWithSingleChild = /**
     * @private
     * @param {?} items
     * @return {?}
     */
    function (items) {
        var _this = this;
        items.forEach((/**
         * @param {?} item
         * @return {?}
         */
        function (item) {
            // Flatten out the dropdowns with single children at each level of dropdown
            _this.flattenItemsWithSingleChild(items);
            if (item.children) {
                // Repeat the same for other nested levels
                _this.flattenNestedItemsWithSingleChild(item.children);
            }
        }));
        return items;
    };
    /**
     * @private
     * @param {?} items
     * @return {?}
     */
    DropdownComponent.prototype.flattenItemsWithSingleChild = /**
     * @private
     * @param {?} items
     * @return {?}
     */
    function (items) {
        /** @type {?} */
        var singleChildItemIndices = [];
        items.forEach((/**
         * @param {?} item
         * @param {?} index
         * @return {?}
         */
        function (item, index) {
            // Collect the indices of single child items
            if (item.children && item.children.length === 1) {
                singleChildItemIndices.push(index);
            }
        }));
        singleChildItemIndices.forEach((/**
         * @param {?} singleChildItemIndex
         * @return {?}
         */
        function (singleChildItemIndex) {
            // Delete them from the original list and add their children to the beginning of the current list
            /** @type {?} */
            var singleChildItem = items.splice(singleChildItemIndex, 1).pop();
            items.unshift(singleChildItem.children[0]);
        }));
    };
    /**
     * Nested menus are toggled using the mouseover and mouseout events instead of mouse clicks. So the claritys
     * click handler which conflicts with that is prevented from executing
     */
    /**
     * Nested menus are toggled using the mouseover and mouseout events instead of mouse clicks. So the claritys
     * click handler which conflicts with that is prevented from executing
     * @return {?}
     */
    DropdownComponent.prototype.ngAfterViewInit = /**
     * Nested menus are toggled using the mouseover and mouseout events instead of mouse clicks. So the claritys
     * click handler which conflicts with that is prevented from executing
     * @return {?}
     */
    function () {
        if (this.parentVcdDropdown) {
            this.clrDropdownTrigger.onDropdownTriggerClick = (/**
             * @param {?} event
             * @return {?}
             */
            function (event) {
                event.stopPropagation();
            });
        }
    };
    /**
     * To check in the HTML, if a dropdown item of separator type should be used to add a separator item in the dropdown
     * This is required because,
     * 1. As each item decides its own availability, some groups may become empty and we collapse separators before them
     * 2. A separator is not required if it is the first item in the dropdown list
     * @param index Position of the dropdown item in the dropdown list
     * @param currentItem The current item in the list that is being iterated over
     */
    /**
     * To check in the HTML, if a dropdown item of separator type should be used to add a separator item in the dropdown
     * This is required because,
     * 1. As each item decides its own availability, some groups may become empty and we collapse separators before them
     * 2. A separator is not required if it is the first item in the dropdown list
     * @param {?} index Position of the dropdown item in the dropdown list
     * @param {?} currentItem The current item in the list that is being iterated over
     * @return {?}
     */
    DropdownComponent.prototype.shouldRenderAsSeparator = /**
     * To check in the HTML, if a dropdown item of separator type should be used to add a separator item in the dropdown
     * This is required because,
     * 1. As each item decides its own availability, some groups may become empty and we collapse separators before them
     * 2. A separator is not required if it is the first item in the dropdown list
     * @param {?} index Position of the dropdown item in the dropdown list
     * @param {?} currentItem The current item in the list that is being iterated over
     * @return {?}
     */
    function (index, currentItem) {
        /** @type {?} */
        var nextItem = this.items[index + 1];
        return index > 0 && currentItem.isSeparator && !!nextItem && !nextItem.isSeparator;
    };
    /**
     * Handles the mouseover events on this dropdown's children that are of {@link #DROPDOWN_ITEM_SELECTOR} and
     * {@link #NESTED_DROPDOWN_TRIGGER_SELECTOR} type. When mouse is hovered on a child of type...
     * - DROPDOWN_ITEM_SELECTOR: Any open children of dropdown type have to be closed. This is because, user will always not mouse out of
     * a nested dropdown host(<vcd-dropdown>) to trigger the close event. He can move the mouse from nested dropdown's item to this
     * dropdown's item directly
     * - NESTED_DROPDOWN_TRIGGER_SELECTOR: Any open children of parent dropdown have to be closed and this dropdown has to be opened. We ask
     * the parent to close its children because, the mouse over events are not propagated upwards when hovered over a child of nested
     * dropdown type
     */
    /**
     * Handles the mouseover events on this dropdown's children that are of {\@link #DROPDOWN_ITEM_SELECTOR} and
     * {\@link #NESTED_DROPDOWN_TRIGGER_SELECTOR} type. When mouse is hovered on a child of type...
     * - DROPDOWN_ITEM_SELECTOR: Any open children of dropdown type have to be closed. This is because, user will always not mouse out of
     * a nested dropdown host(<vcd-dropdown>) to trigger the close event. He can move the mouse from nested dropdown's item to this
     * dropdown's item directly
     * - NESTED_DROPDOWN_TRIGGER_SELECTOR: Any open children of parent dropdown have to be closed and this dropdown has to be opened. We ask
     * the parent to close its children because, the mouse over events are not propagated upwards when hovered over a child of nested
     * dropdown type
     * @param {?} event
     * @return {?}
     */
    DropdownComponent.prototype.onMouseOver = /**
     * Handles the mouseover events on this dropdown's children that are of {\@link #DROPDOWN_ITEM_SELECTOR} and
     * {\@link #NESTED_DROPDOWN_TRIGGER_SELECTOR} type. When mouse is hovered on a child of type...
     * - DROPDOWN_ITEM_SELECTOR: Any open children of dropdown type have to be closed. This is because, user will always not mouse out of
     * a nested dropdown host(<vcd-dropdown>) to trigger the close event. He can move the mouse from nested dropdown's item to this
     * dropdown's item directly
     * - NESTED_DROPDOWN_TRIGGER_SELECTOR: Any open children of parent dropdown have to be closed and this dropdown has to be opened. We ask
     * the parent to close its children because, the mouse over events are not propagated upwards when hovered over a child of nested
     * dropdown type
     * @param {?} event
     * @return {?}
     */
    function (event) {
        event.stopPropagation();
        if (this.hideTimeout) {
            clearTimeout(this.hideTimeout);
        }
        /** @type {?} */
        var target = (/** @type {?} */ (event.target));
        if (target.matches(DROPDOWN_ITEM_SELECTOR)) {
            this.closeOpenVcdDropdownChildren();
        }
        if (target.matches(NESTED_DROPDOWN_TRIGGER_SELECTOR)) {
            if (this.parentVcdDropdown) {
                this.parentVcdDropdown.closeOpenVcdDropdownChildren();
            }
            this.clrDropdown.toggleService.open = true;
        }
    };
    /**
     * Handles the mouseout events on this dropdown's children that are of {@link #NESTED_DROPDOWN_TRIGGER_SELECTOR} type
     */
    /**
     * Handles the mouseout events on this dropdown's children that are of {\@link #NESTED_DROPDOWN_TRIGGER_SELECTOR} type
     * @param {?} event
     * @return {?}
     */
    DropdownComponent.prototype.onMouseOut = /**
     * Handles the mouseout events on this dropdown's children that are of {\@link #NESTED_DROPDOWN_TRIGGER_SELECTOR} type
     * @param {?} event
     * @return {?}
     */
    function (event) {
        var _this = this;
        event.stopPropagation();
        /** @type {?} */
        var target = (/** @type {?} */ (event.target));
        if (target.matches(NESTED_DROPDOWN_TRIGGER_SELECTOR)) {
            this.hideTimeout = window.setTimeout((/**
             * @return {?}
             */
            function () { return (_this.clrDropdown.toggleService.open = false); }), NESTED_MENU_HIDE_DELAY);
        }
    };
    /**
     * @private
     * @return {?}
     */
    DropdownComponent.prototype.closeOpenVcdDropdownChildren = /**
     * @private
     * @return {?}
     */
    function () {
        this.vcdDropdownChildren
            .filter((/**
         * @param {?} vcdDropdown
         * @return {?}
         */
        function (vcdDropdown) { return vcdDropdown.clrDropdown.toggleService.open; }))
            .forEach((/**
         * @param {?} vcdDropdown
         * @return {?}
         */
        function (vcdDropdown) { return (vcdDropdown.clrDropdown.toggleService.open = false); }));
    };
    /**
     * When space or enter key is pressed on the focused dropdown menu item, it has to be clicked
     * @param event Space or Enter key press event
     */
    /**
     * When space or enter key is pressed on the focused dropdown menu item, it has to be clicked
     * @param {?} event Space or Enter key press event
     * @return {?}
     */
    DropdownComponent.prototype.onDropdownItemActivated = /**
     * When space or enter key is pressed on the focused dropdown menu item, it has to be clicked
     * @param {?} event Space or Enter key press event
     * @return {?}
     */
    function (event) {
        event.stopPropagation();
        // We need to dispatch a click event instead of just calling the click handler because, Clarity listens to a
        // click event to close the menu after an item is activated
        event.target.dispatchEvent(new Event('click'));
    };
    /**
     * When space or enter is pressed on a nested trigger, the nested menu has to be opened. So, we trigger a mouseover event which opens
     * the nested menu
     * @param event Space or Enter key press event
     */
    /**
     * When space or enter is pressed on a nested trigger, the nested menu has to be opened. So, we trigger a mouseover event which opens
     * the nested menu
     * @param {?} event Space or Enter key press event
     * @return {?}
     */
    DropdownComponent.prototype.onDropdownTriggerActivated = /**
     * When space or enter is pressed on a nested trigger, the nested menu has to be opened. So, we trigger a mouseover event which opens
     * the nested menu
     * @param {?} event Space or Enter key press event
     * @return {?}
     */
    function (event) {
        // For the root dropdown, it is already being handled by Clarity
        if (!this.parentVcdDropdown) {
            return;
        }
        event.stopPropagation();
        event.target.dispatchEvent(new MouseEvent('mouseover', {
            view: window,
            bubbles: true,
            cancelable: true,
        }));
    };
    /**
     * We use [clrDisabled] instead of [disabled] to show that a dropdown item is disabled. However, it doesn't prevent the item from
     * getting activated when it is clicked. So, we make sure the action is not disabled before clicking it
     */
    /**
     * We use [clrDisabled] instead of [disabled] to show that a dropdown item is disabled. However, it doesn't prevent the item from
     * getting activated when it is clicked. So, we make sure the action is not disabled before clicking it
     * @param {?} item
     * @return {?}
     */
    DropdownComponent.prototype.onItemClicked = /**
     * We use [clrDisabled] instead of [disabled] to show that a dropdown item is disabled. However, it doesn't prevent the item from
     * getting activated when it is clicked. So, we make sure the action is not disabled before clicking it
     * @param {?} item
     * @return {?}
     */
    function (item) {
        if (this.isItemDisabled(item)) {
            return;
        }
        if (item.handler) {
            item.handler(this.selectedEntities, item.handlerData);
        }
    };
    /**
     * To visually disable a displayed action
     */
    /**
     * To visually disable a displayed action
     * @param {?} item
     * @return {?}
     */
    DropdownComponent.prototype.isItemDisabled = /**
     * To visually disable a displayed action
     * @param {?} item
     * @return {?}
     */
    function (item) {
        return (/** @type {?} */ ((CommonUtil.isFunction(item.disabled) ? item.disabled(this.selectedEntities) : item.disabled)));
    };
    /**
     * When an esc key is pressed on a dropdown item, the behavior should be same as pressing left arrow key on the item. This is
     * being handled here instead of inside the {@link DropdownFocusHandlerService} because, the escape event is being absorned by
     * Claritys focus handling logic before it reaches the service.
     */
    /**
     * When an esc key is pressed on a dropdown item, the behavior should be same as pressing left arrow key on the item. This is
     * being handled here instead of inside the {\@link DropdownFocusHandlerService} because, the escape event is being absorned by
     * Claritys focus handling logic before it reaches the service.
     * @param {?} event
     * @return {?}
     */
    DropdownComponent.prototype.onDropdownEscPressed = /**
     * When an esc key is pressed on a dropdown item, the behavior should be same as pressing left arrow key on the item. This is
     * being handled here instead of inside the {\@link DropdownFocusHandlerService} because, the escape event is being absorned by
     * Claritys focus handling logic before it reaches the service.
     * @param {?} event
     * @return {?}
     */
    function (event) {
        event.stopPropagation();
        this.focusHandler.escapePressed();
    };
    DropdownComponent.decorators = [
        { type: Component, args: [{
                    selector: 'vcd-dropdown',
                    template: "<clr-dropdown vcdDynamicDropdown class=\"nested-dropdown\">\n    <button\n        [ngClass]=\"[\n            dropdownTriggerBtnTxt ? 'btn btn-link' : '',\n            !isNestedDropdown ? 'first-dropdown-toggle' : '',\n            dropdownTriggerButtonClassName ? dropdownTriggerButtonClassName : ''\n        ]\"\n        clrDropdownTrigger\n        [vcdShowClippedText]=\"clipTextConfig\"\n        [disabled]=\"isDropdownDisabled\"\n        (keydown.enter)=\"onDropdownTriggerActivated($event)\"\n        (keydown.space)=\"onDropdownTriggerActivated($event)\"\n        (keydown.escape)=\"onDropdownEscPressed($event)\"\n    >\n        <ng-container *ngIf=\"dropdownTriggerBtnTxt\">\n            {{ dropdownTriggerBtnTxt }}\n            <clr-icon *ngIf=\"!isNestedDropdown\" shape=\"caret down\"></clr-icon>\n        </ng-container>\n        <clr-icon *ngIf=\"!dropdownTriggerBtnTxt\" [attr.shape]=\"dropdownTriggerBtnIcon\"></clr-icon>\n    </button>\n\n    <ng-container *ngIf=\"!isDropdownDisabled\">\n        <clr-dropdown-menu\n            class=\"nested-dropdown-menu\"\n            clrPosition=\"{{ isNestedDropdown ? nestedDropdownPosition : dropdownPosition }}\"\n            *clrIfOpen\n        >\n            <ng-container *ngFor=\"let item of items; let i = index; trackBy: trackByFunction\">\n                <div\n                    *ngIf=\"shouldRenderAsSeparator(i, item)\"\n                    class=\"dropdown-divider\"\n                    role=\"separator\"\n                    aria-hidden=\"true\"\n                ></div>\n\n                <ng-container *ngIf=\"!item.isSeparator && item.children && item.children.length\">\n                    <vcd-dropdown\n                        vcdDropdownFocusHandler\n                        [items]=\"item.children\"\n                        [selectedEntities]=\"selectedEntities\"\n                        [dropdownTriggerBtnTxt]=\"\n                            item.isTranslatable === false ? item.textKey : (item.textKey | translate)\n                        \"\n                        [dropdownTriggerButtonClassName]=\"item.class\"\n                        [nestedDropdownPosition]=\"nestedDropdownPosition\"\n                        [isNestedDropdown]=\"true\"\n                        [trackByFunction]=\"trackByFunction\"\n                        [dropdownItemContents]=\"dropdownItemContents\"\n                    ></vcd-dropdown>\n                </ng-container>\n\n                <ng-container *ngIf=\"!item.isSeparator && !item.children\">\n                    <button\n                        [ngClass]=\"[item.class ? item.class : '', shouldShowIcon ? 'btn-icon' : '', 'btn', 'btn-link']\"\n                        clrDropdownItem\n                        (click)=\"onItemClicked(item)\"\n                        (keydown.enter)=\"onDropdownItemActivated($event)\"\n                        (keydown.space)=\"onDropdownItemActivated($event)\"\n                        (keydown.escape)=\"onDropdownEscPressed($event)\"\n                        [clrDisabled]=\"isItemDisabled(item)\"\n                    >\n                        <ng-container *ngIf=\"shouldShowText\">{{\n                            item.isTranslatable === false ? item.textKey : (item.textKey | translate)\n                        }}</ng-container>\n\n                        <a *ngIf=\"shouldShowIcon\" role=\"tooltip\" aria-haspopup=\"true\" class=\"tooltip tooltip-sm\">\n                            <clr-icon size=\"1em\" [attr.shape]=\"item.icon\"></clr-icon>\n                            <span class=\"tooltip-content\" *ngIf=\"shouldShowTooltip\">{{\n                                item.textKey | translate\n                            }}</span>\n                        </a>\n                    </button>\n                </ng-container>\n            </ng-container>\n        </clr-dropdown-menu>\n    </ng-container>\n</clr-dropdown>\n",
                    providers: [DROPDOWN_FOCUS_HANDLER_PROVIDER],
                    styles: [".nested-dropdown-menu ::ng-deep .nested-dropdown{display:block;white-space:nowrap;max-width:15rem}"]
                }] }
    ];
    /** @nocollapse */
    DropdownComponent.ctorParameters = function () { return [
        { type: DropdownComponent, decorators: [{ type: Optional }, { type: SkipSelf }] },
        { type: DropdownFocusHandlerService }
    ]; };
    DropdownComponent.propDecorators = {
        dropdownItemContents: [{ type: Input }],
        items: [{ type: Input }],
        dropdownMenuUpdated: [{ type: Output }],
        clrDropdownMenu: [{ type: ViewChild, args: [ClrDropdownMenu,] }],
        dropdownTriggerEl: [{ type: ViewChild, args: [ClrDropdownTrigger, { read: ElementRef, static: true },] }],
        clrDropdownMenuEl: [{ type: ViewChild, args: [ClrDropdownMenu, { read: ElementRef, static: false },] }],
        dropdownTriggerBtnTxt: [{ type: Input }],
        dropdownTriggerBtnIcon: [{ type: Input }],
        trackByFunction: [{ type: Input }],
        dropdownPosition: [{ type: Input }],
        nestedDropdownPosition: [{ type: Input }],
        selectedEntities: [{ type: Input }],
        isNestedDropdown: [{ type: Input }],
        isDropdownDisabled: [{ type: Input }],
        dropdownTriggerButtonClassName: [{ type: Input }],
        clrDropdown: [{ type: ViewChild, args: [ClrDropdown,] }],
        clrDropdownTrigger: [{ type: ViewChild, args: [ClrDropdownTrigger,] }],
        vcdDropdownChildren: [{ type: ViewChildren, args: [DropdownComponent,] }],
        onMouseOver: [{ type: HostListener, args: ['mouseover', ['$event'],] }],
        onMouseOut: [{ type: HostListener, args: ['mouseout', ['$event'],] }]
    };
    return DropdownComponent;
}());
export { DropdownComponent };
if (false) {
    /**
     * @type {?}
     * @private
     */
    DropdownComponent.prototype._dropdownItemContents;
    /**
     * @type {?}
     * @private
     */
    DropdownComponent.prototype._items;
    /** @type {?} */
    DropdownComponent.prototype.dropdownMenuUpdated;
    /**
     * @type {?}
     * @private
     */
    DropdownComponent.prototype._clrDropdownMenu;
    /** @type {?} */
    DropdownComponent.prototype._dropdownTriggerEl;
    /** @type {?} */
    DropdownComponent.prototype._clrDropdownMenuEl;
    /**
     * If a icon should be displayed inside contextual buttons
     * @type {?}
     */
    DropdownComponent.prototype.shouldShowIcon;
    /**
     * If a text should be displayed inside contextual buttons
     * @type {?}
     */
    DropdownComponent.prototype.shouldShowText;
    /**
     * If the contextual buttons with icons should have a tooltip
     * @type {?}
     */
    DropdownComponent.prototype.shouldShowTooltip;
    /**
     * Default configuration for vcdShowClippedText directive
     * @type {?}
     */
    DropdownComponent.prototype.clipTextConfig;
    /**
     * Text Content of the button that opens the root dropdown when clicked
     * @type {?}
     */
    DropdownComponent.prototype.dropdownTriggerBtnTxt;
    /**
     * Icon shown in the button that opens the root dropdown when clicked
     * @type {?}
     */
    DropdownComponent.prototype.dropdownTriggerBtnIcon;
    /**
     * The {\@link ngForTrackBy} method used for rendering of a dropdown actions or for rendering nested drop downs
     * NOTE: Without this, nested drop downs don't get rendered on the screen
     * @type {?}
     */
    DropdownComponent.prototype.trackByFunction;
    /**
     * The position the root dropdown with respect to root dropdown trigger button. Refer to {\@link clrPosition} for it's values
     * @type {?}
     */
    DropdownComponent.prototype.dropdownPosition;
    /**
     * The position of all the nested dropdowns {\@link clrPosition}. Default is 'bottom-left'
     * @type {?}
     */
    DropdownComponent.prototype.nestedDropdownPosition;
    /**
     * Argument for {\@link ActionItem.handler} and {\@link ActionItem.disabled} methods. Please refer to
     * {\@link ActionMenuComponent.selectedEntities}
     * @type {?}
     */
    DropdownComponent.prototype.selectedEntities;
    /**
     * Used for displaying different button contents in the root dropdown trigger button vs nested dropdown trigger button
     * @type {?}
     */
    DropdownComponent.prototype.isNestedDropdown;
    /** @type {?} */
    DropdownComponent.prototype.isDropdownDisabled;
    /**
     * Css class name added to the dropdown trigger buttons
     * @type {?}
     */
    DropdownComponent.prototype.dropdownTriggerButtonClassName;
    /**
     * To toggle open and close states when hovered over
     * @type {?}
     */
    DropdownComponent.prototype.clrDropdown;
    /**
     * The button that opens this dropdown when clicked. Used for preventing the clarity frameworks click handler logic
     * from executing
     * @type {?}
     */
    DropdownComponent.prototype.clrDropdownTrigger;
    /**
     * List of nested dropdown children that belong to this dropdown. Used to close when a different child in this menu list is
     * hovered over
     * @type {?}
     */
    DropdownComponent.prototype.vcdDropdownChildren;
    /**
     * @type {?}
     * @private
     */
    DropdownComponent.prototype.hideTimeout;
    /**
     * @type {?}
     * @private
     */
    DropdownComponent.prototype.parentVcdDropdown;
    /**
     * @type {?}
     * @private
     */
    DropdownComponent.prototype.focusHandler;
}
//# sourceMappingURL=data:application/json;base64, 