import { AsyncDisposable, Emitter, EnhancedAsyncDisposable } from '@idlebox/common';
import { type IMyLogger } from '@idlebox/logger';
import { inspect, type InspectContext } from 'node:util';
export declare abstract class AbstractBaseNode<State = any> extends EnhancedAsyncDisposable {
    readonly name: string;
    /**
     * 如果不传，会在addNode时创建一个
     */
    readonly logger: IMyLogger;
    protected abstract readonly _dependencies: Set<string>;
    protected _state: State;
    private readonly _onStateChange;
    readonly onStateChange: import("@idlebox/common").EventRegister<State>;
    constructor(name: string, initState: State, 
    /**
     * 如果不传，会在addNode时创建一个
     */
    logger?: IMyLogger);
    get dependencies(): ReadonlySet<string>;
    addDependency(name: string): void;
    removeDependency(name: string): void;
    protected setState(state: State): void;
    private imm?;
    protected publishStateEvent(): void;
    translateState?(): string;
    protected debugPrefix(): string;
    [inspect.custom](_d: number, _options: InspectContext, _ins: typeof inspect): string;
    customInspect(): string;
}
export type ISummary = {
    totalColor?: string;
    statistics?: Record<string, number | string | boolean>;
};
export declare abstract class AbstractBaseGraph<T extends AbstractBaseNode> extends AsyncDisposable {
    protected readonly logger: IMyLogger;
    private readonly graph;
    readonly overallOrder: readonly string[];
    protected readonly nodes: readonly T[];
    protected readonly _anyStateChange: Emitter<T>;
    readonly onAnyStateChange: import("@idlebox/common").EventRegister<T>;
    constructor(nodesIt: Iterable<T>, logger?: IMyLogger);
    get size(): number;
    /**
     * 获取依赖项的列表
     * @param name 当前项名称
     * @param transitively 为true时包括所有间接依赖项
     * @returns 依赖项列表
     */
    dependenciesOf(parent: string, transitively: boolean): string[];
    /**
     * 获取依赖当前项的列表
     * @param parent 当前项名称
     * @param transitively 为true时包括所有间接依赖项
     * @returns 依赖项列表
     */
    dependantsOf(parent: string, transitively: boolean): string[];
    /**
     * 根据整体顺序排序，数组使用此顺序排好后，顺序将会类似于overallOrder
     */
    protected overallOrderSorter(a: string, b: string): number;
    getNodeByName(name: string): T;
    dispose(): Promise<void>;
    /**
     * debug输出依赖图结构，类似：
     * aaaa
     * ├─ bbbb
     * │  ├─ cccc
     * │  └─ dddd
     * └─ cccc
     */
    debugFormatGraph(depth?: number, reverse?: boolean): string;
    debugFormatList(): string;
    protected inspectSummary(): ISummary;
    debugFormatSummary(): string;
    protected [inspect.custom](): string;
}
/**
 * 依赖关系图，包装 dependency-graph ，可一次性添加节点和依赖关系
 */
export declare abstract class AbstractGraphBuilder<T extends AbstractBaseNode, GT extends AbstractBaseGraph<T>> {
    protected readonly logger: IMyLogger;
    protected readonly nodes: Set<T>;
    protected finalized?: GT;
    constructor(logger?: IMyLogger);
    protected getChildLogger(node: T): IMyLogger;
    addNode(node: T): T;
    size(): number;
    get nodeNames(): string[];
    getNode(name: T | string): T;
    removeNode(name: T | string, withDependent?: boolean): void;
    protected abstract _finalize(): GT;
    /**
     * 结束注册
     * 在调用此方法后，不能再添加新的节点
     *
     * @throws {import('dependency-graph').DepGraphCycleError} 如果有环，则抛出异常
     */
    finalize(): GT;
}
//# sourceMappingURL=base-graph.d.ts.map