zklib-ts/dist/ztcp.d.ts

Unofficial zkteco library allows Node.js developers to easily interface with ZK BioMetric Fingerprint Attendance Devices

import { Socket } from 'net';
import { RealTimeLog } from './helper/utils';
import { Finger } from './models/Finger';
import { UserService } from "./services/user.service";
import { TransactionService } from "./services/transaction.service";
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
    */
    ip: string;
    private port;
    timeout: number;
    sessionId: number;
    replyId: number;
    socket: Socket | undefined;
    private comm_key;
    private user_count;
    fp_count: number;
    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;
    userPacketSize: number;
    verbose: boolean;
    private packetNumber;
    private replyData;
    _userService: UserService;
    _transactionService: TransactionService;
    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<void>;
    /**
     *
     * @param {Buffer} reqData - indicate the type of data that need to receive ( user or attLog)
     * @param {Function} cb - callback is triggered when receiving packets
     *
     * readWithBuffer will reject error if it'wrong when starting request data
     * readWithBuffer will return { data: replyData , err: Error } when receiving requested data
     */
    readWithBuffer(reqData: Buffer | string, cb?: Function): Promise<Record<string, Buffer | number>>;
    /**
     *
     * @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>;
    getNetworkParams(): Promise<{
        IPAddress: string;
        NetMask: string;
        GATEIPAddress: 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>;
    getAttendanceSize(): Promise<number>;
    clearAttendanceLog(): Promise<boolean>;
    /**
     * Clears all data on the device
     * @value 1 Attendance records
     * @value 2 Fingerprint templates
     * @value 3 None
     * @value 4 Operation records
     * @value 5 User information
     * @default 0 Delete all
     */
    clearData(value?: number): Promise<boolean>;
    getRealTimeLogs(cb?: (realTimeLog: RealTimeLog) => void): Promise<void>;
    /**
     * Get all Finger objects
     * @returns {Record<string, Finger[]>}
     */
    getTemplates(callbackInProcess?: any): Promise<Record<string, Finger[]>>;
    /**
     * Return size
     * @param packet
     */
    testTcpTop(packet: any): any;
    refreshData(): Promise<boolean>;
    sendWithBuffer(buffer: Buffer): Promise<unknown>;
    sendChunk(commandString: Buffer): Promise<unknown>;
    readSocket(length: number, cb?: any): Promise<any>;
    /**
     * Register events
     * @param {number} flags - Event flags
     * @returns {Promise<void>}
     * @throws {ZKErrorResponse} If registration fails
     */
    regEvent(flags: number): Promise<void>;
    cancelCapture(): Promise<boolean>;
    restartDevice(): Promise<void>;
}