import { Type, Destoryable, IDestoryable, Express, TokenId } from '@tsdi/ioc';
import { IAnnoationContext, AnnoationOption } from '@tsdi/boot';
export declare const CTX_COMPONENT_DECTOR: TokenId<string>;
export declare const CTX_COMPONENT: TokenId<any>;
export declare const CTX_ELEMENT_REF: TokenId<any>;
export declare const CTX_TEMPLATE_REF: TokenId<any>;
export declare const CTX_TEMPLATE_SCOPE: TokenId<any>;
export declare const CTX_COMPONENT_REF: TokenId<ComponentRef<any, NodeType, IAnnoationContext<AnnoationOption<any>>>>;
export declare const COMPONENT_REFS: TokenId<WeakMap<any, IComponentRef<any, any, IAnnoationContext<AnnoationOption<any>>>>>;
export declare const ELEMENT_REFS: TokenId<WeakMap<any, IElementRef<any, IAnnoationContext<AnnoationOption<any>>>>>;
export interface IContextNode<TCtx extends IAnnoationContext = IAnnoationContext> extends IDestoryable {
    readonly context: TCtx;
}
export declare class ContextNode<TCtx extends IAnnoationContext = IAnnoationContext> extends Destoryable {
    private _context;
    readonly context:TCtx;
    constructor(context: TCtx);
    protected destroying(): void;
    static ρAnn(): any;
}
/**
 *  element type.
 */
export interface IElement {
    destroy?(): any;
}
export declare const CONTEXT_REF: TokenId<IAnnoationContext<AnnoationOption<any>>>;
export declare const ELEMENT_REF: TokenId<IElementRef<any, IAnnoationContext<AnnoationOption<any>>>>;
export declare const NATIVE_ELEMENT: TokenId<IElement>;
export interface IElementRef<T = any, TCtx extends IAnnoationContext = IAnnoationContext> extends IContextNode<TCtx> {
    readonly nativeElement: T;
}
export interface INodeRef<T = any, TCtx extends IAnnoationContext = IAnnoationContext> extends IContextNode<TCtx> {
    readonly rootNodes: T[];
}
export declare const TEMPLATE_REF: TokenId<ITemplateRef<any, IAnnoationContext<AnnoationOption<any>>>>;
export declare const ROOT_NODES: TokenId<any[]>;
export interface ITemplateRef<T = any, TCtx extends IAnnoationContext = IAnnoationContext> extends INodeRef<T, TCtx> {
    readonly template: any;
}
export declare const REFCHILD_SELECTOR: TokenId<string>;
export declare const COMPONENT_REF: TokenId<IComponentRef<any, NodeType, IAnnoationContext<AnnoationOption<any>>>>;
export declare const COMPONENT_TYPE: TokenId<Type<any>>;
export declare const COMPONENT_INST: TokenId<object>;
export interface IComponentRef<T = any, TN = NodeType, TCtx extends IAnnoationContext = IAnnoationContext> extends IContextNode<TCtx> {
    readonly componentType: Type<T>;
    readonly instance: T;
    readonly selector: string;
    readonly nodeRef: ITemplateRef<TN>;
    getNodeSelector(): NodeSelector;
}
export declare type NodeType = IElement | IElementRef | INodeRef | ITemplateRef;
export declare class NodeRef<T = NodeType, TCtx extends IAnnoationContext = IAnnoationContext> extends ContextNode<TCtx> implements INodeRef<T, TCtx> {
    private _rootNodes;
    readonly rootNodes:T[];
    constructor(context: TCtx, nodes: T[]);
    protected destroying(): void;
    static ρAnn(): any;
}
export declare class ElementRef<T = any, TCtx extends IAnnoationContext = IAnnoationContext> extends ContextNode<TCtx> implements IElementRef<T, TCtx> {
    readonly nativeElement: T;
    constructor(context: TCtx, nativeElement: T);
    protected destroying(): void;
    static ρAnn(): any;
}
export declare class TemplateRef<T = NodeType, TCtx extends IAnnoationContext = IAnnoationContext> extends NodeRef<T, TCtx> implements ITemplateRef<T, TCtx> {
    readonly template:any;
    static ρAnn(): any;
}
export declare class ComponentRef<T = any, TN = NodeType, TCtx extends IAnnoationContext = IAnnoationContext> extends ContextNode<TCtx> implements IComponentRef<T, TN, TCtx> {
    readonly componentType: Type<T>;
    readonly instance: T;
    readonly nodeRef: ITemplateRef<TN>;
    readonly selector:string;
    constructor(componentType: Type<T>, instance: T, context: TCtx, nodeRef: ITemplateRef<TN>);
    getNodeSelector(): NodeSelector;
    protected destroying(): void;
    static ρAnn(): any;
}
/**
 * route： route up. iterate in parents.
 * children： iterate in children.
 * traverse: iterate as tree map. node first.
 * traverseLast: iterate as tree map. node last.
 */
export declare type Mode = 'route' | 'children' | 'traverse' | 'traverseLast';
/**
 * node selector.
 *
 * @export
 * @abstract
 * @class NodeSelector
 * @template T
 */
export declare class NodeSelector<T = any> {
    protected node: INodeRef<T>;
    constructor(node: INodeRef<T>);
    find<Tc extends T>(express: Tc | Express<Tc, boolean>, mode?: Mode): Tc;
    filter<Tc extends T>(express: Express<Tc, boolean | void>, mode?: Mode): Tc[];
    map<Tc extends T, TR>(express: Express<Tc, TR | boolean>, mode?: Mode): TR[];
    each<Tc extends T>(express: Express<Tc, boolean | void>, mode?: Mode): any;
    protected eachChildren<Tc extends T>(node: INodeRef<T>, express: Express<Tc, void | boolean>): void;
    /**
     *do express work in routing.
     *
     *@param {Express<T, void | boolean>} express
     *
     *@memberOf IComponent
     */
    routeUp(node: INodeRef<T>, express: Express<T, void | boolean>): any;
    /**
     *translate all sub context to do express work.
     *
     *@param {Express<IComponent, void | boolean>} express
     *
     *@memberOf IComponent
     */
    trans(node: INodeRef<T>, express: Express<T, void | boolean>): boolean;
    transAfter(node: INodeRef<T>, express: Express<T, void | boolean>): boolean;
    protected currNode(node: INodeRef<T>, express: Express<T, void | boolean>): boolean;
    protected getParent(node: INodeRef<T>): NodeRef<T>;
    protected getChildren(node: INodeRef<T>): NodeRef<T>[];
    static ρAnn(): any;
}
export declare class NullSelector<T = any> extends NodeSelector<T> {
    protected getParent(node: NodeRef<T>): NodeRef<T>;
    protected getChildren(node: NodeRef<T>): NodeRef<T>[];
    static ρAnn(): any;
}