import { Observable } from 'rxjs';
import { t } from '../common';
declare type O = Record<string, unknown>;
declare type Event = t.Event<O>;
declare type N = t.ITreeNode;
export declare class TreeState<T extends N = N, A extends Event = any> implements t.ITreeState<T, A> {
    static create<T extends N = N, A extends Event = any>(args?: t.ITreeStateArgs<T>): t.ITreeState<T, A>;
    static identity: t.TreeIdentity;
    static props: <P>(of: t.INode<Record<string, unknown>>, fn?: ((props: P) => void) | undefined) => P;
    static children: <T_1 extends t.ITreeNode<Record<string, unknown>>>(of: T_1, fn?: ((children: T_1[]) => void) | undefined) => T_1[];
    static isInstance: (input: any) => boolean;
    private constructor();
    dispose(): void;
    private _store;
    private _children;
    private _kind;
    readonly key: string;
    readonly namespace: string;
    readonly parent: string | undefined;
    private _dispose$;
    readonly dispose$: Observable<void>;
    private _event$;
    readonly event: t.ITreeStateEvents<T, A>;
    get isDisposed(): boolean;
    get readonly(): t.ITreeStateReadonly<T, A>;
    get store(): t.IStateObjectWritable<T, t.Event<Record<string, unknown>>>;
    get root(): T;
    get id(): string;
    get children(): t.ITreeState<any, any>[];
    get query(): t.ITreeQuery<T>;
    get path(): t.ITreeStatePath<T, A>;
    change: t.TreeStateChange<T, A>;
    private _change;
    add: <C extends t.ITreeNode<Record<string, unknown>> = t.ITreeNode<Record<string, unknown>>>(args: {
        parent?: string | undefined;
        root: string | C | t.ITreeState<C, any>;
    }) => t.ITreeState<C, any>;
    remove: (input: string | t.ITreeState) => t.ITreeState<any, any>;
    clear: () => t.ITreeState<T>;
    contains: t.TreeStateContains<T, A>;
    find: t.TreeStateFind<T, A>;
    walkDown: t.TreeStateWalkDown<T, A>;
    syncFrom: t.TreeStateSyncFrom;
    private fire;
    private ctx;
    private child;
    private childExists;
    private getOrCreateInstance;
    private listen;
}
export {};