@odx/angular 12.26.1 → 13.0.0

package/components/inline-message/index.d.ts

@@ -1,2 +1,36 @@
-export * from './lib/inline-message.component';
-export * from './lib/models';
+import * as i0 from '@angular/core';
+
+type InlineMessageVariant = typeof InlineMessageVariant[keyof typeof InlineMessageVariant];
+declare const InlineMessageVariant: {
+    readonly DEFAULT: "default";
+    readonly WARNING: "warning";
+    readonly DANGER: "danger";
+    readonly SUCCESS: "success";
+};
+
+/**
+ * Represents an inline message component used for displaying contextual feedback to users.
+ * This component can show different types of messages such as warnings, errors, successes, or informational messages,
+ * each with corresponding icons. It leverages the `IconComponent` to render these icons.
+ */
+declare class InlineMessageComponent {
+    readonly element: i0.ElementRef<HTMLElement>;
+    /**
+     * Determines the type of message to display, which influences the icon and styling.
+     * Default is `InlineMessageVariant.DEFAULT`, which is typically styled as an informational message.
+     *
+     * @type {InlineMessageVariant}
+     * @default InlineMessageVariant.DEFAULT
+     */
+    variant?: InlineMessageVariant | null;
+    /**
+     * Getter for the icon name based on the current variant.
+     *
+     * @returns {string} The icon name to display.
+     */
+    get icon(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InlineMessageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InlineMessageComponent, "odx-inline-message", never, { "variant": { "alias": "variant"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+export { InlineMessageComponent, InlineMessageVariant };

package/components/link/index.d.ts

@@ -1 +1,13 @@
-export * from './link.directive';
+import * as i0 from '@angular/core';
+import * as i1 from '@odx/angular';
+
+/**
+ * Represents a link directive.
+ */
+declare class LinkDirective {
+    readonly element: i0.ElementRef<HTMLLinkElement>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LinkDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<LinkDirective, "a[odxLink]", never, {}, {}, never, never, true, [{ directive: typeof i1.WithDisabledState; inputs: {}; outputs: {}; }, { directive: typeof i1.WithTabIndex; inputs: {}; outputs: {}; }]>;
+}
+
+export { LinkDirective };

package/components/list/index.d.ts

@@ -1,4 +1,86 @@
-export * from './lib/components';
-export * from './lib/list.component';
-export * from './lib/list.module';
-export * from './lib/models';
+import * as i0 from '@angular/core';
+import { OnChanges } from '@angular/core';
+import * as i1 from '@odx/angular/cdk/expandable';
+import { ExpandableItemDirective } from '@odx/angular/cdk/expandable';
+import { NgChanges } from '@odx/angular/utils';
+import * as i1$1 from '@odx/angular';
+import * as i4 from '@odx/angular/components/icon';
+
+/**
+ * Represents a component that serves as an expandable list item within an application.
+ * It uses animations for expanding and collapsing content, and it integrates seamlessly
+ * with other components such as buttons and icons for interactive elements.
+ *
+ * @see {ExpandableItemDirective}
+ */
+declare class ExpandableListItemComponent {
+    protected readonly expandableItem: ExpandableItemDirective;
+    readonly element: i0.ElementRef<HTMLElement>;
+    interactive: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExpandableListItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ExpandableListItemComponent, "odx-expandable-list-item", never, { "interactive": { "alias": "interactive"; "required": false; }; }, {}, never, ["odx-list-item, [odxListItem]", "odx-list"], true, [{ directive: typeof i1.ExpandableItemDirective; inputs: { "expanded": "expanded"; "id": "id"; "container": "container"; }; outputs: {}; }]>;
+    static ngAcceptInputType_interactive: unknown;
+}
+
+type ListItemVariant = (typeof ListItemVariant)[keyof typeof ListItemVariant];
+declare const ListItemVariant: {
+    readonly DEFAULT: "default";
+    readonly DANGER: "danger";
+    readonly WARNING: "warning";
+};
+
+/**
+ * Represents a stylable list item component that can be easily integrated within Angular applications.
+ * It supports various visual variants, disabled and selected states, and can be used both as a standalone or
+ * as an element in a larger list or collection of items.
+ */
+declare class ListItemComponent implements OnChanges {
+    private readonly withTabIndex;
+    readonly element: i0.ElementRef<HTMLElement>;
+    /**
+     * Specifies the visual variant of the list item.
+     *
+     * @type {ListItemVariant}
+     * @default ListItemVariant.DEFAULT
+     */
+    variant: ListItemVariant;
+    /**
+     * Marks the list item as disabled, preventing user interaction and changing its appearance.
+     *
+     * @type {boolean}
+     * @default false
+     */
+    muted: boolean;
+    /**
+     * Marks the list item as selected, changing its appearance to indicate its state.
+     *
+     * @type {boolean}
+     * @default false
+     */
+    selected: boolean;
+    ngOnChanges(changes: NgChanges<ListItemComponent>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ListItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ListItemComponent, "odx-list-item, [odxListItem]", never, { "variant": { "alias": "variant"; "required": false; }; "muted": { "alias": "muted"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; }, {}, never, ["[odxListPrefix], [odxListItemPrefix]", "*", "[odxListSuffix], [odxListItemSuffix]"], true, [{ directive: typeof i1$1.WithDisabledState; inputs: {}; outputs: {}; }, { directive: typeof i1$1.WithTabIndex; inputs: {}; outputs: {}; }]>;
+    static ngAcceptInputType_muted: unknown;
+    static ngAcceptInputType_selected: unknown;
+}
+
+/**
+ * Represents a list component that can optionally act as an expandable container. This component can be used
+ * to display a list of items where each item might be individually expandable.
+ *
+ * @see {ExpandableContainerDirective}
+ */
+declare class ListComponent {
+    readonly element: i0.ElementRef<HTMLElement>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ListComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ListComponent, "odx-list", never, {}, {}, never, ["odx-list, odx-list-item, [odxListItem], odx-expandable-list-item"], true, [{ directive: typeof i1.ExpandableContainerDirective; inputs: { "multiple": "multiple"; }; outputs: {}; }]>;
+}
+
+declare class ListModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ListModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ListModule, never, [typeof ListComponent, typeof ListItemComponent, typeof ExpandableListItemComponent, typeof i4.IconComponent], [typeof ListComponent, typeof ListItemComponent, typeof ExpandableListItemComponent, typeof i4.IconComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ListModule>;
+}
+
+export { ExpandableListItemComponent, ListComponent, ListItemComponent, ListItemVariant, ListModule };

package/components/loading-spinner/index.d.ts

@@ -1,3 +1,89 @@
-export * from './lib/loading-spinner.component';
-export * from './lib/loading-spinner.directive';
-export * from './lib/loading-spinner.module';
+import * as i0 from '@angular/core';
+import { OnInit } from '@angular/core';
+import { AnimationEvent } from '@angular/animations';
+import * as i3 from '@odx/angular';
+
+/**
+ * Represents a loading spinner component.
+ */
+declare class LoadingSpinnerComponent implements OnInit {
+    private readonly host;
+    private readonly windowRef;
+    protected backgroundColor: string | null;
+    readonly element: i0.ElementRef<HTMLElement>;
+    /**
+     * Indicates whether the color of the loading spinner should be automatically determined.
+     * If set to true, the color will be based on the theme of the parent container.
+     * If set to false, the color will be the default color specified in the component's styles.
+     *
+     * @type {boolean}
+     * @default false
+     */
+    autoColor: boolean;
+    ngOnInit(): void;
+    protected animationFinished({ toState }: AnimationEvent): void;
+    private resolveBackgroundColor;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoadingSpinnerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LoadingSpinnerComponent, "odx-loading-spinner", never, { "autoColor": { "alias": "autoColor"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * A directive that controls the display of a loading spinner overlay on the host element.
+ * This directive can dynamically create or remove a loading spinner based on the `isLoading` state.
+ * It modifies the host element's styles to ensure the spinner is displayed correctly, and optionally,
+ * it can set a minimum height to prevent layout shifts.
+ */
+declare class LoadingSpinnerDirective {
+    private readonly dynamicViewService;
+    private readonly hostElement;
+    private readonly renderer;
+    private readonly injector;
+    private readonly windowRef;
+    private parentMinHeight?;
+    private viewRef;
+    /**
+     * Whether the spinner should automatically adjust its color based on the background.
+     * Allows the user to specify if the spinner should use automatic color adjustment.
+     *
+     * @type {boolean}
+     * @default false
+     */
+    autoColor: boolean;
+    /**
+     * Controls whether the spinner is visible or not.
+     * Manages the loading state, showing or hiding the spinner accordingly.
+     *
+     * @type {boolean}
+     */
+    set isLoading(value: boolean);
+    get isLoading(): boolean;
+    /**
+     * Sets the minimum height for the host element when the spinner is active, to avoid layout shifts.
+     * Specifies the minimum height for the spinner's parent element.
+     *
+     * @type {number}
+     */
+    set minHeight(value: number);
+    /**
+     * Resets styles applied to the parent element when the spinner is removed.
+     * Removes the class, minHeight, and position styles.
+     */
+    resetParentStyles(): void;
+    private setParentHeight;
+    private createSpinner;
+    private removeSpinner;
+    private hasStaticPosition;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoadingSpinnerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<LoadingSpinnerDirective, "[odxLoadingSpinner]", never, { "autoColor": { "alias": "odxLoadingSpinnerAutoColor"; "required": false; }; "isLoading": { "alias": "odxLoadingSpinner"; "required": false; }; "minHeight": { "alias": "odxLoadingSpinnerMinHeight"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_autoColor: unknown;
+    static ngAcceptInputType_isLoading: unknown;
+    static ngAcceptInputType_minHeight: unknown;
+}
+
+declare class LoadingSpinnerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoadingSpinnerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<LoadingSpinnerModule, never, [typeof LoadingSpinnerComponent, typeof LoadingSpinnerDirective], [typeof i3.CoreModule, typeof LoadingSpinnerComponent, typeof LoadingSpinnerDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<LoadingSpinnerModule>;
+}
+
+export { LoadingSpinnerComponent, LoadingSpinnerDirective, LoadingSpinnerModule };

package/components/logo/index.d.ts

@@ -1,2 +1,39 @@
-export * from './logo.directive';
-export * from './models';
+import * as i0 from '@angular/core';
+
+type LogoSize = typeof LogoSize[keyof typeof LogoSize];
+declare const LogoSize: {
+    readonly SMALL: "small";
+    readonly MEDIUM: "medium";
+    readonly LARGE: "large";
+};
+
+type LogoVariant = typeof LogoVariant[keyof typeof LogoVariant];
+declare const LogoVariant: {
+    readonly DEFAULT: "default";
+    readonly INVERSE: "inverse";
+};
+
+/**
+ * A directive that handles the presentation of a logo with configurable size and variant.
+ */
+declare class LogoDirective {
+    readonly element: i0.ElementRef<HTMLElement>;
+    /**
+     * The size of the logo.
+     *
+     * @type {LogoSize}
+     * @default LogoSize.SMALL
+     */
+    size: LogoSize;
+    /**
+     * The variant of the logo.
+     *
+     * @type {LogoVariant}
+     * @default LogoVariant.DEFAULT
+     */
+    variant: LogoVariant;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LogoDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<LogoDirective, "odx-logo", never, { "size": { "alias": "size"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+export { LogoDirective, LogoSize, LogoVariant };

package/components/main-menu/index.d.ts

@@ -1,4 +1,217 @@
-export * from './lib/directives';
-export * from './lib/main-menu.component';
-export * from './lib/main-menu.config';
-export * from './lib/main-menu.module';
+import * as i0 from '@angular/core';
+import { AfterViewInit, ElementRef } from '@angular/core';
+import { RouterLinkActive } from '@angular/router';
+import * as i1 from '@odx/angular';
+import * as rxjs from 'rxjs';
+import { Observable } from 'rxjs';
+import { DynamicTextContent } from '@odx/angular/cdk/dynamic-view';
+import * as _odx_angular_utils from '@odx/angular/utils';
+import * as i1$1 from '@odx/angular/components/link';
+
+/**
+ * Represents a directive for a main menu button.
+ * This directive is used to toggle the main menu.
+ */
+declare class MainMenuButtonDirective {
+    private readonly mainMenuService;
+    readonly element: i0.ElementRef<HTMLButtonElement>;
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MainMenuButtonDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MainMenuButtonDirective, "button[odxMainMenuButton]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Represents a directive for closing the main menu.
+ */
+declare class MainMenuCloseDirective {
+    private readonly mainMenu;
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MainMenuCloseDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MainMenuCloseDirective, "[odxMainMenuClose]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Represents a directive for a main menu item.
+ * This directive is used to define a main menu item.
+ * Has host directives for disabled state, tabindex, and closing the main menu.
+ *
+ * @see {WithDisabledState}
+ * @see {WithTabIndex}
+ * @see {MainMenuCloseDirective}
+ */
+declare class MainMenuItemDirective {
+    protected readonly routerLinkActive: RouterLinkActive | null;
+    readonly element: i0.ElementRef<HTMLElement>;
+    /**
+     * Optionally specifies whether the menu item is selected.
+     * If not specified, the menu item will not be selected.
+     *
+     * @type {boolean}
+     * @default false
+     */
+    isSelected: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MainMenuItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MainMenuItemDirective, "[odxMainMenuItem]", never, { "isSelected": { "alias": "isSelected"; "required": false; }; }, {}, never, never, true, [{ directive: typeof i1.WithDisabledState; inputs: {}; outputs: {}; }, { directive: typeof i1.WithTabIndex; inputs: {}; outputs: {}; }, { directive: typeof MainMenuCloseDirective; inputs: {}; outputs: {}; }]>;
+    static ngAcceptInputType_isSelected: unknown;
+}
+
+interface MainMenuLink {
+    name: string;
+    url: string;
+}
+
+/**
+ * Provides control over the state of the main menu, allowing components to open, close, or toggle its visibility.
+ * This service uses a BehaviorSubject to manage the open state and exposes an observable that emits the current state.
+ */
+declare class MainMenuService {
+    private readonly isOpen$$;
+    /**
+     * An Observable that emits the current state of the menu's visibility.
+     * It uses distinctUntilChanged to prevent unnecessary emissions when the state hasn't actually changed.
+     * shareReplay is configured to cache the last value for any late subscribers.
+     *
+     * @emits {boolean} The current visibility state of the main menu.
+     */
+    readonly isOpen$: rxjs.Observable<boolean>;
+    /**
+     * Returns the current visibility state of the main menu.
+     *
+     * @returns {boolean} True if the menu is open, false otherwise.
+     */
+    isOpen(): boolean;
+    /**
+     * Opens the main menu by setting its state to true.
+     */
+    open(): void;
+    /**
+     * Closes the main menu by setting its state to false.
+     */
+    close(): void;
+    /**
+     * Toggles the visibility state of the main menu.
+     *
+     * @param {boolean | undefined} forceState - If provided, the menu will be set to this specific state. If not provided,
+     * the menu will toggle to the opposite of its current state.
+     */
+    toggle(forceState?: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MainMenuService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MainMenuService>;
+}
+
+/**
+ * The `MainMenuComponent` provides a comprehensive user interface component for displaying a navigation menu within an application.
+ * It supports dynamic content for titles, subtitles, and copyright text, and can dynamically render additional links.
+ * The menu includes animations for opening and closing states, and can be controlled programmatically or via user interaction.
+ */
+declare class MainMenuComponent implements AfterViewInit {
+    private readonly takeUntilDestroyed;
+    protected readonly mainMenuService: MainMenuService;
+    protected readonly mainMenuLinks$: rxjs.Observable<MainMenuLink[]>;
+    protected readonly isOpen$: rxjs.Observable<boolean>;
+    readonly element: ElementRef<HTMLElement>;
+    /**
+     * Input property for the title of the menu. The content is dynamic, allowing complex content structures
+     * like translations or custom components.
+     *
+     * @type {DynamicTextContent}
+     */
+    title: DynamicTextContent;
+    /**
+     * Optional input property for the subtitle of the menu.
+     *
+     * @type {DynamicTextContent | null}
+     * @default null
+     */
+    subtitle?: DynamicTextContent | null;
+    /**
+     * Optional input property for the copyright text of the menu.
+     *
+     * @type {DynamicTextContent | null}
+     * @default null
+     */
+    copyright?: DynamicTextContent | null;
+    /**
+     * Input property to control the open state of the menu. Uses boolean transformation to handle true/false states.
+     * Changing this property will toggle the menu's open state via the MainMenuService.
+     *
+     * @param {boolean} value - The open state of the menu.
+     */
+    set isOpen(value: boolean);
+    /**
+     * Returns the current open state of the menu from the MainMenuService.
+     *
+     * @returns {boolean} `true` if the menu is open, `false` otherwise.
+     */
+    get isOpen(): boolean;
+    /**
+     * Outputs the observable that tracks the open state of the menu.
+     *
+     * @emits {boolean} The open state of the menu.
+     */
+    menuOpen: rxjs.Observable<boolean>;
+    menuInner: ElementRef<HTMLElement>;
+    ngAfterViewInit(): void;
+    /**
+     * Closes the menu.
+     */
+    close(): void;
+    private slideMenuInner;
+    private isPopoverElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MainMenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MainMenuComponent, "odx-main-menu", never, { "title": { "alias": "title"; "required": true; }; "subtitle": { "alias": "subtitle"; "required": false; }; "copyright": { "alias": "copyright"; "required": false; }; "isOpen": { "alias": "isOpen"; "required": false; }; }, { "menuOpen": "menuOpen"; }, never, ["*", "[odxLink]"], true, never>;
+    static ngAcceptInputType_isOpen: unknown;
+}
+
+interface MainMenuLinksConfig {
+    dataProtectionUrl?: string | null;
+    legalNoticeUrl: string | null;
+    providerIdentificationUrl: string | null;
+    termsAndConditionsUrl?: string | null;
+    openSourceUrl?: string | null;
+    statusUrl?: string | null;
+    dynamicLinks?: Observable<MainMenuLink[]>;
+}
+/**
+ * Tokens generated to provide and inject `MainMenuLinksConfig`. These tokens are used to configure and access main menu links throughout the application.
+ *
+ * @exports
+ * - `MainMenuLinksConfig` - Token for injecting the config.
+ * - `MainMenuLinksDefaultConfig` - Default configuration for main menu links.
+ * - `injectMainMenuLinksConfig` - Function to inject the config wherever needed.
+ * - `provideMainMenuLinksConfig` - Provider function to configure and provide the config in Angular's DI system.
+ *
+ * @example
+ * ```ts
+ * // Providing main menu links in an Angular module
+ * @NgModule({
+ *  providers: [
+ *   provideMainMenuLinksConfig({
+ *     legalNoticeUrl: 'https://example.com/legalnotice',
+ *     providerIdentificationUrl: 'https://example.com/provideridentification',
+ *    }),
+ *   ],
+ *  })
+ * export class AppModule { }
+ *
+ * // Injecting and using the main menu links configuration in a component
+ * @Component({ ... })
+ * export class MyComponent {
+ *  constructor(@Inject(MainMenuLinksConfig) private config: MainMenuLinksConfig) {
+ *   console.log('Legal Notice URL:', config.legalNoticeUrl);
+ *  }
+ * }
+ * ```
+ */
+declare const MainMenuLinksConfig: i0.InjectionToken<Partial<MainMenuLinksConfig>>;
+declare const MainMenuLinksDefaultConfig: MainMenuLinksConfig;
+declare const injectMainMenuLinksConfig: () => MainMenuLinksConfig;
+declare const provideMainMenuLinksConfig: <D extends _odx_angular_utils.ConfigDependencies = _odx_angular_utils.ConfigDependencies<Partial<MainMenuLinksConfig>>>(config: _odx_angular_utils.ConfigProvider<Partial<MainMenuLinksConfig>, D>) => i0.FactoryProvider | i0.ValueProvider;
+
+declare class MainMenuModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MainMenuModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MainMenuModule, never, [typeof i1$1.LinkDirective, typeof MainMenuComponent, typeof MainMenuItemDirective, typeof MainMenuButtonDirective, typeof MainMenuCloseDirective], [typeof i1.CoreModule, typeof i1$1.LinkDirective, typeof MainMenuComponent, typeof MainMenuItemDirective, typeof MainMenuButtonDirective, typeof MainMenuCloseDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MainMenuModule>;
+}
+
+export { MainMenuButtonDirective, MainMenuCloseDirective, MainMenuComponent, MainMenuItemDirective, MainMenuLinksConfig, MainMenuLinksDefaultConfig, MainMenuModule, injectMainMenuLinksConfig, provideMainMenuLinksConfig };

package/components/mainfilter-group/index.d.ts

@@ -1 +1,13 @@
-export * from './lib/mainfilter-group.component';
+import * as i0 from '@angular/core';
+
+/**
+ * Represents the MainfilterGroupComponent class.
+ * This component is responsible for styling the main filter group.
+ */
+declare class MainfilterGroupComponent {
+    readonly element: i0.ElementRef<HTMLElement>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MainfilterGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MainfilterGroupComponent, "odx-mainfilter-group", never, {}, {}, never, ["*"], true, never>;
+}
+
+export { MainfilterGroupComponent };

package/components/menu/index.d.ts

@@ -1,4 +1,94 @@
-export * from './lib/directives';
-export * from './lib/menu.component';
-export * from './lib/menu.directive';
-export * from './lib/menu.module';
+import * as i0 from '@angular/core';
+import { OnChanges } from '@angular/core';
+import * as i1 from '@odx/angular/cdk/a11y';
+import { DynamicContent, DynamicTextContent } from '@odx/angular/cdk/dynamic-view';
+import * as i1$1 from '@odx/angular/components/dropdown';
+import { DropdownDirective } from '@odx/angular/components/dropdown';
+import { Position, NgChanges } from '@odx/angular/utils';
+import * as i4 from '@odx/angular/components/icon';
+import * as i5 from '@odx/angular';
+
+/**
+ * Represents a directive for a menu item.
+ * Uses the `ListFocusManagerOptionDirective` to manage focus within the menu items.
+ *
+ * @see {ListFocusManagerOptionDirective}
+ */
+declare class MenuItemDirective {
+    readonly element: i0.ElementRef<HTMLButtonElement | HTMLLinkElement>;
+    protected selectItem(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MenuItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MenuItemDirective, "a[odxButton][odxMenuItem], button[odxButton][odxMenuItem]", never, {}, {}, never, never, true, [{ directive: typeof i1.ListFocusManagerOptionDirective; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * `MenuComponent` provides an Angular component for creating a navigational menu structure in an application.
+ * It utilizes the `ListFocusManagerDirective` to manage focus within the menu items and integrates with other custom components like `ActionGroupComponent`.
+ * The component is styled using CSS component techniques to ensure a consistent look and feel across different parts of the application.
+ * @see {ListFocusManagerDirective}
+ */
+declare class MenuComponent {
+    readonly element: i0.ElementRef<HTMLElement>;
+    /**
+     * A CSS modifier that indicates if the menu should use a tile layout. This is controlled through an input property which can be bound to a boolean value.
+     *
+     * @type {boolean}
+     * @default false
+     */
+    tile: boolean;
+    protected onTab(event: KeyboardEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MenuComponent, "odx-menu", never, { "tile": { "alias": "tile"; "required": false; }; }, {}, never, ["*", "[odxButton]"], true, [{ directive: typeof i1.ListFocusManagerDirective; inputs: {}; outputs: {}; }]>;
+    static ngAcceptInputType_tile: unknown;
+}
+
+/**
+ * `MenuDirective` integrates a menu system into elements using the `DropdownDirective`
+ * for dynamic dropdown functionality.
+ * It enables flexible positioning and content injection capabilities, making it suitable
+ * for creating context menus, dropdown lists, and other interactive menu-driven components.
+ *
+ * @see {DropdownDirective}
+ */
+declare class MenuDirective implements OnChanges {
+    protected readonly dropdown: DropdownDirective;
+    readonly element: i0.ElementRef<HTMLElement>;
+    /**
+     * Accepts dynamic content other than `DynamicTextContent` to be used as the content of the dropdown.
+     * This allows for more complex content structures such as templates or components to be defined
+     * as dropdown content.
+     *
+     * @type {Exclude<DynamicContent, DynamicTextContent> | null}
+     */
+    content?: Exclude<DynamicContent, DynamicTextContent> | null;
+    /**
+     * Optionally specifies the positioning of the dropdown menu relative to its trigger element.
+     * If not specified, a default position may be used.
+     *
+     * @type {Position | null}
+     */
+    position?: Position | null;
+    ngOnChanges(changes: NgChanges<MenuDirective>): void;
+    /**
+     * Returns whether the dropdown is currently open.
+     *
+     * @returns {boolean} `true` if the dropdown is open, `false` otherwise.
+     */
+    isOpen(): boolean;
+    /**
+     * Closes the dropdown.
+     *
+     * @param {Event} [event] The event that triggered the dropdown close.
+     */
+    close(event?: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MenuDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MenuDirective, "[odxMenu]", ["odxMenu"], { "content": { "alias": "odxMenu"; "required": false; }; "position": { "alias": "odxMenuPosition"; "required": false; }; }, {}, never, never, true, [{ directive: typeof i1$1.DropdownDirective; inputs: { "odxDropdown": "odxMenu"; }; outputs: {}; }]>;
+}
+
+declare class MenuModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MenuModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MenuModule, never, [typeof MenuComponent, typeof MenuDirective, typeof MenuItemDirective, typeof i4.IconComponent], [typeof i5.CoreModule, typeof MenuComponent, typeof MenuDirective, typeof MenuItemDirective, typeof i4.IconComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MenuModule>;
+}
+
+export { MenuComponent, MenuDirective, MenuItemDirective, MenuModule };