import * as i0 from '@angular/core';
import { AfterViewInit, OnDestroy, ElementRef, Type, TemplateRef, ChangeDetectorRef, EventEmitter, TrackByFunction, Injector, OnInit, Provider, ModuleWithProviders, InjectionToken } from '@angular/core';
import * as _abp_ng_core from '@abp/ng.core';
import { eLayoutType, ApplicationInfo, CurrentUserDto, RouterEvents, LanguageInfo, EnvironmentService, RoutesService, TreeNode, ABP, SubscriptionService } from '@abp/ng.core';
import { AuthWrapperService, TenantBoxService } from '@volo/abp.ng.account.core';
import * as rxjs from 'rxjs';
import { Subscription, BehaviorSubject, Observable, Subject } from 'rxjs';
import { ProfilePictureImage, ModuleVisibility } from '@volo/abp.commercial.ng.ui/config';
import { Location } from '@angular/common';
import { ActivatedRoute, Router } from '@angular/router';
import * as i2 from '@abp/ng.theme.shared';
import { UserMenuService, UserMenu, NavItemsService, NavItem, PageAlertService, ToasterService } from '@abp/ng.theme.shared';
import * as _angular_forms from '@angular/forms';
import { UntypedFormBuilder } from '@angular/forms';
import * as _volo_abp_ng_theme_lepton_proxy from '@volo/abp.ng.theme.lepton/proxy';
import { UpdateLeptonThemeSettingsDto, MenuPlacement, MenuStatus } from '@volo/abp.ng.theme.lepton/proxy';
import * as i4 from '@ngx-validate/core';
import { ValidationErrorComponent as ValidationErrorComponent$1, Validation } from '@ngx-validate/core';
import * as i3 from '@ng-bootstrap/ng-bootstrap';

declare class AccountLayoutComponent implements AfterViewInit, OnDestroy {
    private renderer;
    static type: eLayoutType;
    authWrapperKey: string;
    isCollapsed: boolean;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AccountLayoutComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AccountLayoutComponent, "abp-layout-account", never, {}, {}, never, never, true, never>;
}

declare class AccountLogoComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<AccountLogoComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AccountLogoComponent, "abp-account-logo", never, {}, {}, never, never, true, never>;
}

declare class AuthWrapperComponent {
    service: AuthWrapperService;
    isFlagIconEnabled: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<AuthWrapperComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AuthWrapperComponent, "abp-auth-wrapper", never, {}, {}, never, ["*"], true, never>;
}

declare class TenantBoxComponent {
    service: TenantBoxService;
    static ɵfac: i0.ɵɵFactoryDeclaration<TenantBoxComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TenantBoxComponent, "abp-tenant-box", never, {}, {}, never, never, true, never>;
}

declare const enum eThemeLeptonComponents {
    AccountLayout = "Theme.AccountLayoutComponent",
    ApplicationLayout = "Theme.ApplicationLayoutComponent",
    ApplicationLayoutHeader = "Theme.ApplicationLayoutHeaderComponent",
    ApplicationLayoutFooter = "Theme.ApplicationLayoutFooterComponent",
    CurrentUser = "Theme.CurrentUserComponent",
    CurrentUserImage = "Theme.CurrentUserImageComponent",
    EmptyLayout = "Theme.EmptyLayoutComponent",
    FullScreen = "Theme.FullScreenComponent",
    Languages = "Theme.LanguagesComponent",
    Logo = "Theme.LogoComponent",
    Routes = "Theme.RoutesComponent",
    Navbar = "Theme.NavbarComponent",
    NavbarMobile = "Theme.NavbarMobileComponent",
    NavItems = "Theme.NavItemsComponent",
    Sidebar = "Theme.Sidebar"
}

declare class ApplicationLayoutComponent implements OnDestroy {
    private environment;
    private layoutState;
    private layout;
    static type: eLayoutType;
    headerComponentKey: eThemeLeptonComponents;
    footerComponentKey: eThemeLeptonComponents;
    mouseMoveSubscription: Subscription;
    containers$: BehaviorSubject<ElementRef<HTMLElement>[]>;
    get appInfo(): ApplicationInfo;
    listenMouseMove(containerRefs: ElementRef<HTMLElement>[]): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApplicationLayoutComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ApplicationLayoutComponent, "abp-application-layout", never, {}, {}, never, never, true, never>;
}

declare namespace ThemeLepton {
    interface Options {
        contentAfterRoutes?: Type<any>[];
        contentBeforeRoutes?: Type<any>[];
        customStyle?: boolean;
    }
    interface CurrentUserImageComponentInputs {
        readonly currentUser?: CurrentUserDto;
        readonly classes: string;
    }
}

declare class CurrentUserImageComponent implements ThemeLepton.CurrentUserImageComponentInputs {
    profilePicture$: BehaviorSubject<ProfilePictureImage>;
    classes: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<CurrentUserImageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CurrentUserImageComponent, "abp-current-user-image", never, { "classes": { "alias": "classes"; "required": false; }; }, {}, never, never, true, never>;
}

declare class EmptyLayoutComponent {
    static type: eLayoutType;
    static ɵfac: i0.ɵɵFactoryDeclaration<EmptyLayoutComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EmptyLayoutComponent, "abp-layout-empty", never, {}, {}, never, never, true, never>;
}

declare namespace Layout {
    enum MenuStatus {
        AlwaysOpened = 0,
        OpenOnHover = 1
    }
    enum MenuPlacement {
        Left = 0,
        Top = 1
    }
    type LogoColor = 'dark' | 'light';
    interface NavigationElement {
        name: string;
        element: TemplateRef<any>;
        order?: number;
    }
    interface State {
        isMenuExpanded: boolean;
        isNavbarExpanded: boolean;
        smallScreen: boolean;
        isSidebarCollapsed: boolean;
        isMenuPlacementTop: boolean;
        mouseOnSidebar: boolean;
        style: number;
        styleElement: HTMLLinkElement;
        menuPlacement: MenuPlacement;
        boxedLayout: boolean;
        menuStatus: MenuStatus;
    }
    type StateKeys = keyof State;
}

declare class LayoutStateService {
    private store;
    state$: Observable<Layout.State>;
    getPrimaryLogoColor(): Layout.LogoColor;
    getPrimaryLogoColor$(): Observable<Layout.LogoColor>;
    getSecondaryLogoColor(): Layout.LogoColor;
    getSecondaryLogoColor$(): Observable<Layout.LogoColor>;
    get<T extends Layout.StateKeys>(key: T): Layout.State[T];
    get$<T extends Layout.StateKeys>(key: T): Observable<Layout.State[T]>;
    update$<T extends Layout.StateKeys>(key: T): Observable<{
        isMenuExpanded?: boolean;
        isNavbarExpanded?: boolean;
        smallScreen?: boolean;
        isSidebarCollapsed?: boolean;
        isMenuPlacementTop?: boolean;
        mouseOnSidebar?: boolean;
        style?: number;
        styleElement?: HTMLLinkElement;
        menuPlacement?: Layout.MenuPlacement;
        boxedLayout?: boolean;
        menuStatus?: Layout.MenuStatus;
    }[T]>;
    patch(state: Partial<Layout.State>): void;
    private getLogoColor;
    private getLogoColor$;
    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutStateService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LayoutStateService>;
}

declare class HeaderComponent implements AfterViewInit {
    protected readonly layoutStateService: LayoutStateService;
    protected readonly cdr: ChangeDetectorRef;
    state$: rxjs.Observable<{
        isNavbarExpanded: boolean;
        isMenuExpanded: boolean;
        smallScreen: boolean;
        isMenuPlacementTop: boolean;
    }>;
    logoComponentKey: eThemeLeptonComponents;
    navbarComponentKey: eThemeLeptonComponents;
    navbarMobileComponentKey: eThemeLeptonComponents;
    sidebarComponentKey: eThemeLeptonComponents;
    mouseMoveContainer: EventEmitter<ElementRef<HTMLElement>[]>;
    navbarBrandRef: ElementRef<any>;
    ngAfterViewInit(): void;
    navbarIconClick(isNavbarExpanded: boolean): void;
    menuIconClick(isMenuExpanded: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HeaderComponent, "abp-header", never, {}, { "mouseMoveContainer": "mouseMoveContainer"; }, never, never, true, never>;
}

declare class FooterComponent {
    currentYear: number;
    appInfo: ApplicationInfo;
    static ɵfac: i0.ɵɵFactoryDeclaration<FooterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FooterComponent, "abp-footer", never, { "appInfo": { "alias": "appInfo"; "required": false; }; }, {}, never, never, true, never>;
}

declare class HttpErrorComponent {
    protected readonly activatedRoute: ActivatedRoute;
    protected readonly router: Router;
    protected readonly location: Location;
    protected readonly routerEvents: RouterEvents;
    destroy$: Subject<void>;
    readonly status: i0.WritableSignal<number>;
    protected readonly errorStatusText: i0.Signal<any>;
    protected readonly errorDetail: i0.Signal<any>;
    readonly lastNavigation: i0.Signal<string>;
    readonly currentNavigation: i0.Signal<string>;
    constructor();
    goBack(): void;
    goHome(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HttpErrorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HttpErrorComponent, "abp-http-error", never, {}, {}, never, never, true, never>;
}

declare class LogoComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<LogoComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LogoComponent, "abp-logo", never, {}, {}, never, never, true, never>;
}

declare class CurrentUserComponent {
    readonly userMenu: UserMenuService;
    private authService;
    private sessionState;
    private configState;
    currentUser$: rxjs.Observable<_abp_ng_core.CurrentUserDto>;
    selectedTenant$: rxjs.Observable<_abp_ng_core.CurrentTenantDto>;
    currentUserImageComponentKey: eThemeLeptonComponents;
    trackByFn: TrackByFunction<UserMenu>;
    get smallScreen(): boolean;
    navigateToLogin(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CurrentUserComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CurrentUserComponent, "abp-current-user", never, {}, {}, never, never, true, never>;
}

declare class FullScreenComponent {
    protected readonly document: Document;
    get fullscreen(): boolean;
    toggleFullscreen(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FullScreenComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FullScreenComponent, "abp-full-screen", never, {}, {}, never, never, true, never>;
}

declare class LanguagesComponent {
    private configState;
    private sessionState;
    isFlagIconEnabled: boolean;
    get smallScreen(): boolean;
    languages$: Observable<any>;
    get defaultLanguage$(): Observable<{
        displayName: string;
        flagIcon: string;
    }>;
    get dropdownLanguages$(): Observable<LanguageInfo[]>;
    get selectedLangCulture(): string;
    changeLang(cultureName: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LanguagesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LanguagesComponent, "abp-languages", never, {}, {}, never, never, true, never>;
}

declare class NavItemsComponent {
    readonly navItems: NavItemsService;
    trackByFn: TrackByFunction<NavItem>;
    static ɵfac: i0.ɵɵFactoryDeclaration<NavItemsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NavItemsComponent, "abp-nav-items", never, {}, {}, never, never, true, never>;
}

declare class NavbarComponent {
    isNavbarExpanded: boolean;
    smallScreen: any;
    navItemsComponentKey: eThemeLeptonComponents;
    static ɵfac: i0.ɵɵFactoryDeclaration<NavbarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NavbarComponent, "abp-navbar", never, { "isNavbarExpanded": { "alias": "isNavbarExpanded"; "required": false; }; "smallScreen": { "alias": "smallScreen"; "required": false; }; }, {}, never, never, true, never>;
}

declare class NavbarMobileComponent {
    isNavbarExpanded: boolean;
    isMenuExpanded: boolean;
    navbarIconClick: EventEmitter<boolean>;
    menuIconClick: EventEmitter<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<NavbarMobileComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NavbarMobileComponent, "abp-navbar-mobile", never, { "isNavbarExpanded": { "alias": "isNavbarExpanded"; "required": false; }; "isMenuExpanded": { "alias": "isMenuExpanded"; "required": false; }; }, { "navbarIconClick": "navbarIconClick"; "menuIconClick": "menuIconClick"; }, never, never, true, never>;
}

declare class PageAlertContainerComponent {
    service: PageAlertService;
    static ɵfac: i0.ɵɵFactoryDeclaration<PageAlertContainerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PageAlertContainerComponent, "abp-page-alert-container", never, {}, {}, never, never, true, never>;
}

declare class RoutesComponent implements AfterViewInit {
    clickedToLink: EventEmitter<MouseEvent>;
    isMenuPlacementTop: boolean;
    smallScreen: boolean;
    readonly expandedRoutes: Set<string>;
    readonly initialLevel = 1;
    readonly environmentService: EnvironmentService;
    private router;
    readonly routes: RoutesService;
    readonly injector: Injector;
    contentBefore: Type<any>[];
    contentAfter: Type<any>[];
    filterOp: rxjs.OperatorFunction<TreeNode<ABP.Route>[], TreeNode<ABP.Route>[]>;
    trackByFn: TrackByFunction<TreeNode<ABP.Route>>;
    get routes$(): rxjs.Observable<TreeNode<ABP.Route>[]>;
    constructor();
    ngAfterViewInit(): void;
    isDropdown(node: TreeNode<ABP.Route>): boolean;
    onNavigate({ parentName }: ABP.Route, level: number): void;
    toggleExpand({ name }: ABP.Route, level: number): void;
    collapseDropdowns(name: string, level: number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RoutesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RoutesComponent, "abp-routes", never, { "isMenuPlacementTop": { "alias": "isMenuPlacementTop"; "required": false; }; "smallScreen": { "alias": "smallScreen"; "required": false; }; }, { "clickedToLink": "clickedToLink"; }, never, never, true, never>;
}

declare class LayoutService {
    private renderer;
    private rendererFactory;
    private themeSettingsService;
    private layoutState;
    private configState;
    protected injector: Injector;
    layoutConfigKey: string;
    constructor();
    listenToLeptonSettings(): void;
    fetchThemeSettings(): rxjs.Observable<_volo_abp_ng_theme_lepton_proxy.LeptonThemeSettingsDto>;
    updateThemeSettings(themeSettings: UpdateLeptonThemeSettingsDto): rxjs.Observable<void>;
    setLayoutBoxed(boxedLayout: boolean): void;
    setMenuStatus(menuStatus: Layout.MenuStatus): void;
    setMenuPlacement(menuPlacement: Layout.MenuPlacement): void;
    onClickMenuIcon(value: boolean): void;
    addMenuPlacementClasses(menuPlacement: Layout.MenuPlacement): void;
    addMenuStatusClasses(menuStatus: Layout.MenuStatus): void;
    addSidebarClasses(mouseOnSidebar: any): void;
    changeMenuPlacementByScreenSize(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LayoutService>;
}

declare class SettingsComponent implements OnInit, AfterViewInit {
    protected readonly subscription: SubscriptionService;
    protected readonly layoutService: LayoutService;
    protected readonly toaster: ToasterService;
    protected readonly fb: UntypedFormBuilder;
    protected readonly customStyle: boolean;
    protected readonly form: _angular_forms.UntypedFormGroup;
    placements: {
        Left: MenuPlacement;
        Top: MenuPlacement;
    };
    statuses: {
        AlwaysOpened: MenuStatus;
        OpenOnHover: MenuStatus;
    };
    boxedLayout: boolean;
    loading: boolean;
    viewInitialized: boolean;
    get isSmallScreen(): boolean;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    save(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SettingsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SettingsComponent, "abp-lepton-settings", never, {}, {}, never, never, true, never>;
}

declare class SidebarComponent implements AfterViewInit {
    private layoutStateService;
    private layout;
    isMenuExpanded: boolean;
    smallScreen: boolean;
    isMenuPlacementTop: boolean;
    mouseMoveContainer: EventEmitter<ElementRef<HTMLElement>[]>;
    routesComponentKey: eThemeLeptonComponents;
    mouseOnSidebar$: rxjs.Observable<boolean>;
    isSidebarCollapsed$: rxjs.Observable<boolean>;
    navbarSidebarRef: ElementRef<HTMLElement>;
    onClickLink(): void;
    onClickMenuIcon(isSidebarCollapsed: boolean): void;
    ngAfterViewInit(): void;
    listenResize(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SidebarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SidebarComponent, "abp-sidebar", never, { "isMenuExpanded": { "alias": "isMenuExpanded"; "required": false; }; "smallScreen": { "alias": "smallScreen"; "required": false; }; "isMenuPlacementTop": { "alias": "isMenuPlacementTop"; "required": false; }; }, { "mouseMoveContainer": "mouseMoveContainer"; }, never, never, true, never>;
}

declare class ValidationErrorComponent extends ValidationErrorComponent$1 {
    get abpErrors(): Validation.Error[] & {
        interpoliteParams?: string[];
    };
    static ɵfac: i0.ɵɵFactoryDeclaration<ValidationErrorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ValidationErrorComponent, "abp-validation-error", never, {}, {}, never, never, true, never>;
}

declare const LEPTON_STYLE_ELEMENT_ID = "lepton-styles";

declare const LEPTON_THEME_NAV_ITEM_PROVIDERS: i0.EnvironmentProviders[];

declare const LEPTON_THEME_SETTING_TAB_PROVIDERS: i0.EnvironmentProviders[];

declare const LEPTON_THEME_STYLES_PROVIDERS: i0.EnvironmentProviders[];

declare enum ThemeLeptonFeatureKind {
    Options = 0
}
interface ThemeLeptonFeature<KindT extends ThemeLeptonFeatureKind> {
    ɵkind: KindT;
    ɵproviders: Provider[];
}
declare function withOptions(options: ThemeLepton.Options): ThemeLeptonFeature<ThemeLeptonFeatureKind.Options>;
declare function provideThemeLepton(...features: ThemeLeptonFeature<ThemeLeptonFeatureKind>[]): i0.EnvironmentProviders;

declare const LAYOUTS: (typeof EmptyLayoutComponent)[];
declare class BaseThemeLeptonModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseThemeLeptonModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<BaseThemeLeptonModule, never, [typeof _abp_ng_core.CoreModule, typeof i2.ThemeSharedModule, typeof i3.NgbDropdownModule, typeof i4.NgxValidateCoreModule, typeof ApplicationLayoutComponent, typeof AccountLayoutComponent, typeof EmptyLayoutComponent, typeof SettingsComponent, typeof ValidationErrorComponent, typeof HttpErrorComponent, typeof LogoComponent, typeof RoutesComponent, typeof NavItemsComponent, typeof CurrentUserImageComponent, typeof LanguagesComponent, typeof CurrentUserComponent, typeof FullScreenComponent, typeof NavbarComponent, typeof NavbarMobileComponent, typeof HeaderComponent, typeof FooterComponent, typeof SidebarComponent, typeof PageAlertContainerComponent, typeof AuthWrapperComponent, typeof TenantBoxComponent, typeof AccountLogoComponent], [typeof ApplicationLayoutComponent, typeof AccountLayoutComponent, typeof EmptyLayoutComponent, typeof SettingsComponent, typeof ValidationErrorComponent, typeof HttpErrorComponent, typeof LogoComponent, typeof RoutesComponent, typeof NavItemsComponent, typeof CurrentUserImageComponent, typeof LanguagesComponent, typeof CurrentUserComponent, typeof FullScreenComponent, typeof NavbarComponent, typeof NavbarMobileComponent, typeof HeaderComponent, typeof FooterComponent, typeof SidebarComponent, typeof PageAlertContainerComponent, typeof AuthWrapperComponent, typeof TenantBoxComponent, typeof AccountLogoComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<BaseThemeLeptonModule>;
}
declare class ThemeLeptonModule {
    /**
     * @deprecated forRoot method is deprecated, use `provideThemeLepton` *function* for config settings.
     */
    static forRoot(options?: ThemeLepton.Options): ModuleWithProviders<ThemeLeptonModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThemeLeptonModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ThemeLeptonModule, never, [typeof BaseThemeLeptonModule], [typeof BaseThemeLeptonModule]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ThemeLeptonModule>;
}

declare const CONTENT_BEFORE_ROUTES: InjectionToken<Type<any>[]>;
declare const CONTENT_AFTER_ROUTES: InjectionToken<Type<any>[]>;

declare const CUSTOM_STYLE: InjectionToken<boolean>;

declare const LEPTON_THEME_FEATURES: InjectionToken<Observable<ModuleVisibility>>;
declare const SET_LEPTON_THEME_SETTING_TAB_VISIBILITY: InjectionToken<void>;
declare const LEPTON_THEME_FEATURES_PROVIDERS: i0.EnvironmentProviders[];

export { AccountLayoutComponent, AccountLogoComponent, ApplicationLayoutComponent, AuthWrapperComponent, BaseThemeLeptonModule, CONTENT_AFTER_ROUTES, CONTENT_BEFORE_ROUTES, CUSTOM_STYLE, CurrentUserComponent, CurrentUserImageComponent, EmptyLayoutComponent, FooterComponent, FullScreenComponent, HeaderComponent, HttpErrorComponent, LAYOUTS, LEPTON_STYLE_ELEMENT_ID, LEPTON_THEME_FEATURES, LEPTON_THEME_FEATURES_PROVIDERS, LEPTON_THEME_NAV_ITEM_PROVIDERS, LEPTON_THEME_SETTING_TAB_PROVIDERS, LEPTON_THEME_STYLES_PROVIDERS, LanguagesComponent, Layout, LayoutService, LayoutStateService, LogoComponent, NavItemsComponent, NavbarComponent, NavbarMobileComponent, PageAlertContainerComponent, RoutesComponent, SET_LEPTON_THEME_SETTING_TAB_VISIBILITY, SettingsComponent, SidebarComponent, TenantBoxComponent, ThemeLepton, ThemeLeptonModule, ValidationErrorComponent, eThemeLeptonComponents, provideThemeLepton, withOptions };