zklib-ts 1.0.0-development

package/dist/logs/log.d.ts

@@ -0,0 +1 @@
+export declare const log: (text: string) => void;

package/dist/models/Attendance.d.ts

@@ -0,0 +1,10 @@
+export declare class Attendance {
+    sn: number;
+    user_id: string;
+    record_time: Date;
+    type?: number;
+    state?: number;
+    private _ip?;
+    constructor(sn: number, user_id: string, record_time: Date, type?: number, state?: number);
+    set ip(value: string);
+}

package/dist/models/Finger.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Represents a fingerprint template with associated metadata
+ */
+export declare class Finger {
+    uid: number;
+    fid: number;
+    valid: number;
+    template: Buffer;
+    size: number;
+    readonly mark: string;
+    /**
+     * Creates a new Finger instance
+     * @param uid User internal reference
+     * @param fid Finger ID (value >= 0 && value <= 9)
+     * @param valid Flag indicating 0 = invalid | 1 = valid | 3 = duress
+     * @param template Fingerprint template data buffer
+     */
+    constructor(uid: number, fid: number, valid: number, template: Buffer);
+    /**
+     * Packs the fingerprint data with metadata into a Buffer
+     * @returns Buffer containing packed fingerprint data
+     */
+    repack(): Buffer;
+    /**
+     * Packs only the fingerprint template data into a Buffer
+     * @returns Buffer containing just the template data
+     */
+    repackOnly(): Buffer;
+    /**
+     * Compares this fingerprint with another for equality
+     * @param other Another Finger instance to compare with
+     * @returns true if all properties and template data match
+     */
+    equals(other: Finger): boolean;
+}

package/dist/models/User.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Represents a User as is from ZkDevice and contain methods
+ * */
+export declare class User {
+    uid: number;
+    name: string;
+    privilege: number;
+    password: string;
+    group_id: string | number;
+    user_id: string;
+    card: number;
+    /**
+     * Creates a new User instance
+     * @param uid User ID
+     * @param name User name
+     * @param privilege Privilege level
+     * @param password User password (default: "")
+     * @param group_id Group ID (default: "")
+     * @param user_id Alternate user ID (default: "")
+     * @param card Card number (default: 0)
+     */
+    constructor(uid: number, name: string, privilege: number, password?: string, group_id?: string | number, user_id?: string, card?: number);
+    private ensureEncoding;
+    repack29(): Buffer;
+    repack73(): Buffer;
+}

package/dist/ztcp.d.ts

@@ -0,0 +1,149 @@
+import { Socket } from 'net';
+import { RealTimeLog } from './helper/utils';
+import { Finger } from './models/Finger';
+import { User } from './models/User';
+export declare 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
+    */
+    private ip;
+    private port;
+    private timeout;
+    private sessionId;
+    private replyId;
+    socket: Socket | undefined;
+    private comm_key;
+    private user_count;
+    private fp_count;
+    private pwd_count;
+    private oplog_count;
+    private attlog_count;
+    private fp_cap;
+    private user_cap;
+    private attlog_cap;
+    private fp_av;
+    private user_av;
+    private attlog_av;
+    private face_count;
+    private face_cap;
+    private userPacketSize;
+    private verbose;
+    constructor(ip: string, port: number, timeout: number, comm_key: number, verbose: boolean);
+    createSocket(cbError: any, cbClose: any): Promise<unknown>;
+    connect(): Promise<boolean>;
+    closeSocket(): Promise<boolean>;
+    writeMessage(msg: Buffer, connect: boolean): Promise<Buffer>;
+    requestData(msg: Buffer): Promise<Buffer>;
+    /**
+     *
+     * @param {*} command
+     * @param {*} data
+     *
+     *
+     * reject error when command fail and resolve data when success
+     */
+    executeCmd(command: number, data: Buffer | string | ArrayBuffer): Promise<Buffer>;
+    sendChunkRequest(start: number, size: number): Promise<any>;
+    /**
+     *
+     * @param {*} reqData - indicate the type of data that need to receive ( user or attLog)
+     * @param {*} cb - callback is triggered when receiving packets
+     *
+     * readWithBuffer will reject error if it'wrong when starting request data
+     * readWithBuffer will return { data: replyData , err: Error } when receiving requested data
+     */
+    readWithBuffer(reqData: Buffer | string, cb?: any): Promise<Record<string, Buffer | number>>;
+    /**
+     *  reject error when starting request data
+     *  @return {Record<string, User[] | Error>} when receiving requested data
+     */
+    getUsers(): Promise<{
+        data: User[];
+    }>;
+    /**
+     *
+     * @param {*} ip
+     * @param {*} callbackInProcess
+     *  reject error when starting request data
+     *  return { data: records, err: Error } when receiving requested data
+     */
+    getAttendances(callbackInProcess?: any): Promise<{
+        data: any[];
+    }>;
+    freeData(): Promise<boolean>;
+    disableDevice(): Promise<boolean>;
+    enableDevice(): Promise<boolean>;
+    disconnect(): Promise<void>;
+    getInfo(): Promise<{
+        userCounts: number;
+        logCounts: number;
+        logCapacity: number;
+    }>;
+    getSizes(): Promise<{
+        userCounts: number;
+        logCounts: number;
+        fingerCount: number;
+        adminCount: number;
+        opLogCount: number;
+        logCapacity: number;
+        fingerCapacity: number;
+        userCapacity: number;
+        attLogCapacity: number;
+        fingerAvailable: number;
+        userAvailable: number;
+        attLogAvailable: number;
+        faceCount: number;
+        faceCapacity: number;
+    }>;
+    getVendor(): Promise<string>;
+    getProductTime(): Promise<Date>;
+    getMacAddress(): Promise<string>;
+    getSerialNumber(): Promise<string>;
+    getDeviceVersion(): Promise<string>;
+    getDeviceName(): Promise<string>;
+    getPlatform(): Promise<string>;
+    getOS(): Promise<string>;
+    getWorkCode(): Promise<string>;
+    getPIN(): Promise<string>;
+    getFaceOn(): Promise<"No" | "Yes">;
+    getSSR(): Promise<string>;
+    getFirmware(): Promise<string>;
+    getTime(): Promise<Date>;
+    setTime(tm: Date | string): Promise<boolean>;
+    voiceTest(): Promise<void>;
+    setUser(uid: number, userid: string, name: string, password: string, role?: number, cardno?: number): Promise<boolean>;
+    deleteUser(uid: number): Promise<boolean>;
+    getAttendanceSize(): Promise<number>;
+    clearAttendanceLog(): Promise<Buffer<ArrayBufferLike>>;
+    clearData(): Promise<Buffer<ArrayBufferLike>>;
+    getRealTimeLogs(cb?: (realTimeLog: RealTimeLog) => void): Promise<void>;
+    getTemplates(): Promise<Finger[]>;
+    refreshData(): Promise<boolean>;
+    sendWithBuffer(buffer: Buffer): Promise<unknown>;
+    sendChunk(commandString: Buffer): Promise<unknown>;
+    /**
+     * save user and template
+     *
+     * @param {User | number | string} user - User class object | uid | user_id
+     * @param {Finger[]} fingers - Array of finger class. `0 <= index <= 9`
+     */
+    saveUserTemplate(user: User, fingers?: Finger[]): Promise<void>;
+    deleteFinger(uid: number, fid: number): Promise<boolean>;
+    enrollUser(uid: number, tempId: number, userId?: string): Promise<boolean>;
+    readSocket(length: number, cb?: any): Promise<any>;
+    /**
+     * Register events
+     * @param {number} flags - Event flags
+     * @returns {Promise<void>}
+     * @throws {ZKErrorResponse} If registration fails
+     */
+    regEvent(flags: any): Promise<void>;
+    ackOk(): Promise<void>;
+    cancelCapture(): Promise<boolean>;
+    verifyUser(uid: number): Promise<boolean>;
+    restartDevice(): Promise<void>;
+}

package/dist/zudp.d.ts

@@ -0,0 +1,49 @@
+import { RecordData16, UserData28 } from './helper/utils';
+import * as dgram from "node:dgram";
+interface DeviceInfo {
+    userCounts: number;
+    logCounts: number;
+    logCapacity: number;
+}
+interface ChunkedDataResponse {
+    data: Buffer | null;
+    err: Error | null;
+}
+export declare class ZUDP {
+    private ip;
+    private port;
+    private timeout;
+    socket: dgram.Socket | null;
+    private sessionId;
+    private replyId;
+    private inport;
+    private comm_key;
+    constructor(ip: string, port: number, timeout: number, inport: number, comm_key?: number);
+    createSocket(cbError?: (err: Error) => void, cbClose?: (type: string) => void): Promise<dgram.Socket>;
+    connect(): Promise<boolean>;
+    closeSocket(): Promise<unknown>;
+    private writeMessage;
+    private requestData;
+    executeCmd(command: number, data: string | Buffer): Promise<Buffer>;
+    private sendChunkRequest;
+    readWithBuffer(reqData: Buffer, cb?: ((progress: number, total: number) => void) | null): Promise<ChunkedDataResponse>;
+    private handleChunkedData;
+    getUsers(): Promise<{
+        data: UserData28[];
+    }>;
+    getAttendances(callbackInProcess?: (progress: number, total: number) => void): Promise<{
+        data: RecordData16[];
+        err: Error;
+    }>;
+    freeData(): Promise<boolean>;
+    getInfo(): Promise<DeviceInfo>;
+    getTime(): Promise<Date>;
+    setTime(tm: Date | string): Promise<boolean>;
+    clearAttendanceLog(): Promise<Buffer>;
+    clearData(): Promise<Buffer>;
+    disableDevice(): Promise<boolean>;
+    enableDevice(): Promise<boolean>;
+    disconnect(): Promise<void>;
+    getRealTimeLogs(cb?: (log: any) => void): Promise<void>;
+}
+export default ZUDP;

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "zklib-ts",
+  "version": "1.0.0-development",
+  "description": "Unofficial zkteco library allows Node.js developers to easily interface with ZK BioMetric Fingerprint Attendance Devices",
+  "main": "dist/index.cjs.js",
+  "module": "dist/index.es.js",
+  "typings": "dist/index",
+  "types": "dist/index.d.ts",
+  "type": "commonjs",
+  "files": [
+    "dist/",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "jest",
+    "build": "rollup -c",
+    "watch": "rollup -c --watch",
+    "prepare": "npm run build"
+  },
+  "repositoryUrl": "https://github.com/guspaz0/zklib-ts.git",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/guspaz0/zklib-ts.git"
+  },
+  "keywords": [
+    "typescript",
+    "javascript",
+    "jest",
+    "ip",
+    "libs",
+    "device",
+    "zkteco",
+    "address",
+    "realtime",
+    "real-time",
+    "biometric",
+    "attendance",
+    "biometric attendance",
+    "biometric attendance device"
+  ],
+  "author": "Gustavo Paz",
+  "license": "MIT",
+  "directories": {
+    "test": "tests"
+  },
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^28.0.3",
+    "@rollup/plugin-node-resolve": "^16.0.1",
+    "@rollup/plugin-typescript": "^12.1.2",
+    "@types/jest": "^29.5.14",
+    "@types/node": "^22.13.14",
+    "cz-conventional-changelog": "^3.3.0",
+    "dotenv": "^16.4.7",
+    "jest": "^29.7.0",
+    "rollup": "^4.37.0",
+    "rollup-plugin-peer-deps-external": "^2.2.4",
+    "semantic-release": "^24.0.0",
+    "ts-jest": "^29.3.0",
+    "ts-node": "^10.9.2",
+    "tslib": "^2.8.1",
+    "typescript": "^5.8.2"
+  },
+  "config": {
+    "commitizen": {
+      "path": "./node_modules/cz-conventional-changelog"
+    }
+  },
+  "precommit": [
+    "build"
+  ]
+}