import * as vue from 'vue';
import { PropType, ComputedRef, App } from 'vue';
import { ColorVariant, ThemeName, ScopeName, PaletteName, ColorSchemeInfo } from '@fastkit/color-scheme';
export { ColorVariant, PaletteName, ScopeName, ThemeName } from '@fastkit/color-scheme';

type PropKey = string | null | false | undefined;
type ColorSchemeProps<ThemeProp extends PropKey = 'theme', ScopeProp extends PropKey = 'color', TextColorProp extends PropKey = 'textColor', BorderColorProp extends PropKey = 'borderColor'> = {
    variant: PropType<ColorVariant>;
} & (ThemeProp extends string ? {
    [K in ThemeProp]: PropType<ThemeName>;
} : never) & (ScopeProp extends string ? {
    [K in ScopeProp]: PropType<ScopeName>;
} : {}) & (TextColorProp extends string ? {
    [K in TextColorProp]: PropType<PaletteName>;
} : never) & (BorderColorProp extends string ? {
    [K in BorderColorProp]: PropType<PaletteName>;
} : never);
interface ColorSchemePropsOptions<ThemeProp extends PropKey = 'theme', ScopeProp extends PropKey = 'color', TextColorProp extends PropKey = 'textColor', BorderColorProp extends PropKey = 'borderColor'> {
    theme?: ThemeProp;
    color?: ScopeProp;
    textColor?: TextColorProp;
    borderColor?: BorderColorProp;
}
interface ColorSchemeHooksProps {
    readonly theme?: ThemeName | (() => ThemeName | undefined);
    readonly color?: ScopeName | (() => ScopeName | undefined);
    readonly textColor?: PaletteName | (() => PaletteName | undefined);
    readonly borderColor?: PaletteName | (() => PaletteName | undefined);
    readonly variant?: ColorVariant | (() => ColorVariant | undefined);
}
interface ColorClassesResult {
    theme: ComputedRef<{
        value?: ThemeName;
        classes?: string;
    }>;
    color: ComputedRef<{
        value?: ScopeName;
        classes?: string;
    }>;
    textColor: ComputedRef<{
        value?: PaletteName;
        classes?: string;
    }>;
    borderColor: ComputedRef<{
        value?: PaletteName;
        classes?: string;
    }>;
    variant: ComputedRef<{
        value?: ColorVariant;
        classes?: string;
    }>;
    colorClasses: ComputedRef<string[]>;
}
type VueColorSchemeServiceSettings = ColorSchemeInfo<ThemeName, PaletteName, ScopeName, ColorVariant>;

declare function useColorVariantClasses(props: ColorSchemeHooksProps): vue.ComputedRef<{
    value: ColorVariant | undefined;
    className: ColorVariant | undefined;
}>;
declare function useThemeClass(props: ColorSchemeHooksProps, useRootThemeDefault?: boolean): vue.ComputedRef<{
    value: ThemeName | undefined;
    className: string | undefined;
}>;
declare function toScopeColorClass(name: string): string;
declare function useScopeColorClass(props: ColorSchemeHooksProps): vue.ComputedRef<{
    value: ScopeName | undefined;
    className: string | undefined;
}>;
declare function toTextColorClass(name: string): string;
declare function useTextColorClass(props: ColorSchemeHooksProps): vue.ComputedRef<{
    value: PaletteName | undefined;
    className: string | undefined;
}>;
declare function useBorderColorClass(props: ColorSchemeHooksProps): vue.ComputedRef<{
    value: PaletteName | undefined;
    className: string | undefined;
}>;
declare function useColorClasses(props: ColorSchemeHooksProps, opts?: {
    useRootThemeDefault?: boolean;
}): ColorClassesResult;
declare function useColorScheme(): VueColorSchemeService;
declare function useInjectTheme(): VueColorSchemeService;
declare function colorSchemeProps<ThemeProp extends PropKey = 'theme', ScopeProp extends PropKey = 'color', TextColorProp extends PropKey = 'textColor', BorderColorProp extends PropKey = 'borderColor', Props = ColorSchemeProps<ThemeProp, ScopeProp, TextColorProp, BorderColorProp>>(opts?: ColorSchemePropsOptions<ThemeProp, ScopeProp, TextColorProp, BorderColorProp>): Props;
declare class VueColorSchemeService {
    readonly _scheme: VueColorSchemeServiceSettings;
    private _rootTheme;
    get scheme(): VueColorSchemeServiceSettings;
    get defaultTheme(): ThemeName;
    get themeNames(): ThemeName[];
    get paletteNames(): PaletteName[];
    get scopeNames(): ScopeName[];
    get rootTheme(): ThemeName;
    set rootTheme(rootTheme: ThemeName);
    constructor(scheme: VueColorSchemeServiceSettings);
    provide(app: App): void;
}

interface VueColorSchemePluginSettings extends Omit<VueColorSchemeServiceSettings, 'defaultTheme'> {
    defaultTheme?: ThemeName;
}
declare class VueColorSchemePlugin {
    readonly settings: VueColorSchemeServiceSettings;
    constructor(settings: VueColorSchemePluginSettings);
    install(app: App): void;
}

export { type ColorClassesResult, type ColorSchemeHooksProps, type ColorSchemeProps, type ColorSchemePropsOptions, type PropKey, VueColorSchemePlugin, type VueColorSchemePluginSettings, VueColorSchemeService, type VueColorSchemeServiceSettings, colorSchemeProps, toScopeColorClass, toTextColorClass, useBorderColorClass, useColorClasses, useColorScheme, useColorVariantClasses, useInjectTheme, useScopeColorClass, useTextColorClass, useThemeClass };