ts-communication 1.0.0 → 1.1.0

package/dist/Invt/InvtModbusTcp.js

@@ -0,0 +1,255 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvtModbusTcp = void 0;
+const ModbusTcpNet_1 = require("../modbus/ModbusTcpNet");
+const Core_1 = require("../core/Core");
+/**
+ * 英威腾 TS600 系列 PLC 的 Modbus TCP 通讯类
+ * 支持通过 PLC 原生地址格式进行读写操作
+ */
+class InvtModbusTcp extends ModbusTcpNet_1.ModbusTcpNet {
+    constructor(ipAddress, port = 502, station = 1) {
+        super(ipAddress, port, station);
+    }
+    /**
+     * 将英威腾 PLC 地址转换为 Modbus 地址
+     * @param address 英威腾 PLC 地址，例如：M100、S100、X0、Y0、T100、C100、D100、R100
+     * @param modbusCode Modbus功能码
+     * @returns 转换后的Modbus地址
+     */
+    TranslateToModbusAddress(address, modbusCode) {
+        try {
+            let station = '';
+            // 提取站号参数
+            const stationMatch = address.match(/^s=(\d+);(.*)$/i);
+            if (stationMatch) {
+                station = `s=${stationMatch[1]};`;
+                address = stationMatch[2];
+            }
+            const isBitCode = modbusCode === 1 || modbusCode === 15 || modbusCode === 5;
+            if (isBitCode) {
+                // 线圈类型地址转换
+                // M：内部继电器（偏移量 0）
+                if (/^M\d+/i.test(address)) {
+                    const num = parseInt(address.substring(1), 10);
+                    return Core_1.OperateResult.CreateSuccessResult(station + num.toString());
+                }
+                // S：状态继电器（偏移量 32768）
+                if (/^S\d+/i.test(address)) {
+                    const num = parseInt(address.substring(1), 10);
+                    return Core_1.OperateResult.CreateSuccessResult(station + (num + 32768).toString());
+                }
+                // X：输入继电器（偏移量 40960，地址为八进制）
+                if (/^X[0-7]+/i.test(address)) {
+                    const num = parseInt(address.substring(1), 8);
+                    return Core_1.OperateResult.CreateSuccessResult(station + (num + 40960).toString());
+                }
+                // Y：输出继电器（偏移量 45056，地址为八进制）
+                if (/^Y[0-7]+/i.test(address)) {
+                    const num = parseInt(address.substring(1), 8);
+                    return Core_1.OperateResult.CreateSuccessResult(station + (num + 45056).toString());
+                }
+                // T：定时器触点（偏移量 49152）
+                if (/^T\d+/i.test(address)) {
+                    const num = parseInt(address.substring(1), 10);
+                    return Core_1.OperateResult.CreateSuccessResult(station + (num + 49152).toString());
+                }
+                // C：计数器触点（偏移量 49664）
+                if (/^C\d+/i.test(address)) {
+                    const num = parseInt(address.substring(1), 10);
+                    return Core_1.OperateResult.CreateSuccessResult(station + (num + 49664).toString());
+                }
+                // D：数据寄存器位访问
+                if (/^D\d+\.\d+/i.test(address)) {
+                    return Core_1.OperateResult.CreateSuccessResult(station + address.substring(1));
+                }
+                // R：扩展寄存器位访问
+                if (/^R\d+\.\d+/i.test(address)) {
+                    const parts = address.substring(1).split('.');
+                    const wordAddr = parseInt(parts[0], 10);
+                    return Core_1.OperateResult.CreateSuccessResult(station + `${wordAddr + 32768}.${parts[1]}`);
+                }
+            }
+            else {
+                // 寄存器类型地址转换
+                // T：定时器当前值（偏移量 57344）
+                if (/^T\d+/i.test(address)) {
+                    const num = parseInt(address.substring(1), 10);
+                    return Core_1.OperateResult.CreateSuccessResult(station + (num + 57344).toString());
+                }
+                // C：计数器当前值（偏移量 57856）
+                if (/^C\d+/i.test(address)) {
+                    const num = parseInt(address.substring(1), 10);
+                    return Core_1.OperateResult.CreateSuccessResult(station + (num + 57856).toString());
+                }
+                // Z：变址寄存器（偏移量 58368，32 位地址乘 2）
+                if (/^Z\d+/i.test(address)) {
+                    // 数字部分从 Z 前缀之后开始。
+                    const num = parseInt(address.substring(1), 10);
+                    return Core_1.OperateResult.CreateSuccessResult(station + (num * 2 + 58368).toString());
+                }
+                // D：数据寄存器（偏移量 0）
+                if (/^D\d+/i.test(address)) {
+                    const num = parseInt(address.substring(1), 10);
+                    return Core_1.OperateResult.CreateSuccessResult(station + num.toString());
+                }
+                // R：扩展寄存器（偏移量 32768）
+                if (/^R\d+/i.test(address)) {
+                    const num = parseInt(address.substring(1), 10);
+                    return Core_1.OperateResult.CreateSuccessResult(station + (num + 32768).toString());
+                }
+                // M：内部继电器状态读取（使用功能码 1）
+                if (/^M\d+/i.test(address)) {
+                    const num = parseInt(address.substring(1), 10);
+                    return Core_1.OperateResult.CreateSuccessResult(station + `x=1;${num}`);
+                }
+            }
+            throw new Error(`Unsupported Invt address: ${address}`);
+        }
+        catch (e) {
+            return new Core_1.OperateResult(e.message);
+        }
+    }
+    /**
+     * 读取寄存器数据
+     */
+    async Read(address, length) {
+        const a = this.TranslateToModbusAddress(address, 3);
+        return a.IsSuccess ? super.Read(a.Content, length) : Core_1.OperateResult.CreateFailedResult(a);
+    }
+    /**
+     * 读取布尔类型数据
+     */
+    async ReadBool(address, length) {
+        const a = this.TranslateToModbusAddress(address, 1);
+        return a.IsSuccess ? super.ReadBool(a.Content, length) : Core_1.OperateResult.CreateFailedResult(a);
+    }
+    /**
+     * 读取线圈
+     */
+    async ReadCoil(address, length) {
+        return this.ReadBool(address, length);
+    }
+    /**
+     * 写入数据
+     */
+    async Write(address, value) {
+        // 单个线圈使用功能码 5，线圈数组使用功能码 15。
+        const code = typeof value === 'boolean' ? 5 : Array.isArray(value) && typeof value[0] === 'boolean' ? 15 : 16;
+        const a = this.TranslateToModbusAddress(address, code);
+        return a.IsSuccess ? super.Write(a.Content, value) : Core_1.OperateResult.CreateFailedResult(a);
+    }
+    /**
+     * 读取Int16类型数据
+     */
+    async ReadInt16(address, length) {
+        const a = this.TranslateToModbusAddress(address, 3);
+        return a.IsSuccess ? super.ReadInt16(a.Content, length) : Core_1.OperateResult.CreateFailedResult(a);
+    }
+    /**
+     * 读取UInt16类型数据
+     */
+    async ReadUInt16(address, length) {
+        const a = this.TranslateToModbusAddress(address, 3);
+        return a.IsSuccess ? super.ReadUInt16(a.Content, length) : Core_1.OperateResult.CreateFailedResult(a);
+    }
+    /**
+     * 读取Int32类型数据
+     */
+    async ReadInt32(address, length) {
+        const a = this.TranslateToModbusAddress(address, 3);
+        return a.IsSuccess ? super.ReadInt32(a.Content, length) : Core_1.OperateResult.CreateFailedResult(a);
+    }
+    /**
+     * 读取UInt32类型数据
+     */
+    async ReadUInt32(address, length) {
+        const a = this.TranslateToModbusAddress(address, 3);
+        return a.IsSuccess ? super.ReadUInt32(a.Content, length) : Core_1.OperateResult.CreateFailedResult(a);
+    }
+    /**
+     * 读取Float类型数据
+     */
+    async ReadFloat(address, length) {
+        const a = this.TranslateToModbusAddress(address, 3);
+        return a.IsSuccess ? super.ReadFloat(a.Content, length) : Core_1.OperateResult.CreateFailedResult(a);
+    }
+    /**
+     * 读取Double类型数据
+     */
+    async ReadDouble(address, length) {
+        const a = this.TranslateToModbusAddress(address, 3);
+        return a.IsSuccess ? super.ReadDouble(a.Content, length) : Core_1.OperateResult.CreateFailedResult(a);
+    }
+    /**
+     * 读取 64 位整数。父类的类型读取路径使用原始读取，避免已转换地址再次映射。
+     */
+    async ReadInt64(address, length) {
+        const a = this.TranslateToModbusAddress(address, 3);
+        return a.IsSuccess ? super.ReadInt64(a.Content, length) : Core_1.OperateResult.CreateFailedResult(a);
+    }
+    async ReadUInt64(address, length) {
+        const a = this.TranslateToModbusAddress(address, 3);
+        return a.IsSuccess ? super.ReadUInt64(a.Content, length) : Core_1.OperateResult.CreateFailedResult(a);
+    }
+    async ReadString(address, length, encoding = 'ascii') {
+        const a = this.TranslateToModbusAddress(address, 3);
+        if (!a.IsSuccess)
+            return Core_1.OperateResult.CreateFailedResult(a);
+        const result = await super.Read(a.Content, length);
+        return result.IsSuccess
+            ? Core_1.OperateResult.CreateSuccessResult(this.ByteTransform.TransString(result.Content, encoding))
+            : Core_1.OperateResult.CreateFailedResult(result);
+    }
+    /**
+     * 写入Int16类型数据
+     */
+    async WriteInt16(address, value) {
+        const a = this.TranslateToModbusAddress(address, 6);
+        return a.IsSuccess ? super.WriteInt16(a.Content, value) : Core_1.OperateResult.CreateFailedResult(a);
+    }
+    /**
+     * 写入UInt16类型数据
+     */
+    async WriteUInt16(address, value) {
+        const a = this.TranslateToModbusAddress(address, 6);
+        return a.IsSuccess ? super.WriteUInt16(a.Content, value) : Core_1.OperateResult.CreateFailedResult(a);
+    }
+    /**
+     * 写入Int32类型数据
+     */
+    async WriteInt32(address, value) {
+        const a = this.TranslateToModbusAddress(address, 16);
+        return a.IsSuccess ? super.WriteInt32(a.Content, value) : Core_1.OperateResult.CreateFailedResult(a);
+    }
+    /**
+     * 写入UInt32类型数据
+     */
+    async WriteUInt32(address, value) {
+        const a = this.TranslateToModbusAddress(address, 16);
+        return a.IsSuccess ? super.WriteUInt32(a.Content, value) : Core_1.OperateResult.CreateFailedResult(a);
+    }
+    /**
+     * 写入Float类型数据
+     */
+    async WriteFloat(address, value) {
+        const a = this.TranslateToModbusAddress(address, 16);
+        return a.IsSuccess ? super.WriteFloat(a.Content, value) : Core_1.OperateResult.CreateFailedResult(a);
+    }
+    /**
+     * 写入Double类型数据
+     */
+    async WriteDouble(address, value) {
+        const a = this.TranslateToModbusAddress(address, 16);
+        return a.IsSuccess ? super.WriteDouble(a.Content, value) : Core_1.OperateResult.CreateFailedResult(a);
+    }
+    async WriteInt64(address, value) {
+        const a = this.TranslateToModbusAddress(address, 16);
+        return a.IsSuccess ? super.WriteInt64(a.Content, value) : Core_1.OperateResult.CreateFailedResult(a);
+    }
+    async WriteUInt64(address, value) {
+        const a = this.TranslateToModbusAddress(address, 16);
+        return a.IsSuccess ? super.WriteUInt64(a.Content, value) : Core_1.OperateResult.CreateFailedResult(a);
+    }
+}
+exports.InvtModbusTcp = InvtModbusTcp;

package/dist/XCommunication.d.ts

@@ -1,4 +1,8 @@
 export * from './core/Core';
+export * from './core/CommunicationLock';
+export * from './core/INetMessage';
+export * from './core/DeviceSerialPort';
+export * from './core/DeviceUdpNet';
 export * from './modbus/ModbusTcpNet';
 export * from './modbus/ModbusRtu';
 export * from './modbus/ModbusRtuOverTcp';
@@ -7,5 +11,19 @@ export * from './modbus/ModbusAsciiOverTcp';
 export * from './modbus/ModbusUdpNet';
 export * from './siemens/SiemensS7Net';
 export * from './melsec/MelsecMcNet';
+export * from './melsec/MelsecMcUdp';
+export * from './melsec/MelsecMcAsciiNet';
+export * from './melsec/MelsecMcAsciiUdp';
 export * from './omron/OmronFinsNet';
+export * from './omron/OmronFinsUdp';
 export * from './inovance/InovanceTcpNet';
+export * from './inovance/InovanceSerial';
+export * from './inovance/InovanceSerialOverTcp';
+export * from './inovance/InovanceEasyNet';
+export * from './Invt/InvtModbusTcp';
+export * from './ge/GeSRTPNet';
+export * from './delta/DeltaTcpNet';
+export * from './xinjie/XinJETcpNet';
+export * from './debug/PingTest';
+export * from './debug/tcpClient';
+export * from './debug/tcpServer';

package/dist/XCommunication.js

@@ -14,14 +14,43 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+// Core
 __exportStar(require("./core/Core"), exports);
+__exportStar(require("./core/CommunicationLock"), exports);
+__exportStar(require("./core/INetMessage"), exports);
+__exportStar(require("./core/DeviceSerialPort"), exports);
+__exportStar(require("./core/DeviceUdpNet"), exports);
+// Modbus
 __exportStar(require("./modbus/ModbusTcpNet"), exports);
 __exportStar(require("./modbus/ModbusRtu"), exports);
 __exportStar(require("./modbus/ModbusRtuOverTcp"), exports);
 __exportStar(require("./modbus/ModbusAscii"), exports);
 __exportStar(require("./modbus/ModbusAsciiOverTcp"), exports);
 __exportStar(require("./modbus/ModbusUdpNet"), exports);
+// Siemens
 __exportStar(require("./siemens/SiemensS7Net"), exports);
+// Melsec
 __exportStar(require("./melsec/MelsecMcNet"), exports);
+__exportStar(require("./melsec/MelsecMcUdp"), exports);
+__exportStar(require("./melsec/MelsecMcAsciiNet"), exports);
+__exportStar(require("./melsec/MelsecMcAsciiUdp"), exports);
+// Omron
 __exportStar(require("./omron/OmronFinsNet"), exports);
+__exportStar(require("./omron/OmronFinsUdp"), exports);
+// Inovance
 __exportStar(require("./inovance/InovanceTcpNet"), exports);
+__exportStar(require("./inovance/InovanceSerial"), exports);
+__exportStar(require("./inovance/InovanceSerialOverTcp"), exports);
+__exportStar(require("./inovance/InovanceEasyNet"), exports);
+// Invt
+__exportStar(require("./Invt/InvtModbusTcp"), exports);
+// 通用电气
+__exportStar(require("./ge/GeSRTPNet"), exports);
+// 台达
+__exportStar(require("./delta/DeltaTcpNet"), exports);
+// XinJE
+__exportStar(require("./xinjie/XinJETcpNet"), exports);
+// Debug
+__exportStar(require("./debug/PingTest"), exports);
+__exportStar(require("./debug/tcpClient"), exports);
+__exportStar(require("./debug/tcpServer"), exports);

package/dist/ab/AbEtherNetIp.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/ab/AbEtherNetIp.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/CommunicationLock.d.ts

@@ -0,0 +1,88 @@
+import { OperateResult } from './Core';
+/**
+ * 用于通信的锁的接口对象，定义了进入锁和离开锁的方法接口信息
+ * An interface object for a lock used for communication that defines interface information for the methods used to enter and exit the lock
+ */
+export interface ICommunicationLock {
+    /**
+     * 进入锁操作，指定超时时间，单位毫秒，并返回是否成功获得锁的标记
+     * Enters the lock operation, specifies the timeout period in milliseconds, and returns a flag as to whether the lock was successfully obtained.
+     * @param timeout 超时时间（毫秒）
+     * @returns 是否成功获得锁
+     */
+    EnterLock(timeout: number): Promise<OperateResult<void>>;
+    /**
+     * 离开锁操作
+     * Leave lock operation
+     */
+    LeaveLock(): void;
+    /**
+     * 释放资源
+     * Dispose resources
+     */
+    dispose(): void;
+}
+/**
+ * 无锁实现，直接返回成功，用于不需要锁的场景
+ * No lock implementation, returns success directly, used for scenarios that do not require locks
+ */
+export declare class CommunicationLockNone implements ICommunicationLock {
+    EnterLock(timeout: number): Promise<OperateResult<void>>;
+    LeaveLock(): void;
+    dispose(): void;
+    toString(): string;
+}
+/**
+ * 用于通信的一个简单的混合锁，基于 Promise 队列实现
+ * A simple hybrid lock for communication, implemented based on Promise queue
+ */
+export declare class CommunicationLockSimple implements ICommunicationLock {
+    private waiters;
+    private queue;
+    /**
+     * 获取当前锁是否在等待当中
+     * Gets whether the current lock is waiting
+     */
+    get IsWaiting(): boolean;
+    /**
+     * 进入锁操作
+     * @param timeout 超时时间（毫秒）
+     */
+    EnterLock(timeout: number): Promise<OperateResult<void>>;
+    /**
+     * 离开锁操作
+     */
+    LeaveLock(): void;
+    /**
+     * 释放资源
+     */
+    dispose(): void;
+    toString(): string;
+}
+/**
+ * 请求队列管理器，确保请求按顺序执行
+ * Request queue manager to ensure requests are executed in order
+ */
+export declare class RequestQueue {
+    private queue;
+    private processing;
+    /**
+     * 将请求加入队列并执行
+     * Add request to queue and execute
+     * @param fn 要执行的异步函数
+     * @returns 执行结果
+     */
+    enqueue<T>(fn: () => Promise<T>): Promise<T>;
+    /**
+     * 处理队列
+     */
+    private processQueue;
+    /**
+     * 获取当前队列长度
+     */
+    get length(): number;
+    /**
+     * 清空队列
+     */
+    clear(): void;
+}

package/dist/core/CommunicationLock.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestQueue = exports.CommunicationLockSimple = exports.CommunicationLockNone = void 0;
+const Core_1 = require("./Core");
+/**
+ * 无锁实现，直接返回成功，用于不需要锁的场景
+ * No lock implementation, returns success directly, used for scenarios that do not require locks
+ */
+class CommunicationLockNone {
+    async EnterLock(timeout) {
+        return Core_1.OperateResult.CreateSuccessResult();
+    }
+    LeaveLock() {
+        // 无操作
+    }
+    dispose() {
+        // 无操作
+    }
+    toString() {
+        return 'CommunicationLockNone[NoLock]';
+    }
+}
+exports.CommunicationLockNone = CommunicationLockNone;
+/**
+ * 用于通信的一个简单的混合锁，基于 Promise 队列实现
+ * A simple hybrid lock for communication, implemented based on Promise queue
+ */
+class CommunicationLockSimple {
+    waiters = 0;
+    queue = [];
+    /**
+     * 获取当前锁是否在等待当中
+     * Gets whether the current lock is waiting
+     */
+    get IsWaiting() {
+        return this.waiters > 0;
+    }
+    /**
+     * 进入锁操作
+     * @param timeout 超时时间（毫秒）
+     */
+    async EnterLock(timeout) {
+        try {
+            this.waiters++;
+            // 如果是第一个进入，直接获得锁
+            if (this.waiters === 1) {
+                return Core_1.OperateResult.CreateSuccessResult();
+            }
+            // 否则加入等待队列
+            return new Promise((resolve, reject) => {
+                const timer = setTimeout(() => {
+                    // 超时，从队列中移除
+                    const index = this.queue.findIndex(item => item.timer === timer);
+                    if (index >= 0) {
+                        this.queue.splice(index, 1);
+                    }
+                    this.waiters--;
+                    resolve(new Core_1.OperateResult(`Enter lock failed, timeout: ${timeout}`, -1));
+                }, timeout);
+                this.queue.push({ resolve: () => resolve(Core_1.OperateResult.CreateSuccessResult()), reject, timer });
+            });
+        }
+        catch (ex) {
+            this.waiters--;
+            return new Core_1.OperateResult(`Enter lock failed, message: ${ex.message}`, -1);
+        }
+    }
+    /**
+     * 离开锁操作
+     */
+    LeaveLock() {
+        this.waiters--;
+        // 如果还有等待的请求，唤醒下一个
+        if (this.waiters > 0 && this.queue.length > 0) {
+            const next = this.queue.shift();
+            if (next) {
+                clearTimeout(next.timer);
+                next.resolve();
+            }
+        }
+    }
+    /**
+     * 释放资源
+     */
+    dispose() {
+        // 清理所有等待的请求
+        for (const item of this.queue) {
+            clearTimeout(item.timer);
+            item.reject(new Error('Lock disposed'));
+        }
+        this.queue = [];
+        this.waiters = 0;
+    }
+    toString() {
+        return `CommunicationLockSimple[${this.IsWaiting ? 'Locking' : 'Unlock'}]`;
+    }
+}
+exports.CommunicationLockSimple = CommunicationLockSimple;
+/**
+ * 请求队列管理器，确保请求按顺序执行
+ * Request queue manager to ensure requests are executed in order
+ */
+class RequestQueue {
+    queue = [];
+    processing = false;
+    /**
+     * 将请求加入队列并执行
+     * Add request to queue and execute
+     * @param fn 要执行的异步函数
+     * @returns 执行结果
+     */
+    async enqueue(fn) {
+        return new Promise((resolve, reject) => {
+            this.queue.push({ fn, resolve, reject });
+            this.processQueue();
+        });
+    }
+    /**
+     * 处理队列
+     */
+    async processQueue() {
+        if (this.processing || this.queue.length === 0) {
+            return;
+        }
+        this.processing = true;
+        while (this.queue.length > 0) {
+            const item = this.queue.shift();
+            if (!item)
+                break;
+            try {
+                const result = await item.fn();
+                item.resolve(result);
+            }
+            catch (error) {
+                item.reject(error);
+            }
+        }
+        this.processing = false;
+    }
+    /**
+     * 获取当前队列长度
+     */
+    get length() {
+        return this.queue.length;
+    }
+    /**
+     * 清空队列
+     */
+    clear() {
+        for (const item of this.queue) {
+            item.reject(new Error('Queue cleared'));
+        }
+        this.queue = [];
+    }
+}
+exports.RequestQueue = RequestQueue;

package/dist/core/Core.d.ts

@@ -1,4 +1,6 @@
 import * as net from 'node:net';
+import { ICommunicationLock, RequestQueue } from './CommunicationLock';
+import { INetMessage } from './INetMessage';
 export declare enum DataFormat {
     ABCD = "ABCD",
     BADC = "BADC",
@@ -60,6 +62,11 @@ export declare class ByteTransform {
     IsStringReverseByteWord: boolean;
     DataFormat: DataFormat;
     constructor(format?: DataFormat);
+    /**
+     * 按照 DataFormat 重新排序字节
+     * 完全匹配 C# RegularByteTransform 的 ByteTransDataFormat* 方法
+     * 转换后的字节将用小端序 DataView 读取
+     */
     private order;
     private view;
     private dataView;
@@ -84,12 +91,31 @@ export declare abstract class DeviceClient {
     ConnectionId: string;
     protected socket?: net.Socket;
     private connecting?;
+    protected communicationLock: ICommunicationLock;
+    protected requestQueue: RequestQueue;
+    EnableCommunicationLock: boolean;
     constructor(ipAddress?: string, port?: number);
+    /**
+     * 获取当前协议的消息解析器
+     * 子类应该重写此方法以提供特定协议的消息解析器
+     */
+    protected GetNewNetMessage(): INetMessage | undefined;
     ConnectServer(): Promise<OperateResult<any>>;
     ConnectClose(): Promise<OperateResult<any>>;
-    protected request(frame: Buffer, parser: (data: Buffer) => Buffer): Promise<OperateResult<Buffer>>;
+    /**
+     * 发送请求并接收响应（带通信锁和队列）
+     */
+    protected request(frame: Buffer, parser?: (data: Buffer) => Buffer): Promise<OperateResult<Buffer>>;
+    /**
+     * 使用 INetMessage 解析器发送请求
+     */
+    private requestWithMessage;
     /** Send one frame on an already connected socket (used by protocol handshakes). */
     protected requestConnected(frame: Buffer, parser: (data: Buffer) => Buffer): Promise<OperateResult<Buffer>>;
+    /**
+     * 批量发送请求（自动合并结果）
+     */
+    protected ReadFromCoreServer(commands: Buffer[]): Promise<OperateResult<Buffer>>;
     protected fromResult<T>(result: OperateResult<Buffer>, fn: (data: Buffer) => T): OperateResult<T>;
 }
 export declare function wordsFor(type: string, length: number): number;