ts-communication 1.0.0 → 1.1.0

package/dist/debug/tcpServer.js

@@ -0,0 +1,102 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TcpServer = void 0;
+const net = __importStar(require("node:net"));
+class TcpServer {
+    server;
+    clients = new Set();
+    port;
+    host;
+    constructor(port = 5000, host = '0.0.0.0') {
+        this.port = port;
+        this.host = host;
+    }
+    async start() {
+        return new Promise((resolve) => {
+            this.server = net.createServer((socket) => {
+                this.handleConnection(socket);
+            });
+            this.server.on('error', (err) => {
+                console.error('[TcpServer] Server error:', err.message);
+                resolve(false);
+            });
+            this.server.listen(this.port, this.host, () => {
+                console.log('[TcpServer] Server listening on ' + this.host + ':' + this.port);
+                resolve(true);
+            });
+        });
+    }
+    handleConnection(socket) {
+        const clientId = socket.remoteAddress + ':' + socket.remotePort;
+        console.log('[TcpServer] Client connected: ' + clientId);
+        this.clients.add(socket);
+        socket.on('data', (data) => {
+            console.log('[TcpServer] Received: ' + data.length + ' bytes');
+            socket.write(data);
+        });
+        socket.on('close', () => {
+            console.log('[TcpServer] Client disconnected: ' + clientId);
+            this.clients.delete(socket);
+        });
+    }
+    broadcast(data) {
+        console.log('[TcpServer] Broadcasting to ' + this.clients.size + ' clients');
+        for (const client of this.clients) {
+            if (!client.destroyed)
+                client.write(data);
+        }
+    }
+    getClientCount() {
+        return this.clients.size;
+    }
+    async stop() {
+        return new Promise((resolve) => {
+            for (const client of this.clients)
+                client.destroy();
+            this.clients.clear();
+            if (this.server) {
+                this.server.close(() => {
+                    console.log('[TcpServer] Server stopped');
+                    resolve();
+                });
+            }
+            else {
+                resolve();
+            }
+        });
+    }
+}
+exports.TcpServer = TcpServer;

package/dist/delta/DeltaTcpNet.d.ts

@@ -0,0 +1,65 @@
+import { ModbusTcpNet, ModbusAddress } from '../modbus/ModbusTcpNet';
+import { OperateResult } from '../core/Core';
+/**
+ * 台达PLC系列枚举
+ */
+export declare enum DeltaSeries {
+    /** DVP系列 */
+    Dvp = 1,
+    /** AS300系列 */
+    AS = 2
+}
+/**
+ * 台达PLC的网口通讯类，基于Modbus-Tcp协议开发，按照台达的地址进行实现
+ *
+ * 适用于DVP-ES/EX/EC/SS型号，DVP-SA/SC/SX/EH型号以及AS300型号
+ *
+ * 地址示例：
+ * - S0-S999: 状态寄存器
+ * - X0-X377(八进制): 输入继电器
+ * - Y0-Y377(八进制): 输出继电器
+ * - T0-T255: 定时器
+ * - C0-C255: 计数器
+ * - M0-M4095: 内部继电器
+ * - D0-D9999: 数据寄存器
+ *
+ * 地址可以携带站号信息，例如：[s=2;D100], [s=3;M100]
+ */
+export declare class DeltaTcpNet extends ModbusTcpNet {
+    /** 台达PLC系列，默认为DVP系列 */
+    Series: DeltaSeries;
+    constructor(ipAddress?: string, port?: number, station?: number);
+    /**
+     * 将台达D寄存器地址转换为Modbus地址
+     */
+    private transDAddressToModbusAddress;
+    /**
+     * 解析AS系列位地址（带小数点的）
+     */
+    private parseDeltaBitAddress;
+    /**
+     * 重写地址解析方法，将台达地址转换为Modbus地址
+     */
+    protected addr(input: string, code: number): OperateResult<ModbusAddress>;
+    /**
+     * DVP系列地址解析
+     */
+    private parseDvpAddress;
+    /**
+     * AS300系列地址解析
+     */
+    private parseASAddress;
+    /**
+     * 读取bool数组，针对DVP系列M地址跨1536的情况进行特殊处理
+     */
+    ReadBool(address: string, length?: number): Promise<OperateResult<boolean | boolean[]>>;
+    /**
+     * 写入bool数组，针对DVP系列M地址跨1536的情况进行特殊处理
+     */
+    Write(address: string, value: boolean | boolean[] | number | number[] | Buffer | string): Promise<OperateResult<any>>;
+    /**
+     * 读取数据，针对DVP系列D地址跨4096的情况进行特殊处理
+     */
+    Read(address: string, length: number): Promise<OperateResult<Buffer>>;
+    toString(): string;
+}

package/dist/delta/DeltaTcpNet.js

@@ -0,0 +1,346 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeltaTcpNet = exports.DeltaSeries = void 0;
+const ModbusTcpNet_1 = require("../modbus/ModbusTcpNet");
+const Core_1 = require("../core/Core");
+/**
+ * 台达PLC系列枚举
+ */
+var DeltaSeries;
+(function (DeltaSeries) {
+    /** DVP系列 */
+    DeltaSeries[DeltaSeries["Dvp"] = 1] = "Dvp";
+    /** AS300系列 */
+    DeltaSeries[DeltaSeries["AS"] = 2] = "AS";
+})(DeltaSeries || (exports.DeltaSeries = DeltaSeries = {}));
+/**
+ * 台达PLC的网口通讯类，基于Modbus-Tcp协议开发，按照台达的地址进行实现
+ *
+ * 适用于DVP-ES/EX/EC/SS型号，DVP-SA/SC/SX/EH型号以及AS300型号
+ *
+ * 地址示例：
+ * - S0-S999: 状态寄存器
+ * - X0-X377(八进制): 输入继电器
+ * - Y0-Y377(八进制): 输出继电器
+ * - T0-T255: 定时器
+ * - C0-C255: 计数器
+ * - M0-M4095: 内部继电器
+ * - D0-D9999: 数据寄存器
+ *
+ * 地址可以携带站号信息，例如：[s=2;D100], [s=3;M100]
+ */
+class DeltaTcpNet extends ModbusTcpNet_1.ModbusTcpNet {
+    /** 台达PLC系列，默认为DVP系列 */
+    Series = DeltaSeries.Dvp;
+    constructor(ipAddress, port = 502, station = 1) {
+        super(ipAddress, port, station);
+        console.log('[DeltaTcpNet] Constructor called, Series:', this.Series);
+    }
+    /**
+     * 将台达D寄存器地址转换为Modbus地址
+     */
+    transDAddressToModbusAddress(address) {
+        if (address >= 4096) {
+            return address - 4096 + 36864;
+        }
+        return address + 4096;
+    }
+    /**
+     * 解析AS系列位地址（带小数点的）
+     */
+    parseDeltaBitAddress(address) {
+        const dotIndex = address.indexOf('.');
+        if (dotIndex > 0) {
+            const base = parseInt(address.substring(0, dotIndex));
+            const bit = parseInt(address.substring(dotIndex + 1));
+            return base * 16 + bit;
+        }
+        return parseInt(address) * 16;
+    }
+    /**
+     * 重写地址解析方法，将台达地址转换为Modbus地址
+     */
+    addr(input, code) {
+        console.log('[DeltaTcpNet] addr called with:', input, 'code:', code, 'Series:', this.Series);
+        try {
+            let text = input.trim();
+            let station = this.Station;
+            // 提取站号参数 s=2;D100
+            const stationMatch = text.match(/^s=(\d+);(.+)$/i);
+            if (stationMatch) {
+                station = parseInt(stationMatch[1]);
+                text = stationMatch[2];
+            }
+            if (this.Series === DeltaSeries.Dvp) {
+                return this.parseDvpAddress(text, station, code);
+            }
+            else if (this.Series === DeltaSeries.AS) {
+                return this.parseASAddress(text, station, code);
+            }
+            return new Core_1.OperateResult('不支持的PLC系列');
+        }
+        catch (e) {
+            console.log('[DeltaTcpNet] Error parsing address:', e.message);
+            return new Core_1.OperateResult(e.message);
+        }
+    }
+    /**
+     * DVP系列地址解析
+     */
+    parseDvpAddress(text, station, code) {
+        // 位操作码：读线圈(01)、写单个线圈(05)、写多个线圈(15)
+        if (code === 0x01 || code === 0x05 || code === 0x0F) {
+            if (text.match(/^S\d+$/i)) {
+                // S0-S999
+                const num = parseInt(text.substring(1));
+                const result = { station, code: 0x01, address: num, writeCode: 0x0F };
+                console.log('[DeltaTcpNet DVP] S register converted to:', result);
+                return Core_1.OperateResult.CreateSuccessResult(result);
+            }
+            if (text.match(/^X[0-7]+$/i)) {
+                // X输入，八进制
+                const num = parseInt(text.substring(1), 8);
+                const result = { station, code: 0x02, address: num + 1024 };
+                console.log('[DeltaTcpNet DVP] X register converted to:', result);
+                return Core_1.OperateResult.CreateSuccessResult(result);
+            }
+            if (text.match(/^Y[0-7]+$/i)) {
+                // Y输出，八进制
+                const num = parseInt(text.substring(1), 8);
+                const result = { station, code: 0x01, address: num + 1280, writeCode: 0x0F };
+                console.log('[DeltaTcpNet DVP] Y register converted to:', result);
+                return Core_1.OperateResult.CreateSuccessResult(result);
+            }
+            if (text.match(/^T\d+$/i)) {
+                // 定时器
+                const num = parseInt(text.substring(1));
+                const result = { station, code: 0x01, address: num + 1536, writeCode: 0x0F };
+                console.log('[DeltaTcpNet DVP] T register converted to:', result);
+                return Core_1.OperateResult.CreateSuccessResult(result);
+            }
+            if (text.match(/^C\d+$/i)) {
+                // 计数器
+                const num = parseInt(text.substring(1));
+                const result = { station, code: 0x01, address: num + 3584, writeCode: 0x0F };
+                console.log('[DeltaTcpNet DVP] C register converted to:', result);
+                return Core_1.OperateResult.CreateSuccessResult(result);
+            }
+            if (text.match(/^M\d+$/i)) {
+                // M内部继电器
+                const num = parseInt(text.substring(1));
+                if (num >= 1536) {
+                    const result = { station, code: 0x01, address: num - 1536 + 45056, writeCode: 0x0F };
+                    console.log('[DeltaTcpNet DVP] M register (>=1536) converted to:', result);
+                    return Core_1.OperateResult.CreateSuccessResult(result);
+                }
+                const result = { station, code: 0x01, address: num + 2048, writeCode: 0x0F };
+                console.log('[DeltaTcpNet DVP] M register converted to:', result);
+                return Core_1.OperateResult.CreateSuccessResult(result);
+            }
+        }
+        else {
+            // 字操作码：读保持寄存器(03)、写单个寄存器(06)、写多个寄存器(16)
+            if (text.match(/^D\d+$/i)) {
+                // D数据寄存器
+                const num = parseInt(text.substring(1));
+                const modbusAddr = this.transDAddressToModbusAddress(num);
+                const result = { station, code: 0x03, address: modbusAddr, writeCode: 0x10 };
+                console.log('[DeltaTcpNet DVP] D' + num + ' converted to modbus address:', modbusAddr, 'result:', result);
+                return Core_1.OperateResult.CreateSuccessResult(result);
+            }
+            if (text.match(/^C\d+$/i)) {
+                // 计数器当前值
+                const num = parseInt(text.substring(1));
+                if (num >= 200) {
+                    const result = { station, code: 0x03, address: num - 200 + 3784, writeCode: 0x10 };
+                    console.log('[DeltaTcpNet DVP] C register (>=200) converted to:', result);
+                    return Core_1.OperateResult.CreateSuccessResult(result);
+                }
+                const result = { station, code: 0x03, address: num + 3584, writeCode: 0x10 };
+                console.log('[DeltaTcpNet DVP] C register converted to:', result);
+                return Core_1.OperateResult.CreateSuccessResult(result);
+            }
+            if (text.match(/^T\d+$/i)) {
+                // 定时器当前值
+                const num = parseInt(text.substring(1));
+                const result = { station, code: 0x03, address: num + 1536, writeCode: 0x10 };
+                console.log('[DeltaTcpNet DVP] T register converted to:', result);
+                return Core_1.OperateResult.CreateSuccessResult(result);
+            }
+        }
+        console.log('[DeltaTcpNet DVP] Unsupported address type:', text);
+        return new Core_1.OperateResult('不支持的地址类型: ' + text);
+    }
+    /**
+     * AS300系列地址解析
+     */
+    parseASAddress(text, station, code) {
+        // 位操作码
+        if (code === 0x01 || code === 0x05 || code === 0x0F) {
+            if (text.match(/^SM\d+$/i)) {
+                const num = parseInt(text.substring(2));
+                return Core_1.OperateResult.CreateSuccessResult({ station, code: 0x01, address: num + 16384, writeCode: 0x0F });
+            }
+            if (text.match(/^HC\d+$/i)) {
+                const num = parseInt(text.substring(2));
+                return Core_1.OperateResult.CreateSuccessResult({ station, code: 0x01, address: num + 64512, writeCode: 0x0F });
+            }
+            if (text.match(/^S\d+$/i)) {
+                const num = parseInt(text.substring(1));
+                return Core_1.OperateResult.CreateSuccessResult({ station, code: 0x01, address: num + 20480, writeCode: 0x0F });
+            }
+            if (text.match(/^X[\d.]+$/i)) {
+                const bitAddr = this.parseDeltaBitAddress(text.substring(1));
+                return Core_1.OperateResult.CreateSuccessResult({ station, code: 0x02, address: bitAddr + 24576 });
+            }
+            if (text.match(/^Y[\d.]+$/i)) {
+                const bitAddr = this.parseDeltaBitAddress(text.substring(1));
+                return Core_1.OperateResult.CreateSuccessResult({ station, code: 0x01, address: bitAddr + 40960, writeCode: 0x0F });
+            }
+            if (text.match(/^T\d+$/i)) {
+                const num = parseInt(text.substring(1));
+                return Core_1.OperateResult.CreateSuccessResult({ station, code: 0x01, address: num + 57344, writeCode: 0x0F });
+            }
+            if (text.match(/^C\d+$/i)) {
+                const num = parseInt(text.substring(1));
+                return Core_1.OperateResult.CreateSuccessResult({ station, code: 0x01, address: num + 61440, writeCode: 0x0F });
+            }
+            if (text.match(/^M\d+$/i)) {
+                const num = parseInt(text.substring(1));
+                return Core_1.OperateResult.CreateSuccessResult({ station, code: 0x01, address: num, writeCode: 0x0F });
+            }
+            if (text.match(/^D\d+\.\d+$/i)) {
+                // D寄存器位地址，直接传递
+                return Core_1.OperateResult.CreateSuccessResult({ station, code: 0x01, address: 0, writeCode: 0x0F });
+            }
+        }
+        else {
+            // 字操作码
+            if (text.match(/^SR\d+$/i)) {
+                const num = parseInt(text.substring(2));
+                return Core_1.OperateResult.CreateSuccessResult({ station, code: 0x03, address: num + 49152, writeCode: 0x10 });
+            }
+            if (text.match(/^HC\d+$/i)) {
+                const num = parseInt(text.substring(2));
+                return Core_1.OperateResult.CreateSuccessResult({ station, code: 0x03, address: num + 64512, writeCode: 0x10 });
+            }
+            if (text.match(/^D\d+$/i)) {
+                const num = parseInt(text.substring(1));
+                return Core_1.OperateResult.CreateSuccessResult({ station, code: 0x03, address: num, writeCode: 0x10 });
+            }
+            if (text.match(/^X\d+$/i)) {
+                const num = parseInt(text.substring(1));
+                return Core_1.OperateResult.CreateSuccessResult({ station, code: 0x04, address: num + 32768 });
+            }
+            if (text.match(/^Y\d+$/i)) {
+                const num = parseInt(text.substring(1));
+                return Core_1.OperateResult.CreateSuccessResult({ station, code: 0x03, address: num + 40960, writeCode: 0x10 });
+            }
+            if (text.match(/^C\d+$/i)) {
+                const num = parseInt(text.substring(1));
+                return Core_1.OperateResult.CreateSuccessResult({ station, code: 0x03, address: num + 61440, writeCode: 0x10 });
+            }
+            if (text.match(/^T\d+$/i)) {
+                const num = parseInt(text.substring(1));
+                return Core_1.OperateResult.CreateSuccessResult({ station, code: 0x03, address: num + 57344, writeCode: 0x10 });
+            }
+        }
+        return new Core_1.OperateResult('不支持的地址类型: ' + text);
+    }
+    /**
+     * 读取bool数组，针对DVP系列M地址跨1536的情况进行特殊处理
+     */
+    async ReadBool(address, length) {
+        const count = length ?? 1;
+        if (this.Series === DeltaSeries.Dvp) {
+            // 提取站号
+            let cleanAddress = address;
+            const stationMatch = address.match(/^s=(\d+);(.+)$/i);
+            if (stationMatch) {
+                cleanAddress = stationMatch[2];
+            }
+            // 检查M地址是否跨越1536边界
+            if (cleanAddress.match(/^M\d+$/i)) {
+                const startAddr = parseInt(cleanAddress.substring(1));
+                if (startAddr < 1536 && startAddr + count > 1536) {
+                    // 需要分割读取
+                    const firstLength = 1536 - startAddr;
+                    const secondLength = count - firstLength;
+                    const result1 = await super.ReadBool(address, firstLength);
+                    if (!result1.IsSuccess)
+                        return result1;
+                    const stationPrefix = stationMatch ? `s=${stationMatch[1]};` : '';
+                    const result2 = await super.ReadBool(stationPrefix + 'M1536', secondLength);
+                    if (!result2.IsSuccess)
+                        return result2;
+                    const combined = [...result1.Content, ...result2.Content];
+                    return Core_1.OperateResult.CreateSuccessResult(combined);
+                }
+            }
+        }
+        return super.ReadBool(address, count);
+    }
+    /**
+     * 写入bool数组，针对DVP系列M地址跨1536的情况进行特殊处理
+     */
+    async Write(address, value) {
+        if (typeof value === 'boolean' || (Array.isArray(value) && typeof value[0] === 'boolean')) {
+            const values = Array.isArray(value) ? value : [value];
+            if (this.Series === DeltaSeries.Dvp) {
+                let cleanAddress = address;
+                const stationMatch = address.match(/^s=(\d+);(.+)$/i);
+                if (stationMatch) {
+                    cleanAddress = stationMatch[2];
+                }
+                // 检查M地址是否跨越1536边界
+                if (cleanAddress.match(/^M\d+$/i)) {
+                    const startAddr = parseInt(cleanAddress.substring(1));
+                    if (startAddr < 1536 && startAddr + values.length > 1536) {
+                        const firstLength = 1536 - startAddr;
+                        const firstValues = values.slice(0, firstLength);
+                        const secondValues = values.slice(firstLength);
+                        const result1 = await super.Write(address, firstValues);
+                        if (!result1.IsSuccess)
+                            return result1;
+                        const stationPrefix = stationMatch ? `s=${stationMatch[1]};` : '';
+                        return super.Write(stationPrefix + 'M1536', secondValues);
+                    }
+                }
+            }
+        }
+        return super.Write(address, value);
+    }
+    /**
+     * 读取数据，针对DVP系列D地址跨4096的情况进行特殊处理
+     */
+    async Read(address, length) {
+        if (this.Series === DeltaSeries.Dvp) {
+            let cleanAddress = address;
+            const stationMatch = address.match(/^s=(\d+);(.+)$/i);
+            if (stationMatch) {
+                cleanAddress = stationMatch[2];
+            }
+            // 检查D地址是否跨越4096边界
+            if (cleanAddress.match(/^D\d+$/i)) {
+                const startAddr = parseInt(cleanAddress.substring(1));
+                if (startAddr < 4096 && startAddr + length > 4096) {
+                    const firstLength = 4096 - startAddr;
+                    const secondLength = length - firstLength;
+                    const result1 = await super.Read(address, firstLength);
+                    if (!result1.IsSuccess)
+                        return result1;
+                    const stationPrefix = stationMatch ? `s=${stationMatch[1]};` : '';
+                    const result2 = await super.Read(stationPrefix + 'D4096', secondLength);
+                    if (!result2.IsSuccess)
+                        return result2;
+                    return Core_1.OperateResult.CreateSuccessResult(Buffer.concat([result1.Content, result2.Content]));
+                }
+            }
+        }
+        return super.Read(address, length);
+    }
+    toString() {
+        return `DeltaTcpNet[${this.IpAddress}:${this.Port}]`;
+    }
+}
+exports.DeltaTcpNet = DeltaTcpNet;

package/dist/ge/GeSRTPNet.d.ts

@@ -0,0 +1,49 @@
+import { ByteTransform, DataFormat, DeviceClient, OperateResult } from '../core/Core';
+import { GeSRTPMessage } from '../core/INetMessage';
+export interface GeSRTPAddress {
+    DataCode: number;
+    AddressStart: number;
+    Length: number;
+    IsBit: boolean;
+}
+/** 解析 GE 地址。PLC 地址从 1 开始，报文内部从 0 开始。 */
+export declare function parseGeSRTPAddress(input: string, length: number, isBit: boolean): OperateResult<GeSRTPAddress>;
+export declare class GeSRTPNet extends DeviceClient {
+    ByteTransform: ByteTransform;
+    private messageId;
+    private initializedSocket?;
+    constructor(ipAddress?: string, port?: number);
+    get DataFormat(): DataFormat;
+    set DataFormat(value: DataFormat);
+    protected GetNewNetMessage(): GeSRTPMessage;
+    ConnectServer(): Promise<OperateResult<any>>;
+    ConnectClose(): Promise<OperateResult<any>>;
+    private nextId;
+    private transact;
+    Read(address: string, length: number): Promise<OperateResult<Buffer>>;
+    ReadBool(address: string, length?: number): Promise<OperateResult<boolean | boolean[]>>;
+    ReadByte(address: string): Promise<OperateResult<number>>;
+    private typedRead;
+    ReadInt16(a: string, l?: number): Promise<OperateResult<unknown>>;
+    ReadUInt16(a: string, l?: number): Promise<OperateResult<unknown>>;
+    ReadInt32(a: string, l?: number): Promise<OperateResult<unknown>>;
+    ReadUInt32(a: string, l?: number): Promise<OperateResult<unknown>>;
+    ReadFloat(a: string, l?: number): Promise<OperateResult<unknown>>;
+    ReadDouble(a: string, l?: number): Promise<OperateResult<unknown>>;
+    ReadInt64(a: string, l?: number): Promise<OperateResult<unknown>>;
+    ReadUInt64(a: string, l?: number): Promise<OperateResult<unknown>>;
+    ReadString(address: string, length: number, encoding?: BufferEncoding): Promise<OperateResult<string>>;
+    Write(address: string, value: number | boolean | string | Buffer | number[] | boolean[]): Promise<OperateResult<any>>;
+    WriteByte(a: string, v: number): OperateResult<unknown> | Promise<OperateResult<any>>;
+    WriteInt16(a: string, v: number): Promise<OperateResult<any>>;
+    WriteUInt16(a: string, v: number): Promise<OperateResult<any>>;
+    WriteInt32(a: string, v: number): Promise<OperateResult<any>>;
+    WriteUInt32(a: string, v: number): Promise<OperateResult<any>>;
+    WriteFloat(a: string, v: number): Promise<OperateResult<any>>;
+    WriteDouble(a: string, v: number): Promise<OperateResult<any>>;
+    WriteInt64(a: string, v: bigint | number): Promise<OperateResult<any>>;
+    WriteUInt64(a: string, v: bigint | number): Promise<OperateResult<any>>;
+    ConnectServerAsync(): Promise<OperateResult<any>>;
+    ConnectCloseAsync(): Promise<OperateResult<any>>;
+    toString(): string;
+}