@rossigee/clarity-angular 18.2.1-fixed.1 → 18.2.1

package/types/clr-angular-modal.d.ts

@@ -0,0 +1,160 @@
+import { AnimationEvent } from '@angular/animations';
+import * as i0 from '@angular/core';
+import { OnChanges, OnDestroy, ElementRef, EventEmitter, TemplateRef, SimpleChange, Renderer2, NgZone, Type, OnInit } from '@angular/core';
+import * as i5 from '@clr/angular/utils';
+import { ClrCommonStringsService, ScrollingService } from '@clr/angular/utils';
+import * as i4 from '@angular/common';
+import * as i6 from '@clr/angular/icon';
+
+declare class ClrModalConfigurationService {
+    fadeMove: string;
+    backdrop: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrModalConfigurationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ClrModalConfigurationService>;
+}
+
+interface Closable {
+    close(): void;
+}
+declare class ModalStackService {
+    private readonly platformId;
+    private readonly modalStack;
+    private readonly keyUpEventListener;
+    constructor(platformId: unknown);
+    trackModalOpen(openedModal: Closable): void;
+    trackModalClose(closedModal: Closable): void;
+    private onKeyUp;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModalStackService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ModalStackService>;
+}
+
+declare class ClrModal implements OnChanges, OnDestroy {
+    private _scrollingService;
+    commonStrings: ClrCommonStringsService;
+    private modalStackService;
+    private configuration;
+    modalId: string;
+    title: ElementRef<HTMLElement>;
+    _open: boolean;
+    _openChanged: EventEmitter<boolean>;
+    closable: boolean;
+    closeButtonAriaLabel: string;
+    size: string;
+    staticBackdrop: boolean;
+    skipAnimation: boolean;
+    stopClose: boolean;
+    altClose: EventEmitter<boolean>;
+    labelledBy: string;
+    bypassScrollService: boolean;
+    protected readonly modalContentTemplate: TemplateRef<any>;
+    private readonly bodyElementRef;
+    constructor(_scrollingService: ScrollingService, commonStrings: ClrCommonStringsService, modalStackService: ModalStackService, configuration: ClrModalConfigurationService);
+    get fadeMove(): string;
+    set fadeMove(move: string);
+    get backdrop(): boolean;
+    ngOnChanges(changes: {
+        [propName: string]: SimpleChange;
+    }): void;
+    ngOnDestroy(): void;
+    open(): void;
+    backdropClick(): void;
+    close(): void;
+    fadeDone(e: AnimationEvent): void;
+    scrollTop(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrModal, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrModal, "clr-modal", never, { "_open": { "alias": "clrModalOpen"; "required": false; }; "closable": { "alias": "clrModalClosable"; "required": false; }; "closeButtonAriaLabel": { "alias": "clrModalCloseButtonAriaLabel"; "required": false; }; "size": { "alias": "clrModalSize"; "required": false; }; "staticBackdrop": { "alias": "clrModalStaticBackdrop"; "required": false; }; "skipAnimation": { "alias": "clrModalSkipAnimation"; "required": false; }; "stopClose": { "alias": "clrModalPreventClose"; "required": false; }; "labelledBy": { "alias": "clrModalLabelledById"; "required": false; }; "bypassScrollService": { "alias": "clrModalOverrideScrollService"; "required": false; }; }, { "_openChanged": "clrModalOpenChange"; "altClose": "clrModalAlternateClose"; }, ["modalContentTemplate"], [".leading-button", ".modal-title", ".modal-body", ".modal-footer"], false, never>;
+}
+
+/**
+ * Allows modal overflow area to be scrollable via keyboard.
+ * The modal body will focus with keyboard navigation only.
+ * This allows inner focusable items to be focused without
+ * the overflow scroll being focused.
+ */
+declare class ClrModalBody implements OnDestroy {
+    private readonly renderer;
+    private readonly host;
+    private tabindex;
+    private unlisteners;
+    private observer;
+    constructor(renderer: Renderer2, host: ElementRef<HTMLElement>, ngZone: NgZone);
+    ngOnDestroy(): void;
+    private addTabIndex;
+    private removeTabIndex;
+    private addOrRemoveTabIndex;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrModalBody, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClrModalBody, ".modal-body", never, {}, {}, never, never, false, never>;
+}
+
+declare class ClrModalHostComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrModalHostComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrModalHostComponent, "[clrModalHost]", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare const CLR_MODAL_DIRECTIVES: Type<any>[];
+declare class ClrModalModule {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrModalModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ClrModalModule, [typeof ClrModal, typeof ClrModalBody, typeof ClrModalHostComponent], [typeof i4.CommonModule, typeof i5.CdkTrapFocusModule, typeof i6.ClrIcon], [typeof ClrModal, typeof ClrModalBody, typeof ClrModalHostComponent, typeof i6.ClrIcon]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ClrModalModule>;
+}
+
+declare class ClrSidePanel implements OnInit, OnDestroy {
+    private element;
+    private configuration;
+    commonStrings: ClrCommonStringsService;
+    openChange: EventEmitter<boolean>;
+    closeButtonAriaLabel: string | undefined;
+    skipAnimation: boolean;
+    labelledById: string;
+    staticBackdrop: boolean;
+    closable: boolean;
+    preventClose: boolean;
+    altClose: EventEmitter<boolean>;
+    private _pinnable;
+    private _pinned;
+    private originalStopClose;
+    private _position;
+    private _modal;
+    private __open;
+    private _size;
+    constructor(element: ElementRef<HTMLElement>, configuration: ClrModalConfigurationService, commonStrings: ClrCommonStringsService);
+    get _open(): boolean;
+    set _open(open: boolean);
+    get size(): string;
+    set size(value: string);
+    get position(): string;
+    set position(position: string);
+    get pinned(): boolean;
+    set pinned(pinned: boolean);
+    get clrSidePanelBackdrop(): boolean;
+    set clrSidePanelBackdrop(backdrop: boolean);
+    get clrSidePanelPinnable(): boolean;
+    set clrSidePanelPinnable(pinnable: boolean);
+    private get modal();
+    private set modal(value);
+    private get hostElement();
+    private get bottomPositionCssClass();
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    handleModalOpen(open: boolean): void;
+    open(): void;
+    close(): void;
+    togglePinned(): void;
+    private documentClick;
+    private updateModalState;
+    private cleanupPinnedClasses;
+    private updatePinnedClasses;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrSidePanel, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrSidePanel, "clr-side-panel", never, { "closeButtonAriaLabel": { "alias": "clrSidePanelCloseButtonAriaLabel"; "required": false; }; "skipAnimation": { "alias": "clrSidePanelSkipAnimation"; "required": false; }; "labelledById": { "alias": "clrSidePanelLabelledById"; "required": false; }; "staticBackdrop": { "alias": "clrSidePanelStaticBackdrop"; "required": false; }; "closable": { "alias": "clrSidePanelClosable"; "required": false; }; "preventClose": { "alias": "clrSidePanelPreventClose"; "required": false; }; "_open": { "alias": "clrSidePanelOpen"; "required": false; }; "size": { "alias": "clrSidePanelSize"; "required": false; }; "position": { "alias": "clrSidePanelPosition"; "required": false; }; "pinned": { "alias": "clrSidePanelPinned"; "required": false; }; "clrSidePanelBackdrop": { "alias": "clrSidePanelBackdrop"; "required": false; }; "clrSidePanelPinnable": { "alias": "clrSidePanelPinnable"; "required": false; }; }, { "openChange": "clrSidePanelOpenChange"; "altClose": "clrSidePanelAlternateClose"; }, never, [".side-panel-title", ".side-panel-body", ".side-panel-footer"], false, never>;
+}
+
+declare const CLR_SIDEPANEL_DIRECTIVES: Type<any>[];
+declare class ClrSidePanelModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrSidePanelModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ClrSidePanelModule, [typeof ClrSidePanel], [typeof i4.CommonModule, typeof i5.CdkTrapFocusModule, typeof i6.ClrIcon, typeof ClrModalModule], [typeof ClrSidePanel, typeof ClrModalModule, typeof i6.ClrIcon]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ClrSidePanelModule>;
+}
+
+export { CLR_MODAL_DIRECTIVES, CLR_SIDEPANEL_DIRECTIVES, ClrModal, ClrModalBody, ClrModalConfigurationService, ClrModalHostComponent, ClrModalModule, ClrSidePanel, ClrSidePanelModule, ModalStackService };
+export type { Closable };

package/types/clr-angular-popover-common.d.ts

@@ -0,0 +1,254 @@
+import { ConnectedPosition, FlexibleConnectedPositionStrategyOrigin, OverlayContainer, Overlay } from '@angular/cdk/overlay';
+import * as i0 from '@angular/core';
+import { ElementRef, OnDestroy, AfterViewInit, ViewContainerRef, TemplateRef, NgZone, OnInit, InjectionToken, EventEmitter } from '@angular/core';
+import { Observable } from 'rxjs';
+import { ClrPosition } from '@clr/angular/utils';
+
+declare enum ClrPopoverType {
+    SIGNPOST = 0,
+    TOOLTIP = 1,
+    DROPDOWN = 2,
+    DEFAULT = 3
+}
+declare enum ClrPopoverPosition {
+    TOP_RIGHT = "top-right",
+    TOP_MIDDLE = "top-middle",
+    TOP_LEFT = "top-left",
+    RIGHT = "right",
+    RIGHT_TOP = "right-top",
+    RIGHT_MIDDLE = "right-middle",
+    RIGHT_BOTTOM = "right-bottom",
+    LEFT = "left",
+    LEFT_TOP = "left-top",
+    LEFT_MIDDLE = "left-middle",
+    LEFT_BOTTOM = "left-bottom",
+    BOTTOM_RIGHT = "bottom-right",
+    BOTTOM_MIDDLE = "bottom-middle",
+    BOTTOM_LEFT = "bottom-left"
+}
+declare const TOOLTIP_POSITIONS: ClrPopoverPosition[];
+declare const DROPDOWN_POSITIONS: ClrPopoverPosition[];
+declare const SIGNPOST_POSITIONS: ClrPopoverPosition[];
+declare function getPositionsArray(type: ClrPopoverType): ClrPopoverPosition[];
+declare function getConnectedPositions(type: ClrPopoverType): ConnectedPosition[];
+declare function mapPopoverKeyToPosition(key: ClrPopoverPosition, type: ClrPopoverType): ConnectedPosition;
+declare function getOriginPosition(key: ClrPosition): Partial<ConnectedPosition>;
+declare function getContentPosition(key: ClrPosition): Partial<ConnectedPosition>;
+
+interface ClrPopoverPoint {
+    x: number;
+    y: number;
+}
+declare class ClrPopoverService {
+    pointTargetElement: HTMLElement | undefined;
+    origin: FlexibleConnectedPositionStrategyOrigin;
+    closeButtonRef: ElementRef;
+    panelClass: string[];
+    private _open;
+    private _openChange;
+    private _openEvent;
+    private _openEventChange;
+    private _positionChange;
+    private _resetPositions;
+    private _updatePosition;
+    private _popoverVisible;
+    get originElement(): ElementRef<HTMLElement> | null;
+    get originPoint(): ClrPopoverPoint | null;
+    get openChange(): Observable<boolean>;
+    get popoverVisible(): Observable<boolean>;
+    get openEvent(): Event;
+    set openEvent(event: Event);
+    get open(): boolean;
+    set open(value: boolean);
+    get resetPositionsChange(): Observable<void>;
+    positionChange(position: ClrPopoverPosition): void;
+    updatePositionChange(): Observable<void>;
+    getPositionChange(): Observable<string>;
+    getEventChange(): Observable<Event>;
+    /**
+     * Sometimes, we need to remember the event that triggered the toggling to avoid loops.
+     * This is for instance the case of components that open on a click, but close on a click outside.
+     */
+    toggleWithEvent(event: any): void;
+    /**
+     * Opens the popover at a specific screen coordinate.
+     * Useful for context menus where the popover should appear at the cursor position.
+     */
+    openAtPoint(point: ClrPopoverPoint, targetElement?: HTMLElement): void;
+    popoverVisibleEmit(visible: boolean): void;
+    resetPositions(): void;
+    updatePosition(): void;
+    focusCloseButton(): void;
+    focusOrigin(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrPopoverService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ClrPopoverService>;
+}
+
+/** @dynamic */
+declare class ClrPopoverContent implements OnDestroy, AfterViewInit {
+    private container;
+    private template;
+    private parent;
+    private overlay;
+    private popoverService;
+    private zone;
+    private platformId;
+    private _outsideClickClose;
+    private _scrollToClose;
+    private view;
+    private elementRef;
+    private overlayRef;
+    private popoverType;
+    private _availablePositions;
+    private _position;
+    private subscriptions;
+    private openCloseSubscription;
+    private domPortal;
+    private preferredPositionIsSet;
+    private availablePositionsAreSet;
+    private _preferredPosition;
+    private intersectionObserver;
+    constructor(element: ElementRef, container: ViewContainerRef, template: TemplateRef<any>, overlayContainer: OverlayContainer, parent: ClrPopoverContent, overlay: Overlay, popoverService: ClrPopoverService, zone: NgZone, platformId: any);
+    set open(value: boolean);
+    get contentAt(): string | ClrPopoverPosition | ConnectedPosition;
+    set contentAt(position: string | ClrPopoverPosition | ConnectedPosition);
+    set availablePositions(positions: ConnectedPosition[]);
+    set contentType(type: ClrPopoverType);
+    get outsideClickClose(): boolean;
+    set outsideClickClose(clickToClose: boolean);
+    get scrollToClose(): boolean;
+    set scrollToClose(scrollToClose: boolean);
+    set contentOrigin(origin: FlexibleConnectedPositionStrategyOrigin);
+    private get positionStrategy();
+    private get preferredPosition();
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private _createOverlayRef;
+    /**
+     * Point-based origins (context menus) delay the subscription to avoid the
+     * mouseup from the same right-click that opened the popover.
+     */
+    private createPointBasedOutsideClickSubscription;
+    /**
+     * Element-based origins close on outside clicks and suppress toggle-button
+     * re-clicks so the popover doesn't immediately reopen.
+     */
+    private createElementBasedOutsideClickSubscription;
+    private resetPosition;
+    private closePopover;
+    private showOverlay;
+    private removeOverlay;
+    private getScrollableParents;
+    /**
+     * Uses IntersectionObserver to detect when the origin element leaves the screen.
+     * This handles the "Close on Scroll" logic much cheaper than getBoundingClientRect.
+     */
+    private setupIntersectionObserver;
+    private listenToScrollEvents;
+    private listenToScrollForElementOrigin;
+    private getRootPopover;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrPopoverContent, [null, null, { optional: true; }, null, { optional: true; skipSelf: true; }, null, null, null, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClrPopoverContent, "[clrPopoverContent]", never, { "open": { "alias": "clrPopoverContent"; "required": false; }; "contentAt": { "alias": "clrPopoverContentAt"; "required": false; }; "availablePositions": { "alias": "clrPopoverContentAvailablePositions"; "required": false; }; "contentType": { "alias": "clrPopoverContentType"; "required": false; }; "outsideClickClose": { "alias": "clrPopoverContentOutsideClickToClose"; "required": false; }; "scrollToClose": { "alias": "clrPopoverContentScrollToClose"; "required": false; }; "contentOrigin": { "alias": "clrPopoverContentOrigin"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class ClrPopoverOrigin {
+    constructor(popoverService: ClrPopoverService, element: ElementRef<HTMLButtonElement>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrPopoverOrigin, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClrPopoverOrigin, "[clrPopoverOrigin]", never, {}, {}, never, never, false, never>;
+}
+
+declare class ClrStopEscapePropagationDirective implements OnInit, OnDestroy {
+    private popoverService;
+    private subscription;
+    private lastOpenChange;
+    constructor(popoverService: ClrPopoverService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onEscapeKey(event: KeyboardEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrStopEscapePropagationDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClrStopEscapePropagationDirective, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class ClrPopoverHostDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrPopoverHostDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClrPopoverHostDirective, never, never, {}, {}, never, never, true, [{ directive: typeof ClrStopEscapePropagationDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare const POPOVER_HOST_ORIGIN: InjectionToken<ElementRef<any>>;
+
+/**********
+ *
+ * @class ClrIfOpen
+ *
+ * @description
+ * A structural directive that controls whether or not the associated TemplateRef is instantiated or not.
+ * It makes use of a Component instance level service: ClrPopoverService to maintain state between itself and the component
+ * using it in the component template.
+ *
+ */
+declare class ClrIfOpen implements OnDestroy {
+    private popoverService;
+    private template;
+    private container;
+    static ngAcceptInputType_open: boolean | '';
+    /**********
+     * @property openChange
+     *
+     * @description
+     * An event emitter that emits when the open property is set to allow for 2way binding when the directive is
+     * used with de-structured / de-sugared syntax.
+     */
+    openChange: EventEmitter<boolean>;
+    private subscriptions;
+    constructor(popoverService: ClrPopoverService, template: TemplateRef<any>, container: ViewContainerRef);
+    /**
+     * @description
+     * A property that gets/sets ClrPopoverService.open with value.
+     */
+    get open(): boolean | string;
+    set open(value: boolean | string);
+    ngOnDestroy(): void;
+    /**
+     * @description
+     * Function that takes a boolean value and either created an embedded view for the associated ViewContainerRef or,
+     * Clears all views from the ViewContainerRef
+     *
+     * @param value
+     */
+    updateView(value: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrIfOpen, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClrIfOpen, "[clrIfOpen]", never, { "open": { "alias": "clrIfOpen"; "required": false; }; }, { "openChange": "clrIfOpenChange"; }, never, never, true, never>;
+}
+
+declare class ClrPopoverCloseButton implements OnDestroy, AfterViewInit {
+    private elementRef;
+    private popoverService;
+    closeChange: EventEmitter<void>;
+    private subscriptions;
+    constructor(elementRef: ElementRef<HTMLButtonElement>, popoverService: ClrPopoverService);
+    handleClick(event: MouseEvent): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrPopoverCloseButton, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClrPopoverCloseButton, "[clrPopoverCloseButton]", never, {}, { "closeChange": "clrPopoverOnCloseChange"; }, never, never, false, never>;
+}
+
+declare class ClrPopoverOpenCloseButton implements OnDestroy {
+    private popoverService;
+    openCloseChange: EventEmitter<boolean>;
+    private subscriptions;
+    constructor(popoverService: ClrPopoverService);
+    handleClick(event: MouseEvent): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrPopoverOpenCloseButton, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClrPopoverOpenCloseButton, "[clrPopoverOpenCloseButton]", never, {}, { "openCloseChange": "clrPopoverOpenCloseChange"; }, never, never, false, never>;
+}
+
+declare class ClrPopoverModuleNext {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrPopoverModuleNext, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ClrPopoverModuleNext, [typeof ClrPopoverOrigin, typeof ClrPopoverCloseButton, typeof ClrPopoverOpenCloseButton], [typeof ClrPopoverContent, typeof ClrIfOpen], [typeof ClrPopoverOrigin, typeof ClrPopoverCloseButton, typeof ClrPopoverOpenCloseButton, typeof ClrPopoverContent, typeof ClrIfOpen]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ClrPopoverModuleNext>;
+}
+
+export { ClrIfOpen, ClrPopoverCloseButton, ClrPopoverContent, ClrPopoverHostDirective, ClrPopoverModuleNext, ClrPopoverOpenCloseButton, ClrPopoverOrigin, ClrPopoverPosition, ClrPopoverService, ClrPopoverType, ClrStopEscapePropagationDirective, DROPDOWN_POSITIONS, POPOVER_HOST_ORIGIN, SIGNPOST_POSITIONS, TOOLTIP_POSITIONS, getConnectedPositions, getContentPosition, getOriginPosition, getPositionsArray, mapPopoverKeyToPosition };
+export type { ClrPopoverPoint };

package/types/clr-angular-popover-dropdown.d.ts

@@ -0,0 +1,123 @@
+import * as i0 from '@angular/core';
+import { OnDestroy, Renderer2, ChangeDetectorRef, AfterContentInit, QueryList, ElementRef, Type } from '@angular/core';
+import * as i1 from '@clr/angular/popover/common';
+import { ClrPopoverService, ClrPopoverPoint, ClrPopoverContent, ClrPopoverPosition } from '@clr/angular/popover/common';
+import { FocusableItem, FocusService } from '@clr/angular/utils';
+import { Observable } from 'rxjs';
+import * as i5 from '@angular/common';
+import * as i6 from '@clr/angular/icon';
+
+declare class DropdownFocusHandler implements OnDestroy, FocusableItem {
+    private renderer;
+    private parent;
+    private popoverService;
+    private focusService;
+    private platformId;
+    id: string;
+    right?: Observable<FocusableItem>;
+    down?: Observable<FocusableItem>;
+    up?: Observable<FocusableItem>;
+    private _trigger;
+    private _container;
+    private children;
+    private _unlistenFuncs;
+    constructor(renderer: Renderer2, parent: DropdownFocusHandler, popoverService: ClrPopoverService, focusService: FocusService, platformId: any);
+    get trigger(): HTMLElement;
+    set trigger(el: HTMLElement);
+    get container(): HTMLElement;
+    set container(el: HTMLElement);
+    ngOnDestroy(): void;
+    /**
+     * If the dropdown was opened by clicking on the trigger, we automatically move to the first item
+     */
+    moveToFirstItemWhenOpen(): void;
+    focus(): void;
+    blur(): void;
+    activate(): void;
+    resetChildren(): void;
+    addChildren(children: FocusableItem[]): void;
+    private openAndGetChildren;
+    private closeAndGetThis;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownFocusHandler, [null, { optional: true; skipSelf: true; }, null, null, null]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DropdownFocusHandler>;
+}
+
+declare class RootDropdownService {
+    private _changes;
+    get changes(): Observable<boolean>;
+    closeMenus(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RootDropdownService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RootDropdownService>;
+}
+
+declare class ClrDropdown implements OnDestroy {
+    parent: ClrDropdown;
+    popoverService: ClrPopoverService;
+    focusHandler: DropdownFocusHandler;
+    isMenuClosable: boolean;
+    private subscriptions;
+    constructor(parent: ClrDropdown, popoverService: ClrPopoverService, focusHandler: DropdownFocusHandler, cdr: ChangeDetectorRef, dropdownService: RootDropdownService);
+    openAtPoint(point: ClrPopoverPoint, targetElement?: HTMLElement): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrDropdown, [{ optional: true; skipSelf: true; }, null, null, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrDropdown, "clr-dropdown", never, { "isMenuClosable": { "alias": "clrCloseMenuOnItemClick"; "required": false; }; }, {}, never, ["*"], false, [{ directive: typeof i1.ClrPopoverHostDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare class ClrDropdownMenu implements AfterContentInit, OnDestroy {
+    private focusHandler;
+    private elementRef;
+    private popoverService;
+    private popoverContent;
+    items: QueryList<FocusableItem>;
+    constructor(parentHost: ElementRef<HTMLElement>, nested: ClrDropdownMenu, focusHandler: DropdownFocusHandler, elementRef: ElementRef, popoverService: ClrPopoverService, popoverContent: ClrPopoverContent);
+    get isOffScreen(): boolean;
+    set position(position: string | ClrPopoverPosition);
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrDropdownMenu, [{ optional: true; }, { optional: true; skipSelf: true; }, null, null, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrDropdownMenu, "clr-dropdown-menu", never, { "position": { "alias": "clrPosition"; "required": false; }; }, {}, ["items"], ["*"], false, [{ directive: typeof i1.ClrPopoverContent; inputs: {}; outputs: {}; }]>;
+}
+
+declare class ClrDropdownTrigger {
+    private popoverService;
+    isRootLevelToggle: boolean;
+    constructor(dropdown: ClrDropdown, popoverService: ClrPopoverService, el: ElementRef<HTMLElement>, focusHandler: DropdownFocusHandler);
+    get active(): boolean;
+    onDropdownTriggerClick(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrDropdownTrigger, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClrDropdownTrigger, "[clrDropdownTrigger],[clrDropdownToggle]", never, {}, {}, never, never, false, never>;
+}
+
+declare class ClrDropdownItem {
+    private dropdown;
+    private _dropdownService;
+    private focusableItem;
+    private el;
+    private renderer;
+    constructor(dropdown: ClrDropdown, _dropdownService: RootDropdownService, focusableItem: FocusableItem, el: ElementRef, renderer: Renderer2);
+    get disabled(): boolean | string;
+    set disabled(value: boolean | string);
+    /**
+     * Let you overwrite the focusable auto increment id.
+     */
+    get dropdownItemId(): string;
+    set dropdownItemId(value: string);
+    private onDropdownItemClick;
+    private onSpaceKeydown;
+    private onEnterKeydown;
+    private stopImmediatePropagationIfDisabled;
+    private findRootDropdown;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrDropdownItem, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClrDropdownItem, "[clrDropdownItem]", never, { "disabled": { "alias": "clrDisabled"; "required": false; }; "dropdownItemId": { "alias": "id"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare const CLR_MENU_POSITIONS: string[];
+
+declare const CLR_DROPDOWN_DIRECTIVES: Type<any>[];
+declare class ClrDropdownModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrDropdownModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ClrDropdownModule, [typeof ClrDropdown, typeof ClrDropdownMenu, typeof ClrDropdownTrigger, typeof ClrDropdownItem], [typeof i5.CommonModule, typeof i6.ClrIcon, typeof i1.ClrIfOpen], [typeof ClrDropdown, typeof ClrDropdownMenu, typeof ClrDropdownTrigger, typeof ClrDropdownItem, typeof i1.ClrIfOpen, typeof i6.ClrIcon]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ClrDropdownModule>;
+}
+
+export { CLR_DROPDOWN_DIRECTIVES, CLR_MENU_POSITIONS, ClrDropdown, ClrDropdownItem, ClrDropdownMenu, ClrDropdownModule, ClrDropdownTrigger };