import { Observable } from 'rxjs';
import { t } from '../common';
declare type N = t.ITreeNode;
export declare class TreeState<T extends N = N> implements t.ITreeState<T> {
    static create<T extends N = N>(args?: t.ITreeStateArgs<T>): t.ITreeState<T>;
    static identity: t.TreeIdentity;
    static props: <P>(of: {
        id: string;
        props?: {
            [x: string]: unknown;
        } | undefined;
    }, fn?: ((props: P) => void) | undefined) => P;
    static children: <T_1 extends t.INode<{
        [x: string]: unknown;
    }> & {
        children?: t.ITreeNode<{
            [x: string]: unknown;
        }>[] | undefined;
    }>(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>;
    get isDisposed(): boolean;
    get readonly(): t.ITreeStateReadonly<T>;
    get state(): T;
    get id(): string;
    get children(): t.ITreeState<any>[];
    get query(): t.ITreeQuery<T>;
    get path(): t.ITreeStatePath<T>;
    change: t.TreeStateChange<T>;
    private _change;
    changeAsync: t.TreeStateChangeAsync<T>;
    add: <C extends N = N>(args: t.ITreeState<C> | {
        parent?: string | undefined;
        root: string | C | t.ITreeState<C>;
    }) => t.ITreeState<C>;
    remove: (input: string | t.ITreeState<any>) => t.ITreeState<any>;
    clear: () => t.ITreeState<T>;
    contains: t.TreeStateContains<T>;
    find: t.TreeStateFind<T>;
    walkDown: t.TreeStateWalkDown<T>;
    syncFrom: t.TreeStateSyncFrom;
    private fire;
    private ctx;
    private child;
    private childExists;
    private getOrCreateInstance;
    private listen;
}
export {};