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";
import { OptionsService } from "./services/options.service";
export declare class ZTCP {
    #private;
    /**
     * @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;
    _optionsService: OptionsService;
    _transactionService: TransactionService;
    _userService: UserService;
    constructor(ip: string, port: number, timeout: number, comm_key: number, verbose: boolean);
    createSocket(cbError: (err: Error) => void, cbClose: (type: string) => void): Promise<unknown>;
    connect(): Promise<boolean>;
    closeSocket(): Promise<boolean>;
    writeMessage(msg: Buffer, connect: boolean, cb: (data: Buffer) => any): 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?: (received: number, total: number) => void): Promise<Record<string, Buffer | number | Error>>;
    /**
     *
     * @param {*} callbackInProcess
     *  reject error when starting request data
     *  return { data: records, err: Error } when receiving requested data
     */
    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;
    }>;
    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>;
}