/**
 * Main server manager for MCP servers
 */
import { EventEmitter } from 'node:events';
import type { Client } from '@modelcontextprotocol/sdk/client/index.js';
import type { ManagerConfig, ServerConfig } from '../types/config.js';
import type { ServerStateSummary, ServerStatus } from '../types/state.js';
import type { LifecycleEvent, LifecycleEventMap, LifecycleEventType, ManagerEvent, ManagerEventMap, ManagerEventType } from '../types/events.js';
import { type LoggerFactory } from '../utils/logger.js';
/**
 * Options for ServerManager construction
 */
export interface ServerManagerOptions {
    /** Optional logger factory for custom logging */
    loggerFactory?: LoggerFactory;
    /** Whether to auto-start servers marked with autoStart: true (default: true) */
    autoStart?: boolean;
}
/**
 * Combined event map for the manager
 */
export type AllEventMap = LifecycleEventMap & ManagerEventMap;
export type AllEventType = LifecycleEventType | ManagerEventType;
/**
 * Main class for managing multiple MCP servers
 */
export declare class ServerManager extends EventEmitter {
    private config;
    private servers;
    private logger;
    private loggerFactory?;
    private started;
    private shuttingDown;
    constructor(config: ManagerConfig, options?: ServerManagerOptions);
    /**
     * Creates a ServerManager from a configuration file
     */
    static fromConfigFile(filePath: string, options?: ServerManagerOptions): Promise<ServerManager>;
    /**
     * Creates a ServerManager from a configuration object
     */
    static fromConfig(config: unknown, options?: ServerManagerOptions): ServerManager;
    /**
     * Initializes server lifecycle instances
     */
    private initializeServers;
    /**
     * Starts all servers configured for auto-start
     */
    start(): Promise<void>;
    /**
     * Stops all servers gracefully
     */
    shutdown(): Promise<void>;
    /**
     * Starts a specific server by name
     */
    startServer(name: string): Promise<void>;
    /**
     * Stops a specific server by name
     */
    stopServer(name: string): Promise<void>;
    /**
     * Restarts a specific server by name
     */
    restartServer(name: string): Promise<void>;
    /**
     * Gets the status of a specific server
     */
    getServerStatus(name: string): ServerStatus | undefined;
    /**
     * Gets the state summary for a specific server
     */
    getServerState(name: string): ServerStateSummary | undefined;
    /**
     * Gets state summaries for all servers
     */
    getAllServerStates(): ServerStateSummary[];
    /**
     * Gets the MCP client for a specific server
     */
    getClient(name: string): Client | null;
    /**
     * Gets all connected MCP clients
     */
    getConnectedClients(): Map<string, Client>;
    /**
     * Checks if a server is connected
     */
    isServerConnected(name: string): boolean;
    /**
     * Checks if all servers are connected
     */
    areAllServersConnected(): boolean;
    /**
     * Gets the list of server names
     */
    getServerNames(): string[];
    /**
     * Gets the number of managed servers
     */
    getServerCount(): number;
    /**
     * Adds a new server dynamically
     */
    addServer(config: ServerConfig): void;
    /**
     * Removes a server (must be stopped first)
     */
    removeServer(name: string): Promise<void>;
    /**
     * Emits a state snapshot event with current states of all servers
     */
    emitStateSnapshot(): void;
    /**
     * Emits a manager event
     */
    private emitManagerEvent;
    /**
     * Adds an event listener for lifecycle events.
     */
    onLifecycleEvent<T extends LifecycleEventType>(event: T, listener: (e: LifecycleEventMap[T]) => void): this;
    /**
     * Adds an event listener for manager events.
     */
    onManagerEvent<T extends ManagerEventType>(event: T, listener: (e: ManagerEventMap[T]) => void): this;
    /**
     * Adds a listener for all lifecycle events.
     */
    onAnyLifecycleEvent(listener: (e: LifecycleEvent) => void): this;
    /**
     * Adds a listener for all manager events.
     */
    onAnyManagerEvent(listener: (e: ManagerEvent) => void): this;
    /**
     * Adds a one-time event listener for lifecycle events.
     */
    onceLifecycleEvent<T extends LifecycleEventType>(event: T, listener: (e: LifecycleEventMap[T]) => void): this;
    /**
     * Adds a one-time event listener for manager events.
     */
    onceManagerEvent<T extends ManagerEventType>(event: T, listener: (e: ManagerEventMap[T]) => void): this;
}
//# sourceMappingURL=server-manager.d.ts.map