@cute-widgets/base 20.0.1

package/menu/index.d.ts

@@ -0,0 +1,497 @@
+import * as i0 from '@angular/core';
+import { OnDestroy, InjectionToken, TemplateRef, EventEmitter, AfterViewInit, AfterContentInit, OnInit, QueryList, ElementRef, ViewContainerRef, NgZone } from '@angular/core';
+import { AnimationEvent } from '@angular/animations';
+import { FocusOrigin, FocusableOption, FocusMonitor } from '@angular/cdk/a11y';
+import { Direction, Directionality } from '@angular/cdk/bidi';
+import { Subject, Observable } from 'rxjs';
+import * as i1 from '@angular/cdk/menu';
+import { ScrollStrategy, Overlay } from '@angular/cdk/overlay';
+import * as i1$1 from '@angular/common';
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * This code is a modification of the `@angular/material` original
+ * code licensed under MIT-style License (https://angular.dev/license).
+ */
+/** Menu position on X axis. */
+type MenuPositionX = 'before' | 'after';
+/** Menu position on Y axis. */
+type MenuPositionY = 'above' | 'below';
+
+/**
+ * Injection token that can be used to reference instances of `CuteMenuContent`. It serves
+ * as an alternative token to the actual `CuteMenuContent` class, which could cause unnecessary
+ * retention of the class and its directive metadata.
+ */
+declare const CUTE_MENU_CONTENT: InjectionToken<CuteMenuContent>;
+/** Menu content that will be rendered lazily once the menu is opened. */
+declare class CuteMenuContent implements OnDestroy {
+    private _template;
+    private _appRef;
+    private _injector;
+    private _viewContainerRef;
+    private _document;
+    private _changeDetectorRef;
+    private _portal;
+    private _outlet;
+    /** Emits when the menu content has been attached. */
+    readonly _attached: Subject<void>;
+    constructor(...args: unknown[]);
+    /**
+     * Attaches the content with a particular context.
+     */
+    attach(context?: any): void;
+    /**
+     * Detaches the content.
+     */
+    detach(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteMenuContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteMenuContent, "ng-template[cuteMenuContent]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * This code is a modification of the `@angular/material` original
+ * code licensed under MIT-style License (https://angular.dev/license).
+ */
+
+/**
+ * Interface for a custom menu panel that can be used with `cuteMenuTriggerFor`.
+ */
+interface CuteMenuPanel<T = any> {
+    xPosition: MenuPositionX;
+    yPosition: MenuPositionY;
+    overlapTrigger: boolean;
+    templateRef: TemplateRef<any>;
+    readonly closed: EventEmitter<void | 'click' | 'keydown' | 'tab'>;
+    parentMenu?: CuteMenuPanel | undefined;
+    direction?: Direction;
+    focusFirstItem: (origin?: FocusOrigin) => void;
+    resetActiveItem: () => void;
+    setPositionClasses?: (x: MenuPositionX, y: MenuPositionY) => void;
+    /**
+     * @deprecated No longer used and will be removed.
+     * @breaking-change 21.0.0
+     */
+    setElevation?(depth: number): void;
+    lazyContent?: CuteMenuContent;
+    backdropClass?: string;
+    overlayPanelClass?: string | string[];
+    hasBackdrop?: boolean;
+    readonly panelId?: string;
+    /**
+     * @deprecated To be removed.
+     * @breaking-change 8.0.0
+     */
+    addItem?: (item: T) => void;
+    /**
+     * @deprecated To be removed.
+     * @breaking-change 8.0.0
+     */
+    removeItem?: (item: T) => void;
+}
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * This code is a modification of the `@angular/material` original
+ * code licensed under MIT-style License (https://angular.dev/license).
+ */
+
+/**
+ * Single item inside a `cute-menu`. Provides the menu item styling and accessibility treatment.
+ */
+declare class CuteMenuItem implements FocusableOption, AfterViewInit, OnDestroy {
+    private _elementRef;
+    private _document;
+    private _focusMonitor;
+    _parentMenu?: CuteMenuPanel<CuteMenuItem> | null | undefined;
+    private _changeDetectorRef;
+    /** ARIA role for the menu item. */
+    role: 'menuitem' | 'menuitemradio' | 'menuitemcheckbox';
+    /** Whether the menu item is disabled. */
+    disabled: boolean;
+    /** Whether ripples are disabled on the menu item. */
+    disableRipple: boolean;
+    /** Stream that emits when the menu item is hovered. */
+    readonly _hovered: Subject<CuteMenuItem>;
+    /** Stream that emits when the menu item is focused. */
+    readonly _focused: Subject<CuteMenuItem>;
+    /** Whether the menu item is highlighted. */
+    protected _highlighted: boolean;
+    /** Whether the menu item acts as a trigger for a submenu. */
+    protected _triggersSubmenu: boolean;
+    constructor(...args: unknown[]);
+    /** Focuses the menu item. */
+    focus(origin?: FocusOrigin, options?: FocusOptions): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    /** Used to set the `tabindex`. */
+    _getTabIndex(): string;
+    /** Returns the host DOM element. */
+    _getHostElement(): HTMLElement;
+    /** Prevents the default element actions if it is disabled. */
+    _checkDisabled(event: Event): void;
+    /** Emits to the hover stream. */
+    _handleMouseEnter(): void;
+    /** Gets the label to be used when determining whether the option should be focused. */
+    getLabel(): string;
+    _setHighlighted(isHighlighted: boolean): void;
+    _setTriggersSubmenu(triggersSubmenu: boolean): void;
+    _hasFocus(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteMenuItem, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuteMenuItem, "[cute-menu-item]", ["cuteMenuItem"], { "role": { "alias": "role"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "disableRipple": { "alias": "disableRipple"; "required": false; }; }, {}, never, ["cute-icon, i[class], [cuteMenuItemIcon]", "*"], true, never>;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_disableRipple: unknown;
+}
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * This code is a modification of the `@angular/material` original
+ * code licensed under MIT-style License (https://angular.dev/license).
+ */
+
+type MenuShadowElevation = 0 | 1 | 2 | 3;
+/** Reason why the menu was closed. */
+type MenuCloseReason = void | 'click' | 'keydown' | 'tab';
+/** Default `cute-menu` options that can be overridden. */
+interface CuteMenuDefaultOptions {
+    /** The x-axis position of the menu. */
+    xPosition: MenuPositionX;
+    /** The y-axis position of the menu. */
+    yPosition: MenuPositionY;
+    /** Whether the menu should overlap the menu trigger. */
+    overlapTrigger: boolean;
+    /** Class to be applied to the menu's backdrop. */
+    backdropClass: string;
+    /** Class or list of classes to be applied to the menu's overlay panel. */
+    overlayPanelClass?: string | string[];
+    /** Whether the menu has a backdrop. */
+    hasBackdrop?: boolean;
+}
+/** Injection token to be used to override the default options for `mat-menu`. */
+declare const CUTE_MENU_DEFAULT_OPTIONS: InjectionToken<CuteMenuDefaultOptions>;
+/**
+ * @docs-private
+ * @deprecated No longer used, will be removed.
+ * @breaking-change 21.0.0
+ */
+declare function CUTE_MENU_DEFAULT_OPTIONS_FACTORY(): CuteMenuDefaultOptions;
+declare class CuteMenu implements CuteMenuPanel<CuteMenuItem>, AfterContentInit, OnInit, OnDestroy {
+    private _elementRef;
+    private _changeDetectorRef;
+    private _injector;
+    private _keyManager;
+    private _xPosition;
+    private _yPosition;
+    private _firstItemFocusRef?;
+    private _exitFallbackTimeout;
+    private _previousElevation;
+    private _elevationPrefix;
+    private _baseElevation;
+    /** Config object to be passed into the menu's ngClass */
+    protected _classList: {
+        [key: string]: boolean;
+    };
+    /** Current state of the panel animation. */
+    protected _panelAnimationState: 'void' | 'enter';
+    /** Only the direct descendant menu items. */
+    _directDescendantItems: QueryList<CuteMenuItem>;
+    /** Emits whenever an animation on the menu completes. */
+    readonly _animationDone: Subject<AnimationEvent>;
+    /** Whether the menu is animating. */
+    _isAnimating: boolean | undefined;
+    /** Parent menu of the current menu panel. */
+    parentMenu: CuteMenuPanel | undefined;
+    /** Layout direction of the menu. */
+    direction: Direction | undefined;
+    /** Class or list of classes to be added to the overlay panel. */
+    overlayPanelClass: string | string[];
+    /** Class to be added to the backdrop element. */
+    backdropClass: string;
+    /** aria-label for the menu panel. */
+    ariaLabel: string | undefined;
+    /** aria-labelledby for the menu panel. */
+    ariaLabelledby: string | undefined;
+    /** aria-describedby for the menu panel. */
+    ariaDescribedby: string | undefined;
+    /** Position of the menu in the X axis. */
+    get xPosition(): MenuPositionX;
+    set xPosition(value: MenuPositionX);
+    /** Position of the menu in the Y axis. */
+    get yPosition(): MenuPositionY;
+    set yPosition(value: MenuPositionY);
+    /** Whether the menu should overlap its trigger. */
+    overlapTrigger: boolean;
+    /** Whether the menu has a backdrop. */
+    hasBackdrop?: boolean;
+    /** @docs-private */
+    templateRef: TemplateRef<any>;
+    /** All items inside the menu. Includes items nested inside another menu. */
+    _allItems: QueryList<CuteMenuItem> | undefined;
+    /**
+     * List of the items inside a menu.
+     * @deprecated
+     * @breaking-change 8.0.0
+     */
+    items: QueryList<CuteMenuItem> | undefined;
+    /**
+     * Menu content that will be rendered lazily.
+     */
+    lazyContent: CuteMenuContent | undefined;
+    /**
+     * This method takes classes set on the host mat-menu element and applies them on the
+     * menu template that displays in the overlay container.  Otherwise, it's difficult
+     * to style the containing menu from outside the component.
+     * @param classes list of class names
+     */
+    set panelClass(classes: string);
+    private _previousPanelClass;
+    /** Event emitted when the menu is closed. */
+    readonly closed: EventEmitter<MenuCloseReason>;
+    readonly panelId: string;
+    constructor(...args: unknown[]);
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    /** Stream that emits whenever the hovered menu item changes. */
+    _hovered(): Observable<CuteMenuItem>;
+    /** Handle a keyboard event from the menu, delegating to the appropriate action. */
+    protected _handleKeydown(event: KeyboardEvent): void;
+    /**
+     * Handle a mouse event from the menu, delegating to the appropriate action.
+     * @param event
+     */
+    protected onClick(event: MouseEvent): void;
+    /**
+     * Focus the first item in the menu.
+     * @param origin Action from which the focus originated. Used to set the correct styling.
+     */
+    focusFirstItem(origin?: FocusOrigin): void;
+    /**
+     * Resets the active item in the menu. This is used when the menu is opened, allowing
+     * the user to start from the first option when pressing the down arrow.
+     */
+    resetActiveItem(): void;
+    /**
+     * Sets the menu panel elevation.
+     * @param depth Number of parent menus that come before the menu.
+     */
+    setElevation(depth: number): void;
+    /**
+     * Adds classes to the menu panel based on its position. Can be used by
+     * consumers to add specific styling based on the position.
+     * @param posX Position of the menu along the x axis.
+     * @param posY Position of the menu along the y axis.
+     */
+    setPositionClasses(posX?: MenuPositionX, posY?: MenuPositionY): void;
+    /** Starts the entered animation. */
+    _startAnimation(): void;
+    /** Resets the panel animation to its initial state. */
+    _resetAnimation(): void;
+    /** Callback that is invoked when the panel animation completes. */
+    _onAnimationDone(event: AnimationEvent): void;
+    _onAnimationStart(event: AnimationEvent): void;
+    /**
+     * Sets up a stream that will keep track of any newly-added menu items and will update the list
+     * of direct descendants. We collect the descendants this way, because `_allItems` can include
+     * items that are part of child menus, and using a custom way of registering items is unreliable
+     * when it comes to maintaining the item order.
+     */
+    private _updateDirectDescendants;
+    /** Gets the menu panel DOM node. */
+    private _resolvePanel;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteMenu, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuteMenu, "cute-menu", ["cuteMenu"], { "backdropClass": { "alias": "backdropClass"; "required": false; }; "ariaLabel": { "alias": "aria-label"; "required": false; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; }; "ariaDescribedby": { "alias": "aria-describedby"; "required": false; }; "xPosition": { "alias": "xPosition"; "required": false; }; "yPosition": { "alias": "yPosition"; "required": false; }; "overlapTrigger": { "alias": "overlapTrigger"; "required": false; }; "hasBackdrop": { "alias": "hasBackdrop"; "required": false; }; "panelClass": { "alias": "class"; "required": false; }; }, { "closed": "closed"; }, ["lazyContent", "_allItems", "items"], ["*"], true, [{ directive: typeof i1.CdkMenu; inputs: {}; outputs: {}; }]>;
+    static ngAcceptInputType_overlapTrigger: unknown;
+    static ngAcceptInputType_hasBackdrop: any;
+}
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * This code is a modification of the `@angular/material` original
+ * code licensed under MIT-style License (https://angular.dev/license).
+ */
+
+/** Injection token that determines the scroll handling while the menu is open. */
+declare const CUTE_MENU_SCROLL_STRATEGY: InjectionToken<() => ScrollStrategy>;
+/** @docs-private */
+declare function CUTE_MENU_SCROLL_STRATEGY_FACTORY(overlay: Overlay): () => ScrollStrategy;
+/** @docs-private */
+declare const CUTE_MENU_SCROLL_STRATEGY_FACTORY_PROVIDER: {
+    provide: InjectionToken<() => ScrollStrategy>;
+    deps: (typeof Overlay)[];
+    useFactory: typeof CUTE_MENU_SCROLL_STRATEGY_FACTORY;
+};
+/** Directive applied to an element that should trigger a `cute-menu`. */
+declare class CuteMenuTrigger implements AfterContentInit, OnDestroy {
+    private _overlay;
+    private _element;
+    private _viewContainerRef;
+    private _menuItemInstance;
+    private _dir;
+    private _focusMonitor;
+    private _ngZone?;
+    private _portal;
+    private _overlayRef;
+    private _menuOpen;
+    private _closingActionsSubscription;
+    private _hoverSubscription;
+    private _menuCloseSubscription;
+    private readonly _scrollStrategy;
+    private _changeDetectorRef;
+    /**
+     * We're specifically looking for a `CuteMenu` here since the generic `CuteMenuPanel`
+     * interface lacks some functionality around nested menus and animations.
+     */
+    private readonly _parentCuteMenu;
+    /**
+     * Cached value of the padding of the parent menu panel.
+     * Used to offset submenus to compensate for the padding.
+     */
+    private _parentInnerPadding;
+    /**
+     * Handles touch start events on the trigger.
+     * Needs to be an arrow function, so we can easily use addEventListener and removeEventListener.
+     */
+    private _handleTouchStart;
+    _openedBy: Exclude<FocusOrigin, 'program' | null> | undefined;
+    /** References the menu instance that the trigger is associated with. */
+    get menu(): CuteMenuPanel | null;
+    set menu(menu: CuteMenuPanel | null);
+    private _menu;
+    /** Data to be passed along to any lazily rendered content. */
+    menuData: any;
+    /**
+     * Whether focus should be restored when the menu is closed.
+     * Note that disabling this option can have accessibility implications, and
+     * it's up to you to manage focus if you decide to turn it off.
+     */
+    restoreFocus: boolean;
+    /** Event emitted when the associated menu is opened. */
+    readonly menuOpened: EventEmitter<void>;
+    /** Event emitted when the associated menu is closed. */
+    readonly menuClosed: EventEmitter<void>;
+    constructor(overlay: Overlay, element: ElementRef<HTMLElement>, viewContainerRef: ViewContainerRef, scrollStrategy: any, parentMenu: CuteMenuPanel, menuItemInstance: CuteMenuItem, dir: Directionality, focusMonitor: FocusMonitor, ngZone: NgZone);
+    /**
+     * @deprecated `focusMonitor` will become a required parameter.
+     * @breaking-change 8.0.0
+     */
+    constructor(overlay: Overlay, element: ElementRef<HTMLElement>, viewContainerRef: ViewContainerRef, scrollStrategy: any, parentMenu: CuteMenuPanel, menuItemInstance: CuteMenuItem, dir: Directionality, focusMonitor?: FocusMonitor | null);
+    /**
+     * @deprecated `ngZone` will become a required parameter.
+     * @breaking-change 15.0.0
+     */
+    constructor(overlay: Overlay, element: ElementRef<HTMLElement>, viewContainerRef: ViewContainerRef, scrollStrategy: any, parentMenu: CuteMenuPanel, menuItemInstance: CuteMenuItem, dir: Directionality, focusMonitor: FocusMonitor);
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    /** Whether the menu is open. */
+    get menuOpen(): boolean;
+    /** The text direction of the containing app. */
+    get dir(): Direction;
+    get elementRef(): Readonly<ElementRef<HTMLElement>>;
+    /** Whether the menu triggers a submenu or a top-level one. */
+    triggersSubmenu(): boolean;
+    /** Toggles the menu between the open and closed states. */
+    toggleMenu(): void;
+    /** Opens the menu. */
+    openMenu(): void;
+    /** Closes the menu. */
+    closeMenu(): void;
+    /**
+     * Focuses the menu trigger.
+     * @param origin Source of the menu trigger's focus.
+     * @param options Focus options
+     */
+    focus(origin?: FocusOrigin, options?: FocusOptions): void;
+    /**
+     * Updates the position of the menu to ensure that it fits all options within the viewport.
+     */
+    updatePosition(): void;
+    /** Closes the menu and does the necessary cleanup. */
+    private _destroyMenu;
+    /**
+     * This method sets the menu state to open and focuses the first item if
+     * the menu was opened via the keyboard.
+     */
+    private _initMenu;
+    /** Updates the menu elevation based on the amount of parent menus that it has. */
+    private _setMenuElevation;
+    private _setIsMenuOpen;
+    /**
+     * This method creates the overlay from the provided menu's template and saves its
+     * OverlayRef so that it can be attached to the DOM when openMenu is called.
+     */
+    private _createOverlay;
+    /**
+     * This method builds the configuration object needed to create the overlay, the OverlayState.
+     * @returns OverlayConfig
+     */
+    private _getOverlayConfig;
+    /**
+     * Listens to changes in the position of the overlay and sets the correct classes
+     * on the menu based on the new position. This ensures the animation origin is always
+     * correct, even if a fallback position is used for the overlay.
+     */
+    private _subscribeToPositions;
+    /**
+     * Sets the appropriate positions on a position strategy
+     * so the overlay connects with the trigger correctly.
+     * @param menu Menu panel
+     * @param positionStrategy Strategy whose position is to update.
+     */
+    private _setPosition;
+    /** Returns a stream that emits whenever an action that should close the menu occurs. */
+    private _menuClosingActions;
+    /** Handles mouse presses on the trigger. */
+    _handleMousedown(event: MouseEvent): void;
+    /** Handles key presses on the trigger. */
+    _handleKeydown(event: KeyboardEvent): void;
+    /** Handles click events on the trigger. */
+    _handleClick(event: MouseEvent): void;
+    /** Handles the cases where the user hovers over the trigger. */
+    private _handleHover;
+    /** Gets the portal that should be attached to the overlay. */
+    private _getPortal;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteMenuTrigger, [null, null, null, null, { optional: true; }, { optional: true; self: true; }, { optional: true; }, null, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteMenuTrigger, "[cuteMenuTriggerFor]", ["cuteMenuTrigger"], { "menu": { "alias": "cuteMenuTriggerFor"; "required": false; }; "menuData": { "alias": "cuteMenuTriggerData"; "required": false; }; "restoreFocus": { "alias": "cuteMenuTriggerRestoreFocus"; "required": false; }; }, { "menuOpened": "menuOpened"; "menuClosed": "menuClosed"; }, never, never, true, never>;
+}
+
+declare class CuteMenuModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteMenuModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CuteMenuModule, never, [typeof i1$1.CommonModule, typeof i1$1.CommonModule, typeof CuteMenu, typeof CuteMenuItem, typeof CuteMenuContent, typeof CuteMenuTrigger], [typeof i1$1.CommonModule, typeof CuteMenu, typeof CuteMenuItem, typeof CuteMenuContent, typeof CuteMenuTrigger]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CuteMenuModule>;
+}
+
+export { CUTE_MENU_CONTENT, CUTE_MENU_DEFAULT_OPTIONS, CUTE_MENU_DEFAULT_OPTIONS_FACTORY, CUTE_MENU_SCROLL_STRATEGY, CUTE_MENU_SCROLL_STRATEGY_FACTORY, CUTE_MENU_SCROLL_STRATEGY_FACTORY_PROVIDER, CuteMenu, CuteMenuContent, CuteMenuItem, CuteMenuModule, CuteMenuTrigger };
+export type { CuteMenuDefaultOptions, MenuCloseReason, MenuPositionX, MenuPositionY, MenuShadowElevation };

package/navbar/index.d.ts

@@ -0,0 +1,91 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, QueryList, EventEmitter } from '@angular/core';
+import { CuteLayoutControl } from '@cute-widgets/base/abstract';
+import * as _cute_widgets_base_navbar from '@cute-widgets/base/navbar';
+import * as i1 from '@cute-widgets/base/collapse';
+import { CuteCollapse, CuteCollapseState } from '@cute-widgets/base/collapse';
+import { CuteNav } from '@cute-widgets/base/core/nav';
+import * as i1$1 from '@angular/common';
+
+/**
+ * Collapsible navbar content.
+ */
+declare class CuteNavbarContent extends CuteCollapse {
+    private _subscription;
+    protected _navbar: _cute_widgets_base_navbar.CuteNavbar;
+    protected _breakpointMatches: i0.WritableSignal<boolean>;
+    constructor();
+    getState(): CuteCollapseState;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteNavbarContent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuteNavbarContent, "cute-navbar-content", ["cuteNavbarContent"], {}, {}, never, ["*"], true, never>;
+}
+
+/** Navbar's vertical non-static position. */
+type NavbarPosition = "fixed-top" | "fixed-bottom" | "sticky-top" | "sticky-bottom";
+declare const CUTE_NAVBAR: InjectionToken<CuteNavbar>;
+/**
+ * Powerful and responsive navigation header in which responsive behavior depends on `CuteCollapse` component.
+ * Includes support for branding, navigation, and more.
+ */
+declare class CuteNavbar extends CuteLayoutControl {
+    navContent: QueryList<CuteNavbarContent> | undefined;
+    /** Placement `navbar` in non-static position, if the `position` differs from the default.  */
+    position: NavbarPosition | undefined;
+    /** Event emitted when the navbar's content expansion status changed. */
+    expansionChange: EventEmitter<boolean>;
+    readonly contentExpanded: i0.Signal<boolean>;
+    private _expanded;
+    get classBinding(): string;
+    constructor();
+    protected generateId(): string;
+    ngAfterContentInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteNavbar, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuteNavbar, "cute-navbar", ["cuteNavbar"], { "position": { "alias": "position"; "required": false; }; }, { "expansionChange": "expansionChange"; }, ["navContent"], ["*"], true, never>;
+}
+
+/**
+ * Subcomponent for company, product, or project name
+ */
+declare class CuteNavbarBrand {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteNavbarBrand, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteNavbarBrand, "[cuteNavbarBrand], [cute-navbar-brand]", ["cuteNavbarBrand"], {}, {}, never, never, true, never>;
+}
+
+declare class CuteNavbarNav extends CuteNav {
+    /**
+     * Enable/disable vertical scrolling within the toggleable contents of a collapsed `navbar`.
+     * By default, scrolling kicks in at 75vh (or 75% of the viewport height).
+     */
+    scrollable: boolean;
+    /** The minimum height of the expanded content that triggers the scrolling mode when `scrollable` property is enabled. Default is **75vh**. */
+    get scrollHeight(): string | undefined;
+    set scrollHeight(value: string | number | undefined);
+    private _scrollHeight;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteNavbarNav, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteNavbarNav, "[cuteNavbarNav], [cute-navbar-nav]", ["cuteNavbarNav"], { "scrollable": { "alias": "scrollable"; "required": false; }; "scrollHeight": { "alias": "scrollHeight"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_scrollable: unknown;
+}
+
+/**
+ *  This directive adjusts vertical alignment and horizontal spacing for strings of text.
+ */
+declare class CuteNavbarText {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteNavbarText, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteNavbarText, "cute-navbar-text, [cuteNavbarText], [cute-navbar-text]", ["cuteNavbarText"], {}, {}, never, never, true, never>;
+}
+
+declare class CuteNavbarToggler {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteNavbarToggler, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteNavbarToggler, "[cuteNavbarToggler], [cute-navbar-toggler]", ["cuteNavbarToggler"], {}, {}, never, never, true, [{ directive: typeof i1.CuteCollapseTrigger; inputs: { "cuteCollapseTriggerFor": "cuteNavbarTogglerFor"; }; outputs: {}; }]>;
+}
+
+declare class CuteNavbarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteNavbarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CuteNavbarModule, never, [typeof i1$1.CommonModule, typeof CuteNavbar, typeof CuteNavbarBrand, typeof CuteNavbarContent, typeof CuteNavbarNav, typeof CuteNavbarText, typeof CuteNavbarToggler], [typeof CuteNavbar, typeof CuteNavbarBrand, typeof CuteNavbarContent, typeof CuteNavbarNav, typeof CuteNavbarText, typeof CuteNavbarToggler]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CuteNavbarModule>;
+}
+
+export { CUTE_NAVBAR, CuteNavbar, CuteNavbarBrand, CuteNavbarContent, CuteNavbarModule, CuteNavbarNav, CuteNavbarText, CuteNavbarToggler };
+export type { NavbarPosition };