@esengine/network-shared/index.d.ts

ECS Framework网络层 - 共享组件和协议

/**
 * @esengine/network-shared v1.0.7
 * TypeScript definitions
 */
import { Component, Emitter } from '@esengine/ecs-framework';

/**
 * 网络层核心类型定义
 */
/**
 * 网络消息类型枚举
 */
declare enum MessageType {
    CONNECT = "connect",
    DISCONNECT = "disconnect",
    HEARTBEAT = "heartbeat",
    SYNC_VAR = "sync_var",
    SYNC_BATCH = "sync_batch",
    SYNC_SNAPSHOT = "sync_snapshot",
    RPC_CALL = "rpc_call",
    RPC_RESPONSE = "rpc_response",
    ENTITY_CREATE = "entity_create",
    ENTITY_DESTROY = "entity_destroy",
    ENTITY_UPDATE = "entity_update",
    JOIN_ROOM = "join_room",
    LEAVE_ROOM = "leave_room",
    ROOM_STATE = "room_state",
    GAME_EVENT = "game_event",
    ERROR = "error",
    WARNING = "warning",
    INFO = "info"
}
/**
 * 网络消息基础接口
 */
interface INetworkMessage {
    /** 消息类型 */
    type: MessageType;
    /** 消息唯一ID */
    messageId: string;
    /** 时间戳 */
    timestamp: number;
    /** 发送者ID */
    senderId: string;
    /** 消息数据 */
    data: any;
    /** 是否可靠传输 */
    reliable?: boolean;
    /** 消息优先级 */
    priority?: number;
}
/**
 * 同步权限类型
 */
declare enum AuthorityType {
    /** 服务端权限 */
    Server = "server",
    /** 客户端权限 */
    Client = "client",
    /** 共享权限 */
    Shared = "shared"
}
/**
 * 网络作用域
 */
declare enum NetworkScope {
    /** 全局可见 */
    Global = "global",
    /** 房间内可见 */
    Room = "room",
    /** 仅拥有者可见 */
    Owner = "owner",
    /** 附近玩家可见 */
    Nearby = "nearby",
    /** 自定义作用域 */
    Custom = "custom"
}
/**
 * 同步模式
 */
declare enum SyncMode {
    /** 同步给所有客户端 */
    All = "all",
    /** 只同步给拥有者 */
    Owner = "owner",
    /** 同步给除拥有者外的客户端 */
    Others = "others",
    /** 同步给附近的客户端 */
    Nearby = "nearby",
    /** 自定义同步逻辑 */
    Custom = "custom"
}
/**
 * RPC目标
 */
declare enum RpcTarget {
    /** 服务端 */
    Server = "server",
    /** 客户端 */
    Client = "client",
    /** 所有客户端 */
    All = "all",
    /** 除发送者外的客户端 */
    Others = "others",
    /** 拥有者客户端 */
    Owner = "owner",
    /** 附近的客户端 */
    Nearby = "nearby"
}
/**
 * 客户端信息
 */
interface IClientInfo {
    /** 客户端ID */
    id: string;
    /** 客户端名称 */
    name: string;
    /** 加入时间 */
    joinTime: number;
    /** 是否已认证 */
    authenticated: boolean;
    /** 延迟（毫秒） */
    latency?: number;
    /** 自定义数据 */
    userData?: Record<string, any>;
}
/**
 * 房间信息
 */
interface IRoomInfo {
    /** 房间ID */
    id: string;
    /** 房间名称 */
    name: string;
    /** 当前玩家数量 */
    playerCount: number;
    /** 最大玩家数量 */
    maxPlayers: number;
    /** 房间状态 */
    state: RoomState;
    /** 自定义数据 */
    metadata?: Record<string, any>;
}
/**
 * 房间状态
 */
declare enum RoomState {
    /** 等待中 */
    Waiting = "waiting",
    /** 游戏中 */
    Playing = "playing",
    /** 已暂停 */
    Paused = "paused",
    /** 已结束 */
    Finished = "finished"
}
/**
 * 网络统计信息
 */
interface INetworkStats {
    /** 总发送字节数 */
    bytesSent: number;
    /** 总接收字节数 */
    bytesReceived: number;
    /** 发送消息数 */
    messagesSent: number;
    /** 接收消息数 */
    messagesReceived: number;
    /** 平均延迟 */
    averageLatency: number;
    /** 丢包率 */
    packetLoss: number;
    /** 连接时长 */
    connectionTime: number;
}
/**
 * 向量2D
 */
interface IVector2 {
    x: number;
    y: number;
}
/**
 * 向量3D
 */
interface IVector3 extends IVector2 {
    z: number;
}
/**
 * 四元数
 */
interface IQuaternion {
    x: number;
    y: number;
    z: number;
    w: number;
}
/**
 * 变换信息
 */
interface ITransform {
    position: IVector3;
    rotation: IQuaternion;
    scale: IVector3;
}
/**
 * 网络错误类型
 */
declare enum NetworkErrorType {
    CONNECTION_FAILED = "connection_failed",
    CONNECTION_LOST = "connection_lost",
    AUTHENTICATION_FAILED = "authentication_failed",
    PERMISSION_DENIED = "permission_denied",
    RATE_LIMITED = "rate_limited",
    INVALID_MESSAGE = "invalid_message",
    TIMEOUT = "timeout",
    UNKNOWN = "unknown"
}
/**
 * 网络错误信息
 */
interface INetworkError {
    type: NetworkErrorType;
    message: string;
    code?: number;
    details?: any;
    timestamp: number;
}

/**
 * 传输层接口定义
 */
/**
 * 传输层抽象接口
 */
interface ITransport {
    /**
     * 启动传输层
     * @param port - 端口号
     * @param host - 主机地址
     */
    start(port: number, host?: string): Promise<void>;
    /**
     * 停止传输层
     */
    stop(): Promise<void>;
    /**
     * 发送数据到指定客户端
     * @param clientId - 客户端ID
     * @param data - 数据
     */
    send(clientId: string, data: ArrayBuffer | string): void;
    /**
     * 广播数据到所有客户端
     * @param data - 数据
     * @param exclude - 排除的客户端ID列表
     */
    broadcast(data: ArrayBuffer | string, exclude?: string[]): void;
    /**
     * 监听客户端连接事件
     * @param handler - 处理函数
     */
    onConnect(handler: (clientInfo: ITransportClientInfo) => void): void;
    /**
     * 监听客户端断开事件
     * @param handler - 处理函数
     */
    onDisconnect(handler: (clientId: string, reason?: string) => void): void;
    /**
     * 监听消息接收事件
     * @param handler - 处理函数
     */
    onMessage(handler: (clientId: string, data: ArrayBuffer | string) => void): void;
    /**
     * 监听错误事件
     * @param handler - 处理函数
     */
    onError(handler: (error: Error) => void): void;
    /**
     * 获取连接的客户端数量
     */
    getClientCount(): number;
    /**
     * 检查客户端是否连接
     * @param clientId - 客户端ID
     */
    isClientConnected(clientId: string): boolean;
    /**
     * 断开指定客户端
     * @param clientId - 客户端ID
     * @param reason - 断开原因
     */
    disconnectClient(clientId: string, reason?: string): void;
}
/**
 * 客户端传输层接口
 */
interface IClientTransport {
    /**
     * 连接到服务器
     * @param url - 服务器URL
     * @param options - 连接选项
     */
    connect(url: string, options?: IConnectionOptions): Promise<void>;
    /**
     * 断开连接
     * @param reason - 断开原因
     */
    disconnect(reason?: string): Promise<void>;
    /**
     * 发送数据到服务器
     * @param data - 数据
     */
    send(data: ArrayBuffer | string): void;
    /**
     * 监听服务器消息
     * @param handler - 处理函数
     */
    onMessage(handler: (data: ArrayBuffer | string) => void): void;
    /**
     * 监听连接状态变化
     * @param handler - 处理函数
     */
    onConnectionStateChange(handler: (state: ConnectionState) => void): void;
    /**
     * 监听错误事件
     * @param handler - 处理函数
     */
    onError(handler: (error: Error) => void): void;
    /**
     * 获取连接状态
     */
    getConnectionState(): ConnectionState;
    /**
     * 获取连接统计信息
     */
    getStats(): IConnectionStats;
}
/**
 * 传输层客户端信息
 */
interface ITransportClientInfo {
    /** 客户端ID */
    id: string;
    /** 远程地址 */
    remoteAddress: string;
    /** 连接时间 */
    connectTime: number;
    /** 用户代理 */
    userAgent?: string;
    /** 自定义头信息 */
    headers?: Record<string, string>;
}
/**
 * 连接选项
 */
interface IConnectionOptions {
    /** 连接超时时间（毫秒） */
    timeout?: number;
    /** 重连间隔（毫秒） */
    reconnectInterval?: number;
    /** 最大重连次数 */
    maxReconnectAttempts?: number;
    /** 是否自动重连 */
    autoReconnect?: boolean;
    /** 自定义头信息 */
    headers?: Record<string, string>;
    /** 协议版本 */
    protocolVersion?: string;
}
/**
 * 连接状态
 */
declare enum ConnectionState {
    /** 断开连接 */
    Disconnected = "disconnected",
    /** 连接中 */
    Connecting = "connecting",
    /** 已连接 */
    Connected = "connected",
    /** 重连中 */
    Reconnecting = "reconnecting",
    /** 连接失败 */
    Failed = "failed"
}
/**
 * 连接统计信息
 */
interface IConnectionStats {
    /** 连接状态 */
    state: ConnectionState;
    /** 连接时间 */
    connectTime?: number;
    /** 断开时间 */
    disconnectTime?: number;
    /** 重连次数 */
    reconnectCount: number;
    /** 发送字节数 */
    bytesSent: number;
    /** 接收字节数 */
    bytesReceived: number;
    /** 发送消息数 */
    messagesSent: number;
    /** 接收消息数 */
    messagesReceived: number;
    /** 延迟（毫秒） */
    latency?: number;
}
/**
 * SSL配置
 */
interface SSLConfig {
    enabled: boolean;
    cert?: string;
    key?: string;
}
/**
 * 传输层配置
 */
interface ITransportConfig {
    /** 端口号 */
    port: number;
    /** 主机地址 */
    host?: string;
    /** 最大连接数 */
    maxConnections?: number;
    /** 心跳间隔（毫秒） */
    heartbeatInterval?: number;
    /** 连接超时时间（毫秒） */
    connectionTimeout?: number;
    /** 消息最大大小（字节） */
    maxMessageSize?: number;
    /** 是否启用压缩 */
    compression?: boolean;
    /** SSL配置 */
    ssl?: SSLConfig;
}

/**
 * RPC调用配置
 */
interface RpcOptions {
    /** 是否可靠传输 */
    reliable?: boolean;
    /** 调用优先级 0-10，10为最高 */
    priority?: number;
    /** 调用目标 */
    target?: RpcTarget;
    /** 超时时间(毫秒) */
    timeout?: number;
    /** 是否需要身份验证 */
    requireAuth?: boolean;
    /** 调用频率限制(每秒) */
    rateLimit?: number;
}
/**
 * RPC方法元数据
 */
interface RpcMethodMetadata {
    /** 方法名 */
    methodName: string;
    /** 所属类名 */
    className: string;
    /** 是否为服务端RPC */
    isServerRpc: boolean;
    /** RPC配置 */
    options: RpcOptions;
    /** 参数类型 */
    paramTypes: string[];
    /** 返回值类型 */
    returnType: string;
}
/**
 * RPC调用请求
 */
interface RpcCallRequest<T extends readonly unknown[] = readonly unknown[]> {
    /** 调用ID */
    callId: string;
    /** 方法名 */
    methodName: string;
    /** 调用参数 */
    args: T;
    /** 发送者ID */
    senderId: string;
    /** 目标ID(可选，用于特定客户端调用) */
    targetId?: string;
    /** 调用时间戳 */
    timestamp: number;
    /** 调用配置 */
    options: RpcOptions;
}
/**
 * RPC调用响应
 */
interface RpcCallResponse<T = unknown> {
    /** 调用ID */
    callId: string;
    /** 是否成功 */
    success: boolean;
    /** 返回值 */
    result?: T;
    /** 错误信息 */
    error?: RpcError;
    /** 响应时间戳 */
    timestamp: number;
    /** 处理时长(毫秒) */
    duration: number;
}
/**
 * RPC错误类型
 */
declare enum RpcErrorType {
    /** 方法不存在 */
    METHOD_NOT_FOUND = "method_not_found",
    /** 参数无效 */
    INVALID_ARGUMENTS = "invalid_arguments",
    /** 权限不足 */
    PERMISSION_DENIED = "permission_denied",
    /** 调用超时 */
    TIMEOUT = "timeout",
    /** 速率限制 */
    RATE_LIMITED = "rate_limited",
    /** 网络错误 */
    NETWORK_ERROR = "network_error",
    /** 服务端错误 */
    SERVER_ERROR = "server_error",
    /** 客户端错误 */
    CLIENT_ERROR = "client_error",
    /** 未知错误 */
    UNKNOWN = "unknown"
}
/**
 * RPC错误信息
 */
interface RpcError {
    /** 错误类型 */
    type: RpcErrorType;
    /** 错误消息 */
    message: string;
    /** 错误代码 */
    code?: number;
    /** 详细信息 */
    details?: Record<string, unknown>;
    /** 堆栈信息 */
    stack?: string;
}
/**
 * RPC调用状态
 */
declare enum RpcCallStatus {
    /** 待发送 */
    PENDING = "pending",
    /** 已发送 */
    SENT = "sent",
    /** 处理中 */
    PROCESSING = "processing",
    /** 已完成 */
    COMPLETED = "completed",
    /** 已失败 */
    FAILED = "failed",
    /** 已超时 */
    TIMEOUT = "timeout",
    /** 已取消 */
    CANCELLED = "cancelled"
}
/**
 * RPC调用信息
 */
interface RpcCallInfo<T extends readonly unknown[] = readonly unknown[]> {
    /** 调用请求 */
    request: RpcCallRequest<T>;
    /** 调用状态 */
    status: RpcCallStatus;
    /** Promise解析器 */
    resolve?: (value: unknown) => void;
    /** Promise拒绝器 */
    reject?: (reason: RpcError) => void;
    /** 重试次数 */
    retryCount: number;
    /** 下次重试时间 */
    nextRetryTime?: number;
    /** 创建时间 */
    createdAt: number;
    /** 发送时间 */
    sentAt?: number;
    /** 完成时间 */
    completedAt?: number;
}
/**
 * RPC统计信息
 */
interface RpcStats {
    /** 总调用次数 */
    totalCalls: number;
    /** 成功调用次数 */
    successfulCalls: number;
    /** 失败调用次数 */
    failedCalls: number;
    /** 平均响应时间(毫秒) */
    averageResponseTime: number;
    /** 当前等待中的调用数 */
    pendingCalls: number;
    /** 超时调用次数 */
    timeoutCalls: number;
    /** 重试次数 */
    retryCount: number;
    /** 最后更新时间 */
    lastUpdated: number;
}
/**
 * RPC方法签名类型
 */
type RpcMethod<TArgs extends readonly unknown[] = readonly unknown[], TReturn = unknown> = (...args: TArgs) => Promise<TReturn>;
/**
 * RPC方法注册表类型
 */
type RpcMethodRegistry = Map<string, {
    metadata: RpcMethodMetadata;
    handler: RpcMethod;
}>;
/**
 * 客户端RPC调用接口类型
 */
type ClientRpcInvoker = <TArgs extends readonly unknown[], TReturn>(methodName: string, args: TArgs, options?: Partial<RpcOptions>) => Promise<TReturn>;
/**
 * 服务端RPC调用接口类型
 */
type ServerRpcInvoker = <TArgs extends readonly unknown[], TReturn>(clientId: string, methodName: string, args: TArgs, options?: Partial<RpcOptions>) => Promise<TReturn>;

/**
 * 网络消息协议定义
 */

/**
 * 3D位置信息
 */
interface Position3D {
    x: number;
    y: number;
    z?: number;
}
/**
 * 组件数据
 */
interface ComponentData {
    type: string;
    data: any;
}
/**
 * 客户端信息
 */
interface ClientInfo {
    name: string;
    version: string;
    platform: string;
}
/**
 * 服务器信息
 */
interface ServerInfo {
    name: string;
    version: string;
    maxPlayers: number;
    currentPlayers: number;
}
/**
 * 玩家信息
 */
interface PlayerInfo {
    playerId: string;
    playerName: string;
}
/**
 * 连接数据
 */
interface ConnectData {
    clientVersion: string;
    protocolVersion: string;
    authToken?: string;
    clientInfo: ClientInfo;
}
/**
 * 连接响应数据
 */
interface ConnectResponseData {
    success: boolean;
    clientId?: string;
    error?: string;
    serverInfo?: ServerInfo;
}
/**
 * 断开连接数据
 */
interface DisconnectData {
    reason: string;
    code: number;
}
/**
 * 心跳数据
 */
interface HeartbeatData {
    clientTime: number;
    serverTime?: number;
}
/**
 * RPC请求数据
 */
interface RpcRequestData {
    callId: string;
    methodName: string;
    target: RpcTarget;
    args: any[];
    timeout?: number;
}
/**
 * 实体创建数据
 */
interface EntityCreateData {
    entityId: string;
    entityType: string;
    ownerId: string;
    authority: AuthorityType;
    components: ComponentData[];
    position?: Position3D;
}
/**
 * 实体销毁数据
 */
interface EntityDestroyData {
    entityId: string;
    reason?: string;
}
/**
 * 组件同步数据
 */
interface ComponentSyncData {
    entityId: string;
    componentType: string;
    syncMode: SyncMode;
    data: any;
    timestamp: number;
}
/**
 * 状态同步数据
 */
interface StateSyncData {
    entityId: string;
    stateData: any;
    timestamp: number;
}
/**
 * 聊天数据
 */
interface ChatData {
    playerId: string;
    message: string;
    timestamp: number;
    playerInfo?: PlayerInfo;
}
/**
 * 加入房间数据
 */
interface JoinRoomData {
    roomId: string;
    playerInfo: PlayerInfo;
}
/**
 * 离开房间数据
 */
interface LeaveRoomData {
    roomId: string;
    reason?: string;
}
/**
 * 玩家加入数据
 */
interface PlayerJoinedData {
    playerId: string;
    playerName: string;
    roomId: string;
}
/**
 * 玩家离开数据
 */
interface PlayerLeftData {
    playerId: string;
    roomId: string;
    reason?: string;
}
/**
 * 自定义数据
 */
interface CustomData {
    eventType: string;
    data: any;
    timestamp: number;
}
/**
 * 错误数据
 */
interface ErrorData {
    code: string;
    message: string;
    details?: any;
    relatedMessageId?: string;
}
/**
 * 连接请求消息
 */
interface IConnectMessage extends INetworkMessage {
    type: MessageType.CONNECT;
    data: ConnectData;
}
/**
 * 连接响应消息
 */
interface IConnectResponseMessage extends INetworkMessage {
    type: MessageType.CONNECT;
    data: ConnectResponseData;
}
/**
 * 心跳消息
 */
interface IHeartbeatMessage extends INetworkMessage {
    type: MessageType.HEARTBEAT;
    data: HeartbeatData;
}
/**
 * 同步变量消息
 */
interface ISyncVarMessage extends INetworkMessage {
    type: MessageType.SYNC_VAR;
    data: {
        /** 网络实体ID */
        networkId: number;
        /** 组件类型名称 */
        componentType: string;
        /** 变化的属性 */
        changes: Record<string, any>;
        /** 同步模式 */
        syncMode: SyncMode;
        /** 时间戳 */
        timestamp: number;
    };
}
/**
 * 批量同步消息
 */
interface ISyncBatchMessage extends INetworkMessage {
    type: MessageType.SYNC_BATCH;
    data: {
        /** 同步数据列表 */
        syncData: Array<{
            networkId: number;
            componentType: string;
            changes: Record<string, any>;
            syncMode: SyncMode;
        }>;
        /** 批次时间戳 */
        batchTimestamp: number;
    };
}
/**
 * RPC调用消息
 */
interface IRpcCallMessage extends INetworkMessage {
    type: MessageType.RPC_CALL;
    data: {
        /** 网络实体ID */
        networkId: number;
        /** 组件类型名称 */
        componentType: string;
        /** 方法名 */
        methodName: string;
        /** 参数列表 */
        args: any[];
        /** 调用ID（用于响应匹配） */
        callId?: string;
        /** RPC目标 */
        target: RpcTarget;
        /** 是否需要响应 */
        expectResponse?: boolean;
        /** 超时时间 */
        timeout?: number;
    };
}
/**
 * RPC响应数据
 */
interface RpcResponseData {
    /** 调用ID */
    callId: string;
    /** 是否成功 */
    success: boolean;
    /** 返回值 */
    result?: any;
    /** 错误信息 */
    error?: string;
}
/**
 * RPC响应消息
 */
interface IRpcResponseMessage extends INetworkMessage {
    type: MessageType.RPC_RESPONSE;
    data: RpcResponseData;
}
/**
 * 实体创建消息
 */
interface IEntityCreateMessage extends INetworkMessage {
    type: MessageType.ENTITY_CREATE;
    data: {
        /** 网络实体ID */
        networkId: number;
        /** 实体名称 */
        entityName: string;
        /** 拥有者ID */
        ownerId: string;
        /** 权限类型 */
        authority: AuthorityType;
        /** 初始组件数据 */
        components: ComponentData[];
        /** 位置信息 */
        position?: Position3D;
    };
}
/**
 * 实体销毁消息
 */
interface IEntityDestroyMessage extends INetworkMessage {
    type: MessageType.ENTITY_DESTROY;
    data: {
        /** 网络实体ID */
        networkId: number;
        /** 销毁原因 */
        reason?: string;
    };
}
/**
 * 加入房间消息
 */
interface IJoinRoomMessage extends INetworkMessage {
    type: MessageType.JOIN_ROOM;
    data: {
        /** 房间ID */
        roomId: string;
        /** 密码（如果需要） */
        password?: string;
        /** 玩家信息 */
        playerInfo?: {
            name: string;
            avatar?: string;
            customData?: Record<string, any>;
        };
    };
}
/**
 * 离开房间消息
 */
interface ILeaveRoomMessage extends INetworkMessage {
    type: MessageType.LEAVE_ROOM;
    data: LeaveRoomData;
}
/**
 * 房间状态消息
 */
interface IRoomStateMessage extends INetworkMessage {
    type: MessageType.ROOM_STATE;
    data: {
        /** 房间ID */
        roomId: string;
        /** 房间状态 */
        state: string;
        /** 玩家列表 */
        players: Array<{
            id: string;
            name: string;
            isHost: boolean;
            customData?: Record<string, any>;
        }>;
        /** 房间设置 */
        settings?: Record<string, any>;
    };
}
/**
 * 游戏事件消息
 */
interface IGameEventMessage extends INetworkMessage {
    type: MessageType.GAME_EVENT;
    data: {
        /** 事件类型 */
        eventType: string;
        /** 事件数据 */
        eventData: any;
        /** 目标客户端 */
        target?: RpcTarget;
        /** 事件优先级 */
        priority?: number;
    };
}
/**
 * 错误消息
 */
interface IErrorMessage extends INetworkMessage {
    type: MessageType.ERROR;
    data: ErrorData;
}
/**
 * 消息类型联合
 */
type NetworkMessage = IConnectMessage | IConnectResponseMessage | IHeartbeatMessage | ISyncVarMessage | ISyncBatchMessage | IRpcCallMessage | IRpcResponseMessage | IEntityCreateMessage | IEntityDestroyMessage | IJoinRoomMessage | ILeaveRoomMessage | IRoomStateMessage | IGameEventMessage | IErrorMessage;

/**
 * 消息ID生成器类型
 */
declare enum MessageIdGeneratorType {
    UUID = "uuid",
    SNOWFLAKE = "snowflake",
    SEQUENTIAL = "sequential",
    TIMESTAMP = "timestamp"
}
/**
 * 消息创建选项
 */
interface MessageCreateOptions {
    reliable?: boolean;
    priority?: number;
    timestamp?: number;
}
/**
 * 消息管理器配置
 */
interface MessageManagerConfig {
    idGenerator: MessageIdGeneratorType;
    enableTimestampValidation: boolean;
    maxTimestampDrift: number;
    enableMessageDeduplication: boolean;
    deduplicationWindowMs: number;
    enableMessageOrdering: boolean;
    orderingWindowMs: number;
    maxPendingMessages: number;
}
/**
 * 消息验证结果
 */
interface MessageValidationResult {
    isValid: boolean;
    errors: string[];
    warnings: string[];
}
/**
 * 消息统计信息
 */
interface MessageStats {
    totalGenerated: number;
    totalValidated: number;
    validMessages: number;
    invalidMessages: number;
    duplicateMessages: number;
    outOfOrderMessages: number;
    timestampErrors: number;
}
/**
 * 消息管理器
 */
declare class MessageManager {
    private logger;
    private config;
    private stats;
    private sequentialId;
    private snowflakeGenerator;
    private recentMessageIds;
    private pendingMessages;
    private messageSequence;
    private cleanupTimer?;
    /**
     * 构造函数
     */
    constructor(config?: Partial<MessageManagerConfig>);
    /**
     * 生成消息ID
     */
    generateMessageId(): string;
    /**
     * 创建网络消息
     */
    createMessage<T extends INetworkMessage>(type: MessageType, data: any, senderId: string, options?: MessageCreateOptions): T;
    /**
     * 验证消息
     */
    validateMessage(message: INetworkMessage, senderId?: string): MessageValidationResult;
    /**
     * 处理消息排序
     */
    processMessageOrdering(message: INetworkMessage): INetworkMessage[];
    /**
     * 获取统计信息
     */
    getStats(): MessageStats;
    /**
     * 重置统计信息
     */
    resetStats(): void;
    /**
     * 更新配置
     */
    updateConfig(newConfig: Partial<MessageManagerConfig>): void;
    /**
     * 销毁管理器
     */
    destroy(): void;
    /**
     * 生成UUID
     */
    private generateUUID;
    /**
     * 刷新待处理消息
     */
    private flushPendingMessages;
    /**
     * 清理过期的待处理消息
     */
    private cleanupOldPendingMessages;
    /**
     * 启动清理定时器
     */
    private startCleanupTimer;
    /**
     * 执行清理操作
     */
    private performCleanup;
    /**
     * 获取消息处理报告
     */
    getProcessingReport(): {
        stats: MessageStats;
        validationRate: number;
        duplicateRate: number;
        pendingMessagesCount: number;
        cachedMessageIdsCount: number;
        recommendation: string;
    };
    /**
     * 生成优化建议
     */
    private generateRecommendation;
    /**
     * 批量验证消息
     */
    validateMessageBatch(messages: INetworkMessage[], senderId?: string): MessageValidationResult[];
    /**
     * 获取消息年龄（毫秒）
     */
    getMessageAge(message: INetworkMessage): number;
    /**
     * 检查消息是否过期
     */
    isMessageExpired(message: INetworkMessage, maxAge?: number): boolean;
}

/**
 * 网络事件类型枚举
 * 定义网络层中的所有事件类型
 */
declare enum NetworkEventType {
    CONNECTION_ESTABLISHED = "network:connection:established",
    CONNECTION_LOST = "network:connection:lost",
    CONNECTION_ERROR = "network:connection:error",
    CONNECTION_TIMEOUT = "network:connection:timeout",
    RECONNECTION_STARTED = "network:reconnection:started",
    RECONNECTION_SUCCEEDED = "network:reconnection:succeeded",
    RECONNECTION_FAILED = "network:reconnection:failed",
    IDENTITY_CREATED = "network:identity:created",
    IDENTITY_DESTROYED = "network:identity:destroyed",
    IDENTITY_OWNER_CHANGED = "network:identity:owner:changed",
    IDENTITY_AUTHORITY_CHANGED = "network:identity:authority:changed",
    IDENTITY_SYNC_ENABLED = "network:identity:sync:enabled",
    IDENTITY_SYNC_DISABLED = "network:identity:sync:disabled",
    IDENTITY_PROPERTY_CHANGED = "network:identity:property:changed",
    IDENTITY_VISIBLE_CHANGED = "network:identity:visible:changed",
    SYNC_STARTED = "network:sync:started",
    SYNC_COMPLETED = "network:sync:completed",
    SYNC_FAILED = "network:sync:failed",
    SYNC_RATE_CHANGED = "network:sync:rate:changed",
    SYNC_PRIORITY_CHANGED = "network:sync:priority:changed",
    RPC_CALL_SENT = "network:rpc:call:sent",
    RPC_CALL_RECEIVED = "network:rpc:call:received",
    RPC_RESPONSE_SENT = "network:rpc:response:sent",
    RPC_RESPONSE_RECEIVED = "network:rpc:response:received",
    RPC_ERROR = "network:rpc:error",
    RPC_TIMEOUT = "network:rpc:timeout",
    MESSAGE_SENT = "network:message:sent",
    MESSAGE_RECEIVED = "network:message:received",
    MESSAGE_QUEUED = "network:message:queued",
    MESSAGE_DROPPED = "network:message:dropped",
    MESSAGE_RETRY = "network:message:retry",
    MESSAGE_ACKNOWLEDGED = "network:message:acknowledged",
    ROOM_JOINED = "network:room:joined",
    ROOM_LEFT = "network:room:left",
    ROOM_CREATED = "network:room:created",
    ROOM_DESTROYED = "network:room:destroyed",
    ROOM_PLAYER_JOINED = "network:room:player:joined",
    ROOM_PLAYER_LEFT = "network:room:player:left",
    CLIENT_CONNECTED = "network:client:connected",
    CLIENT_DISCONNECTED = "network:client:disconnected",
    CLIENT_AUTHENTICATED = "network:client:authenticated",
    CLIENT_KICKED = "network:client:kicked",
    CLIENT_TIMEOUT = "network:client:timeout",
    SERVER_STARTED = "network:server:started",
    SERVER_STOPPED = "network:server:stopped",
    SERVER_ERROR = "network:server:error",
    SERVER_OVERLOADED = "network:server:overloaded",
    DATA_SYNCHRONIZED = "network:data:synchronized",
    DATA_CONFLICT = "network:data:conflict",
    DATA_CORRUPTED = "network:data:corrupted",
    DATA_VALIDATED = "network:data:validated",
    BANDWIDTH_WARNING = "network:bandwidth:warning",
    LATENCY_HIGH = "network:latency:high",
    PACKET_LOSS_DETECTED = "network:packet:loss:detected",
    PERFORMANCE_DEGRADED = "network:performance:degraded"
}
/**
 * 网络事件优先级
 */
declare enum NetworkEventPriority {
    LOW = 10,
    NORMAL = 20,
    HIGH = 30,
    CRITICAL = 40,
    EMERGENCY = 50
}
/**
 * 网络事件数据基础接口
 */
interface NetworkEventData {
    timestamp: number;
    networkId?: number;
    clientId?: string;
    roomId?: string;
    [key: string]: any;
}
/**
 * 网络身份事件数据
 */
interface NetworkIdentityEventData extends NetworkEventData {
    networkId: number;
    ownerId: string;
    oldValue?: any;
    newValue?: any;
}
/**
 * RPC事件数据
 */
interface RpcEventData extends NetworkEventData {
    rpcId: string;
    methodName: string;
    parameters?: any[];
    result?: any;
    error?: string;
}
/**
 * 消息事件数据
 */
interface MessageEventData extends NetworkEventData {
    messageId: string;
    messageType: string;
    payload: any;
    reliable: boolean;
    size: number;
}
/**
 * 连接事件数据
 */
interface ConnectionEventData extends NetworkEventData {
    clientId: string;
    address?: string;
    reason?: string;
    reconnectAttempt?: number;
}
/**
 * 房间事件数据
 */
interface RoomEventData extends NetworkEventData {
    roomId: string;
    playerId?: string;
    playerCount?: number;
    maxPlayers?: number;
}
/**
 * 性能事件数据
 */
interface PerformanceEventData extends NetworkEventData {
    metric: string;
    value: number;
    threshold?: number;
    duration?: number;
}
/**
 * 网络事件工具类
 */
declare class NetworkEventUtils {
    /**
     * 创建网络身份事件数据
     */
    static createIdentityEventData(networkId: number, ownerId: string, oldValue?: any, newValue?: any): NetworkIdentityEventData;
    /**
     * 创建RPC事件数据
     */
    static createRpcEventData(rpcId: string, methodName: string, clientId?: string, parameters?: any[], result?: any, error?: string): RpcEventData;
    /**
     * 创建消息事件数据
     */
    static createMessageEventData(messageId: string, messageType: string, payload: any, reliable?: boolean, clientId?: string): MessageEventData;
    /**
     * 创建连接事件数据
     */
    static createConnectionEventData(clientId: string, address?: string, reason?: string, reconnectAttempt?: number): ConnectionEventData;
    /**
     * 创建房间事件数据
     */
    static createRoomEventData(roomId: string, playerId?: string, playerCount?: number, maxPlayers?: number): RoomEventData;
    /**
     * 创建性能事件数据
     */
    static createPerformanceEventData(metric: string, value: number, threshold?: number, duration?: number, clientId?: string): PerformanceEventData;
}

/**
 * 网络身份组件
 */

/**
 * 网络身份组件
 *
 * 为实体提供网络同步能力的核心组件。
 * 每个需要网络同步的实体都必须拥有此组件。
 *
 * 集成了事件系统，当属性变化时自动发射事件用于网络同步。
 */
declare class NetworkIdentity extends Component {
    /**
     * 事件发射器
     * 用于发射网络相关事件
     */
    private eventEmitter;
    /**
     * 网络ID (全局唯一)
     * 用于在网络中标识实体
     */
    networkId: number;
    /**
     * 拥有者ID
     * 表示哪个客户端拥有此实体的控制权
     */
    ownerId: string;
    /**
     * 权限类型
     * 决定哪一端对此实体有控制权
     */
    authority: AuthorityType;
    /**
     * 同步频率 (Hz)
     * 每秒同步的次数
     */
    syncRate: number;
    /**
     * 网络作用域
     * 决定哪些客户端可以看到此实体
     */
    scope: NetworkScope;
    /**
     * 是否是本地玩家
     * 标识此实体是否代表本地玩家
     */
    isLocalPlayer: boolean;
    /**
     * 是否启用网络同步
     * 临时禁用/启用同步
     */
    syncEnabled: boolean;
    /**
     * 同步优先级
     * 影响同步的顺序和频率，数值越高优先级越高
     */
    priority: number;
    /**
     * 距离阈值
     * 用于附近同步模式，超过此距离的客户端不会收到同步
     */
    distanceThreshold: number;
    /**
     * 最后同步时间
     * 记录上次同步的时间戳
     */
    lastSyncTime: number;
    /**
     * 是否可见
     * 控制实体是否对其他客户端可见
     */
    visible: boolean;
    /**
     * 自定义同步过滤器
     * 用于自定义作用域的同步逻辑
     */
    customSyncFilter?: (clientId: string) => boolean;
    /**
     * 获取实体的同步权重
     * 基于优先级和距离计算
     */
    getSyncWeight(distance?: number): number;
    /**
     * 检查是否应该同步给指定客户端
     */
    shouldSyncToClient(clientId: string, distance?: number): boolean;
    /**
     * 检查客户端是否有权限修改此实体
     */
    hasAuthority(clientId: string): boolean;
    /**
     * 设置拥有者
     */
    setOwner(clientId: string): void;
    /**
     * 设置权限类型
     */
    setAuthority(authority: AuthorityType): void;
    /**
     * 设置同步状态
     */
    setSyncEnabled(enabled: boolean): void;
    /**
     * 设置同步频率
     */
    setSyncRate(rate: number): void;
    /**
     * 添加事件监听器
     */
    addEventListener(eventType: NetworkEventType, handler: (data: NetworkIdentityEventData) => void): void;
    /**
     * 移除事件监听器
     */
    removeEventListener(eventType: NetworkEventType, handler: (data: NetworkIdentityEventData) => void): void;
    /**
     * 发射事件
     * @private
     */
    private emitEvent;
    /**
     * 监听属性变化事件
     */
    onPropertyChanged(handler: (data: NetworkIdentityEventData) => void): void;
    /**
     * 监听拥有者变化事件
     */
    onOwnerChanged(handler: (data: NetworkIdentityEventData) => void): void;
    /**
     * 监听权限变化事件
     */
    onAuthorityChanged(handler: (data: NetworkIdentityEventData) => void): void;
    /**
     * 监听同步状态变化事件
     */
    onSyncStateChanged(handler: (data: NetworkIdentityEventData) => void): void;
    /**
     * 获取调试信息
     */
    getDebugInfo(): Record<string, any>;
    /**
     * 组件销毁时清理事件监听器
     */
    dispose(): void;
}

/**
 * 心跳配置
 */
interface HeartbeatConfig {
    interval: number;
    timeout: number;
    maxMissedHeartbeats: number;
    enableLatencyMeasurement: boolean;
}
/**
 * 心跳状态
 */
interface HeartbeatStatus {
    isHealthy: boolean;
    lastHeartbeat: number;
    latency?: number;
    missedHeartbeats: number;
    averageLatency?: number;
    packetLoss?: number;
}
/**
 * 心跳事件接口
 */
interface HeartbeatEvents {
    heartbeatSent: (timestamp: number) => void;
    heartbeatReceived: (latency: number) => void;
    heartbeatTimeout: (missedCount: number) => void;
    healthStatusChanged: (isHealthy: boolean) => void;
}
/**
 * 心跳消息接口
 */
interface HeartbeatMessage {
    type: MessageType.HEARTBEAT;
    clientTime: number;
    serverTime?: number;
    sequence?: number;
}
/**
 * 心跳管理器
 */
declare class HeartbeatManager {
    private logger;
    private config;
    private status;
    private eventHandlers;
    private heartbeatTimer?;
    private timeoutTimer?;
    private pendingPings;
    private latencyHistory;
    private sequence;
    private sentCount;
    private receivedCount;
    /**
     * 发送心跳回调
     */
    private sendHeartbeat?;
    /**
     * 构造函数
     */
    constructor(config?: Partial<HeartbeatConfig>);
    /**
     * 启动心跳
     */
    start(sendCallback: (message: HeartbeatMessage) => void): void;
    /**
     * 停止心跳
     */
    stop(): void;
    /**
     * 处理接收到的心跳响应
     */
    handleHeartbeatResponse(message: HeartbeatMessage): void;
    /**
     * 处理心跳超时
     */
    handleHeartbeatTimeout(): void;
    /**
     * 获取心跳状态
     */
    getStatus(): HeartbeatStatus;
    /**
     * 获取统计信息
     */
    getStats(): {
        sentCount: number;
        receivedCount: number;
        packetLoss: number;
        averageLatency: number | undefined;
        currentLatency: number | undefined;
        isHealthy: boolean;
        missedHeartbeats: number;
        latencyHistory: number[];
    };
    /**
     * 设置事件处理器
     */
    on<K extends keyof HeartbeatEvents>(event: K, handler: HeartbeatEvents[K]): void;
    /**
     * 移除事件处理器
     */
    off<K extends keyof HeartbeatEvents>(event: K): void;
    /**
     * 手动发送心跳
     */
    sendHeartbeatNow(): void;
    /**
     * 更新配置
     */
    updateConfig(newConfig: Partial<HeartbeatConfig>): void;
    /**
     * 启动心跳定时器
     */
    private startHeartbeatTimer;
    /**
     * 停止心跳定时器
     */
    private stopHeartbeatTimer;
    /**
     * 启动超时定时器
     */
    private startTimeoutTimer;
    /**
     * 停止超时定时器
     */
    private stopTimeoutTimer;
    /**
     * 执行发送心跳
     */
    private doSendHeartbeat;
    /**
     * 更新延迟信息
     */
    private updateLatency;
    /**
     * 更新健康状态
     */
    private updateHealthStatus;
    /**
     * 清理过期的pending pings
     */
    private cleanupPendingPings;
    /**
     * 重置统计信息
     */
    resetStats(): void;
    /**
     * 检查连接是否健康
     */
    isConnectionHealthy(): boolean;
    /**
     * 获取建议的重连延迟
     */
    getReconnectDelay(): number;
}

/**
 * 错误趋势分析结果
 */
interface ErrorTrendAnalysis {
    trend: string;
    recommendation: string;
}
/**
 * 错误严重级别
 */
declare enum ErrorSeverity {
    Low = "low",// 低级错误，可以忽略
    Medium = "medium",// 中级错误，需要记录但不影响功能
    High = "high",// 高级错误，影响功能但可以恢复
    Critical = "critical"
}
/**
 * 错误恢复策略
 */
declare enum RecoveryStrategy {
    Ignore = "ignore",// 忽略错误
    Retry = "retry",// 重试操作
    Reconnect = "reconnect",// 重新连接
    Restart = "restart",// 重启服务
    Escalate = "escalate"
}
/**
 * 错误处理配置
 */
interface ErrorHandlerConfig {
    maxRetryAttempts: number;
    retryDelay: number;
    enableAutoRecovery: boolean;
    enableErrorReporting: boolean;
    errorReportingEndpoint?: string;
}
/**
 * 错误统计信息
 */
interface ErrorStats {
    totalErrors: number;
    errorsByType: Record<NetworkErrorType, number>;
    errorsBySeverity: Record<ErrorSeverity, number>;
    recoveredErrors: number;
    unrecoveredErrors: number;
    lastError?: INetworkError;
}
/**
 * 错误处理事件
 */
interface ErrorHandlerEvents {
    errorOccurred: (error: INetworkError, severity: ErrorSeverity) => void;
    errorRecovered: (error: INetworkError, strategy: RecoveryStrategy) => void;
    errorUnrecoverable: (error: INetworkError) => void;
    criticalError: (error: INetworkError) => void;
}
/**
 * 网络错误处理器
 */
declare class ErrorHandler {
    private logger;
    private config;
    private stats;
    private eventHandlers;
    private retryAttempts;
    private pendingRecoveries;
    private severityRules;
    private recoveryRules;
    /**
     * 构造函数
     */
    constructor(config?: Partial<ErrorHandlerConfig>);
    /**
     * 处理错误
     */
    handleError(error: Error | INetworkError, context?: string): void;
    /**
     * 设置错误分类规则
     */
    setErrorSeverityRule(errorType: NetworkErrorType, severity: ErrorSeverity): void;
    /**
     * 设置错误恢复策略
     */
    setRecoveryStrategy(errorType: NetworkErrorType, strategy: RecoveryStrategy): void;
    /**
     * 获取错误统计
     */
    getStats(): ErrorStats;
    /**
     * 重置统计信息
     */
    resetStats(): void;
    /**
     * 设置事件处理器
     */
    on<K extends keyof ErrorHandlerEvents>(event: K, handler: ErrorHandlerEvents[K]): void;
    /**
     * 移除事件处理器
     */
    off<K extends keyof ErrorHandlerEvents>(event: K): void;
    /**
     * 更新配置
     */
    updateConfig(newConfig: Partial<ErrorHandlerConfig>): void;
    /**
     * 手动标记错误已恢复
     */
    markErrorRecovered(errorId: string): void;
    /**
     * 检查错误是否可恢复
     */
    isRecoverable(errorType: NetworkErrorType): boolean;
    /**
     * 标准化错误对象
     */
    private normalizeError;
    /**
     * 确定错误类型
     */
    private determineErrorType;
    /**
     * 分类错误严重程度
     */
    private classifyErrorSeverity;
    /**
     * 更新统计信息
     */
    private updateStats;
    /**
     * 尝试错误恢复
     */
    private attemptRecovery;
    /**
     * 执行恢复策略
     */
    private executeRecoveryStrategy;
    /**
     * 报告错误
     */
    private reportError;
    /**
     * 生成错误ID
     */
    private generateErrorId;
    /**
     * 初始化默认规则
     */
    private initializeDefaultRules;
    /**
     * 获取错误趋势分析
     */
    getErrorTrends(): ErrorTrendAnalysis;
}

/**
 * 序列化器配置
 */
interface SerializerConfig {
    enableTypeChecking: boolean;
    enableCompression: boolean;
    maxMessageSize: number;
    enableProfiling: boolean;
    customSerializers?: Map<string, ICustomSerializer>;
}
/**
 * JSON序列化消息验证结果
 */
interface JsonMessageValidationResult {
    isValid: boolean;
    errors: string[];
}
/**
 * 自定义序列化器接口
 */
interface ICustomSerializer {
    serialize(data: any): any;
    deserialize(data: any): any;
    canHandle(data: any): boolean;
}
/**
 * 序列化结果
 */
interface SerializationResult$2 {
    data: string | Buffer;
    size: number;
    compressionRatio?: number;
    serializationTime: number;
}
/**
 * 反序列化结果
 */
interface DeserializationResult$2<T = any> {
    data: T;
    deserializationTime: number;
    isValid: boolean;
    errors?: string[];
}
/**
 * 序列化统计信息
 */
interface SerializationStats {
    totalSerialized: number;
    totalDeserialized: number;
    totalBytes: number;
    averageSerializationTime: number;
    averageDeserializationTime: number;
    averageMessageSize: number;
    errorCount: number;
    compressionSavings: number;
}
/**
 * JSON序列化器
 */
declare class JSONSerializer {
    private logger;
    private config;
    private stats;
    private serializationTimes;
    private deserializationTimes;
    private messageSizes;
    /**
     * 构造函数
     */
    constructor(config?: Partial<SerializerConfig>);
    /**
     * 序列化消息
     */
    serialize<T extends INetworkMessage>(message: T): SerializationResult$2;
    /**
     * 反序列化消息
     */
    deserialize<T extends INetworkMessage>(data: string | ArrayBuffer): DeserializationResult$2<T>;
    /**
     * 批量序列化
     */
    serializeBatch<T extends INetworkMessage>(messages: T[]): SerializationResult$2;
    /**
     * 批量反序列化
     */
    deserializeBatch<T extends INetworkMessage>(data: string | ArrayBuffer): DeserializationResult$2<T[]>;
    /**
     * 获取统计信息
     */
    getStats(): SerializationStats;
    /**
     * 重置统计信息
     */
    resetStats(): void;
    /**
     * 添加自定义序列化器
     */
    addCustomSerializer(name: string, serializer: ICustomSerializer): void;
    /**
     * 移除自定义序列化器
     */
    removeCustomSerializer(name: string): boolean;
    /**
     * 更新配置
     */
    updateConfig(newConfig: Partial<SerializerConfig>): void;
    /**
     * 验证消息格式
     */
    private validateMessage;
    /**
     * 验证解析后的消息
     */
    private validateParsedMessage;
    /**
     * 预处理消息（序列化前）
     */
    private preprocessMessage;
    /**
     * 后处理消息（反序列化后）
     */
    private postprocessMessage;
    /**
     * 序列化特殊类型
     */
    private serializeSpecialTypes;
    /**
     * 反序列化特殊类型
     */
    private deserializeSpecialTypes;
    /**
     * 创建JSON.stringify替换函数
     */
    private createReplacer;
    /**
     * 创建JSON.parse恢复函数
     */
    private createReviver;
    /**
     * 查找自定义序列化器
     */
    private findCustomSerializer;
    /**
     * 更新序列化统计
     */
    private updateSerializationStats;
    /**
     * 更新反序列化统计
     */
    private updateDeserializationStats;
    /**
     * 获取性能分析报告
     */
    getPerformanceReport(): {
        stats: SerializationStats;
        serializationTimes: number[];
        deserializationTimes: number[];
        messageSizes: number[];
        percentiles: {
            serialization: {
                p50?: undefined;
                p90?: undefined;
                p95?: undefined;
                p99?: undefined;
            } | {
                p50: number;
                p90: number;
                p95: number;
                p99: number;
            };
            deserialization: {
                p50?: undefined;
                p90?: undefined;
                p95?: undefined;
                p99?: undefined;
            } | {
                p50: number;
                p90: number;
                p95: number;
                p99: number;
            };
            messageSize: {
                p50?: undefined;
                p90?: undefined;
                p95?: undefined;
                p99?: undefined;
            } | {
                p50: number;
                p90: number;
                p95: number;
                p99: number;
            };
        };
    };
    /**
     * 计算百分位数
     */
    private calculatePercentiles;
}

/**
 * 容器头结构
 */
interface ContainerHeader {
    /** 魔数标识 'MCF0' */
    magic: 'MCF0';
    /** 版本号 */
    version: 1;
    /** 压缩算法名称 */
    algo: string;
    /** 原始数据大小 */
    originalSize: number;
    /** 标志位，预留扩展用 */
    flags: number;
}
/**
 * 容器头解析结果
 */
interface ParsedHeader {
    /** 解析到的头部信息 */
    header: ContainerHeader;
    /** 头部字节长度 */
    headerSize: number;
    /** 载荷数据 */
    payload: Uint8Array;
}
/**
 * 压缩算法接口
 */
interface ICompressionAlgorithm {
    /** 算法名称 */
    readonly name: string;
    /** 算法版本 */
    readonly version: string;
    /** 是否支持异步压缩 */
    readonly supportsAsync: boolean;
    /**
     * 同步压缩
     * @param data - 待压缩的字节数据
     * @returns 压缩后的字节数据
     */
    compress(data: Uint8Array): Uint8Array;
    /**
     * 同步解压缩
     * @param data - 待解压的字节数据
     * @returns 解压后的字节数据
     */
    decompress(data: Uint8Array): Uint8Array;
    /**
     * 异步压缩（可选）
     */
    compressAsync?(data: Uint8Array): Promise<Uint8Array>;
    /**
     * 异步解压缩（可选）
     */
    decompressAsync?(data: Uint8Array): Promise<Uint8Array>;
}
/**
 * 压缩配置
 */
interface CompressionConfig {
    /** 默认压缩算法名称 */
    defaultAlgorithm: string;
    /** 最小压缩阈值（字节） */
    threshold: number;
    /** 是否启用异步压缩 */
    enableAsync: boolean;
    /** 压缩级别提示 (0-9) */
    level: number;
    /** 分块大小 */
    chunkSize: number;
    /** 是否启用压缩统计 */
    enableStats: boolean;
}
/**
 * 压缩结果
 */
interface CompressionResult {
    /** 压缩后的数据 */
    data: ArrayBuffer;
    /** 原始大小 */
    originalSize: number;
    /** 压缩后大小 */
    compressedSize: number;
    /** 压缩比 */
    compressionRatio: number;
    /** 压缩耗时 */
    compressionTime: number;
    /** 使用的算法 */
    algorithm: string;
    /** 是否实际进行了压缩 */
    wasCompressed: boolean;
}
/**
 * 解压缩结果
 */
interface DecompressionResult {
    /** 解压缩后的数据 */
    data: ArrayBuffer;
    /** 原始压缩大小 */
    compressedSize: number;
    /** 解压缩后大小 */
    decompressedSize: number;
    /** 解压缩耗时 */
    decompressionTime: number;
    /** 使用的算法 */
    algorithm: string;
}
/**
 * 压缩统计信息
 */
interface CompressionStats {
    /** 总压缩次数 */
    totalCompressions: number;
    /** 总解压缩次数 */
    totalDecompressions: number;
    /** 总原始字节数 */
    totalOriginalBytes: number;
    /** 总压缩字节数 */
    totalCompressedBytes: number;
    /** 平均压缩比 */
    averageCompressionRatio: number;
    /** 平均压缩时间 */
    averageCompressionTime: number;
    /** 平均解压缩时间 */
    averageDecompressionTime: number;
    /** 算法使用统计 */
    algorithmUsage: Record<string, number>;
}
/**
 * 无压缩算法实现（默认）
 */
declare class NoCompressionAlgorithm implements ICompressionAlgorithm {
    readonly name = "none";
    readonly version = "1.0.0";
    readonly supportsAsync = false;
    compress(data: Uint8Array): Uint8Array;
    decompress(data: Uint8Array): Uint8Array;
}
/**
 * LZ字符串压缩算法实现
 */
declare class LZCompressionAlgorithm implements ICompressionAlgorithm {
    readonly name = "lz-string";
    readonly version = "1.0.0";
    readonly supportsAsync = false;
    compress(data: Uint8Array): Uint8Array;
    decompress(data: Uint8Array): Uint8Array;
    /**
     * 将数字数组编码为字节数组
     */
    private numbersToUint8Array;
    /**
     * 将字节数组解码为数字数组
     */
    private uint8ArrayToNumbers;
}
/**
 * 消息压缩器
 */
declare class MessageCompressor {
    private logger;
    private config;
    private algorithms;
    private stats;
    /**
     * 构造函数
     */
    constructor(config?: Partial<CompressionConfig>);
    /**
     * 注册压缩算法
     */
    registerAlgorithm(algorithm: ICompressionAlgorithm): void;
    /**
     * 注销压缩算法
     */
    unregisterAlgorithm(algorithmName: string): boolean;
    /**
     * 获取已注册的算法列表
     */
    getRegisteredAlgorithms(): string[];
    /**
     * 检查算法是否已注册
     */
    hasAlgorithm(algorithmName: string): boolean;
    /**
     * 压缩数据
     */
    compress(data: ArrayBuffer | string, algorithmName?: string): Promise<CompressionResult>;
    /**
     * 解压缩数据
     */
    decompress(data: ArrayBuffer): Promise<DecompressionResult>;
    /**
     * 获取压缩统计信息
     */
    getStats(): CompressionStats;
    /**
     * 重置统计信息
     */
    resetStats(): void;
    /**
     * 更新配置
     */
    updateConfig(newConfig: Partial<CompressionConfig>): void;
    /**
     * 获取配置
     */
    getConfig(): CompressionConfig;
    /**
     * 更新压缩统计信息
     */
    private updateCompressionStats;
    /**
     * 更新解压缩统计信息
     */
    private updateDecompressionStats;
    /**
     * 编码容器头
     * 格式: [MAGIC:4] 'MCF0' | [ver:1] | [algoLen:1] | [algoName:algoLen]
     *       [origLen:4, LE] | [flags:1] | [payload:...]
     */
    private encodeContainerHeader;
    /**
     * 解码容器头
     */
    private decodeContainerHeader;
    /**
     * 检测是否为新的容器格式
     */
    private isContainerFormat;
}
/**
 * 全局压缩器实例
 */
declare const globalCompressor: MessageCompressor;

/**
 * SyncVar支持的值类型
 */
type SyncVarValue = string | number | boolean | object | null | undefined;
/**
 * SyncVar配置选项
 */
interface SyncVarOptions<T = SyncVarValue> {
    /** 同步模式 */
    mode?: SyncMode;
    /** 同步频率(毫秒) */
    syncRate?: number;
    /** 权限类型 */
    authority?: AuthorityType;
    /** 网络作用域 */
    scope?: NetworkScope;
    /** 变化阈值，用于数值类型 */
    threshold?: number;
    /** 是否启用压缩 */
    compression?: boolean;
    /** 优先级(0-10，数值越高优先级越高) */
    priority?: number;
    /** 是否启用插值 */
    interpolation?: boolean;
    /** 自定义序列化函数 */
    customSerializer?: (value: T) => unknown;
    /** 自定义反序列化函数 */
    customDeserializer?: (value: unknown) => T;
    /** 变化回调函数 */
    onChanged?: (oldValue: T, newValue: T) => void;
}
/**
 * SyncVar元数据
 */
interface SyncVarMetadata<T = SyncVarValue> {
    propertyKey: string | symbol;
    options: Required<SyncVarOptions<T>>;
    originalDescriptor?: PropertyDescriptor;
    lastValue?: T;
    lastSyncTime: number;
    isDirty: boolean;
    syncCount: number;
}
/**
 * 存储SyncVar元数据的Symbol键
 */
declare const SYNCVAR_METADATA_KEY: unique symbol;
/**
 * 默认SyncVar配置
 */
declare const DEFAULT_SYNCVAR_OPTIONS: Required<SyncVarOptions<SyncVarValue>>;
/**
 * SyncVar装饰器
 * 用于标记需要网络同步的属性
 */
declare function SyncVar<T extends SyncVarValue = SyncVarValue>(options?: SyncVarOptions<T>): (target: object, propertyKey: string | symbol) => void;
/**
 * 获取对象的所有SyncVar元数据
 */
declare function getSyncVarMetadata(target: object): Map<string | symbol, SyncVarMetadata>;
/**
 * 获取特定属性的SyncVar元数据
 */
declare function getSyncVarPropertyMetadata(target: object, propertyKey: string | symbol): SyncVarMetadata | undefined;
/**
 * 检查对象是否有SyncVar属性
 */
declare function hasSyncVars(target: object): boolean;
/**
 * 获取对象的所有脏SyncVar属性
 */
declare function getDirtySyncVars(target: object): Map<string | symbol, SyncVarMetadata>;
/**
 * 清理所有脏标记
 */
declare function clearDirtyFlags(target: object): void;
/**
 * 重置SyncVar统计信息
 */
declare function resetSyncVarStats(target: object): void;
/**
 * SyncVar统计信息条目
 */
interface SyncVarStatEntry {
    syncCount: number;
    lastSyncTime: number;
    isDirty: boolean;
}
/**
 * SyncVar统计信息映射
 */
interface SyncVarStatsMap {
    [key: string]: SyncVarStatEntry;
}
/**
 * 获取SyncVar统计信息
 */
declare function getSyncVarStats(target: object): SyncVarStatsMap;

/**
 * 网络层专用的EventEmitter实现
 * 继承自core库的Emitter，提供简单的事件API
 */

/**
 * 网络事件发射器，专为网络层设计
 * 使用字符串或symbol作为事件类型，简化API
 */
declare class EventEmitter<T = Record<string, (...args: any[]) => void>> extends Emitter<string | symbol, void> {
    constructor();
    /**
     * 添加事件监听器
     * @param event - 事件名称
     * @param listener - 监听函数
     */
    on(event: string | symbol, listener: Function): this;
    /**
     * 添加一次性事件监听器
     * @param event - 事件名称
     * @param listener - 监听函数
     */
    once(event: string | symbol, listener: Function): this;
    /**
     * 移除事件监听器
     * @param event - 事件名称
     * @param listener - 监听函数，不传则移除所有
     */
    off(event: string | symbol, listener?: Function): this;
    /**
     * 移除事件监听器（别名）
     */
    removeListener(event: string | symbol, listener: Function): this;
    /**
     * 移除所有监听器
     */
    removeAllListeners(event?: string | symbol): this;
    /**
     * 获取监听器数量
     */
    listenerCount(event: string | symbol): number;
    /**
     * 发射事件（兼容Node.js EventEmitter）
     * @param event - 事件名称
     * @param args - 事件参数
     */
    emit(event: string | symbol, ...args: any[]): boolean;
}

/**
 * 属性值映射类型
 */
interface PropertyChanges {
    [propertyKey: string]: SyncVarValue;
}
/**
 * 同步模式映射类型
 */
interface SyncModeMap {
    [propertyKey: string]: SyncMode;
}
/**
 * 权限映射类型
 */
interface AuthorityMap {
    [propertyKey: string]: AuthorityType;
}
/**
 * 作用域映射类型
 */
interface ScopeMap {
    [propertyKey: string]: NetworkScope;
}
/**
 * 优先级映射类型
 */
interface PriorityMap {
    [propertyKey: string]: number;
}
/**
 * 同步批次数据
 */
interface SyncBatch {
    /** 实例ID */
    instanceId: string;
    /** 实例类型 */
    instanceType: string;
    /** 变化的属性数据 */
    changes: PropertyChanges;
    /** 时间戳 */
    timestamp: number;
    /** 同步模式映射 */
    syncModes: SyncModeMap;
    /** 权限映射 */
    authorities: AuthorityMap;
    /** 作用域映射 */
    scopes: ScopeMap;
    /** 优先级映射 */
    priorities: PriorityMap;
}
/**
 * 同步统计信息
 */
interface SyncStats {
    /** 注册的实例数量 */
    registeredInstances: number;
    /** 脏实例数量 */
    dirtyInstances: number;
    /** 总同步次数 */
    totalSyncs: number;
    /** 总传输字节数 */
    totalBytes: number;
    /** 平均同步延迟 */
    averageLatency: number;
    /** 每秒同步次数 */
    syncsPerSecond: number;
    /** 最后同步时间 */
    lastSyncTime: number;
}
/**
 * SyncVar管理器
 * 负责管理所有带有SyncVar的实例，追踪变化并生成同步批次
 */
declare class SyncVarMana