import * as dfx_theme from 'dfx-theme';
import * as i0 from '@angular/core';
import { OnDestroy, Provider, EnvironmentProviders } from '@angular/core';

type ResolvedTheme = 'light' | 'dark';
type Theme = ResolvedTheme | 'system';
interface ThemeConfig {
    defaultTheme: Theme;
    enableAutoInit: boolean;
    enableSystem: boolean;
    forcedTheme?: Theme;
}
type ThemeStrategy = (element: HTMLElement, theme: ResolvedTheme) => void;
interface ThemeStorageManager {
    storage?: Storage;
    setup(): void;
    loadTheme(storageKey: string): Theme | undefined;
    saveTheme(storageKey: string, theme: Theme): void;
}

declare class ThemeService implements OnDestroy {
    private readonly platformId;
    private readonly injector;
    private readonly config;
    private readonly themeStrategies;
    private readonly storageKey;
    private readonly storageManager;
    private readonly mediaManager;
    private readonly systemThemeChangeListener;
    private isInitialized;
    private isDestroyed;
    private lastAppliedTheme;
    private readonly themeSignal;
    private readonly systemThemeSignal;
    readonly theme: i0.Signal<Theme>;
    readonly systemTheme: i0.Signal<"light" | "dark">;
    readonly resolvedTheme: i0.Signal<dfx_theme.ResolvedTheme>;
    get initialized(): boolean;
    get isForced(): boolean;
    initialize(): void;
    setTheme(theme: Theme): void;
    toggle(): void;
    isDark(): boolean;
    isLight(): boolean;
    isSystem(): boolean;
    ngOnDestroy(): void;
    cleanup(): void;
    private setupManagers;
    private loadInitialTheme;
    private setFallbackThemes;
    private handleSystemThemeChange;
    private setupEffects;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThemeService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ThemeService>;
}

declare enum ThemeFeatureKind {
    CONFIG = 0,
    STORAGE = 1,
    STRATEGIES = 2
}
declare interface ThemeFeature<KindT extends ThemeFeatureKind> {
    kind: KindT;
    providers: Provider[];
}
declare type ThemeConfigFeature = ThemeFeature<ThemeFeatureKind.CONFIG>;
declare type ThemeStorageFeature = ThemeFeature<ThemeFeatureKind.STORAGE>;
declare type ThemeStrategiesFeature = ThemeFeature<ThemeFeatureKind.STRATEGIES>;
declare type ThemeFeatures = ThemeConfigFeature | ThemeStorageFeature | ThemeStrategiesFeature;

declare function provideTheme(...features: ThemeFeatures[]): EnvironmentProviders;
declare function withThemeConfig(userConfig: {
    defaultTheme?: Theme;
    enableAutoInit?: boolean;
    enableSystem?: boolean;
    forcedTheme?: Theme;
}): ThemeConfigFeature;
declare function withThemeStorage(userConfig?: {
    key?: string;
    manager?: ThemeStorageManager;
}): ThemeStorageFeature;
declare function withThemeStrategies(themeStrategies: ThemeStrategy[]): ThemeStrategiesFeature;

declare class ThemeLocalStorageManager implements ThemeStorageManager {
    storage?: Storage;
    setup(): void;
    loadTheme(storageKey: string): Theme | undefined;
    saveTheme(storageKey: string, theme: Theme): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThemeLocalStorageManager, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ThemeLocalStorageManager>;
}

declare const themeClassStrategy: ThemeStrategy;
declare const themeAttributeStrategy: ThemeStrategy;
declare const themeColorSchemeStrategy: ThemeStrategy;

export { ThemeLocalStorageManager, ThemeService, provideTheme, themeAttributeStrategy, themeClassStrategy, themeColorSchemeStrategy, withThemeConfig, withThemeStorage, withThemeStrategies };
export type { ResolvedTheme, Theme, ThemeConfig, ThemeStorageManager, ThemeStrategy };