easemob-websdk 4.24.1 → 5.0.0

package/core/connection/heartbeat.d.ts

@@ -0,0 +1,68 @@
+/**
+ * 心跳机制
+ *
+ * 实现 ping/pong 机制，超时处理
+ * 参考：HEARTBEAT_INTERVAL = 30000ms
+ */
+import { type SocketLike } from '../../platform';
+/**
+ * 心跳配置
+ */
+export interface HeartbeatConfig {
+    interval?: number;
+    timeout?: number;
+}
+/**
+ * 心跳管理器
+ */
+export declare class HeartbeatManager {
+    private config;
+    private websocket;
+    private heartbeatTimer;
+    private timeoutTimer;
+    private lastPongTime;
+    private onTimeoutCallback;
+    private sendPing;
+    private probeResolvers;
+    private messageDisposer;
+    private readonly handlePong;
+    constructor(config?: HeartbeatConfig);
+    /**
+     * 启动心跳
+     */
+    start(websocket: SocketLike, onTimeout?: () => void, sendPing?: () => void): void;
+    /**
+     * 停止心跳
+     */
+    stop(): void;
+    /**
+     * 发送 ping
+     */
+    private sendPingInternal;
+    /**
+     * 处理 pong 消息
+     */
+    private extractMessageText;
+    private parseJson;
+    private static isRecord;
+    private static readString;
+    /**
+     * 重置超时定时器
+     */
+    private resetTimeout;
+    /**
+     * 标记心跳成功
+     */
+    markAlive(): void;
+    /**
+     * 获取最后 pong 时间
+     */
+    getLastPongTime(): number;
+    /**
+     * 单次心跳探测
+     */
+    probeOnce(websocket: SocketLike, timeoutMs?: number): Promise<boolean>;
+    private attachWebSocket;
+    private resolveProbe;
+    private removeProbeResolver;
+}

package/core/contact-sync/contact-roster-event-sidecar.d.ts

@@ -0,0 +1,3 @@
+import type { ContactRosterEventPayload } from '../../types/contact';
+export declare const setContactRosterVersionSidecar: (payload: ContactRosterEventPayload, rosterVersion: string | undefined) => void;
+export declare const getContactRosterVersionSidecar: (payload: ContactRosterEventPayload) => string | undefined;

package/core/contact-sync/roster-sync-client.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 联系人同步 websocket 客户端
+ */
+import type { SharedSyncWebSocketSession } from '../sync/shared-sync-websocket-session';
+import type { RosterRequest } from '../../protocol/roster/types';
+export declare class RosterSyncClient {
+    private readonly codec;
+    private readonly sharedSession;
+    constructor(sharedSession: SharedSyncWebSocketSession);
+    sync(options: {
+        urls: ReadonlyArray<string>;
+        request: RosterRequest;
+    }): Promise<{
+        readonly mode: 'full' | 'incremental';
+        readonly version: string;
+        readonly pages: ReadonlyArray<import('../../protocol/roster/types').RosterResponse>;
+    }>;
+    cancel(): void;
+    private syncWithSharedSession;
+    private buildAttemptRequest;
+}

package/core/contact-sync/roster-sync-controller.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 联系人同步控制器
+ */
+import type { ContactSyncContextState, ContactSyncDependencies, ContactSyncDecisionResult } from './roster-sync-types';
+export declare const decideContactSync: (options: {
+    metadata?: {
+        readonly version: string;
+        readonly requiresSync: boolean;
+    };
+    metadataFailed?: boolean;
+    state: ContactSyncContextState;
+}) => ContactSyncDecisionResult;
+export declare class RosterSyncController {
+    private readonly dependencies;
+    private running;
+    constructor(dependencies: ContactSyncDependencies);
+    sync(): Promise<void>;
+    cancel(): void;
+    private runSync;
+}

package/core/contact-sync/roster-sync-session.d.ts

@@ -0,0 +1,28 @@
+/**
+ * 联系人同步分页会话
+ */
+import type { RosterResponse } from '../../protocol/roster/types';
+export declare class RosterSyncSession {
+    private readonly requestId;
+    private readonly pages;
+    private responseType;
+    private version;
+    private nextCursor;
+    private pageCount;
+    private completed;
+    constructor(requestId: string);
+    push(page: RosterResponse): {
+        readonly done: boolean;
+        readonly nextCursor: number;
+        readonly pageCount: number;
+    };
+    getNextCursor(): number;
+    getPageCount(): number;
+    hasPages(): boolean;
+    isCompleted(): boolean;
+    buildResult(): {
+        readonly mode: 'full' | 'incremental';
+        readonly version: string;
+        readonly pages: ReadonlyArray<RosterResponse>;
+    };
+}

package/core/contact-sync/roster-sync-types.d.ts

@@ -0,0 +1,74 @@
+/**
+ * 联系人同步内部类型
+ */
+import type { ContactCacheMeta, ContactRelationRecord, ContactVersionState } from '../../cache/cache-types';
+import type { ContactSnapshot, ContactSyncDecision, ContactSyncStage } from '../../types/contact';
+import type { ContactMetadataVersionResponse } from '../../rest/contact-metadata';
+import type { RosterRequest, RosterResponse } from '../../protocol/roster/types';
+import type { SharedSyncWebSocketSession } from '../sync/shared-sync-websocket-session';
+export interface ContactSyncDecisionResult {
+    readonly decision: ContactSyncDecision;
+    readonly version: string;
+}
+export interface ParsedRosterMetadata {
+    readonly nickname?: string;
+    readonly avatarUrl?: string;
+    readonly sign?: string;
+    readonly ext?: string;
+}
+export interface ParsedRosterItem {
+    readonly relation: ContactRelationRecord;
+    readonly userInfo: {
+        readonly userId: string;
+        readonly nickname?: string;
+        readonly avatarUrl?: string;
+        readonly sign?: string;
+        readonly ext?: string;
+    };
+}
+export interface ContactSyncContextState {
+    readonly cacheMeta: ContactCacheMeta;
+    readonly versionState: ContactVersionState;
+    readonly cachedSnapshot: ContactSnapshot;
+}
+export interface ContactSyncFailure {
+    readonly code: number;
+    readonly stage: ContactSyncStage;
+    readonly message: string;
+    readonly retryable: boolean;
+}
+export interface RosterSyncExecutionResult {
+    readonly mode: 'full' | 'incremental';
+    readonly version: string;
+    readonly pages: ReadonlyArray<RosterResponse>;
+}
+export interface ContactSyncDependencies {
+    readonly getContextState: () => ContactSyncContextState;
+    readonly queryMetadata: (currentVersion: string) => Promise<ContactMetadataVersionResponse>;
+    readonly getSyncUrls: () => Promise<ReadonlyArray<string>>;
+    readonly getSharedSyncSession: () => SharedSyncWebSocketSession;
+    readonly buildRosterRequest: (options: {
+        decision: ContactSyncDecision;
+        version: string;
+    }) => RosterRequest;
+    readonly applySyncResult: (options: {
+        mode: 'full' | 'incremental';
+        relations: ReadonlyArray<ContactRelationRecord>;
+        userInfos: ReadonlyArray<{
+            readonly userId: string;
+            readonly nickname?: string;
+            readonly avatarUrl?: string;
+            readonly sign?: string;
+            readonly ext?: string;
+        }>;
+        version: string;
+        lastSyncTs: number;
+    }) => {
+        readonly snapshot: ContactSnapshot;
+        readonly changed: boolean;
+    };
+    readonly onStart: () => void;
+    readonly onFinish: (payload?: {
+        readonly error: ContactSyncFailure;
+    }) => void;
+}

package/core/events/event-hub.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 统一事件系统 EventHub
+ */
+import type { EventHandlerId, EventHandlerMap, EventName, EventPayloadMap } from '../../types/event-system';
+export declare class EventHub {
+    private handlers;
+    addEventHandler(id: EventHandlerId, handlers: EventHandlerMap): void;
+    removeEventHandler(id: EventHandlerId): void;
+    dispatch<K extends EventName>(event: K, payload: EventPayloadMap[K]): void;
+    private dispatchToHandlers;
+    private invokeHandler;
+    private isPromiseLike;
+}

package/core/group-sync/group-sync-client.d.ts

@@ -0,0 +1,19 @@
+import { SDKError } from '../../utils/errors';
+import type { SharedSyncWebSocketSession } from '../sync/shared-sync-websocket-session';
+import type { JoinedGroupsErrorDetail, JoinedGroupsRequest, JoinedGroupsResponse } from '../../protocol/joined-groups/types';
+export declare const mapJoinedGroupsApiError: (detail: JoinedGroupsErrorDetail) => SDKError;
+export declare class GroupSyncClient {
+    private readonly codec;
+    private readonly sharedSession;
+    constructor(sharedSession: SharedSyncWebSocketSession);
+    sync(options: {
+        readonly urls: ReadonlyArray<string>;
+        readonly request: JoinedGroupsRequest;
+    }): Promise<{
+        readonly batches: ReadonlyArray<JoinedGroupsResponse>;
+        readonly lastSyncFinishedTs?: number;
+    }>;
+    cancel(): void;
+    private syncWithSharedSession;
+    private buildAttemptRequest;
+}

package/core/group-sync/group-sync-controller.d.ts

@@ -0,0 +1,11 @@
+import type { GroupSyncControllerDependencies } from './group-sync-types';
+export declare class GroupSyncController {
+    private readonly dependencies;
+    private running;
+    constructor(dependencies: GroupSyncControllerDependencies);
+    sync(): Promise<void>;
+    cancel(): void;
+    private runSync;
+    private hasSameMembership;
+    private buildRequest;
+}

package/core/group-sync/group-sync-merge.d.ts

@@ -0,0 +1,3 @@
+import type { JoinedGroupSnapshot } from '../../types/group';
+import type { GroupSyncMergeInput } from './group-sync-types';
+export declare const mergeJoinedGroupSnapshot: (input: GroupSyncMergeInput) => JoinedGroupSnapshot;

package/core/group-sync/group-sync-normalizer.d.ts

@@ -0,0 +1,4 @@
+import type { JoinedGroupProtocolItem } from '../../protocol/joined-groups/types';
+import type { JoinedGroupSummary } from '../../types/group';
+export declare const normalizeJoinedGroupItem: (item: JoinedGroupProtocolItem) => JoinedGroupSummary | null;
+export declare const normalizeJoinedGroupItems: (items: ReadonlyArray<JoinedGroupProtocolItem>) => ReadonlyArray<JoinedGroupSummary>;

package/core/group-sync/group-sync-session.d.ts

@@ -0,0 +1,17 @@
+import type { JoinedGroupsResponse } from '../../protocol/joined-groups/types';
+export declare class GroupSyncSession {
+    private readonly requestId;
+    private readonly batches;
+    private latestCursor;
+    private done;
+    private lastSyncFinishedTs;
+    constructor(requestId: string);
+    getResumeCursor(): string | undefined;
+    push(response: JoinedGroupsResponse): {
+        readonly done: boolean;
+    };
+    buildResult(): {
+        readonly batches: ReadonlyArray<JoinedGroupsResponse>;
+        readonly lastSyncFinishedTs?: number;
+    };
+}

package/core/group-sync/group-sync-types.d.ts

@@ -0,0 +1,24 @@
+import type { CacheManager } from '../../cache/cache-manager';
+import type { JoinedGroupSnapshot, JoinedGroupSummary } from '../../types/group';
+import type { SyncDataError } from '../../types/sync-data';
+import type { RestContext } from '../../types/chat-client';
+import type { SharedSyncWebSocketSession } from '../sync/shared-sync-websocket-session';
+export type GroupSyncStage = 'config' | 'socket_connect' | 'request_send' | 'response_decode' | 'batch_merge' | 'preview_persist' | 'completion_meta' | 'auth' | 'server_limit' | 'cancelled';
+export interface GroupSyncControllerDependencies {
+    readonly getRestContext: () => RestContext;
+    readonly getSyncUrls: () => Promise<ReadonlyArray<string>>;
+    readonly getSharedSyncSession: () => SharedSyncWebSocketSession;
+    readonly getCacheManager: () => CacheManager;
+    readonly getRuntimeSnapshot: () => JoinedGroupSnapshot | null;
+    readonly applyRuntimeSnapshot: (snapshot: JoinedGroupSnapshot) => void;
+    readonly onStart: () => void;
+    readonly onFinish: (payload: {
+        readonly status: 'success' | 'failed';
+        readonly error?: SyncDataError;
+    }) => void;
+}
+export interface GroupSyncMergeInput {
+    readonly existingItems: ReadonlyArray<JoinedGroupSummary>;
+    readonly incomingItems: ReadonlyArray<JoinedGroupSummary>;
+    readonly lastSyncFinishedTs?: number;
+}

package/core/group-sync/index.d.ts

@@ -0,0 +1,4 @@
+export * from './group-sync-controller';
+export * from './group-sync-normalizer';
+export * from './group-sync-merge';
+export * from './group-sync-types';

package/core/index.d.ts

@@ -0,0 +1,95 @@
+/**
+ * 核心模块集成
+ *
+ * 集成连接和消息组件
+ */
+import { EventHub } from './events/event-hub';
+import type { ConnectionStatus, Message, DownloadCombineMessageParams, MessageAttachmentDownloadResult, SendMessageOptions, TokenRenewalResult } from '../types';
+import type { PlatformFactoryResult, SocketAdapter } from '../platform';
+import type { MessageActionRequest, ActionAckResult } from './message/message-action-types';
+import type { ChatRoomOperationRequest } from './message/chatroom-operation-types';
+/**
+ * 核心 SDK 类
+ */
+export declare class CoreSDK {
+    private eventHub;
+    private connectionManager;
+    private messageSender;
+    private messageReceiver;
+    private combineMessageDownloader;
+    private attachmentDownloader;
+    private readonly platformAdapter;
+    private runtimeEventBridge;
+    private readonly handleOnline;
+    private readonly handleOffline;
+    private readonly handleForegroundChange;
+    constructor(config: {
+        serverUrl: string;
+        serverUrls?: ReadonlyArray<string>;
+        userId: string;
+        token: string;
+        appKey: string;
+        restBaseUrl?: string;
+        useCustomAttachmentUpload?: boolean;
+        enableMd5Check?: boolean;
+        enableMultipartUpload?: boolean;
+        heartBeatWait?: number;
+        autoReconnectNumMax?: number;
+        useReplacedMessageContents?: boolean;
+        useFixedDeviceId?: boolean;
+        deviceId?: string;
+        customDeviceName?: string;
+        customOSPlatform?: number;
+        uiKitVersion?: string;
+        loginExtensionInfo?: string;
+        serviceId?: string;
+        platformAdapter?: PlatformFactoryResult;
+        socketAdapter?: SocketAdapter;
+        enableDeliveryReceipt?: boolean;
+    }, eventHub: EventHub);
+    /**
+     * 设置事件处理器
+     */
+    private setupEventHandlers;
+    private registerNetworkListeners;
+    private unregisterNetworkListeners;
+    private resolveRuntimeAdapter;
+    private createBrowserRuntimeAdapter;
+    /**
+     * 连接
+     */
+    connect(): Promise<void>;
+    /**
+     * 断开连接
+     */
+    disconnect(): Promise<void>;
+    /**
+     * 获取连接状态
+     */
+    getConnectionStatus(): ConnectionStatus;
+    /**
+     * 获取客户端资源标识
+     */
+    getClientResource(): string;
+    /**
+     * 更新当前连接与发送链路使用的 IM token。
+     * Updates the IM token used by connection and send pipeline.
+     */
+    renewToken(token: string, expireAt: number): TokenRenewalResult;
+    /**
+     * 发送消息
+     */
+    sendMessage(message: Message, options?: SendMessageOptions): Promise<Message>;
+    sendMessageAction(action: MessageActionRequest, createAckError?: (statusCode: number, reason?: string) => Error): Promise<ActionAckResult>;
+    sendChatRoomOperation(request: ChatRoomOperationRequest, createAckError?: (statusCode: number, reason?: string) => Error): Promise<ActionAckResult>;
+    /**
+     * 下载并解析合并消息详情
+     */
+    downloadAndParseCombineMessage(options: DownloadCombineMessageParams): Promise<ReadonlyArray<Message>>;
+    downloadAttachment(message: Message, timeoutMs?: number): Promise<MessageAttachmentDownloadResult>;
+    decodeServerMessageMeta(metaPayload: Uint8Array): Message | null;
+    /**
+     * 销毁
+     */
+    destroy(): void;
+}

package/core/message/attachment-downloader.d.ts

@@ -0,0 +1,7 @@
+import type { RequestAdapter } from '../../platform';
+import type { Message, MessageAttachmentDownloadResult } from '../../types';
+export declare class AttachmentDownloader {
+    private readonly requestAdapter;
+    constructor(requestAdapter?: RequestAdapter);
+    download(message: Message, timeoutMs?: number): Promise<MessageAttachmentDownloadResult>;
+}

package/core/message/chatroom-operation-types.d.ts

@@ -0,0 +1,6 @@
+export interface ChatRoomOperationRequest {
+    readonly operation: 'join' | 'leave';
+    readonly chatRoomId: string;
+    readonly ext?: string;
+    readonly leaveOtherRooms?: boolean;
+}

package/core/message/combine-message-downloader.d.ts

@@ -0,0 +1,7 @@
+import type { RequestAdapter } from '../../platform';
+import type { DownloadCombineMessageParams, Message } from '../../types';
+export declare class CombineMessageDownloader {
+    private readonly requestAdapter;
+    constructor(requestAdapter?: RequestAdapter);
+    downloadAndParse(options: DownloadCombineMessageParams): Promise<ReadonlyArray<Message>>;
+}

package/core/message/message-action-types.d.ts

@@ -0,0 +1,22 @@
+import type { ChatConversationType } from '../../types/chat-manager';
+import type { JoinChatRoomInfo } from '../../types/chatroom';
+import type { Message, MessageBody } from '../../types';
+export interface MessageActionRequest {
+    readonly kind: 'clearConversationUnreadMessageCount' | 'clearAllConversationUnreadMessageCount' | 'sendMessageReadReceipts' | 'recall' | 'update' | 'deliveryAck';
+    readonly conversationId: string;
+    readonly conversationType: ChatConversationType;
+    readonly messageId?: string;
+    readonly messageIds?: ReadonlyArray<string>;
+    readonly sendToPeer?: boolean;
+    readonly clearAllUnreadMessageCount?: boolean;
+    readonly body?: MessageBody;
+    readonly messageType?: Message['type'];
+    readonly ext?: Record<string, unknown>;
+}
+export interface ActionAckResult {
+    readonly protocolId: string;
+    readonly serverId: string;
+    readonly statusCode: number;
+    readonly reason?: string;
+    readonly chatRoomInfo?: JoinChatRoomInfo;
+}

package/core/message/message-deduplicator.d.ts

@@ -0,0 +1,11 @@
+/** 普通消息最近 ID 的有界去重器。 */
+export declare class RecentMessageIdDeduper {
+    private readonly limit;
+    private readonly seenIds;
+    private readonly orderedIds;
+    constructor(limit?: number);
+    /** 返回 true 表示 ID 已在当前窗口内出现。 */
+    checkAndRecord(messageId: string): boolean;
+    clear(): void;
+    size(): number;
+}

package/core/message/message-receiver.d.ts

@@ -0,0 +1,65 @@
+/**
+ * 消息接收器
+ *
+ * 负责处理下行 SYNC 消息：解析 ACK 与聊天消息，并派发事件。
+ */
+import { EventHub } from '../events/event-hub';
+import type { Message } from '../../types';
+import type { MsyncCodec, SyncDecodeResult } from '../../protocol/msync/codec';
+import type { MessageSender } from './message-sender';
+/**
+ * 消息接收器
+ */
+export declare class MessageReceiver {
+    private eventHub;
+    private messageSender;
+    private msyncCodec;
+    private streamMessageHandler;
+    private readonly messageContexts;
+    private readonly recentMessageIds;
+    private enableDeliveryReceipt;
+    constructor(msyncCodec: MsyncCodec, messageSender: MessageSender, eventHub: EventHub);
+    setDeliveryAckEnabled(enabled: boolean): void;
+    rememberSentMessageContext(message: Message): void;
+    /**
+     * 处理 SYNC payload，分离 ACK 与聊天消息
+     */
+    handleSyncPayload(payload: Uint8Array): SyncDecodeResult | null;
+    /**
+     * 处理 ACK 回包
+     */
+    private handleAck;
+    /**
+     * 派发消息事件
+     */
+    private dispatchMessage;
+    private sendDeliveryAckIfNeeded;
+    private handleNotifies;
+    private handleUserInfoNotify;
+    private handleContactNotify;
+    private handlePresenceNotify;
+    private handleGroupNotify;
+    private handleChatRoomNotify;
+    private handleReactionNotify;
+    private handleConversationNotify;
+    private handleMultiDeviceNotify;
+    private toMessageReceiptPayload;
+    private handleMessageDeliveredNotify;
+    private handleMessageRecalledNotify;
+    private handleMessageUpdatedNotify;
+    private normalizeUpdatedMessageBody;
+    private handleChatThreadNotify;
+    private normalizePresenceStatus;
+    /**
+     * 销毁接收器
+     */
+    destroy(): void;
+    private rememberMessageContext;
+    private resolveMessageReceiptContext;
+    private resolveMessageContextId;
+    private resolveMessageConversationContext;
+    private resolveReactionConversationContext;
+    private normalizeReactionList;
+    private normalizeReactionOperations;
+    private normalizeTimestamp;
+}

package/core/message/message-retry.d.ts

@@ -0,0 +1,33 @@
+/**
+ * 消息重试逻辑
+ *
+ * 存储失败消息、重连后重试、最多 3 次尝试
+ */
+import { Message } from '../../types';
+/**
+ * 失败消息存储
+ */
+export declare class MessageRetryManager {
+    private failedMessages;
+    private maxRetries;
+    /**
+     * 记录失败消息
+     */
+    recordFailedMessage(message: Message): void;
+    /**
+     * 获取所有失败消息
+     */
+    getFailedMessages(): Message[];
+    /**
+     * 重试失败消息
+     */
+    retryFailedMessages(sendMessageFn: (message: Message) => Promise<Message>): Promise<void>;
+    /**
+     * 清除失败消息
+     */
+    clearFailedMessages(): void;
+    /**
+     * 移除特定消息
+     */
+    removeFailedMessage(msgLocalId: string): void;
+}

package/core/message/message-sender.d.ts

@@ -0,0 +1,63 @@
+/**
+ * 消息发送器
+ *
+ * 接收 Message 对象，发送消息、等待 ACK、错误处理
+ * 参考：engineCore/mSync.ts
+ */
+import type { Message, SendMessageOptions } from '../../types';
+import { MsyncCodec } from '../../protocol/msync/codec';
+import { EventHub } from '../events/event-hub';
+import { AttachmentUploader } from '../../upload/attachment-uploader';
+import { type SocketLike } from '../../platform';
+import type { ActionAckResult, MessageActionRequest } from './message-action-types';
+import type { ChatRoomOperationRequest } from './chatroom-operation-types';
+import type { JoinChatRoomInfo } from '../../types/chatroom';
+/**
+ * 消息发送器
+ */
+export declare class MessageSender {
+    private websocket;
+    private pendingMessages;
+    private ackTimeout;
+    private eventHub;
+    private msyncCodec;
+    private attachmentUploader;
+    private messageReportCount;
+    private chatRoomReportCount;
+    private messageReportSaturated;
+    private chatRoomReportSaturated;
+    constructor(msyncCodec: MsyncCodec, websocket: SocketLike | null, eventHub: EventHub, attachmentUploader?: AttachmentUploader);
+    updateAuthToken(token: string): void;
+    /**
+     * 发送消息
+     */
+    sendMessage(message: Message, options?: SendMessageOptions): Promise<Message>;
+    sendAction(action: MessageActionRequest, createAckError?: (statusCode: number, reason?: string) => Error): Promise<ActionAckResult>;
+    sendChatRoomOperation(request: ChatRoomOperationRequest, createAckError?: (statusCode: number, reason?: string) => Error): Promise<ActionAckResult>;
+    /**
+     * 实际发送消息
+     */
+    private doSendMessage;
+    private sendProtocolPayload;
+    private prepareCombineMessage;
+    /**
+     * 处理 ACK
+     */
+    handleAck(protocolId: string, msgServerId?: string, replacedMessage?: Message, chatRoomInfo?: JoinChatRoomInfo): void;
+    private resolveReplacedMessage;
+    /**
+     * 处理发送失败
+     */
+    handleSendError(protocolId: string, error: Error): void;
+    handleAckFailure(protocolId: string, statusCode: number, reason: string | undefined, error: Error): void;
+    /**
+     * 更新 WebSocket 实例
+     */
+    setWebSocket(websocket: SocketLike | null): void;
+    /**
+     * 销毁消息发送器
+     */
+    destroy(): void;
+    private createPendingDataReport;
+    private finishPendingDataReport;
+}