import { ComponentType } from 'react';
import { ModuleId, ModuleBoundaryConfig, ModuleRegistryEntry, ModuleQueryOptions, ModuleSecurityConfig, HydrationConfig } from './types';
/**
 * HMR update handler type.
 */
export type HMRUpdateHandler = (moduleId: ModuleId, newComponent: ComponentType<unknown>) => void;
/**
 * Module registration options.
 */
export interface ModuleRegistrationOptions {
    /** Dynamic import function for lazy loading */
    loader?: () => Promise<{
        default: ComponentType<unknown>;
    }>;
    /** Component if already loaded */
    component?: ComponentType<unknown>;
    /** Enable HMR support */
    hmrEnabled?: boolean;
    /** Module priority for loading */
    priority?: number;
    /** Prefetch hint */
    prefetch?: boolean;
}
/**
 * Dependency resolution result.
 */
export interface DependencyResolutionResult {
    /** Resolved modules in topological order */
    resolved: ModuleId[];
    /** Modules that failed to resolve */
    failed: Array<{
        moduleId: ModuleId;
        reason: string;
    }>;
    /** Circular dependency chains detected */
    circularDependencies: ModuleId[][];
}
/**
 * Central registry for module management.
 * Handles registration, dependency resolution, and HMR.
 *
 * @example
 * ```typescript
 * const registry = new ModuleRegistry();
 *
 * // Register a module
 * registry.register({
 *   id: createModuleId('my-module'),
 *   name: 'My Module',
 * }, {
 *   loader: () => import('./MyModule'),
 * });
 *
 * // Get module component
 * const component = await registry.getComponent(createModuleId('my-module'));
 * ```
 */
export declare class ModuleRegistry {
    /** Registered modules */
    private readonly modules;
    /** HMR update handlers */
    private readonly hmrHandlers;
    /** Dependency graph (moduleId -> dependsOn) */
    private readonly dependencyGraph;
    /** Reverse dependency graph (moduleId -> dependedOnBy) */
    private readonly reverseDependencyGraph;
    /** Module load promises for deduplication */
    private readonly loadPromises;
    /** Module versions (for HMR) */
    private readonly moduleVersions;
    /**
     * Gets the count of registered modules.
     */
    get size(): number;
    /**
     * Registers a module with the registry.
     * @param config - Module configuration
     * @param options - Registration options
     * @returns Whether registration was successful
     */
    register(config: ModuleBoundaryConfig, options?: ModuleRegistrationOptions): boolean;
    /**
     * Unregisters a module from the registry.
     * @param moduleId - Module to unregister
     * @returns Whether unregistration was successful
     */
    unregister(moduleId: ModuleId): boolean;
    /**
     * Checks if a module is registered.
     * @param moduleId - Module ID to check
     */
    has(moduleId: ModuleId): boolean;
    /**
     * Gets a module entry.
     * @param moduleId - Module ID
     * @returns Module entry or null
     */
    get(moduleId: ModuleId): ModuleRegistryEntry | null;
    /**
     * Gets module configuration.
     * @param moduleId - Module ID
     * @returns Module configuration or null
     */
    getConfig(moduleId: ModuleId): ModuleBoundaryConfig | null;
    /**
     * Gets or loads a module's component.
     * @param moduleId - Module ID
     * @returns Component or null if not found
     */
    getComponent(moduleId: ModuleId): Promise<ComponentType<unknown> | null>;
    /**
     * Preloads a module's component.
     * @param moduleId - Module ID
     */
    preload(moduleId: ModuleId): Promise<void>;
    /**
     * Preloads multiple modules.
     * @param moduleIds - Module IDs to preload
     */
    preloadMany(moduleIds: ModuleId[]): Promise<void>;
    /**
     * Resolves dependencies for a module using topological sort.
     * @param moduleId - Root module ID
     * @param options - Resolution options
     * @returns Resolution result
     */
    resolveDependencies(moduleId: ModuleId, options?: {
        maxDepth?: number;
        includeOptional?: boolean;
    }): DependencyResolutionResult;
    /**
     * Gets modules that depend on a given module.
     * @param moduleId - Module ID
     * @returns Array of dependent module IDs
     */
    getDependents(moduleId: ModuleId): ModuleId[];
    /**
     * Gets modules that a given module depends on.
     * @param moduleId - Module ID
     * @returns Array of dependency module IDs
     */
    getDependencies(moduleId: ModuleId): ModuleId[];
    /**
     * Registers an HMR update handler.
     * @param handler - Update handler
     * @returns Unsubscribe function
     */
    onHMRUpdate(handler: HMRUpdateHandler): () => void;
    /**
     * Handles an HMR update for a module.
     * @param moduleId - Module that was updated
     * @param newComponent - New component
     */
    handleHMRUpdate(moduleId: ModuleId, newComponent: ComponentType<unknown>): void;
    /**
     * Gets the current version of a module.
     * @param moduleId - Module ID
     * @returns Version number
     */
    getVersion(moduleId: ModuleId): number;
    /**
     * Queries modules based on criteria.
     * @param options - Query options
     * @returns Matching module entries
     */
    query(options?: ModuleQueryOptions): ModuleRegistryEntry[];
    /**
     * Gets all registered module IDs.
     * @returns Array of module IDs
     */
    getAllModuleIds(): ModuleId[];
    /**
     * Clears all registered modules.
     */
    clear(): void;
    /**
     * Exports registry state for debugging.
     * @returns Registry state object
     */
    exportState(): {
        modules: Array<{
            id: ModuleId;
            name: string;
            loadingState: string;
            accessCount: number;
        }>;
        dependencyGraph: Record<string, string[]>;
    };
    /**
     * Updates the dependency graph for a module.
     * @param config - Module configuration
     */
    private updateDependencyGraph;
}
/**
 * Gets the default global module registry.
 * @returns Default ModuleRegistry instance
 */
export declare function getDefaultRegistry(): ModuleRegistry;
/**
 * Sets the default global module registry.
 * @param registry - Registry to set as default
 */
export declare function setDefaultRegistry(registry: ModuleRegistry): void;
/**
 * Resets the default global module registry.
 */
export declare function resetDefaultRegistry(): void;
/**
 * Registers a module with the default registry.
 * @param config - Module configuration
 * @param options - Registration options
 * @returns Whether registration was successful
 */
export declare function registerModule(config: ModuleBoundaryConfig, options?: ModuleRegistrationOptions): boolean;
/**
 * Gets a module component from the default registry.
 * @param moduleId - Module ID
 * @returns Component or null
 */
export declare function getModuleComponent(moduleId: ModuleId): Promise<ComponentType<unknown> | null>;
/**
 * Creates a module registration helper with builder pattern.
 *
 * @example
 * ```typescript
 * const registration = createModuleRegistration('my-module', 'My Module')
 *   .withLoader(() => import('./MyModule'))
 *   .withDependency('other-module')
 *   .withHMR()
 *   .register();
 * ```
 */
type ModuleRegistrationBuilder = {
    withLoader: (loader: () => Promise<{
        default: ComponentType<unknown>;
    }>) => ModuleRegistrationBuilder;
    withComponent: (component: ComponentType<unknown>) => ModuleRegistrationBuilder;
    withDependency: (moduleId: ModuleId, required?: boolean) => ModuleRegistrationBuilder;
    withSecurity: (security: Partial<ModuleSecurityConfig>) => ModuleRegistrationBuilder;
    withHydration: (hydration: Partial<HydrationConfig>) => ModuleRegistrationBuilder;
    withHMR: (enabled?: boolean) => ModuleRegistrationBuilder;
    withVersion: (version: string) => ModuleRegistrationBuilder;
    register: (registry?: ModuleRegistry) => boolean;
};
export declare function createModuleRegistration(id: string, name: string): ModuleRegistrationBuilder;
export {};