import { SourceLocation, SourcePosition } from "@opticss/element-analysis";
import { SerializedTemplateInfo, TemplateAnalysis as OptimizationTemplateAnalysis, TemplateTypes } from "@opticss/template-api";
import { ObjectDictionary } from "@opticss/util";
import { IdentGenerator } from "opticss";
import { BlockFactory } from "../BlockParser";
import { Block, Style } from "../BlockTree";
import { ResolvedConfiguration } from "../configuration";
import { Analyzer } from "./Analyzer";
import { ElementAnalysis, SerializedElementAnalysis, SerializedElementSourceAnalysis } from "./ElementAnalysis";
import { TemplateValidatorOptions } from "./validations";
/**
 * This interface defines a JSON friendly serialization
 * of an {Analysis}.
 */
export interface SerializedAnalysis<K extends keyof TemplateTypes> {
    template: SerializedTemplateInfo<K>;
    blocks: ObjectDictionary<string>;
    stylesFound: string[];
    elements: ObjectDictionary<SerializedElementAnalysis>;
}
/**
 * This interface defines a JSON friendly serialization
 * of an {Analysis}.
 */
export interface SerializedSourceAnalysis<K extends keyof TemplateTypes> {
    template: SerializedTemplateInfo<K>;
    blocks: ObjectDictionary<string>;
    stylesFound: string[];
    elements: ObjectDictionary<SerializedElementSourceAnalysis>;
}
declare type ElementAnalyzedCallback<BooleanExpression, StringExpression, TernaryExpression> = (element: ElementAnalysis<BooleanExpression, StringExpression, TernaryExpression>) => void;
/**
 * An Analysis performs book keeping and ensures internal consistency of the block objects referenced
 * within a single template. It is designed to be used as part of an AST walk over a template.
 *
 * 1. Call [[startElement startElement()]] at the beginning of an new html element.
 * 2. Call [[addStyle addStyle(style, isDynamic)]] for all the styles used on the current html element.
 * 2. Call [[addExclusiveStyle addExclusiveStyle(alwaysPresent, ...style)]] for all the styles used that are mutually exclusive on the current html element.
 * 3. Call [[endElement endElement()]] when done adding styles for the current element.
 */
export declare class Analysis<K extends keyof TemplateTypes> {
    idGenerator: IdentGenerator;
    template: TemplateTypes[K];
    /**
     * A per-element correlation of styles used. The current correlation is added
     * to this list when [[endElement]] is called.
     */
    elements: Map<string, ElementAnalysis<any, any, any>>;
    /**
     * A map from a local name for the block to the [[Block]].
     * The local name must be a legal CSS ident/class name but this is not validated here.
     * See [[CLASS_NAME_IDENT]] for help validating a legal class name.
     */
    private blocks;
    /**
     * The current element, created when calling [[startElement]].
     * The current element is unset after calling [[endElement]].
     */
    private currentElement;
    /**
     * Template validator instance to verify blocks applied to an element.
     */
    private validator;
    /**
     * Callback when an element is done being analyzed.
     * The element analysis will be sealed.
     */
    onElementAnalyzed?: ElementAnalyzedCallback<any, any, any>;
    /**
     * @param template The template being analyzed.
     */
    constructor(template: TemplateTypes[K], options?: TemplateValidatorOptions, onElementAnalyzed?: ElementAnalyzedCallback<any, any, any>);
    /**
     * Return the number of blocks discovered in this Template.
    */
    blockCount(): number;
    /**
     * Convenience setter for adding a block to the template scope.
     */
    addBlock(name: string, block: Block): Block;
    /**
     * Convenience getter for fetching a block from the template scope.
     */
    getBlock(name: string): Block | undefined;
    /**
     * Return the number of elements discovered in this Analysis.
     */
    elementCount(): number;
    /**
     * Get the nth element discovered in this Analysis.
     */
    getElement<BooleanExpression, StringExpression, TernaryExpression>(idx: number): ElementAnalysis<BooleanExpression, StringExpression, TernaryExpression>;
    /**
     * Return the number of styles discovered in this Analysis' Template.
     * TODO: This is slow. We can pre-compute this as elements are added.
     */
    styleCount(): number;
    /**
     * Get an Element by ID.
     */
    getElementById<BooleanExpression, StringExpression, TernaryExpression>(id: string): ElementAnalysis<BooleanExpression, StringExpression, TernaryExpression> | undefined;
    /**
     * Returns the local name of the provided in this Analysis' template.
     * @param block The block for which the local name should be returned.
     * @return The local name of the given block.
     */
    getBlockName(block: Block): string | null;
    _searchForBlock(blockToFind: Block, block: Block, parentPath: string): string | null;
    /**
     * Get a new {ElementAnalysis} object to track an individual element's {Style}
     * consumption in this {Analysis}' template. Every {ElementAnalysis} returned from
     * `Analysis.startElement` must be passed to `Analysis.endElement` before startElement
     * is called again.
     * @param location  The {SourceLocation} of this element in the template.
     * @param tagName  Optional. The tag name of the element being represented by this {ElementAnalysis}.
     * @returns A new {ElementAnalysis}.
     */
    startElement<BooleanExpression, StringExpression, TernaryExpression>(location: SourceLocation | SourcePosition, tagName?: string): ElementAnalysis<BooleanExpression, StringExpression, TernaryExpression>;
    /**
     * Finish an {ElementAnalysis} object returned from `Analysis.startElement` to
     * the end location in source and save {Style} usage on the parent {Analysis}.
     * @param element  The {ElementAnalysis} we are finishing.
     * @param endPosition  Optional. The location in code where this element tag is closed..
     */
    endElement<BooleanExpression, StringExpression, TernaryExpression>(element: ElementAnalysis<BooleanExpression, StringExpression, TernaryExpression>, endPosition?: SourcePosition): void;
    /**
     * Given a {SourcePosition}, ensure that the file name is present. If not,
     * add the template identifier.
     * @param post  The {SourcePosition} we are validating.
     */
    private ensureFilename;
    /**
     * @return The local name for the block object using the local prefix for the block.
     */
    serializedName(o: Style): string;
    /**
     * All the blocks referenced by this analysis.
     */
    referencedBlocks(): Block[];
    /**
     * For now, returns all aliases referenced by this block and all the blocks they
     * reference recursively. We can add more to this set in future
     */
    reservedClassNames(): Set<string>;
    /**
     * All the blocks referenced by this block and all the blocks they reference recursively.
     */
    transitiveBlockDependencies(): Set<Block>;
    /**
     * All bhe blocks this block depends on. Same as referenced blocks except for the return type.
     */
    blockDependencies(): Set<Block>;
    stylesFound(dynamic?: boolean): IterableIterator<Style>;
    serializeSource(blockPaths?: Map<Block, string>): SerializedSourceAnalysis<K>;
    /**
     * Generates a [[SerializedTemplateAnalysis]] for this analysis.
     */
    serialize(blockPaths?: Map<Block, string>): SerializedAnalysis<K>;
    _serializeSetup(blockPaths?: Map<Block, string>): {
        template: SerializedTemplateInfo<K>;
        blocks: {};
        stylesFound: string[];
        styleIndexes: Map<Style, number>;
    };
    /**
     * Creates a TemplateAnalysis from its serialized form.
     * @param serializedAnalysis The analysis to be recreated.
     * @param blockFactory for loading blocks referenced in the serialization.
     * @param parent The analyzer this analysis will belong to.
     */
    static deserializeSource(serializedAnalysis: SerializedSourceAnalysis<keyof TemplateTypes>, blockFactory: BlockFactory, parent: Analyzer<keyof TemplateTypes>): Promise<Analysis<keyof TemplateTypes>>;
    /**
     * Creates a TemplateAnalysis from its serialized form.
     *
     * **DO NOT USE THIS METHOD, ITS NOT FULLY IMPLEMENTED.**
     * @param serializedAnalysis The analysis to be recreated.
     * @param blockFactory for loading blocks referenced in the serialization.
     * @param parent The analyzer this analysis will belong to.
     */
    static deserialize(serializedAnalysis: SerializedAnalysis<keyof TemplateTypes>, blockFactory: BlockFactory, parent: Analyzer<keyof TemplateTypes>): Promise<Analysis<keyof TemplateTypes>>;
    forOptimizer(config: ResolvedConfiguration): OptimizationTemplateAnalysis<K>;
}
export interface IAnalysis<K extends keyof TemplateTypes> extends Analysis<K> {
}
export {};
//# sourceMappingURL=Analysis.d.ts.map