zklib-ts 1.0.6 → 1.0.8

package/dist/index.cjs.js

@@ -43,7 +43,7 @@ var COMMANDS;
     COMMANDS[COMMANDS["CMD_ATTLOG_RRQ"] = 13] = "CMD_ATTLOG_RRQ";
     /** [0x4E, 0x04] Request to begin session using commkey. */
     COMMANDS[COMMANDS["CMD_AUTH"] = 1102] = "CMD_AUTH";
-    /** Disable normal authentication of users. */
+    /** [0x3e, 0x00] Disable normal authentication of users. */
     COMMANDS[COMMANDS["CMD_CANCELCAPTURE"] = 62] = "CMD_CANCELCAPTURE";
     /** Capture fingerprint picture. */
     COMMANDS[COMMANDS["CMD_CAPTUREFINGER"] = 1009] = "CMD_CAPTUREFINGER";
@@ -140,9 +140,9 @@ var COMMANDS;
     COMMANDS[COMMANDS["CMD_SMS_RRQ"] = 71] = "CMD_SMS_RRQ";
     /** Upload short message. */
     COMMANDS[COMMANDS["CMD_SMS_WRQ"] = 70] = "CMD_SMS_WRQ";
-    /** Start enroll procedure. */
+    /** [0x3d, 0x00] Start enroll procedure. */
     COMMANDS[COMMANDS["CMD_STARTENROLL"] = 61] = "CMD_STARTENROLL";
-    /** Set the machine to authentication state. */
+    /** [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";
@@ -186,29 +186,36 @@ var COMMANDS;
     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. */
-    COMMANDS[COMMANDS["EF_ALARM"] = 512] = "EF_ALARM";
+    RTEvent[RTEvent["EF_ALARM"] = 512] = "EF_ALARM";
     /** Attendance entry. */
-    COMMANDS[COMMANDS["EF_ATTLOG"] = 1] = "EF_ATTLOG";
+    RTEvent[RTEvent["EF_ATTLOG"] = 1] = "EF_ATTLOG";
     /** Pressed keyboard key. */
-    COMMANDS[COMMANDS["EF_BUTTON"] = 16] = "EF_BUTTON";
+    RTEvent[RTEvent["EF_BUTTON"] = 16] = "EF_BUTTON";
     /** Upload user data. */
-    COMMANDS[COMMANDS["EF_ENROLLFINGER"] = 8] = "EF_ENROLLFINGER";
+    RTEvent[RTEvent["EF_ENROLLFINGER"] = 8] = "EF_ENROLLFINGER";
     /** Enrolled user. */
-    COMMANDS[COMMANDS["EF_ENROLLUSER"] = 4] = "EF_ENROLLUSER";
+    RTEvent[RTEvent["EF_ENROLLUSER"] = 4] = "EF_ENROLLUSER";
     /** Pressed finger. */
-    COMMANDS[COMMANDS["EF_FINGER"] = 2] = "EF_FINGER";
+    RTEvent[RTEvent["EF_FINGER"] = 2] = "EF_FINGER";
     /** Fingerprint score in enroll procedure. */
-    COMMANDS[COMMANDS["EF_FPFTR"] = 256] = "EF_FPFTR";
+    RTEvent[RTEvent["EF_FPFTR"] = 256] = "EF_FPFTR";
     /** Restore access control to default. */
-    COMMANDS[COMMANDS["EF_UNLOCK"] = 32] = "EF_UNLOCK";
+    RTEvent[RTEvent["EF_UNLOCK"] = 32] = "EF_UNLOCK";
     /** Registered user placed finger. */
-    COMMANDS[COMMANDS["EF_VERIFY"] = 128] = "EF_VERIFY";
-})(COMMANDS || (COMMANDS = {}));
+    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) {
@@ -227,33 +234,57 @@ const REQUEST_DATA = {
 };
 
 /**
- *
- * @param {number} time
+ * Error types for device communication
  */
-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);
-};
+const ERROR_TYPES = {
+    ECONNRESET: 'ECONNRESET',
+    ECONNREFUSED: 'ECONNREFUSED'};
 /**
- *
- * @param {Date} date
+ * Custom error class for device communication errors
  */
-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 };
+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();
@@ -295,7 +326,7 @@ class User {
      * @param user_id Alternate user ID (default: "")
      * @param card Card number (default: 0)
      */
-    constructor(uid, name, privilege, password = "", group_id = "", user_id = "", card = 0) {
+    constructor(uid, name, privilege, password = '', group_id = '', user_id = '', card = 0) {
         this.uid = uid;
         this.name = name;
         this.privilege = privilege;
@@ -365,6 +396,9 @@ class User {
     }
 }
 
+/**
+ * Represents an Attendance Records
+ */
 class Attendance {
     /** Internal serial number for the user */
     sn;
@@ -393,7 +427,7 @@ const parseHexToTime = (hex) => {
         date: hex.readUIntLE(2, 1),
         hour: hex.readUIntLE(3, 1),
         minute: hex.readUIntLE(4, 1),
-        second: hex.readUIntLE(5, 1)
+        second: hex.readUIntLE(5, 1),
     };
     return new Date(2000 + time.year, time.month - 1, time.date, time.hour, time.minute, time.second);
 };
@@ -427,7 +461,9 @@ const createUDPHeader = (command, sessionId, replyId, data) => {
 };
 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]);
+    const prefixBuf = Buffer.from([
+        0x50, 0x50, 0x82, 0x7d, 0x13, 0x00, 0x00, 0x00,
+    ]);
     prefixBuf.writeUInt16LE(buf.length, 4);
     return Buffer.concat([prefixBuf, buf]);
 };
@@ -447,7 +483,7 @@ const parseTimeToDate = (time) => {
     time = (time - minute) / 60;
     const hour = time % 24;
     time = (time - hour) / 24;
-    const day = time % 31 + 1;
+    const day = (time % 31) + 1;
     time = (time - (day - 1)) / 31;
     const month = time % 12;
     time = (time - month) / 12;
@@ -460,38 +496,34 @@ const decodeUserData28 = (userData) => {
         privilege: userData.readUIntLE(2, 1),
         name: userData
             .slice(8, 8 + 8)
-            .toString('ascii')
-            .split('\0')
-            .shift() || '',
+            .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
+    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
+        .toString("ascii")
+        .split("\0")
+        .shift() || "", userData.readUIntLE(39, 1), userData
         .slice(48, 48 + 9)
-        .toString('ascii')
-        .split('\0')
-        .shift() || '', userData.readUIntLE(35, 4));
+        .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));
+        .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))
+        record_time: parseTimeToDate(recordData.readUInt32LE(4)),
     };
 };
 const decodeRecordRealTimeLog18 = (recordData) => {
@@ -499,22 +531,12 @@ const decodeRecordRealTimeLog18 = (recordData) => {
     const record_time = parseHexToTime(recordData.subarray(12, 18));
     return { user_id, record_time };
 };
-const decodeRecordRealTimeLog52 = (recordData) => {
-    const payload = removeTcpHeader(recordData);
-    const recvData = payload.subarray(8);
-    const user_id = recvData.slice(0, 9)
-        .toString('ascii')
-        .split('\0')
-        .shift() || '';
-    const record_time = parseHexToTime(recvData.subarray(26, 26 + 6));
-    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)
+        replyId: header.readUIntLE(6, 2),
     };
 };
 const decodeTCPHeader = (header) => {
@@ -525,7 +547,7 @@ const decodeTCPHeader = (header) => {
         checkSum: recvData.readUIntLE(2, 2),
         sessionId: recvData.readUIntLE(4, 2),
         replyId: recvData.readUIntLE(6, 2),
-        payloadSize
+        payloadSize,
     };
 };
 const exportErrorMessage = (commandValue) => {
@@ -535,17 +557,18 @@ const exportErrorMessage = (commandValue) => {
             return key.toString();
         }
     }
-    return 'AN UNKNOWN ERROR';
+    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 event === COMMANDS.EF_ATTLOG && commandId === COMMANDS.CMD_REG_EVENT;
+        return isRTEvent(event) && commandId === COMMANDS.CMD_REG_EVENT;
     }
     catch (err) {
-        log(`[228] : ${err.toString()} ,${data.toString('hex')} `);
+        log(`[228] : ${err.toString()} ,${data.toString("hex")} `);
         return false;
     }
 };
@@ -553,6 +576,42 @@ 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++) {
@@ -565,30 +624,30 @@ const makeKey = (key, sessionId) => {
     }
     k += sessionId;
     let hex = k.toString(16).padStart(8, "0");
-    let response = new Uint8Array(4);
+    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);
+    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);
-    let swp = finalKey >>> 16;
+    const swp = finalKey >>> 16;
     finalKey = (finalKey << 16) | swp;
     return finalKey >>> 0;
 };
 const authKey = (comKey, sessionId) => {
-    let k = makeKey(comKey, sessionId) >>> 0;
-    let rand = Math.floor(Math.random() * 256);
+    const k = makeKey(comKey, sessionId) >>> 0;
+    const rand = Math.floor(Math.random() * 256);
     let hex = k.toString(16).padStart(8, "0");
-    let response = new Uint8Array(4);
+    const response = new Uint8Array(4);
     let index = 3;
     while (index >= 0) {
         response[index] = parseInt(hex.substring(0, 2), 16);
@@ -601,59 +660,17 @@ const authKey = (comKey, sessionId) => {
     response[3] ^= rand;
     return Array.from(response);
 };
-
-/**
- * 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
-        };
-    }
-}
+/** 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
@@ -661,6 +678,7 @@ class ZkError {
 class Finger {
     uid;
     fid;
+    /** Flag indicating 0 = invalid | 1 = valid | 3 = duress. if is not initilizaed, default is 1 = valid */
     valid;
     template;
     size;
@@ -672,10 +690,10 @@ class Finger {
      * @param valid Flag indicating 0 = invalid | 1 = valid | 3 = duress
      * @param template Fingerprint template data buffer
      */
-    constructor(uid, fid, valid, template) {
+    constructor(uid, fid, template, valid) {
         this.uid = Number(uid);
         this.fid = Number(fid);
-        this.valid = Number(valid);
+        this.valid = valid ? Number(valid) : 1;
         this.template = template;
         this.size = template.length;
         // Create mark showing first and last 8 bytes as hex
@@ -756,75 +774,75 @@ class UserService {
             if (this._zkTcp.socket) {
                 await this._zkTcp.freeData();
             }
-            // Request user data
-            const data = await this._zkTcp.readWithBuffer(REQUEST_DATA.GET_USERS);
+            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) {
+            if (this._zkTcp.socket && users) {
+                await this._zkTcp.enableDevice();
                 await this._zkTcp.freeData();
             }
-            // Constants for user data processing
-            const USER_PACKET_SIZE = 72;
-            // Ensure data.data is a valid buffer
-            if (!data.data || !(data.data instanceof Buffer)) {
-                throw new Error('Invalid data received');
-            }
-            let userData = data.data.subarray(4); // Skip the first 4 bytes (headers)
-            const users = [];
-            // 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
-            }
             // Return the list of users
             return { data: users };
         }
         catch (err) {
             // Log the error for debugging
-            console.error('Error getting users:', err);
+            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) {
-        let user;
-        try {
-            user = await this.getUserByUserId(user_id);
-        }
-        catch (err) {
-            if (err.message.includes("user_id not exists")) {
-                user.uid = Math.max(...Array.from(this._users.values()).map(usr => usr.uid)) + 1;
-                this._users.set(user_id, user);
-            }
-        }
         try {
             // Validate input parameters
             if (user_id.length > 9 ||
                 name.length > 24 ||
                 password.length > 8 ||
-                typeof role !== 'number' ||
+                typeof role !== "number" ||
                 cardno.toString().length > 10) {
-                throw new Error('Invalid input parameters');
+                throw new Error("Invalid input parameters");
             }
             // Allocate and initialize the buffer
             const commandBuffer = Buffer.alloc(72);
             // Fill the buffer with user data
-            commandBuffer.writeUInt16LE(user.uid, 0);
+            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.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
+            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);
+            console.error("Error setting user:", err);
             // Re-throw error for upstream handling
             throw err;
         }
@@ -842,22 +860,24 @@ class UserService {
         }
         catch (err) {
             // Log error details for debugging
-            console.error('Error deleting user:', err);
+            console.error("Error deleting user:", err);
             // Re-throw error for upstream handling
             throw err;
         }
     }
-    async getTemplates(callbackInProcess = () => { }) {
-        let templates = [];
+    async getTemplates(cb) {
+        const templates = [];
         try {
+            await this._zkTcp.disableDevice();
             if (this._zkTcp.socket) {
                 await this._zkTcp.freeData();
             }
-            await this._zkTcp.getSizes();
+            if (!this._zkTcp.fp_count) {
+                await this._zkTcp.getSizes();
+            }
             if (this._zkTcp.fp_count == 0)
                 return { data: [] };
-            await this._zkTcp.disableDevice();
-            const resp = await this._zkTcp.readWithBuffer(REQUEST_DATA.GET_TEMPLATES);
+            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) {
@@ -868,15 +888,17 @@ class UserService {
                 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, valid, tplBytes));
+                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);
-            return { data: templates };
+            throw err;
         }
         finally {
             await this._zkTcp.freeData();
@@ -885,9 +907,9 @@ class UserService {
     }
     async DownloadFp(user_id, fid) {
         try {
-            const user = await this.getUserByUserId(user_id);
+            const user = (await this.getUserByUserId(String(user_id)));
             if (0 > fid || fid > 9)
-                throw new Error('fid must be between 0 and 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
@@ -897,30 +919,30 @@ class UserService {
             const packet = createTCPHeader(COMMANDS.CMD_USERTEMP_RRQ, this._zkTcp.sessionId, this._zkTcp.replyId, data);
             let fingerSize = 0;
             let fingerTemplate = Buffer.from([]);
-            return await new Promise((resolve, reject) => {
+            const template = await new Promise((resolve, reject) => {
                 let timeout;
                 const cleanup = () => {
                     if (this._zkTcp.socket) {
-                        this._zkTcp.socket.removeListener('data', receiveData);
+                        this._zkTcp.socket.removeListener("data", receiveData);
                     }
                     if (timeout)
                         clearTimeout(timeout);
                 };
                 let timer = () => setTimeout(() => {
                     cleanup();
-                    reject(new Error('Time Out, Could not retrieve data'));
+                    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)
+                        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?');
+                                throw new Error("Could not retrieve data. maybe finger id not exists?");
                             case COMMANDS.CMD_PREPARE_DATA:
                                 fingerSize = data.readUIntLE(16, 2);
                                 break;
@@ -928,7 +950,10 @@ class UserService {
                                 // 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)]);
+                                fingerTemplate = Buffer.concat([
+                                    fingerTemplate,
+                                    data.subarray(16, fingerSize + 10),
+                                ]);
                                 // @ts-ignore
                                 resolve(fingerTemplate);
                                 break;
@@ -955,8 +980,8 @@ class UserService {
                     }
                 };
                 if (this._zkTcp.socket) {
-                    this._zkTcp.socket.on('data', receiveData);
-                    this._zkTcp.socket.write(packet, (err) => {
+                    this._zkTcp.socket.on("data", receiveData);
+                    this._zkTcp.socket.write(packet, undefined, (err) => {
                         if (err) {
                             cleanup();
                             reject(err);
@@ -964,15 +989,16 @@ class UserService {
                     });
                 }
                 else {
-                    reject(new Error('Socket not initialized'));
+                    reject(new Error("Socket not initialized"));
                 }
             });
+            return new Finger(user.uid, fid, template);
         }
         catch (err) {
             throw err;
         }
         finally {
-            await this._zkTcp.refreshData();
+            await this._zkTcp.freeData();
         }
     }
     /**
@@ -1014,15 +1040,15 @@ class UserService {
             head.writeUInt32LE(table.length, 4);
             head.writeUInt32LE(fpack.length, 8);
             const packet = Buffer.concat([head, upack, table, fpack]);
-            const bufferResponse = await this._zkTcp.sendWithBuffer(packet);
+            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);
-            const cmdResponse = await this._zkTcp.executeCmd(command, commandString);
+            await this._zkTcp.executeCmd(command, commandString);
             if (this._zkTcp.verbose)
-                console.log("finally bulk save user templates: \n", cmdResponse.readUInt16LE(0));
+                console.log("finally bulk save user templates: \n", "templates saved successfully");
         }
         catch (error) {
             throw error;
@@ -1034,9 +1060,7 @@ class UserService {
     }
     async deleteFinger(user_id, fid) {
         try {
-            if (!this._users.has(user_id))
-                throw new Error("user_id not exists");
-            const user = await this.getUserByUserId(user_id);
+            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);
@@ -1051,101 +1075,75 @@ class UserService {
         }
     }
     async enrollInfo(user_id, tempId) {
-        let done = false;
-        try {
-            const userBuf = Buffer.alloc(24);
-            userBuf.write(user_id, 0, 24, 'ascii');
-            let commandString = Buffer.concat([
-                userBuf,
-                Buffer.from([tempId, 1])
-            ]);
-            const sendAckOk = async () => {
-                try {
-                    const buf = createTCPHeader(COMMANDS.CMD_ACK_OK, this._zkTcp.sessionId, Constants.USHRT_MAX - 1, Buffer.from([]));
-                    this._zkTcp.socket.write(buf);
-                }
-                catch (e) {
-                    throw new ZkError(e, COMMANDS.CMD_ACK_OK, this._zkTcp.ip);
-                }
+        try {
+            let timer;
+            const setTimeoutTimer = (cb) => {
+                if (timer)
+                    clearTimeout(timer);
+                return setTimeout(() => {
+                    cb(new Error("[ENROLL_INFO] time out"));
+                }, 1000 * 20);
             };
-            const cancel = await this._zkTcp.cancelCapture();
-            const cmdResponse = await this._zkTcp.executeCmd(COMMANDS.CMD_STARTENROLL, commandString);
-            this._zkTcp.timeout = 60000; // 60 seconds timeout
-            let attempts = 3;
-            while (attempts > 0) {
-                if (this._zkTcp.verbose)
-                    console.log(`A:${attempts} esperando primer regevent`);
-                let dataRecv = await this._zkTcp.readSocket(17);
-                await sendAckOk();
-                if (dataRecv.length > 16) {
-                    const padded = Buffer.concat([dataRecv, Buffer.alloc(24 - dataRecv.length)]);
-                    const res = padded.readUInt16LE(16);
-                    if (this._zkTcp.verbose)
-                        console.log(`res ${res}`);
-                    if (res === 0 || res === 6 || res === 4) {
-                        if (this._zkTcp.verbose)
-                            console.log("posible timeout o reg Fallido");
-                        break;
+            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;
                     }
-                }
-                if (this._zkTcp.verbose)
-                    console.log(`A:${attempts} esperando 2do regevent`);
-                dataRecv = await this._zkTcp.readSocket(17);
-                await sendAckOk();
-                if (this._zkTcp.verbose)
-                    console.log(dataRecv);
-                if (dataRecv.length > 8) {
-                    const padded = Buffer.concat([dataRecv, Buffer.alloc(24 - dataRecv.length)]);
-                    const res = padded.readUInt16LE(16);
-                    if (this._zkTcp.verbose)
-                        console.log(`res ${res}`);
-                    if (res === 6 || res === 4) {
-                        if (this._zkTcp.verbose)
-                            console.log("posible timeout o reg Fallido");
-                        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);
+                        }
                     }
-                    else if (res === 0x64) {
-                        if (this._zkTcp.verbose)
-                            console.log("ok, continue?");
-                        attempts--;
+                    catch (e) {
+                        this._zkTcp.verbose &&
+                            console.debug("Finger index is empty, skipping delete");
                     }
-                }
-            }
-            if (attempts === 0) {
-                const dataRecv = await this._zkTcp.readSocket(17);
-                await sendAckOk();
-                if (this._zkTcp.verbose)
-                    console.log(dataRecv.toString('hex'));
-                const padded = Buffer.concat([dataRecv, Buffer.alloc(24 - dataRecv.length)]);
-                let res = padded.readUInt16LE(16);
-                if (this._zkTcp.verbose)
-                    console.log(`res ${res}`);
-                if (res === 5) {
-                    if (this._zkTcp.verbose)
-                        console.log("finger duplicate");
-                }
-                if (res === 6 || res === 4) {
-                    if (this._zkTcp.verbose)
-                        console.log("posible timeout");
-                }
-                if (res === 0) {
-                    const size = padded.readUInt16LE(10);
-                    const pos = padded.readUInt16LE(12);
-                    if (this._zkTcp.verbose)
-                        console.log(`enroll ok ${size} ${pos}`);
-                    done = true;
-                }
-            }
-            //this.__sock.setTimeout(this.__timeout);
-            await this._zkTcp.regEvent(0); // TODO: test
-            return done;
+                    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);
+            //await this._zkTcp.cancelCapture();
+            //await this.verify(user_id);
         }
     }
     async verify(user_id) {
@@ -1172,35 +1170,38 @@ class UserService {
      */
     async uploadFingerTemplate(user_id, fingerTemplate, fid, fp_valid) {
         try {
-            const check_ACK_OK = (buf) => {
-                let resp_cmd = initPacket.readUInt16LE(0);
-                if (resp_cmd === COMMANDS.CMD_ACK_OK)
-                    return true;
-                else
-                    throw new Error(`received unexpected command: ${resp_cmd}`);
-            };
             const user = this._users.get(user_id);
             await this._zkTcp.disableDevice();
             const prep_struct = Buffer.alloc(4);
-            const fingerBuffer = Buffer.from(fingerTemplate, 'base64');
+            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);
-            check_ACK_OK(initPacket);
+            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);
-            check_ACK_OK(fpPacket);
-            const cheksumPacket = await this._zkTcp.executeCmd(COMMANDS.CMD_CHECKSUM_BUFFER, '');
-            check_ACK_OK(cheksumPacket);
-            const checksum = cheksumPacket.readUInt32LE(8);
+            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);
-            check_ACK_OK(tmp_wreqPacket);
-            const freeData = await this._zkTcp.executeCmd(COMMANDS.CMD_FREE_DATA, '');
-            return check_ACK_OK(freeData);
+            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;
@@ -1272,40 +1273,1016 @@ class TransactionService {
     }
 }
 
-class ZTCP {
+/**
+ *
+ * @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) {
     /**
-    * @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;
+     * 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([]);
-    _userService;
+    _optionsService;
     _transactionService;
+    _userService;
     constructor(ip, port, timeout, comm_key, verbose) {
         this.ip = ip;
         this.port = port;
@@ -1313,6 +2290,7 @@ class ZTCP {
         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);
     }
@@ -1320,21 +2298,21 @@ class ZTCP {
         return new Promise((resolve, reject) => {
             this.socket = new net.Socket();
             // Handle socket error
-            this.socket.once('error', (err) => {
+            this.socket.once("error", (err) => {
                 this.socket = undefined; // Ensure socket reference is cleared
                 reject(err);
-                if (typeof cbError === 'function')
+                if (typeof cbError === "function")
                     cbError(err);
             });
             // Handle successful connection
-            this.socket.once('connect', () => {
+            this.socket.once("connect", () => {
                 resolve(this.socket);
             });
             // Handle socket closure
-            this.socket.once('close', () => {
+            this.socket.once("close", () => {
                 this.socket = undefined; // Ensure socket reference is cleared
-                if (typeof cbClose === 'function')
-                    cbClose('tcp');
+                if (typeof cbClose === "function")
+                    cbClose("tcp");
             });
             // Set socket timeout if provided
             if (this.timeout) {
@@ -1346,7 +2324,7 @@ class ZTCP {
     }
     async connect() {
         try {
-            let reply = await this.executeCmd(COMMANDS.CMD_CONNECT, '');
+            let reply = await this.executeCmd(COMMANDS.CMD_CONNECT, "");
             if (reply.readUInt16LE(0) === COMMANDS.CMD_ACK_OK) {
                 return true;
             }
@@ -1362,12 +2340,12 @@ class ZTCP {
             }
             else {
                 // No reply received; throw an error
-                throw new Error('NO_REPLY_ON_CMD_CONNECT');
+                throw new Error("NO_REPLY_ON_CMD_CONNECT");
             }
         }
         catch (err) {
             // Log the error for debugging, if necessary
-            console.error('Failed to connect:', err);
+            console.error("Failed to connect:", err);
             // Re-throw the error for handling by the caller
             throw err;
         }
@@ -1379,10 +2357,10 @@ class ZTCP {
                 return resolve(true);
             }
             // Clean up listeners to avoid potential memory leaks or duplicate handling
-            this.socket.removeAllListeners('data');
+            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
+                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
@@ -1391,49 +2369,44 @@ class ZTCP {
                 resolve(true); // Resolve once the socket has ended
             });
             // Handle socket errors during closing
-            this.socket.once('error', (err) => {
+            this.socket.once("error", (err) => {
                 clearTimeout(timer);
                 reject(err); // Reject the promise with the error
             });
         });
     }
-    writeMessage(msg, connect) {
+    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'));
+                return reject(new Error("Socket is not initialized"));
             }
             // Define a variable for the timeout reference
-            let timer = null;
+            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
+                    this.socket.removeListener("data", onData); // Remove the data event listener
                 }
-                clearTimeout(timer); // Clear the timeout once data is received
-                resolve(data); // Resolve the promise with the received data
             };
             // Attach the data event listener
-            this.socket.once('data', onData);
+            this.socket.on("data", onData);
             // Attempt to write the message to the socket
-            this.socket.write(msg, null, (err) => {
+            this.socket.write(msg, undefined, (err) => {
                 if (err) {
-                    // Check if the socket is still valid before trying to remove the listener
-                    if (this.socket) {
-                        this.socket.removeListener('data', onData); // Clean up listener on write error
-                    }
-                    return reject(err); // Reject the promise with the write error
-                }
-                // If a timeout is set, configure it
-                if (this.timeout) {
-                    timer = setTimeout(() => {
-                        // Check if the socket is still valid before trying to remove the listener
-                        if (this.socket) {
-                            this.socket.removeListener('data', onData); // Remove listener on timeout
-                        }
-                        reject(new Error('TIMEOUT_ON_WRITING_MESSAGE')); // Reject the promise on timeout
-                    }, connect ? 2000 : this.timeout);
+                    cleanUp();
+                    reject(err); // Reject the promise with the write error
                 }
             });
         });
@@ -1446,12 +2419,18 @@ class ZTCP {
                 // Internal callback to handle data reception
                 const internalCallback = (data_1) => {
                     if (this.socket) {
-                        this.socket.removeListener('data', handleOnData); // Clean up listener
+                        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
@@ -1461,7 +2440,7 @@ class ZTCP {
                     // Decode the TCP header
                     const header = decodeTCPHeader(replyBuffer.subarray(0, 16));
                     if (this.verbose) {
-                        console.log("linea 232: replyId: ", header.replyId, "      command:    ", header.commandId, Object.keys(COMMANDS).find(c => COMMANDS[c] == header.commandId));
+                        console.log("response command: ", header.commandId, COMMANDS[header.commandId], "replyid: ", header.replyId);
                     }
                     // Handle based on command ID
                     if (header.commandId === COMMANDS.CMD_DATA) {
@@ -1472,12 +2451,7 @@ class ZTCP {
                     }
                     else {
                         // Set a timeout to handle errors
-                        timer = setTimeout(() => {
-                            if (this.socket) {
-                                this.socket.removeListener('data', handleOnData); // Clean up listener on timeout
-                            }
-                            reject(new Error('TIMEOUT_ON_RECEIVING_REQUEST_DATA')); // Reject on timeout
-                        }, this.timeout);
+                        timer = onTimeOut();
                         // Extract packet length and handle accordingly
                         const packetLength = data_3.readUIntLE(4, 2);
                         if (packetLength > 8) {
@@ -1487,26 +2461,21 @@ class ZTCP {
                 };
                 // Ensure the socket is valid before attaching the listener
                 if (this.socket) {
-                    this.socket.on('data', handleOnData);
+                    this.socket.on("data", handleOnData);
                     // Write the message to the socket
-                    this.socket.write(msg, null, (err) => {
+                    this.socket.write(msg, undefined, (err) => {
                         if (err) {
                             if (this.socket) {
-                                this.socket.removeListener('data', handleOnData); // Clean up listener on error
+                                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 = 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);
+                        timer = onTimeOut();
                     });
                 }
                 else {
-                    reject(new Error('SOCKET_NOT_INITIALIZED')); // Reject if socket is not initialized
+                    reject(new Error("SOCKET_NOT_INITIALIZED")); // Reject if socket is not initialized
                 }
             });
         }
@@ -1532,27 +2501,49 @@ class ZTCP {
         else {
             this.replyId++;
         }
+        const currentReply = this.replyId;
         const buf = createTCPHeader(command, this.sessionId, this.replyId, data);
-        try {
-            // Write the message to the socket and wait for a response
-            const reply = await this.writeMessage(buf, command === COMMANDS.CMD_CONNECT || command === COMMANDS.CMD_EXIT);
-            if (this.verbose) {
-                let headers = decodeTCPHeader(reply);
-                console.log('command: ', COMMANDS[headers.commandId], 'replyid: ', headers.replyId);
-            }
-            // Remove TCP header from the response
-            const rReply = removeTcpHeader(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);
+        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 rReply;
-        }
-        catch (err) {
-            // Log or handle the error if necessary
-            console.error('Error executing command:', err);
-            throw err; // Re-throw the error for handling by the caller
-        }
+        };
+        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++;
@@ -1561,8 +2552,8 @@ class ZTCP {
         reqData.writeUInt32LE(size, 4);
         const buf = createTCPHeader(COMMANDS.CMD_DATA_RDY, this.sessionId, this.replyId, reqData);
         try {
-            await new Promise((resolve, reject) => {
-                this.socket.write(buf, null, (err) => {
+            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
@@ -1572,6 +2563,7 @@ class ZTCP {
                     }
                 });
             });
+            await promise;
         }
         catch (err) {
             // Handle or log the error as needed
@@ -1587,18 +2579,18 @@ class ZTCP {
      * 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 = null) {
+    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 = null;
+            let reply;
             try {
                 reply = await this.requestData(buf);
             }
             catch (err) {
                 reject(err);
             }
-            const header = decodeTCPHeader(reply.subarray(0, 16));
+            const header = decodeTCPHeader(reply?.subarray(0, 16));
             switch (header.commandId) {
                 case COMMANDS.CMD_DATA: {
                     resolve({ data: reply.subarray(16), mode: 8 });
@@ -1612,56 +2604,64 @@ class ZTCP {
                     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
-                    let remain = size % Constants.MAX_CHUNK;
-                    let numberChunks = Math.round(size - remain) / Constants.MAX_CHUNK;
+                    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'));
+                        internalCallback(this.replyData, new Error("TIMEOUT WHEN RECEIVING PACKET"));
                     }, this.timeout);
                     const internalCallback = (replyData, err = null) => {
-                        this.socket && this.socket.removeAllListeners('data');
+                        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'));
+                    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) => {
+                                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);
-                                    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;
+                                    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)]);
+                                        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)) {
+                                        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));
@@ -1675,8 +2675,11 @@ class ZTCP {
                                 reject2(e);
                             }
                         });
-                        this.replyData = Buffer.concat([this.replyData, data]);
-                        this.socket.removeAllListeners('data');
+                        this.replyData = Buffer.concat([
+                            this.replyData,
+                            data,
+                        ]);
+                        this.socket?.removeAllListeners("data");
                         if (this.packetNumber <= 0) {
                             resolve({ data: this.replyData });
                         }
@@ -1684,7 +2687,7 @@ class ZTCP {
                     break;
                 }
                 default: {
-                    reject(new Error('ERROR_IN_UNHANDLE_CMD ' + exportErrorMessage(header.commandId)));
+                    reject(new Error("ERROR_IN_UNHANDLE_CMD " + exportErrorMessage(header.commandId)));
                 }
             }
         });
@@ -1695,16 +2698,13 @@ class ZTCP {
      *  reject error when starting request data
      *  return { data: records, err: Error } when receiving requested data
      */
-    async getAttendances(callbackInProcess = () => { }) {
-        return await this._transactionService.getAttendances(callbackInProcess);
-    }
     async freeData() {
         try {
-            const resp = await this.executeCmd(COMMANDS.CMD_FREE_DATA, '');
+            const resp = await this.executeCmd(COMMANDS.CMD_FREE_DATA, "");
             return !!resp;
         }
         catch (err) {
-            console.error('Error freeing data:', err);
+            console.error("Error freeing data:", err);
             throw err; // Optionally, re-throw the error if you need to handle it upstream
         }
     }
@@ -1714,28 +2714,28 @@ class ZTCP {
             return !!resp;
         }
         catch (err) {
-            console.error('Error disabling device:', 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, '');
+            const resp = await this.executeCmd(COMMANDS.CMD_ENABLEDEVICE, "");
             return !!resp;
         }
         catch (err) {
-            console.error('Error enabling device:', 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, '');
+            await this.executeCmd(COMMANDS.CMD_EXIT, "");
         }
         catch (err) {
             // Log any errors encountered during command execution
-            console.error('Error during disconnection:', err);
+            console.error("Error during disconnection:", err);
             // Optionally, add more handling or recovery logic here
         }
         // Attempt to close the socket and return the result
@@ -1744,7 +2744,7 @@ class ZTCP {
         }
         catch (err) {
             // Log any errors encountered while closing the socket
-            console.error('Error during socket closure:', err);
+            console.error("Error during socket closure:", err);
             // Optionally, rethrow or handle the error if necessary
             throw err; // Re-throwing to propagate the error
         }
@@ -1752,17 +2752,17 @@ class ZTCP {
     async getInfo() {
         try {
             // Execute the command to retrieve free sizes from the device
-            const data = await this.executeCmd(COMMANDS.CMD_GET_FREE_SIZES, '');
+            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
+                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);
+            console.error("Error getting device info:", err);
             // Re-throw the error to allow upstream error handling
             throw err;
         }
@@ -1770,7 +2770,7 @@ class ZTCP {
     async getSizes() {
         try {
             // Execute the command to retrieve free sizes from the device
-            const data = await this.executeCmd(COMMANDS.CMD_GET_FREE_SIZES, '');
+            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);
@@ -1800,362 +2800,27 @@ class ZTCP {
                 userAvailable: this.user_av,
                 attLogAvailable: this.attlog_av,
                 faceCount: this.face_count,
-                faceCapacity: this.face_cap
+                faceCapacity: this.face_cap,
             };
         }
         catch (err) {
             // Log the error for debugging purposes
-            console.error('Error getting device info:', err);
+            console.error("Error getting device info:", err);
             // Re-throw the error to allow upstream error handling
             throw err;
         }
     }
-    async getVendor() {
-        const keyword = '~OEMVendor';
-        try {
-            // Execute the command to get oem vendor
-            const data = await this.executeCmd(COMMANDS.CMD_OPTIONS_RRQ, keyword);
-            // Extract and format the oem bendor from the response data
-            const vendor = 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 vendor;
-        }
-        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.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.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: this.ip,
-                NetMask: '',
-                GATEIPAddress: ''
-            };
-            const keywords = Object.keys(params);
-            for await (const keyword of keywords) {
-                const data = await this.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.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
-                if (serialNumber.length !== 13 && this.verbose) {
-                    console.warn('Serial number length not equal to 13, check');
-                }
-                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;
-        }
-    }
-    async getDeviceVersion() {
-        const keyword = '~ZKFPVersion';
-        try {
-            // Execute the command to get device version
-            const data = await this.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;
-        }
-    }
-    async getDeviceName() {
-        const keyword = '~DeviceName';
-        try {
-            // Execute the command to get the device name
-            const data = await this.executeCmd(COMMANDS.CMD_OPTIONS_RRQ, keyword);
-            // Extract and format the device name 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 name:', err);
-            // Re-throw the error for higher-level handling
-            throw err;
-        }
-    }
-    async getPlatform() {
-        const keyword = '~Platform';
-        try {
-            // Execute the command to get the platform information
-            const data = await this.executeCmd(COMMANDS.CMD_OPTIONS_RRQ, keyword);
-            // Extract and format the platform 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, '');
-        }
-        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';
-        try {
-            // Execute the command to get the OS information
-            const data = await this.executeCmd(COMMANDS.CMD_OPTIONS_RRQ, keyword);
-            // Extract and format the OS 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, '');
-        }
-        catch (err) {
-            // Log the error for debugging
-            console.error('Error getting OS information:', err);
-            // Re-throw the error for higher-level handling
-            throw err;
-        }
-    }
-    async getWorkCode() {
-        const keyword = 'WorkCode';
-        try {
-            // Execute the command to get the WorkCode information
-            const data = await this.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, '');
-        }
-        catch (err) {
-            // Log the error for debugging
-            console.error('Error getting WorkCode:', err);
-            // Re-throw the error to be handled by the caller
-            throw err;
-        }
-    }
-    async getPIN() {
-        const keyword = '~PIN2Width';
-        try {
-            // Execute the command to get the PIN information
-            const data = await this.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 getFaceOn() {
-        const keyword = 'FaceFunOn';
-        try {
-            // Execute the command to get the face function status
-            const data = await this.executeCmd(COMMANDS.CMD_OPTIONS_RRQ, keyword);
-            // Extract and process the status from the response data
-            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';
-        }
-        catch (err) {
-            // Log the error for debugging
-            console.error('Error getting face function status:', err);
-            // Re-throw the error to be handled by the caller
-            throw err;
-        }
-    }
-    async getSSR() {
-        const keyword = '~SSR';
-        try {
-            // Execute the command to get the SSR value
-            const data = await this.executeCmd(COMMANDS.CMD_OPTIONS_RRQ, keyword);
-            // Extract and process the SSR value from the response data
-            // Remove the keyword prefix
-            // Return the SSR value
-            return data.slice(8) // Skip the first 8 bytes (header)
-                .toString('ascii') // Convert buffer to ASCII string
-                .replace(`${keyword}=`, '');
-        }
-        catch (err) {
-            // Log the error for debugging
-            console.error('Error getting SSR value:', err);
-            // Re-throw the error to be handled by the caller
-            throw err;
-        }
-    }
-    async getFirmware() {
-        try {
-            // Execute the command to get firmware information
-            const data = await this.executeCmd(1100, '');
-            // Extract and return the firmware version from the response data
-            return data.slice(8) // Skip the first 8 bytes (header)
-                .toString('ascii') // convert to ASCII string
-                .replace(/\u0000/g, ''); // remove x00
-        }
-        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.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
-            return timeParser.decode(timeValue); // Parse and return the decoded 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.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.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;
-        }
-    }
+    #listeners = new Map();
     async getAttendanceSize() {
         try {
             // Execute command to get free sizes
-            const data = await this.executeCmd(COMMANDS.CMD_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);
+            console.error("Error getting attendance size:", err);
             // Re-throw the error to be handled by the caller
             throw err;
         }
@@ -2186,7 +2851,7 @@ class ZTCP {
         }
         catch (err) {
             // Log the error for debugging purposes
-            console.error('Error clearing data:', err);
+            console.error("Error clearing data:", err);
             // Re-throw the error to be handled by the caller
             throw err;
         }
@@ -2197,22 +2862,23 @@ class ZTCP {
             // 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, null, (err) => {
+            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);
+                    console.error("Error sending real-time logs request:", err);
                     throw err;
                 }
             });
             // Ensure data listeners are added only once
-            if (this.socket.listenerCount('data') === 0) {
-                this.socket.on('data', (data) => {
+            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(decodeRecordRealTimeLog52(data));
+                            cb(decodeRTEvent(data));
                         }
                     }
                 });
@@ -2220,7 +2886,7 @@ class ZTCP {
         }
         catch (err) {
             // Handle errors and reject the promise
-            console.error('Error getting real-time logs:', err);
+            console.error("Error getting real-time logs:", err);
             throw err;
         }
     }
@@ -2252,11 +2918,11 @@ class ZTCP {
     }
     async refreshData() {
         try {
-            const reply = await this.executeCmd(COMMANDS.CMD_REFRESHDATA, '');
+            const reply = await this.executeCmd(COMMANDS.CMD_REFRESHDATA, "");
             return !!reply;
         }
         catch (err) {
-            console.error('Error getting user templates: ', err);
+            console.error("Error getting user templates: ", err);
             throw err;
         }
     }
@@ -2307,13 +2973,13 @@ class ZTCP {
     }
     async readSocket(length, cb = null) {
         let replyBufer = Buffer.from([]);
-        let totalPackets = 0;
+        const totalPackets = 0;
         return new Promise((resolve, reject) => {
             let timer = setTimeout(() => {
-                internalCallback(replyBufer, new Error('TIMEOUT WHEN RECEIVING PACKET'));
+                internalCallback(replyBufer, new Error("TIMEOUT WHEN RECEIVING PACKET"));
             }, this.timeout);
             const internalCallback = (replyData, err = null) => {
-                this.socket && this.socket.removeListener('data', onDataEnroll);
+                this.socket && this.socket.removeListener("data", onDataEnroll);
                 timer && clearTimeout(timer);
                 resolve({ data: replyData, err: err });
             };
@@ -2327,10 +2993,10 @@ class ZTCP {
                     internalCallback(data);
                 }
             }
-            this.socket.once('close', () => {
-                internalCallback(replyBufer, new Error('Socket is disconnected unexpectedly'));
+            this.socket.once("close", () => {
+                internalCallback(replyBufer, new Error("Socket is disconnected unexpectedly"));
             });
-            this.socket.on('data', onDataEnroll);
+            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
@@ -2356,7 +3022,7 @@ class ZTCP {
     }
     async cancelCapture() {
         try {
-            const reply = await this.executeCmd(COMMANDS.CMD_CANCELCAPTURE, '');
+            const reply = await this.executeCmd(COMMANDS.CMD_CANCELCAPTURE, "");
             return !!reply;
         }
         catch (e) {
@@ -2365,7 +3031,7 @@ class ZTCP {
     }
     async restartDevice() {
         try {
-            await this.executeCmd(COMMANDS.CMD_RESTART, '');
+            await this.executeCmd(COMMANDS.CMD_RESTART, "");
         }
         catch (e) {
             throw new ZkError(e, COMMANDS.CMD_RESTART, this.ip);
@@ -2434,7 +3100,7 @@ class ZUDP {
                     return true;
                 }
                 else {
-                    throw new Error("Authentication error");
+                    throw new Error('Authentication error');
                 }
             }
             else {
@@ -2862,22 +3528,22 @@ class Zklib {
     async functionWrapper(tcpCallback, udpCallback, command) {
         try {
             switch (this._connectionType) {
-                case 'tcp':
+                case "tcp":
                     if (this.ztcp && this.ztcp.socket) {
                         return await tcpCallback();
                     }
                     else {
-                        throw new 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':
+                case "udp":
                     if (this.zudp && this.zudp.socket) {
                         return await udpCallback();
                     }
                     else {
-                        throw new 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 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) {
@@ -2889,24 +3555,24 @@ class Zklib {
             if (this.ztcp.socket) {
                 try {
                     await this.ztcp.connect();
-                    console.log('TCP reconnection successful');
-                    this._connectionType = 'tcp';
+                    console.log("TCP reconnection successful");
+                    this._connectionType = "tcp";
                     return true;
                 }
                 catch (err) {
-                    throw new ZkError(err, 'TCP CONNECT', this.ip);
+                    throw new ZkError(err, "TCP CONNECT", this.ip);
                 }
             }
             else {
                 try {
                     await this.ztcp.createSocket(cbErr, cbClose);
                     await this.ztcp.connect();
-                    console.log('TCP connection successful');
-                    this._connectionType = 'tcp';
+                    console.log("TCP connection successful");
+                    this._connectionType = "tcp";
                     return true;
                 }
                 catch (err) {
-                    throw new ZkError(err, 'TCP CONNECT', this.ip);
+                    throw new ZkError(err, "TCP CONNECT", this.ip);
                 }
             }
         }
@@ -2916,86 +3582,114 @@ class Zklib {
                     await this.ztcp.disconnect();
             }
             catch (disconnectErr) {
-                console.error('Error disconnecting TCP:', disconnectErr);
+                console.error("Error disconnecting TCP:", disconnectErr);
             }
             if (err.code !== ERROR_TYPES.ECONNREFUSED) {
-                throw new ZkError(err, 'TCP CONNECT', this.ip);
+                throw new ZkError(err, "TCP CONNECT", this.ip);
             }
             try {
                 if (!this.zudp.socket) {
                     await this.zudp.createSocket(cbErr, cbClose);
                 }
                 await this.zudp.connect();
-                console.log('UDP connection successful');
-                this._connectionType = 'udp';
+                console.log("UDP connection successful");
+                this._connectionType = "udp";
                 return true;
             }
             catch (err) {
-                if (err.message !== 'EADDRINUSE') {
+                if (err.message !== "EADDRINUSE") {
                     this._connectionType = null;
                     try {
                         await this.zudp.disconnect();
                     }
                     catch (disconnectErr) {
-                        console.error('Error disconnecting UDP:', disconnectErr);
+                        console.error("Error disconnecting UDP:", disconnectErr);
                     }
-                    throw new ZkError(err, 'UDP CONNECT', this.ip);
+                    throw new ZkError(err, "UDP CONNECT", this.ip);
                 }
-                this._connectionType = 'udp';
+                this._connectionType = "udp";
                 return true;
             }
         }
     }
     async getUsers() {
-        return this.functionWrapper(() => this.ztcp._userService.getUsers(), () => this.zudp.getUsers(), 'GET_USERS');
+        return this.functionWrapper(() => this.ztcp._userService.getUsers(), () => this.zudp.getUsers(), "GET_USERS");
     }
     async getTime() {
-        return this.functionWrapper(() => this.ztcp.getTime(), () => this.zudp.getTime(), 'GET_TIME');
+        return this.functionWrapper(() => this.ztcp._optionsService.getTime(), () => this.zudp.getTime(), "GET_TIME");
     }
     async setTime(t) {
-        return this.functionWrapper(() => this.ztcp.setTime(t), () => this.zudp.setTime(t), 'SET_TIME');
+        return this.functionWrapper(() => this.ztcp._optionsService.setTime(t), () => this.zudp.setTime(t), "SET_TIME");
     }
     async voiceTest() {
-        return this.functionWrapper(() => this.ztcp.voiceTest(), async () => { throw new Error('UDP voice test not supported'); }, 'VOICE_TEST');
+        return this.functionWrapper(() => this.ztcp._optionsService.voiceTest(), async () => {
+            throw new Error("UDP voice test not supported");
+        }, "VOICE_TEST");
     }
     async getProductTime() {
-        return this.functionWrapper(() => this.ztcp.getProductTime(), async () => { throw new Error('UDP get product time not supported'); }, 'GET_PRODUCT_TIME');
+        return this.functionWrapper(() => this.ztcp._optionsService.getProductTime(), async () => {
+            throw new Error("UDP get product time not supported");
+        }, "GET_PRODUCT_TIME");
     }
     async getVendor() {
-        return this.functionWrapper(() => this.ztcp.getVendor(), async () => { throw new Error('UDP get vendor not supported'); }, 'GET_VENDOR');
+        return this.functionWrapper(() => this.ztcp._optionsService.getVendor(), async () => {
+            throw new Error("UDP get vendor not supported");
+        }, "GET_VENDOR");
     }
     async getMacAddress() {
-        return this.functionWrapper(() => this.ztcp.getMacAddress(), async () => { throw new Error('UDP get MAC address not supported'); }, 'GET_MAC_ADDRESS');
+        return this.functionWrapper(() => this.ztcp._optionsService.getMacAddress(), async () => {
+            throw new Error("UDP get MAC address not supported");
+        }, "GET_MAC_ADDRESS");
     }
     async getSerialNumber() {
-        return this.functionWrapper(() => this.ztcp.getSerialNumber(), async () => { throw new Error('UDP get serial number not supported'); }, 'GET_SERIAL_NUMBER');
+        return this.functionWrapper(() => this.ztcp._optionsService.getSerialNumber(), async () => {
+            throw new Error("UDP get serial number not supported");
+        }, "GET_SERIAL_NUMBER");
     }
     async getDeviceVersion() {
-        return this.functionWrapper(() => this.ztcp.getDeviceVersion(), async () => { throw new Error('UDP get device version not supported'); }, 'GET_DEVICE_VERSION');
+        return this.functionWrapper(() => this.ztcp._optionsService.getDeviceVersion(), async () => {
+            throw new Error("UDP get device version not supported");
+        }, "GET_DEVICE_VERSION");
     }
     async getDeviceName() {
-        return this.functionWrapper(() => this.ztcp.getDeviceName(), async () => { throw new Error('UDP get device name not supported'); }, 'GET_DEVICE_NAME');
+        return this.functionWrapper(() => this.ztcp._optionsService.getDeviceName(), async () => {
+            throw new Error("UDP get device name not supported");
+        }, "GET_DEVICE_NAME");
     }
     async getPlatform() {
-        return this.functionWrapper(() => this.ztcp.getPlatform(), async () => { throw new Error('UDP get platform not supported'); }, 'GET_PLATFORM');
+        return this.functionWrapper(() => this.ztcp._optionsService.getPlatform(), async () => {
+            throw new Error("UDP get platform not supported");
+        }, "GET_PLATFORM");
     }
     async getOS() {
-        return this.functionWrapper(() => this.ztcp.getOS(), async () => { throw new Error('UDP get OS not supported'); }, 'GET_OS');
+        return this.functionWrapper(() => this.ztcp._optionsService.getOS(), async () => {
+            throw new Error("UDP get OS not supported");
+        }, "GET_OS");
     }
     async getWorkCode() {
-        return this.functionWrapper(() => this.ztcp.getWorkCode(), async () => { throw new Error('UDP get work code not supported'); }, 'GET_WORK_CODE');
+        return this.functionWrapper(() => this.ztcp._optionsService.getWorkCode(), async () => {
+            throw new Error("UDP get work code not supported");
+        }, "GET_WORK_CODE");
     }
     async getPIN() {
-        return this.functionWrapper(() => this.ztcp.getPIN(), async () => { throw new Error('UDP get PIN not supported'); }, 'GET_PIN');
+        return this.functionWrapper(() => this.ztcp._optionsService.getPIN(), async () => {
+            throw new Error("UDP get PIN not supported");
+        }, "GET_PIN");
     }
     async getFaceOn() {
-        return this.functionWrapper(() => this.ztcp.getFaceOn(), async () => { throw new Error('UDP get face on not supported'); }, 'GET_FACE_ON');
+        return this.functionWrapper(() => this.ztcp._optionsService.getFaceOn(), async () => {
+            throw new Error("UDP get face on not supported");
+        }, "GET_FACE_ON");
     }
     async getSSR() {
-        return this.functionWrapper(() => this.ztcp.getSSR(), async () => { throw new Error('UDP get SSR not supported'); }, 'GET_SSR');
+        return this.functionWrapper(() => this.ztcp._optionsService.getSSR(), async () => {
+            throw new Error("UDP get SSR not supported");
+        }, "GET_SSR");
     }
     async getFirmware() {
-        return this.functionWrapper(() => this.ztcp.getFirmware(), async () => { throw new Error('UDP get firmware not supported'); }, 'GET_FIRMWARE');
+        return this.functionWrapper(() => this.ztcp._optionsService.getFirmware(), async () => {
+            throw new Error("UDP get firmware not supported");
+        }, "GET_FIRMWARE");
     }
     /** Update or create a user if user id/pin not exists
      * @param user_id {string} user id/pin for customer
@@ -3005,26 +3699,34 @@ class Zklib {
      * @param cardno {number} card number/id
      */
     async setUser(user_id, name, password, role = 0, cardno = 0) {
-        return this.functionWrapper(() => this.ztcp._userService.setUser(user_id, name, password, role, cardno), async () => { throw new Error('UDP set user not supported'); }, 'SET_USER');
+        return this.functionWrapper(() => this.ztcp._userService.setUser(user_id, name, password, role, cardno), async () => {
+            throw new Error("UDP set user not supported");
+        }, "SET_USER");
     }
     /**
      * Delete user by a given user id/pin
      * @param user_id {string}
      */
     async deleteUser(user_id) {
-        return this.functionWrapper(() => this.ztcp._userService.DeleteUser(user_id), async () => { throw new Error('UDP delete user not supported'); }, 'DELETE_USER');
+        return this.functionWrapper(() => this.ztcp._userService.DeleteUser(user_id), async () => {
+            throw new Error("UDP delete user not supported");
+        }, "DELETE_USER");
     }
     async getAttendanceSize() {
-        return this.functionWrapper(() => this.ztcp.getAttendanceSize(), async () => { throw new Error('UDP get attendance size not supported'); }, 'GET_ATTENDANCE_SIZE');
+        return this.functionWrapper(() => this.ztcp.getAttendanceSize(), async () => {
+            throw new Error("UDP get attendance size not supported");
+        }, "GET_ATTENDANCE_SIZE");
     }
     async getAttendances(cb) {
-        return this.functionWrapper(() => this.ztcp.getAttendances(cb), () => this.zudp.getAttendances(cb), 'GET_ATTENDANCES');
+        return this.functionWrapper(() => this.ztcp._transactionService.getAttendances(cb), () => this.zudp.getAttendances(cb), "GET_ATTENDANCES");
     }
     async getRealTimeLogs(cb) {
-        return this.functionWrapper(() => this.ztcp.getRealTimeLogs(cb), () => this.zudp.getRealTimeLogs(cb), 'GET_REAL_TIME_LOGS');
+        return this.functionWrapper(() => this.ztcp.getRealTimeLogs(cb), () => this.zudp.getRealTimeLogs(cb), "GET_REAL_TIME_LOGS");
     }
     async getTemplates() {
-        return this.functionWrapper(() => this.ztcp.getTemplates(), async () => { throw new Error('UDP get templates not supported'); }, 'GET_TEMPLATES');
+        return this.functionWrapper(() => this.ztcp.getTemplates(), async () => {
+            throw new Error("UDP get templates not supported");
+        }, "GET_TEMPLATES");
     }
     /**
      * Get a user template for a given user id/pin and finger id
@@ -3032,7 +3734,9 @@ class Zklib {
      * @param fid {number} finger index
      */
     async getUserTemplate(user_id, fid) {
-        return await this.functionWrapper(async () => await this.ztcp._userService.DownloadFp(user_id, fid), async () => { throw new Error('UDP get user template not implemented'); }, 'GET_USER_TEMPLATE');
+        return await this.functionWrapper(async () => await this.ztcp._userService.DownloadFp(user_id, fid), async () => {
+            throw new Error("UDP get user template not implemented");
+        }, "GET_USER_TEMPLATE");
     }
     /**
      * Upload a single fingerprint for a given user id
@@ -3042,7 +3746,9 @@ class Zklib {
      * @param fp_valid {number} finger flag. e.g., valid=1, duress=3
      */
     async uploadFingerTemplate(user_id, fingerTemplate, fid, fp_valid) {
-        return await this.functionWrapper(async () => await this.ztcp._userService.uploadFingerTemplate(user_id, fingerTemplate, fid, fp_valid), async () => { throw new Error('UDP get user template not implemented'); }, 'UPLOAD_USER_TEMPLATE');
+        return await this.functionWrapper(async () => await this.ztcp._userService.uploadFingerTemplate(user_id, fingerTemplate, fid, fp_valid), async () => {
+            throw new Error("UDP get user template not implemented");
+        }, "UPLOAD_USER_TEMPLATE");
     }
     /**
      * save user and template
@@ -3051,7 +3757,9 @@ class Zklib {
      * @param {Finger[]} fingers - Array of finger class
      */
     async saveUserTemplate(user_id, fingers = []) {
-        return await this.functionWrapper(async () => await this.ztcp._userService.saveTemplates(user_id, fingers), async () => { throw new Error('UDP save user template not supported'); }, 'SAVE_USER_TEMPLATE');
+        return await this.functionWrapper(async () => await this.ztcp._userService.saveTemplates(user_id, fingers), async () => {
+            throw new Error("UDP save user template not supported");
+        }, "SAVE_USER_TEMPLATE");
     }
     /**
      * Delete a single finger template by user id and finger index
@@ -3061,7 +3769,9 @@ class Zklib {
     async deleteFinger(user_id, fid) {
         if (fid > 9 || 0 > fid)
             throw new Error("fid params out of index");
-        return this.functionWrapper(() => this.ztcp._userService.deleteFinger(user_id, fid), async () => { throw new Error('UDP delete finger not supported'); }, 'DELETE_FINGER');
+        return this.functionWrapper(() => this.ztcp._userService.deleteFinger(user_id, fid), async () => {
+            throw new Error("UDP delete finger not supported");
+        }, "DELETE_FINGER");
     }
     /**
      * Start to enroll a finger template
@@ -3071,43 +3781,53 @@ class Zklib {
     async enrollUser(user_id, temp_id) {
         if (temp_id < 0 || temp_id > 9)
             throw new Error("temp_id out of range 0-9");
-        return this.functionWrapper(() => this.ztcp._userService.enrollInfo(user_id, temp_id), async () => { throw new Error('UDP enroll user not supported'); }, 'ENROLL_USER');
+        return this.functionWrapper(() => this.ztcp._userService.enrollInfo(user_id, temp_id), async () => {
+            throw new Error("UDP enroll user not supported");
+        }, "ENROLL_USER");
     }
     async verifyUser(user_id) {
-        return this.functionWrapper(() => this.ztcp._userService.verify(user_id), async () => { throw new Error('UDP verify user not supported'); }, 'VERIFY_USER');
+        return this.functionWrapper(() => this.ztcp._userService.verify(user_id), async () => {
+            throw new Error("UDP verify user not supported");
+        }, "VERIFY_USER");
     }
     async restartDevice() {
-        return this.functionWrapper(() => this.ztcp.restartDevice(), async () => { throw new Error('UDP restart device not supported'); }, 'RESTART_DEVICE');
+        return this.functionWrapper(() => this.ztcp.restartDevice(), async () => {
+            throw new Error("UDP restart device not supported");
+        }, "RESTART_DEVICE");
     }
     async getSizes() {
-        return this.functionWrapper(() => this.ztcp.getSizes(), () => { throw new Error('not implemented ofr UDP'); }, 'GET_SIZES');
+        return this.functionWrapper(() => this.ztcp.getSizes(), () => {
+            throw new Error("not implemented ofr UDP");
+        }, "GET_SIZES");
     }
     async disconnect() {
-        return this.functionWrapper(() => this.ztcp.disconnect(), () => this.zudp.disconnect(), 'DISCONNECT');
+        return this.functionWrapper(() => this.ztcp.disconnect(), () => this.zudp.disconnect(), "DISCONNECT");
     }
     async freeData() {
-        return this.functionWrapper(() => this.ztcp.freeData(), () => this.zudp.freeData(), 'FREE_DATA');
+        return this.functionWrapper(() => this.ztcp.freeData(), () => this.zudp.freeData(), "FREE_DATA");
     }
     async disableDevice() {
-        return this.functionWrapper(() => this.ztcp.disableDevice(), () => this.zudp.disableDevice(), 'DISABLE_DEVICE');
+        return this.functionWrapper(() => this.ztcp.disableDevice(), () => this.zudp.disableDevice(), "DISABLE_DEVICE");
     }
     async enableDevice() {
-        return this.functionWrapper(() => this.ztcp.enableDevice(), () => this.zudp.enableDevice(), 'ENABLE_DEVICE');
+        return this.functionWrapper(() => this.ztcp.enableDevice(), () => this.zudp.enableDevice(), "ENABLE_DEVICE");
     }
     async getInfo() {
-        return this.functionWrapper(() => this.ztcp.getInfo(), () => this.zudp.getInfo(), 'GET_INFO');
+        return this.functionWrapper(() => this.ztcp.getInfo(), () => this.zudp.getInfo(), "GET_INFO");
     }
     async clearAttendanceLog() {
-        return this.functionWrapper(() => this.ztcp.clearAttendanceLog(), () => this.zudp.clearAttendanceLog(), 'CLEAR_ATTENDANCE_LOG');
+        return this.functionWrapper(() => this.ztcp.clearAttendanceLog(), () => this.zudp.clearAttendanceLog(), "CLEAR_ATTENDANCE_LOG");
     }
     async clearData() {
-        return this.functionWrapper(() => this.ztcp.clearData(), () => this.zudp.clearData(), 'CLEAR_DATA');
+        return this.functionWrapper(() => this.ztcp.clearData(), () => this.zudp.clearData(), "CLEAR_DATA");
     }
-    async executeCmd(command, data = '') {
-        return this.functionWrapper(() => this.ztcp.executeCmd(command, data), () => this.zudp.executeCmd(command, data), 'EXECUTE_CMD');
+    async executeCmd(command, data = "") {
+        return this.functionWrapper(() => this.ztcp.executeCmd(command, data), () => this.zudp.executeCmd(command, data), "EXECUTE_CMD");
     }
     async getNetworkParams() {
-        return this.functionWrapper(() => this.ztcp.getNetworkParams(), async () => { throw new Error('UDP getNetworkParams not implemented'); }, 'NETWORK_PARAMS');
+        return this.functionWrapper(() => this.ztcp._optionsService.getNetworkParams(), async () => {
+            throw new Error("UDP getNetworkParams not implemented");
+        }, "NETWORK_PARAMS");
     }
 }