import { CompilationResult, MacroMatch, RegExpMatch, CustomSelector } from '.';
export interface CompilerContentOptionsInterface {
    pregenerate: PregenerateType;
    components: ComponentsType;
    variables: VariablesType;
    keyframes: KeyframesType;
    customSelectors: CustomSelectorType;
    screens: ScreensType;
}
export interface CompilerHooksListInterface {
    'compiler:beforeMacrosProcessed': CompilationResult;
    'compiler:afterMacrosProcessed': CompilationResult;
    'compiler:compilationResultConfigured': CompilationResult;
    'compiler:newMacroMatch': {
        match: MacroMatch;
        utilityShouldBeGenerated: boolean;
        selectorProperties: MacroCallbackReturnType;
        dev: boolean;
        variables: VariablesType;
        helpers: HelpersType;
    };
    [key: `compiler:processContentOption:${string}`]: {
        contentOptions: Record<string, any>;
        key: string;
        value: string;
    };
}
export type MacroCallbackReturnType = Record<string, string>;
export type MacroCallbackType = (this: Compiler, match: MacroMatch) => MacroCallbackReturnType;
export type ScreenCallbackType = (this: Compiler, screen: RegExpMatch) => string;
export interface CustomSelectorInterface {
    selectors: string[];
}
export type HelperCallbackType = (this: Compiler, ...args: any[]) => any;
export type ComponentsType = Record<string, ComponentsInterface>;
export type MacrosType = Record<string, MacroCallbackType>;
export type HelpersType = Record<string, HelperCallbackType>;
export type ScreensType = Record<string, string | ScreenCallbackType>;
type VariablesTypeValue = string;
export type VariablesType = Record<string, VariablesTypeValue | Record<string, string>>;
export type ExternalVariableCallbackType = (this: Compiler, variable: string) => boolean | void;
export type ExternalVariablesType = (string | RegExp | ExternalVariableCallbackType)[];
export interface IsVariableDefinedInterface {
    defined: boolean;
    isExternal: boolean;
}
export type KeyframesType = Record<string, string>;
export type CustomSelectorType = Record<string, string>;
export type PregenerateType = string[] | string;
export type ComponentType = Record<string, string | ComponentGeneratorFunctionType>;
export interface CompilerConfigInterface {
    dev?: boolean;
    macros?: MacrosType;
    helpers?: HelpersType;
    variables?: VariablesType;
    undefinedVariableWarningLevel?: UndefinedVariableWarningLevelType;
    externalVariables?: ExternalVariablesType;
    keyframes?: KeyframesType;
    screens?: ScreensType;
    customSelectors?: CustomSelectorType;
    mangleSelectors?: boolean;
    mangledSelectorsPrefix?: string;
    selectorsPrefix?: string;
    pregenerate?: PregenerateType;
    components?: ComponentType;
    ignoredAreas?: RegExp[];
    selectorsAreas?: RegExp[];
    cssVariablesEnabled?: boolean;
    injectVariablesIntoCss?: boolean;
    matchCustomSelectors?: boolean;
}
export type CustomSelectorTypeType = 'custom' | 'customMatchedInClass' | 'component' | 'utilitiesGroup';
export interface CustomSelectorsInterface {
    customSelectors: CustomSelector[];
    type: CustomSelectorTypeType;
}
export type ComponentGeneratorFunctionType = (this: Compiler, match: RegExpMatch) => string;
export interface ComponentsInterface {
    selectorsOrGenerators: (string | ComponentGeneratorFunctionType)[];
}
export type UndefinedVariableWarningLevelType = 'silent' | 'warning' | 'error';
export declare class Compiler {
    private readonly macroRegExpStartPart;
    private readonly macroRegExpEndPart;
    private readonly variableRegExp;
    private readonly contentOptionsRegExp;
    private readonly macrosRegExpGenerators;
    private undefinedVariableWarningLevel;
    private rewrittenAreasCache;
    ignoredAreas: RegExp[];
    mangleSelectors: boolean;
    mangledSelectorsPrefix: string;
    selectorsPrefix: string;
    dev: boolean;
    macros: MacrosType;
    helpers: HelpersType;
    screens: ScreensType;
    variables: VariablesType;
    externalVariables: ExternalVariablesType;
    keyframes: KeyframesType;
    components: ComponentsType;
    pregenerate: string;
    selectorsAreas: RegExp[];
    customSelectors: Record<string, CustomSelectorsInterface>;
    private matchCustomSelectors;
    private processedHelpers;
    cssVariablesEnabled: boolean;
    injectVariablesIntoCss: boolean;
    /** @internal */
    ignoredAreasRegExpString: string;
    constructor(config?: CompilerConfigInterface);
    configure(config: CompilerConfigInterface): void;
    addVariables(variables: VariablesType, screen?: string): void;
    addCustomSelector(selector: string, selectors: string, selectorCanBeSplit?: boolean, type?: CustomSelectorTypeType): void;
    addComponent(selector: string, selectorsOrGenerator: string | ComponentGeneratorFunctionType): Compiler;
    addMacro(re: string, callback: MacroCallbackType): void;
    rewriteSelectors(options: {
        content: string;
        rewriteOnlyInSelectorsAreas?: boolean;
        matchSelectorsWithPrefixes?: boolean;
    } | string): string;
    compile(content: string, compilationResult?: CompilationResult, matchOnlyInAreas?: boolean): CompilationResult;
    getOptionsFromContent<ContentOptions extends CompilerContentOptionsInterface, Keys extends keyof ContentOptions = keyof ContentOptions, Data = Record<Keys, string[]>>(content: string): Data;
    private generateMangledSelector;
    private configureCompilationResult;
    private processCustomSelectors;
    private processComponents;
    private processMacros;
    private processHelpers;
    private replaceVariableString;
    private isVariableDefined;
    private processOptionsFromContent;
}
export {};