import * as primeng_usestyle from 'primeng/usestyle';
import { UseStyle } from 'primeng/usestyle';
import * as i0 from '@angular/core';
import { InjectionToken } from '@angular/core';
import { Theme } from '@onecx/integration-interface';
import * as _onecx_angular_utils_theme_primeng from '@onecx/angular-utils/theme/primeng';

declare const CustomPreset: Record<string, any>;

declare class CustomUseStyle extends UseStyle {
    private readonly logger;
    private readonly appStateService;
    private readonly skipStyleScoping;
    private readonly remoteComponentConfig;
    private readonly themeOverrides;
    constructor();
    use(css: any, options?: any): {
        id: any;
        name: any;
        el: any;
        css: any;
    };
    private applyOverrides;
    private createOrRetrieveOverrideElement;
    private createFakeUseResponse;
    private isVariables;
    private isStyle;
    static ɵfac: i0.ɵɵFactoryDeclaration<CustomUseStyle, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CustomUseStyle>;
}

declare const IS_ADVANCED_THEMING: InjectionToken<boolean>;
declare function provideThemeConfigService(isAdvanced?: boolean): (typeof ThemeConfigService | {
    provide: InjectionToken<readonly (() => void)[]>;
    multi: boolean;
    useFactory(): () => ThemeConfigService;
    useClass?: undefined;
    useValue?: undefined;
} | {
    provide: typeof UseStyle;
    useClass: typeof CustomUseStyle;
    multi?: undefined;
    useFactory?: undefined;
    useValue?: undefined;
} | {
    provide: InjectionToken<boolean>;
    useValue: boolean;
    multi?: undefined;
    useFactory?: undefined;
    useClass?: undefined;
})[];
declare class ThemeConfigService {
    private themeService;
    private primeNG;
    private readonly isAdvancedTheming;
    constructor();
    private foldOverrides;
    private parsePrimeNGOverridesValue;
    applyThemeVariables(oldTheme: Theme): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThemeConfigService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ThemeConfigService>;
}

type ThemeOverrides = (() => Promise<any> | any) | Promise<any> | any;
declare const THEME_OVERRIDES: InjectionToken<any>;
interface ThemeConfigProviderOptions {
    overrides?: ThemeOverrides;
    isAdvancedTheming?: boolean;
}
declare function provideThemeConfig(options?: ThemeConfigProviderOptions): ((typeof _onecx_angular_utils_theme_primeng.ThemeConfigService | {
    provide: InjectionToken<readonly (() => void)[]>;
    multi: boolean;
    useFactory(): () => _onecx_angular_utils_theme_primeng.ThemeConfigService;
    useClass?: undefined;
    useValue?: undefined;
} | {
    provide: typeof primeng_usestyle.UseStyle;
    useClass: typeof _onecx_angular_utils_theme_primeng.CustomUseStyle;
    multi?: undefined;
    useFactory?: undefined;
    useValue?: undefined;
} | {
    provide: InjectionToken<boolean>;
    useValue: boolean;
    multi?: undefined;
    useFactory?: undefined;
    useClass?: undefined;
})[] | i0.EnvironmentProviders | i0.EnvironmentProviders[] | {
    provide: InjectionToken<any>;
    useValue: any;
})[];

interface ColorAdjustment {
    [key: number]: number;
}
declare const standardColorAdjustment: ColorAdjustment;
/**
 * Adjusts the color by lightening or darkening it based on the provided offset.
 *
 * @param {string} color - A string representing the color in hexadecimal format (e.g., "#RRGGBB").
 * @param {number} channelOffset - A number indicating how much to lighten or darken the color.
 *                                 Positive values lighten the color, while negative values darken it.
 *                                 Valid values range from -255 to 255.
 * @returns {string} - The adjusted color in hexadecimal format.
 */
declare function adjustColor(color: string, channelOffSet: number): string;
declare function createPalette(primaryColor: string, adjustments: ColorAdjustment): {
    [key: number]: string;
};
/**
 * Calculates the Euclidean distance between two colors in RGB space.
 *
 * @param {string} color1 - A string representing the first color in hexadecimal format (e.g., "#RRGGBB").
 * @param {string} color2 - A string representing the second color in hexadecimal format (e.g., "#RRGGBB").
 * @returns {number} - The Euclidean distance between the two colors.
 */
declare function colorDelta(color1: string, color2: string): number;

/**
 * Recursively normalizes the keys of an object by converting camelCase keys into nested objects.
 * Keys matching an excluded pattern are preserved as-is.
 * Non-object values are returned unchanged.
 *
 * @param obj - The input object to normalize.
 * @returns A new object with normalized (nested) keys.
 */
declare function normalizeKeys(obj: any): Record<string, any>;

export { CustomPreset, CustomUseStyle, IS_ADVANCED_THEMING, THEME_OVERRIDES, ThemeConfigService, adjustColor, colorDelta, createPalette, normalizeKeys, provideThemeConfig, provideThemeConfigService, standardColorAdjustment };
export type { ColorAdjustment, ThemeConfigProviderOptions, ThemeOverrides };