import * as t from '@rekajs/types';
import { IArraySplice, IArrayUpdate, IObjectDidChange } from 'mobx';
type Location = {
    parent: t.Type;
    path: Array<string | number>;
};
export type MobxChangePayload = IObjectDidChange | IArraySplice | IArrayUpdate;
export type ObserverAddPayload = {
    type: t.Type;
};
export type ObserverDiposePayload = {
    type: t.Type;
};
export type ObserverChangePayload = MobxChangePayload & Location;
export type ObserverHooks = {
    onAdd: (payload: ObserverAddPayload) => void;
    onChange: (payload: ObserverChangePayload) => void;
    onDispose: (payload: ObserverDiposePayload) => void;
    onNormalize: (changeset: Changeset) => void;
};
export type ObserverOptions = {
    id?: string;
    batch: boolean;
    shouldIgnoreObservable: (parent: t.Type, key: string, value: any) => boolean;
    hooks: Partial<ObserverHooks>;
    resolveProp: t.Tree['resolveProp'];
};
export type ChangeOpts<O extends Record<string, any> = {}> = {
    source?: any;
} & O;
export type Changeset<O extends Record<string, any> = {}> = {
    changes: ObserverChangePayload[];
    disposed: t.Type[];
    added: t.Type[];
} & ChangeOpts<O>;
export type ChangesetListener<I extends Record<string, any> = {}> = (changeset: Changeset<I>) => void;
export declare class Observer<T extends t.Type = t.Type, O extends Record<string, any> = {}> extends t.Tree {
    readonly root: T;
    private rootDisposer;
    private valueToTraversalInfo;
    private idToType;
    private opts;
    private typeToDisposer;
    private markedForDisposal;
    private isDisposing;
    private isMutating;
    private changesetListeners;
    private uncommittedValues;
    private changeset;
    constructor(root: T, opts?: Partial<ObserverOptions>);
    private whileDisposing;
    private disposeTypes;
    private setRoot;
    resolveProp(node: t.Type, name: string): any;
    getTypeFromId<T extends t.Type = t.Any>(id: string, expectedType?: t.TypeConstructor<T>): T;
    listenToChangeset(subscriber: ChangesetListener<any>): () => void;
    private setupChild;
    private setupType;
    private setupArray;
    private setupMap;
    private updateChangeset;
    private handleOnAddType;
    private handleOnDisposeType;
    private handleOnChange;
    private isParentValueUncommitted;
    private notifyChangesetListeners;
    private getValueTraversalInfo;
    /**
     * Get the nearest parent Type node (and any additional path to traverse) in order to reach a given value
     * For example:
     * {
     *   type: "A",
     *   children: [
     *      {
     *        type: "B"
     *      }
     *   ]
     *
     *   The location of "B" is {
     *     parent: "A",
     *     path: ["children", 0]
     *   }
     * }
     */
    private getValueLocation;
    getNodeLocation(node: t.Type): Location;
    getParentNode<T extends t.Type = t.Any>(node: t.Type, expectedParentType?: t.TypeConstructor<T>): T | null;
    getNodePath(node: t.Type): (string | number)[] | null;
    getNodePathStr(node: t.Type, nearest?: boolean): any;
    change<C>(mutation: () => C, opts?: ChangeOpts<O>): C;
    dispose(): void;
}
export {};