import * as _volo_ngx_lepton_x_core from '@volo/ngx-lepton-x.core';
import { LpxStyle, HasStyleFactory, DataStore, LpxNavbarItem, LpxCoreOptions, LpxStyleFactory, styleLoadFactory } from '@volo/ngx-lepton-x.core';
import * as rxjs from 'rxjs';
import * as i0 from '@angular/core';
import { InjectionToken, ModuleWithProviders, ChangeDetectorRef, Type, Injector, TemplateRef, Provider, EnvironmentProviders } from '@angular/core';
import * as i1 from '@angular/common';
import { SafeHtml, DomSanitizer } from '@angular/platform-browser';

interface LpxHttpError {
    errorPath?: string;
}

interface LpxThemeOptions {
    localStorageKey: string;
    disableSystemOption?: boolean;
}
type SystemKey = 'dark' | 'light';
interface LpxThemeStyleConfig {
    bundles: LpxStyle[];
    styleName: string;
    defaultTheme?: boolean;
    label: string;
    icon: string;
    order?: number;
    systemKey?: SystemKey;
}
declare class LpxTheme implements LpxThemeStyleConfig {
    bundles: LpxStyle[];
    styleName: string;
    defaultTheme?: boolean;
    label: string;
    icon: string;
    order?: number;
    systemKey?: SystemKey;
    constructor(args: LpxThemeStyleConfig);
    updateBundle(bundle: LpxStyle): void;
    addBundle(bundle: LpxStyle): void;
    deleteBundle(bundle: LpxStyle): void;
}
type LpxThemes = Array<LpxTheme>;
interface LpxThemeModuleOptions extends LpxThemeOptions, HasStyleFactory<LpxThemes> {
}

declare const dimTheme: LpxTheme;
declare const darkTheme: LpxTheme;
declare const lightTheme: LpxTheme;
declare const LPX_THEME_DEFAULTS: LpxThemeOptions;
declare const LPX_THEME_STYLES_DEFAULTS: LpxThemes;
declare const ThemeLinkElemId = "lpxTheme";

declare enum StyleNames {
    Dark = "dark",
    Dim = "dim",
    Light = "light",
    System = "system"
}
declare enum BundleNames {
    BootstrapDark = "bootstrap-dark",
    BootstrapDim = "bootstrap-dim",
    BootstrapLight = "bootstrap-light",
    Dark = "dark",
    Dim = "dim",
    Light = "light",
    Ng = "ng-bundle"
}

declare enum ThemeTranslateKeys {
    AppearanceTitle = "theme.settings.title",
    DarkMode = "theme.settings.darkMode",
    LightMode = "theme.settings.lightMode",
    SemiDarkMode = "theme.settings.semiDarkMode",
    System = "theme.settings.system"
}
type ThemeTranslateValues = {
    [key in ThemeTranslateKeys]: string;
};
declare const ThemeTranslateDefaults: ThemeTranslateValues;

declare class ThemeService {
    themeSettings: LpxThemeOptions;
    styles: LpxThemes;
    private injector;
    protected window: Window;
    private languageService;
    private styleService;
    private localStorageService;
    private cookieStorageService;
    private lpxAppStartedWithSsr;
    private platformId;
    readonly store: DataStore<{
        styles: LpxTheme[];
        selectedStyle: LpxTheme;
    }>;
    id: string;
    convertThemeToNavbarItem: (styles: LpxTheme[]) => LpxNavbarItem[];
    get selectedStyle(): LpxThemeStyleConfig;
    selectedStyle$: rxjs.Observable<LpxTheme>;
    styles$: rxjs.Observable<LpxTheme[]>;
    stylesAsNavbarItems$: rxjs.Observable<LpxNavbarItem[]>;
    stylesAsSettingsGroup$: rxjs.Observable<{
        text: ThemeTranslateKeys;
        icon: string;
        id: string;
        children: LpxNavbarItem[];
    }>;
    systemMediaQueryList: MediaQueryList;
    systemThemeChange$: rxjs.Observable<boolean>;
    get currentSystemTheme(): "dark" | "light";
    constructor();
    getInitialTheme(): LpxTheme | undefined;
    createSystemOption(): void;
    initTheme(): Promise<void>;
    setTheme(style?: LpxTheme): Promise<boolean>;
    private getBundlesAndStyle;
    private activateStyle;
    private findLpxStyleByName;
    private setThemeClassToBody;
    private removeOldThemeStyles;
    private subscribeDirectionChange;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThemeService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ThemeService>;
}

declare const LPX_THEME_OPTIONS: InjectionToken<LpxThemeOptions>;
declare const LPX_THEMES: InjectionToken<LpxThemeStyleConfig[]>;
declare const LPX_THEMES_FINAL: InjectionToken<LpxThemeStyleConfig[]>;

declare function initTheme(): void;
declare class LpxThemeModule {
    /**
     * @deprecated `LpxThemeModule.forRoot()` is deprecated. You can use `provideLpxTheme` **function** instead.
     */
    static forRoot(options?: LpxThemeModuleOptions, defaultTheme?: string): ModuleWithProviders<LpxThemeModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<LpxThemeModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<LpxThemeModule, never, [typeof i1.CommonModule], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<LpxThemeModule>;
}

interface LpxOptions extends LpxCoreOptions, HasStyleFactory {
    themeOptions?: LpxThemeModuleOptions;
    defaultTheme?: string;
    httpError?: LpxHttpError;
}

declare class CardFooterComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<CardFooterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CardFooterComponent, "lpx-card-footer", never, {}, {}, never, ["*"], true, never>;
}

declare class CardHeaderComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<CardHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CardHeaderComponent, "lpx-card-header", never, {}, {}, never, ["*"], true, never>;
}

declare class CardComponent {
    cardFooterTemplate?: CardFooterComponent;
    cardHeaderTemplate?: CardHeaderComponent;
    static ɵfac: i0.ɵɵFactoryDeclaration<CardComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CardComponent, "lpx-card", never, {}, {}, ["cardFooterTemplate", "cardHeaderTemplate"], ["lpx-card-header", "*", "lpx-card-footer"], true, never>;
}

declare class CardModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CardModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CardModule, never, [typeof i1.CommonModule, typeof CardComponent, typeof CardFooterComponent, typeof CardHeaderComponent], [typeof CardComponent, typeof CardFooterComponent, typeof CardHeaderComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CardModule>;
}

declare class ContextMenuHeaderComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<ContextMenuHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ContextMenuHeaderComponent, "lpx-context-menu-header", never, {}, {}, never, ["*"], true, never>;
}

declare class ContextMenuComponent {
    protected readonly cdRef: ChangeDetectorRef;
    header?: ContextMenuHeaderComponent;
    private _visible;
    get visible(): boolean;
    set visible(value: boolean);
    open(): void;
    close(): void;
    toggle(status?: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ContextMenuComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ContextMenuComponent, "lpx-context-menu", ["lpx-context-menu"], {}, {}, ["header"], ["lpx-context-menu-header", "*"], true, never>;
}

declare class ContextMenuActionGroupComponent {
    hostClass: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<ContextMenuActionGroupComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ContextMenuActionGroupComponent, "lpx-context-menu-action-group", never, {}, {}, never, ["*"], true, never>;
}

declare class ContextMenuToggleDirective {
    lpxCtx: ContextMenuComponent;
    clickOnItem(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ContextMenuToggleDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ContextMenuToggleDirective, "[lpxCtxToggle]", never, { "lpxCtx": { "alias": "lpxCtxToggle"; "required": false; }; }, {}, never, never, true, never>;
}

declare class LpxContextMenuModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<LpxContextMenuModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<LpxContextMenuModule, never, [typeof i1.CommonModule, typeof _volo_ngx_lepton_x_core.LpxBrandLogoModule, typeof ContextMenuComponent, typeof ContextMenuHeaderComponent, typeof ContextMenuActionGroupComponent, typeof ContextMenuToggleDirective], [typeof ContextMenuComponent, typeof ContextMenuHeaderComponent, typeof ContextMenuActionGroupComponent, typeof ContextMenuToggleDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<LpxContextMenuModule>;
}

interface TopBarItem {
    action?: () => void;
    component?: Type<any>;
    injector?: Injector;
    html?: string | SafeHtml;
    id: string | number;
    order?: number;
    template?: TemplateRef<any>;
    visible?: () => boolean;
}
interface TopbarData {
    items: Array<TopBarItem>;
}
declare class TopbarContentService {
    protected store: DataStore<TopbarData>;
    items$: rxjs.Observable<TopBarItem[]>;
    setItems(items: Array<TopBarItem>): void;
    addItem(item: TopBarItem): void;
    patchItem(itemId: string | number, item: Omit<TopBarItem, 'id'>): void;
    removeItem(id: string | number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TopbarContentService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TopbarContentService>;
}

declare class TopbarContentComponent {
    topbarContent: TopbarContentService;
    sanitizer: DomSanitizer;
    injector: Injector;
    items$: rxjs.Observable<TopBarItem[]>;
    actionClick(item: TopBarItem): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TopbarContentComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TopbarContentComponent, "lpx-topbar-content", never, {}, {}, never, never, true, never>;
}

declare class LpxTopbarContentModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<LpxTopbarContentModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<LpxTopbarContentModule, never, [typeof i1.CommonModule, typeof TopbarContentComponent], [typeof TopbarContentComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<LpxTopbarContentModule>;
}

declare class LpxModule {
    /**
     * @deprecated `LpxModule.forRoot()` is deprecated. You can use `provideLpx` **function** instead.
     */
    static forRoot(options?: LpxOptions): ModuleWithProviders<LpxModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<LpxModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<LpxModule, never, [typeof _volo_ngx_lepton_x_core.LpxCoreModule, typeof LpxThemeModule], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<LpxModule>;
}

declare const getLpxProStyleProviders: (styleFactory?: LpxStyleFactory) => (i0.EnvironmentProviders | {
    provide: i0.InjectionToken<_volo_ngx_lepton_x_core.LpxStyles>;
    deps: i0.InjectionToken<_volo_ngx_lepton_x_core.LpxStyles>[];
    useFactory: typeof styleLoadFactory;
})[];

declare enum LpxFeatureKind {
    Options = 0,
    DefaultTheme = 1
}
interface LpxFeature<KindT extends LpxFeatureKind> {
    ɵkind: KindT;
    ɵproviders: (Provider | EnvironmentProviders)[];
}
declare function withLpxThemeDefaults(defaultTheme?: string): LpxFeature<LpxFeatureKind.DefaultTheme>;
declare function withLpxThemeOptions(options?: LpxThemeModuleOptions): LpxFeature<LpxFeatureKind.Options>;
/**
 * @description Provides the core LPX theme functionality including:
 * - Theme service initialization
 * - Default theme translation tokens
 */
declare function provideLpxTheme(...features: LpxFeature<LpxFeatureKind>[]): EnvironmentProviders;
declare function withLpxOptions(options?: LpxOptions): LpxFeature<LpxFeatureKind.Options>;
/**
 * @description Provides the complete LPX functionality by combining all specified features.
 * Acts as the main entry point for LPX configuration.
 *
 */
declare function provideLpx(...features: LpxFeature<LpxFeatureKind>[]): EnvironmentProviders;

export { BundleNames, CardComponent, CardFooterComponent, CardHeaderComponent, CardModule, ContextMenuActionGroupComponent, ContextMenuComponent, ContextMenuHeaderComponent, ContextMenuToggleDirective, LPX_THEMES, LPX_THEMES_FINAL, LPX_THEME_DEFAULTS, LPX_THEME_OPTIONS, LPX_THEME_STYLES_DEFAULTS, LpxContextMenuModule, LpxFeatureKind, LpxModule, LpxTheme, LpxThemeModule, LpxTopbarContentModule, StyleNames, ThemeLinkElemId, ThemeService, ThemeTranslateDefaults, ThemeTranslateKeys, TopbarContentComponent, TopbarContentService, darkTheme, dimTheme, getLpxProStyleProviders, initTheme, lightTheme, provideLpx, provideLpxTheme, withLpxOptions, withLpxThemeDefaults, withLpxThemeOptions };
export type { LpxFeature, LpxHttpError, LpxOptions, LpxThemeModuleOptions, LpxThemeOptions, LpxThemeStyleConfig, LpxThemes, SystemKey, ThemeTranslateValues, TopBarItem };