import * as t from '@rekajs/types';
import { IComputedValue, IObservableValue } from 'mobx';
import { EachDirectiveEvaluator } from './each';
import { Environment } from './environment';
import { Frame } from './frame';
import { ChangesetListener } from './observer';
import { Reka } from './reka';
export type TemplateEvaluateContext = {
    env: Environment;
    owner: t.ComponentView | null;
    path: string[];
    componentStack: t.Component[];
};
export type TemplateViewComputationCache = {
    template: t.Template;
    computation: IComputedValue<t.View[]>;
};
export type TemplateEachComputationCache = {
    evaluator: EachDirectiveEvaluator;
};
export declare class Evaluator {
    readonly frame: Frame;
    readonly componentName: string;
    readonly componentProps: Record<string, any>;
    readonly reka: Reka;
    readonly external: boolean;
    private _view;
    private viewObserver;
    private rootTemplate;
    private rootTemplateObserver;
    private rootTemplateComputation;
    tplToView: Map<t.Template, t.View[]>;
    private tplKeyToClassListComputationCache;
    private tplToEachComputationCache;
    private viewToParentView;
    private tplKeyToViewComputationCache;
    private tplKeyToComponentEvaluator;
    private tplKeyToView;
    _component: IObservableValue<t.Component | null>;
    constructor(frame: Frame, componentName: string, componentProps: Record<string, any>, reka: Reka, external?: boolean);
    get view(): t.FrameView;
    get component(): t.Component | null;
    getViewsForTpl(tpl: t.Template): t.View[];
    getViewFromId<T extends t.Type = t.Any>(id: string, expectedType?: t.TypeConstructor<T>): T;
    getParentView<T extends t.View>(view: t.View, expectedParentType?: t.TypeConstructor<T>): T | null;
    private disposeComponentEvaluators;
    private changeRootTemplate;
    diff(key: string, newView: t.View): any;
    private setView;
    listenToChangeset(listener: ChangesetListener): () => void;
    computeTemplate(template: t.Template, ctx: TemplateEvaluateContext): any[];
    computeFragmentTemplate(template: t.FragmentTemplate, ctx: TemplateEvaluateContext): t.FragmentView[];
    computeSlotTemplate(template: t.SlotTemplate, ctx: TemplateEvaluateContext): t.SlotView[];
    computeTagTemplate(template: t.TagTemplate, ctx: TemplateEvaluateContext): t.View[];
    computeComponentTemplate(template: t.ComponentTemplate, ctx: TemplateEvaluateContext): t.View[];
    computeExpr(expr: t.Any, env: Environment): any;
    computeRootTemplate(): t.View[];
    computeView(): void;
    dispose(): void;
    setProps(props: Record<string, any>): void;
}