import ts from "typescript";
import { EntityType, ICompChildRefPluginOptions, IComponentCreateOptions, ICompositionCreateOptions, IDirectiveCreateOptions } from "./entity";
import { IInnerCompnentChildRef, IInnerCompositionChildRef } from "../child-ref";
import { AnonymousStatementGenerator, ClassGenerator, FunctionGenerator, ImportGenerator, JsxAttributeGenerator, JsxElementGenerator, JsxExpressionGenerator, VariableGenerator } from "../typescript";
import { ReconcilerEngine } from "../reconciler";
export declare const ContextItemsGroup: {
    import: typeof ImportGenerator;
    variable: typeof VariableGenerator;
    class: typeof ClassGenerator;
    function: typeof FunctionGenerator;
    statement: typeof AnonymousStatementGenerator;
    ["jsx-element"]: typeof JsxElementGenerator;
    ["jsx-attribute"]: typeof JsxAttributeGenerator;
    ["jsx-expression"]: typeof JsxExpressionGenerator;
};
export interface IFinalScopedContext {
    imports: InstanceType<typeof ContextItemsGroup["import"]>[];
    variables: InstanceType<typeof ContextItemsGroup["variable"]>[];
    classes: InstanceType<typeof ContextItemsGroup["class"]>[];
    functions: InstanceType<typeof ContextItemsGroup["function"]>[];
    statements: InstanceType<typeof ContextItemsGroup["statement"]>[];
}
export interface IFinalAstContext {
    imports: ts.ImportDeclaration[];
    variables: ts.VariableStatement[];
    classes: ts.ClassDeclaration[];
    functions: ts.FunctionDeclaration[];
    statements: ts.Statement[];
}
export interface IFinalGeneratorContext {
    imports: ImportGenerator[];
    variables: VariableGenerator[];
    classes: ClassGenerator[];
    functions: FunctionGenerator[];
    statements: AnonymousStatementGenerator[];
}
export interface IScopeStructure<TYPE extends EntityType, ENTITY> {
    scope: string | symbol;
    parent: string | symbol | undefined;
    type: TYPE;
    container: ENTITY;
}
export interface ISourceBuildOptions {
    codeShakes: boolean;
}
export interface IScopedContext extends Map<string | symbol, IScopeStructure<EntityType, Partial<IFinalScopedContext>>> {
}
export declare type IInnerSolidEntity = IInnerCompnentChildRef | IInnerCompositionChildRef;
export declare abstract class SourceFileContext<T extends any> {
    scopedContext: IScopedContext;
    genContext: IFinalGeneratorContext;
    astContext: IFinalAstContext;
    provider: T;
    reconciler: ReconcilerEngine;
    root: IInnerCompnentChildRef | IInnerCompositionChildRef;
    rootSlot: string;
    components: IComponentCreateOptions[];
    directives: IDirectiveCreateOptions[];
    compositions: ICompositionCreateOptions[];
    dependencies: Record<string, string>;
    protected useCodeShakes: boolean;
    abstract getDefaultEntityId(entity: IInnerSolidEntity): string;
    abstract setProvider(provider: string): this;
    abstract importComponents(components: IComponentCreateOptions[]): this;
    abstract importDirectives(directives: IDirectiveCreateOptions[]): this;
    abstract importCompositions(compositions: ICompositionCreateOptions[]): this;
    abstract build(options?: Partial<ISourceBuildOptions>): this;
    abstract getDependencies(): Record<string, string>;
    abstract createRoot(options: ICompChildRefPluginOptions, slot?: string): this;
    abstract callCompilation(): Promise<void>;
    abstract createSourceFile(): Promise<ts.SourceFile>;
}