import { Type, ITypeReflects, IProvider, SymbolType, Token, ClassType, TokenId } from '@tsdi/ioc';
import { ICoreInjector } from '@tsdi/core';
import { IAnnoationContext } from '@tsdi/boot';
import { IComponentRef, ITemplateRef, IElementRef, NodeSelector } from './ComponentRef';
import { IPipeTransform } from './bindings/IPipeTransform';
import { IComponentContext } from './ComponentContext';
import { ITemplateContext, ITemplateOption } from './compile/TemplateContext';
export interface BindFunc extends Function {
    __binded?: boolean;
}
export declare const CTX_COMPONENT_PROVIDER: TokenId<ComponentProvider>;
/**
 * ref element identfy selector.
 *
 * @export
 * @abstract
 * @class RefIdentfy
 */
export declare abstract class ComponentProvider {
    protected dectorator: string;
    constructor(dectorator: string);
    reflects: ITypeReflects;
    private providers;
    getProviders(): IProvider;
    abstract getSelectorKey(): string;
    abstract getRefSelectKey(): string;
    abstract getDefaultCompose(): Type;
    /**
     * parse element, template as ref or not.
     */
    parseRef: boolean;
    createNodeSelector(element: any): NodeSelector;
    private ast;
    getAstResolver(): AstResolver;
    isTemplate(target: any): boolean;
    createComponentRef<T>(type: Type<T>, target: T, context: IAnnoationContext, ...nodes: any[]): IComponentRef<T, any>;
    abstract isTemplateContext(context: IAnnoationContext): boolean;
    abstract createTemplateContext(injector: ICoreInjector, options?: ITemplateOption): ITemplateContext;
    createTemplateRef(context: IAnnoationContext, ...nodes: any[]): ITemplateRef;
    createElementRef(context: IAnnoationContext, target: any): IElementRef;
    getElementRef(target: any, injector?: ICoreInjector): IElementRef;
    getComponentRef<T>(target: T, injector?: ICoreInjector): IComponentRef<T, any>;
    getPipe<T extends IPipeTransform>(token: Token<T>, injector: ICoreInjector): T;
    toSelectorToken(selector: string): SymbolType;
    toAttrSelectorToken(selector: string): SymbolType;
    /**
     * bind function context.
     * @param func func
     * @param ctx context to bind.
     */
    bindContext(func: Function, ctx: IComponentContext): BindFunc;
    /**
     * select ref tag in element.
     *
     * @param {*} element
     * @param {(string | ((e: any) => boolean))} selector
     * @returns {*}
     * @memberof RefSelector
     */
    select(element: any, selector: string | ((e: any) => boolean)): any;
    protected match(e: any, selector: string, idkey: string): boolean;
    abstract isElementRef(target: any): target is IElementRef;
    abstract isComponentRef(target: any): target is IComponentRef;
    abstract isElementRefType(target: ClassType): boolean;
    abstract isComponentRefType(target: ClassType): boolean;
    isNodeType(element: ClassType): boolean;
    isComponentType(element: ClassType): boolean;
    abstract isElementType(element: ClassType): boolean;
    static ρAnn(): any;
}
export declare class AstResolver {
    protected provider: ComponentProvider;
    constructor(provider: ComponentProvider);
    /**
     * resolve expression.
     *
     * @param {string} expression
     * @param {ICoreInjector} [injector]
     * @param {Object | Map<string, any>} [scope]
     * @param {*} [envOptions]
     * @returns {*}
     * @memberof AstResolver
     */
    resolve(expression: string, injector: ICoreInjector, scope?: Object | Map<string, any>, envOptions?: any): any;
    parse(expression: string, injector: ICoreInjector): (scope: Map<string, any>, envOptions?: any) => any;
    parseScope(expression: string, scope?: Object | Map<string, any>, envOptions?: Object): Map<string, any>;
    eval(expression: string, scopes?: Map<string, any>): any;
    toScopFunc(expression: string, scopes: string[]): (...args: any[]) => any;
    protected transforms(pipes: string[], injector: ICoreInjector, scopes: string[]): ((value: any, args: any[], envOptions?: any) => any)[];
    static ρAnn(): any;
}