import { InjectScope, InjectToken, ImplementBasicFactory, ScopeID, DIContainerEntry, DepedencyResolveEntry, IDIContainer, IContainerConfigs, IRegisterConfig } from "./declares";
import { DIScopePool } from "./scope-pool";
export declare const Helpers: {
    isFactory(target: any): boolean;
    isClass(target: any): boolean;
    isValue(target: any): boolean;
};
export declare abstract class BaseDIContainer<ID extends ScopeID = string, SCOPE extends any = any> implements IDIContainer<ID, SCOPE> {
    private sections;
    private map;
    private sorted;
    private configs;
    readonly count: number;
    /**
     * 变量池，用来实现范围模式
     * @description
     * @protected
     * @memberof DIContainer
     */
    protected scopePools: Map<ID, DIScopePool<ID>>;
    abstract register<K, V, DEPTS extends any[] = []>(configs: IRegisterConfig<K, V, ID, DEPTS>): void;
    abstract createFactory<T>(imp: DIContainerEntry<T>): ImplementBasicFactory<T, ID>;
    constructor(configs?: Partial<IContainerConfigs>);
    /**
     * 添加一个token-实现映射
     * @description
     * @author Big Mogician
     * @protected
     * @template T
     * @param {InjectToken<T>} token
     * @param {DepedencyResolveEntry<T>} entry
     * @memberof DIContainer
     */
    protected set<T>(token: InjectToken<T>, entry: DepedencyResolveEntry<T>): void;
    resetConfigs(configs: Partial<IContainerConfigs>): this;
    private emitMessage;
    complete(): void;
    createScope(scopeId: ID, metadata: SCOPE): void;
    dispose(scopeId?: ID): void;
    /**
     * 解析单个token
     * @description
     * @author Big Mogician
     * @template T
     * @param {InjectToken<T>} token
     * @param {ID} [scopeId]
     * @returns {(T | null)}
     * @memberof DIContainer
     */
    get<T>(token: InjectToken<T>, scopeId?: ID): T;
    /**
     * 获取最终DI容器的整体信息
     * @description
     * @author Big Mogician
     * @returns
     * @memberof DIContainer
     */
    getConfig(): {
        contract: any;
        implement: any;
        scope: InjectScope;
        level: number;
        dependencies: any[];
    }[];
    /**
     * 将依赖令牌数组解析成最终的依赖项数组
     * @description
     * @author Big Mogician
     * @template T
     * @param {InjectToken<any>[]} depts
     * @param {ID} scopeId
     * @returns
     * @memberof DIContainer
     */
    getDepedencies<T>(depts: InjectToken<any>[], scopeId?: ID): any[];
    /**
     * 执行依赖处理程序，构建整个DI容器
     * @description
     * @author Big Mogician
     * @private
     * @memberof DIContainer
     */
    private resolve;
    /**
     * 为可监控依赖变化的注入单例初始化工厂函数
     * * 如有必要的话- -
     * @param item
     * @param func
     */
    private wrapWatchableSingleton;
    private createWatchableSinglton;
    /**
     * 依赖算法
     * ---
     * * 将依赖项按照依赖级别从低到高排列
     * * 每个实例的依赖项级别一定低于自身
     * * 最终无法被排列的内容，可能存在循环引用，或者不可达引用，可以继续分析
     * @description
     * @author Big Mogician
     * @private
     * @param {DeptNode[]} queue
     * @returns {DeptNode[]}
     * @memberof DIContainer
     */
    private sort;
    /**
     * 完成依赖堆叠的排列
     * @description
     * @author Big Mogician
     * @private
     * @param {DeptNode[]} queue
     * @param {DeptNode[]} sourceQueue
     * @param {Array<DeptNode[]>} sections
     * @param {number} current
     * @returns
     * @memberof DIContainer
     */
    private decideSection;
    /**
     * 依次递归解析下一层级的依赖信息
     *
     * @author Big Mogician
     * @private
     * @param {DeptNode} node
     * @param {Array<DeptNode[]>} sections
     * @param {number} checkIndex
     * @param {DeptNode[]} sourceQueue
     * @memberof BaseDIContainer
     */
    private resolveUnder;
    /**
     * 按照scope处理工厂方法
     * @description
     * @author Big Mogician
     * @private
     * @template T
     * @param {DIContainerEntry<T>} item
     * @param {ImplementBasicFactory<T, ID>} fac
     * @returns {(Nullable<(scopeId?: ID) => T | null>)}
     * @memberof DIContainer
     */
    private scopeMark;
}
export declare function invalidOperation(error: string, more?: any): Error;
export declare function ERROR(error: string, more?: any): Error;