import { modelSymbol, parentSymbol, apc, vpc, modelName } from './symbols';
import { EventHandler } from './emitter';
export declare type EmitFn = (evt: string, val: Event) => void;
interface ModelCommons {
    onAction(fn: EventHandler, after?: boolean): () => void;
    onSnapshot(fn: EventHandler): () => void;
    onPatch(fn: EventHandler): () => void;
    getSnapshot(): object;
    applySnapshot(snapshot: object, dontemit?: boolean): void;
    getParent(): (UnknownObj & Model<UnknownObj>) | null;
    getRoot(): UnknownObj & Model<UnknownObj>;
}
export declare type FnMap = {
    [index: string]: Function;
};
declare type Obj = {
    [index: string]: any;
};
declare type UnknownObj = {
    [index: string]: unknown;
};
export interface Model<S extends Obj> extends ModelCommons {
    [vpc]: S & Model<S>;
    [apc]: S & Model<S>;
    [modelName]: string;
    [modelSymbol]: boolean;
    [parentSymbol]: (emit: EmitFn, _parent: Model<S>, _path: string) => void;
}
export declare type Event = {
    path?: string;
    value?: string;
    [index: string]: any;
};
export declare type ModelArgs<S extends Obj, A extends FnMap, V extends FnMap> = {
    initial: () => S;
    actions?: (self: S & Model<S>) => A;
    views?: (self: S & Model<S>) => V;
};
export declare function model<S extends Obj, K extends keyof S, A extends FnMap = {}, V extends FnMap = {}>(name: string, { initial, actions, views }: ModelArgs<S, A, V>): (obj?: object | undefined) => S & A & V & Model<S>;
export declare function clearCache(): void;
export {};