import { Event } from '@gedit/utils';
import { Disposable, DisposableCollection, Emitter } from '@gedit/utils';
import { PlaygroundContext } from './playground-context';
import type { Able, AbleRegistry } from './able';
import type { EntityManager } from './entity-manager';
import type { EntityAbles, AbleChangedEvent } from './entity-ables';
import type { EntityData, EntityDataProps, EntityDataRegistry } from './entity-data';
import type { AbleManager } from './able-manager';
/**
 * 注册类
 */
export interface EntityRegistry<E extends Entity = Entity> {
    new (opts: EntityOpts): E;
    readonly type: E['type'];
}
/**
 * 持久化数据
 */
export interface EntityJSON {
    type: string;
    id: string;
    ableList?: string[];
    dataList: object[];
}
export interface EntityChildChangedEvent<T extends Entity = Entity> {
    type: 'add' | 'delete' | 'update';
    entity: T;
}
export interface EntityDataChangedEvent<T extends Entity = Entity> {
    type: 'add' | 'delete' | 'update';
    data: EntityData;
    entity: T;
}
export interface EntityOpts {
    entityManager: EntityManager;
    id?: string;
    ables?: AbleRegistry[];
    datas?: {
        registry: EntityDataRegistry;
        data: EntityDataProps<any>;
    }[];
    savedInManager?: boolean;
}
export declare class Entity<OPTS extends EntityOpts = EntityOpts> implements Disposable {
    static type: string;
    private readonly onEntityChangedEmitter;
    private readonly onDataChangedEmitter;
    private readonly onChildrenChangedEmitter;
    private readonly initializeDataKeys;
    protected readonly dataManager: Map<string, EntityData>;
    readonly onBeforeAbleDispatchedEmitter: Emitter<Able<any>>;
    readonly onAfterAbleDispatchedEmitter: Emitter<Able<any>>;
    /**
     * 销毁事件管理
     */
    readonly toDispose: DisposableCollection;
    /**
     * able管理
     */
    readonly ables: EntityAbles;
    /**
     * 修改会触发
     */
    readonly onEntityChanged: Event<Entity<EntityOpts>>;
    /**
     * able触发之前
     */
    readonly onBeforeAbleDispatched: Event<Able<any>>;
    /**
     * able触发之后
     */
    readonly onAfterAbleDispatched: Event<Able<any>>;
    /**
     * 子节点变化
     */
    readonly onChildrenChanged: Event<EntityChildChangedEvent<Entity<EntityOpts>>>;
    /**
     * 数据更改事件
     */
    readonly onDataChanged: Event<EntityDataChangedEvent<Entity<EntityOpts>>>;
    /**
     * able数据更改
     */
    readonly onAbleChanged: Event<AbleChangedEvent>;
    /**
     * 由上下文注入的数据
     */
    context: PlaygroundContext;
    /**
     * 初始化的data
     */
    getDefaultAbleRegistries(): AbleRegistry[];
    /**
     * 初始化的able
     */
    getDefaultDataRegistries(): EntityDataRegistry[];
    private _pauseChangedTimes;
    protected isInitialized: boolean;
    private _id;
    private _version;
    private _parent?;
    private _children?;
    private _savedInManager;
    readonly ableManager: AbleManager;
    /**
     * 暂停更新开关
     * @protected
     */
    protected get pauseChanged(): boolean;
    protected set pauseChanged(pauseChanged: boolean);
    /**
     * 实体类型
     */
    get type(): string;
    /**
     * 全局的entity管理器
     */
    readonly entityManager: EntityManager;
    constructor(opts: OPTS);
    /**
     * 实体的版本
     */
    get version(): number;
    /**
     * 存储数据, 用于持久化存储
     */
    toJSON(): EntityJSON | undefined;
    /**
     * 还原数据
     * @param data
     */
    fromJSON(data?: EntityJSON): void;
    /**
     * 实体id
     */
    get id(): string;
    /**
     * 销毁实体
     */
    dispose(): void;
    get disposed(): boolean;
    /**
     * 重制为初始化状态
     */
    reset(): void;
    /**
     * 销毁事件
     */
    get onDispose(): Event<void>;
    /**
     * 触发实体更新
     * @protected
     */
    protected fireChanged(): void;
    /**
     * 添加数据
     */
    addData<D extends EntityData>(Registry: EntityDataRegistry, defaultProps?: EntityDataProps<D>): D;
    /**
     * 是否存到全局manager，默认true
     */
    get savedInManager(): boolean;
    /**
     * 更新实体的数据
     */
    updateData<D extends EntityData>(Registry: EntityDataRegistry<D>, props: EntityDataProps<D>): void;
    /**
     * 获取data数据
     * @param Registry
     */
    getData<D extends EntityData>(Registry: EntityDataRegistry<D>): D | undefined;
    /**
     * 是否有指定数据
     * @param Registry
     */
    hasData(Registry: EntityDataRegistry): boolean;
    /**
     * 删除数据, 初始化状态注入的数据无法被删除
     */
    removeData<D extends EntityData>(Registry: EntityDataRegistry<D>): void;
    /**
     * 添加able
     * @param ables
     */
    addAbles(...ables: AbleRegistry[]): void;
    /**
     * 删除able
     * @param ables
     */
    removeAbles(...ables: AbleRegistry[]): void;
    /**
     * 是否有able
     * @param able
     */
    hasAble(able: AbleRegistry): boolean;
    hasAbles(...ables: AbleRegistry[]): boolean;
    /**
     * 添加子节点
     * @param Registry
     * @param opts
     * @param savedInManager - 是否存储到manager，默认false
     */
    createChild<E extends Entity>(Registry: EntityRegistry, opts: Omit<E['__opts_type__'], 'entityManager'>): E;
    /**
     * 获取父亲节点
     */
    getParent<E extends Entity>(): E | undefined;
    get hasChild(): boolean;
    /**
     * 获取子节点
     * @param Registry
     */
    getChildren<E extends Entity>(Registry?: EntityRegistry): E[];
    /**
     * 清空所有子节点
     */
    clearChildren(): void;
    /**
     * 根据id获取子节点
     * @param id
     */
    getChildById<E extends Entity>(id: string): E | undefined;
    protected register(): void;
    __opts_type__: OPTS;
}
export declare namespace Entity {
    function getType(registry: EntityRegistry): string;
    /**
     * 默认数据比较，采用浅比较
     */
    function checkDataChanged(oldProps: any, newProps: any): boolean;
    function isRegistryOf(target: any, Registry: any): boolean;
}
//# sourceMappingURL=entity.d.ts.map