import { Element, SourceLocation } from "@opticss/element-analysis";
import { ObjectDictionary } from "@opticss/util";
import { AttrValue, Attribute, Block, BlockClass, Style } from "../BlockTree";
import { ResolvedConfiguration } from "../configuration";
export interface HasAttrValue<T extends Style = Style> {
    value: Set<T>;
}
export declare function hasAttrValue(o: object): o is HasAttrValue | SerializedHasAttrValue;
export interface HasGroup<GroupType extends BlockClass | AttrValue | number = AttrValue> {
    group: ObjectDictionary<GroupType>;
}
export declare function isAttrGroup(o: object): o is HasGroup<AttrValue | number>;
/**
 * A boolean condition.
 */
export interface Conditional<BooleanExpression> {
    condition: BooleanExpression;
}
export declare function isConditional<BooleanExpression>(o: object): o is Conditional<BooleanExpression>;
/**
 * A string expression used to switch between attribute values.
 * When falsy is allowed, it's possible to disable the attribute.
 */
export interface Switch<StringExpression> {
    stringExpression: StringExpression;
    /** whether the attribute can be disabled. */
    disallowFalsy?: boolean;
}
export declare function isSwitch(o: object): o is Switch<unknown>;
/**
 * When the style container is dynamic but the style itself is not.
 */
export interface Dependency<Container extends BlockClass | number = BlockClass> {
    container: Container;
}
export declare function hasDependency(o: object): o is Dependency<BlockClass | number>;
/**
 * the main branch of the style-if helper and the else branch of the
 * style-unless helper
 */
export interface TrueCondition<Container extends BlockClass | number = BlockClass> {
    whenTrue: Array<Container>;
}
export declare function isTrueCondition(o: object): o is TrueCondition<BlockClass | number>;
/**
 * the else branch of the style-if helper and the main branch of the
 * style-unless helper
 */
export interface FalseCondition<Container extends BlockClass | number = BlockClass> {
    whenFalse: Array<Container>;
}
export declare function isFalseCondition(o: object): o is FalseCondition<BlockClass | number>;
export interface StaticClass {
    klass: BlockClass;
}
export declare function isStaticClass(o: object): o is StaticClass | SerializedStaticClass;
/** An attribute value that is conditionally set */
export declare type ConditionalAttr<BooleanExpression> = Conditional<BooleanExpression> & HasAttrValue;
/** An attribute value that is only set when its dynamic class is set */
export declare type DependentAttr = Dependency & HasAttrValue;
/** An attribute value that is only set when its condition is true and its dynamic class is set */
export declare type ConditionalDependentAttr<BooleanExpression> = Conditional<BooleanExpression> & Dependency & HasAttrValue;
/** An attribute value that is dynamic for any reason */
export declare type DynamicAttr<BooleanExpression> = ConditionalAttr<BooleanExpression> | DependentAttr | ConditionalDependentAttr<BooleanExpression>;
/** An attribute group where one is set conditionally */
export declare type ConditionalAttrGroup<StringExpression> = Switch<StringExpression> & HasGroup & HasAttrValue;
/** An attribute group that are only set when its dynamic class is set and where one (or none) is selected at runtime. */
export declare type ConditionalDependentAttrGroup<StringExpression> = Switch<StringExpression> & Dependency & HasGroup & HasAttrValue;
/** An attribute group that are dynamic for any reason */
export declare type DynamicAttrGroup<StringExpression> = ConditionalAttrGroup<StringExpression> | ConditionalDependentAttrGroup<StringExpression>;
/** Any type of dynamic attribute or group of attributes. */
export declare type DynamicAttrs<BooleanExpression, StringExpression> = DynamicAttr<BooleanExpression> | DynamicAttrGroup<StringExpression>;
/** a ternary expression where different classes can be set when true or false */
export declare type DynamicClasses<TernaryExpression> = (Conditional<TernaryExpression> & TrueCondition) | (Conditional<TernaryExpression> & FalseCondition) | (Conditional<TernaryExpression> & TrueCondition & FalseCondition);
export interface SerializedHasAttrValue {
    value: number[];
}
export interface SerializedStaticClass {
    klass: number;
}
export declare type SerializedConditionalAttr = Conditional<true> & SerializedHasAttrValue;
export declare type SerializedDependentAttr = Dependency<number> & SerializedHasAttrValue;
export declare type SerializedConditionalDependentAttr = Conditional<true> & Dependency<number> & SerializedHasAttrValue;
export declare type SerializedDynamicAttr = SerializedConditionalAttr | SerializedDependentAttr | SerializedConditionalDependentAttr;
export declare type SerializedConditionalAttrGroup = Switch<true> & HasGroup<number>;
export declare type SerializedDependentAttrGroup = Dependency<number> & HasGroup<number>;
export declare type SerializedConditionalDependentAttrGroup = Switch<true> & Dependency<number> & HasGroup<number>;
export declare type SerializedDynamicAttrGroup = SerializedConditionalAttrGroup | SerializedDependentAttrGroup | SerializedConditionalDependentAttrGroup;
export declare type SerializedDynamicContainer = Conditional<true> & (TrueCondition<number> | FalseCondition<number> | (TrueCondition<number> & FalseCondition<number>));
export declare type SerializedDynamicAttrs = SerializedDynamicAttr | SerializedDynamicAttrGroup;
export declare type SerializedDynamicClasses = (Conditional<true> & TrueCondition<number>) | (Conditional<true> & FalseCondition<number>) | (Conditional<true> & TrueCondition<number> & FalseCondition<number>);
export interface SerializedElementAnalysis {
    id?: string | undefined;
    tagName?: string | undefined;
    sourceLocation?: SourceLocation;
    staticStyles: Array<number>;
    dynamicClasses: Array<SerializedDynamicContainer>;
    dynamicAttributes: Array<SerializedDynamicAttrs>;
}
/**
 * This serialization is just the styles that were set explicitly
 * by the source code.
 */
export interface SerializedElementSourceAnalysis {
    id?: string | undefined;
    tagName?: string | undefined;
    sourceLocation?: SourceLocation;
    analyzedStyles: Array<SerializedAnalyzedStyle>;
}
declare type AnalyzedStyle<BooleanExpression, StringExpression, TernaryExpression> = DependentAttr | ConditionalDependentAttr<BooleanExpression> | ConditionalDependentAttrGroup<StringExpression> | StaticClass | DynamicClasses<TernaryExpression>;
declare type SerializedAnalyzedStyle = SerializedDependentAttr | SerializedConditionalDependentAttr | SerializedConditionalDependentAttrGroup | SerializedStaticClass | SerializedDynamicClasses;
/**
 * This class is used to track the styles and dynamic expressions on an element
 * and produce a runtime class expression in conjunction with a style mapping.
 *
 * This class tracks dependencies between attributes and classes and the runtime
 * expression causes attributes to be removed if the parent class is not present at
 * runtime.
 *
 * With some syntaxes, if an element has different classes on it at runtime
 * from the same block, the attributes in use become ambiguous. To manage this,
 * the caller must ensure that the attribute names used exist for all possible
 * classes and produce an error if not. Then add the attributes for each
 * possible class with multiple calls to add(Static|Dynamic)(Attribute|Attribute-Group).
 * If the AST can't handle multiple references pointing at the expression node,
 * the caller must clone it -- This won't result in multiple expression
 * invocations unless multiple classes from the same block are applied at the
 * same time -- which would be illegal.
 */
export declare class ElementAnalysis<BooleanExpression, StringExpression, TernaryExpression> {
    static autoGenerateId: symbol;
    /** an opaque id assigned from the analyzer for later retrieval */
    id: string | undefined;
    /** The name of the tag these styles are applied -- if known. */
    tagName: string | undefined;
    /** where the element starts and ends */
    sourceLocation: SourceLocation;
    /** static styles explicitly declared on this element */
    static: Set<Style>;
    /** blocks/classes set conditionally */
    dynamicClasses: Array<DynamicClasses<TernaryExpression>>;
    /** attributes set dynamically or depending on a dynamic class */
    dynamicAttributes: Array<DynamicAttrs<BooleanExpression, StringExpression>>;
    private explicitlyAddedStyles;
    private addedStyles;
    /** classes declared explicitly and found in at least one dynamic class expression. */
    private dynamicClassExpressions;
    /** All the classes on this element, by block. */
    private allClasses;
    /** All the AttrValues on this element. */
    private allAttributes;
    /**
     * All the static styles including styles implied by the explicitly specified
     * styles.
     */
    private allStaticStyles;
    private _sealed;
    private _reservedClassNames;
    /** whether all styles have been added and the styles can be analyzed now. */
    get sealed(): boolean;
    constructor(location: SourceLocation, reservedClassNames: Set<string>, tagName?: string, id?: string);
    hasStyles(): boolean;
    /**
     * Get a list of all possible block objects for the given block
     * on this element that can be used a parent for an attribute.
     *
     * This can be called before or after being sealed.
     */
    classesForBlock(block: Block): Array<BlockClass>;
    blocksFound(): Array<Block>;
    stylesFound(): Array<Style>;
    /**
     * Checks if the given class or block is set on this element,
     * or if it is implied by one of the other styles on this element.
     *
     * This can be called before or after being sealed.
     */
    hasClass(klass: BlockClass): boolean;
    /**
     * Checks if the given AttrValue is possibly set on this element,
     * or if it is implied by one of the other styles on this element.
     *
     * This can be called before or after being sealed.
     */
    hasAttribute(attr: AttrValue): boolean;
    /**
     * Iterate over all static and dynamic Attributes explicitly set on this element.
     * The analysis must be sealed to call this method.
     * @param dynamic
     *   * undefined - return all attributes,
     *   * true - return only dynamic attributes
     *   * false - return only static attributes
     */
    attributesFound(dynamic?: boolean): Generator<AttrValue, void, unknown>;
    /**
     * iterate over all static and dynamic blocks and classes explicitly set on this element.
     *
     * the analysis must be sealed to call this method.
     * @param dynamic
     *   * undefined - return all classes,
     *   * true - return only dynamic classes
     *   * false - return only static classes
     */
    classesFound(dynamic?: boolean): Generator<BlockClass, void, unknown>;
    /** Holds reference to all styles applied because of in-stylesheet composition. */
    private composedStyles;
    /**
     * Test if a given style is applied because of in-stylesheet composition.
     * Used in validators to skip some of the more strict validation checks.
     * @param style Style to test.
     * @returns `true` or `false` depending on if the provided stye was applied because of an in-stylesheet composition.
     */
    isFromComposition(style: Style): boolean;
    /**
     * Given a condition, return whether or not it should be applied and under what conditions.
     * @param comp Composition  The Composition we're testing against this ElementAnalysis.
     * @returns True if should always be applied, False if should never be applied,
     *          otherwise an object detailing the application conditions.
     */
    private fetchConditions;
    getSourceAnalysis(): ElementSourceAnalysis<BooleanExpression, StringExpression, TernaryExpression>;
    /**
     * This method indicates that all styles have been added
     * and can be analyzed and validated.
     */
    seal(): void;
    /**
     * This is used to add any static AttrValue even if it is part of an attribute group.
     * The AttrValue is added as dynamic and conditional on its class if that
     * class is dynamic.
     */
    addStaticAttr(container: BlockClass, value: AttrValue): void;
    private _addStaticAttr;
    /**
     * Adds an AttrValue that is toggled on and off at runtime.
     *
     * @param value the AttrValue that is dynamic.
     * @param condition The AST node(s) representing this boolean expression.
     */
    addDynamicAttr(container: BlockClass, value: AttrValue, condition: BooleanExpression): void;
    private _addDynamicAttr;
    /**
     * Adds a group of AttrValues that are toggled between at runtime.
     *
     * @param container The class or block root to which the AttrValues belong.
     * @param group The AttrValues that are to be chosen from. All must be children
     *   of the same group -- they can be from different blocks if they inherit.
     * @param condition The AST node(s) representing this group -- can be used
     *   by the rewriter. This is just an opaque value that is passed through.
     * @param disallowFalsy Whether a missing value is expected or should be
     *   a runtime error.
     */
    addDynamicGroup(container: BlockClass, group: Attribute, stringExpression: StringExpression, disallowFalsy?: boolean): void;
    private _addDynamicGroup;
    /**
     * Adds a AttrValue parent (BlockClass) that is always set on this element.
     */
    addStaticClass(klass: BlockClass): void;
    private _addStaticClass;
    private mapForAttribute;
    /**
     * Map the class and all the classes that the explicit class implies
     * to all the blocks those classes belong to via inheritance.
     *
     * These classes become valid containers for AttrValues even if they are not
     * explicitly set on the element.
     */
    private mapBlocksForClass;
    /**
     * Adds BlockClasses that are set based on a conditional.
     * This is modeled as a ternary (if/else) expression.
     *
     * Nested ternaries are not supported at this time.
     */
    addDynamicClasses(dynClasses: DynamicClasses<TernaryExpression>): void;
    private _addDynamicClasses;
    assertSealed(isSealed?: boolean): void;
    countAllStaticStyles(): number;
    getAllStaticStyles(): IterableIterator<Style>;
    /**
     * Only serializes the styles that were added during source analysis.
     */
    serializeSourceAnalysis(styleIndexes: Map<Style, number>): SerializedElementSourceAnalysis;
    serializeAnalyzedStyle(s: AnalyzedStyle<BooleanExpression, StringExpression, TernaryExpression>, indexOf: (s: Style) => number): SerializedAnalyzedStyle;
    static deserializeAnalyzedStyle(element: ElementAnalysis<null, null, null>, analyzedStyle: SerializedAnalyzedStyle, styleRef: (n: number) => Style, classRef: (n: number) => BlockClass, attrValueRef: (n: number) => AttrValue): void;
    /**
     * Get a simple object with no circular references that is possible to
     * emit and restore as JSON.
     *
     * @param styleIndexes a map of block objects to a number that represents
     *   it in the template analysis serialization.
     */
    serialize(styleIndexes: Map<Style, number>): SerializedElementAnalysis;
    private serializeDynamicContainer;
    private serializeDynamicAttrs;
    /**
     * Compute an OptiCSS element description and a map of class names back to
     * the block objects for use in re-writing.
     *
     * This mapping of classname to block object is stable and the keys can be
     * assumed to be unique per Style across all blocks -- so these
     * maps can be merged safely.
     */
    forOptimizer(configuration: ResolvedConfiguration): [Element, Map<string, Style>];
    /**
     * Because of the possibility for classes to inherit and imply
     * other classes, we need to convert any dynamic class
     * that is static because of another static class to be static
     * This ensures that otherwise static AttrValues won't get
     * hoisted into dynamic expressions because of a class dependency.
     */
    private prepareForAttributes;
    private prepareCondition;
}
/**
 * The source analysis is useful when the code wants an exact view of what styles
 * were explicitly set on an element.
 */
export declare class ElementSourceAnalysis<BooleanExpression, StringExpression, TernaryExpression> {
    addedStyles: AnalyzedStyle<BooleanExpression, StringExpression, TernaryExpression>[];
    blocksFound: Set<Block>;
    stylesFound: Set<Style>;
    /**
     * Styles that are always applied by the author.
     * This includes styles that are disabled if a dynamic dependency isn't present. */
    staticStyles: Array<Style>;
    ternaryStyles: Array<DynamicClasses<TernaryExpression>>;
    booleanStyles: Array<ConditionalAttr<BooleanExpression>>;
    switchStyles: Array<DynamicAttrGroup<StringExpression>>;
    constructor(addedStyles: Array<AnalyzedStyle<BooleanExpression, StringExpression, TernaryExpression>>);
    size(): number;
}
export {};
//# sourceMappingURL=ElementAnalysis.d.ts.map