/**
 * Server lifecycle state machine for MCP servers
 */
import { EventEmitter } from 'node:events';
import { Client } from '@modelcontextprotocol/sdk/client/index.js';
import type { ServerConfig, LifecycleConfig } from '../types/config.js';
import type { ServerState, ServerStatus, ServerStateSummary } from '../types/state.js';
import type { LifecycleEvent, LifecycleEventMap } from '../types/events.js';
import { type Logger } from '../utils/logger.js';
/**
 * Manages the complete lifecycle of a single MCP server
 */
export declare class ServerLifecycle extends EventEmitter {
    readonly name: string;
    private config;
    private lifecycleConfig;
    private logger;
    private state;
    private client;
    private transport;
    private processManager;
    private httpConnection;
    private healthMonitor;
    private restartInProgress;
    private stopRequested;
    constructor(config: ServerConfig, globalDefaults?: LifecycleConfig, logger?: Logger);
    /**
     * Gets the current server state
     */
    getState(): ServerState;
    /**
     * Gets a summary of the current state
     */
    getStateSummary(): ServerStateSummary;
    /**
     * Gets the MCP client (if connected)
     */
    getClient(): Client | null;
    /**
     * Gets the current status
     */
    getStatus(): ServerStatus;
    /**
     * Starts the server connection
     */
    start(): Promise<void>;
    /**
     * Stops the server gracefully
     */
    stop(): Promise<void>;
    /**
     * Manually triggers a restart
     */
    restart(): Promise<void>;
    /**
     * Connects to the server
     */
    private connect;
    /**
     * Connects using stdio transport
     */
    private connectStdio;
    /**
     * Connects using HTTP transport
     */
    private connectHttp;
    /**
     * Handles process exit for stdio servers
     */
    private handleProcessExit;
    /**
     * Starts health monitoring
     */
    private startHealthMonitoring;
    /**
     * Handles a health check result
     */
    private handleHealthCheck;
    /**
     * Handles transition to unhealthy state
     */
    private handleUnhealthy;
    /**
     * Handles recovery from unhealthy state
     */
    private handleRecovered;
    /**
     * Performs a restart with backoff
     */
    private performRestart;
    /**
     * Transitions to a new status
     */
    private transitionTo;
    /**
     * Emits a lifecycle event
     */
    private emitEvent;
    /**
     * Adds an event listener for lifecycle events.
     * Use '*' to listen to all events.
     */
    onLifecycleEvent<T extends keyof LifecycleEventMap>(event: T, listener: (e: LifecycleEventMap[T]) => void): this;
    /**
     * Adds a one-time event listener for lifecycle events.
     */
    onceLifecycleEvent<T extends keyof LifecycleEventMap>(event: T, listener: (e: LifecycleEventMap[T]) => void): this;
    /**
     * Adds a listener for all lifecycle events.
     */
    onAnyEvent(listener: (e: LifecycleEvent) => void): this;
}
//# sourceMappingURL=server-lifecycle.d.ts.map