koatty_serve/dist/index.d.ts

Provide http1/2, websocket, gRPC server for Koatty.

/*!
* @Author: richen
* @Date: 2025-06-17 02:25:51
* @License: BSD (3-Clause)
* @Copyright (c) - <richenlin(at)gmail.com>
* @HomePage: https://koatty.org/
*/
/// <reference types="node" />

import { ChannelOptions } from '@grpc/grpc-js';
import EventEmitter from 'events';
import { Http2SecureServer } from 'http2';
import { Http2Session } from 'http2';
import { IncomingMessage } from 'http';
import { KoattyApplication } from 'koatty_core';
import { KoattyServer } from 'koatty_core';
import { NativeServer } from 'koatty_core';
import { Server } from '@grpc/grpc-js';
import { Server as Server_2 } from 'http';
import { Server as Server_3 } from 'https';
import { ServiceDefinition } from '@grpc/grpc-js';
import { Socket } from 'net';
import { TLSSocket } from 'tls';
import { UntypedHandleCall } from '@grpc/grpc-js';
import * as WS from 'ws';
import { ws } from 'ws';

/**
 * Base server class with template method pattern
 * 模板方法模式：定义算法骨架，子类实现具体步骤
 */
declare abstract class BaseServer<T extends BaseServerOptions = BaseServerOptions> implements KoattyServer {
    options: T;
    readonly server: any;
    readonly protocol: string;
    status: number;
    listenCallback?: () => void;
    constructor(app: KoattyApplication, options: T);
    /**
     * 模板方法：服务器初始化流程
     * 定义了所有协议服务器的通用初始化步骤
     */
    /**
     * 模板方法：配置热更新流程
     */
    updateConfig(newConfig: Partial<T>): Promise<boolean>;
    /**
     * 模板方法：优雅关闭流程
     * 现在使用统一的 GracefulShutdownManager 来处理关闭流程
     */
    gracefulShutdown(options?: GracefulShutdownOptions): Promise<ShutdownResult>;
    /**
     * 检测配置变更
     */
    /**
     * 设置连接池事件监听（公共逻辑）
     */
    /**
     * 设置定期清理（公共逻辑）
     */
    /**
     * 处理需要重启的配置变更
     */
    /**
     * 处理运行时配置变更
     */
    /**
     * 停止监控和清理（公共逻辑）
     */
    /**
     * 获取活跃连接数（公共逻辑）
     */
    /**
     * 获取连接统计信息（公共接口）
     */
    getConnectionStats(): ConnectionStats;
    /**
     * 获取连接池健康状态（公共接口）
     */
    getConnectionPoolHealth(): ConnectionPoolHealth;
    /**
     * 获取连接池指标（公共接口）
     */
    getConnectionPoolMetrics(): ConnectionPoolMetrics;
    /**
     * 初始化连接池（各协议自定义）
     */
    /**
     * 创建协议特定的服务器实例（各协议自定义）
     */
    /**
     * 配置服务器选项（各协议自定义）
     */
    /**
     * 协议特定的额外初始化（各协议自定义，可选实现）
     */
    /**
     * 分析配置变更影响（各协议自定义）
     */
    /**
     * 运行时配置变更处理（各协议自定义）
     */
    /**
     * 提取相关配置用于日志（各协议自定义）
     */
    /**
     * 停止接受新连接（各协议自定义）
     */
    /**
     * 等待现有连接完成（各协议自定义）
     */
    /**
     * 强制关闭剩余连接（各协议自定义）
     */
    /**
     * 强制关闭（各协议自定义）
     */
    /**
     * 启动服务器
     */
    abstract Start(listenCallback?: () => void): any;
    /**
     * 获取服务器状态
     */
    abstract getStatus(): number;
    /**
     * 获取原生服务器实例
     */
    abstract getNativeServer(): NativeServer;
    /**
     * 停止服务器（向后兼容）
     */
    Stop(callback?: (err?: Error) => void): void;
}

/**
 * Base Server Options
 *
 * @export
 * @interface BaseServerOptions
 * @extends {ListeningOptions}
 */
declare interface BaseServerOptions extends ListeningOptions {
    hostname: string;
    port: number;
    protocol: KoattyProtocol;
    trace?: boolean;
    ext?: Record<string, any>;
    connectionPool?: ConnectionPoolConfig;
}

/**
 * 基础SSL配置
 */
declare interface BaseSSLConfig {
    key?: string;
    cert?: string;
    ca?: string;
    passphrase?: string;
    ciphers?: string;
    honorCipherOrder?: boolean;
    secureProtocol?: string;
}

/**
 * Bind event to the process
 *
 * @param {EventEmitter} event
 * @param {string} originEventName
 * @param {string} [targetEventName]
 */
export declare function BindProcessEvent(event: EventEmitter, originEventName: string, targetEventName?: processEvent): void;

/**
 * Child logger with preset context
 */
declare class ChildLogger {
    constructor(parent: StructuredLogger, childContext: LogContext);
    debug(message: string, additionalContext?: LogContext, data?: any): void;
    info(message: string, additionalContext?: LogContext, data?: any): void;
    warn(message: string, additionalContext?: LogContext, data?: any): void;
    error(message: string, additionalContext?: LogContext, error?: Error | any): void;
    logServerEvent(event: 'starting' | 'started' | 'stopping' | 'stopped' | 'error', additionalContext?: LogContext, data?: any): void;
    logConnectionEvent(event: 'connected' | 'disconnected' | 'error' | 'timeout', additionalContext?: LogContext, data?: any): void;
    logSecurityEvent(event: 'auth_success' | 'auth_failure' | 'rate_limit' | 'blocked', additionalContext?: LogContext, data?: any): void;
    startPerformanceTracking(trackingId: string, additionalContext?: LogContext): void;
    endPerformanceTracking(trackingId: string, additionalContext?: LogContext): PerformanceMetrics | null;
}

/**
 * Configuration change detection result
 */
declare interface ConfigChangeAnalysis {
    requiresRestart: boolean;
    changedKeys: (keyof ListeningOptions)[];
    restartReason?: string;
    canApplyRuntime?: boolean;
}

/**
 * 统一连接池配置接口
 */
declare interface ConnectionPoolConfig {
    connectionTimeout?: number;
    maxConnections?: number;
    maxSessionMemory?: number;
    maxHeaderListSize?: number;
    keepAliveTimeout?: number;
    headersTimeout?: number;
    requestTimeout?: number;
    pingInterval?: number;
    pongTimeout?: number;
    heartbeatInterval?: number;
    protocolSpecific?: {
        maxSessionMemory?: number;
        maxHeaderListSize?: number;
        maxReceiveMessageLength?: number;
        maxSendMessageLength?: number;
        keepAliveTime?: number;
        pingInterval?: number;
        pongTimeout?: number;
        heartbeatInterval?: number;
    };
}

/**
 * Connection pool event types
 */
declare enum ConnectionPoolEvent {
    CONNECTION_ADDED = "connection_added",
    CONNECTION_REMOVED = "connection_removed",
    CONNECTION_TIMEOUT = "connection_timeout",
    CONNECTION_ERROR = "connection_error",
    POOL_LIMIT_REACHED = "pool_limit_reached",
    HEALTH_STATUS_CHANGED = "health_status_changed"
}

/**
 * 连接池健康状态
 */
declare interface ConnectionPoolHealth {
    status: ConnectionPoolStatus;
    utilizationRatio: number;
    activeConnections: number;
    maxConnections: number;
    rejectedConnections: number;
    averageResponseTime: number;
    errorRate: number;
    message: string;
    lastUpdated: number;
}

/**
 * Abstract connection pool manager
 */
declare abstract class ConnectionPoolManager<T = any> {
    protected waitingQueue: Array<{
        resolve: (result: ConnectionRequestResult<T>) => void;
        reject: (error: Error) => void;
        options: ConnectionRequestOptions;
        timestamp: number;
    }>;
    constructor(protocol: string, config?: ConnectionPoolConfig);
    /**
     * 初始化指标
     */
    /**
     * 初始化健康状态
     */
    /**
     * Validate and normalize configuration
     */
    /**
     * 申请连接
     */
    requestConnection(options?: ConnectionRequestOptions): Promise<ConnectionRequestResult<T>>;
    /**
     * 释放连接
     */
    releaseConnection(connection: T, options?: {
        destroy?: boolean;
        error?: Error;
    }): Promise<boolean>;
    /**
     * Add connection to the pool
     */
    addConnection(connection: T, metadata?: any): Promise<boolean>;
    /**
     * Remove connection from pool
     */
    removeConnection(connection: T, reason?: string): Promise<void>;
    /**
     * Get active connection count
     */
    getActiveConnectionCount(): number;
    /**
     * Check if the connection is healthy
     */
    abstract isConnectionHealthy(connection: T): boolean;
    /**
     * Close all connections
     */
    closeAllConnections(timeout?: number): Promise<void>;
    /**
     * Protocol-specific connection validation
     */
    /**
     * Protocol-specific connection cleanup
     */
    /**
     * 获取可用连接
     */
    protected abstract getAvailableConnection(): Promise<{
        connection: T;
        id: string;
    } | null>;
    /**
     * 创建新连接
     */
    protected createNewConnection(options: ConnectionRequestOptions): Promise<{
        connection: T;
        id: string;
        metadata?: any;
    } | null>;
    /**
     * Check if new connections can be accepted
     */
    canAcceptConnection(): boolean;
    /**
     * Update connection pool health status
     */
    updateHealthStatus(): void;
    /**
     * Get connection pool health status
     */
    getHealth(): ConnectionPoolHealth;
    /**
     * Get connection pool metrics
     */
    getMetrics(): ConnectionPoolMetrics;
    /**
     * Get connection pool configuration
     */
    getConfig(): Readonly<ConnectionPoolConfig>;
    /**
     * Update connection pool configuration
     */
    updateConfig(newConfig: Partial<ConnectionPoolConfig>): Promise<boolean>;
    /**
     * Add event listener
     */
    on(event: ConnectionPoolEvent, listener: Function): void;
    /**
     * Remove event listener
     */
    off(event: ConnectionPoolEvent, listener: Function): void;
    /**
     * 辅助方法
     */
    /**
     * 设置统一监控
     */
    /**
     * Trigger event
     */
    /**
     * Record connection event for statistics
     */
    /**
     * Record request latency
     */
    /**
     * Destroy connection pool manager
     */
    destroy(): Promise<void>;
    /**
     * 统一的连接获取接口 - 对外提供统一API
     */
    getConnection(options?: ConnectionRequestOptions): Promise<ConnectionRequestResult<T>>;
    /**
     * 统一的连接添加接口 - 协议无关的连接注册
     * 各协议通过此方法注册新连接到池中
     */
    registerConnection(connection: T, metadata?: any): Promise<boolean>;
    /**
     * 协议特定的连接处理器设置 - 子类实现
     */
    /**
     * 协议特定的连接创建逻辑 - 子类实现
     */
    protected abstract createProtocolConnection(options: ConnectionRequestOptions): Promise<{
        connection: T;
        metadata?: any;
    } | null>;
}

/**
 * 连接池指标
 */
declare interface ConnectionPoolMetrics extends ConnectionStats {
    protocol: string;
    poolConfig: ConnectionPoolConfig;
    health: ConnectionPoolHealth;
    performance: {
        throughput: number;
        latency: {
            p50: number;
            p95: number;
            p99: number;
        };
        memoryUsage: number;
        cpuUsage: number;
    };
    uptime: number;
}

/**
 * 连接池状态枚举
 */
declare enum ConnectionPoolStatus {
    HEALTHY = "healthy",
    DEGRADED = "degraded",
    OVERLOADED = "overloaded",
    UNAVAILABLE = "unavailable"
}

/**
 * 连接申请选项
 */
declare interface ConnectionRequestOptions {
    timeout?: number;
    priority?: 'low' | 'normal' | 'high';
    metadata?: Record<string, any>;
}

/**
 * 连接申请结果
 */
declare interface ConnectionRequestResult<T> {
    connection: T | null;
    success: boolean;
    error?: Error;
    waitTime: number;
    connectionId?: string;
}

/**
 * 连接统计信息接口
 */
declare interface ConnectionStats {
    activeConnections: number;
    totalConnections: number;
    connectionsPerSecond: number;
    averageLatency: number;
    errorRate: number;
}

/**
 * Create terminus event
 *
 * @export
 * @param {KoattyApplication} app
 * @param {(Server | Http2SecureServer)} server
 * @param {TerminusOptions} [options]
 */
export declare function CreateTerminus(app: KoattyApplication, server: KoattyServer, options?: TerminusOptions): void;

/**
 * 优雅关闭管理器
 * 提供统一的优雅关闭流程管理，支持多步骤关闭和详细状态跟踪
 *
 * 性能优化：
 * - 移除不必要的 TimerManager 依赖
 * - 优化日志记录频率
 * - 统一超时机制
 */
declare class GracefulShutdownManager {
    constructor(protocol: string);
    /**
     * 检查是否正在关闭中
     */
    isInShutdown(): boolean;
    /**
     * 获取当前关闭状态
     */
    getStatus(): ShutdownStatus;
    /**
     * 执行优雅关闭流程
     * 优化：减少日志记录频率，统一错误处理
     */
    performGracefulShutdown(steps: ShutdownStep[], options?: GracefulShutdownOptions): Promise<ShutdownResult>;
    /**
     * 执行单个关闭步骤
     */
    /**
     * 执行排空延迟
     */
    /**
     * 设置强制关闭定时器（已优化，移除不必要的实现）
     */
    /**
     * 带超时的执行函数
     */
    /**
     * 创建失败结果
     */
    /**
     * 清理资源
     */
    /**
     * 执行各个关闭步骤
     */
    /**
     * 执行全局超时控制
     */
}

/**
 * 优雅关闭选项
 */
declare interface GracefulShutdownOptions {
    timeout?: number;
    drainDelay?: number;
    stepTimeout?: number;
    forceTimeout?: number;
    steps?: ShutdownStep[];
}

/**
 * 简化的gRPC连接接口
 */
declare interface GrpcConnection {
    id: string;
    peer: string;
    metadata: any;
    cancelled: boolean;
    deadline?: Date;
    [key: string]: any;
}

/**
 * gRPC连接池管理器
 */
declare class GrpcConnectionPoolManager extends ConnectionPoolManager<GrpcConnection> {
    constructor(config?: ConnectionPoolConfig);
    /**
     * 注册gRPC特定的清理任务到统一监控器
     */
    /**
     * 验证gRPC连接
     */
    /**
     * 清理gRPC连接
     */
    /**
     * 获取可用连接
     */
    protected getAvailableConnection(): Promise<{
        connection: GrpcConnection;
        id: string;
    } | null>;
    /**
     * 检查连接是否健康
     */
    isConnectionHealthy(connection: GrpcConnection): boolean;
    /**
     * 添加gRPC连接（由服务器调用）
     */
    addGrpcConnection(peer: string, callMetadata?: any): Promise<boolean>;
    /**
     * 设置连接事件处理器
     */
    /**
     * 处理gRPC调用完成
     */
    handleCallComplete(connection: GrpcConnection, success: boolean): Promise<void>;
    /**
     * 更新调用指标
     */
    /**
     * 判断是否为一元调用
     */
    /**
     * 处理流响应发送
     */
    handleStreamResponse(connection: GrpcConnection, data: any): Promise<void>;
    /**
     * 清理过期连接
     */
    /**
     * 获取连接统计信息
     */
    getConnectionStats(): {
        grpcSpecific: {
            totalCalls: number;
            totalErrors: number;
            totalStreams: number;
            activeStreams: number;
            totalBytesReceived: number;
            totalBytesSent: number;
            errorRate: number;
            callMetrics: {
                totalUnarycalls: number;
                totalStreamingCalls: number;
                totalErrors: number;
                averageCallDuration: number;
                activeStreams: number;
            };
        };
        protocol: string;
        poolConfig: ConnectionPoolConfig;
        health: ConnectionPoolHealth;
        performance: {
            throughput: number;
            latency: {
                p50: number;
                /**
                 * 验证gRPC连接
                 */
                p95: number;
                p99: number;
            };
            memoryUsage: number;
            cpuUsage: number;
        };
        uptime: number;
        activeConnections: number;
        totalConnections: number;
        connectionsPerSecond: number;
        averageLatency: number;
        errorRate: number;
    };
    /**
     * 获取gRPC特定指标
     */
    getGrpcMetrics(): {
        connections: {
            id: any;
            peer: any;
            callCount: any;
            errorCount: any;
            streamCount: any;
            activeStreams: any;
            totalBytesReceived: any;
            totalBytesSent: any;
            age: number;
            idle: number;
        }[];
        totalUnarycalls: number;
        totalStreamingCalls: number;
        totalErrors: number;
        averageCallDuration: number;
        activeStreams: number;
    };
    /**
     * 找到连接ID的辅助方法
     */
    /**
     * 创建连接ID
     */
    /**
     * 销毁连接池
     */
    destroy(): Promise<void>;
    /**
     * 协议特定的连接处理器设置
     */
    /**
     * 协议特定的连接创建逻辑
     */
    protected createProtocolConnection(_options: ConnectionRequestOptions): Promise<{
        connection: GrpcConnection;
        metadata?: any;
    } | null>;
}

export declare class GrpcServer extends BaseServer<GrpcServerOptions> {
    readonly server: Server;
    options: GrpcServerOptions;
    constructor(app: KoattyApplication, options: GrpcServerOptions);
    /**
     * 初始化gRPC连接池
     */
    /**
     * 创建gRPC服务器实例
     */
    /**
     * 配置gRPC服务器选项
     */
    /**
     * gRPC特定的额外初始化
     */
    protected extractRelevantConfig(config: GrpcServerOptions): {
        hostname: string;
        port: number;
        protocol: KoattyProtocol;
        sslEnabled: boolean;
        connectionPool: {
            maxConnections: number;
            keepAliveTime: number;
            keepAliveTimeout: number;
        };
    };
    /**
     * Create SSL credentials from configuration
     * @private
     */
    /**
     * Start Server with enhanced connection management
     */
    Start(listenCallback?: () => void): NativeServer;
    /**
     * Start connection monitoring and statistics collection
     * @private
     */
    /**
     * Register Service with enhanced logging and monitoring
     */
    RegisterService(impl: ServiceImplementation): void;
    /**
     * Get connection statistics
     */
    getConnectionStats(): ConnectionStats;
    /**
     * Get connection pool health
     */
    getConnectionPoolHealth(): ConnectionPoolHealth;
    /**
     * Get connection pool metrics
     */
    getConnectionPoolMetrics(): ConnectionPoolMetrics;
    /**
     * Get status
     */
    getStatus(): number;
    /**
     * Get native server
     */
    getNativeServer(): NativeServer;
    /**
     * 提取连接池配置
     */
}

/**
 * gRPC Server Options with enhanced configuration
 *
 * @export
 * @interface GrpcServerOptions
 * @extends {ListeningOptions}
 */
declare interface GrpcServerOptions extends BaseServerOptions {
    channelOptions?: ChannelOptions;
    ssl?: SSLConfig;
    connectionPool?: ConnectionPoolConfig;
    ext?: {
        key?: string;
        cert?: string;
        ca?: string;
        [key: string]: any;
    };
}

/**
 * HTTP/2连接池管理器
 */
declare class Http2ConnectionPoolManager extends ConnectionPoolManager<Http2Session> {
    constructor(config?: ConnectionPoolConfig);
    /**
     * 验证HTTP/2会话
     */
    /**
     * 清理HTTP/2会话
     */
    /**
     * 获取可用会话
     */
    protected getAvailableConnection(): Promise<{
        connection: Http2Session;
        id: string;
    } | null>;
    /**
     * 创建新连接 - HTTP/2会话通常是被动接受的
     */
    protected createNewConnection(_options: ConnectionRequestOptions): Promise<{
        connection: Http2Session;
        id: string;
        metadata?: any;
    } | null>;
    /**
     * 检查会话是否健康
     */
    isConnectionHealthy(session: Http2Session): boolean;
    /**
     * 添加HTTP/2会话（由服务器调用）
     */
    addHttp2Session(session: Http2Session): Promise<boolean>;
    /**
     * 设置会话事件处理器
     */
    /**
     * 处理新流
     */
    /**
     * 启动会话ping（保留在TimerManager中，因为是动态创建的）
     */
    /**
     * 注册HTTP/2监控任务到统一监控器
     */
    /**
     * 向所有会话发送ping
     */
    /**
     * 执行健康检查
     */
    /**
     * 获取会话统计信息
     */
    getConnectionStats(): {
        availableSessions: number;
        goingAwaySessions: number;
        totalActiveStreams: number;
        totalStreams: number;
        totalStreamErrors: number;
        averageStreamsPerSession: number;
        utilizationRatio: number;
        protocol: string;
        poolConfig: ConnectionPoolConfig;
        health: ConnectionPoolHealth;
        performance: {
            throughput: number;
            latency: {
                p50: number;
                p95: number;
                p99: number;
            };
            memoryUsage: number;
            cpuUsage: number;
        };
        uptime: number;
        activeConnections: number;
        totalConnections: number;
        connectionsPerSecond: number;
        averageLatency: number;
        errorRate: number;
    };
    /**
     * 获取会话详细信息
     */
    getSessionDetails(): Array<{
        id: string;
        remoteAddress: string;
        protocol: string;
        activeStreams: number;
        totalStreams: number;
        streamErrors: number;
        maxConcurrentStreams: number;
        isGoingAway: boolean;
        age: number;
        idle: number;
    }>;
    /**
     * 优雅关闭会话
     */
    gracefulCloseSession(session: Http2Session, timeout?: number): Promise<void>;
    /**
     * 找到会话ID的辅助方法
     */
    /**
     * 销毁连接池
     */
    destroy(): Promise<void>;
    /**
     * 设置协议特定的连接处理器
     */
    /**
     * 协议特定的连接创建逻辑
     */
    protected createProtocolConnection(_options: ConnectionRequestOptions): Promise<{
        connection: Http2Session;
        metadata?: any;
    } | null>;
}

/**
 * HTTP/2 Server implementation using template method pattern
 * 继承BaseServer，只实现HTTP/2特定的逻辑
 */
export declare class Http2Server extends BaseServer<Http2ServerOptions> {
    readonly server: Http2SecureServer;
    constructor(app: KoattyApplication, options: Http2ServerOptions);
    /**
     * 初始化HTTP/2连接池
     */
    /**
     * 创建HTTP/2服务器实例
     */
    /**
     * 配置HTTP/2服务器选项
     */
    /**
     * HTTP/2特定的额外初始化
     */
    /**
     * 创建HTTP/2选项
     */
    /**
     * 创建SSL选项
     */
    /**
     * 自动SSL配置
     */
    /**
     * 手动SSL配置
     */
    /**
     * 双向TLS配置
     */
    /**
     * 加载证书文件
     */
    /**
     * 设置会话处理
     */
    /**
     * 提取连接池配置
     */
    protected extractRelevantConfig(config: Http2ServerOptions): {
        hostname: string;
        port: number;
        protocol: KoattyProtocol;
        sslMode: "auto" | "manual" | "mutual_tls";
        allowHTTP1: boolean;
        connectionPool: {
            maxConnections: number;
            maxSessionMemory: number;
            maxHeaderListSize: number;
        };
        http2Settings: {
            headerTableSize?: number;
            enablePush?: boolean;
            maxConcurrentStreams?: number;
            initialWindowSize?: number;
            maxFrameSize?: number;
            maxHeaderListSize?: number;
        };
    };
    /**
     * 检查SSL配置是否变更
     */
    /**
     * 检查HTTP/2配置是否变更
     */
    /**
     * 检查连接池配置是否变更
     */
    /**
     * 重写停止监控和清理方法以处理HTTP/2特定的监控间隔
     */
    Start(listenCallback?: () => void): NativeServer;
    getStatus(): number;
    getNativeServer(): NativeServer;
    /**
     * 启动连接池监控
     */
    /**
     * 获取HTTP/2统计信息
     */
    getHttp2Stats(): {
        availableSessions: number;
        goingAwaySessions: number;
        totalActiveStreams: number;
        totalStreams: number;
        totalStreamErrors: number;
        averageStreamsPerSession: number;
        utilizationRatio: number;
        protocol: string;
        poolConfig: ConnectionPoolConfig;
        health: ConnectionPoolHealth;
        performance: {
            throughput: number;
            latency: {
                p50: number;
                p95: number;
                p99: number;
            };
            memoryUsage: number;
            cpuUsage: number;
        };
        uptime: number;
        activeConnections: number;
        totalConnections: number;
        connectionsPerSecond: number;
        averageLatency: number;
        errorRate: number;
    };
    /**
     * 获取当前连接状态
     */
    getConnectionsStatus(): {
        current: number;
        max: number;
    };
    /**
     * 销毁服务器
     */
    destroy(): Promise<void>;
}

/**
 * Enhanced HTTP/2 Server Options
 */
declare interface Http2ServerOptions extends BaseServerOptions {
    ssl?: SSL2Config;
    http2?: {
        maxHeaderListSize?: number;
        maxSessionMemory?: number;
        settings?: {
            headerTableSize?: number;
            enablePush?: boolean;
            maxConcurrentStreams?: number;
            initialWindowSize?: number;
            maxFrameSize?: number;
            maxHeaderListSize?: number;
        };
    };
    connectionPool?: ConnectionPoolConfig;
    ext?: {
        key?: string;
        cert?: string;
        ca?: string;
        [key: string]: any;
    };
}

/**
 * HTTP连接池管理器
 */
declare class HttpConnectionPoolManager extends ConnectionPoolManager<Socket> {
    constructor(config?: ConnectionPoolConfig);
    /**
     * 验证HTTP连接
     */
    /**
     * 清理HTTP连接
     */
    /**
     * 获取可用连接
     */
    protected getAvailableConnection(): Promise<{
        connection: Socket;
        id: string;
    } | null>;
    /**
     * 创建新连接
     */
    protected createNewConnection(_options: ConnectionRequestOptions): Promise<{
        connection: Socket;
        id: string;
        metadata?: any;
    } | null>;
    /**
     * 检查连接是否健康
     */
    isConnectionHealthy(connection: Socket): boolean;
    /**
     * 添加HTTP连接（由服务器调用）
     */
    addHttpConnection(connection: Socket): Promise<boolean>;
    /**
     * 设置连接事件处理器
     */
    /**
     * 处理HTTP请求完成
     */
    handleRequestComplete(connection: Socket, bytesSent?: number): Promise<void>;
    /**
     * 注册HTTP特定的清理任务到统一监控器
     */
    /**
     * 清理空闲连接
     */
    /**
     * 获取连接统计信息
     */
    getConnectionStats(): {
        availableConnections: number;
        totalRequests: number;
        totalBytesSent: number;
        totalBytesReceived: number;
        httpsConnections: number;
        httpConnections: number;
        averageRequestsPerConnection: number;
        utilizationRatio: number;
        protocol: string;
        poolConfig: ConnectionPoolConfig;
        health: ConnectionPoolHealth;
        performance: {
            throughput: number;
            latency: {
                p50: number;
                p95: number;
                p99: number;
            };
            memoryUsage: number;
            cpuUsage: number;
        };
        uptime: number;
        activeConnections: number;
        totalConnections: number;
        connectionsPerSecond: number;
        averageLatency: number;
        errorRate: number;
    };
    /**
     * 设置Keep-Alive超时
     */
    setKeepAliveTimeout(timeout: number): void;
    /**
     * 获取连接详细信息
     */
    getConnectionDetails(): Array<{
        id: string;
        remoteAddress: string;
        protocol: string;
        requestCount: number;
        bytesSent: number;
        bytesReceived: number;
        age: number;
        idle: number;
    }>;
    /**
     * 找到连接ID的辅助方法
     */
    /**
     * 销毁连接池
     */
    destroy(): Promise<void>;
    /**
     * 协议特定的连接处理器设置
     */
    /**
     * 协议特定的连接创建逻辑
     */
    protected createProtocolConnection(_options: ConnectionRequestOptions): Promise<{
        connection: Socket;
        metadata?: any;
    } | null>;
}

/**
 * HTTPS连接池管理器
 */
declare class HttpsConnectionPoolManager extends ConnectionPoolManager<TLSSocket> {
    constructor(config?: ConnectionPoolConfig);
    /**
     * 验证HTTPS连接
     */
    /**
     * 清理HTTPS连接
     */
    /**
     * 获取可用连接
     */
    protected getAvailableConnection(): Promise<{
        connection: TLSSocket;
        id: string;
    } | null>;
    /**
     * 创建新连接
     */
    protected createNewConnection(_options: ConnectionRequestOptions): Promise<{
        connection: TLSSocket;
        id: string;
        metadata?: any;
    } | null>;
    /**
     * 检查连接是否健康
     */
    isConnectionHealthy(connection: TLSSocket): boolean;
    /**
     * 添加HTTPS连接（由服务器调用）
     */
    addHttpsConnection(connection: TLSSocket): Promise<boolean>;
    /**
     * 计算连接安全评分
     */
    /**
     * 更新安全指标
     */
    /**
     * 设置连接事件处理器
     */
    /**
     * 处理HTTPS请求完成
     */
    handleRequestComplete(connection: TLSSocket, bytesSent?: number): Promise<void>;
    /**
     * 注册HTTPS特定的清理任务到统一监控器
     */
    /**
     * 清理空闲连接
     */
    /**
     * 获取连接统计信息
     */
    getConnectionStats(): {
        security: {
            totalHandshakes: number;
            successfulHandshakes: number;
            failedHandshakes: number;
            averageHandshakeTime: number;
        };
        total: number;
        active: number;
        available: number;
        authorized: number;
        unauthorized: number;
        totalRequests: number;
        totalBytesSent: number;
        totalBytesReceived: number;
        averageSecurityScore: number;
        protocols: Record<string, number>;
        ciphers: Record<string, number>;
    };
    /**
     * 获取安全指标
     */
    getSecurityMetrics(): {
        connectionSecurityScores: {
            id: any;
            securityScore: any;
            authorized: any;
            cipher: any;
            protocol: any;
        }[];
        totalHandshakes: number;
        successfulHandshakes: number;
        failedHandshakes: number;
        averageHandshakeTime: number;
    };
    /**
     * 设置Keep-Alive超时
     */
    setKeepAliveTimeout(timeout: number): void;
    /**
     * 获取连接详情
     */
    getConnectionDetails(): Array<{
        id: string;
        remoteAddress: string;
        protocol: string;
        cipher: string;
        authorized: boolean;
        securityScore: number;
        requestCount: number;
        bytesSent: number;
        bytesReceived: number;
        age: number;
        idle: number;
    }>;
    /**
     * 查找HTTPS连接ID
     */
    /**
     * 销毁连接池
     */
    destroy(): Promise<void>;
    /**
     * 设置协议特定的连接处理器
     */
    /**
     * 协议特定的连接创建逻辑
     */
    protected createProtocolConnection(_options: ConnectionRequestOptions): Promise<{
        connection: TLSSocket;
        metadata?: any;
    } | null>;
}

/**
 * HTTP Server implementation using template method pattern
 * 继承BaseServer，只实现HTTP特定的逻辑
 */
export declare class HttpServer extends BaseServer<HttpServerOptions> {
    readonly server: Server_2;
    constructor(app: KoattyApplication, options: HttpServerOptions);
    /**
     * 初始化HTTP连接池
     */
    /**
     * 创建HTTP服务器实例
     */
    /**
     * 配置HTTP服务器选项
     */
    /**
     * HTTP特定的额外初始化
     */
    /**
     * 提取连接池配置
     */
    /**
     * 配置连接池设置
     */
    /**
     * 设置连接跟踪
     */
    protected extractRelevantConfig(config: HttpServerOptions): {
        hostname: string;
        port: number;
        protocol: KoattyProtocol;
        connectionPool: {
            maxConnections: number;
            keepAliveTimeout: number;
            headersTimeout: number;
            requestTimeout: number;
        };
    };
    /**
     * 检查连接池配置是否变更
     */
    Start(listenCallback?: () => void): NativeServer;
    getStatus(): number;
    getNativeServer(): NativeServer;
    /**
     * 启动连接池监控
     */
    /**
     * 获取HTTP连接统计信息
     */
    getHttpConnectionStats(): {
        availableConnections: number;
        totalRequests: number;
        totalBytesSent: number;
        totalBytesReceived: number;
        httpsConnections: number;
        httpConnections: number;
        averageRequestsPerConnection: number;
        utilizationRatio: number;
        protocol: string;
        poolConfig: ConnectionPoolConfig;
        health: ConnectionPoolHealth;
        performance: {
            throughput: number;
            latency: {
                p50: number;
                p95: number;
                p99: number;
            };
            memoryUsage: number;
            cpuUsage: number;
        };
        uptime: number;
        activeConnections: number;
        totalConnections: number;
        connectionsPerSecond: number;
        averageLatency: number;
        errorRate: number;
    };
}

/**
 * HTTP Server Options extending base options
 */
declare interface HttpServerOptions extends BaseServerOptions {
    connectionPool?: ConnectionPoolConfig;
}

/**
 * HTTPS Server implementation using template method pattern
 * 继承BaseServer，只实现HTTPS特定的逻辑
 */
export declare class HttpsServer extends BaseServer<HttpsServerOptions> {
    readonly server: Server_3;
    constructor(app: KoattyApplication, options: HttpsServerOptions);
    /**
     * 初始化HTTPS连接池
     */
    /**
     * 创建HTTPS服务器实例
     */
    /**
     * 配置HTTPS服务器选项
     */
    /**
     * HTTPS特定的额外初始化
     */
    /**
     * 创建SSL选项
     */
    /**
     * 自动SSL配置
     */
    /**
     * 手动SSL配置
     */
    /**
     * 双向TLS配置
     */
    /**
     * 加载证书文件
     */
    /**
     * 设置连接处理
     */
    /**
     * 记录请求
     */
    /**
     * 提取连接池配置
     */
    protected extractRelevantConfig(config: HttpsServerOptions): {
        hostname: string;
        port: number;
        protocol: KoattyProtocol;
        sslMode: "auto" | "manual" | "mutual_tls";
        connectionPool: {
            maxConnections: number;
            keepAliveTimeout: number;
            headersTimeout: number;
            requestTimeout: number;
        };
    };
    /**
     * 检查SSL配置是否变更
     */
    /**
     * 检查连接池配置是否变更
     */
    Start(listenCallback?: () => void): NativeServer;
    getStatus(): number;
    getNativeServer(): NativeServer;
    /**
     * 启动连接池监控
     */
    /**
     * 获取安全统计信息
     */
    getSecurityMetrics(): {
        sslMode: "auto" | "manual" | "mutual_tls";
        ciphers: string;
        secureProtocol: string;
        mutualTLS: boolean;
    };
    /**
     * 获取当前连接状态
     */
    getConnectionsStatus(): {
        current: number;
        max: number;
    };
    /**
     * 销毁服务器
     */
    destroy(): Promise<void>;
}

/**
 * Enhanced HTTPS Server Options
 */
declare interface HttpsServerOptions extends BaseServerOptions {
    ssl?: SSL1Config;
    connectionPool?: ConnectionPoolConfig;
    ext?: {
        key?: string;
        cert?: string;
        ca?: string;
        [key: string]: any;
    };
}

/**
 * Implementation
 *
 * @interface Implementation
 */
declare interface Implementation {
    [methodName: string]: UntypedHandleCall;
}

export declare type KoattyProtocol = 'http' | "https" | 'http2' | 'grpc' | 'ws' | 'wss';

/**
 * listening options
 *
 * @interface ListeningOptions
 */
export declare interface ListeningOptions {
    hostname: string;
    port: number;
    protocol: KoattyProtocol | KoattyProtocol[];
    trace?: boolean;
    ext?: Record<string, any>;
    connectionPool?: ConnectionPoolConfig;
}

/**
 * Log context interface
 */
declare interface LogContext {
    module?: string;
    protocol?: string;
    serverId?: string;
    connectionId?: string;
    requestId?: string;
    userId?: string;
    sessionId?: string;
    traceId?: string;
    action?: string;
    [key: string]: any;
}

/**
 * 监控统计信息
 */
declare interface MonitoringStats {
    tasksExecuted: number;
    tasksSuccessful: number;
    tasksFailed: number;
    lastExecutionTime: number;
    averageExecutionTime: number;
    uptime: number;
}

/**
 * 监控任务接口
 */
declare interface MonitoringTask {
    name: string;
    interval: number;
    priority: number;
    execute: () => Promise<void> | void;
    onError?: (error: Error) => void;
    enabled?: boolean;
    description?: string;
}

/**
 * Multi-protocol server manager
 */
export declare class MultiProtocolServer implements KoattyServer {
    readonly options: ListeningOptions;
    server?: NativeServer;
    constructor(app: KoattyApplication, opt: ListeningOptions);
    /**
     * Start all servers
     */
    Start(listenCallback?: () => void): NativeServer;
    /**
     * Stop all servers
     */
    Stop(callback?: () => void): void;
    /**
     * Register Service for gRPC server
     */
    RegisterService(impl: (...args: any[]) => any, protocolType?: KoattyProtocol, port?: number): void;
    /**
     * Get status by protocol and port
     * @param protocolType
     * @param port
     * @returns
     */
    getStatus(protocolType?: KoattyProtocol, port?: number): number;
    /**
     * Get native server by protocol and port
     * @param protocolType
     * @param port
     * @returns
     */
    getNativeServer(protocolType?: KoattyProtocol, port?: number): NativeServer;
    /**
     * Get server by protocol and port
     */
    getServer(protocolType?: KoattyProtocol, port?: number): KoattyServer | undefined;
    /**
     * Get all running servers
     */
    getAllServers(): Map<string, KoattyServer>;
    /**
     * Get all failed servers
     */
    getFailedServers(): Map<string, Error>;
    /**
     * Get protocols as array
     */
    /**
     * Create protocol servers based on configuration
     */
    /**
     * Create server instance based on protocol
     */
}

/**
 * Create Server
 *
 * @export
 * @param {KoattyApplication} app
 * @param {ListeningOptions} [opt]
 * @returns {*}  {KoattyServer}
 */
export declare function NewServe(app: KoattyApplication, opt?: ListeningOptions): KoattyServer;

/**
 * cleanup function, returning a promise (used to be onSigterm)
 *
 * @returns {*}
 */
export declare function onSignal(event: string, app: KoattyApplication, server: KoattyServer, forceTimeout: number): Promise<never>;

/**
 * Performance metrics interface
 */
declare interface PerformanceMetrics {
    startTime: number;
    endTime?: number;
    duration?: number;
    memoryUsage?: NodeJS.MemoryUsage;
    [key: string]: any;
}

declare type processEvent = "beforeExit" | "exit" | NodeJS.Signals;

/**
 * ServiceImplementation
 *
 * @interface ServiceImplementation
 */
declare interface ServiceImplementation {
    service: ServiceDefinition;
    implementation: Implementation;
}

/**
 * 优雅关闭结果
 */
declare interface ShutdownResult {
    status: ShutdownStatus;
    totalTime: number;
    completedSteps: string[];
    failedSteps: Array<{
        step: string;
        error: string;
        timestamp: number;
    }>;
}

/**
 * 优雅关闭状态
 */
declare enum ShutdownStatus {
    NOT_STARTED = "not_started",
    IN_PROGRESS = "in_progress",
    DRAINING = "draining",
    COMPLETING = "completing",
    COMPLETED = "completed",
    FAILED = "failed",
    FORCED = "forced"
}

/**
 * 优雅关闭步骤接口
 */
declare interface ShutdownStep {
    name: string;
    description: string;
    timeout?: number;
    execute: (traceId: string) => Promise<void>;
    isRequired?: boolean;
    retryCount?: number;
}

/**
 * HTTPS使用的高级SSL配置
 */
declare interface SSL1Config extends BaseSSLConfig {
    mode: 'auto' | 'manual' | 'mutual_tls';
    requestCert?: boolean;
    rejectUnauthorized?: boolean;
}

/**
 * HTTP/2使用的SSL配置（支持HTTP/1.1降级）
 */
declare interface SSL2Config extends SSL1Config {
    allowHTTP1?: boolean;
}

/**
 * gRPC和WebSocket使用的简单SSL配置
 */
declare interface SSLConfig extends BaseSSLConfig {
    enabled: boolean;
    keyFile?: string;
    certFile?: string;
    caFile?: string;
    clientCertRequired?: boolean;
}

/**
 * Structured logger class based on koatty_logger
 */
declare class StructuredLogger {
    /**
     * Get singleton instance
     */
    static getInstance(): StructuredLogger;
    /**
     * Set global context for all logs
     */
    setGlobalContext(context: LogContext): void;
    /**
     * Clear global context
     */
    clearGlobalContext(): void;
    /**
     * Format log message with context
     */
    /**
     * Debug level logging
     */
    debug(message: string, context?: LogContext, data?: any): void;
    /**
     * Info level logging
     */
    info(message: string, context?: LogContext, data?: any): void;
    /**
     * Warning level logging
     */
    warn(message: string, context?: LogContext, data?: any): void;
    /**
     * Error level logging
     */
    error(message: string, context?: LogContext, error?: Error | any): void;
    /**
     * Start performance tracking
     */
    startPerformanceTracking(trackingId: string, context?: LogContext): void;
    /**
     * End performance tracking and log results
     */
    endPerformanceTracking(trackingId: string, context?: LogContext): PerformanceMetrics | null;
    /**
     * Log server lifecycle events
     */
    logServerEvent(event: 'starting' | 'started' | 'stopping' | 'stopped' | 'error', context: LogContext, data?: any): void;
    /**
     * Log connection events
     */
    logConnectionEvent(event: 'connected' | 'disconnected' | 'error' | 'timeout', context: LogContext, data?: any): void;
    /**
     * Log security events
     */
    logSecurityEvent(event: 'auth_success' | 'auth_failure' | 'rate_limit' | 'blocked', context: LogContext, data?: any): void;
    /**
     * Create a child logger with preset context
     */
    createChildLogger(childContext: LogContext): ChildLogger;
}

export declare interface TerminusOptions {
    timeout: number;
    signals?: string[];
    onSignal?: (event: string, app: KoattyApplication, server: KoattyServer, forceTimeout: number) => Promise<any>;
}

/**
 * 定时器信息接口
 */
declare interface TimerInfo {
    id: string;
    name: string;
    interval: number;
    callback: () => void;
    timer: NodeJS.Timeout;
    createdAt: number;
    lastExecuted?: number;
    priority?: 'high' | 'medium' | 'low';
    protocol?: string;
}

/**
 * 统一定时器管理器
 * 解决定时器资源泄漏和难以追踪的问题
 * Phase 3: 添加定时器优化功能
 */
declare class TimerManager {
    constructor(config?: Partial<TimerOptimizerConfig>);
    /**
     * 添加定时器 (传统方式)
     * @param name 定时器名称
     * @param callback 回调函数
     * @param interval 间隔时间(毫秒)
     * @returns 定时器ID
     */
    /**
     * 添加定时器 - 统一使用优化模式
     * @param name 定时器名称
     * @param callback 回调函数
     * @param interval 间隔时间(毫秒)
     * @returns 定时器ID
     */
    addTimer(name: string, callback: () => void, interval: number): string;
    /**
     * 添加优化定时器 - Phase 3
     * @param task 定时器任务
     * @returns 任务ID
     */
    addOptimizedTimer(task: Omit<TimerTask, 'id' | 'lastExecuted' | 'executionCount'>): string;
    /**
     * 创建物理定时器 - 用于合并定时器的底层实现
     */
    /**
     * 清理指定定时器 - 支持逻辑定时器清理
     * @param timerIdOrName 定时器ID或名称
     * @returns 是否成功清理
     */
    clearTimer(timerIdOrName: string): boolean;
    /**
     * 清理所有定时器 - 支持逻辑和物理定时器清理
     */
    clearAllTimers(): void;
    /**
     * 获取活跃定时器数量 - 返回逻辑定时器数量
     */
    getActiveTimerCount(): number;
    /**
     * 获取所有定时器名称 - 返回逻辑定时器名称
     */
    getTimerNames(): string[];
    /**
     * 获取定时器详细信息
     */
    getTimerInfo(timerId: string): TimerInfo | undefined;
    /**
     * 获取所有定时器统计信息 - 返回逻辑定时器统计
     */
    getTimerStats(): {
        totalTimers: number;
        timers: Array<{
            id: string;
            name: string;
            interval: number;
            uptime: number;
            lastExecuted?: number;
            priority: string;
            executionCount: number;
        }>;
    };
    /**
     * 检查是否存在指定定时器 - 支持逻辑和物理定时器
     */
    hasTimer(timerId: string): boolean;
    /**
     * 确定定时器优先级 - Phase 3 优化
     */
    /**
     * 从定时器名称提取协议 - Phase 3 优化
     */
    /**
     * 选择最佳频率 - Phase 3 优化
     */
    /**
     * 优化定时器 - Phase 3 核心优化逻辑
     */
    /**
     * 创建合并定时器 - Phase 3 优化
     */
    /**
     * 执行任务批次 - Phase 3 优化
     */
    /**
     * 判断是否应该执行任务（自适应频率）- Phase 3 优化
     */
    /**
     * 更新平均执行时间 - Phase 3 优化
     */
    /**
     * 清理合并定时器 - Phase 3 优化
     */
    /**
     * 获取优化统计信息 - Phase 3 优化
     */
    getOptimizationStats(): {
        performance: {
            totalTasks: number;
            executedTasks: number;
            averageExecutionTime: number;
            lastOptimization: number;
        };
        consolidation: {
            activeTimers: number;
            totalTasks: number;
            tasksByFrequency: {
                [k: string]: number;
            };
            tasksByPriority: {
                high: number;
                medium: number;
                low: number;
            };
        };
        config: TimerOptimizerConfig;
    };
    /**
     * 演示Phase 3优化功能 - 创建优化版本的TimerManager实例
     */
    static createOptimizedInstance(): TimerManager;
    /**
     * 演示定时器优化效果
     */
    demonstrateOptimization(): {
        before: {
            timerCount: number;
            intervals: number[];
        };
        after: {
            consolidatedTimers: number;
            frequencies: number[];
            estimatedReduction: string;
        };
    };
    /**
     * 安全销毁管理器
     */
    destroy(): void;
}

/**
 * 定时器优化配置
 */
declare interface TimerOptimizerConfig {
    enableConsolidation: boolean;
    enableAdaptiveFrequency: boolean;
    maxTimersPerFrequency: number;
    loadThreshold: number;
}

/**
 * 定时器任务接口 - Phase 3 优化
 */
declare interface TimerTask {
    id: string;
    name: string;
    callback: () => void;
    interval: number;
    priority: 'high' | 'medium' | 'low';
    protocol?: string;
    lastExecuted?: number;
    executionCount?: number;
}

/**
 * 统一连接池监控管理器
 * 解决连接池监控定时器过多的问题，合并相似功能
 */
declare class UnifiedPoolMonitor {
    constructor(protocol: string, monitoringInterval?: number);
    /**
     * 注册监控任务
     */
    registerTask(task: MonitoringTask): void;
    /**
     * 注销监控任务
     */
    unregisterTask(taskName: string): void;
    /**
     * 启用/禁用任务
     */
    setTaskEnabled(taskName: string, enabled: boolean): void;
    /**
     * 开始监控
     */
    startMonitoring(): void;
    /**
     * 停止监控
     */
    stopMonitoring(): void;
    /**
     * 执行监控周期
     */
    /**
     * 获取需要执行的任务
     */
    /**
     * 按优先级分组任务
     */
    /**
     * 执行同优先级任务组
     */
    /**
     * 执行单个任务
     */
    /**
     * 计算平均执行时间
     */
    /**
     * 获取任务统计信息
     */
    getTaskStats(taskName?: string): MonitoringStats | Map<string, MonitoringStats>;
    /**
     * 获取监控器状态
     */
    getMonitorStatus(): {
        isRunning: boolean;
        uptime: number;
        tasksCount: number;
        enabledTasksCount: number;
        totalExecutions: number;
        totalSuccesses: number;
        totalFailures: number;
    };
    /**
     * 获取任务列表
     */
    getTasks(): Array<{
        name: string;
        interval: number;
        priority: number;
        enabled: boolean;
        description: string;
        stats: MonitoringStats;
    }>;
    /**
     * 销毁监控器
     */
    destroy(): void;
}

/**
 * WebSocket连接池管理器
 */
declare class WebSocketConnectionPoolManager extends ConnectionPoolManager<WS.WebSocket> {
    constructor(config?: ConnectionPoolConfig);
    /**
     * 验证WebSocket连接
     */
    /**
     * 清理WebSocket连接
     */
    /**
     * 获取可用连接
     */
    protected getAvailableConnection(): Promise<{
        connection: WS.WebSocket;
        id: string;
    } | null>;
    /**
     * 创建新连接 - 支持主动创建WebSocket连接（用于客户端模式或测试）
     */
    protected createNewConnection(options: ConnectionRequestOptions): Promise<{
        connection: WS.WebSocket;
        id: string;
        metadata?: any;
    } | null>;
    /**
     * 检查连接是否健康
     */
    isConnectionHealthy(connection: WS.WebSocket): boolean;
    /**
     * 协议特定的连接处理器设置
     */
    /**
     * 协议特定的连接创建逻辑
     */
    protected createProtocolConnection(_options: ConnectionRequestOptions): Promise<{
        connection: WS.WebSocket;
        metadata?: any;
    } | null>;
    /**
     * 添加WebSocket连接（对外接口，使用统一的registerConnection）
     */
    addWebSocketConnection(connection: WS.WebSocket, request?: IncomingMessage): Promise<boolean>;
    /**
     * 注册WebSocket特定的监控任务到统一监控器
     */
    /**
     * 向所有连接发送ping
     */
    /**
     * 清理死连接
     */
    /**
     * 清理过期连接
     */
    cleanupStaleConnections(): number;
    /**
     * 获取连接统计信息
     */
    getConnectionStats(): {
        availableConnections: number;
        healthyConnections: number;
        utilizationRatio: number;
        protocol: string;
        poolConfig: ConnectionPoolConfig;
        health: ConnectionPoolHealth;
        performance: {
            throughput: number;
            latency: {
                p50: number;
                p95: number;
                p99: number;
            };
            memoryUsage: number;
            cpuUsage: number;
        };
        uptime: number;
        activeConnections: number;
        totalConnections: number;
        connectionsPerSecond: number;
        averageLatency: number;
        errorRate: number;
    };
    /**
     * 找到连接ID的辅助方法
     */
    /**
     * 销毁连接池
     */
    /**
     * 重写添加连接方法，确保WebSocket连接正确设置
     */
    addConnection(connection: WS.WebSocket, metadata?: any): Promise<boolean>;
    destroy(): Promise<void>;
}

/**
 * WebSocket Server Options extending base options
 */
declare interface WebSocketServerOptions extends BaseServerOptions {
    wsOptions?: WS.ServerOptions;
    ssl?: SSLConfig;
    connectionPool?: ConnectionPoolConfig;
}

/**
 * WebSocket Server implementation using template method pattern
 * 继承BaseServer，只实现WebSocket特定的逻辑
 */
export declare class WsServer extends BaseServer<WebSocketServerOptions> {
    readonly server: WS.WebSocketServer;
    readonly httpServer: Server_2 | Server_3;
    socket: any;
    constructor(app: KoattyApplication, options: WebSocketServerOptions);
    /**