zklib-ts 1.0.7 → 1.0.8

package/dist/index.es.js

@@ -1,7 +1,3479 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-const ztcp_1 = require("./ztcp");
-const zudp_1 = require("./zudp");
-const handler_1 = require("./exceptions/handler");
+import { Socket } from 'net';
+import { appendFile } from 'fs';
+import * as dgram from 'node:dgram';
+
+var COMMANDS;
+(function (COMMANDS) {
+    COMMANDS[COMMANDS["CMD_ACK_DATA"] = 2002] = "CMD_ACK_DATA";
+    /** There was an error when processing the request.*/
+    COMMANDS[COMMANDS["CMD_ACK_ERROR"] = 2001] = "CMD_ACK_ERROR";
+    COMMANDS[COMMANDS["CMD_ACK_ERROR_CMD"] = 65533] = "CMD_ACK_ERROR_CMD";
+    COMMANDS[COMMANDS["CMD_ACK_ERROR_DATA"] = 65531] = "CMD_ACK_ERROR_DATA";
+    COMMANDS[COMMANDS["CMD_ACK_ERROR_INIT"] = 65532] = "CMD_ACK_ERROR_INIT";
+    /** [0xD0, 0x07] The request was processed sucessfully. */
+    COMMANDS[COMMANDS["CMD_ACK_OK"] = 2000] = "CMD_ACK_OK";
+    COMMANDS[COMMANDS["CMD_ACK_REPEAT"] = 2004] = "CMD_ACK_REPEAT";
+    COMMANDS[COMMANDS["CMD_ACK_RETRY"] = 2003] = "CMD_ACK_RETRY";
+    /** [0xD5, 0x07] Connection not authorized. */
+    COMMANDS[COMMANDS["CMD_ACK_UNAUTH"] = 2005] = "CMD_ACK_UNAUTH";
+    /** Received unknown command. */
+    COMMANDS[COMMANDS["CMD_ACK_UNKNOWN"] = 65535] = "CMD_ACK_UNKNOWN";
+    /** Request attendance log. */
+    COMMANDS[COMMANDS["CMD_ATTLOG_RRQ"] = 13] = "CMD_ATTLOG_RRQ";
+    /** [0x4E, 0x04] Request to begin session using commkey. */
+    COMMANDS[COMMANDS["CMD_AUTH"] = 1102] = "CMD_AUTH";
+    /** [0x3e, 0x00] Disable normal authentication of users. */
+    COMMANDS[COMMANDS["CMD_CANCELCAPTURE"] = 62] = "CMD_CANCELCAPTURE";
+    /** Capture fingerprint picture. */
+    COMMANDS[COMMANDS["CMD_CAPTUREFINGER"] = 1009] = "CMD_CAPTUREFINGER";
+    /** Capture the entire image. */
+    COMMANDS[COMMANDS["CMD_CAPTUREIMAGE"] = 1012] = "CMD_CAPTUREIMAGE";
+    /** Change transmission speed. */
+    COMMANDS[COMMANDS["CMD_CHANGE_SPEED"] = 1101] = "CMD_CHANGE_SPEED";
+    /** [0x77, 0x00] Get checksum of machine's buffer. */
+    COMMANDS[COMMANDS["CMD_CHECKSUM_BUFFER"] = 119] = "CMD_CHECKSUM_BUFFER";
+    /** Restore access control to default. */
+    COMMANDS[COMMANDS["CMD_CLEAR_ACC"] = 32] = "CMD_CLEAR_ACC";
+    /** Clears admins privileges. */
+    COMMANDS[COMMANDS["CMD_CLEAR_ADMIN"] = 20] = "CMD_CLEAR_ADMIN";
+    /** Delete attendance record. */
+    COMMANDS[COMMANDS["CMD_CLEAR_ATTLOG"] = 15] = "CMD_CLEAR_ATTLOG";
+    /** Delete data. */
+    COMMANDS[COMMANDS["CMD_CLEAR_DATA"] = 14] = "CMD_CLEAR_DATA";
+    /** Clear screen captions. */
+    COMMANDS[COMMANDS["CMD_CLEAR_LCD"] = 67] = "CMD_CLEAR_LCD";
+    /** Delete operations log. */
+    COMMANDS[COMMANDS["CMD_CLEAR_OPLOG"] = 33] = "CMD_CLEAR_OPLOG";
+    /** [0xE8, 0x03] Begin connection. */
+    COMMANDS[COMMANDS["CMD_CONNECT"] = 1000] = "CMD_CONNECT";
+    /** [0xDD, 0x05] Data packet. */
+    COMMANDS[COMMANDS["CMD_DATA"] = 1501] = "CMD_DATA";
+    /** Indicates that it is ready to receive data. */
+    COMMANDS[COMMANDS["CMD_DATA_RDY"] = 1504] = "CMD_DATA_RDY";
+    /** Read/Write a large data set. */
+    COMMANDS[COMMANDS["CMD_DATA_WRRQ"] = 1503] = "CMD_DATA_WRRQ";
+    /** Read saved data. */
+    COMMANDS[COMMANDS["CMD_DB_RRQ"] = 7] = "CMD_DB_RRQ";
+    /** Deletes fingerprint template. */
+    COMMANDS[COMMANDS["CMD_DEL_FPTMP"] = 134] = "CMD_DEL_FPTMP";
+    /** Delete short message. */
+    COMMANDS[COMMANDS["CMD_DELETE_SMS"] = 72] = "CMD_DELETE_SMS";
+    /** Delete user short message. */
+    COMMANDS[COMMANDS["CMD_DELETE_UDATA"] = 74] = "CMD_DELETE_UDATA";
+    /** Delete user. */
+    COMMANDS[COMMANDS["CMD_DELETE_USER"] = 18] = "CMD_DELETE_USER";
+    /** Delete user fingerprint template. */
+    COMMANDS[COMMANDS["CMD_DELETE_USERTEMP"] = 19] = "CMD_DELETE_USERTEMP";
+    /** Disables fingerprint, rfid reader and keyboard. */
+    COMMANDS[COMMANDS["CMD_DISABLEDEVICE"] = 1003] = "CMD_DISABLEDEVICE";
+    /** Get door state. */
+    COMMANDS[COMMANDS["CMD_DOORSTATE_RRQ"] = 75] = "CMD_DOORSTATE_RRQ";
+    /** Clear Mifare card. */
+    COMMANDS[COMMANDS["CMD_EMPTY_MIFARE"] = 78] = "CMD_EMPTY_MIFARE";
+    /** Enables the ":" in screen clock. */
+    COMMANDS[COMMANDS["CMD_ENABLE_CLOCK"] = 57] = "CMD_ENABLE_CLOCK";
+    /** Change machine state to "normal work". */
+    COMMANDS[COMMANDS["CMD_ENABLEDEVICE"] = 1002] = "CMD_ENABLEDEVICE";
+    /** [0xE9, 0x03] Disconnect. */
+    COMMANDS[COMMANDS["CMD_EXIT"] = 1001] = "CMD_EXIT";
+    /** [0xDE, 0x05] Release buffer used for data transmission. */
+    COMMANDS[COMMANDS["CMD_FREE_DATA"] = 1502] = "CMD_FREE_DATA";
+    /** Request machine status (remaining space). */
+    COMMANDS[COMMANDS["CMD_GET_FREE_SIZES"] = 50] = "CMD_GET_FREE_SIZES";
+    /** Request max size for users id. */
+    COMMANDS[COMMANDS["CMD_GET_PINWIDTH"] = 69] = "CMD_GET_PINWIDTH";
+    /** Request machine time. */
+    COMMANDS[COMMANDS["CMD_GET_TIME"] = 201] = "CMD_GET_TIME";
+    COMMANDS[COMMANDS["CMD_GET_USERTEMP"] = 88] = "CMD_GET_USERTEMP";
+    /** Request the firmware edition. */
+    COMMANDS[COMMANDS["CMD_GET_VERSION"] = 1100] = "CMD_GET_VERSION";
+    /** Get group timezone. */
+    COMMANDS[COMMANDS["CMD_GRPTZ_RRQ"] = 25] = "CMD_GRPTZ_RRQ";
+    /** Set group timezone. */
+    COMMANDS[COMMANDS["CMD_GRPTZ_WRQ"] = 26] = "CMD_GRPTZ_WRQ";
+    /** Read operations log. */
+    COMMANDS[COMMANDS["CMD_OPLOG_RRQ"] = 34] = "CMD_OPLOG_RRQ";
+    /** Read configuration value of the machine. */
+    COMMANDS[COMMANDS["CMD_OPTIONS_RRQ"] = 11] = "CMD_OPTIONS_RRQ";
+    /** Change configuration value of the machine. */
+    COMMANDS[COMMANDS["CMD_OPTIONS_WRQ"] = 12] = "CMD_OPTIONS_WRQ";
+    /** Shut-down machine. */
+    COMMANDS[COMMANDS["CMD_POWEROFF"] = 1005] = "CMD_POWEROFF";
+    /** [0xDC, 0x05] Prepare for data transmission. */
+    COMMANDS[COMMANDS["CMD_PREPARE_DATA"] = 1500] = "CMD_PREPARE_DATA";
+    /** [0xF5, 0x03] Refresh the machine stored data. */
+    COMMANDS[COMMANDS["CMD_REFRESHDATA"] = 1013] = "CMD_REFRESHDATA";
+    /** Refresh the configuration parameters. */
+    COMMANDS[COMMANDS["CMD_REFRESHOPTION"] = 1014] = "CMD_REFRESHOPTION";
+    /** Realtime events. */
+    COMMANDS[COMMANDS["CMD_REG_EVENT"] = 500] = "CMD_REG_EVENT";
+    /** Restart machine. */
+    COMMANDS[COMMANDS["CMD_RESTART"] = 1004] = "CMD_RESTART";
+    /** Change machine state to "awaken". */
+    COMMANDS[COMMANDS["CMD_RESUME"] = 1007] = "CMD_RESUME";
+    /** Set machine time. */
+    COMMANDS[COMMANDS["CMD_SET_TIME"] = 202] = "CMD_SET_TIME";
+    /** Change machine state to "idle". */
+    COMMANDS[COMMANDS["CMD_SLEEP"] = 1006] = "CMD_SLEEP";
+    /** Download short message. */
+    COMMANDS[COMMANDS["CMD_SMS_RRQ"] = 71] = "CMD_SMS_RRQ";
+    /** Upload short message. */
+    COMMANDS[COMMANDS["CMD_SMS_WRQ"] = 70] = "CMD_SMS_WRQ";
+    /** [0x3d, 0x00] Start enroll procedure. */
+    COMMANDS[COMMANDS["CMD_STARTENROLL"] = 61] = "CMD_STARTENROLL";
+    /** [0x3c, 0x00] Set the machine to authentication state. */
+    COMMANDS[COMMANDS["CMD_STARTVERIFY"] = 60] = "CMD_STARTVERIFY";
+    /** Query state. */
+    COMMANDS[COMMANDS["CMD_STATE_RRQ"] = 64] = "CMD_STATE_RRQ";
+    /** Test if fingerprint exists. */
+    COMMANDS[COMMANDS["CMD_TEST_TEMP"] = 1011] = "CMD_TEST_TEMP";
+    /** Test voice. */
+    COMMANDS[COMMANDS["CMD_TESTVOICE"] = 1017] = "CMD_TESTVOICE";
+    /** [0x77, 0x00] Transfer fp template from buffer. */
+    COMMANDS[COMMANDS["CMD_TMP_WRITE"] = 87] = "CMD_TMP_WRITE";
+    /** Get device timezones. */
+    COMMANDS[COMMANDS["CMD_TZ_RRQ"] = 27] = "CMD_TZ_RRQ";
+    /** Set device timezones. */
+    COMMANDS[COMMANDS["CMD_TZ_WRQ"] = 28] = "CMD_TZ_WRQ";
+    /** Set user short message. */
+    COMMANDS[COMMANDS["CMD_UDATA_WRQ"] = 73] = "CMD_UDATA_WRQ";
+    /** Get group combination to unlock. */
+    COMMANDS[COMMANDS["CMD_ULG_RRQ"] = 29] = "CMD_ULG_RRQ";
+    /** Set group combination to unlock. */
+    COMMANDS[COMMANDS["CMD_ULG_WRQ"] = 30] = "CMD_ULG_WRQ";
+    /** Unlock door for a specified amount of time. */
+    COMMANDS[COMMANDS["CMD_UNLOCK"] = 31] = "CMD_UNLOCK";
+    /** Upload user data. */
+    COMMANDS[COMMANDS["CMD_USER_WRQ"] = 8] = "CMD_USER_WRQ";
+    /** Read user group. */
+    COMMANDS[COMMANDS["CMD_USERGRP_RRQ"] = 21] = "CMD_USERGRP_RRQ";
+    /** Set user group. */
+    COMMANDS[COMMANDS["CMD_USERGRP_WRQ"] = 22] = "CMD_USERGRP_WRQ";
+    /** [0x09, 0x00] Read user fingerprint template. */
+    COMMANDS[COMMANDS["CMD_USERTEMP_RRQ"] = 9] = "CMD_USERTEMP_RRQ";
+    /** Upload user fingerprint template. */
+    COMMANDS[COMMANDS["CMD_USERTEMP_WRQ"] = 10] = "CMD_USERTEMP_WRQ";
+    /** Get user timezones. */
+    COMMANDS[COMMANDS["CMD_USERTZ_RRQ"] = 23] = "CMD_USERTZ_RRQ";
+    /** Set the user timezones. */
+    COMMANDS[COMMANDS["CMD_USERTZ_WRQ"] = 24] = "CMD_USERTZ_WRQ";
+    /** Read verification style of a given user. */
+    COMMANDS[COMMANDS["CMD_VERIFY_RRQ"] = 80] = "CMD_VERIFY_RRQ";
+    /** Change verification style of a given user. */
+    COMMANDS[COMMANDS["CMD_VERIFY_WRQ"] = 79] = "CMD_VERIFY_WRQ";
+    /** Prints chars to the device screen. */
+    COMMANDS[COMMANDS["CMD_WRITE_LCD"] = 66] = "CMD_WRITE_LCD";
+    /** Write data to Mifare card. */
+    COMMANDS[COMMANDS["CMD_WRITE_MIFARE"] = 76] = "CMD_WRITE_MIFARE";
+})(COMMANDS || (COMMANDS = {}));
+var RTEvent;
+(function (RTEvent) {
+    /** Triggered alarm. */
+    RTEvent[RTEvent["EF_ALARM"] = 512] = "EF_ALARM";
+    /** Attendance entry. */
+    RTEvent[RTEvent["EF_ATTLOG"] = 1] = "EF_ATTLOG";
+    /** Pressed keyboard key. */
+    RTEvent[RTEvent["EF_BUTTON"] = 16] = "EF_BUTTON";
+    /** Upload user data. */
+    RTEvent[RTEvent["EF_ENROLLFINGER"] = 8] = "EF_ENROLLFINGER";
+    /** Enrolled user. */
+    RTEvent[RTEvent["EF_ENROLLUSER"] = 4] = "EF_ENROLLUSER";
+    /** Pressed finger. */
+    RTEvent[RTEvent["EF_FINGER"] = 2] = "EF_FINGER";
+    /** Fingerprint score in enroll procedure. */
+    RTEvent[RTEvent["EF_FPFTR"] = 256] = "EF_FPFTR";
+    /** Restore access control to default. */
+    RTEvent[RTEvent["EF_UNLOCK"] = 32] = "EF_UNLOCK";
+    /** Registered user placed finger. */
+    RTEvent[RTEvent["EF_VERIFY"] = 128] = "EF_VERIFY";
+})(RTEvent || (RTEvent = {}));
+var DISCOVERED_CMD;
+(function (DISCOVERED_CMD) {
+    /** [0x7f, 0x13] */
+    DISCOVERED_CMD[DISCOVERED_CMD["UNKNOWN"] = 4991] = "UNKNOWN";
+    /** Returned when the Finger id not exists in the user uid, when attempting to download single finger template */
+    DISCOVERED_CMD[DISCOVERED_CMD["FID_NOT_FOUND"] = 4993] = "FID_NOT_FOUND";
+    /** [0x87, 0x13] i guess is an error reply code, is returned when attempint to read options ~isABCPinEnable and ~T9FunOn */
+    DISCOVERED_CMD[DISCOVERED_CMD["UNKNOWN_OR_NOT_SUPPORTED"] = 4999] = "UNKNOWN_OR_NOT_SUPPORTED";
+})(DISCOVERED_CMD || (DISCOVERED_CMD = {}));
+var Constants;
+(function (Constants) {
+    Constants[Constants["USHRT_MAX"] = 65535] = "USHRT_MAX";
+    Constants[Constants["MAX_CHUNK"] = 65472] = "MAX_CHUNK";
+    Constants[Constants["MACHINE_PREPARE_DATA_1"] = 20560] = "MACHINE_PREPARE_DATA_1";
+    Constants[Constants["MACHINE_PREPARE_DATA_2"] = 32130] = "MACHINE_PREPARE_DATA_2";
+})(Constants || (Constants = {}));
+const REQUEST_DATA = {
+    START_TAG: Buffer.from([0x50, 0x50, 0x82, 0x7d]),
+    DISABLE_DEVICE: Buffer.from([0, 0, 0, 0]),
+    GET_REAL_TIME_EVENT: Buffer.from([0x01, 0x00, 0x00, 0x00]),
+    GET_ATTENDANCE_LOGS: Buffer.from([0x01, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]),
+    GET_USERS: Buffer.from([0x01, 0x09, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]),
+    GET_TEMPLATES: Buffer.from([0x01, 0x07, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
+};
+
+/**
+ * Error types for device communication
+ */
+const ERROR_TYPES = {
+    ECONNRESET: 'ECONNRESET',
+    ECONNREFUSED: 'ECONNREFUSED'};
+/**
+ * Custom error class for device communication errors
+ */
+class ZkError {
+    err;
+    ip;
+    command;
+    /**
+     * Creates a new ZkError instance
+     * @param err The error object
+     * @param command The command that caused the error
+     * @param ip The IP address of the device
+     */
+    constructor(err, command, ip) {
+        this.err = err;
+        this.ip = ip;
+        this.command = command;
+    }
+    /**
+     * Gets a user-friendly error message
+     * @returns A formatted error message
+     */
+    toast() {
+        if (this.err.code === ERROR_TYPES.ECONNRESET) {
+            return 'Another device is connecting to the device so the connection is interrupted';
+        }
+        else if (this.err.code === ERROR_TYPES.ECONNREFUSED) {
+            return 'IP of the device is refused';
+        }
+        return this.err.message;
+    }
+    /**
+     * Gets detailed error information
+     * @returns An object containing error details
+     */
+    getError() {
+        return {
+            err: {
+                message: this.err.message,
+                code: this.err.code
+            },
+            ip: this.ip,
+            command: this.command
+        };
+    }
+}
+
+const parseCurrentTime = () => {
+    const currentTime = new Date();
+    return {
+        year: currentTime.getFullYear(),
+        month: currentTime.getMonth() + 1,
+        day: currentTime.getDate(),
+        hour: currentTime.getHours(),
+        second: currentTime.getSeconds()
+    };
+};
+const log = (text) => {
+    const currentTime = parseCurrentTime();
+    const fileName = `${currentTime.day}`.padStart(2, '0') +
+        `${currentTime.month}`.padStart(2, '0') +
+        `${currentTime.year}.err.log`;
+    const logMessage = `\n [${currentTime.hour}:${currentTime.second}] ${text}`;
+    appendFile(fileName, logMessage, () => { });
+};
+
+/**
+ * Represents a User as is from ZkDevice and contain methods
+ * */
+class User {
+    uid;
+    name;
+    privilege;
+    password;
+    group_id;
+    user_id;
+    card;
+    /**
+     * Creates a new User instance
+     * @param uid User ID
+     * @param name User name
+     * @param privilege Privilege level
+     * @param password User password (default: "")
+     * @param group_id Group ID (default: "")
+     * @param user_id Alternate user ID (default: "")
+     * @param card Card number (default: 0)
+     */
+    constructor(uid, name, privilege, password = '', group_id = '', user_id = '', card = 0) {
+        this.uid = uid;
+        this.name = name;
+        this.privilege = privilege;
+        this.password = password;
+        this.group_id = group_id;
+        this.user_id = user_id;
+        this.card = card;
+    }
+    ensureEncoding(string) {
+        try {
+            return decodeURIComponent(string);
+        }
+        catch (e) {
+            return unescape(string);
+        }
+    }
+    repack29() {
+        // Pack format: <BHB5s8sIxBhI (total 29 bytes)
+        const buf = Buffer.alloc(29);
+        let offset = 0;
+        buf.writeUInt8(2, offset);
+        offset += 1;
+        buf.writeUInt16LE(this.uid, offset);
+        offset += 2;
+        buf.writeUInt8(this.privilege, offset);
+        offset += 1;
+        const passwordBuf = Buffer.from(this.ensureEncoding(this.password));
+        passwordBuf.copy(buf, offset, 0, 5);
+        offset += 5;
+        const nameBuf = Buffer.from(this.ensureEncoding(this.name));
+        nameBuf.copy(buf, offset, 0, 8);
+        offset += 8;
+        buf.writeUInt32LE(this.card, offset);
+        offset += 4;
+        offset += 1; // padding byte
+        buf.writeUInt8(0, offset);
+        offset += 1;
+        buf.writeUInt32LE(parseInt(this.user_id) || 0, offset);
+        return buf;
+    }
+    repack73() {
+        // Pack format: <BHB8s24sIB7sx24s (total 73 bytes)
+        const buf = Buffer.alloc(73);
+        let offset = 0;
+        buf.writeUInt8(2, offset);
+        offset += 1;
+        buf.writeUInt16LE(this.uid, offset);
+        offset += 2;
+        buf.writeUInt8(this.privilege, offset);
+        offset += 1;
+        const passwordBuf = Buffer.from(this.ensureEncoding(this.password));
+        passwordBuf.copy(buf, offset, 0, 8);
+        offset += 8;
+        const nameBuf = Buffer.from(this.ensureEncoding(this.name));
+        nameBuf.copy(buf, offset, 0, 24);
+        offset += 24;
+        buf.writeUInt32LE(this.card, offset);
+        offset += 4;
+        buf.writeUInt8(1, offset);
+        offset += 1;
+        const groupBuf = Buffer.from(this.ensureEncoding(String(this.group_id)));
+        groupBuf.copy(buf, offset, 0, 7);
+        offset += 8;
+        const userIdBuf = Buffer.from(this.ensureEncoding(String(this.user_id)));
+        userIdBuf.copy(buf, offset, 0, 24);
+        return buf;
+    }
+}
+
+/**
+ * Represents an Attendance Records
+ */
+class Attendance {
+    /** Internal serial number for the user */
+    sn;
+    /** User ID/Pin stored as a string */
+    user_id;
+    /** Verification type */
+    type;
+    /** Time of the attendance event */
+    record_time;
+    /** Verify state */
+    state;
+    ip;
+    constructor(sn, user_id, type, record_time, state) {
+        this.sn = sn;
+        this.user_id = user_id;
+        this.type = type || undefined;
+        this.record_time = record_time;
+        this.state = state || undefined;
+    }
+}
+
+const parseHexToTime = (hex) => {
+    const time = {
+        year: hex.readUIntLE(0, 1),
+        month: hex.readUIntLE(1, 1),
+        date: hex.readUIntLE(2, 1),
+        hour: hex.readUIntLE(3, 1),
+        minute: hex.readUIntLE(4, 1),
+        second: hex.readUIntLE(5, 1),
+    };
+    return new Date(2000 + time.year, time.month - 1, time.date, time.hour, time.minute, time.second);
+};
+const createChkSum = (buf) => {
+    let chksum = 0;
+    for (let i = 0; i < buf.length; i += 2) {
+        if (i === buf.length - 1) {
+            chksum += buf[i];
+        }
+        else {
+            chksum += buf.readUInt16LE(i);
+        }
+        chksum %= Constants.USHRT_MAX;
+    }
+    chksum = Constants.USHRT_MAX - chksum - 1;
+    return chksum;
+};
+const createUDPHeader = (command, sessionId, replyId, data) => {
+    const dataBuffer = Buffer.from(data);
+    const buf = Buffer.alloc(8 + dataBuffer.length);
+    buf.writeUInt16LE(command, 0);
+    buf.writeUInt16LE(0, 2);
+    buf.writeUInt16LE(sessionId, 4);
+    buf.writeUInt16LE(replyId, 6);
+    dataBuffer.copy(buf, 8);
+    const chksum2 = createChkSum(buf);
+    buf.writeUInt16LE(chksum2, 2);
+    replyId = (replyId + 1) % Constants.USHRT_MAX;
+    buf.writeUInt16LE(replyId, 6);
+    return buf;
+};
+const createTCPHeader = (command, sessionId, replyId, data) => {
+    const buf = createUDPHeader(command, sessionId, replyId, data);
+    const prefixBuf = Buffer.from([
+        0x50, 0x50, 0x82, 0x7d, 0x13, 0x00, 0x00, 0x00,
+    ]);
+    prefixBuf.writeUInt16LE(buf.length, 4);
+    return Buffer.concat([prefixBuf, buf]);
+};
+const removeTcpHeader = (buf) => {
+    if (buf.length < 8) {
+        return buf;
+    }
+    if (buf.compare(Buffer.from([0x50, 0x50, 0x82, 0x7d]), 0, 4, 0, 4) !== 0) {
+        return buf;
+    }
+    return buf.slice(8);
+};
+const parseTimeToDate = (time) => {
+    const second = time % 60;
+    time = (time - second) / 60;
+    const minute = time % 60;
+    time = (time - minute) / 60;
+    const hour = time % 24;
+    time = (time - hour) / 24;
+    const day = (time % 31) + 1;
+    time = (time - (day - 1)) / 31;
+    const month = time % 12;
+    time = (time - month) / 12;
+    const year = time + 2000;
+    return new Date(Date.UTC(year, month, day, hour, minute, second));
+};
+const decodeUserData28 = (userData) => {
+    return {
+        uid: userData.readUIntLE(0, 2),
+        privilege: userData.readUIntLE(2, 1),
+        name: userData
+            .slice(8, 8 + 8)
+            .toString("ascii")
+            .split("\0")
+            .shift() || "",
+        user_id: userData.readUIntLE(24, 4).toString(),
+    };
+};
+const decodeUserData72 = (userData) => {
+    return new User(userData.readUIntLE(0, 2), userData.slice(11).toString("ascii").split("\0").shift() || "", userData.readUIntLE(2, 1), userData
+        .subarray(3, 3 + 8)
+        .toString("ascii")
+        .split("\0")
+        .shift() || "", userData.readUIntLE(39, 1), userData
+        .slice(48, 48 + 9)
+        .toString("ascii")
+        .split("\0")
+        .shift() || "", userData.readUIntLE(35, 4));
+};
+const decodeRecordData40 = (recordData) => {
+    return new Attendance(recordData.readUIntLE(0, 2), recordData
+        .slice(2, 2 + 9)
+        .toString("ascii")
+        .split("\0")
+        .shift() || "", recordData.readUIntLE(26, 1), parseTimeToDate(recordData.readUInt32LE(27)), recordData.readUIntLE(31, 1));
+};
+const decodeRecordData16 = (recordData) => {
+    return {
+        user_id: recordData.readUIntLE(0, 2).toString(),
+        record_time: parseTimeToDate(recordData.readUInt32LE(4)),
+    };
+};
+const decodeRecordRealTimeLog18 = (recordData) => {
+    const user_id = recordData.readUIntLE(8, 1).toString();
+    const record_time = parseHexToTime(recordData.subarray(12, 18));
+    return { user_id, record_time };
+};
+const decodeUDPHeader = (header) => {
+    return {
+        commandId: header.readUIntLE(0, 2),
+        checkSum: header.readUIntLE(2, 2),
+        sessionId: header.readUIntLE(4, 2),
+        replyId: header.readUIntLE(6, 2),
+    };
+};
+const decodeTCPHeader = (header) => {
+    const recvData = header.subarray(8);
+    const payloadSize = header.readUIntLE(4, 2);
+    return {
+        commandId: recvData.readUIntLE(0, 2),
+        checkSum: recvData.readUIntLE(2, 2),
+        sessionId: recvData.readUIntLE(4, 2),
+        replyId: recvData.readUIntLE(6, 2),
+        payloadSize,
+    };
+};
+const exportErrorMessage = (commandValue) => {
+    const keys = Object.keys(COMMANDS);
+    for (const key of keys) {
+        if (COMMANDS[key] === commandValue) {
+            return key.toString();
+        }
+    }
+    return "AN UNKNOWN ERROR";
+};
+const isRTEvent = (event) => Object.values(RTEvent).includes(event);
+const checkNotEventTCP = (data) => {
+    try {
+        const cleanedData = removeTcpHeader(data);
+        const commandId = cleanedData.readUIntLE(0, 2);
+        const event = cleanedData.readUIntLE(4, 2);
+        return isRTEvent(event) && commandId === COMMANDS.CMD_REG_EVENT;
+    }
+    catch (err) {
+        log(`[228] : ${err.toString()} ,${data.toString("hex")} `);
+        return false;
+    }
+};
+const checkNotEventUDP = (data) => {
+    const { commandId } = decodeUDPHeader(data.subarray(0, 8));
+    return commandId === COMMANDS.CMD_REG_EVENT;
+};
+const decodeRTEvent = (data) => {
+    const header = decodeTCPHeader(data);
+    console.log(header);
+    const event = header.sessionId;
+    const recvData = data.subarray(16);
+    const build = {
+        alarm4bytes: function (data) {
+            return {
+                alarm_type: data.readUintLE(0, 4),
+                alarm_cause: data.readUintLE(4, 2),
+                user_uid: data.readUintLE(6, 2),
+                match_type: data.readUintLE(8, 4),
+            };
+        },
+        enrolledFinger: function (data) {
+            return {
+                result: data.readUIntLE(0, 2),
+                size: data.readUintLE(2, 2),
+                pin: data.subarray(4, 4 + 9).toString("ascii"),
+                fid: data.readUIntLE(1, 13),
+            };
+        },
+        fingerScore: function (data) {
+            return { score: data.readUintLE(0, 1) };
+        },
+    };
+    switch (event) {
+        case RTEvent.EF_FINGER:
+            return { event };
+        case RTEvent.EF_FPFTR:
+            return { event, payload: build.fingerScore(recvData) };
+        default:
+            console.log("utils linea 284");
+            break;
+    }
+};
+const makeKey = (key, sessionId) => {
+    let k = 0;
+    for (let i = 0; i < 32; i++) {
+        if ((key & (1 << i)) !== 0) {
+            k = (k << 1) | 1;
+        }
+        else {
+            k = k << 1;
+        }
+    }
+    k += sessionId;
+    let hex = k.toString(16).padStart(8, "0");
+    const response = new Uint8Array(4);
+    let index = 3;
+    while (hex.length > 0) {
+        response[index] = parseInt(hex.substring(0, 2), 16);
+        index--;
+        hex = hex.substring(2);
+    }
+    response[0] ^= "Z".charCodeAt(0);
+    response[1] ^= "K".charCodeAt(0);
+    response[2] ^= "S".charCodeAt(0);
+    response[3] ^= "O".charCodeAt(0);
+    let finalKey = response[0] +
+        (response[1] << 8) +
+        (response[2] << 16) +
+        (response[3] << 24);
+    const swp = finalKey >>> 16;
+    finalKey = (finalKey << 16) | swp;
+    return finalKey >>> 0;
+};
+const authKey = (comKey, sessionId) => {
+    const k = makeKey(comKey, sessionId) >>> 0;
+    const rand = Math.floor(Math.random() * 256);
+    let hex = k.toString(16).padStart(8, "0");
+    const response = new Uint8Array(4);
+    let index = 3;
+    while (index >= 0) {
+        response[index] = parseInt(hex.substring(0, 2), 16);
+        index--;
+        hex = hex.substring(2);
+    }
+    response[0] ^= rand;
+    response[1] ^= rand;
+    response[2] = rand;
+    response[3] ^= rand;
+    return Array.from(response);
+};
+/** Some Tcp packets receibed by the socket client can be merged in one single data event by the OS, and we need to split to handle correctly */
+const splitTcpPackets = (data) => {
+    const packets = [];
+    let unProcessed = data;
+    while (unProcessed.length > 0) {
+        const headers = decodeTCPHeader(unProcessed);
+        packets.push(unProcessed.subarray(0, headers.payloadSize + 8));
+        unProcessed = unProcessed.subarray(headers.payloadSize + 8);
+    }
+    return packets;
+};
+
+/**
+ * Represents a fingerprint template with associated metadata
+ */
+class Finger {
+    uid;
+    fid;
+    /** Flag indicating 0 = invalid | 1 = valid | 3 = duress. if is not initilizaed, default is 1 = valid */
+    valid;
+    template;
+    size;
+    mark;
+    /**
+     * Creates a new Finger instance
+     * @param uid User internal reference
+     * @param fid Finger ID (value >= 0 && value <= 9)
+     * @param valid Flag indicating 0 = invalid | 1 = valid | 3 = duress
+     * @param template Fingerprint template data buffer
+     */
+    constructor(uid, fid, template, valid) {
+        this.uid = Number(uid);
+        this.fid = Number(fid);
+        this.valid = valid ? Number(valid) : 1;
+        this.template = template;
+        this.size = template.length;
+        // Create mark showing first and last 8 bytes as hex
+        const start = Uint8Array.prototype.slice.call(template, 0, 8).toString('hex');
+        const end = Uint8Array.prototype.slice.call(template, -8).toString('hex');
+        this.mark = `${start}...${end}`;
+    }
+    /**
+     * Packs the fingerprint data with metadata into a Buffer
+     * @returns Buffer containing packed fingerprint data
+     */
+    repack() {
+        // pack("HHbb%is" % (self.size), self.size+6, self.uid, self.fid, self.valid, self.template)
+        const buf = Buffer.alloc(6 + this.size); // HHbb = 6 bytes + template size
+        let offset = 0;
+        buf.writeUInt16LE(this.size + 6, offset);
+        offset += 2;
+        buf.writeUInt16LE(this.uid, offset);
+        offset += 2;
+        buf.writeUInt8(this.fid, offset);
+        offset += 1;
+        buf.writeUInt8(this.valid, offset);
+        offset += 1;
+        this.template.copy(buf, offset);
+        return buf;
+    }
+    /**
+     * Packs only the fingerprint template data into a Buffer
+     * @returns Buffer containing just the template data
+     */
+    repackOnly() {
+        // pack("H%is" % (self.size), self.size, self.template)
+        const buf = Buffer.alloc(2 + this.size); // H = 2 bytes + template size
+        buf.writeUInt16LE(this.size, 0);
+        this.template.copy(buf, 2);
+        return buf;
+    }
+    /**
+     * Compares this fingerprint with another for equality
+     * @param other Another Finger instance to compare with
+     * @returns true if all properties and template data match
+     */
+    equals(other) {
+        if (!(other instanceof Finger))
+            return false;
+        return this.uid === other.uid &&
+            this.fid === other.fid &&
+            this.valid === other.valid &&
+            this.template.equals(other.template);
+    }
+}
+
+class UserService {
+    _zkTcp;
+    _users;
+    constructor(zkTcp) {
+        this._zkTcp = zkTcp;
+    }
+    async getUserByUserId(user_id) {
+        if (!this._users) {
+            await this.getUsers();
+        }
+        if (this._users.has(String(user_id))) {
+            return this._users.get(String(user_id));
+        }
+        else
+            throw new Error("user_id not exists");
+    }
+    async getUsers() {
+        try {
+            // Free any existing buffer data to prepare for a new request
+            if (this._users) {
+                return { data: Array.from(this._users.values()) };
+            }
+            else {
+                this._users = new Map([]);
+            }
+            if (this._zkTcp.socket) {
+                await this._zkTcp.freeData();
+            }
+            await this._zkTcp.disableDevice();
+            const users = await new Promise((resolve, reject) => {
+                // Request user data
+                this._zkTcp
+                    .readWithBuffer(REQUEST_DATA.GET_USERS)
+                    .then(async (data) => {
+                    // Ensure data.data is a valid buffer
+                    if (!data.data || !(data.data instanceof Buffer)) {
+                        reject(new Error("Invalid data received"));
+                        return;
+                    }
+                    let userData = data.data.subarray(4); // Skip the first 4 bytes (headers)
+                    const users = [];
+                    // Constants for user data processing
+                    const USER_PACKET_SIZE = 72;
+                    // Process each user packet
+                    while (userData.length >= USER_PACKET_SIZE) {
+                        // Decode user data and add to the users array
+                        const user = decodeUserData72(userData.subarray(0, USER_PACKET_SIZE));
+                        users.push(user);
+                        this._users.set(user.user_id, user);
+                        userData = userData.subarray(USER_PACKET_SIZE); // Move to the next packet
+                    }
+                    resolve(users);
+                })
+                    .catch(reject);
+            });
+            // Free buffer data after receiving the data
+            if (this._zkTcp.socket && users) {
+                await this._zkTcp.enableDevice();
+                await this._zkTcp.freeData();
+            }
+            // Return the list of users
+            return { data: users };
+        }
+        catch (err) {
+            // Log the error for debugging
+            console.error("Error getting users:", err);
+            // Re-throw the error to be handled by the caller
+            throw err;
+        }
+    }
+    async setUser(user_id, name, password, role = 0, cardno = 0) {
+        try {
+            // Validate input parameters
+            if (user_id.length > 9 ||
+                name.length > 24 ||
+                password.length > 8 ||
+                typeof role !== "number" ||
+                cardno.toString().length > 10) {
+                throw new Error("Invalid input parameters");
+            }
+            // Allocate and initialize the buffer
+            const commandBuffer = Buffer.alloc(72);
+            // Fill the buffer with user data
+            commandBuffer.writeUInt16LE(0, 0); // uid will be set in the device
+            commandBuffer.writeUInt16LE(role, 2);
+            commandBuffer.write(password.padEnd(8, "\0"), 3, 8); // Ensure password is 8 bytes
+            commandBuffer.write(name.padEnd(24, "\0"), 11, 24); // Ensure name is 24 bytes
+            commandBuffer.writeUInt16LE(cardno, 35);
+            commandBuffer.writeUInt32LE(0, 40); // Placeholder or reserved field
+            commandBuffer.write(user_id.padEnd(9, "\0"), 48, 9); // Ensure userid is 9 bytes
+            // Send the command and return the result
+            const created = await this._zkTcp.executeCmd(COMMANDS.CMD_USER_WRQ, commandBuffer);
+            return !!created;
+        }
+        catch (err) {
+            // Log error details for debugging
+            console.error("Error setting user:", err);
+            // Re-throw error for upstream handling
+            throw err;
+        }
+    }
+    async DeleteUser(user_id) {
+        try {
+            const user = await this.getUserByUserId(user_id);
+            // Allocate and initialize the buffer
+            const commandBuffer = Buffer.alloc(72);
+            // Write UID to the buffer
+            commandBuffer.writeUInt16LE(user.uid, 0);
+            // Send the delete command and return the result
+            const deleted = await this._zkTcp.executeCmd(COMMANDS.CMD_DELETE_USER, commandBuffer);
+            return !!deleted;
+        }
+        catch (err) {
+            // Log error details for debugging
+            console.error("Error deleting user:", err);
+            // Re-throw error for upstream handling
+            throw err;
+        }
+    }
+    async getTemplates(cb) {
+        const templates = [];
+        try {
+            await this._zkTcp.disableDevice();
+            if (this._zkTcp.socket) {
+                await this._zkTcp.freeData();
+            }
+            if (!this._zkTcp.fp_count) {
+                await this._zkTcp.getSizes();
+            }
+            if (this._zkTcp.fp_count == 0)
+                return { data: [] };
+            const resp = (await this._zkTcp.readWithBuffer(REQUEST_DATA.GET_TEMPLATES));
+            let templateData = resp.data.subarray(4);
+            let totalSize = resp.data.readUIntLE(0, 4);
+            while (totalSize) {
+                const buf = templateData.subarray(0, 6);
+                const size = buf.readUIntLE(0, 2);
+                const uid = buf.readUIntLE(2, 2);
+                const fid = buf.readUIntLE(4, 1);
+                const valid = buf.readUIntLE(5, 1);
+                // Force-copy bytes so we don't retain the entire big backing buffer
+                const tplBytes = Buffer.from(templateData.subarray(6, size));
+                templates.push(new Finger(uid, fid, tplBytes, valid));
+                templateData = templateData.subarray(size);
+                totalSize -= size;
+            }
+            if (cb)
+                cb(templates);
+            return { data: templates };
+        }
+        catch (err) {
+            this._zkTcp.verbose && console.log("Error getting templates", err);
+            throw err;
+        }
+        finally {
+            await this._zkTcp.freeData();
+            await this._zkTcp.enableDevice();
+        }
+    }
+    async DownloadFp(user_id, fid) {
+        try {
+            const user = (await this.getUserByUserId(String(user_id)));
+            if (0 > fid || fid > 9)
+                throw new Error("fid must be between 0 and 9");
+            // Allocate and initialize the buffer
+            const data = Buffer.alloc(3);
+            // Fill the buffer with user data
+            data.writeUInt16LE(user.uid, 0);
+            data.writeUIntLE(fid, 2, 1);
+            this._zkTcp.replyId++;
+            const packet = createTCPHeader(COMMANDS.CMD_USERTEMP_RRQ, this._zkTcp.sessionId, this._zkTcp.replyId, data);
+            let fingerSize = 0;
+            let fingerTemplate = Buffer.from([]);
+            const template = await new Promise((resolve, reject) => {
+                let timeout;
+                const cleanup = () => {
+                    if (this._zkTcp.socket) {
+                        this._zkTcp.socket.removeListener("data", receiveData);
+                    }
+                    if (timeout)
+                        clearTimeout(timeout);
+                };
+                let timer = () => setTimeout(() => {
+                    cleanup();
+                    reject(new Error("Time Out, Could not retrieve data"));
+                }, this._zkTcp.timeout);
+                const receiveData = (data) => {
+                    timeout = timer();
+                    if (data.length === 0)
+                        return;
+                    try {
+                        if (data.length === 0)
+                            return;
+                        const headers = decodeTCPHeader(data);
+                        switch (headers.commandId) {
+                            case DISCOVERED_CMD.FID_NOT_FOUND:
+                                throw new Error("Could not retrieve data. maybe finger id not exists?");
+                            case COMMANDS.CMD_PREPARE_DATA:
+                                fingerSize = data.readUIntLE(16, 2);
+                                break;
+                            case COMMANDS.CMD_DATA:
+                                // A single 'data' event might contain multiple TCP packets combined by the OS
+                                // in this method, is possible to get CMD_DATA and CMD_ACK_OK in the same event,
+                                // so It's important to split data received for remove CMD_ACK_OK headers
+                                fingerTemplate = Buffer.concat([
+                                    fingerTemplate,
+                                    data.subarray(16, fingerSize + 10),
+                                ]);
+                                // @ts-ignore
+                                resolve(fingerTemplate);
+                                break;
+                            case COMMANDS.CMD_ACK_OK:
+                                cleanup();
+                                // @ts-ignore
+                                resolve(fingerTemplate);
+                                return;
+                            default:
+                                // If it's not a recognized command but has data, it might be raw template data
+                                if (headers.commandId > 2000 && headers.commandId < 3000) {
+                                    // Likely another ACK or system msg
+                                }
+                                else {
+                                    fingerTemplate = Buffer.concat([fingerTemplate, data]);
+                                }
+                                break;
+                        }
+                        clearTimeout(timeout);
+                    }
+                    catch (e) {
+                        cleanup();
+                        reject(e);
+                    }
+                };
+                if (this._zkTcp.socket) {
+                    this._zkTcp.socket.on("data", receiveData);
+                    this._zkTcp.socket.write(packet, undefined, (err) => {
+                        if (err) {
+                            cleanup();
+                            reject(err);
+                        }
+                    });
+                }
+                else {
+                    reject(new Error("Socket not initialized"));
+                }
+            });
+            return new Finger(user.uid, fid, template);
+        }
+        catch (err) {
+            throw err;
+        }
+        finally {
+            await this._zkTcp.freeData();
+        }
+    }
+    /**
+     *
+     * @param user_id {string} user
+     * @param fingers {Finger[]} array of finger templates instances
+     * */
+    async saveTemplates(user_id, fingers = []) {
+        if (fingers.length > 9 || fingers.length == 0)
+            throw new Error("maximum finger length is 10 and can't be empty");
+        try {
+            await this._zkTcp.disableDevice();
+            // check users exists
+            const user = await this.getUserByUserId(user_id);
+            let fpack = Buffer.alloc(0);
+            let table = Buffer.alloc(0);
+            const fnum = 0x10;
+            let tstart = 0;
+            for (const finger of fingers) {
+                const tfp = finger.repackOnly();
+                const tableEntry = Buffer.alloc(11); // b=1, H=2, b=1, I=4 => 1+2+1+4=8? Wait, bHbI is 1+2+1+4=8 bytes
+                tableEntry.writeInt8(2, 0);
+                tableEntry.writeUInt16LE(user.uid, 1);
+                tableEntry.writeInt8(fnum + finger.fid, 3);
+                tableEntry.writeUInt32LE(tstart, 4);
+                table = Buffer.concat([table, tableEntry]);
+                tstart += tfp.length;
+                fpack = Buffer.concat([fpack, tfp]);
+            }
+            let upack;
+            if (this._zkTcp.userPacketSize === 28) {
+                upack = user.repack29();
+            }
+            else {
+                upack = user.repack73();
+            }
+            const head = Buffer.alloc(12); // III = 3*4 bytes
+            head.writeUInt32LE(upack.length, 0);
+            head.writeUInt32LE(table.length, 4);
+            head.writeUInt32LE(fpack.length, 8);
+            const packet = Buffer.concat([head, upack, table, fpack]);
+            await this._zkTcp.sendWithBuffer(packet);
+            const command = 110;
+            const commandString = Buffer.alloc(8); // <IHH = I(4) + H(2) + H(2) = 8 bytes
+            commandString.writeUInt32LE(12, 0);
+            commandString.writeUInt16LE(0, 4);
+            commandString.writeUInt16LE(8, 6);
+            await this._zkTcp.executeCmd(command, commandString);
+            if (this._zkTcp.verbose)
+                console.log("finally bulk save user templates: \n", "templates saved successfully");
+        }
+        catch (error) {
+            throw error;
+        }
+        finally {
+            await this._zkTcp.refreshData();
+            await this._zkTcp.enableDevice();
+        }
+    }
+    async deleteFinger(user_id, fid) {
+        try {
+            const user = (await this.getUserByUserId(user_id));
+            const buf = Buffer.alloc(4);
+            buf.writeUInt16LE(user_id ? user.uid : 0, 0);
+            buf.writeUint16LE(fid ? fid : 0, 2);
+            const reply = await this._zkTcp.executeCmd(COMMANDS.CMD_DELETE_USERTEMP, buf);
+            return !!reply;
+        }
+        catch (error) {
+            throw new Error("Can't save utemp");
+        }
+        finally {
+            await this._zkTcp.refreshData();
+        }
+    }
+    async enrollInfo(user_id, tempId) {
+        try {
+            let timer;
+            const setTimeoutTimer = (cb) => {
+                if (timer)
+                    clearTimeout(timer);
+                return setTimeout(() => {
+                    cb(new Error("[ENROLL_INFO] time out"));
+                }, 1000 * 20);
+            };
+            const cleanUp = () => {
+                if (timer)
+                    clearTimeout(timer);
+            };
+            return await new Promise((resolve, reject) => {
+                const handleRtEvent = (rtEvent) => {
+                    switch (rtEvent.event) {
+                        case RTEvent.EF_FPFTR:
+                            timer = setTimeoutTimer(reject);
+                            break;
+                        case RTEvent.EF_FINGER:
+                            console.log(rtEvent);
+                            break;
+                        case RTEvent.EF_ENROLLFINGER:
+                            cleanUp();
+                            resolve(rtEvent);
+                            break;
+                        default:
+                            console.log(rtEvent);
+                            break;
+                    }
+                };
+                // Start enroll process
+                this.getUserByUserId(user_id)
+                    .then(async (user) => {
+                    /** First check if Finger index already exists, and if so, it must be deleted  */
+                    try {
+                        const exists = await this.DownloadFp(user_id, tempId);
+                        console.log("exists: ", exists);
+                        if (exists) {
+                            this._zkTcp.verbose &&
+                                console.debug("Deleting Finger index before start enroll");
+                            await this.deleteFinger(user_id, tempId);
+                        }
+                    }
+                    catch (e) {
+                        this._zkTcp.verbose &&
+                            console.debug("Finger index is empty, skipping delete");
+                    }
+                    const userBuf = Buffer.alloc(24);
+                    userBuf.write(user_id, 0, 24, "ascii");
+                    const commandString = Buffer.concat([
+                        userBuf,
+                        Buffer.from([tempId, 1]),
+                    ]);
+                    await this._zkTcp.executeCmd(COMMANDS.CMD_STARTENROLL, commandString); // #5
+                    this._zkTcp.timeout = 60000; // 60 seconds timeout
+                    await this._zkTcp.executeCmd(COMMANDS.CMD_STARTVERIFY, ""); // #17
+                    timer = setTimeoutTimer(reject);
+                    void (await this._zkTcp.getRealTimeLogs(handleRtEvent)); // #9
+                })
+                    .catch(reject);
+            });
+        }
+        catch (error) {
+            throw error;
+        }
+        finally {
+            //await this._zkTcp.cancelCapture();
+            //await this.verify(user_id);
+        }
+    }
+    async verify(user_id) {
+        try {
+            const user = await this.getUserByUserId(user_id);
+            const command_string = Buffer.alloc(4);
+            command_string.writeUInt32LE(user.uid, 0);
+            const reply = await this._zkTcp.executeCmd(COMMANDS.CMD_STARTVERIFY, command_string);
+            if (this._zkTcp.verbose)
+                console.log(reply.readUInt16LE(0));
+            return !!reply;
+        }
+        catch (error) {
+            console.error(error);
+            throw error;
+        }
+    }
+    /**
+     * Upload a single fingerprint for a given user id
+     * @param user_id {string} user id for customer
+     * @param fingerTemplate {string} finger template in base64 string
+     * @param fid {number} finger id is a number between 0 and 9
+     * @param fp_valid {number} finger flag. e.g., valid=1, duress=3
+     */
+    async uploadFingerTemplate(user_id, fingerTemplate, fid, fp_valid) {
+        try {
+            const user = this._users.get(user_id);
+            await this._zkTcp.disableDevice();
+            const prep_struct = Buffer.alloc(4);
+            const fingerBuffer = Buffer.from(fingerTemplate, "base64");
+            const fp_size = fingerBuffer.length;
+            prep_struct.writeUInt16LE(fp_size, 0);
+            const initPacket = await this._zkTcp.executeCmd(COMMANDS.CMD_PREPARE_DATA, prep_struct);
+            if (initPacket.readUInt16LE(0) !== COMMANDS.CMD_ACK_OK) {
+                throw new Error(`received unexpected command: ${initPacket.readUInt16LE(0)}`);
+            }
+            const fpPacket = await this._zkTcp.executeCmd(COMMANDS.CMD_DATA, fingerBuffer);
+            if (fpPacket.readUInt16LE(0) !== COMMANDS.CMD_ACK_OK) {
+                throw new Error(`received unexpected command: ${fpPacket.readUInt16LE(0)}`);
+            }
+            const cheksumPacket = await this._zkTcp.executeCmd(COMMANDS.CMD_CHECKSUM_BUFFER, "");
+            if (cheksumPacket.readUInt16LE(0) !== COMMANDS.CMD_ACK_OK) {
+                throw new Error(`received unexpected command: ${cheksumPacket.readUInt16LE(0)}`);
+            }
+            const tmp_wreq = Buffer.alloc(6);
+            tmp_wreq.writeUInt16LE(user.uid, 0);
+            tmp_wreq.writeUIntLE(fid, 2, 1);
+            tmp_wreq.writeUIntLE(fp_valid, 3, 1);
+            tmp_wreq.writeUInt16LE(fp_size, 4);
+            const tmp_wreqPacket = await this._zkTcp.executeCmd(COMMANDS.CMD_TMP_WRITE, tmp_wreq);
+            if (tmp_wreqPacket.readUInt16LE(0) !== COMMANDS.CMD_ACK_OK) {
+                throw new Error(`received unexpected command: ${tmp_wreqPacket.readUInt16LE(0)}`);
+            }
+            const freeData = await this._zkTcp.executeCmd(COMMANDS.CMD_FREE_DATA, "");
+            if (freeData.readUInt16LE(0) !== COMMANDS.CMD_ACK_OK) {
+                throw new Error(`received unexpected command: ${freeData.readUInt16LE(0)}`);
+            }
+            return true;
+        }
+        catch (err) {
+            throw err;
+        }
+        finally {
+            await this._zkTcp.refreshData();
+            await this._zkTcp.enableDevice();
+        }
+    }
+}
+
+class TransactionService {
+    _zkTcp;
+    constructor(zkTcp) {
+        this._zkTcp = zkTcp;
+    }
+    async getAttendances(callbackInProcess = () => { }) {
+        try {
+            // Free any existing buffer data to prepare for a new request
+            if (this._zkTcp.socket) {
+                await this._zkTcp.freeData();
+            }
+            // Request attendance logs and handle chunked data
+            const data = await this._zkTcp.readWithBuffer(REQUEST_DATA.GET_ATTENDANCE_LOGS, callbackInProcess);
+            // Free buffer data after receiving the attendance logs
+            if (this._zkTcp.socket) {
+                await this._zkTcp.freeData();
+            }
+            // Constants for record processing
+            const RECORD_PACKET_SIZE = 40;
+            // Ensure data.data is a valid buffer
+            if (!data.data || !(data.data instanceof Buffer)) {
+                throw new Error('Invalid data received');
+            }
+            // Process the record data
+            let recordData = data.data.subarray(4); // Skip header
+            const records = [];
+            // Process each attendance record
+            while (recordData.length >= RECORD_PACKET_SIZE) {
+                const record = decodeRecordData40(recordData.subarray(0, RECORD_PACKET_SIZE));
+                records.push({ ...record, ip: this._zkTcp.ip }); // Add IP address to each record
+                recordData = recordData.subarray(RECORD_PACKET_SIZE); // Move to the next packet
+            }
+            // Return the list of attendance records
+            return { data: records };
+        }
+        catch (err) {
+            // Log and re-throw the error
+            console.error('Error getting attendance records:', err);
+            throw err; // Re-throw the error for handling by the caller
+        }
+    }
+    // Clears the attendance logs on the device
+    async clearAttendanceLog() {
+        try {
+            // Execute the command to clear attendance logs
+            await this._zkTcp.disableDevice();
+            const buf = await this._zkTcp.executeCmd(COMMANDS.CMD_CLEAR_ATTLOG, '');
+            await this._zkTcp.refreshData();
+            await this._zkTcp.enableDevice();
+            return !!buf;
+        }
+        catch (err) {
+            // Log the error for debugging purposes
+            console.error('Error clearing attendance log:', err);
+            // Re-throw the error to be handled by the caller
+            throw err;
+        }
+    }
+}
+
+/**
+ *
+ * @param {number} time
+ */
+const decode = time => {
+    const second = time % 60;
+    time = (time - second) / 60;
+    const minute = time % 60;
+    time = (time - minute) / 60;
+    const hour = time % 24;
+    time = (time - hour) / 24;
+    const day = time % 31 + 1;
+    time = (time - (day - 1)) / 31;
+    const month = time % 12;
+    time = (time - month) / 12;
+    const year = time + 2000;
+    return new Date(year, month, day, hour, minute, second);
+};
+/**
+ *
+ * @param {Date} date
+ */
+const encode = date => {
+    return (((date.getFullYear() % 100) * 12 * 31 + date.getMonth() * 31 + date.getDate() - 1) * (24 * 60 * 60) +
+        (date.getHours() * 60 + date.getMinutes()) * 60 +
+        date.getSeconds());
+};
+var timeParser = { encode, decode };
+
+/**
+ * SDK Parameters Enum
+ *
+ * Generated from SDK parameter table with the following structure:
+ * - Keys: Parameter names in uppercase without ~ prefix
+ * - Values: Original parameter names
+ * - JSDoc: Includes description, permissions, and notes
+ */
+var SdkParameter;
+(function (SdkParameter) {
+    /**
+     * Device ID.
+     * Permissions: RW
+     * Notes: Value ranges from 1 to 254.
+     */
+    SdkParameter["DEVICE_ID"] = "DeviceID";
+    /**
+     * Language.
+     * Permissions: RW
+     * Notes: For english it is 97.
+     */
+    SdkParameter["NEW_LNG"] = "NewLng";
+    /**
+     * The machine will enter standby state or power off, after this time elapses.
+     * Permissions: RW
+     * Notes: Given in minutes.
+     */
+    SdkParameter["IDLE_MINUTE"] = "IdleMinute";
+    /**
+     * Lock control time.
+     * Permissions: RW
+     * Notes: Given in seconds.
+     */
+    SdkParameter["LOCK_ON"] = "LockOn";
+    /**
+     * Attendance record quantity alarm.
+     * Permissions: RW
+     * Notes:
+     */
+    SdkParameter["ALARM_ATT_LOG"] = "AlarmAttLog";
+    /**
+     * Operation record quantity alarm.
+     * Permissions: RW
+     * Notes:
+     */
+    SdkParameter["ALARM_OP_LOG"] = "AlarmOpLog";
+    /**
+     * Minimun time to record the same attendance state.
+     * Permissions: RW
+     * Notes: Units are unknown.
+     */
+    SdkParameter["ALARM_RE_REC"] = "AlarmReRec";
+    /**
+     * Baud rate for RS232/485.
+     * Permissions: RW
+     * Notes: Valid values are 1200, 2400, 4800, 9600, 19200, 38400 57600, 115200.
+     */
+    SdkParameter["RS232_BAUD_RATE"] = "RS232BaudRate";
+    /**
+     * Enable flag for network functions.
+     * Permissions: RW
+     * Notes:
+     */
+    SdkParameter["NETWORK_ON"] = "NetworkOn";
+    /**
+     * Enable flag for RS232.
+     * Permissions: RW
+     * Notes:
+     */
+    SdkParameter["RS232_ON"] = "RS232On";
+    /**
+     * Enable flag for RS485.
+     * Permissions: RW
+     * Notes:
+     */
+    SdkParameter["RS485_ON"] = "RS485On";
+    /**
+     * Enable announcements(voice).
+     * Permissions: RW
+     * Notes:
+     */
+    SdkParameter["VOICE_ON"] = "VoiceOn";
+    /**
+     * Perform high-speed comparison.
+     * Permissions: RW
+     * Notes: Value codification is unknown.
+     */
+    SdkParameter["MSPEED"] = "MSpeed";
+    /**
+     * Idle mode.
+     * Permissions: RW
+     * Notes: 87 indicates shutdown and 88 indicates hibernation.
+     */
+    SdkParameter["IDLE_POWER"] = "IdlePower";
+    /**
+     * Automatic shutdown time.
+     * Permissions: RW
+     * Notes: Value 255 indicates the machine to not shutdown automatically.
+     */
+    SdkParameter["AUTO_POWER_OFF"] = "AutoPowerOff";
+    /**
+     * Automatic startup time.
+     * Permissions: RW
+     * Notes: Value 255 indicates the machine to not startup automatically.
+     */
+    SdkParameter["AUTO_POWER_ON"] = "AutoPowerOn";
+    /**
+     * Automatic hibernation time.
+     * Permissions: RW
+     * Notes: Value 255 indicates the machine to not suspend automatically.
+     */
+    SdkParameter["AUTO_POWER_SUSPEND"] = "AutoPowerSuspend";
+    /**
+     * Alarm 1 time.
+     * Permissions: RW
+     * Notes: Value 65535 disables the alarm(t).
+     */
+    SdkParameter["AUTO_ALARM1"] = "AutoAlarm1";
+    /**
+     * 1:N comparison threshold.
+     * Permissions: RW
+     * Notes: Integer.
+     */
+    SdkParameter["MTHRESHOLD"] = "MThreshold";
+    /**
+     * Registration threshold.
+     * Permissions: RW
+     * Notes: Integer.
+     */
+    SdkParameter["ETHRESHOLD"] = "EThreshold";
+    /**
+     * 1:1 comparison threshold.
+     * Permissions: RW
+     * Notes: Integer.
+     */
+    SdkParameter["VTHRESHOLD"] = "VThreshold";
+    /**
+     * Display matching score during verification.
+     * Permissions: RW
+     * Notes: Bool.
+     */
+    SdkParameter["SHOW_SCORE"] = "ShowScore";
+    /**
+     * Number of people that may unlock the door at the same time.
+     * Permissions: RW
+     * Notes: Integer.
+     */
+    SdkParameter["UNLOCK_PERSON"] = "UnlockPerson";
+    /**
+     * Verify only the card number.
+     * Permissions: RW
+     * Notes: Bool.
+     */
+    SdkParameter["ONLY_PIN_CARD"] = "OnlyPINCard";
+    /**
+     * Network speed.
+     * Permissions: RW
+     * Notes: Value correspondence: 1=100M-H, 4=10M-F, 5=100M-F, 8=Auto, others=10M-H.
+     */
+    SdkParameter["HI_SPEED_NET"] = "HiSpeedNet";
+    /**
+     * Accept only registered cards.
+     * Permissions: RW
+     * Notes: Bool.
+     */
+    SdkParameter["MUST_ENROLL"] = "MustEnroll";
+    /**
+     * Timeout to return to the initial state.
+     * Permissions: RW
+     * Notes: Given in seconds.
+     */
+    SdkParameter["TO_STATE"] = "TOState";
+    /**
+     * Timeout to return to the initial state if there are no inputs after entering PIN.
+     * Permissions: RW
+     * Notes: Given in seconds.
+     */
+    SdkParameter["TO_STATE_PIN"] = "TOState";
+    /**
+     * Timeout to return to the initial state if there are no inputs after entering menu.
+     * Permissions: RW
+     * Notes: Given in seconds.
+     */
+    SdkParameter["TO_MENU"] = "TOMenu";
+    /**
+     * Time format.
+     * Permissions: NA
+     * Notes: Value codification is unknown.
+     */
+    SdkParameter["DT_FMT"] = "DtFmt";
+    /**
+     * Flag for mandatory 1:1 comparison.
+     * Permissions: RW
+     * Notes: Bool.
+     */
+    SdkParameter["MUST_1TO1"] = "Must1To1";
+    /**
+     * Alarm 2 time.
+     * Permissions: RW
+     * Notes: Value 65535 disables the alarm(t).
+     */
+    SdkParameter["AUTO_ALARM2"] = "AutoAlarm2";
+    /**
+     * Alarm 3 time.
+     * Permissions: RW
+     * Notes: Value 65535 disables the alarm(t).
+     */
+    SdkParameter["AUTO_ALARM3"] = "AutoAlarm3";
+    /**
+     * Alarm 4 time.
+     * Permissions: RW
+     * Notes: Value 65535 disables the alarm(t).
+     */
+    SdkParameter["AUTO_ALARM4"] = "AutoAlarm4";
+    /**
+     * Alarm 5 time.
+     * Permissions: RW
+     * Notes: Value 65535 disables the alarm(t).
+     */
+    SdkParameter["AUTO_ALARM5"] = "AutoAlarm5";
+    /**
+     * Alarm 6 time.
+     * Permissions: RW
+     * Notes: Value 65535 disables the alarm(t).
+     */
+    SdkParameter["AUTO_ALARM6"] = "AutoAlarm6";
+    /**
+     * Automatic status changing times.
+     * Permissions: ?
+     * Notes: -1 value indicates that the status will not change automatically.
+     */
+    SdkParameter["AS1"] = "AS1";
+    /**
+     * Automatic status changing times.
+     * Permissions: ?
+     * Notes: -1 value indicates that the status will not change automatically.
+     */
+    SdkParameter["AS2"] = "AS2";
+    /**
+     * Automatic status changing times.
+     * Permissions: ?
+     * Notes: -1 value indicates that the status will not change automatically.
+     */
+    SdkParameter["AS3"] = "AS3";
+    /**
+     * Automatic status changing times.
+     * Permissions: ?
+     * Notes: -1 value indicates that the status will not change automatically.
+     */
+    SdkParameter["AS4"] = "AS4";
+    /**
+     * Automatic status changing times.
+     * Permissions: ?
+     * Notes: -1 value indicates that the status will not change automatically.
+     */
+    SdkParameter["AS5"] = "AS5";
+    /**
+     * Automatic status changing times.
+     * Permissions: ?
+     * Notes: -1 value indicates that the status will not change automatically.
+     */
+    SdkParameter["AS6"] = "AS6";
+    /**
+     * Automatic status changing times.
+     * Permissions: ?
+     * Notes: -1 value indicates that the status will not change automatically.
+     */
+    SdkParameter["AS7"] = "AS7";
+    /**
+     * Automatic status changing times.
+     * Permissions: ?
+     * Notes: -1 value indicates that the status will not change automatically.
+     */
+    SdkParameter["AS8"] = "AS8";
+    /**
+     * Automatic status changing times.
+     * Permissions: ?
+     * Notes: -1 value indicates that the status will not change automatically.
+     */
+    SdkParameter["AS9"] = "AS9";
+    /**
+     * Automatic status changing times.
+     * Permissions: ?
+     * Notes: -1 value indicates that the status will not change automatically.
+     */
+    SdkParameter["AS10"] = "AS10";
+    /**
+     * Automatic status changing times.
+     * Permissions: ?
+     * Notes: -1 value indicates that the status will not change automatically.
+     */
+    SdkParameter["AS11"] = "AS11";
+    /**
+     * Automatic status changing times.
+     * Permissions: ?
+     * Notes: -1 value indicates that the status will not change automatically.
+     */
+    SdkParameter["AS12"] = "AS12";
+    /**
+     * Automatic status changing times.
+     * Permissions: ?
+     * Notes: -1 value indicates that the status will not change automatically.
+     */
+    SdkParameter["AS13"] = "AS13";
+    /**
+     * Automatic status changing times.
+     * Permissions: ?
+     * Notes: -1 value indicates that the status will not change automatically.
+     */
+    SdkParameter["AS14"] = "AS14";
+    /**
+     * Automatic status changing times.
+     * Permissions: ?
+     * Notes: -1 value indicates that the status will not change automatically.
+     */
+    SdkParameter["AS15"] = "AS15";
+    /**
+     * Automatic status changing times.
+     * Permissions: ?
+     * Notes: -1 value indicates that the status will not change automatically.
+     */
+    SdkParameter["AS16"] = "AS16";
+    /**
+     * Wiegand failure ID.
+     * Permissions: ?
+     * Notes:
+     */
+    SdkParameter["WG_FAILED_ID"] = "WGFailedID";
+    /**
+     * Wiegand duress ID.
+     * Permissions: ?
+     * Notes:
+     */
+    SdkParameter["WG_DURESS_ID"] = "WGDuressID";
+    /**
+     * Wiegand zone bit.
+     * Permissions: ?
+     * Notes:
+     */
+    SdkParameter["WG_SITE_CODE"] = "WGSiteCode";
+    /**
+     * Pulse width of Wiegand outputs.
+     * Permissions: ?
+     * Notes:
+     */
+    SdkParameter["WG_PULSE_WIDTH"] = "WGPulseWidth";
+    /**
+     * Pulse interval for Wiegand outputs.
+     * Permissions: ?
+     * Notes:
+     */
+    SdkParameter["WG_PULSE_INTERVAL"] = "WGPulseInterval";
+    /**
+     * ID of the start sector on the Mifare card where fingerprints are stored.
+     * Permissions: ?
+     * Notes:
+     */
+    SdkParameter["RF_START"] = "RFSStart";
+    /**
+     * Total number of sectors on the Mifare card where fingerprints are stored.
+     * Permissions: ?
+     * Notes:
+     */
+    SdkParameter["RF_LEN"] = "RFSLen";
+    /**
+     * Number of fingerprints stored on the Mifare card.
+     * Permissions: ?
+     * Notes:
+     */
+    SdkParameter["RF_FPC"] = "RFFPC";
+    /**
+     * Forbidden.
+     * Permissions: NA
+     * Notes:
+     */
+    SdkParameter["FORBIDDEN"] = "Forbidden";
+    /**
+     * Wheter to display the attendance status.
+     * Permissions: RW
+     * Notes:
+     */
+    SdkParameter["SHOW_STATE"] = "~ShowState";
+    /**
+     * TCP Port.
+     * Permissions: ?
+     * Notes:
+     */
+    SdkParameter["TCP_PORT"] = "TCPPort";
+    /**
+     * UDP Port.
+     * Permissions: ?
+     * Notes:
+     */
+    SdkParameter["UDP_PORT"] = "UDPPort";
+    /**
+     * Fingerprint algorithm version.
+     * Permissions: R
+     * Notes:
+     */
+    SdkParameter["ZK_FP_VERSION"] = "~ZKFPVersion";
+    /**
+     * Face algorithm version.
+     * Permissions: R
+     * Notes:
+     */
+    SdkParameter["ZK_FACE_VERSION"] = "~ZKFaceVersion";
+    /**
+     * Finger vein version.
+     * Permissions: R
+     * Notes:
+     */
+    SdkParameter["ZK_FV_VERSION"] = "~ZKFVVersion";
+    /**
+     * Face function.
+     * Permissions: R
+     * Notes:
+     */
+    SdkParameter["FACE_FUN_ON"] = "~FaceFunOn";
+    /**
+     * User id max length.
+     * Permissions: R
+     * Notes:
+     */
+    SdkParameter["PIN2_WIDTH"] = "~PIN2Width";
+    /**
+     * Does the user id support chars.
+     * Permissions: R
+     * Notes:
+     */
+    SdkParameter["IS_SUPPORT_ABC_PIN"] = "IsSupportABCPin";
+    /**
+     * ?
+     * Permissions: ?
+     * Notes:
+     */
+    SdkParameter["IME_FUN_ON"] = "IMEFunOn";
+    /**
+     * ?
+     * Permissions: ?
+     * Notes:
+     */
+    SdkParameter["IS_SUPPORT_ALARM_EXT"] = "IsSupportAlarmExt";
+    /**
+     * ?
+     * Permissions: ?
+     * Notes:
+     */
+    SdkParameter["DCTZ"] = "~DCTZ";
+    /**
+     * ?
+     * Permissions: ?
+     * Notes:
+     */
+    SdkParameter["DOTZ"] = "~DOTZ";
+    /**
+   * -
+   * Permissions: ?
+   * Notes:
+   */
+    SdkParameter["EXTEND_OP_LOG"] = "ExtendOPLog";
+    /**
+     * Bool
+     * Permissions: RW
+     * Notes:
+     */
+    SdkParameter["WORK_CODE"] = "WorkCode";
+    /**
+     * Integer
+     * Permissions: RW
+     * Notes:
+     */
+    SdkParameter["LANGUAGE"] = "Language";
+    /**
+     * -
+     * Permissions: ?
+     * Notes:
+     */
+    SdkParameter["BIOMETRIC_TYPE"] = "BiometricType";
+    /**
+     * Bool
+     * Permissions: RW
+     * Notes:
+     */
+    SdkParameter["FINGER_FUN_ON"] = "FingerFunOn";
+    /**
+     * Bool
+     * Permissions: ?
+     * Notes:
+     */
+    SdkParameter["IS_ONLY_RF_MACHINE"] = "~IsOnlyRFMachine";
+    /**
+     * Vendor name
+     * Permissions: ?
+     * Notes:
+     */
+    SdkParameter["OEM_VENDOR"] = "~OEMVendor";
+    /**
+     * Device name
+     * Permissions: ?
+     * Notes:
+     */
+    SdkParameter["DEVICE_NAME"] = "~DeviceName";
+    /**
+     * MAC address
+     * Permissions: ?
+     * Notes:
+     */
+    SdkParameter["MAC"] = "MAC";
+    /**
+     * Serial number
+     * Permissions: ?
+     * Notes:
+     */
+    SdkParameter["SERIAL_NUMBER"] = "~SerialNumber";
+    /**
+     * Date string
+     * Permissions: ?
+     * Notes:
+     */
+    SdkParameter["PRODUCT_TIME"] = "~ProductTime";
+    /**
+     * Bool
+     * Permissions: ?
+     * Notes:
+     */
+    SdkParameter["IS_ABC_PIN_ENABLE"] = "~IsABCPinEnable";
+    /**
+     * Bool
+     * Permissions: ?
+     * Notes:
+     */
+    SdkParameter["T9_FUN_ON"] = "~T9FunOn";
+    /**
+     * Date Time
+     * Permissions: RW
+     */
+    SdkParameter["DATETIME"] = "DateTime";
+    /**
+     *
+     */
+    SdkParameter["OS"] = "~OS";
+})(SdkParameter || (SdkParameter = {}));
+
+class OptionsService {
+    _zkTcp;
+    constructor(zkTcp) {
+        this._zkTcp = zkTcp;
+    }
+    /** Ask if the device doesn't support alphanumeric symbols for user id values. */
+    async isAbcPinEnable() {
+        const keyword = "~IsABCPinEnable";
+        try {
+            // Execute the command to get the PIN information
+            const data = await this._zkTcp.executeCmd(COMMANDS.CMD_OPTIONS_RRQ, keyword);
+            // Extract and format the PIN information from the response data
+            return data
+                .slice(8) // Skip the first 8 bytes (header)
+                .toString("ascii") // Convert buffer to ASCII string
+                .replace(`${keyword}=`, "") // Remove the keyword prefix
+                .replace(/\u0000/g, ""); // Remove null characters 0x00
+        }
+        catch (err) {
+            // Log the error for debugging
+            console.error("Error getting PIN:", err);
+            // Re-throw the error to be handled by the caller
+            throw err;
+        }
+    }
+    /** Ask if the device doesn't support alphanumeric symbols for user id values. */
+    async isT9FunOn() {
+        const keyword = "~T9FunOn";
+        try {
+            // Execute the command to get the PIN information
+            const data = await this._zkTcp.executeCmd(COMMANDS.CMD_OPTIONS_RRQ, keyword);
+            // Extract and format the PIN information from the response data
+            return data
+                .slice(8) // Skip the first 8 bytes (header)
+                .toString("ascii") // Convert buffer to ASCII string
+                .replace(`${keyword}=`, "") // Remove the keyword prefix
+                .replace(/\u0000/g, ""); // Remove null characters 0x00
+        }
+        catch (err) {
+            // Log the error for debugging
+            console.error("Error getting PIN:", err);
+            // Re-throw the error to be handled by the caller
+            throw err;
+        }
+    }
+    async getDeviceId() {
+        const keyword = SdkParameter.DEVICE_ID;
+        try {
+            let result;
+            let retry = true;
+            while (retry) {
+                // Execute the command to get the device name
+                const data = await this._zkTcp.executeCmd(COMMANDS.CMD_OPTIONS_RRQ, keyword);
+                // Extract and format the device name from the response data
+                result = data
+                    .slice(8) // Skip the first 8 bytes (header)
+                    .toString("ascii") // Convert buffer to ASCII string
+                    .replace(`${keyword}=`, "") // Remove the keyword prefix
+                    .replace(/\u0000/g, ""); // Remove null characters
+                retry = result.includes("=");
+            }
+            return result;
+        }
+        catch (err) {
+            // Log the error for debugging
+            console.error("Error getting vendor:", err);
+            // Re-throw the error for higher-level handling
+            throw err;
+        }
+    }
+    /**
+     * Change Device ID
+     * @param id a number between 1 and 254
+     */
+    async setDeviceId(id) {
+        if (id < 1 || id > 254)
+            throw new Error("Device ID must be a number between 1 and 254");
+        const data = await this._zkTcp.executeCmd(COMMANDS.CMD_OPTIONS_WRQ, `DeviceID=${id}\x00`);
+        return data.readUInt16LE(0) === COMMANDS.CMD_ACK_OK;
+    }
+    async getVendor() {
+        const keyword = "~OEMVendor";
+        try {
+            let result;
+            let retry = true;
+            while (retry) {
+                // Execute the command to get the device name
+                const data = await this._zkTcp.executeCmd(COMMANDS.CMD_OPTIONS_RRQ, keyword);
+                // Extract and format the device name from the response data
+                result = data
+                    .slice(8) // Skip the first 8 bytes (header)
+                    .toString("ascii") // Convert buffer to ASCII string
+                    .replace(`${keyword}=`, "") // Remove the keyword prefix
+                    .replace(/\u0000/g, ""); // Remove null characters
+                retry = result.includes("=");
+            }
+            return result;
+        }
+        catch (err) {
+            // Log the error for debugging
+            console.error("Error getting vendor:", err);
+            // Re-throw the error for higher-level handling
+            throw err;
+        }
+    }
+    async getProductTime() {
+        const keyword = "~ProductTime";
+        try {
+            // Execute the command to get serial number
+            const data = await this._zkTcp.executeCmd(COMMANDS.CMD_OPTIONS_RRQ, keyword);
+            // Extract and format the serial number from the response data
+            const ProductTime = data
+                .slice(8) // Skip the first 8 bytes (header)
+                .toString("ascii") // Convert buffer to string
+                .replace(`${keyword}=`, "") // Remove the keyword prefix
+                .replace(/\u0000/g, ""); // Remove null characters
+            return new Date(ProductTime);
+        }
+        catch (err) {
+            // Log the error for debugging
+            console.error("Error getting Product Time:", err);
+            // Re-throw the error for higher-level handling
+            throw err;
+        }
+    }
+    async getMacAddress() {
+        const keyword = "MAC";
+        try {
+            // Execute the command to get serial number
+            const data = await this._zkTcp.executeCmd(COMMANDS.CMD_OPTIONS_RRQ, keyword);
+            // Extract and format the serial number from the response data
+            const macAddr = data
+                .slice(8) // Skip the first 8 bytes (header)
+                .toString("ascii") // Convert buffer to string
+                .replace(`${keyword}=`, "") // Remove the keyword prefix
+                .replace(/\u0000/g, ""); // Remove null characters
+            return macAddr;
+        }
+        catch (err) {
+            // Log the error for debugging
+            console.error("Error getting MAC address:", err);
+            // Re-throw the error for higher-level handling
+            throw err;
+        }
+    }
+    async getNetworkParams() {
+        try {
+            const params = {
+                IPAddress: "",
+                NetMask: "",
+                GATEIPAddress: "",
+                TCPPort: "",
+            };
+            const keywords = Object.keys(params);
+            for await (const keyword of keywords) {
+                const data = await this._zkTcp.executeCmd(COMMANDS.CMD_OPTIONS_RRQ, keyword);
+                params[keyword] = data
+                    .slice(8)
+                    .toString("utf-8")
+                    .replace(`${keyword}=`, "") // Remove the keyword prefix
+                    .replace(/\u0000/g, "")
+                    .replace("=", "."); // Replace equal simbol to dot, due to sometimes there are parsing errors
+            }
+            return params;
+        }
+        catch (err) {
+            console.error("Error getting Network Params: ", err);
+            throw err;
+        }
+    }
+    async getSerialNumber() {
+        const keyword = "~SerialNumber";
+        let serialNumber = "";
+        let count = 10;
+        try {
+            // Execute the command to get serial number
+            /**
+             * @dev implemented a counter and a while loop because sometimes serial number parses wrong for some reason
+             * */
+            while (serialNumber.length !== 13 && count > 0) {
+                const data = await this._zkTcp.executeCmd(COMMANDS.CMD_OPTIONS_RRQ, keyword);
+                // Extract and format the serial number from the response data
+                const SN = data
+                    .slice(8) // Skip the first 8 bytes (header)
+                    .toString("utf-8") // Convert buffer to string
+                    .replace(`${keyword}=`, "") // Remove the keyword prefix
+                    .replace("=", "") // Remove sometines last number is a character equal to = or unknow character
+                    .replace(/\u0000/g, ""); // Remove null characters
+                count--;
+                serialNumber = SN;
+            }
+            return serialNumber;
+        }
+        catch (err) {
+            // Log the error for debugging
+            console.error("Error getting serial number:", err);
+            // Re-throw the error for higher-level handling
+            throw err;
+        }
+    }
+    /**
+     * get Zkteko Template version
+     * @returns number
+     */
+    async getDeviceVersion() {
+        const keyword = "~ZKFPVersion";
+        try {
+            // Execute the command to get device version
+            const data = await this._zkTcp.executeCmd(COMMANDS.CMD_OPTIONS_RRQ, keyword);
+            // Extract and format the device version from the response data
+            // Remove null characters
+            return data
+                .slice(8) // Skip the first 8 bytes (header)
+                .toString("ascii") // Convert buffer to ASCII string
+                .replace(`${keyword}=`, "") // Remove the keyword prefix
+                .replace(/\u0000/g, "");
+        }
+        catch (err) {
+            // Log the error for debugging
+            console.error("Error getting device version:", err);
+            // Re-throw the error for higher-level handling
+            throw err;
+        }
+    }
+    /**
+     * get Device/Model Name
+     * @returns
+     */
+    async getDeviceName() {
+        const keyword = "~DeviceName";
+        try {
+            let result;
+            let retry = true;
+            while (retry) {
+                // Execute the command to get the device name
+                const data = await this._zkTcp.executeCmd(COMMANDS.CMD_OPTIONS_RRQ, keyword);
+                // Extract and format the device name from the response data
+                result = data
+                    .slice(8) // Skip the first 8 bytes (header)
+                    .toString("ascii") // Convert buffer to ASCII string
+                    .replace(`${keyword}=`, "") // Remove the keyword prefix
+                    .replace(/\u0000/g, ""); // Remove null characters
+                retry = result.includes("=");
+            }
+            return result;
+        }
+        catch (err) {
+            // Log the error for debugging
+            console.error("Error getting device name:", err);
+            // Re-throw the error for higher-level handling
+            throw err;
+        }
+    }
+    async getPlatform() {
+        const keyword = "~Platform";
+        try {
+            let result;
+            let retry = true;
+            while (retry) {
+                // Execute the command to get the device name
+                const data = await this._zkTcp.executeCmd(COMMANDS.CMD_OPTIONS_RRQ, keyword);
+                // Extract and format the device name from the response data
+                result = data
+                    .slice(8) // Skip the first 8 bytes (header)
+                    .toString("ascii") // Convert buffer to ASCII string
+                    .replace(`${keyword}=`, "") // Remove the keyword prefix
+                    .replace(/\u0000/g, ""); // Remove null characters
+                retry = result.includes("=");
+            }
+            return result;
+        }
+        catch (err) {
+            // Log the error for debugging
+            console.error("Error getting platform information:", err);
+            // Re-throw the error for higher-level handling
+            throw err;
+        }
+    }
+    async getOS() {
+        const keyword = "~OS";
+        const data = await this._zkTcp.executeCmd(COMMANDS.CMD_OPTIONS_RRQ, keyword);
+        return data
+            .slice(8) // Skip the first 8 bytes (header)
+            .toString("ascii") // Convert buffer to ASCII string
+            .replace(`${keyword}=`, "") // Remove the keyword prefix
+            .replace(/\u0000/g, "");
+    }
+    async getWorkCode() {
+        const keyword = "WorkCode";
+        const data = await this._zkTcp.executeCmd(COMMANDS.CMD_OPTIONS_RRQ, keyword);
+        // Extract and format the WorkCode information from the response data
+        // Remove null characters
+        return data
+            .slice(8) // Skip the first 8 bytes (header)
+            .toString("ascii") // Convert buffer to ASCII string
+            .replace(`${keyword}=`, "") // Remove the keyword prefix
+            .replace(/\u0000/g, "");
+    }
+    /**
+     * get User ID max length
+     * @returns
+     */
+    async getPIN() {
+        const keyword = "~PIN2Width";
+        const data = await this._zkTcp.executeCmd(COMMANDS.CMD_OPTIONS_RRQ, keyword);
+        return data
+            .slice(8) // Skip the first 8 bytes (header)
+            .toString("ascii") // Convert buffer to ASCII string
+            .replace(`${keyword}=`, "") // Remove the keyword prefix
+            .replace(/\u0000/g, "");
+    }
+    async getFaceOn() {
+        const keyword = "FaceFunOn";
+        const data = await this._zkTcp.executeCmd(COMMANDS.CMD_OPTIONS_RRQ, keyword);
+        const status = data
+            .slice(8) // Skip the first 8 bytes (header)
+            .toString("ascii") // Convert buffer to ASCII string
+            .replace(`${keyword}=`, ""); // Remove the keyword prefix
+        // Determine and return the face function status
+        return status.includes("0") ? "No" : "Yes";
+    }
+    async getSSR() {
+        const keyword = "~SSR";
+        const data = await this._zkTcp.executeCmd(COMMANDS.CMD_OPTIONS_RRQ, keyword);
+        return data
+            .slice(8) // Skip the first 8 bytes (header)
+            .toString("ascii") // Convert buffer to ASCII string
+            .replace(`${keyword}=`, "");
+    }
+    async getFirmware() {
+        try {
+            // Execute the command to get firmware information
+            const data = await this._zkTcp.executeCmd(1100, "");
+            // Extract and return the firmware version from the response data
+            return data.slice(8).toString("ascii"); // Skip the first 8 bytes (header) and convert to ASCII string
+        }
+        catch (err) {
+            // Log the error for debugging
+            console.error("Error getting firmware version:", err);
+            // Re-throw the error to be handled by the caller
+            throw err;
+        }
+    }
+    async getTime() {
+        try {
+            // Execute the command to get the current time
+            const response = await this._zkTcp.executeCmd(COMMANDS.CMD_GET_TIME, "");
+            // Check if the response is valid
+            if (!response || response.length < 12) {
+                throw new Error("Invalid response received for time command");
+            }
+            // Extract and decode the time value from the response
+            const timeValue = response.readUInt32LE(8); // Read 4 bytes starting at offset 8
+            const time = timeParser.decode(timeValue); // Parse and return the decoded time
+            return time;
+        }
+        catch (err) {
+            // Log the error for debugging
+            console.error("Error getting time:", err);
+            // Re-throw the error for the caller to handle
+            throw err;
+        }
+    }
+    async setTime(tm) {
+        try {
+            // Validate the input time
+            if (!(tm instanceof Date) && typeof tm !== "number") {
+                throw new TypeError("Invalid time parameter. Must be a Date object or a timestamp.");
+            }
+            // Convert the input time to a Date object if it's not already
+            const date = tm instanceof Date ? tm : new Date(tm);
+            // Encode the time into the required format
+            const encodedTime = timeParser.encode(date);
+            // Create a buffer and write the encoded time
+            const commandString = Buffer.alloc(32);
+            commandString.writeUInt32LE(encodedTime, 0);
+            // Send the command to set the time
+            const time = await this._zkTcp.executeCmd(COMMANDS.CMD_SET_TIME, commandString);
+            return !!time;
+        }
+        catch (err) {
+            // Log the error for debugging
+            console.error("Error setting time:", err);
+            // Re-throw the error for the caller to handle
+            throw err;
+        }
+    }
+    async voiceTest() {
+        try {
+            // Define the command data for the voice test
+            const commandData = Buffer.from("\x00\x00", "binary");
+            await this._zkTcp.executeCmd(COMMANDS.CMD_TESTVOICE, commandData);
+            // Execute the command and return the result
+        }
+        catch (err) {
+            // Log the error for debugging purposes
+            console.error("Error executing voice test:", err);
+            // Re-throw the error to be handled by the caller
+            throw err;
+        }
+    }
+}
+
+class ZTCP {
+    /**
+     * @param_ip ip address of device
+     * @param_port port number of device
+     * @param_timeout connection timout
+     * @param_comm_key communication key of device (if the case)
+     * @return Zkteco TCP socket connection instance
+     */
+    ip;
+    port;
+    timeout;
+    sessionId = 0;
+    replyId = 0;
+    socket;
+    comm_key;
+    user_count = 0;
+    fp_count = 0;
+    pwd_count = 0;
+    oplog_count = 0;
+    attlog_count = 0;
+    fp_cap = 0;
+    user_cap = 0;
+    attlog_cap = 0;
+    fp_av = 0;
+    user_av = 0;
+    attlog_av = 0;
+    face_count = 0;
+    face_cap = 0;
+    userPacketSize = 72;
+    verbose = false;
+    packetNumber = 0;
+    replyData = Buffer.from([]);
+    _optionsService;
+    _transactionService;
+    _userService;
+    constructor(ip, port, timeout, comm_key, verbose) {
+        this.ip = ip;
+        this.port = port;
+        this.timeout = timeout ? timeout : 10000;
+        this.replyId = 0;
+        this.comm_key = comm_key;
+        this.verbose = verbose;
+        this._optionsService = new OptionsService(this);
+        this._userService = new UserService(this);
+        this._transactionService = new TransactionService(this);
+    }
+    createSocket(cbError, cbClose) {
+        return new Promise((resolve, reject) => {
+            this.socket = new Socket();
+            // Handle socket error
+            this.socket.once("error", (err) => {
+                this.socket = undefined; // Ensure socket reference is cleared
+                reject(err);
+                if (typeof cbError === "function")
+                    cbError(err);
+            });
+            // Handle successful connection
+            this.socket.once("connect", () => {
+                resolve(this.socket);
+            });
+            // Handle socket closure
+            this.socket.once("close", () => {
+                this.socket = undefined; // Ensure socket reference is cleared
+                if (typeof cbClose === "function")
+                    cbClose("tcp");
+            });
+            // Set socket timeout if provided
+            if (this.timeout) {
+                this.socket.setTimeout(this.timeout);
+            }
+            // Initiate connection
+            this.socket.connect(this.port, this.ip);
+        });
+    }
+    async connect() {
+        try {
+            let reply = await this.executeCmd(COMMANDS.CMD_CONNECT, "");
+            if (reply.readUInt16LE(0) === COMMANDS.CMD_ACK_OK) {
+                return true;
+            }
+            if (reply.readUInt16LE(0) === COMMANDS.CMD_ACK_UNAUTH) {
+                const hashedCommkey = authKey(this.comm_key, this.sessionId);
+                reply = await this.executeCmd(COMMANDS.CMD_AUTH, hashedCommkey);
+                if (reply.readUInt16LE(0) === COMMANDS.CMD_ACK_OK) {
+                    return true;
+                }
+                else {
+                    throw new Error("error de authenticacion");
+                }
+            }
+            else {
+                // No reply received; throw an error
+                throw new Error("NO_REPLY_ON_CMD_CONNECT");
+            }
+        }
+        catch (err) {
+            // Log the error for debugging, if necessary
+            console.error("Failed to connect:", err);
+            // Re-throw the error for handling by the caller
+            throw err;
+        }
+    }
+    async closeSocket() {
+        return new Promise((resolve, reject) => {
+            // If no socket is present, resolve immediately
+            if (!this.socket) {
+                return resolve(true);
+            }
+            // Clean up listeners to avoid potential memory leaks or duplicate handling
+            this.socket.removeAllListeners("data");
+            // Set a timeout to handle cases where socket.end might not resolve
+            const timer = setTimeout(() => {
+                this.socket?.destroy(); // Forcibly close the socket if not closed properly
+                resolve(true); // Resolve even if the socket was not closed properly
+            }, 2000);
+            // Close the socket and clear the timeout upon successful completion
+            this.socket.end(() => {
+                clearTimeout(timer);
+                resolve(true); // Resolve once the socket has ended
+            });
+            // Handle socket errors during closing
+            this.socket.once("error", (err) => {
+                clearTimeout(timer);
+                reject(err); // Reject the promise with the error
+            });
+        });
+    }
+    writeMessage(msg, connect, cb) {
+        return new Promise((resolve, reject) => {
+            // Check if the socket is initialized
+            if (!this.socket) {
+                return reject(new Error("Socket is not initialized"));
+            }
+            // Define a variable for the timeout reference
+            const timer = setTimeout(() => {
+                // Check if the socket is still valid before trying to remove the listener
+                cleanUp();
+                reject(new Error("TIMEOUT_ON_WRITING_MESSAGE")); // Reject the promise on timeout
+            }, connect ? 3000 : this.timeout);
+            // Handle incoming data
+            const onData = (data) => {
+                // Check if the socket is still valid before trying to remove the listener
+                cleanUp(); // Clear the timeout once data is received
+                resolve(cb(data)); // Resolve the promise with the received data
+            };
+            const cleanUp = () => {
+                if (timer)
+                    clearTimeout(timer);
+                if (this.socket) {
+                    this.socket.removeListener("data", onData); // Remove the data event listener
+                }
+            };
+            // Attach the data event listener
+            this.socket.on("data", onData);
+            // Attempt to write the message to the socket
+            this.socket.write(msg, undefined, (err) => {
+                if (err) {
+                    cleanUp();
+                    reject(err); // Reject the promise with the write error
+                }
+            });
+        });
+    }
+    async requestData(msg) {
+        try {
+            return await new Promise((resolve, reject) => {
+                let timer = null;
+                let replyBuffer = Buffer.from([]);
+                // Internal callback to handle data reception
+                const internalCallback = (data_1) => {
+                    if (this.socket) {
+                        this.socket.removeListener("data", handleOnData); // Clean up listener
+                    }
+                    if (timer)
+                        clearTimeout(timer); // Clear the timeout
+                    resolve(data_1); // Resolve the promise with the data
+                };
+                const onTimeOut = () => setTimeout(() => {
+                    if (this.socket) {
+                        this.socket.removeListener("data", handleOnData); // Clean up listener on timeout
+                    }
+                    reject(new Error("TIMEOUT_IN_RECEIVING_RESPONSE_AFTER_REQUESTING_DATA")); // Reject on timeout
+                }, this.timeout);
+                // Handle incoming data
+                const handleOnData = (data_3) => {
+                    replyBuffer = Buffer.concat([replyBuffer, data_3]); // Accumulate data
+                    // Check if the data is a valid TCP event
+                    if (checkNotEventTCP(data_3))
+                        return;
+                    // Decode the TCP header
+                    const header = decodeTCPHeader(replyBuffer.subarray(0, 16));
+                    if (this.verbose) {
+                        console.log("response command: ", header.commandId, COMMANDS[header.commandId], "replyid: ", header.replyId);
+                    }
+                    // Handle based on command ID
+                    if (header.commandId === COMMANDS.CMD_DATA) {
+                        // Set a timeout to handle delayed responses
+                        timer = setTimeout(() => {
+                            internalCallback(replyBuffer); // Resolve with accumulated buffer
+                        }, 1000);
+                    }
+                    else {
+                        // Set a timeout to handle errors
+                        timer = onTimeOut();
+                        // Extract packet length and handle accordingly
+                        const packetLength = data_3.readUIntLE(4, 2);
+                        if (packetLength > 8) {
+                            internalCallback(data_3); // Resolve immediately if sufficient data
+                        }
+                    }
+                };
+                // Ensure the socket is valid before attaching the listener
+                if (this.socket) {
+                    this.socket.on("data", handleOnData);
+                    // Write the message to the socket
+                    this.socket.write(msg, undefined, (err) => {
+                        if (err) {
+                            if (this.socket) {
+                                this.socket.removeListener("data", handleOnData); // Clean up listener on error
+                            }
+                            return reject(err); // Reject the promise with the error
+                        }
+                        // Set a timeout to handle cases where no response is received
+                        timer = onTimeOut();
+                    });
+                }
+                else {
+                    reject(new Error("SOCKET_NOT_INITIALIZED")); // Reject if socket is not initialized
+                }
+            });
+        }
+        catch (err_1) {
+            console.error("Promise Rejected:", err_1); // Log the rejection reason
+            throw err_1; // Re-throw the error to be handled by the caller
+        }
+    }
+    /**
+     *
+     * @param {*} command
+     * @param {*} data
+     *
+     *
+     * reject error when command fail and resolve data when success
+     */
+    async executeCmd(command, data) {
+        // Reset sessionId and replyId for connection commands
+        if (command === COMMANDS.CMD_CONNECT) {
+            this.sessionId = 0;
+            this.replyId = 0;
+        }
+        else {
+            this.replyId++;
+        }
+        const currentReply = this.replyId;
+        const buf = createTCPHeader(command, this.sessionId, this.replyId, data);
+        const callback = (responseData) => {
+            const packets = splitTcpPackets(responseData);
+            for (const packet of packets) {
+                const headers = decodeTCPHeader(packet);
+                if (this.verbose) {
+                    const JOIN_CMD = { ...COMMANDS, ...DISCOVERED_CMD };
+                    console.debug("request command:", COMMANDS[command], "\nresponse command: ", JOIN_CMD[headers.commandId], "replyid: ", headers.replyId);
+                }
+                if (+headers.replyId === currentReply + 1) {
+                    return packet;
+                }
+                continue;
+            }
+        };
+        return new Promise((Resolve, Reject) => {
+            // Write the message to the socket and wait for a response
+            this.writeMessage(buf, command === COMMANDS.CMD_CONNECT || command === COMMANDS.CMD_EXIT, callback)
+                .then((reply) => {
+                // Remove TCP header from the response
+                let rReply;
+                try {
+                    rReply = removeTcpHeader(reply);
+                }
+                catch (e) {
+                    console.log("reply", reply);
+                }
+                // Update sessionId for connection command responses
+                if (command === COMMANDS.CMD_CONNECT &&
+                    rReply &&
+                    rReply.length >= 6) {
+                    // Assuming sessionId is located at offset 4 and is 2 bytes long
+                    this.sessionId = rReply.readUInt16LE(4);
+                }
+                Resolve(rReply);
+            })
+                .catch((err) => {
+                // Log or handle the error if necessary
+                console.error("Error executing command:", err);
+                Reject(err); // Re-throw the error for handling by the caller
+            });
+        });
+    }
+    async sendChunkRequest(start, size) {
+        this.replyId++;
+        const reqData = Buffer.alloc(8);
+        reqData.writeUInt32LE(start, 0);
+        reqData.writeUInt32LE(size, 4);
+        const buf = createTCPHeader(COMMANDS.CMD_DATA_RDY, this.sessionId, this.replyId, reqData);
+        try {
+            const promise = new Promise((resolve, reject) => {
+                this.socket?.write(buf, undefined, (err) => {
+                    if (err) {
+                        console.error(`[TCP][SEND_CHUNK_REQUEST] Error sending chunk request: ${err.message}`);
+                        reject(err); // Reject the promise if there is an error
+                    }
+                    else {
+                        resolve(true); // Resolve the promise if the write operation succeeds
+                    }
+                });
+            });
+            await promise;
+        }
+        catch (err) {
+            // Handle or log the error as needed
+            console.error(`[TCP][SEND_CHUNK_REQUEST] Exception: ${err.message}`);
+            throw err; // Re-throw the error for handling by the caller
+        }
+    }
+    /**
+     *
+     * @param {Buffer} reqData - indicate the type of data that need to receive ( user or attLog)
+     * @param {Function} cb - callback is triggered when receiving packets
+     *
+     * readWithBuffer will reject error if it'wrong when starting request data
+     * readWithBuffer will return { data: replyData , err: Error } when receiving requested data
+     */
+    readWithBuffer(reqData, cb) {
+        return new Promise(async (resolve, reject) => {
+            this.replyId++;
+            const buf = createTCPHeader(COMMANDS.CMD_DATA_WRRQ, this.sessionId, this.replyId, reqData);
+            let reply;
+            try {
+                reply = await this.requestData(buf);
+            }
+            catch (err) {
+                reject(err);
+            }
+            const header = decodeTCPHeader(reply?.subarray(0, 16));
+            switch (header.commandId) {
+                case COMMANDS.CMD_DATA: {
+                    resolve({ data: reply.subarray(16), mode: 8 });
+                    break;
+                }
+                case COMMANDS.CMD_ACK_OK:
+                case COMMANDS.CMD_PREPARE_DATA: {
+                    // this case show that data is prepared => send command to get these data
+                    // reply variable includes information about the size of following data
+                    const recvData = reply.subarray(16);
+                    const size = recvData.readUIntLE(1, 4);
+                    // We need to split the data to many chunks to receive , because it's to large
+                    // After receiving all chunk data , we concat it to TotalBuffer variable , that 's the data we want
+                    const remain = size % Constants.MAX_CHUNK;
+                    const numberChunks = Math.round(size - remain) / Constants.MAX_CHUNK;
+                    this.packetNumber = numberChunks + (remain > 0 ? 1 : 0);
+                    //let replyData = Buffer.from([])
+                    let totalBuffer = Buffer.from([]);
+                    let realTotalBuffer = Buffer.from([]);
+                    let timer = setTimeout(() => {
+                        internalCallback(this.replyData, new Error("TIMEOUT WHEN RECEIVING PACKET"));
+                    }, this.timeout);
+                    const internalCallback = (replyData, err = null) => {
+                        this.socket && this.socket.removeAllListeners("data");
+                        timer && clearTimeout(timer);
+                        resolve({ data: replyData, err });
+                    };
+                    this.socket?.once("close", () => {
+                        internalCallback(this.replyData, new Error("Socket is disconnected unexpectedly"));
+                    });
+                    for (let i = 0; i <= numberChunks; i++) {
+                        const data = await new Promise((resolve2, reject2) => {
+                            try {
+                                this.sendChunkRequest(i * Constants.MAX_CHUNK, i === numberChunks ? remain : Constants.MAX_CHUNK);
+                                this.socket?.on("data", (reply) => {
+                                    clearTimeout(timer);
+                                    timer = setTimeout(() => {
+                                        internalCallback(this.replyData, new Error(`TIME OUT !! ${this.packetNumber} PACKETS REMAIN !`));
+                                    }, this.timeout);
+                                    if (this.verbose && reply.length >= 8) {
+                                        const headers = decodeTCPHeader(reply);
+                                        if (COMMANDS[headers.commandId]) {
+                                            switch (headers.commandId) {
+                                                case COMMANDS.CMD_ACK_OK:
+                                                case COMMANDS.CMD_DATA:
+                                                    this.verbose &&
+                                                        console.log("CMD received: ", COMMANDS[headers.commandId]);
+                                                    break;
+                                                case COMMANDS.CMD_PREPARE_DATA:
+                                                    this.verbose &&
+                                                        console.log("CMD received: ", COMMANDS[headers.commandId]);
+                                                    this.verbose &&
+                                                        console.log(`recieve chunk: prepare data size is ${headers.payloadSize}`);
+                                                    break;
+                                                default:
+                                                    break;
+                                            }
+                                        }
+                                    }
+                                    totalBuffer = Buffer.concat([totalBuffer, reply]);
+                                    const packetLength = totalBuffer.readUIntLE(4, 2);
+                                    if (totalBuffer.length >= 8 + packetLength) {
+                                        realTotalBuffer = Buffer.concat([
+                                            realTotalBuffer,
+                                            totalBuffer.subarray(16, 8 + packetLength),
+                                        ]);
+                                        totalBuffer = totalBuffer.subarray(8 + packetLength);
+                                        if ((this.packetNumber > 1 &&
+                                            realTotalBuffer.length === Constants.MAX_CHUNK + 8) ||
+                                            (this.packetNumber === 1 &&
+                                                realTotalBuffer.length === remain + 8)) {
+                                            this.packetNumber--;
+                                            cb && cb(realTotalBuffer.length, size);
+                                            resolve2(realTotalBuffer.subarray(8));
+                                            totalBuffer = Buffer.from([]);
+                                            realTotalBuffer = Buffer.from([]);
+                                        }
+                                    }
+                                });
+                            }
+                            catch (e) {
+                                reject2(e);
+                            }
+                        });
+                        this.replyData = Buffer.concat([
+                            this.replyData,
+                            data,
+                        ]);
+                        this.socket?.removeAllListeners("data");
+                        if (this.packetNumber <= 0) {
+                            resolve({ data: this.replyData });
+                        }
+                    }
+                    break;
+                }
+                default: {
+                    reject(new Error("ERROR_IN_UNHANDLE_CMD " + exportErrorMessage(header.commandId)));
+                }
+            }
+        });
+    }
+    /**
+     *
+     * @param {*} callbackInProcess
+     *  reject error when starting request data
+     *  return { data: records, err: Error } when receiving requested data
+     */
+    async freeData() {
+        try {
+            const resp = await this.executeCmd(COMMANDS.CMD_FREE_DATA, "");
+            return !!resp;
+        }
+        catch (err) {
+            console.error("Error freeing data:", err);
+            throw err; // Optionally, re-throw the error if you need to handle it upstream
+        }
+    }
+    async disableDevice() {
+        try {
+            const resp = await this.executeCmd(COMMANDS.CMD_DISABLEDEVICE, REQUEST_DATA.DISABLE_DEVICE);
+            return !!resp;
+        }
+        catch (err) {
+            console.error("Error disabling device:", err);
+            throw err; // Optionally, re-throw the error if you need to handle it upstream
+        }
+    }
+    async enableDevice() {
+        try {
+            const resp = await this.executeCmd(COMMANDS.CMD_ENABLEDEVICE, "");
+            return !!resp;
+        }
+        catch (err) {
+            console.error("Error enabling device:", err);
+            throw err; // Optionally, re-throw the error if you need to handle it upstream
+        }
+    }
+    async disconnect() {
+        try {
+            // Attempt to execute the disconnect command
+            await this.executeCmd(COMMANDS.CMD_EXIT, "");
+        }
+        catch (err) {
+            // Log any errors encountered during command execution
+            console.error("Error during disconnection:", err);
+            // Optionally, add more handling or recovery logic here
+        }
+        // Attempt to close the socket and return the result
+        try {
+            await this.closeSocket();
+        }
+        catch (err) {
+            // Log any errors encountered while closing the socket
+            console.error("Error during socket closure:", err);
+            // Optionally, rethrow or handle the error if necessary
+            throw err; // Re-throwing to propagate the error
+        }
+    }
+    async getInfo() {
+        try {
+            // Execute the command to retrieve free sizes from the device
+            const data = await this.executeCmd(COMMANDS.CMD_GET_FREE_SIZES, "");
+            // Parse the response data to extract and return relevant information
+            return {
+                userCounts: data.readUIntLE(24, 4), // Number of users
+                logCounts: data.readUIntLE(40, 4), // Number of logs
+                logCapacity: data.readUIntLE(72, 4), // Capacity of logs in bytes
+            };
+        }
+        catch (err) {
+            // Log the error for debugging purposes
+            console.error("Error getting device info:", err);
+            // Re-throw the error to allow upstream error handling
+            throw err;
+        }
+    }
+    async getSizes() {
+        try {
+            // Execute the command to retrieve free sizes from the device
+            const data = await this.executeCmd(COMMANDS.CMD_GET_FREE_SIZES, "");
+            // Parse the response data to extract and return relevant information
+            const buf = data.slice(8); // remove header
+            this.user_count = buf.readUIntLE(16, 4);
+            this.fp_count = buf.readUIntLE(24, 4);
+            this.pwd_count = buf.readUIntLE(52, 4);
+            this.oplog_count = buf.readUIntLE(40, 4);
+            this.attlog_count = buf.readUIntLE(32, 4);
+            this.fp_cap = buf.readUIntLE(56, 4);
+            this.user_cap = buf.readUIntLE(60, 4);
+            this.attlog_cap = buf.readUIntLE(64, 4);
+            this.fp_av = buf.readUIntLE(68, 4);
+            this.user_av = buf.readUIntLE(72, 4);
+            this.attlog_av = buf.readUIntLE(76, 4);
+            this.face_count = buf.readUIntLE(80, 4);
+            this.face_cap = buf.readUIntLE(88, 4);
+            return {
+                userCounts: this.user_count, // Number of users
+                logCounts: this.attlog_count, // Number of logs
+                fingerCount: this.fp_count,
+                adminCount: this.pwd_count,
+                opLogCount: this.oplog_count,
+                logCapacity: this.attlog_cap, // Capacity of logs in bytes
+                fingerCapacity: this.fp_cap,
+                userCapacity: this.user_cap,
+                attLogCapacity: this.attlog_cap,
+                fingerAvailable: this.fp_av,
+                userAvailable: this.user_av,
+                attLogAvailable: this.attlog_av,
+                faceCount: this.face_count,
+                faceCapacity: this.face_cap,
+            };
+        }
+        catch (err) {
+            // Log the error for debugging purposes
+            console.error("Error getting device info:", err);
+            // Re-throw the error to allow upstream error handling
+            throw err;
+        }
+    }
+    #listeners = new Map();
+    async getAttendanceSize() {
+        try {
+            // Execute command to get free sizes
+            const data = await this.executeCmd(COMMANDS.CMD_GET_FREE_SIZES, "");
+            // Parse and return the attendance size
+            return data.readUIntLE(40, 4); // Assuming data at offset 40 represents the attendance size
+        }
+        catch (err) {
+            // Log error details for debugging
+            console.error("Error getting attendance size:", err);
+            // Re-throw the error to be handled by the caller
+            throw err;
+        }
+    }
+    // Clears the attendance logs on the device
+    async clearAttendanceLog() {
+        return await this._transactionService.clearAttendanceLog();
+    }
+    /**
+     * Clears all data on the device
+     * @value 1 Attendance records
+     * @value 2 Fingerprint templates
+     * @value 3 None
+     * @value 4 Operation records
+     * @value 5 User information
+     * @default 0 Delete all
+     */
+    async clearData(value) {
+        try {
+            // Execute the command to clear all data
+            await this.disableDevice();
+            if (!value)
+                value = 3;
+            const buf = await this.executeCmd(COMMANDS.CMD_CLEAR_DATA, value.toString());
+            await this.refreshData();
+            await this.enableDevice();
+            return !!buf;
+        }
+        catch (err) {
+            // Log the error for debugging purposes
+            console.error("Error clearing data:", err);
+            // Re-throw the error to be handled by the caller
+            throw err;
+        }
+    }
+    async getRealTimeLogs(cb = (realTimeLog) => { }) {
+        this.replyId++; // Increment the reply ID for this request
+        try {
+            // Create a buffer with the command header to request real-time logs
+            const buf = createTCPHeader(COMMANDS.CMD_REG_EVENT, this.sessionId, this.replyId, Buffer.from([0x01, 0x00, 0x00, 0x00]));
+            // Send the request to the device
+            this.socket?.write(buf, undefined, (err) => {
+                if (err) {
+                    // Log and reject the promise if there is an error writing to the socket
+                    console.error("Error sending real-time logs request:", err);
+                    throw err;
+                }
+            });
+            // Ensure data listeners are added only once
+            if (this.socket?.listenerCount("data") === 0) {
+                console.log("entraaa");
+                this.socket.on("data", (data) => {
+                    // Check if the data is an event and not just a regular response
+                    if (checkNotEventTCP(data)) {
+                        // Process the data if it is of the expected length
+                        if (data.length > 16) {
+                            // Decode and pass the log to the callback
+                            cb(decodeRTEvent(data));
+                        }
+                    }
+                });
+            }
+        }
+        catch (err) {
+            // Handle errors and reject the promise
+            console.error("Error getting real-time logs:", err);
+            throw err;
+        }
+    }
+    /**
+     * Get all Finger objects
+     * @returns {Record<string, Finger[]>}
+     */
+    async getTemplates(callbackInProcess = () => { }) {
+        return await this._userService.getTemplates(callbackInProcess);
+    }
+    /**
+     * Return size
+     * @param packet
+     */
+    testTcpTop(packet) {
+        // Check if packet is too small
+        if (packet.length <= 8)
+            return 0;
+        // Extract header values using little-endian format
+        const headerValue1 = packet.readUInt16LE(0);
+        const headerValue2 = packet.readUInt16LE(2);
+        const size = packet.readUInt32LE(4);
+        // Check if magic numbers match
+        if (headerValue1 === Constants.MACHINE_PREPARE_DATA_1 &&
+            headerValue2 === Constants.MACHINE_PREPARE_DATA_2) {
+            return size;
+        }
+        return 0;
+    }
+    async refreshData() {
+        try {
+            const reply = await this.executeCmd(COMMANDS.CMD_REFRESHDATA, "");
+            return !!reply;
+        }
+        catch (err) {
+            console.error("Error getting user templates: ", err);
+            throw err;
+        }
+    }
+    async sendWithBuffer(buffer) {
+        const MAX_CHUNK = 1024;
+        const size = buffer.length;
+        await this.freeData();
+        const commandString = Buffer.alloc(4); // 'I' is 4 bytes
+        commandString.writeUInt32LE(size, 0);
+        try {
+            const cmdResponse = await this.executeCmd(COMMANDS.CMD_PREPARE_DATA, commandString);
+            // responds with 2000 = CMD_ACK_OK
+            if (!cmdResponse) {
+                throw new Error("Can't prepare data");
+            }
+        }
+        catch (e) {
+            console.error(e);
+        }
+        const remain = size % MAX_CHUNK;
+        const packets = Math.floor((size - remain) / MAX_CHUNK);
+        let start = 0;
+        try {
+            for (let i = 0; i < packets; i++) {
+                const resp = await this.sendChunk(buffer.slice(start, start + MAX_CHUNK));
+                if (resp) {
+                    start += MAX_CHUNK;
+                    if (i == packets - 1 && remain) {
+                        const lastPacket = await this.sendChunk(buffer.slice(start, start + remain));
+                        return lastPacket;
+                    }
+                }
+            }
+        }
+        catch (e) {
+            console.error(e);
+        }
+    }
+    async sendChunk(commandString) {
+        try {
+            return await new Promise((resolve, reject) => {
+                resolve(this.executeCmd(COMMANDS.CMD_DATA, commandString));
+            });
+        }
+        catch (e) {
+            throw new ZkError(e, COMMANDS.CMD_DATA, this.ip);
+        }
+    }
+    async readSocket(length, cb = null) {
+        let replyBufer = Buffer.from([]);
+        const totalPackets = 0;
+        return new Promise((resolve, reject) => {
+            let timer = setTimeout(() => {
+                internalCallback(replyBufer, new Error("TIMEOUT WHEN RECEIVING PACKET"));
+            }, this.timeout);
+            const internalCallback = (replyData, err = null) => {
+                this.socket && this.socket.removeListener("data", onDataEnroll);
+                timer && clearTimeout(timer);
+                resolve({ data: replyData, err: err });
+            };
+            function onDataEnroll(data) {
+                clearTimeout(timer);
+                timer = setTimeout(() => {
+                    internalCallback(replyBufer, new Error(`TIME OUT !! ${totalPackets} PACKETS REMAIN !`));
+                }, this.timeout);
+                replyBufer = Buffer.concat([replyBufer, data], replyBufer.length + data.length);
+                if (data.length == length) {
+                    internalCallback(data);
+                }
+            }
+            this.socket.once("close", () => {
+                internalCallback(replyBufer, new Error("Socket is disconnected unexpectedly"));
+            });
+            this.socket.on("data", onDataEnroll);
+        }).catch((err) => {
+            console.error("Promise Rejected:", err); // Log the rejection reason
+            throw err; // Re-throw the error to be handled by the caller
+        });
+    }
+    /**
+     * Register events
+     * @param {number} flags - Event flags
+     * @returns {Promise<void>}
+     * @throws {ZKErrorResponse} If registration fails
+     */
+    async regEvent(flags) {
+        try {
+            const commandString = Buffer.alloc(4); // 'I' format is 4 bytes
+            commandString.writeUInt32LE(flags, 0); // Little-endian unsigned int
+            const cmdResponse = await this.executeCmd(COMMANDS.CMD_REG_EVENT, commandString);
+            if (this.verbose)
+                console.log("regEvent: ", cmdResponse.readUInt16LE(0));
+        }
+        catch (e) {
+            throw new ZkError(e, COMMANDS.CMD_REG_EVENT, this.ip);
+        }
+    }
+    async cancelCapture() {
+        try {
+            const reply = await this.executeCmd(COMMANDS.CMD_CANCELCAPTURE, "");
+            return !!reply;
+        }
+        catch (e) {
+            throw new ZkError(e, COMMANDS.CMD_CANCELCAPTURE, this.ip);
+        }
+    }
+    async restartDevice() {
+        try {
+            await this.executeCmd(COMMANDS.CMD_RESTART, "");
+        }
+        catch (e) {
+            throw new ZkError(e, COMMANDS.CMD_RESTART, this.ip);
+        }
+    }
+}
+
+class ZUDP {
+    ip;
+    port;
+    timeout;
+    socket;
+    sessionId;
+    replyId;
+    inport;
+    comm_key;
+    constructor(ip, port, timeout, inport, comm_key = 0) {
+        this.ip = ip;
+        this.port = port;
+        this.timeout = timeout;
+        this.socket = null;
+        this.sessionId = null;
+        this.replyId = 0;
+        this.inport = inport;
+        this.comm_key = comm_key;
+    }
+    createSocket(cbError, cbClose) {
+        return new Promise((resolve, reject) => {
+            this.socket = dgram.createSocket('udp4');
+            this.socket.setMaxListeners(Infinity);
+            this.socket.once('error', (err) => {
+                this.socket = null;
+                reject(err);
+                if (cbError)
+                    cbError(err);
+            });
+            this.socket.once('close', () => {
+                this.socket = null;
+                if (cbClose)
+                    cbClose('udp');
+            });
+            this.socket.once('listening', () => {
+                resolve(this.socket);
+            });
+            try {
+                this.socket.bind(this.inport);
+            }
+            catch (err) {
+                this.socket = null;
+                reject(err);
+                if (cbError)
+                    cbError(err);
+            }
+        });
+    }
+    async connect() {
+        try {
+            let reply = await this.executeCmd(COMMANDS.CMD_CONNECT, '');
+            if (reply.readUInt16LE(0) === COMMANDS.CMD_ACK_OK) {
+                return true;
+            }
+            if (reply.readUInt16LE(0) === COMMANDS.CMD_ACK_UNAUTH) {
+                const hashedCommkey = authKey(this.comm_key, this.sessionId);
+                reply = await this.executeCmd(COMMANDS.CMD_AUTH, hashedCommkey);
+                if (reply.readUInt16LE(0) === COMMANDS.CMD_ACK_OK) {
+                    return true;
+                }
+                else {
+                    throw new Error('Authentication error');
+                }
+            }
+            else {
+                throw new Error('NO_REPLY_ON_CMD_CONNECT');
+            }
+        }
+        catch (err) {
+            console.error('Error in connect method:', err);
+            throw err;
+        }
+    }
+    async closeSocket() {
+        return new Promise((resolve, reject) => {
+            if (!this.socket) {
+                resolve(true);
+                return;
+            }
+            const timeout = 2000;
+            const timer = setTimeout(() => {
+                console.warn('Socket close timeout');
+                resolve(true);
+            }, timeout);
+            this.socket.removeAllListeners('message');
+            // @ts-ignore
+            this.socket.close((err) => {
+                clearTimeout(timer);
+                if (err) {
+                    console.error('Error closing socket:', err);
+                    reject(err);
+                }
+                else {
+                    resolve(true);
+                }
+                this.socket = null;
+            });
+        });
+    }
+    writeMessage(msg, connect) {
+        return new Promise((resolve, reject) => {
+            if (!this.socket) {
+                reject(new Error('Socket not initialized'));
+                return;
+            }
+            let sendTimeoutId;
+            const onMessage = (data) => {
+                clearTimeout(sendTimeoutId);
+                this.socket.removeListener('message', onMessage);
+                resolve(data);
+            };
+            this.socket.once('message', onMessage);
+            this.socket.send(msg, 0, msg.length, this.port, this.ip, (err) => {
+                if (err) {
+                    this.socket.removeListener('message', onMessage);
+                    reject(err);
+                    return;
+                }
+                if (this.timeout) {
+                    sendTimeoutId = setTimeout(() => {
+                        this.socket.removeListener('message', onMessage);
+                        reject(new Error('TIMEOUT_ON_WRITING_MESSAGE'));
+                    }, connect ? 2000 : this.timeout);
+                }
+            });
+        });
+    }
+    requestData(msg) {
+        return new Promise((resolve, reject) => {
+            if (!this.socket) {
+                reject(new Error('Socket not initialized'));
+                return;
+            }
+            let sendTimeoutId;
+            let responseTimeoutId;
+            const handleOnData = (data) => {
+                if (checkNotEventUDP(data))
+                    return;
+                clearTimeout(sendTimeoutId);
+                clearTimeout(responseTimeoutId);
+                this.socket.removeListener('message', handleOnData);
+                resolve(data);
+            };
+            const onReceiveTimeout = () => {
+                this.socket.removeListener('message', handleOnData);
+                reject(new Error('TIMEOUT_ON_RECEIVING_REQUEST_DATA'));
+            };
+            this.socket.on('message', handleOnData);
+            this.socket.send(msg, 0, msg.length, this.port, this.ip, (err) => {
+                if (err) {
+                    this.socket.removeListener('message', handleOnData);
+                    reject(err);
+                    return;
+                }
+                responseTimeoutId = setTimeout(onReceiveTimeout, this.timeout);
+            });
+            sendTimeoutId = setTimeout(() => {
+                this.socket.removeListener('message', handleOnData);
+                reject(new Error('TIMEOUT_IN_RECEIVING_RESPONSE_AFTER_REQUESTING_DATA'));
+            }, this.timeout);
+        });
+    }
+    async executeCmd(command, data) {
+        try {
+            if (command === COMMANDS.CMD_CONNECT) {
+                this.sessionId = 0;
+                this.replyId = 0;
+            }
+            else {
+                this.replyId++;
+            }
+            const buf = createUDPHeader(command, this.sessionId, this.replyId, data);
+            const reply = await this.writeMessage(buf, command === COMMANDS.CMD_CONNECT || command === COMMANDS.CMD_EXIT);
+            if (reply && reply.length > 0) {
+                if (command === COMMANDS.CMD_CONNECT) {
+                    this.sessionId = reply.readUInt16LE(4);
+                }
+            }
+            return reply;
+        }
+        catch (err) {
+            console.error(`Error executing command ${command}:`, err);
+            throw err;
+        }
+    }
+    async sendChunkRequest(start, size) {
+        this.replyId++;
+        const reqData = Buffer.alloc(8);
+        reqData.writeUInt32LE(start, 0);
+        reqData.writeUInt32LE(size, 4);
+        const buf = createUDPHeader(COMMANDS.CMD_DATA_RDY, this.sessionId, this.replyId, reqData);
+        try {
+            await new Promise((resolve, reject) => {
+                this.socket.send(buf, 0, buf.length, this.port, this.ip, (err) => {
+                    if (err) {
+                        log(`[UDP][SEND_CHUNK_REQUEST] Error sending chunk request: ${err.message}`);
+                        reject(err);
+                    }
+                    else {
+                        resolve();
+                    }
+                });
+            });
+        }
+        catch (error) {
+            log(`[UDP][SEND_CHUNK_REQUEST] Exception: ${error.message}`);
+            throw error;
+        }
+    }
+    async readWithBuffer(reqData, cb = null) {
+        this.replyId++;
+        const buf = createUDPHeader(COMMANDS.CMD_DATA_WRRQ, this.sessionId, this.replyId, reqData);
+        try {
+            const reply = await this.requestData(buf);
+            const header = decodeUDPHeader(reply.subarray(0, 8));
+            switch (header.commandId) {
+                case COMMANDS.CMD_DATA:
+                    return { data: reply.subarray(8), err: null };
+                case COMMANDS.CMD_ACK_OK:
+                case COMMANDS.CMD_PREPARE_DATA:
+                    return await this.handleChunkedData(reply, header.commandId, cb);
+                default:
+                    throw new Error('ERROR_IN_UNHANDLE_CMD ' + exportErrorMessage(header.commandId));
+            }
+        }
+        catch (err) {
+            return { data: null, err: err };
+        }
+    }
+    async handleChunkedData(reply, commandId, cb) {
+        return new Promise((resolve) => {
+            const recvData = reply.subarray(8);
+            const size = recvData.readUIntLE(1, 4);
+            let totalBuffer = Buffer.from([]);
+            const timeout = 3000;
+            let timer = setTimeout(() => {
+                this.socket.removeListener('message', handleOnData);
+                resolve({ data: null, err: new Error('TIMEOUT WHEN RECEIVING PACKET') });
+            }, timeout);
+            const internalCallback = (replyData, err = null) => {
+                this.socket.removeListener('message', handleOnData);
+                clearTimeout(timer);
+                resolve({ data: err ? null : replyData, err });
+            };
+            const handleOnData = (reply) => {
+                if (checkNotEventUDP(reply))
+                    return;
+                clearTimeout(timer);
+                timer = setTimeout(() => {
+                    internalCallback(totalBuffer, new Error(`TIMEOUT !! ${(size - totalBuffer.length) / size} % REMAIN !`));
+                }, timeout);
+                const header = decodeUDPHeader(reply);
+                switch (header.commandId) {
+                    case COMMANDS.CMD_PREPARE_DATA:
+                        break;
+                    case COMMANDS.CMD_DATA:
+                        totalBuffer = Buffer.concat([totalBuffer, reply.subarray(8)]);
+                        cb && cb(totalBuffer.length, size);
+                        break;
+                    case COMMANDS.CMD_ACK_OK:
+                        if (totalBuffer.length === size) {
+                            internalCallback(totalBuffer);
+                        }
+                        break;
+                    default:
+                        internalCallback(Buffer.from([]), new Error('ERROR_IN_UNHANDLE_CMD ' + exportErrorMessage(header.commandId)));
+                }
+            };
+            this.socket.on('message', handleOnData);
+            const chunkCount = Math.ceil(size / Constants.MAX_CHUNK);
+            for (let i = 0; i < chunkCount; i++) {
+                const start = i * Constants.MAX_CHUNK;
+                const chunkSize = (i === chunkCount - 1) ? size % Constants.MAX_CHUNK : Constants.MAX_CHUNK;
+                this.sendChunkRequest(start, chunkSize).catch(err => {
+                    internalCallback(Buffer.from([]), err);
+                });
+            }
+        });
+    }
+    async getUsers() {
+        try {
+            if (this.socket) {
+                await this.freeData();
+            }
+            const data = await this.readWithBuffer(REQUEST_DATA.GET_USERS);
+            if (this.socket) {
+                await this.freeData();
+            }
+            const USER_PACKET_SIZE = 28;
+            let userData = data.data?.subarray(4) || Buffer.from([]);
+            const users = [];
+            while (userData.length >= USER_PACKET_SIZE) {
+                const user = decodeUserData28(userData.subarray(0, USER_PACKET_SIZE));
+                users.push(user);
+                userData = userData.subarray(USER_PACKET_SIZE);
+            }
+            return { data: users };
+        }
+        catch (err) {
+            throw new Error(err.message);
+        }
+    }
+    async getAttendances(callbackInProcess) {
+        try {
+            if (this.socket) {
+                await this.freeData();
+            }
+            const data = await this.readWithBuffer(REQUEST_DATA.GET_ATTENDANCE_LOGS);
+            if (this.socket) {
+                await this.freeData();
+            }
+            const RECORD_PACKET_SIZE = 16;
+            let recordData = data.data?.subarray(4) || Buffer.from([]);
+            const records = [];
+            while (recordData.length >= RECORD_PACKET_SIZE) {
+                const record = decodeRecordData16(recordData.subarray(0, RECORD_PACKET_SIZE));
+                records.push({ ...record, ip: this.ip });
+                recordData = recordData.subarray(RECORD_PACKET_SIZE);
+            }
+            return { data: records, err: data.err };
+        }
+        catch (err) {
+            return { data: [], err: err };
+        }
+    }
+    async freeData() {
+        try {
+            const resp = await this.executeCmd(COMMANDS.CMD_FREE_DATA, Buffer.alloc(0));
+            return !!resp;
+        }
+        catch (err) {
+            console.error('Error freeing data:', err);
+            throw err;
+        }
+    }
+    async getInfo() {
+        try {
+            const data = await this.executeCmd(COMMANDS.CMD_GET_FREE_SIZES, Buffer.alloc(0));
+            return {
+                userCounts: data.readUIntLE(24, 4),
+                logCounts: data.readUIntLE(40, 4),
+                logCapacity: data.readUIntLE(72, 4)
+            };
+        }
+        catch (err) {
+            console.error('Error retrieving info:', err);
+            throw err;
+        }
+    }
+    async getTime() {
+        try {
+            const response = await this.executeCmd(COMMANDS.CMD_GET_TIME, Buffer.alloc(0));
+            const timeValue = response.readUInt32LE(8);
+            return timeParser.decode(timeValue);
+        }
+        catch (err) {
+            console.error('Error retrieving time:', err);
+            throw err;
+        }
+    }
+    async setTime(tm) {
+        try {
+            const commandBuffer = Buffer.alloc(32);
+            commandBuffer.writeUInt32LE(timeParser.encode(new Date(tm)), 0);
+            await this.executeCmd(COMMANDS.CMD_SET_TIME, commandBuffer);
+            return true;
+        }
+        catch (err) {
+            console.error('Error setting time:', err);
+            throw err;
+        }
+    }
+    async clearAttendanceLog() {
+        try {
+            return !!await this.executeCmd(COMMANDS.CMD_CLEAR_ATTLOG, Buffer.alloc(0));
+        }
+        catch (err) {
+            console.error('Error clearing attendance log:', err);
+            throw err;
+        }
+    }
+    async clearData() {
+        try {
+            return !!await this.executeCmd(COMMANDS.CMD_CLEAR_DATA, Buffer.alloc(0));
+        }
+        catch (err) {
+            console.error('Error clearing data:', err);
+            throw err;
+        }
+    }
+    async disableDevice() {
+        try {
+            const resp = await this.executeCmd(COMMANDS.CMD_DISABLEDEVICE, REQUEST_DATA.DISABLE_DEVICE);
+            return !!resp;
+        }
+        catch (err) {
+            console.error('Error disabling device:', err);
+            throw err;
+        }
+    }
+    async enableDevice() {
+        try {
+            const resp = await this.executeCmd(COMMANDS.CMD_ENABLEDEVICE, Buffer.alloc(0));
+            return !!resp;
+        }
+        catch (err) {
+            console.error('Error enabling device:', err);
+            throw err;
+        }
+    }
+    async disconnect() {
+        try {
+            await this.executeCmd(COMMANDS.CMD_EXIT, Buffer.alloc(0));
+        }
+        catch (err) {
+            console.error('Error executing disconnect command:', err);
+        }
+        try {
+            await this.closeSocket();
+        }
+        catch (err) {
+            console.error('Error closing the socket:', err);
+        }
+    }
+    async getRealTimeLogs(cb = () => { }) {
+        this.replyId++;
+        const buf = createUDPHeader(COMMANDS.CMD_REG_EVENT, this.sessionId, this.replyId, REQUEST_DATA.GET_REAL_TIME_EVENT);
+        try {
+            this.socket.send(buf, 0, buf.length, this.port, this.ip, (err) => {
+                if (err) {
+                    console.error('Error sending UDP message:', err);
+                    return;
+                }
+                console.log('UDP message sent successfully');
+            });
+        }
+        catch (err) {
+            console.error('Error during send operation:', err);
+            return;
+        }
+        const handleMessage = (data) => {
+            if (!checkNotEventUDP(data))
+                return;
+            if (data.length === 18) {
+                cb(decodeRecordRealTimeLog18(data));
+            }
+        };
+        if (this.socket.listenerCount('message') === 0) {
+            this.socket.on('message', handleMessage);
+        }
+        else {
+            console.warn('Multiple message listeners detected. Ensure only one listener is attached.');
+        }
+    }
+}
+
 class Zklib {
     set connectionType(value) {
         this._connectionType = value;
@@ -29,8 +3501,8 @@ class Zklib {
     constructor(ip, port = 4370, timeout = 5000, inport = 10000, comm_key = 0, verbose = false) {
         this.ip = ip;
         this.comm_key = comm_key;
-        this.ztcp = new ztcp_1.ZTCP(ip, port, timeout, comm_key, verbose);
-        this.zudp = new zudp_1.ZUDP(ip, port, timeout, inport);
+        this.ztcp = new ZTCP(ip, port, timeout, comm_key, verbose);
+        this.zudp = new ZUDP(ip, port, timeout, inport);
     }
     async functionWrapper(tcpCallback, udpCallback, command) {
         try {
@@ -40,21 +3512,21 @@ class Zklib {
                         return await tcpCallback();
                     }
                     else {
-                        throw new handler_1.ZkError(new Error("TCP socket isn't connected!"), `[TCP] ${command}`, this.ip);
+                        throw new ZkError(new Error("TCP socket isn't connected!"), `[TCP] ${command}`, this.ip);
                     }
                 case "udp":
                     if (this.zudp && this.zudp.socket) {
                         return await udpCallback();
                     }
                     else {
-                        throw new handler_1.ZkError(new Error("UDP socket isn't connected!"), `[UDP] ${command}`, this.ip);
+                        throw new ZkError(new Error("UDP socket isn't connected!"), `[UDP] ${command}`, this.ip);
                     }
                 default:
-                    throw new handler_1.ZkError(new Error("Unsupported connection type or socket isn't connected!"), "", this.ip);
+                    throw new ZkError(new Error("Unsupported connection type or socket isn't connected!"), "", this.ip);
             }
         }
         catch (err) {
-            throw new handler_1.ZkError(err, `[${this._connectionType?.toUpperCase()}] ${command}`, this.ip);
+            throw new ZkError(err, `[${this._connectionType?.toUpperCase()}] ${command}`, this.ip);
         }
     }
     async createSocket(cbErr, cbClose) {
@@ -67,7 +3539,7 @@ class Zklib {
                     return true;
                 }
                 catch (err) {
-                    throw new handler_1.ZkError(err, "TCP CONNECT", this.ip);
+                    throw new ZkError(err, "TCP CONNECT", this.ip);
                 }
             }
             else {
@@ -79,7 +3551,7 @@ class Zklib {
                     return true;
                 }
                 catch (err) {
-                    throw new handler_1.ZkError(err, "TCP CONNECT", this.ip);
+                    throw new ZkError(err, "TCP CONNECT", this.ip);
                 }
             }
         }
@@ -91,8 +3563,8 @@ class Zklib {
             catch (disconnectErr) {
                 console.error("Error disconnecting TCP:", disconnectErr);
             }
-            if (err.code !== handler_1.ERROR_TYPES.ECONNREFUSED) {
-                throw new handler_1.ZkError(err, "TCP CONNECT", this.ip);
+            if (err.code !== ERROR_TYPES.ECONNREFUSED) {
+                throw new ZkError(err, "TCP CONNECT", this.ip);
             }
             try {
                 if (!this.zudp.socket) {
@@ -112,7 +3584,7 @@ class Zklib {
                     catch (disconnectErr) {
                         console.error("Error disconnecting UDP:", disconnectErr);
                     }
-                    throw new handler_1.ZkError(err, "UDP CONNECT", this.ip);
+                    throw new ZkError(err, "UDP CONNECT", this.ip);
                 }
                 this._connectionType = "udp";
                 return true;
@@ -337,4 +3809,5 @@ class Zklib {
         }, "NETWORK_PARAMS");
     }
 }
-exports.default = Zklib;
+
+export { Zklib as default };