@volosoft/abp.ng.theme.lepton-x/types/volosoft-abp.ng.theme.lepton-x.d.ts

ABP Framework is a complete open-source infrastructure to create modern web applications by following the best practices and conventions of software development. This package is a part of the [ABP Framework](https://abp.io) and contains client-side files.

import * as i3 from '@ngx-validate/core';
import { ValidationErrorComponent, Validation } from '@ngx-validate/core';
import * as i0 from '@angular/core';
import { ModuleWithProviders, Provider, EnvironmentProviders, InjectionToken } from '@angular/core';
import * as i1 from '@angular/common';
import { Location } from '@angular/common';
import * as i2 from '@abp/ng.core';
import { RouterEvents, RouteBasedCultureUrlService } from '@abp/ng.core';
import { Router, ActivatedRoute } from '@angular/router';
import * as rxjs from 'rxjs';
import { Subject, Observable } from 'rxjs';
import { CreateErrorComponentService, HttpErrorWrapperComponent } from '@abp/ng.theme.shared';
import { TranslateService, AuthService, LanguageTranslateValues } from '@volo/ngx-lepton-x.core';
import { ThemeTranslateValues, LpxOptions } from '@volosoft/ngx-lepton-x';

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

declare class AbpValidationErrorModule {
    /**
     * @deprecated `AbpValidationErrorModule.forRoot()` is deprecated. You can use `provideAbpValidationError` **function** instead.
     */
    static forRoot(): ModuleWithProviders<AbpValidationErrorModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AbpValidationErrorModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<AbpValidationErrorModule, never, [typeof i1.CommonModule, typeof i2.CoreModule, typeof i3.NgxValidateCoreModule, typeof AbpValidationErrorComponent], [typeof AbpValidationErrorComponent, typeof i3.NgxValidateCoreModule]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<AbpValidationErrorModule>;
}

declare const enum eThemeLeptonXComponents {
    AccountLayout = "Theme.AccountLayoutComponent",
    ApplicationLayout = "Theme.ApplicationLayoutComponent",
    Footer = "Theme.FooterComponent",
    CurrentUser = "Theme.CurrentUserComponent",
    CurrentUserImage = "Theme.CurrentUserImageComponent",
    EmptyLayout = "Theme.EmptyLayoutComponent",
    Languages = "Theme.LanguagesComponent",
    Logo = "Theme.LogoComponent",
    Routes = "Theme.RoutesComponent",
    Navbar = "Theme.NavbarComponent",
    MobileNavbar = "Theme.MobileNavbarComponent",
    MobileNavbarSettings = "Theme.MobileNavbarSettingsComponent",
    MobileNavbarProfile = "Theme.MobileNavbarProfileComponent",
    NavItems = "Theme.NavItemsComponent",
    Breadcrumb = "Theme.Breadcrumb",
    PageAlertContainer = "Theme.PageAlertContainerComponent",
    Toolbar = "Theme.ToolbarComponent",
    TopNavbar = "Theme.TopNavbarComponent",
    Settings = "Theme.SettingsComponent",
    HttpError = "Theme.HttpErrorComponent"
}

declare enum eUserMenuItems {
    Sessions = "Sessions",
    SwitchTenant = "SwitchTenant",
    ExternalLogins = "ExternalLogins",
    LinkedAccounts = "LinkedAccounts",
    MyAccount = "MyAccount",
    SecurityLogs = "SecurityLogs",
    BackToImpersonator = "BackToImpersonator",
    AuthorityDelegation = "AuthorityDelegation",
    Logout = "Logout"
}

declare class HttpErrorComponent {
    protected readonly router: Router;
    protected readonly activatedRoute: ActivatedRoute;
    protected readonly location: Location;
    protected readonly routerEvents: RouterEvents;
    protected readonly platformId: Object;
    readonly destroy$: Subject<void>;
    protected readonly errorComponentKey = eThemeLeptonXComponents.HttpError;
    protected readonly status: i0.WritableSignal<number>;
    readonly lastNavigation: i0.Signal<string>;
    readonly currentNavigation: i0.Signal<string>;
    protected readonly statusText: i0.Signal<any>;
    protected readonly detail: i0.Signal<any>;
    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 AbpSettingsService {
    private sessionService;
    private configStateService;
    private languageService;
    private userProfileService;
    private profilePicture$;
    navigateToManageProfile: () => void;
    navigateToMySecurityLogs: () => void;
    openMyLinkUsersModal: unknown;
    private userMenuService;
    protected readonly routeCultureUrl: RouteBasedCultureUrlService;
    setUpListeners(): void;
    setUserProfile(): void;
    setUserMenuGroups(): void;
    setProfilePicture(): void;
    setLanguageOptions(): void;
    listenToLangChange(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AbpSettingsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AbpSettingsService>;
}

declare class AbpCreateErrorComponentService extends CreateErrorComponentService {
    protected readonly router: Router;
    protected readonly httpErrorPath: string;
    constructor();
    execute(instance: Partial<HttpErrorWrapperComponent>): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AbpCreateErrorComponentService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AbpCreateErrorComponentService>;
}

declare class AbpTranslateService implements TranslateService {
    private localization;
    private translateKeys;
    get(key: string, defaultValue: string | undefined): string;
    get$(key: string, defaultValue: string | undefined): Observable<string>;
    private getKey;
    static ɵfac: i0.ɵɵFactoryDeclaration<AbpTranslateService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AbpTranslateService>;
}

declare class AbpAuthService implements AuthService {
    private userProfileService;
    private authService;
    isUserExists$: rxjs.Observable<boolean>;
    navigateToLogin(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AbpAuthService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AbpAuthService>;
}

declare const INIT_SERVICE_PROVIDER: i0.EnvironmentProviders;
declare function initServices(): void;

declare const LPX_STYLE_PROVIDER: i0.EnvironmentProviders;

declare const LPX_TRANSLATE_PROVIDER: Provider;
declare const translateKeys: ThemeTranslateValues & LanguageTranslateValues;
declare const LPX_TRANSLATE_KEYS_PROVIDER: Provider;

declare const ACCOUNT_LAYOUT_PROVIDER: i0.EnvironmentProviders;
declare function initAccountLayout(): void;

type ThemeLeptonXModuleOptions = LpxOptions;
declare enum ThemeLeptonXFeatureKind {
    Options = 0
}
interface ThemeLeptonXFeature<KindT extends ThemeLeptonXFeatureKind> {
    ɵkind: KindT;
    ɵproviders: (Provider | EnvironmentProviders)[];
}
declare function withThemeLeptonXOptions(options?: ThemeLeptonXModuleOptions): ThemeLeptonXFeature<ThemeLeptonXFeatureKind.Options>;
declare function provideAbpValidationError(): EnvironmentProviders;
declare function provideThemeLeptonX(...features: ThemeLeptonXFeature<ThemeLeptonXFeatureKind>[]): EnvironmentProviders;

declare function httpErrorProvider(options: ThemeLeptonXModuleOptions): (Provider | EnvironmentProviders)[];

declare const LEPTON_X_USER_MENU_PROVIDERS: i0.EnvironmentProviders[];
declare function configureUserMenu(): void;

declare function leptonXRoutes(options: ThemeLeptonXModuleOptions): EnvironmentProviders;

declare class ThemeLeptonXModule {
    /**
     * @deprecated `ThemeLeptonXModule.forRoot()` is deprecated. You can use `provideThemeLeptonX` **function** instead.
     */
    static forRoot(options?: ThemeLeptonXModuleOptions): ModuleWithProviders<ThemeLeptonXModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThemeLeptonXModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ThemeLeptonXModule, never, never, never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ThemeLeptonXModule>;
}

declare const HTTP_ERROR_PATH: InjectionToken<string>;

declare const LPX_TRANSLATE_KEY_MAP_TOKEN: InjectionToken<{
    [key: string]: string;
}>;

export { ACCOUNT_LAYOUT_PROVIDER, AbpAuthService, AbpCreateErrorComponentService, AbpSettingsService, AbpTranslateService, AbpValidationErrorComponent, AbpValidationErrorModule, HTTP_ERROR_PATH, HttpErrorComponent, INIT_SERVICE_PROVIDER, LEPTON_X_USER_MENU_PROVIDERS, LPX_STYLE_PROVIDER, LPX_TRANSLATE_KEYS_PROVIDER, LPX_TRANSLATE_KEY_MAP_TOKEN, LPX_TRANSLATE_PROVIDER, ThemeLeptonXFeatureKind, ThemeLeptonXModule, configureUserMenu, eThemeLeptonXComponents, eUserMenuItems, httpErrorProvider, initAccountLayout, initServices, leptonXRoutes, provideAbpValidationError, provideThemeLeptonX, translateKeys, withThemeLeptonXOptions };
export type { ThemeLeptonXFeature, ThemeLeptonXModuleOptions };