@progress/kendo-angular-menu 24.2.2 → 25.0.0-develop.1

package/index.d.ts

@@ -2,33 +2,1424 @@
 * Copyright © 2026 Progress Software Corporation. All rights reserved.
 * Licensed under commercial license. See LICENSE.md in the project root for more information
 *-------------------------------------------------------------------------------------------*/
-export { MenuComponent } from './menu.component';
-export { ListComponent, ItemComponent } from './rendering/list.component';
-export { LinkDirective } from './rendering/link.directive';
-export { ExpandArrowComponent } from './rendering/arrow.component';
-export { MenuItemComponent } from './menu-item.component';
-export { MenuAnimation } from './menu-animation.interface';
-export { MenuItem } from './menu-item.interface';
-export { MenuEvent } from './menu-event';
-export { MenuSelectEvent } from './menu-select-event';
-export { OpenOnClickSettings } from './open-on-click-settings';
-export { PopupSettings } from './rendering/popup-settings';
-export { ItemContentTemplateDirective } from './templates/item-content-template.directive';
-export { ItemTemplateDirective } from './templates/item-template.directive';
-export { ItemLinkTemplateDirective } from './templates/item-link-template.directive';
-export { HierarchyBindingDirective } from './data-binding/hierachy-binding.directive';
-export { FlatBindingDirective } from './data-binding/flat-binding.directive';
-export { MenuModule } from './menu.module';
-export { ContextMenuEvent } from './context-menu/context-menu-event';
-export { ContextMenuSelectEvent } from './context-menu/context-menu-select-event';
-export { ContextMenuPopupEvent } from './context-menu/context-menu-popup-event';
-export { ContextMenuTemplateDirective } from './context-menu/context-menu-template.directive';
-export { ContextMenuComponent } from './context-menu/context-menu.component';
-export { ContextMenuModule } from './context-menu/context-menu.module';
-export { ContextMenuService } from './context-menu/context-menu.service';
-export { ItemsService } from './services/items.service';
-export { ContextMenuTargetContainerDirective } from './context-menu/context-menu-target-container.directive';
-export { ContextMenuTargetDirective } from './context-menu/context-menu-target.directive';
-export { MenuSize } from './size';
-export { MenusModule } from './menus.module';
-export * from './directives';
+import * as i0 from '@angular/core';
+import { NgZone, EventEmitter, TemplateRef, QueryList, TrackByFunction, OnChanges, AfterViewChecked, ViewContainerRef, Renderer2, OnInit, AfterViewInit, OnDestroy, ElementRef, ChangeDetectorRef, SimpleChanges } from '@angular/core';
+import { LocalizationService } from '@progress/kendo-angular-l10n';
+import * as _progress_kendo_angular_icons from '@progress/kendo-angular-icons';
+import { SVGIcon } from '@progress/kendo-angular-icons';
+import { SVGIcon as SVGIcon$1 } from '@progress/kendo-svg-icons';
+import { Margin, PopupService, PopupAnimation, Align, Collision, Offset } from '@progress/kendo-angular-popup';
+
+/**
+ * @hidden
+ */
+declare class ItemsService {
+    items: any;
+    lists: any[];
+    private idPrefix;
+    get hasItems(): boolean;
+    childId(index: string): string;
+    itemIndex(parentIndex: string, index: any): string;
+    get(index: string): any;
+    add(item: any): any;
+    remove(item: any): any;
+    addList(list: any): any;
+    removeList(list: any): any;
+    containsList(element: any): boolean;
+    siblings(item: any): any[];
+    otherSiblings(item: any): any[];
+    children(item: any): any[];
+    parent(item: any): any;
+    root(item: any): any;
+    indices(index: string): string[];
+    filter(predicate: any): any[];
+    previous(item: any): any;
+    next(item: any): any;
+    hasParent(item: any, parent: any): boolean;
+    areSiblings(item1: any, item2: any): boolean;
+    forEach(callback: any): void;
+    private parentIndex;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ItemsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ItemsService>;
+}
+
+/**
+ * @hidden
+ */
+declare class ActionsService {
+    private ngZone;
+    private items;
+    owner: any;
+    actions: any[];
+    constructor(ngZone: NgZone, items: ItemsService);
+    open(item: any, finished?: any): void;
+    close(item: any): void;
+    closeItem(item: any): void;
+    closeToRoot(item: any): void;
+    closeOthers(item: any): void;
+    closeAll(): void;
+    select(item: any, domEvent: any, prevented?: any, finished?: any): void;
+    emit(name: string, item: any, domEvent?: any): boolean;
+    get hasPending(): boolean;
+    execute(toExecute?: any[]): void;
+    clear(): any[];
+    private executeActions;
+    private requiresZone;
+    private closeChildren;
+    private closeItems;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ActionsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ActionsService>;
+}
+
+/**
+ * @hidden
+ */
+declare class NavigationService {
+    private items;
+    private actions;
+    private localization;
+    private ngZone;
+    vertical: boolean;
+    activeIndex: string;
+    focusedIdx: string;
+    get focusedItem(): any;
+    private get activeItem();
+    private get handlers();
+    constructor(items: ItemsService, actions: ActionsService, localization: LocalizationService, ngZone: NgZone);
+    focus(item: any): void;
+    setFocus(item: any): void;
+    focusLeave(): void;
+    updateActive(): void;
+    keydown(e: KeyboardEvent): void;
+    focusIndex(index?: string): void;
+    focusFirst(): void;
+    focusLast(): void;
+    search(current: any, key: string): void;
+    down(current: any): void;
+    up(current: any): void;
+    left(current: any): void;
+    right(current: any): void;
+    home(current: any): void;
+    end(current: any): void;
+    enter(current: any, domEvent: any): void;
+    esc(current: any): void;
+    tab(current: any): void;
+    private focusChild;
+    private setActive;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavigationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NavigationService>;
+}
+
+/**
+ * @hidden
+ */
+declare class HoverService {
+    private actions;
+    private items;
+    delay: number;
+    get openOnOver(): boolean;
+    set openOnOver(value: boolean);
+    private _openOnOver;
+    private hoveredIdx;
+    private get hovered();
+    private set hovered(value);
+    private scheduled;
+    constructor(actions: ActionsService, items: ItemsService);
+    ngOnDestroy(): void;
+    over(item: any): void;
+    leave(disableOpenOnOver?: boolean): void;
+    closeCurrent(): void;
+    private scheduleActions;
+    private scheduleDisableOpenOnOver;
+    private removeScheduled;
+    private cancelActions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HoverService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HoverService>;
+}
+
+/**
+ * @hidden
+ */
+declare class PreventableEvent {
+    private prevented;
+    /**
+     * Prevents the default action for a specified event.
+     * In this way, the source component suppresses
+     * the built-in behavior that follows the event.
+     */
+    preventDefault(): void;
+    /**
+     * Returns `true` if the event was prevented
+     * by any of its subscribers.
+     *
+     * @returns `true` if the default action was prevented.
+     * Otherwise, returns `false`.
+     */
+    isDefaultPrevented(): boolean;
+    /**
+     * @hidden
+     */
+    constructor(args?: any);
+}
+
+/**
+ * Represents the arguments for the `open` and `close` events of the Menu.
+ */
+declare class MenuEvent extends PreventableEvent {
+    /**
+     * Specifies the MenuComponent that triggered the event.
+     */
+    sender: MenuComponent;
+    /**
+     * Specifies the item data of the event.
+     */
+    item: any;
+    /**
+     * Specifies the item index of the event.
+     */
+    index: string;
+}
+
+/**
+ * Arguments for the `select` event of the Menu.
+ */
+declare class MenuSelectEvent extends MenuEvent {
+    /**
+     * The DOM event that triggered the selection.
+     */
+    originalEvent: any;
+}
+
+/**
+ * @hidden
+ */
+declare class ContextMenuService {
+    keydown: EventEmitter<any>;
+    owner: any;
+    items: any;
+    emit(name: string, args: any): void;
+    hasObservers(name: string): boolean;
+    leaveMenu(e: any): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextMenuService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ContextMenuService>;
+}
+
+/**
+ * Represents a template for the Menu items ([see example](https://www.telerik.com/kendo-angular-ui/components/menus/menu/templates)). To define a template
+ * for an item, nest an `<ng-template>` tag with the `kendoMenuItemTemplate` directive inside a `<kendo-menu-item>`
+ * component. To define a template for all Menu items, nest the template inside the `<kendo-menu>` component.
+ *
+ * The available fields in the template context are:
+ * - `item`&mdash;The item data.
+ * - `index`&mdash;The item index.
+ *
+ * @example
+ * ```ts-preview
+ *
+ * _@Component({
+ *    selector: 'my-app',
+ *    template: `
+ *        <kendo-menu>
+ *          <kendo-menu-item text="item2">
+ *              <ng-template kendoMenuItemTemplate let-item="item" let-index="index">
+ *                  <div style="padding: 10px;">
+ *                      My Template for: {{ item.text }} at index: {{ index }}
+ *                  </div>
+ *              </ng-template>
+ *          </kendo-menu-item>
+ *        </kendo-menu>
+ *    `
+ * })
+ *
+ * class AppComponent {
+ * }
+ * ```
+ */
+declare class ItemTemplateDirective {
+    templateRef: TemplateRef<any>;
+    constructor(templateRef: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ItemTemplateDirective, [{ optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ItemTemplateDirective, "[kendoMenuItemTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Represents a template for the links of the Menu items ([see example](https://www.telerik.com/kendo-angular-ui/components/menus/menu/templates)). To define a template
+ * for an item, nest an `<ng-template>` tag with the `kendoMenuItemLinkTemplate` directive inside a `<kendo-menu-item>`
+ * component. To define a template for all Menu items, nest the template inside the `<kendo-menu>` component.
+ *
+ * The available fields in the template context are:
+ * - `item`&mdash;The item data.
+ * - `index`&mdash;The item index.
+ *
+ * @example
+ * ```ts-preview
+ *
+ * _@Component({
+ *    selector: 'my-app',
+ *    template: `
+ *        <kendo-menu>
+ *          <kendo-menu-item text="item2">
+ *              <ng-template kendoMenuItemLinkTemplate let-item="item" let-index="index">
+ *                  <span [kendoMenuItemLink]="index">
+ *                      {{ item.text }}
+ *                      @if (item.items && item.items.length) {
+ *                        <span [kendoMenuExpandArrow]="index"></span>
+ *                      }
+ *                  </span>
+ *              </ng-template>
+ *          </kendo-menu-item>
+ *        </kendo-menu>
+ *    `
+ * })
+ *
+ * class AppComponent {
+ * }
+ * ```
+ */
+declare class ItemLinkTemplateDirective {
+    templateRef: TemplateRef<any>;
+    constructor(templateRef: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ItemLinkTemplateDirective, [{ optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ItemLinkTemplateDirective, "[kendoMenuItemLinkTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Represents a template for the content of the Menu items ([see example](https://www.telerik.com/kendo-angular-ui/components/menus/menu/templates)). To define the template,
+ * nest an `<ng-template>` tag with the `kendoMenuItemContentTemplate` directive inside a `<kendo-menu-item>` component.
+ *
+ * The available fields in the template context are:
+ * - `item`&mdash;The item data.
+ * - `index`&mdash;The item index.
+ *
+ * @example
+ * ```ts-preview
+ *
+ * _@Component({
+ *    selector: 'my-app',
+ *    template: `
+ *        <kendo-menu>
+ *          <kendo-menu-item text="item2">
+ *              <ng-template kendoMenuItemContentTemplate let-item="item" let-index="index">
+ *                  <div style="padding: 10px;">
+ *                      My Content Template for: {{ item.text }} at index: {{ index }}
+ *                  </div>
+ *              </ng-template>
+ *          </kendo-menu-item>
+ *        </kendo-menu>
+ *    `
+ * })
+ *
+ * class AppComponent {
+ * }
+ * ```
+ */
+declare class ItemContentTemplateDirective {
+    templateRef: TemplateRef<any>;
+    constructor(templateRef: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ItemContentTemplateDirective, [{ optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ItemContentTemplateDirective, "[kendoMenuItemContentTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Represents an interface for the Menu items.
+ */
+interface MenuItem {
+    /**
+     * Specifies the item text ([see example](https://www.telerik.com/kendo-angular-ui/components/menus/menu/items#showing-text)).
+     */
+    text?: string;
+    /**
+     * Specifies a URL which is rendered as a `href` attribute on the item link
+     * ([see example](https://www.telerik.com/kendo-angular-ui/components/menus/menu/items#rendering-urls)).
+     */
+    url?: string;
+    /**
+     * Specifies the name of the [font icon](https://www.telerik.com/kendo-angular-ui/components/styling/icons#icons-list) that will
+     * be rendered for the item ([see example](https://www.telerik.com/kendo-angular-ui/components/menus/menu/items#displaying-font-icons)).
+     */
+    icon?: string;
+    /**
+     * Defines an [`SVGIcon`](https://www.telerik.com/kendo-angular-ui/components/icons/api/svgicon) that will be
+     * rendered for the item using a [`KendoSVGIcon`](https://www.telerik.com/kendo-angular-ui/components/icons/api/svgiconcomponent) component ([see example](https://www.telerik.com/kendo-angular-ui/components/menus/menu/items#displaying-svg-icons)).
+     */
+    svgIcon?: SVGIcon;
+    /**
+     * Specifies if the item is disabled ([see example](https://www.telerik.com/kendo-angular-ui/components/menus/menu/items#disabling-items)).
+     */
+    disabled?: boolean;
+    /**
+     * Specifies the CSS classes that will be rendered on the item element ([see example](https://www.telerik.com/kendo-angular-ui/components/menus/menu/items#adding-styles-and-classes)).
+     * Supports the type of values that are supported by [`ngClass`](link:site.data.urls.angular['ngclassapi']).
+     */
+    cssClass?: any;
+    /**
+     * Specifies the CSS styles that will be rendered on the item element ([see example](https://www.telerik.com/kendo-angular-ui/components/menus/menu/items#adding-styles-and-classes)).
+     * Supports the type of values that are supported by [`ngStyle`](link:site.data.urls.angular['ngstyleapi']).
+     */
+    cssStyle?: any;
+    /**
+     * Specifies a template for the item.
+     */
+    template?: TemplateRef<any>;
+    /**
+     * Specifies a template for the item content.
+     */
+    contentTemplate?: TemplateRef<any>;
+    /**
+     * Specifies the children of the item ([see example](https://www.telerik.com/kendo-angular-ui/components/menus/menu/data-binding)).
+     */
+    items?: any[];
+    /**
+     * Represents the additional data that is associated with the Menu item.
+     */
+    data?: any;
+    /**
+     * Specifies if this is a separator item.
+     * If set to true only the `cssClass` and `cssStyle` fields are rendered.
+     */
+    separator?: boolean;
+}
+
+/**
+ * Represents a component that can be used to specify the Menu items
+ * ([more information and examples](https://www.telerik.com/kendo-angular-ui/components/menus/menu/items)).
+ *
+ * @example
+ * ```html
+ * <kendo-menu>
+ *   <kendo-menu-item text="item1">
+ *       <kendo-menu-item text="item1.1" url="https://example.com">
+ *       </kendo-menu-item>
+ *       <kendo-menu-item text="item1.2" [disabled]="true">
+ *       </kendo-menu-item>
+ *   </kendo-menu-item>
+ *   <kendo-menu-item text="item2">
+ *       <ng-template kendoMenuItemContentTemplate let-item="item">
+ *           <div style="padding: 10px;">
+ *               My Content Template: {{ item.text }}
+ *           </div>
+ *       </ng-template>
+ *       <ng-template kendoMenuItemTemplate let-item="item">
+ *           <div style="padding: 10px;">
+ *               My Template: {{ item.text }}
+ *           </div>
+ *       </ng-template>
+ *   </kendo-menu-item>
+ *   <kendo-menu-item text="item3">
+ *       <ng-template kendoMenuItemLinkTemplate let-item="item" let-index="index">
+ *           <span [kendoMenuItemLink]="index">
+ *               {{ item.text }}
+ *               @if (item.items && item.items.length) {
+ *                 <span [kendoMenuExpandArrow]="index"></span>
+ *               }
+ *           </span>
+ *       </ng-template>
+ *   </kendo-menu-item>
+ * </kendo-menu>
+ * ```
+ *
+ * @remarks
+ * Supported children components are: {@link MenuItemComponent}.
+ */
+declare class MenuItemComponent implements MenuItem {
+    text: string;
+    url: string;
+    disabled: boolean;
+    cssClass: any;
+    cssStyle: any;
+    icon: string;
+    svgIcon: SVGIcon$1;
+    data: any;
+    separator: boolean;
+    /**
+     * @hidden
+     */
+    itemTemplate: QueryList<ItemTemplateDirective>;
+    /**
+     * @hidden
+     */
+    itemLinkTemplate: QueryList<ItemLinkTemplateDirective>;
+    /**
+     * @hidden
+     */
+    itemContentTemplate: QueryList<ItemContentTemplateDirective>;
+    /**
+     * @hidden
+     */
+    children: QueryList<MenuItemComponent>;
+    /**
+     * @hidden
+     */
+    get template(): TemplateRef<any>;
+    /**
+     * @hidden
+     */
+    get linkTemplate(): TemplateRef<any>;
+    /**
+     * @hidden
+     */
+    get contentTemplate(): TemplateRef<any>;
+    /**
+     * @hidden
+     */
+    get items(): any[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<MenuItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MenuItemComponent, "kendo-menu-item", never, { "text": { "alias": "text"; "required": false; }; "url": { "alias": "url"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "cssClass": { "alias": "cssClass"; "required": false; }; "cssStyle": { "alias": "cssStyle"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "svgIcon": { "alias": "svgIcon"; "required": false; }; "data": { "alias": "data"; "required": false; }; "separator": { "alias": "separator"; "required": false; }; }, {}, ["itemTemplate", "itemLinkTemplate", "itemContentTemplate", "children"], never, true, never>;
+}
+
+/**
+ * Represents the animation settings for the Popup component.
+ */
+interface MenuAnimation {
+    /**
+     * Specifies the type of the animation.
+     *
+     * @default 'slide'
+     */
+    type?: 'slide' | 'expand' | 'zoom' | 'fade';
+    /**
+     * Specifies the animation duration in milliseconds.
+     *
+     * @default 100
+     */
+    duration: number;
+}
+
+/**
+ * The settings for the `openOnClick` option.
+ */
+interface OpenOnClickSettings {
+    /**
+     * Specifies the way in which you can toggle the open-on-click behavior.
+     *
+     * The supported values are:
+     * - `"select"`&mdash;The user opens an item with a click and the Menu items open on hover until one of them is selected.
+     * - `"leave"`&mdash;The user opens an item with a click and the Menu items open on hover until either one of them is selected, or the mouse pointer leaves the Menu and the predefined delay passes.
+     * - `"click"`&mdash;The user opens an item with a click and the Menu items open on hover but do not close when the mouse pointer leaves the Menu. To close the items, the user has to either select an item, or click a random place on the page.
+     *
+     * @default 'select'
+     */
+    toggle: 'select' | 'leave' | 'click';
+}
+
+/**
+ * Represents the possible size options of the menu.
+ */
+type MenuSize = 'small' | 'medium' | 'large';
+
+/**
+ * Settings for the Menu and ContextMenu popups.
+ */
+interface PopupSettings {
+    /**
+     * The CSS class that will be applied to the popup container.
+     */
+    popupClass?: string | string[] | object | Set<string>;
+    /**
+     * The margin of the popup container.
+     */
+    margin?: Margin;
+}
+
+/**
+ * @hidden
+ */
+declare class MenuBase {
+    /**
+     * Specifies the Menu items.
+     */
+    items: any[];
+    /**
+     * Specifies if the Menu will be vertical ([see example](https://www.telerik.com/kendo-angular-ui/components/menus/menu/vertical)).
+     */
+    vertical: boolean;
+    /**
+     * Specifies that the root items can be opened only on click
+     * ([see example](https://www.telerik.com/kendo-angular-ui/components/menus/menu/open-close#opening-on-click)).
+     */
+    openOnClick: boolean | OpenOnClickSettings;
+    /**
+     * Specifies the delay in milliseconds before the Menu items are opened or closed on item hover
+     * or leave ([see example](https://www.telerik.com/kendo-angular-ui/components/menus/menu/open-close#delay-on-hover)). Used to avoid the accidental
+     * opening or closing of the items.
+     */
+    hoverDelay: number;
+    /**
+     * Sets the Menu animation.
+     */
+    animate: boolean | MenuAnimation;
+    /**
+     * Sets the Menu size.
+     *
+     * The possible values are:
+     * * `small`
+     * * `medium`
+     * * `large`
+     *
+     */
+    size: MenuSize;
+    /**
+     * Configures the popup settings for the Menu items.
+     * Allows customization of the popup class and margin.
+     */
+    popupSettings: PopupSettings;
+    /**
+     * Defines a function that determines how to track changes for the menu items.
+     * By default, the component tracks changes by index.
+     */
+    trackBy: TrackByFunction<any>;
+    /**
+     * @hidden
+     */
+    itemTemplate: QueryList<ItemTemplateDirective>;
+    /**
+     * @hidden
+     */
+    itemLinkTemplate: QueryList<ItemLinkTemplateDirective>;
+    /**
+     * @hidden
+     */
+    children: QueryList<MenuItemComponent>;
+    /**
+     * @hidden
+     */
+    get rootItems(): any[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<MenuBase, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MenuBase, "kendo-menu-base", never, { "items": { "alias": "items"; "required": false; }; "vertical": { "alias": "vertical"; "required": false; }; "openOnClick": { "alias": "openOnClick"; "required": false; }; "hoverDelay": { "alias": "hoverDelay"; "required": false; }; "animate": { "alias": "animate"; "required": false; }; "size": { "alias": "size"; "required": false; }; "popupSettings": { "alias": "popupSettings"; "required": false; }; "trackBy": { "alias": "trackBy"; "required": false; }; }, {}, ["itemTemplate", "itemLinkTemplate", "children"], never, true, never>;
+}
+
+/**
+ * Represents the [Kendo UI Menu component for Angular](https://www.telerik.com/kendo-angular-ui/components/menus/menu).
+ *
+ * @example
+ * ```ts
+ * _@Component({
+ *    selector: 'my-app',
+ *    template: `
+ *        <kendo-menu [items]="items">
+ *        </kendo-menu>
+ *    `
+ * })
+ * class AppComponent {
+ *    public items: any[] = [{ text: 'item1', items: [{ text: 'item1.1' }] }, { text: 'item2', disabled: true }];
+ * }
+ * ```
+ *
+ * @remarks
+ * Supported children components are: {@link MenuItemComponent}.
+ */
+declare class MenuComponent extends MenuBase implements OnChanges, AfterViewChecked {
+    private itemsService;
+    private hover;
+    private actions;
+    private navigation;
+    private localization;
+    private ngZone;
+    private renderer;
+    private contextService?;
+    /**
+     * Defines the container to which the popups will be appended.
+     */
+    appendTo: ViewContainerRef;
+    /**
+     * @hidden
+     */
+    menuItemTemplate: TemplateRef<any>;
+    /**
+     * @hidden
+     */
+    ariaRole: string;
+    /**
+     * @hidden
+     */
+    menuItemLinkTemplate: TemplateRef<any>;
+    /**
+     * Fires when a Menu item is selected ([see example](https://www.telerik.com/kendo-angular-ui/components/menus/menu/events)).
+     */
+    select: EventEmitter<MenuSelectEvent>;
+    /**
+     * Fires when a Menu item is opened ([see example](https://www.telerik.com/kendo-angular-ui/components/menus/menu/events)).
+     */
+    open: EventEmitter<MenuEvent>;
+    /**
+     * Fires when a Menu item is closed ([see example](https://www.telerik.com/kendo-angular-ui/components/menus/menu/events)).
+     */
+    close: EventEmitter<MenuEvent>;
+    /**
+     * @hidden
+     */
+    get ariaOrientation(): string | null;
+    /**
+     * @hidden
+     */
+    get isContextMenu(): boolean;
+    get direction(): boolean;
+    get rtl(): boolean;
+    /**
+     * @hidden
+     */
+    get menuClasses(): string;
+    private closeClickSubscription;
+    private contextKeyDownSubscription;
+    constructor(itemsService: ItemsService, hover: HoverService, actions: ActionsService, navigation: NavigationService, localization: LocalizationService, ngZone: NgZone, renderer: Renderer2, contextService?: ContextMenuService);
+    /**
+     * Opens or closes the specified Menu items.
+     *
+     * @param open - A Boolean value which indicates if the items will be opened or closed.
+     * @param indices - One or more values which represent the hierarchical indices of the items that will be opened or closed.
+     */
+    toggle(open: boolean, ...indices: string[]): void;
+    /**
+     * @hidden
+     */
+    focus(index?: string): void;
+    ngOnChanges(changes: any): void;
+    ngAfterViewChecked(): void;
+    ngOnDestroy(): void;
+    private attachCloseClick;
+    private unsubscribeClick;
+    private contextKeyDown;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MenuComponent, [null, null, null, null, null, null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MenuComponent, "kendo-menu", ["kendoMenu"], { "appendTo": { "alias": "appendTo"; "required": false; }; "menuItemTemplate": { "alias": "menuItemTemplate"; "required": false; }; "ariaRole": { "alias": "ariaRole"; "required": false; }; "menuItemLinkTemplate": { "alias": "menuItemLinkTemplate"; "required": false; }; }, { "select": "select"; "open": "open"; "close": "close"; }, never, never, true, never>;
+}
+
+/**
+ * @hidden
+ */
+declare class ListComponent implements OnInit, OnDestroy {
+    private itemsService;
+    private hover;
+    private actions;
+    private navigation;
+    private renderer;
+    private ngZone;
+    element: ElementRef;
+    appendTo: ViewContainerRef;
+    items: any[];
+    level: number;
+    index: string;
+    animate: boolean | MenuAnimation;
+    size: MenuSize;
+    vertical: boolean;
+    rtl: boolean;
+    openOnClick: any;
+    itemTemplate: TemplateRef<any>;
+    itemLinkTemplate: TemplateRef<any>;
+    popupSettings: PopupSettings;
+    trackBy: TrackByFunction<any>;
+    private domSubscriptions;
+    constructor(itemsService: ItemsService, hover: HoverService, actions: ActionsService, navigation: NavigationService, renderer: Renderer2, ngZone: NgZone, element: ElementRef);
+    trackByWrapper(index: number, item: any): any;
+    hierarchyIndex(index: number): string;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private initDomEvents;
+    private leavesMenu;
+    private onLeave;
+    private nodeItem;
+    private clickHandler;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ListComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ListComponent, "[kendoMenuList]", never, { "appendTo": { "alias": "appendTo"; "required": false; }; "items": { "alias": "items"; "required": false; }; "level": { "alias": "level"; "required": false; }; "index": { "alias": "index"; "required": false; }; "animate": { "alias": "animate"; "required": false; }; "size": { "alias": "size"; "required": false; }; "vertical": { "alias": "vertical"; "required": false; }; "rtl": { "alias": "rtl"; "required": false; }; "openOnClick": { "alias": "openOnClick"; "required": false; }; "itemTemplate": { "alias": "itemTemplate"; "required": false; }; "itemLinkTemplate": { "alias": "itemLinkTemplate"; "required": false; }; "popupSettings": { "alias": "popupSettings"; "required": false; }; "trackBy": { "alias": "trackBy"; "required": false; }; }, {}, never, never, true, never>;
+}
+/**
+ * @hidden
+ */
+declare class ItemComponent implements OnInit, OnChanges, AfterViewInit, OnDestroy {
+    private itemsService;
+    private navigation;
+    private changeDetector;
+    private renderer;
+    private popupService;
+    element: ElementRef;
+    private contextService?;
+    appendTo: ViewContainerRef;
+    item: any;
+    level: number;
+    set index(index: string);
+    get index(): string;
+    siblingIndex: number;
+    animate: boolean | MenuAnimation;
+    size: MenuSize;
+    vertical: boolean;
+    rtl: boolean;
+    openOnClick: boolean;
+    itemTemplate: TemplateRef<any>;
+    itemLinkTemplate: TemplateRef<any>;
+    popupSettings: PopupSettings;
+    trackBy: TrackByFunction<any>;
+    link: ElementRef;
+    popupTemplate: TemplateRef<any>;
+    get disabled(): boolean;
+    get hasPopup(): string;
+    get defaultPopupSettings(): any;
+    get horizontal(): boolean;
+    get hasLink(): boolean;
+    get linkTemplate(): TemplateRef<any>;
+    get hasContent(): boolean;
+    get isContent(): boolean;
+    get iconClass(): string;
+    get isContextMenu(): boolean;
+    get menuListClasses(): string;
+    get children(): any[];
+    get template(): TemplateRef<any>;
+    /**
+     * @hidden
+     */
+    fontIcon: (horizontal: boolean, rtl: boolean) => string;
+    /**
+     * @hidden
+     */
+    SVGIcon: (horizontal: boolean, rtl: boolean) => _progress_kendo_angular_icons.SVGIcon;
+    opened: boolean;
+    navigating: boolean;
+    childId: string;
+    private contentItems;
+    private popupRef;
+    private _index;
+    private destroyed;
+    constructor(itemsService: ItemsService, navigation: NavigationService, changeDetector: ChangeDetectorRef, renderer: Renderer2, popupService: PopupService, element: ElementRef, contextService?: ContextMenuService);
+    hasContentTemplates(): boolean;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    focus(): void;
+    blur(): void;
+    toggleActive(isActive: boolean): void;
+    open(): void;
+    close(): void;
+    navigate(): void;
+    private setAttribute;
+    private getMergedPopupSettings;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ItemComponent, [null, null, null, null, null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ItemComponent, "[kendoMenuItem]", never, { "appendTo": { "alias": "appendTo"; "required": false; }; "item": { "alias": "item"; "required": false; }; "level": { "alias": "level"; "required": false; }; "index": { "alias": "index"; "required": false; }; "siblingIndex": { "alias": "siblingIndex"; "required": false; }; "animate": { "alias": "animate"; "required": false; }; "size": { "alias": "size"; "required": false; }; "vertical": { "alias": "vertical"; "required": false; }; "rtl": { "alias": "rtl"; "required": false; }; "openOnClick": { "alias": "openOnClick"; "required": false; }; "itemTemplate": { "alias": "itemTemplate"; "required": false; }; "itemLinkTemplate": { "alias": "itemLinkTemplate"; "required": false; }; "popupSettings": { "alias": "popupSettings"; "required": false; }; "trackBy": { "alias": "trackBy"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Represents a directive that can be used in the [`linkTemplate`](https://www.telerik.com/kendo-angular-ui/components/menus/api/itemlinktemplatedirective)
+ * of the items to apply the default styling and behavior.
+ *
+ * @example
+ * ```html
+ * <ng-template kendoMenuItemLinkTemplate let-item="item" let-index="index">
+ *   <a [kendoMenuItemLink]="index">{{ item.text }}</a>
+ * </ng-template>
+ * ```
+ */
+declare class LinkDirective implements OnInit {
+    private itemsService;
+    /**
+     * Specifies the index of the Menu item. The input is mandatory.
+     */
+    index: string;
+    hostClasses: boolean;
+    role: string;
+    tabindex: string;
+    get activeClass(): boolean;
+    private item;
+    constructor(itemsService: ItemsService);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LinkDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<LinkDirective, "[kendoMenuItemLink]", never, { "index": { "alias": "kendoMenuItemLink"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Represents a component that can be used in the [`linkTemplate`](https://www.telerik.com/kendo-angular-ui/components/menus/api/itemlinktemplatedirective)
+ * of the items to render the default expand arrow.
+ *
+ * @example
+ * ```html
+ * <ng-template kendoMenuItemLinkTemplate let-item="item" let-index="index">
+ *   <span [kendoMenuExpandArrow]="index"></span>
+ * </ng-template>
+ * ```
+ */
+declare class ExpandArrowComponent implements OnInit {
+    private itemsService;
+    /**
+     * Specifies the index of the Menu item. The input is mandatory.
+     */
+    index: string;
+    hostClasses: boolean;
+    ariaHidden: string;
+    private item;
+    /**
+     * @hidden
+     */
+    fontIcon: string;
+    /**
+     * @hidden
+     */
+    SVGIcon: SVGIcon$1;
+    constructor(itemsService: ItemsService);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExpandArrowComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ExpandArrowComponent, "[kendoMenuExpandArrow]", never, { "index": { "alias": "kendoMenuExpandArrow"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * @hidden
+ */
+declare abstract class BindingDirectiveBase implements OnChanges {
+    protected menu: MenuBase;
+    data: any[];
+    protected fields: any[];
+    constructor(menu: MenuBase);
+    ngOnChanges(): void;
+    /**
+     *  Rebinds the Menu items.
+     */
+    rebind(): void;
+    protected abstract mapItems(items: any[]): any[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<BindingDirectiveBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BindingDirectiveBase, "kendoBindingBase", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Represents a directive that converts the provided hierarchical data to [MenuItems](https://www.telerik.com/kendo-angular-ui/components/menus/api/menuitem) and binds them to the Menu.
+ *
+ * @example
+ * ```html
+ * <kendo-menu [kendoMenuHierarchyBinding]="hierarchicalData" [textField]="'text'" [childrenField]="'items'">
+ * </kendo-menu>
+ * ```
+ *
+ * @remarks
+ * Applied to: {@link MenuComponent}.
+ */
+declare class HierarchyBindingDirective extends BindingDirectiveBase {
+    /**
+     * Specifies the array of data which will be used to populate the Menu.
+     */
+    data: any[];
+    /**
+     * Defines the `text` field (or fields) of an item.
+     */
+    textField: string | string[];
+    /**
+     * Defines the `url` field (or fields) of an item.
+     */
+    urlField: string | string[];
+    /**
+     * Defines the `icon` field (or fields) of an item.
+     */
+    iconField: string | string[];
+    /**
+     * Defines the `svgIcon` field of the items.
+     */
+    svgIconField: string | string[];
+    /**
+     * Defines the `disabled` field (or fields) of an item.
+     */
+    disabledField: string | string[];
+    /**
+     * Defines the `cssClass` field (or fields) of an item.
+     */
+    cssClassField: string | string[];
+    /**
+     * Defines the `cssStyle` field (or fields) of an item.
+     */
+    cssStyleField: string | string[];
+    /**
+     * Defines the `separator` field (or fields) of the items.
+     */
+    separatorField: string | string[];
+    /**
+     * Defines the `children` field (or fields) of the items.
+     */
+    childrenField: string | string[];
+    constructor(menu: MenuBase);
+    protected mapItems(items: any[], level?: number): any[];
+    protected createItem(item: any, level: number): any;
+    protected getChildren(item: any, level: number): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HierarchyBindingDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HierarchyBindingDirective, "[kendoMenuHierarchyBinding]", ["kendoMenuHierarchyBinding"], { "data": { "alias": "kendoMenuHierarchyBinding"; "required": false; }; "textField": { "alias": "textField"; "required": false; }; "urlField": { "alias": "urlField"; "required": false; }; "iconField": { "alias": "iconField"; "required": false; }; "svgIconField": { "alias": "svgIconField"; "required": false; }; "disabledField": { "alias": "disabledField"; "required": false; }; "cssClassField": { "alias": "cssClassField"; "required": false; }; "cssStyleField": { "alias": "cssStyleField"; "required": false; }; "separatorField": { "alias": "separatorField"; "required": false; }; "childrenField": { "alias": "childrenField"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Represents a directive that converts the provided flat data to [MenuItems](https://www.telerik.com/kendo-angular-ui/components/menus/api/menuitem) and binds them to the Menu.
+ *
+ * @example
+ * ```html
+ * <kendo-menu [kendoMenuFlatBinding]="flatData" [textField]="'text'" [idField]="'id'" [parentIdField]="'parentId'">
+ * </kendo-menu>
+ * ```
+ *
+ * @remarks
+ * Applied to: {@link MenuComponent}.
+ */
+declare class FlatBindingDirective extends BindingDirectiveBase {
+    /**
+     * Specifies the array of data which will be used to populate the Menu.
+     */
+    data: any[];
+    /**
+     * Defines the `text` field of the items.
+     */
+    textField: string;
+    /**
+     * Defines the `url` field of the items.
+     */
+    urlField: string;
+    /**
+     * Defines the `icon` field of the items.
+     */
+    iconField: string | string[];
+    /**
+     * Defines the `svgIcon` field of the items.
+     */
+    svgIconField: string | string[];
+    /**
+     * Defines the `disabled` field of the items.
+     */
+    disabledField: string;
+    /**
+     * Defines the `cssClass` field of the items.
+     */
+    cssClassField: string;
+    /**
+     * Defines the `cssStyle` field of the items.
+     */
+    cssStyleField: string;
+    /**
+     * Defines the `separator` field of the items.
+     */
+    separatorField: string;
+    /**
+     * Defines the `id` field of the items.
+     */
+    idField: string;
+    /**
+     * Defines the parent `id` field of the items.
+     */
+    parentIdField: string;
+    constructor(menu: MenuBase);
+    protected mapItems(items: any[]): any[];
+    protected createItem(dataItem: any): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FlatBindingDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FlatBindingDirective, "[kendoMenuFlatBinding]", ["kendoMenuFlatBinding"], { "data": { "alias": "kendoMenuFlatBinding"; "required": false; }; "textField": { "alias": "textField"; "required": false; }; "urlField": { "alias": "urlField"; "required": false; }; "iconField": { "alias": "iconField"; "required": false; }; "svgIconField": { "alias": "svgIconField"; "required": false; }; "disabledField": { "alias": "disabledField"; "required": false; }; "cssClassField": { "alias": "cssClassField"; "required": false; }; "cssStyleField": { "alias": "cssStyleField"; "required": false; }; "separatorField": { "alias": "separatorField"; "required": false; }; "idField": { "alias": "idField"; "required": false; }; "parentIdField": { "alias": "parentIdField"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Represents the [NgModule](link:site.data.urls.angular['ngmoduleapi'])
+ * definition for the Menu component.
+ *
+ * @example
+ *
+ * ```ts-no-run
+ * // Import the Menu module
+ * import { MenuModule } from '@progress/kendo-angular-menu';
+ *
+ * // The browser platform with a compiler
+ * import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';
+ * import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
+ *
+ * import { NgModule } from '@angular/core';
+ *
+ * // Import the app component
+ * import { AppComponent } from './app.component';
+ *
+ * // Define the app module
+ * _@NgModule({
+ *     declarations: [AppComponent], // declare app component
+ *     imports:      [BrowserModule, BrowserAnimationsModule, MenuModule], // import Menu module
+ *     bootstrap:    [AppComponent]
+ * })
+ * export class AppModule {}
+ *
+ * // Compile and launch the module
+ * platformBrowserDynamic().bootstrapModule(AppModule);
+ *
+ * ```
+ */
+declare class MenuModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MenuModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MenuModule, never, [typeof MenuComponent, typeof MenuItemComponent, typeof ItemTemplateDirective, typeof ItemLinkTemplateDirective, typeof ItemContentTemplateDirective, typeof HierarchyBindingDirective, typeof FlatBindingDirective, typeof LinkDirective, typeof ExpandArrowComponent], [typeof MenuComponent, typeof MenuItemComponent, typeof ItemTemplateDirective, typeof ItemLinkTemplateDirective, typeof ItemContentTemplateDirective, typeof HierarchyBindingDirective, typeof FlatBindingDirective, typeof LinkDirective, typeof ExpandArrowComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MenuModule>;
+}
+
+/**
+ * Represents the arguments for the `select` event of the ContextMenu.
+ */
+declare class ContextMenuSelectEvent extends ContextMenuEvent {
+    /**
+     * Specifies the DOM event that triggered the selection.
+     */
+    originalEvent: any;
+}
+
+/**
+ * Represents the arguments for the `popupOpen` and `popupClose` events of the ContextMenu.
+ */
+declare class ContextMenuPopupEvent extends PreventableEvent {
+    /**
+     * Specifies the target element for which the ContextMenu is opened.
+     */
+    target: any;
+    /**
+     * Specifies the DOM event that started the action.
+     */
+    originalEvent: any;
+    /**
+     * Specifies the ContextMenuComponent that triggered the event.
+     */
+    sender: ContextMenuComponent;
+    /**
+     * @hidden
+     */
+    constructor(args: any);
+}
+
+/**
+ * Represents a template for the content of the ContextMenu. To define a template, nest an `<ng-template>`
+ * tag with the `kendoContextMenuTemplate` directive inside a `<kendo-contextmenu>` component
+ * ([more information and examples](https://www.telerik.com/kendo-angular-ui/components/menus/contextmenu/templates)).
+ *
+ * <demo metaUrl="menus/context-menu/template/" height="200"></demo>
+ *
+ * @example
+ * ```html
+ * <kendo-contextmenu>
+ *   <ng-template kendoContextMenuTemplate let-item="item">
+ *     <span>{{ item.text }}</span>
+ *   </ng-template>
+ * </kendo-contextmenu>
+ * ```
+ */
+declare class ContextMenuTemplateDirective {
+    templateRef: TemplateRef<any>;
+    constructor(templateRef: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextMenuTemplateDirective, [{ optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ContextMenuTemplateDirective, "[kendoContextMenuTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * @hidden
+ */
+declare class ContextMenuTargetService {
+    targets: any[];
+    add(target: any): void;
+    remove(target: any): void;
+    find(targetElement: any): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextMenuTargetService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ContextMenuTargetService>;
+}
+
+/**
+ * Represents a container for the [targets](https://www.telerik.com/kendo-angular-ui/components/menus/api/contextmenutargetdirective) of the ContextMenu.
+ *
+ * @example
+ * ```html
+ * <div
+ *   #target="kendoContextMenuTargetContainer"
+ *   kendoContextMenuTargetContainer
+ * >
+ *   <div kendoContextMenuTarget></div>
+ *   <div kendoContextMenuTarget></div>
+ * </div>
+ * ```
+ */
+declare class ContextMenuTargetContainerDirective {
+    targetService: ContextMenuTargetService;
+    /**
+     * @hidden
+     */
+    element: any;
+    /**
+     * @hidden
+     */
+    constructor(elementRef: ElementRef, targetService: ContextMenuTargetService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextMenuTargetContainerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ContextMenuTargetContainerDirective, "[kendoContextMenuTargetContainer]", ["kendoContextMenuTargetContainer"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Represents the [Kendo UI ContextMenu component for Angular](https://www.telerik.com/kendo-angular-ui/components/menus/contextmenu).
+ *
+ * @example
+ * ```ts
+ * _@Component({
+ *    selector: 'my-app',
+ *    template: `
+ *    <div #target>
+ *        Right-click to open Context menu</p>
+ *    </div>
+ *    <kendo-contextmenu [target]="target" [items]="items"> </kendo-contextmenu>
+ *    `
+ * })
+ * class AppComponent {
+ *    public items: any[] = [{ text: 'item1', items: [{ text: 'item1.1' }] }, { text: 'item2', disabled: true }];
+ * }
+ * ```
+ */
+declare class ContextMenuComponent extends MenuBase implements OnInit, OnChanges, OnDestroy {
+    private popupService;
+    private service;
+    private ngZone;
+    private renderer;
+    /**
+     * Specifies the event on which the ContextMenu will open ([see example](https://www.telerik.com/kendo-angular-ui/components/menus/contextmenu/opening)).
+     * Accepts the name of a native DOM event. For example, `click`, `dblclick`, `mouseover`, etc.
+     *
+     * @default 'contextmenu'
+     */
+    showOn: string;
+    /**
+     * Specifies the element for which the ContextMenu will open ([see example](https://www.telerik.com/kendo-angular-ui/components/menus/contextmenu/target#configuration)).
+     */
+    target: HTMLElement | ElementRef | ContextMenuTargetContainerDirective | string;
+    /**
+     * Specifies a CSS selector which filters the elements in the target for which the ContextMenu will open
+     * ([see example](https://www.telerik.com/kendo-angular-ui/components/menus/contextmenu/target#changing-items-for-specific-targets)).
+     */
+    filter: string;
+    /**
+     * Specifies if the ContextMenu will be aligned to the target or to the `filter` element (if specified).
+     *
+     * @default false
+     */
+    alignToAnchor: boolean;
+    /**
+     * Specifies if the Menu will be vertically rendered ([see example](https://www.telerik.com/kendo-angular-ui/components/menus/contextmenu/orientation)).
+     *
+     * @default true
+     */
+    vertical: boolean;
+    /**
+     * Specifies the popup animation.
+     *
+     * @default true
+     */
+    popupAnimate: boolean | PopupAnimation;
+    /**
+     * Specifies the pivot point of the popup.
+     *
+     * @default { horizontal: 'left', vertical: 'top' }
+     */
+    popupAlign: Align;
+    /**
+     * Specifies the pivot point of the anchor. Applicable if `alignToAnchor` is `true`.
+     *
+     * @default { horizontal: 'left', vertical: 'bottom' }
+     */
+    anchorAlign: Align;
+    /**
+     * Configures the collision behavior of the popup.
+     *
+     * @default { horizontal: 'fit', vertical: 'flip' }
+     */
+    collision: Collision;
+    /**
+     * Defines the container to which the popups will be appended.
+     */
+    appendTo: ViewContainerRef;
+    /**
+     * Sets the value for the [`aria-label`](https://www.w3.org/TR/wai-aria-1.1/#aria-label) attribute of the ContextMenu.
+     *
+     * @remarks
+     * This property is related to accessibility.
+     */
+    ariaLabel: string;
+    /**
+     * Fires when the Menu is opened ([see example](https://www.telerik.com/kendo-angular-ui/components/menus/contextmenu/events)).
+     */
+    popupOpen: EventEmitter<ContextMenuPopupEvent>;
+    /**
+     * Fires when the Menu is closed ([see example](https://www.telerik.com/kendo-angular-ui/components/menus/contextmenu/events)).
+     */
+    popupClose: EventEmitter<ContextMenuPopupEvent>;
+    /**
+     * Fires when a Menu item is selected ([see example](https://www.telerik.com/kendo-angular-ui/components/menus/contextmenu/events)).
+     */
+    select: EventEmitter<ContextMenuSelectEvent>;
+    /**
+     * Fires when a Menu item is opened ([see example](https://www.telerik.com/kendo-angular-ui/components/menus/contextmenu/events)).
+     */
+    open: EventEmitter<ContextMenuEvent>;
+    /**
+     * Fires when a Menu item is closed ([see example](https://www.telerik.com/kendo-angular-ui/components/menus/contextmenu/events)).
+     */
+    close: EventEmitter<ContextMenuEvent>;
+    /**
+     * @hidden
+     */
+    contentTemplate: ContextMenuTemplateDirective;
+    /**
+     * @hidden
+     */
+    defaultContentTemplate: TemplateRef<any>;
+    private closeSubscription;
+    private showSubscription;
+    private keydownSubscription;
+    private popupSubscriptions;
+    private popupRef;
+    private currentTarget;
+    private directiveTarget;
+    private activeTarget;
+    constructor(popupService: PopupService, service: ContextMenuService, ngZone: NgZone, renderer: Renderer2);
+    /**
+     * Hides the ContextMenu.
+     */
+    hide(): void;
+    /**
+     * Shows the ContextMenu for the specified target.
+     *
+     * @param target - The offset or the target element for which the ContextMenu will open.
+     */
+    show(target: Offset | HTMLElement | ElementRef): void;
+    ngOnChanges(changes: any): void;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * @hidden
+     */
+    emitMenuEvent(name: string, args: any): void;
+    private bindShowHandler;
+    private showContextMenu;
+    private unbindShowHandler;
+    private targetElement;
+    private targetFilter;
+    private closePopup;
+    private removePopup;
+    private openPopup;
+    private createPopup;
+    private closeAndFocus;
+    private popupKeyDownHandler;
+    private popupAction;
+    private get currentTargetElement();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextMenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ContextMenuComponent, "kendo-contextmenu", ["kendoContextMenu"], { "showOn": { "alias": "showOn"; "required": false; }; "target": { "alias": "target"; "required": false; }; "filter": { "alias": "filter"; "required": false; }; "alignToAnchor": { "alias": "alignToAnchor"; "required": false; }; "vertical": { "alias": "vertical"; "required": false; }; "popupAnimate": { "alias": "popupAnimate"; "required": false; }; "popupAlign": { "alias": "popupAlign"; "required": false; }; "anchorAlign": { "alias": "anchorAlign"; "required": false; }; "collision": { "alias": "collision"; "required": false; }; "appendTo": { "alias": "appendTo"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; }, { "popupOpen": "popupOpen"; "popupClose": "popupClose"; "select": "select"; "open": "open"; "close": "close"; }, ["contentTemplate"], never, true, never>;
+}
+
+/**
+ * Represents the arguments for the `open` and `close` events of the ContextMenu.
+ */
+declare class ContextMenuEvent {
+    /**
+     * Specifies the target element for which the ContextMenu is opened.
+     */
+    target: any;
+    /**
+     * Specifies the ContextMenuComponent that triggered the event.
+     */
+    sender: ContextMenuComponent;
+    /**
+     * Specifies the item data of the event.
+     */
+    item: any;
+    /**
+     * Specifies the item index of the event.
+     */
+    index: string;
+}
+
+/**
+ * Represents a [target](https://www.telerik.com/kendo-angular-ui/components/menus/api/contextmenutargetdirective) for the ContextMenu
+ * ([see example](https://www.telerik.com/kendo-angular-ui/components/menus/contextmenu/target#directives)).
+ *
+ * @example
+ * ```html
+ * <div kendoContextMenuTarget> </div>
+ * ```
+ */
+declare class ContextMenuTargetDirective implements OnDestroy {
+    targetService: ContextMenuTargetService;
+    /**
+     * Specifies the data which is associated with the target.
+     */
+    data: any;
+    /**
+     * Specifies the target DOM element.
+     */
+    element: any;
+    /**
+     * @hidden
+     */
+    hostClass: boolean;
+    constructor(elementRef: ElementRef, targetService: ContextMenuTargetService);
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextMenuTargetDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ContextMenuTargetDirective, "[kendoContextMenuTarget]", ["kendoContextMenuTarget"], { "data": { "alias": "kendoContextMenuTarget"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Represents the [NgModule](link:site.data.urls.angular['ngmoduleapi'])
+ * definition for the ContextMenu component.
+ *
+ * @example
+ *
+ * ```ts-no-run
+ * // Import the ContextMenu module
+ * import { ContextMenuModule } from '@progress/kendo-angular-menu';
+ *
+ * // The browser platform with a compiler
+ * import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';
+ * import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
+ *
+ * import { NgModule } from '@angular/core';
+ *
+ * // Import the app component
+ * import { AppComponent } from './app.component';
+ *
+ * // Define the app module
+ * _@NgModule({
+ *     declarations: [AppComponent], // declare app component
+ *     imports:      [BrowserModule, BrowserAnimationsModule, ContextMenuModule], // import ContextMenuModule module
+ *     bootstrap:    [AppComponent]
+ * })
+ * export class AppModule {}
+ *
+ * // Compile and launch the module
+ * platformBrowserDynamic().bootstrapModule(AppModule);
+ *
+ * ```
+ */
+declare class ContextMenuModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextMenuModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ContextMenuModule, never, [typeof ContextMenuComponent, typeof ContextMenuTemplateDirective, typeof ContextMenuTargetDirective, typeof ContextMenuTargetContainerDirective, typeof MenuComponent, typeof MenuItemComponent, typeof ItemTemplateDirective, typeof ItemLinkTemplateDirective, typeof ItemContentTemplateDirective, typeof HierarchyBindingDirective, typeof FlatBindingDirective, typeof LinkDirective, typeof ExpandArrowComponent], [typeof ContextMenuComponent, typeof ContextMenuTemplateDirective, typeof ContextMenuTargetDirective, typeof ContextMenuTargetContainerDirective, typeof MenuComponent, typeof MenuItemComponent, typeof ItemTemplateDirective, typeof ItemLinkTemplateDirective, typeof ItemContentTemplateDirective, typeof HierarchyBindingDirective, typeof FlatBindingDirective, typeof LinkDirective, typeof ExpandArrowComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ContextMenuModule>;
+}
+
+/**
+ * A [module](link:site.data.urls.angular['ngmoduleapi']) that includes the Menu and ContextMenu components and directives.
+ * Imports the MenusModule into your application [root module](link:site.data.urls.angular['ngmodules']#angular-modularity)
+ * or any other sub-module that will use the Menu and ContextMenu components.
+ *
+ * @example
+ * ```ts-no-run
+ * import { NgModule } from '@angular/core';
+ * import { BrowserModule } from '@angular/platform-browser';
+ * import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
+ * import { MenusModule } from '@progress/kendo-angular-menu';
+ * import { AppComponent } from './app.component';
+ *
+ * _@NgModule({
+ *     bootstrap:    [AppComponent],
+ *     declarations: [AppComponent],
+ *     imports:      [BrowserModule, BrowserAnimationsModule, MenusModule]
+ * })
+ * export class AppModule {
+ * }
+ * ```
+ */
+declare class MenusModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MenusModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MenusModule, never, [typeof MenuComponent, typeof MenuItemComponent, typeof ItemTemplateDirective, typeof ItemLinkTemplateDirective, typeof ItemContentTemplateDirective, typeof HierarchyBindingDirective, typeof FlatBindingDirective, typeof LinkDirective, typeof ExpandArrowComponent, typeof ContextMenuComponent, typeof ContextMenuTemplateDirective, typeof ContextMenuTargetDirective, typeof ContextMenuTargetContainerDirective, typeof MenuComponent, typeof MenuItemComponent, typeof ItemTemplateDirective, typeof ItemLinkTemplateDirective, typeof ItemContentTemplateDirective, typeof HierarchyBindingDirective, typeof FlatBindingDirective, typeof LinkDirective, typeof ExpandArrowComponent], [typeof MenuComponent, typeof MenuItemComponent, typeof ItemTemplateDirective, typeof ItemLinkTemplateDirective, typeof ItemContentTemplateDirective, typeof HierarchyBindingDirective, typeof FlatBindingDirective, typeof LinkDirective, typeof ExpandArrowComponent, typeof ContextMenuComponent, typeof ContextMenuTemplateDirective, typeof ContextMenuTargetDirective, typeof ContextMenuTargetContainerDirective, typeof MenuComponent, typeof MenuItemComponent, typeof ItemTemplateDirective, typeof ItemLinkTemplateDirective, typeof ItemContentTemplateDirective, typeof HierarchyBindingDirective, typeof FlatBindingDirective, typeof LinkDirective, typeof ExpandArrowComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MenusModule>;
+}
+
+/**
+ * Represents a utility array that contains all `Menu` related components and directives.
+ */
+declare const KENDO_MENU: readonly [typeof MenuComponent, typeof MenuItemComponent, typeof ItemTemplateDirective, typeof ItemLinkTemplateDirective, typeof ItemContentTemplateDirective, typeof HierarchyBindingDirective, typeof FlatBindingDirective, typeof LinkDirective, typeof ExpandArrowComponent];
+/**
+ * Represents a utility array that contains all `ContextMenu` related components and directives.
+ */
+declare const KENDO_CONTEXTMENU: readonly [typeof ContextMenuComponent, typeof ContextMenuTemplateDirective, typeof ContextMenuTargetDirective, typeof ContextMenuTargetContainerDirective, typeof MenuComponent, typeof MenuItemComponent, typeof ItemTemplateDirective, typeof ItemLinkTemplateDirective, typeof ItemContentTemplateDirective, typeof HierarchyBindingDirective, typeof FlatBindingDirective, typeof LinkDirective, typeof ExpandArrowComponent];
+/**
+ * Represents a utility array that contains all `@progress/kendo-angular-menu` related components and directives.
+ */
+declare const KENDO_MENUS: readonly [typeof MenuComponent, typeof MenuItemComponent, typeof ItemTemplateDirective, typeof ItemLinkTemplateDirective, typeof ItemContentTemplateDirective, typeof HierarchyBindingDirective, typeof FlatBindingDirective, typeof LinkDirective, typeof ExpandArrowComponent, typeof ContextMenuComponent, typeof ContextMenuTemplateDirective, typeof ContextMenuTargetDirective, typeof ContextMenuTargetContainerDirective, typeof MenuComponent, typeof MenuItemComponent, typeof ItemTemplateDirective, typeof ItemLinkTemplateDirective, typeof ItemContentTemplateDirective, typeof HierarchyBindingDirective, typeof FlatBindingDirective, typeof LinkDirective, typeof ExpandArrowComponent];
+
+export { ContextMenuComponent, ContextMenuEvent, ContextMenuModule, ContextMenuPopupEvent, ContextMenuSelectEvent, ContextMenuService, ContextMenuTargetContainerDirective, ContextMenuTargetDirective, ContextMenuTemplateDirective, ExpandArrowComponent, FlatBindingDirective, HierarchyBindingDirective, ItemComponent, ItemContentTemplateDirective, ItemLinkTemplateDirective, ItemTemplateDirective, ItemsService, KENDO_CONTEXTMENU, KENDO_MENU, KENDO_MENUS, LinkDirective, ListComponent, MenuComponent, MenuEvent, MenuItemComponent, MenuModule, MenuSelectEvent, MenusModule };
+export type { MenuAnimation, MenuItem, MenuSize, OpenOnClickSettings, PopupSettings };