import { type InterfaceConnectionRef, InterfaceRegistry } from "./interface-registry";
import { Module } from "./module";
import type { ModuleManifest } from "./module-manifest";
import { ModuleRegistry } from "./module-registry";
import { ModuleTracker } from "./module-tracker";
import type { UnresolvedInterface } from "./resolution/interface-resolution";
import { Resolver } from "./resolution/resolver";
export interface ModuleConfig {
    config?: unknown;
    importOverrides?: Map<string, InterfaceConnectionRef[]>;
    disabledExports?: Set<string>;
}
export interface ManagedModule {
    module: Module;
    config: ModuleConfig;
}
interface ModuleManagerDeps {
    registry?: ModuleRegistry;
    resolver?: Resolver;
    interfaceRegistry?: InterfaceRegistry;
    moduleTracker?: ModuleTracker;
}
export declare class ModuleManager {
    readonly registry: ModuleRegistry;
    readonly resolver: Resolver;
    private readonly interfaceRegistry;
    private readonly moduleTracker;
    private readonly resolverDetour;
    private readonly resolvedAssociations;
    private readonly staticModules;
    private readonly loaded;
    private readonly stubbedInterfacePaths;
    private startupOrder;
    constructor(deps?: ModuleManagerDeps);
    addStaticModule(entry: {
        manifest: ModuleManifest;
        config?: ModuleConfig;
    }): void;
    addModules(entries: Array<{
        manifest: ModuleManifest;
        config?: ModuleConfig;
    }>): ManagedModule[];
    listModules(): string[];
    getModule(id: string): Module | undefined;
    getModuleEntry(id: string): ManagedModule | undefined;
    getLoadedModuleEntry(id: string): ManagedModule | undefined;
    getLoadedModules(): IterableIterator<ManagedModule>;
    getAllManagedModules(): ManagedModule[];
    unrequireModuleFiles(moduleId: string): void;
    replaceLoadedModule(id: string, module: Module): ManagedModule | undefined;
    refreshAssociations(): void;
    hasResolvedInterface(moduleId: string, interfaceName: string): boolean;
    registerStubbedInterfaces(stubbed: UnresolvedInterface[]): void;
    private resolveInterfacePackageRoot;
    private applyInterfaceStubs;
    private collectImplementedInterfaces;
    constructAll(): Promise<void>;
    constructModules(modules: ManagedModule[]): Promise<void>;
    startAll(): void;
    startModules(modules: ManagedModule[]): void;
    stopAll(): Promise<void>;
    destroyAll(): Promise<void>;
    private trackModuleStart;
    private rebuildAssociations;
    private collectInterfaceSources;
    private resolveInterfacePackagePaths;
    private buildModuleAssociations;
    private addDefaultAssociations;
    private applyImportOverrides;
    private isPathWithin;
}
export {};