/**
 * Dependency Injection Container - Manages module dependencies and lifecycle
 *
 * This module provides a simple dependency injection system for MCP modules
 */
import { Logger } from "./types.js";
export interface ServiceDefinition<T = unknown> {
    name: string;
    factory: (container: DIContainer) => T;
    singleton?: boolean;
    dependencies?: string[];
}
export interface ServiceInstance<T = unknown> {
    instance?: T;
    definition: ServiceDefinition<T>;
    initialized: boolean;
}
export declare class DIContainer {
    private services;
    private logger;
    constructor(logger: Logger);
    /**
     * Register a service definition
     */
    register<T>(definition: ServiceDefinition<T>): void;
    /**
     * Register multiple services
     */
    registerServices(definitions: ServiceDefinition[]): void;
    /**
     * Get a service instance
     */
    get<T>(name: string): T;
    /**
     * Check if a service is registered
     */
    has(name: string): boolean;
    /**
     * Get all registered service names
     */
    getServiceNames(): string[];
    /**
     * Create a service instance with dependency resolution
     */
    private createInstance;
    /**
     * Clear all services (useful for testing)
     */
    clear(): void;
    /**
     * Get service statistics
     */
    getStats(): {
        totalServices: number;
        initializedServices: number;
        singletonServices: number;
    };
}
/**
 * Service factory for common MCP services
 */
export declare class MCPServiceFactory {
    /**
     * Create default MCP services
     */
    static createDefaultServices(logger: Logger): ServiceDefinition[];
    /**
     * Create custom service definition
     */
    static createService<T>(name: string, factory: (container: DIContainer) => T, options?: {
        singleton?: boolean;
        dependencies?: string[];
    }): ServiceDefinition<T>;
}
/**
 * Service locator pattern implementation
 */
export declare class ServiceLocator {
    private static container;
    /**
     * Initialize the service locator with a container
     */
    static initialize(container: DIContainer): void;
    /**
     * Get a service from the global container
     */
    static get<T>(name: string): T;
    /**
     * Check if a service exists
     */
    static has(name: string): boolean;
    /**
     * Clear the global container
     */
    static clear(): void;
}
//# sourceMappingURL=dependency-injection.d.ts.map