import * as i0 from '@angular/core';
import { TemplateRef, Type, EventEmitter, AfterViewInit, ElementRef, QueryList, Provider, EnvironmentProviders, ModuleWithProviders, TrackByFunction, Injector, InjectionToken, OnDestroy } from '@angular/core';
import * as i3 from '@volo/ngx-lepton-x.core';
import { LpxLanguage, LpxStyleFactory, LpxNavbarItem, VariantSource, LanguageService, NavBarPropPredicate, ToolbarService, NavbarService, UserProfileService, RoutesService, LogoPanelDirective, MobileNavbarSettingsPanelDirective, MobileNavbarProfilePanelDirective, UserProfile, AuthService as AuthService$1, DataStore, NavbarPanelDirective, BreadcrumbPanelDirective, ToolbarPanelDirective, SettingsPanelDirective, FooterPanelDirective, NavitemPanelDirective, CurrentUserImagePanelDirective, MobileNavbarPanelDirective, ContentPanelDirective, LpxStyles, TopNavbarPanelDirective, Layouts } from '@volo/ngx-lepton-x.core';
import * as i1 from '@angular/common';
import * as i2 from '@volosoft/ngx-lepton-x';
import { ContextMenuComponent } from '@volosoft/ngx-lepton-x';
import * as rxjs from 'rxjs';
import { Observable, ReplaySubject, Subscription } from 'rxjs';
import * as i2$1 from '@angular/router';
import { AuthService } from '@abp/ng.core';
import * as i3$1 from '@angular/forms';
import { Placement } from '@floating-ui/dom';

interface LpxContainer {
    layoutClass: string;
    label: string;
    icon: string;
    order?: number;
    default?: boolean;
}
interface LpxSideMenuLayoutOptions {
    containers?: LpxContainer[];
    styleFactory?: LpxStyleFactory;
    settingsMenuEventName?: ContextMenuTriggerEvent;
}
interface LpxTopMenuLayoutOptions {
    styleFactory?: LpxStyleFactory;
    topMenuItems?: LpxNavbarItem[];
    userMenuEventName?: ContextMenuTriggerEvent;
    settingsMenuEventName?: ContextMenuTriggerEvent;
}
type ContextMenuTriggerEvent = 'click' | 'hover';
type LpxSelectedLanguageLabelFnType = (lang: LpxLanguage | undefined, id: string | undefined) => {
    shortText: string | undefined;
    id: string | undefined;
};

interface ISettingsService {
    settings$: Observable<Setting[]>;
    selectedSettings$: Observable<Setting[]>;
}

interface Setting {
    text?: string;
    icon?: string;
    shortText?: string;
    action?: () => VariantSource<boolean>;
    selected?: boolean;
    expanded?: boolean;
    order?: number;
    children?: Setting[];
    visibleInCtxMenu?: boolean;
    id?: string;
    template?: TemplateRef<any>;
}
interface SettingsOptions {
    generalSettingsTranslateKey: string;
    settingsService: Type<ISettingsService>;
    settingsMenuEventName?: ContextMenuTriggerEvent;
}

declare class SettingComponent {
    setting: Setting;
    settingClick: EventEmitter<Setting>;
    clickOnSetting(setting: Setting): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SettingComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SettingComponent, "lpx-setting", never, { "setting": { "alias": "setting"; "required": false; }; }, { "settingClick": "settingClick"; }, never, never, true, never>;
}

declare class SettingsComponent implements AfterViewInit {
    service: ISettingsService;
    languageService: LanguageService;
    generalSettingsTranslateKey: string;
    private menuTriggerType;
    private readonly destroyRef;
    private readonly settingsState;
    /** Which panel layout to show: all groups or a single toolbar group. */
    private readonly panelScope;
    /** Bumped after navbar route clicks mutate the displayed panel clone. */
    private readonly panelVersion;
    /** Immutable clone passed to lpx-navbar-routes — new reference on each recompute. */
    readonly panelSettings: i0.Signal<Setting[]>;
    readonly exceptedRefs: i0.WritableSignal<ElementRef<any>[]>;
    settingComponents: QueryList<ElementRef>;
    ctxMenu: ContextMenuComponent;
    hideCtxMenu(): void;
    toggleCtxMenu(): void;
    openCtxMenuWith(setting: Setting): void;
    onPanelRouteClick(): void;
    ngAfterViewInit(): void;
    openAllExpendedSettingsPanel(selectedSettings: Setting[] | null): void;
    openExpendedSettingsPanel(setting: Setting, eventName: string): void;
    openMenu(eventName: string): void;
    closeMenu(eventName: string): void;
    private buildPanel;
    private isChildSelected;
    static ɵfac: i0.ɵɵFactoryDeclaration<SettingsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SettingsComponent, "lpx-settings", never, {}, {}, never, never, true, never>;
}

declare enum SettingsFeatureKind {
    Options = 0
}
interface SettingsFeature<KindT extends SettingsFeatureKind> {
    ɵkind: KindT;
    ɵproviders: (Provider | EnvironmentProviders)[];
}
declare function withSettingsOption(options?: SettingsOptions): SettingsFeature<SettingsFeatureKind.Options>;
declare function defineSettingsProviders(...features: SettingsFeature<SettingsFeatureKind>[]): EnvironmentProviders;

declare class SettingsModule {
    /**
     * @deprecated `SettingsModule.defineProvidersWith(...)` is depreacted. You can use `defineSettingsProviders` **function** instead.
     */
    static defineProvidersWith(options: SettingsOptions): ModuleWithProviders<SettingsModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<SettingsModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SettingsModule, never, [typeof i1.CommonModule, typeof i3.LpxIconModule, typeof i3.LpxClickOutsideModule, typeof i2.LpxContextMenuModule, typeof i3.LpxNavbarModule, typeof i3.LpxLanguageModule, typeof i3.LpxTranslateModule, typeof SettingsComponent, typeof SettingComponent], [typeof SettingsComponent, typeof SettingComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SettingsModule>;
}

interface Badge {
    count?: number | Observable<number>;
    color?: string;
    icon?: string;
}
interface ToolbarItem {
    id?: string | number;
    name?: string;
    description?: string;
    icon?: string;
    badge?: Badge;
    component?: Type<any>;
    html?: string;
    template?: TemplateRef<any>;
    action?: () => void;
    order?: number;
    requiredPolicy?: string;
    visible?: NavBarPropPredicate<ToolbarItem>;
    additional?: {
        [key: string]: any;
    };
}

declare class MobileToolbarComponent {
    items: ToolbarItem[] | undefined | null;
    routeClick: EventEmitter<ToolbarItem>;
    itemsRef: TemplateRef<ToolbarItem[]> | undefined;
    itemRef: TemplateRef<ToolbarItem> | undefined;
    trackByFn: TrackByFunction<ToolbarItem>;
    static ɵfac: i0.ɵɵFactoryDeclaration<MobileToolbarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MobileToolbarComponent, "lpx-mobile-toolbar", never, { "items": { "alias": "items"; "required": false; }; }, { "routeClick": "routeClick"; }, ["itemsRef", "itemRef"], never, true, never>;
}

interface MobileNavbarState {
    settings: LpxNavbarItem[];
}
declare class MobileNavbarService {
    private themeService;
    private languageService;
    private userProfileService;
    settings$: rxjs.Observable<{
        text: string;
        icon: string;
        id: string;
        children: LpxNavbarItem[];
    }[]>;
    userProfileActions$: rxjs.Observable<i3.UserActionGroup | undefined>;
    static ɵfac: i0.ɵɵFactoryDeclaration<MobileNavbarService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MobileNavbarService>;
}

declare enum MobileMenuTranslate {
    SettingsTitle = "mobileMenu.settings.title",
    MenuTitle = "mobileMenu.menu.title"
}
type MobileMenuTranslateValues = {
    [key in MobileMenuTranslate]: string;
};
declare const MobileMenuTranslateDefaults: MobileMenuTranslateValues;

declare class MobileNavbarComponent {
    protected readonly injector: Injector;
    protected readonly service: MobileNavbarService;
    protected readonly toolbarService: ToolbarService;
    protected readonly navbarService: NavbarService;
    protected readonly profileService: UserProfileService;
    protected readonly authService: AuthService;
    protected readonly document: Document;
    protected readonly routesService: RoutesService;
    private platformId;
    logoPanel?: LogoPanelDirective;
    settingsPanel?: MobileNavbarSettingsPanelDirective;
    profilePanel?: MobileNavbarProfilePanelDirective;
    protected readonly currentUser: i0.Signal<UserProfile<string>>;
    isAuthenticated: i0.Signal<boolean>;
    avatar: i0.Signal<i3.Avatar | undefined>;
    userName: i0.Signal<string>;
    displayName: i0.Signal<string>;
    email: i0.Signal<string>;
    menuVisible: boolean;
    navTabs: LpxNavbarItem[];
    selectedMenuItems: LpxNavbarItem[];
    groupedItems$: rxjs.Observable<{
        group: string;
        items: LpxNavbarItem[];
    }[] | undefined>;
    navbarMenuItems: LpxNavbarItem[];
    settingsMenuItems: LpxNavbarItem[];
    profileMenuItems?: LpxNavbarItem[];
    activeMenu: string;
    icons: {
        bagFill: string;
        bellFill: string;
        calendarWeek: string;
        chatDots: string;
        chevronDown: string;
        chevronUp: string;
        gearConnected: string;
        filter: string;
        filterFill: string;
        layoutThreeColumns: string;
        moon: string;
        square: string;
        sunset: string;
        sunup: string;
        star: string;
        x: string;
        xCircleFill: string;
    };
    settingsTitle: MobileMenuTranslate;
    menuTitle: MobileMenuTranslate;
    toggleClass: string;
    protected getGroupedItems(): rxjs.Observable<{
        group: string;
        items: LpxNavbarItem[];
    }[] | undefined>;
    protected init(): void;
    constructor();
    onSubnavbarExpand(menuItem: LpxNavbarItem): void;
    toggleMenu(type?: string, menuItems?: LpxNavbarItem[]): void;
    toggleNavbarMenu(): void;
    closeMenu(): void;
    navigateToLogin(): void;
    forceScrollToTop(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MobileNavbarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MobileNavbarComponent, "lpx-mobile-navbar", never, {}, {}, ["logoPanel", "settingsPanel", "profilePanel"], never, true, never>;
}

declare class LpxMobileNavbarModule {
    /**
     * @deprecated `LpxMobileNavbarModule.forRoot()` is deprecated. You can use `provideLpxMobileNavbar` **function** instead.
     */
    static forRoot(): ModuleWithProviders<LpxMobileNavbarModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<LpxMobileNavbarModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<LpxMobileNavbarModule, never, [typeof i1.CommonModule, typeof i2$1.RouterModule, typeof i3.LpxAvatarModule, typeof i3.LpxBrandLogoModule, typeof i3.LpxIconModule, typeof i3.LpxNavbarModule, typeof i3.LpxTranslateModule, typeof i3.ToObservableModule, typeof MobileToolbarComponent, typeof MobileNavbarComponent], [typeof MobileNavbarComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<LpxMobileNavbarModule>;
}

declare class ToolbarComponent implements AfterViewInit {
    readonly userProfileService: UserProfileService;
    readonly toolbarService: ToolbarService;
    readonly authService: AuthService$1;
    profileRef?: ReplaySubject<ElementRef>;
    profileClick: EventEmitter<void>;
    profileLink: ElementRef;
    itemsTmp?: TemplateRef<any>;
    ngAfterViewInit(): void;
    navigateToLogin(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ToolbarComponent, "lpx-toolbar", never, { "profileRef": { "alias": "profileRef"; "required": false; }; }, { "profileClick": "profileClick"; }, ["itemsTmp"], ["*"], true, never>;
}

declare class ToolbarItemsComponent {
    items: ToolbarItem[];
    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarItemsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ToolbarItemsComponent, "lpx-toolbar-items", never, { "items": { "alias": "items"; "required": false; }; }, {}, never, never, true, never>;
}

declare class ToolbarItemsDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarItemsDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ToolbarItemsDirective, "[lpx-toolbar-items]", never, {}, {}, never, never, true, never>;
}

declare class ToolbarItemComponent {
    component?: Type<any>;
    template?: TemplateRef<any>;
    icon?: string;
    badge?: number | Observable<number>;
    html?: string;
    action?: () => void;
    get badge$(): Observable<number | undefined>;
    actionClick(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ToolbarItemComponent, "lpx-toolbar-item", never, { "component": { "alias": "component"; "required": false; }; "template": { "alias": "template"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "badge": { "alias": "badge"; "required": false; }; "html": { "alias": "html"; "required": false; }; "action": { "alias": "action"; "required": false; }; }, {}, never, never, true, never>;
}

declare class LpxToolbarModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<LpxToolbarModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<LpxToolbarModule, never, [typeof i1.CommonModule, typeof i3.LpxIconModule, typeof i3.LpxAvatarModule, typeof i3.LpxClickOutsideModule, typeof i3.LpxNavbarModule, typeof i3.LpxVisibleDirective, typeof ToolbarComponent, typeof ToolbarItemsComponent, typeof ToolbarItemsDirective, typeof ToolbarItemComponent], [typeof ToolbarComponent, typeof ToolbarItemsComponent, typeof ToolbarItemsDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<LpxToolbarModule>;
}

declare enum ToolbarTranslateKeys {
    ContextMenuWelcome = "toolbar.contextMenu.Welcome"
}
type ToolbarTranslateValues = {
    [key in ToolbarTranslateKeys]: string;
};
declare const ToolbarTranslateDefaults: ToolbarTranslateValues;

declare class ToolbarContainerComponent {
    protected readonly toolbarService: ToolbarService;
    protected readonly userProfileService: UserProfileService;
    ctxMenu: ContextMenuComponent;
    profileRef$: ReplaySubject<ElementRef<any>>;
    welcomeText: ToolbarTranslateKeys;
    toggleCtxMenu(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarContainerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ToolbarContainerComponent, "lpx-toolbar-container", never, {}, {}, never, never, true, never>;
}

declare class LpxToolbarContainerModule {
    /**
     * @deprecated `LpxToolbarContainerModule.forRoot()` is deprecated. You can use `provideLpxToolbarContainer` **function** instead.
     */
    static forRoot(): ModuleWithProviders<LpxToolbarContainerModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<LpxToolbarContainerModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<LpxToolbarContainerModule, never, [typeof i1.CommonModule, typeof i2.LpxContextMenuModule, typeof i3.LpxClickOutsideModule, typeof i3.LpxAvatarModule, typeof i3.LpxNavbarModule, typeof LpxToolbarModule, typeof i3.LpxTranslateModule, typeof ToolbarContainerComponent], [typeof ToolbarContainerComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<LpxToolbarContainerModule>;
}

declare enum SideMenuLayoutTranslate {
    GeneralSettings = "sideMenuLayout.settings.generalSettings",
    MenuFilter = "sideMenuLayout.filterMenu"
}
type SideMenuLayoutTranslateValues = {
    [key in SideMenuLayoutTranslate]: string;
};
declare const SideMenuLayoutTranslateDefaults: SideMenuLayoutTranslateValues;

declare class MenuFilterService {
    private navbarService;
    private menuFilter$;
    get menuFilter(): string;
    set menuFilter(value: string);
    testAgainst: (text: string, filter: string) => boolean;
    shouldBeExpanded: (item: LpxNavbarItem, filter: string) => boolean | undefined;
    filterNavbarItem: (items: LpxNavbarItem[] | undefined, filter: string) => LpxNavbarItem[];
    private expandAllChildren;
    constructor();
    addFilterToNavItems$(): void;
    clearFilter(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MenuFilterService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MenuFilterService>;
}

declare class MenuFilterComponent {
    service: MenuFilterService;
    menuFilterText: SideMenuLayoutTranslate;
    static ɵfac: i0.ɵɵFactoryDeclaration<MenuFilterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MenuFilterComponent, "lpx-menu-filter", never, {}, {}, never, never, true, never>;
}

declare class MenuFilterModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<MenuFilterModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<MenuFilterModule, never, [typeof i1.CommonModule, typeof i3.LpxIconModule, typeof i3$1.FormsModule, typeof i3.LpxTranslateModule, typeof MenuFilterComponent], [typeof MenuFilterComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<MenuFilterModule>;
}

declare class SettingsService implements ISettingsService {
    private themeService;
    private languageService;
    private layoutService;
    selectedLanguageLabelFn: LpxSelectedLanguageLabelFnType | null;
    settings$: Observable<Setting[]>;
    private coreSettings$;
    private languageSetting$;
    selectedSettings$: Observable<({
        shortText: string | undefined;
        id: string | undefined;
    } | {
        icon: string;
        id: string;
    })[]>;
    private _selectedLanguageLabelFn;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<SettingsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SettingsService>;
}

declare enum LayoutTranslate {
    SettingsTitle = "settings.title",
    BoxedContainer = "settings.boxedContainer",
    FullWidthContainer = "settings.fullWidthContainer",
    FluidContainer = "settings.fluidContainer"
}
type LayoutTranslateValues = {
    [key in LayoutTranslate]: string;
};
declare const LayoutTranslateDefaults: LayoutTranslateValues;

declare class LayoutSettingService {
    private containers;
    private layoutService;
    private localStorageService;
    private lpxAppStartedWithSsr;
    private cookieStorageService;
    readonly store: DataStore<{
        layouts: LpxContainer[];
        selectedLayout: LpxContainer;
    }>;
    private containerWidthTypes;
    id: string;
    convertLayoutToNavbarItem: (layouts: LpxContainer[]) => LpxNavbarItem[];
    selectedLayout$: rxjs.Observable<LpxContainer>;
    containerClass$: rxjs.Observable<string[]>;
    layouts$: rxjs.Observable<LpxContainer[]>;
    layoutsAsNavbarItems$: rxjs.Observable<LpxNavbarItem[]>;
    layoutsAsSettingsGroup$: rxjs.Observable<{
        text: LayoutTranslate;
        icon: string;
        id: string;
        children: LpxNavbarItem[];
    }>;
    constructor();
    initLayout(): void;
    changeLayout(container: LpxContainer): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutSettingService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LayoutSettingService>;
}

declare class SideMenuLayoutComponent {
    layoutService: LayoutSettingService;
    navbarPanel?: NavbarPanelDirective;
    breadcrumbPanel?: BreadcrumbPanelDirective;
    toolbarPanel?: ToolbarPanelDirective;
    settingsPanel?: SettingsPanelDirective;
    footerPanel?: FooterPanelDirective;
    navitemPanel?: NavitemPanelDirective;
    logoPanel?: LogoPanelDirective;
    currentUserImagePanel?: CurrentUserImagePanelDirective;
    mobileNavbarPanel?: MobileNavbarPanelDirective;
    mobileNavbarSettingsPanel?: MobileNavbarSettingsPanelDirective;
    mobileNavbarProfilePanel?: MobileNavbarProfilePanelDirective;
    contentPanel?: ContentPanelDirective;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<SideMenuLayoutComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SideMenuLayoutComponent, "lpx-layout", never, {}, {}, ["navbarPanel", "breadcrumbPanel", "toolbarPanel", "settingsPanel", "footerPanel", "navitemPanel", "logoPanel", "currentUserImagePanel", "mobileNavbarPanel", "mobileNavbarSettingsPanel", "mobileNavbarProfilePanel", "contentPanel"], ["*"], true, never>;
}

declare class LpxSideMenuLayoutModule {
    /**
     * @deprecated `LpxSideMenuLayoutModule.forRoot()` is deprecated. You can use `provideLpxSideMenuLayout` **function** instead.
     */
    static forRoot(options?: LpxSideMenuLayoutOptions): ModuleWithProviders<LpxSideMenuLayoutModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<LpxSideMenuLayoutModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<LpxSideMenuLayoutModule, never, [typeof i1.CommonModule, typeof i2.LpxTopbarContentModule, typeof i3.LpxBreadcrumbModule, typeof SettingsModule, typeof LpxMobileNavbarModule, typeof i3.LpxNavbarModule, typeof LpxToolbarContainerModule, typeof MenuFilterModule, typeof i3.PanelsModule, typeof i3.LpxFooterModule, typeof i3.LpxBrandLogoModule, typeof i3.LpxAvatarModule, typeof i2.LpxContextMenuModule, typeof i3.LpxResponsiveModule, typeof i2.LpxThemeModule, typeof SideMenuLayoutComponent], [typeof SideMenuLayoutComponent, typeof i2.LpxTopbarContentModule, typeof i3.LpxBreadcrumbModule, typeof SettingsModule, typeof LpxMobileNavbarModule, typeof i3.LpxNavbarModule, typeof LpxToolbarContainerModule, typeof MenuFilterModule, typeof i3.PanelsModule, typeof i3.LpxFooterModule, typeof i3.LpxBrandLogoModule, typeof i3.LpxAvatarModule, typeof i2.LpxContextMenuModule]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<LpxSideMenuLayoutModule>;
}

declare const LPX_SIDE_MENU_LAYOUT_STYLE_TOKEN: InjectionToken<LpxStyles>;

declare const getLpxSideMenuLayoutStyleProviders: (styleFactory?: LpxStyleFactory) => (i0.EnvironmentProviders | {
    provide: i0.InjectionToken<i3.LpxStyles>;
    useFactory: () => {
        bundleName: string;
    }[];
    deps?: undefined;
} | {
    provide: i0.InjectionToken<i3.LpxStyles>;
    deps: i0.InjectionToken<i3.LpxStyles>[];
    useFactory: LpxStyleFactory<i3.LpxStyles>;
})[];

declare enum LpxSideMenuLayoutFeatureKind {
    Options = 0,
    SideMenuDefaults = 1
}
interface LpxSideMenuLayoutFeature<KindT extends LpxSideMenuLayoutFeatureKind> {
    ɵkind: KindT;
    ɵproviders: (Provider | EnvironmentProviders)[];
}
declare function withLpxSideMenuOptions(options?: LpxSideMenuLayoutOptions): LpxSideMenuLayoutFeature<LpxSideMenuLayoutFeatureKind.Options>;
declare const SIDE_MENU_DEFAULTS: LpxSideMenuLayoutFeature<LpxSideMenuLayoutFeatureKind.SideMenuDefaults>;
declare function provideLpxSideMenuLayout(...features: LpxSideMenuLayoutFeature<LpxSideMenuLayoutFeatureKind>[]): EnvironmentProviders;

declare class TopMenuLayoutComponent implements AfterViewInit {
    private readonly cdr;
    layoutService: LayoutSettingService;
    navbarPanel?: NavbarPanelDirective;
    breadcrumb?: BreadcrumbPanelDirective;
    footer?: FooterPanelDirective;
    mobileNavbar?: MobileNavbarPanelDirective;
    toolbar?: ToolbarPanelDirective;
    topNavbar?: TopNavbarPanelDirective;
    settingsPanel?: SettingsPanelDirective;
    contentPanel?: ContentPanelDirective;
    logo?: LogoPanelDirective;
    mobileNavbarSettingsPanel?: MobileNavbarSettingsPanelDirective;
    mobileNavbarProfilePanel?: MobileNavbarProfilePanelDirective;
    ngAfterViewInit(): void;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<TopMenuLayoutComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TopMenuLayoutComponent, "lpx-layout", never, {}, {}, ["navbarPanel", "breadcrumb", "footer", "mobileNavbar", "toolbar", "topNavbar", "settingsPanel", "contentPanel", "logo", "mobileNavbarSettingsPanel", "mobileNavbarProfilePanel"], ["*"], true, never>;
}

declare class LpxTopMenuNavItemComponent {
    private languageService;
    private renderer2;
    isInnerMenu: i0.InputSignal<boolean>;
    menuItem: i0.InputSignal<LpxNavbarItem>;
    get isRTL(): boolean;
    onHover(): void;
    floating: ElementRef | undefined;
    reference: ElementRef;
    private calculatePosition;
    getPosition(): Placement;
    static ɵfac: i0.ɵɵFactoryDeclaration<LpxTopMenuNavItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LpxTopMenuNavItemComponent, "lpx-top-menu-nav-item", never, { "isInnerMenu": { "alias": "isInnerMenu"; "required": false; "isSignal": true; }; "menuItem": { "alias": "menuItem"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class TopMenuNavItemModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<TopMenuNavItemModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<TopMenuNavItemModule, never, [typeof i1.CommonModule, typeof i2$1.RouterModule, typeof LpxTopMenuNavItemComponent], [typeof LpxTopMenuNavItemComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<TopMenuNavItemModule>;
}

declare class HeaderComponent {
    private topMenuSubNavbarService;
    menuItems$: Observable<LpxNavbarItem[]>;
    navbarTemplateRef: TemplateRef<unknown> | undefined;
    logoTemplateRef: TemplateRef<unknown> | undefined;
    toolbarTemplateRef: TemplateRef<unknown> | undefined;
    topNavbarTemplateRef: TemplateRef<unknown> | undefined;
    settingsTemplateRef: TemplateRef<unknown> | undefined;
    layouts: typeof Layouts;
    static ɵfac: i0.ɵɵFactoryDeclaration<HeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HeaderComponent, "lpx-header", never, { "navbarTemplateRef": { "alias": "navbarTemplateRef"; "required": false; }; "logoTemplateRef": { "alias": "logoTemplateRef"; "required": false; }; "toolbarTemplateRef": { "alias": "toolbarTemplateRef"; "required": false; }; "topNavbarTemplateRef": { "alias": "topNavbarTemplateRef"; "required": false; }; "settingsTemplateRef": { "alias": "settingsTemplateRef"; "required": false; }; }, {}, never, never, true, never>;
}

declare class TopMenuNavbarComponent implements OnDestroy {
    private navbarService;
    menuItems$: rxjs.Observable<i3.LpxNavbarItem[]>;
    subscription: Subscription;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TopMenuNavbarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TopMenuNavbarComponent, "lpx-top-menu-navbar", never, {}, {}, never, never, true, never>;
}

declare class MobileToolbarItemComponent {
    item: ToolbarItem;
    get count(): number;
    get color(): string | undefined;
    get icon(): string | undefined;
    get badgeIcon(): string | undefined;
    action(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MobileToolbarItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MobileToolbarItemComponent, "lpx-mobile-toolbar-item", never, { "item": { "alias": "item"; "required": true; }; }, {}, never, never, true, never>;
}

declare class HeaderToolbarComponent {
    protected readonly toolbarService: ToolbarService;
    class: string;
    itemsTmp?: TemplateRef<any>;
    items$: Observable<ToolbarItem[]>;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<HeaderToolbarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HeaderToolbarComponent, "lpx-header-toolbar", never, {}, {}, ["itemsTmp"], never, true, never>;
}

declare class HeaderUserComponent {
    class: string;
    avatarContainerRef: ElementRef;
    ctxMenu: ContextMenuComponent;
    readonly authService: AuthService;
    readonly userProfileService: UserProfileService;
    readonly menuTriggerType: ContextMenuTriggerEvent;
    protected readonly currentUser: i0.Signal<UserProfile<string>>;
    isAuthenticated: i0.Signal<boolean>;
    openCtxMenu(eventType: ContextMenuTriggerEvent): void;
    closeCtxMenu(eventType: ContextMenuTriggerEvent): void;
    navigateToLogin(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HeaderUserComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HeaderUserComponent, "lpx-header-user", never, {}, {}, never, never, true, never>;
}

declare class LpxHeaderModule {
    /**
     * @deprecated `LpxHeaderModule.forRoot()` is deprecated. You can use `provideLpxHeader` **function** instead.
     */
    static forRoot(userMenuEventName: ContextMenuTriggerEvent, settingsMenuEventName: ContextMenuTriggerEvent): ModuleWithProviders<LpxHeaderModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<LpxHeaderModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<LpxHeaderModule, never, [typeof i1.CommonModule, typeof i3.LpxBrandLogoModule, typeof SettingsModule, typeof TopMenuNavItemModule, typeof i3.LpxAvatarModule, typeof LpxToolbarModule, typeof i2.LpxContextMenuModule, typeof i3.LpxNavbarModule, typeof i3.LpxClickOutsideModule, typeof HeaderComponent, typeof TopMenuNavbarComponent, typeof HeaderToolbarComponent, typeof HeaderUserComponent], [typeof HeaderComponent, typeof TopMenuNavbarComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<LpxHeaderModule>;
}

declare class LpxTopMenuLayoutModule {
    /**
     * @deprecated `LpxTopMenuLayoutModule.forRoot()` is deprecated. You can use `provideLpxTopMenuLayout` **function** instead.
     */
    static forRoot(options?: LpxTopMenuLayoutOptions): ModuleWithProviders<LpxTopMenuLayoutModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<LpxTopMenuLayoutModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<LpxTopMenuLayoutModule, never, [typeof i1.CommonModule, typeof i2.LpxTopbarContentModule, typeof i3.LpxBreadcrumbModule, typeof LpxMobileNavbarModule, typeof LpxHeaderModule, typeof i3.LpxLanguageModule, typeof i3.PanelsModule, typeof i3.LpxResponsiveModule, typeof i3.LpxFooterModule, typeof TopMenuLayoutComponent], [typeof TopMenuLayoutComponent, typeof i2.LpxTopbarContentModule, typeof i3.LpxBreadcrumbModule, typeof LpxMobileNavbarModule, typeof LpxHeaderModule, typeof i3.LpxLanguageModule, typeof i3.PanelsModule, typeof i3.LpxResponsiveModule, typeof i3.LpxFooterModule]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<LpxTopMenuLayoutModule>;
}

declare class TopMenuSubNavbarService {
    private _items$;
    readonly items$: rxjs.Observable<LpxNavbarItem[]>;
    setItems(value: LpxNavbarItem[]): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TopMenuSubNavbarService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TopMenuSubNavbarService>;
}

declare enum TopMenuLayoutTranslate {
    GeneralSettings = "topMenuLayout.settings.generalSettings"
}
type TopMenuLayoutTranslateValues = {
    [key in TopMenuLayoutTranslate]: string;
};
declare const TopMenuLayoutTranslateDefaults: TopMenuLayoutTranslateValues;

declare const LPX_TOP_MENU_LAYOUT_STYLE_TOKEN: InjectionToken<LpxStyles>;

declare const getLpxTopMenuLayoutStyleProviders: (styleFactory?: LpxStyleFactory) => (i0.EnvironmentProviders | {
    provide: i0.InjectionToken<i3.LpxStyles>;
    useFactory: () => {
        bundleName: string;
    }[];
    deps?: undefined;
} | {
    provide: i0.InjectionToken<i3.LpxStyles>;
    deps: i0.InjectionToken<i3.LpxStyles>[];
    useFactory: LpxStyleFactory<i3.LpxStyles>;
})[];

declare enum LpxTopMenuLayoutFeatureKind {
    Options = 0,
    AppendDefaults = 1
}
interface LpxTopMenuLayoutFeature<KindT extends LpxTopMenuLayoutFeatureKind> {
    ɵkind: KindT;
    ɵproviders: (Provider | EnvironmentProviders)[];
}
declare function withLpxTopMenuOptions(options?: LpxTopMenuLayoutOptions): LpxTopMenuLayoutFeature<LpxTopMenuLayoutFeatureKind>;
declare const TOP_MENU_DEFAULTS: LpxTopMenuLayoutFeature<LpxTopMenuLayoutFeatureKind.AppendDefaults>;
declare function provideLpxTopMenuLayout(...features: LpxTopMenuLayoutFeature<LpxTopMenuLayoutFeatureKind>[]): EnvironmentProviders;

type LpxHeaderOptions = Pick<LpxTopMenuLayoutOptions, 'userMenuEventName' | 'settingsMenuEventName'>;
declare enum LpxHeaderFeatureKind {
    Options = 0
}
interface LpxHeaderFeature<KindT extends LpxHeaderFeatureKind> {
    ɵkind: KindT;
    ɵproviders: (Provider | EnvironmentProviders)[];
}
declare function withHeaderOptions(options?: LpxHeaderOptions): LpxHeaderFeature<LpxHeaderFeatureKind>;
declare function provideLpxHeader(...features: LpxHeaderFeature<LpxHeaderFeatureKind>[]): EnvironmentProviders;

declare function provideLpxMobileNavbar(): EnvironmentProviders;

declare function provideLpxToolbarContainer(): EnvironmentProviders;

declare const AUTH_LAYOUT_IMG: InjectionToken<string>;

declare class AuthLayoutComponent {
    protected readonly appName: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<AuthLayoutComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AuthLayoutComponent, "lpx-auth-layout", never, {}, {}, never, ["*"], true, never>;
}

interface LpxAuthLayoutOptions {
    authLayoutImg?: string;
}
declare class LpxAuthLayoutModule {
    static forRoot(options?: LpxAuthLayoutOptions): ModuleWithProviders<LpxAuthLayoutModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<LpxAuthLayoutModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<LpxAuthLayoutModule, never, [typeof i1.CommonModule, typeof AuthLayoutComponent], [typeof AuthLayoutComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<LpxAuthLayoutModule>;
}

/**
 * @deprecated The variable should not be used
 */
declare const defaultLoginBg = "";

declare function combineAndFilterByChildren<T extends {
    children: LpxNavbarItem[];
}>(obs: Observable<T>[]): Observable<T[]>;

declare const LPX_CONTAINERS: InjectionToken<LpxContainer[]>;
declare const LPX_SETTINGS_SERVICE: InjectionToken<ISettingsService>;
declare const LPX_GENERAL_SETTINGS_TRANSLATE_KEY: InjectionToken<string>;
declare const LPX_SETTINGS_MENU_EVENT_NAME: InjectionToken<ContextMenuTriggerEvent>;
declare const LPX_USER_MENU_EVENT_NAME: InjectionToken<ContextMenuTriggerEvent>;
declare const LPX_SELECTED_LANGUAGE_LABEL_FN: InjectionToken<LpxSelectedLanguageLabelFnType>;

declare const DefaultSelectedLanguageLabelFn: LpxSelectedLanguageLabelFnType;
declare const ContainerDefaults: LpxContainer[];

export { AUTH_LAYOUT_IMG, AuthLayoutComponent, ContainerDefaults, DefaultSelectedLanguageLabelFn, HeaderComponent, HeaderToolbarComponent, HeaderUserComponent, LPX_CONTAINERS, LPX_GENERAL_SETTINGS_TRANSLATE_KEY, LPX_SELECTED_LANGUAGE_LABEL_FN, LPX_SETTINGS_MENU_EVENT_NAME, LPX_SETTINGS_SERVICE, LPX_SIDE_MENU_LAYOUT_STYLE_TOKEN, LPX_TOP_MENU_LAYOUT_STYLE_TOKEN, LPX_USER_MENU_EVENT_NAME, LayoutSettingService, LayoutTranslate, LayoutTranslateDefaults, LpxAuthLayoutModule, LpxHeaderFeatureKind, LpxHeaderModule, LpxMobileNavbarModule, LpxSideMenuLayoutFeatureKind, LpxSideMenuLayoutModule, LpxToolbarContainerModule, LpxToolbarModule, LpxTopMenuLayoutFeatureKind, LpxTopMenuLayoutModule, LpxTopMenuNavItemComponent, MenuFilterComponent, MenuFilterModule, MobileMenuTranslate, MobileMenuTranslateDefaults, MobileNavbarComponent, MobileNavbarService, MobileToolbarComponent, MobileToolbarItemComponent, SIDE_MENU_DEFAULTS, SettingComponent, SettingsComponent, SettingsFeatureKind, SettingsModule, SettingsService, SideMenuLayoutComponent, SideMenuLayoutTranslate, SideMenuLayoutTranslateDefaults, TOP_MENU_DEFAULTS, ToolbarComponent, ToolbarContainerComponent, ToolbarItemComponent, ToolbarItemsComponent, ToolbarItemsDirective, ToolbarTranslateDefaults, ToolbarTranslateKeys, TopMenuLayoutComponent, TopMenuLayoutTranslate, TopMenuLayoutTranslateDefaults, TopMenuNavbarComponent, TopMenuSubNavbarService, combineAndFilterByChildren, defaultLoginBg, defineSettingsProviders, getLpxSideMenuLayoutStyleProviders, getLpxTopMenuLayoutStyleProviders, provideLpxHeader, provideLpxMobileNavbar, provideLpxSideMenuLayout, provideLpxToolbarContainer, provideLpxTopMenuLayout, withHeaderOptions, withLpxSideMenuOptions, withLpxTopMenuOptions, withSettingsOption };
export type { Badge, ContextMenuTriggerEvent, ISettingsService, LayoutTranslateValues, LpxAuthLayoutOptions, LpxContainer, LpxHeaderFeature, LpxHeaderOptions, LpxSelectedLanguageLabelFnType, LpxSideMenuLayoutFeature, LpxSideMenuLayoutOptions, LpxTopMenuLayoutFeature, LpxTopMenuLayoutOptions, MobileMenuTranslateValues, MobileNavbarState, Setting, SettingsFeature, SettingsOptions, SideMenuLayoutTranslateValues, ToolbarItem, ToolbarTranslateValues, TopMenuLayoutTranslateValues };