import ts from "typescript";
import { InjectDIToken, Injector } from "@bonbons/di";
import { IInnerComponent } from "../../core/component";
import { EntityConstructor, IConstructor, IFrameworkDepts } from "../../core/decorators";
import { IBasicCompilationContext, IBasicCompilationFinalContext, IChildPropMap, IDirectiveInputMap, IComponentAttachMap } from "../../core/base";
import { BasicDirective } from "../../core/directive";
import { BasicHelper } from "../entity-helper";
export interface IChildRefPluginOptions {
    refComponent: string;
    childName: string;
    props: IChildPropMap;
}
export interface IComponentPluginOptions<T extends InjectDIToken<any>> extends IDirectivePluginOptions<T> {
    provider: keyof IFrameworkDepts;
    components?: IComponentPluginOptions<any>[];
    directives?: IDirectivePluginOptions<any>[];
    children?: IChildRefPluginOptions[];
    dependencies?: {
        [prop: string]: any;
    };
}
export interface IDirectivePluginOptions<T extends InjectDIToken<any>> {
    id: string;
    provider: keyof IFrameworkDepts;
    template: T;
    input?: IDirectiveInputMap;
}
export interface IRootPageCreateOptions<T extends InjectDIToken<any>> extends IComponentPluginOptions<T> {
    passContext?: IBasicCompilationContext;
    attach?: IComponentAttachMap;
}
export interface IPropertiesOptions {
    input?: IDirectiveInputMap;
    attach?: IComponentAttachMap;
}
export declare abstract class BasicEntityProvider {
    protected readonly injector: Injector;
    protected readonly helper: BasicHelper;
    constructor(injector: Injector, helper: BasicHelper);
    createInstance<T extends IConstructor<IInnerComponent>>({ template, input, attach, components, directives, children, id, passContext, }: IRootPageCreateOptions<T>, provider: BasicEntityProvider): any;
    callCompilation(provider: keyof IFrameworkDepts, model: IInnerComponent, name: string, unExport?: boolean): Promise<ts.SourceFile>;
    /** @override */
    resolveExtensionsMetadata(_: EntityConstructor<any>): {
        [name: string]: any;
    };
    /** @override */
    attachDirective<T extends BasicDirective, P extends IInnerComponent>(parent: P, target: T): T;
    /** @override */
    protected onInputPropertiesInit<T extends any>(_: T, options: IPropertiesOptions): void;
    /** @override */
    protected onCompilationCall(model: IInnerComponent, _context: IBasicCompilationContext): IBasicCompilationFinalContext;
    protected emitClassComponentContext(_context: Partial<IBasicCompilationFinalContext>): Partial<IBasicCompilationFinalContext> | null;
    protected emitFunctionComponentContext(_context: Partial<IBasicCompilationFinalContext>): Partial<IBasicCompilationFinalContext> | null;
    /** @override */
    protected onImportsUpdate(model: IInnerComponent, imports: ts.ImportDeclaration[], init?: ts.ImportDeclaration[]): ts.ImportDeclaration[];
    /** @override */
    protected onStatementsEmitted(model: IInnerComponent, statements: ts.Statement[]): ts.Statement[];
    /** @override */
    protected abstract createRootComponent(model: IInnerComponent, context: IBasicCompilationFinalContext, isExport?: boolean): ts.Statement;
    private _initContextInstance;
    private _inputProperties;
    private _attachProperties;
}