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

package/index.d.ts

@@ -2,33 +2,1591 @@
 * 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, AfterContentInit, TrackByFunction, OnChanges, AfterViewChecked, OnDestroy, ViewContainerRef, Renderer2, OnInit, AfterViewInit, ElementRef } 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 {
+    set text(value: string);
+    get text(): string;
+    set url(value: string);
+    get url(): string;
+    set disabled(value: boolean);
+    get disabled(): boolean;
+    set cssClass(value: any);
+    get cssClass(): any;
+    set cssStyle(value: any);
+    get cssStyle(): any;
+    set icon(value: string);
+    get icon(): string;
+    set svgIcon(value: SVGIcon$1);
+    get svgIcon(): SVGIcon$1;
+    set data(value: any);
+    get data(): any;
+    set separator(value: boolean);
+    get 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[];
+    private _text;
+    private _url;
+    private _disabled;
+    private _cssClass;
+    private _cssStyle;
+    private _icon;
+    private _svgIcon;
+    private _data;
+    private _separator;
+    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 implements AfterContentInit {
+    /**
+     * Specifies the Menu items.
+     */
+    set items(value: any[]);
+    get items(): any[];
+    /**
+     * Specifies if the Menu will be vertical ([see example](https://www.telerik.com/kendo-angular-ui/components/menus/menu/vertical)).
+     */
+    set vertical(value: boolean);
+    get 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)).
+     */
+    set openOnClick(value: boolean | OpenOnClickSettings);
+    get 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.
+     */
+    set hoverDelay(value: number);
+    get hoverDelay(): number;
+    /**
+     * Sets the Menu animation.
+     */
+    set animate(value: boolean | MenuAnimation);
+    get animate(): boolean | MenuAnimation;
+    /**
+     * Sets the Menu size.
+     *
+     * The possible values are:
+     * * `small`
+     * * `medium`
+     * * `large`
+     *
+     */
+    set size(value: MenuSize);
+    get size(): MenuSize;
+    /**
+     * Configures the popup settings for the Menu items.
+     * Allows customization of the popup class and margin.
+     */
+    set popupSettings(value: PopupSettings);
+    get popupSettings(): PopupSettings;
+    /**
+     * Defines a function that determines how to track for the menu items.
+     * By default, the component tracks changes by index.
+     */
+    set trackBy(value: TrackByFunction<any>);
+    get trackBy(): TrackByFunction<any>;
+    /**
+     * @hidden
+     */
+    itemTemplate: QueryList<ItemTemplateDirective>;
+    /**
+     * @hidden
+     */
+    itemLinkTemplate: QueryList<ItemLinkTemplateDirective>;
+    /**
+     * @hidden
+     */
+    children: QueryList<MenuItemComponent>;
+    protected _items: i0.WritableSignal<any[]>;
+    protected _vertical: i0.WritableSignal<boolean>;
+    protected _openOnClick: i0.WritableSignal<boolean | OpenOnClickSettings>;
+    protected _hoverDelay: i0.WritableSignal<number>;
+    protected _animate: i0.WritableSignal<boolean | MenuAnimation>;
+    protected _size: i0.WritableSignal<MenuSize>;
+    protected _popupSettings: i0.WritableSignal<PopupSettings>;
+    protected _trackBy: i0.WritableSignal<TrackByFunction<any>>;
+    protected _children: i0.WritableSignal<MenuItemComponent[]>;
+    private destroyRef;
+    ngAfterContentInit(): void;
+    /**
+     * @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, OnDestroy {
+    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.
+     */
+    set appendTo(value: ViewContainerRef);
+    get appendTo(): ViewContainerRef;
+    /**
+     * @hidden
+     */
+    set menuItemTemplate(value: TemplateRef<any>);
+    get menuItemTemplate(): TemplateRef<any>;
+    /**
+     * @hidden
+     */
+    set ariaRole(value: string);
+    get ariaRole(): string;
+    /**
+     * @hidden
+     */
+    set menuItemLinkTemplate(value: TemplateRef<any>);
+    get 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;
+    private localizationSubscription;
+    private _appendTo;
+    private _menuItemTemplate;
+    private _ariaRole;
+    private _menuItemLinkTemplate;
+    private _rtl;
+    constructor(itemsService: ItemsService, hover: HoverService, actions: ActionsService, navigation: NavigationService, localization: LocalizationService, ngZone: NgZone, renderer: Renderer2, contextService?: ContextMenuService);
+    ngOnChanges(changes: any): void;
+    /**
+     * 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;
+    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;
+    set appendTo(value: ViewContainerRef);
+    get appendTo(): ViewContainerRef;
+    set items(value: any[]);
+    get items(): any[];
+    set level(value: number);
+    get level(): number;
+    set index(value: string);
+    get index(): string;
+    set animate(value: boolean | MenuAnimation);
+    get animate(): boolean | MenuAnimation;
+    set size(value: MenuSize);
+    get size(): MenuSize;
+    set vertical(value: boolean);
+    get vertical(): boolean;
+    set rtl(value: boolean);
+    get rtl(): boolean;
+    set openOnClick(value: any);
+    get openOnClick(): any;
+    set itemTemplate(value: TemplateRef<any>);
+    get itemTemplate(): TemplateRef<any>;
+    set itemLinkTemplate(value: TemplateRef<any>);
+    get itemLinkTemplate(): TemplateRef<any>;
+    set popupSettings(value: PopupSettings);
+    get popupSettings(): PopupSettings;
+    set trackBy(value: TrackByFunction<any>);
+    get trackBy(): TrackByFunction<any>;
+    private domSubscriptions;
+    private _appendTo;
+    private _items;
+    private _level;
+    private _index;
+    private _animate;
+    private _size;
+    private _vertical;
+    private _rtl;
+    private _openOnClick;
+    private _itemTemplate;
+    private _itemLinkTemplate;
+    private _popupSettings;
+    private _trackBy;
+    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, AfterViewInit, OnDestroy {
+    private itemsService;
+    private navigation;
+    private renderer;
+    private popupService;
+    element: ElementRef;
+    private contextService?;
+    set appendTo(value: ViewContainerRef);
+    get appendTo(): ViewContainerRef;
+    set item(value: any);
+    get item(): any;
+    set level(value: number);
+    get level(): number;
+    set index(index: string);
+    get index(): string;
+    set siblingIndex(value: number);
+    get siblingIndex(): number;
+    set animate(value: boolean | MenuAnimation);
+    get animate(): boolean | MenuAnimation;
+    set size(value: MenuSize);
+    get size(): MenuSize;
+    set vertical(value: boolean);
+    get vertical(): boolean;
+    set rtl(value: boolean);
+    get rtl(): boolean;
+    set openOnClick(value: any);
+    get openOnClick(): any;
+    set itemTemplate(value: TemplateRef<any>);
+    get itemTemplate(): TemplateRef<any>;
+    set itemLinkTemplate(value: TemplateRef<any>);
+    get itemLinkTemplate(): TemplateRef<any>;
+    set popupSettings(value: PopupSettings);
+    get popupSettings(): PopupSettings;
+    set trackBy(value: TrackByFunction<any>);
+    get 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;
+    get opened(): boolean;
+    set opened(value: boolean);
+    navigating: boolean;
+    childId: string;
+    private contentItems;
+    private popupRef;
+    private destroyed;
+    private _index;
+    private _appendTo;
+    private _item;
+    private _level;
+    private _opened;
+    private _siblingIndex;
+    private _animate;
+    private _size;
+    private _vertical;
+    private _rtl;
+    private _openOnClick;
+    private _itemTemplate;
+    private _itemLinkTemplate;
+    private _popupSettings;
+    private _trackBy;
+    constructor(itemsService: ItemsService, navigation: NavigationService, renderer: Renderer2, popupService: PopupService, element: ElementRef, contextService?: ContextMenuService);
+    hasContentTemplates(): boolean;
+    ngOnInit(): 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, { 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.
+     */
+    set index(value: string);
+    get index(): string;
+    private _index;
+    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.
+     */
+    set index(value: string);
+    get index(): string;
+    private _index;
+    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 {
+    protected menu: MenuBase;
+    set data(value: any[]);
+    get data(): any[];
+    protected _data: i0.WritableSignal<any[]>;
+    protected fields: any[];
+    constructor(menu: MenuBase);
+    /**
+     *  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.
+     */
+    set data(value: any[]);
+    get data(): any[];
+    /**
+     * Defines the `text` field (or fields) of an item.
+     */
+    set textField(value: string | string[]);
+    get textField(): string | string[];
+    /**
+     * Defines the `url` field (or fields) of an item.
+     */
+    set urlField(value: string | string[]);
+    get urlField(): string | string[];
+    /**
+     * Defines the `icon` field (or fields) of an item.
+     */
+    set iconField(value: string | string[]);
+    get iconField(): string | string[];
+    /**
+     * Defines the `svgIcon` field of the items.
+     */
+    set svgIconField(value: string | string[]);
+    get svgIconField(): string | string[];
+    /**
+     * Defines the `disabled` field (or fields) of an item.
+     */
+    set disabledField(value: string | string[]);
+    get disabledField(): string | string[];
+    /**
+     * Defines the `cssClass` field (or fields) of an item.
+     */
+    set cssClassField(value: string | string[]);
+    get cssClassField(): string | string[];
+    /**
+     * Defines the `cssStyle` field (or fields) of an item.
+     */
+    set cssStyleField(value: string | string[]);
+    get cssStyleField(): string | string[];
+    /**
+     * Defines the `separator` field (or fields) of the items.
+     */
+    set separatorField(value: string | string[]);
+    get separatorField(): string | string[];
+    /**
+     * Defines the `children` field (or fields) of the items.
+     */
+    set childrenField(value: string | string[]);
+    get childrenField(): string | string[];
+    private _textField;
+    private _urlField;
+    private _iconField;
+    private _svgIconField;
+    private _disabledField;
+    private _cssClassField;
+    private _cssStyleField;
+    private _separatorField;
+    private _childrenField;
+    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.
+     */
+    set data(value: any[]);
+    get data(): any[];
+    /**
+     * Defines the `text` field of the items.
+     */
+    set textField(value: string);
+    get textField(): string;
+    /**
+     * Defines the `url` field of the items.
+     */
+    set urlField(value: string);
+    get urlField(): string;
+    /**
+     * Defines the `icon` field of the items.
+     */
+    set iconField(value: string | string[]);
+    get iconField(): string | string[];
+    /**
+     * Defines the `svgIcon` field of the items.
+     */
+    set svgIconField(value: string | string[]);
+    get svgIconField(): string | string[];
+    /**
+     * Defines the `disabled` field of the items.
+     */
+    set disabledField(value: string);
+    get disabledField(): string;
+    /**
+     * Defines the `cssClass` field of the items.
+     */
+    set cssClassField(value: string);
+    get cssClassField(): string;
+    /**
+     * Defines the `cssStyle` field of the items.
+     */
+    set cssStyleField(value: string);
+    get cssStyleField(): string;
+    /**
+     * Defines the `separator` field of the items.
+     */
+    set separatorField(value: string);
+    get separatorField(): string;
+    /**
+     * Defines the `id` field of the items.
+     */
+    set idField(value: string);
+    get idField(): string;
+    /**
+     * Defines the parent `id` field of the items.
+     */
+    set parentIdField(value: string);
+    get parentIdField(): string;
+    private _textField;
+    private _urlField;
+    private _iconField;
+    private _svgIconField;
+    private _disabledField;
+    private _cssClassField;
+    private _cssStyleField;
+    private _separatorField;
+    private _idField;
+    private _parentIdField;
+    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, 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'
+     */
+    set showOn(value: string);
+    get 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)).
+     */
+    set target(value: HTMLElement | ElementRef | ContextMenuTargetContainerDirective | string);
+    get 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)).
+     */
+    set filter(value: string);
+    get filter(): string;
+    /**
+     * Specifies if the ContextMenu will be aligned to the target or to the `filter` element (if specified).
+     *
+     * @default false
+     */
+    set alignToAnchor(value: boolean);
+    get 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
+     */
+    set vertical(value: boolean);
+    get vertical(): boolean;
+    /**
+     * Specifies the popup animation.
+     *
+     * @default true
+     */
+    set popupAnimate(value: boolean | PopupAnimation);
+    get popupAnimate(): boolean | PopupAnimation;
+    /**
+     * Specifies the pivot point of the popup.
+     *
+     * @default { horizontal: 'left', vertical: 'top' }
+     */
+    set popupAlign(value: Align);
+    get popupAlign(): Align;
+    /**
+     * Specifies the pivot point of the anchor. Applicable if `alignToAnchor` is `true`.
+     *
+     * @default { horizontal: 'left', vertical: 'bottom' }
+     */
+    set anchorAlign(value: Align);
+    get anchorAlign(): Align;
+    /**
+     * Configures the collision behavior of the popup.
+     *
+     * @default { horizontal: 'fit', vertical: 'flip' }
+     */
+    set collision(value: Collision);
+    get collision(): Collision;
+    /**
+     * Defines the container to which the popups will be appended.
+     */
+    set appendTo(value: ViewContainerRef);
+    get 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.
+     */
+    set ariaLabel(value: string);
+    get 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;
+    private _showOn;
+    private _target;
+    private _filter;
+    private _alignToAnchor;
+    private _popupAnimate;
+    private _popupAlign;
+    private _anchorAlign;
+    private _collision;
+    private _appendTo;
+    private _ariaLabel;
+    protected _vertical: i0.WritableSignal<boolean>;
+    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;
+    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.
+     */
+    set data(value: any);
+    get data(): any;
+    /**
+     * Specifies the target DOM element.
+     */
+    element: any;
+    /**
+     * @hidden
+     */
+    hostClass: boolean;
+    private _data;
+    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 };