import { EventEmitter } from "node:events";
import { SerialPort, SerialPortOpenOptions } from "serialport";
import { HCPPacket, PacketFilterParams } from "./parser";
import { AutoDetectTypes } from "@serialport/bindings-cpp";
export declare enum STATUS_RESPONSE_BYTE0_BITFIELD {
    OPEN = 0,
    CLOSE = 1,
    REVERSE = 2,
    TOGGLE_LIGHT = 3,
    VENTING = 4
}
export declare enum DIRECTION {
    OPENING = 0,
    CLOSING = 1
}
export declare enum BROADCAST_STATUS_BYTE0_BITFIELD {
    DOOR_CLOSED = 0,
    DOOR_OPENED = 1,
    EXT_RELAY_ON = 2,
    LIGHT_RELAY_ON = 3,
    ERROR_ACTIVE = 4,
    DOOR_DIRECTION = 5,
    DOOR_MOVING = 6,
    DOOR_VENTING = 7
}
export interface ResponsePayload {
    payload: number[];
    counter?: number;
    resolve: (value: HCPPacket) => void;
    reject?: (reason?: string) => void;
}
export interface SerialOptions extends Omit<SerialPortOpenOptions<AutoDetectTypes>, "baudRate"> {
    baudRate?: number;
}
export interface HCPClient {
    /** Hormann Communication Protocol client
     * should emit 'data' event whenever a broadcast status packet is received from the driver
     * should implement a 'pushCommand' to be able to operate the door driver
     */
    readonly listenOnly: boolean;
    emit(event: "data", data: Uint8Array): boolean;
    on(event: "data", listener: (data: Uint8Array) => void): this;
    pushCommand(flags: STATUS_RESPONSE_BYTE0_BITFIELD[], emergencyStop?: boolean): Promise<HCPPacket>;
}
export declare class SerialHCPClient extends EventEmitter implements HCPClient {
    private readonly parser;
    readonly listenOnly: boolean;
    port: SerialPort;
    nextMessageCounter: number;
    sendQueue: ResponsePayload[];
    constructor({ path, baudRate, ...rest }: SerialOptions, parserOptions?: PacketFilterParams, listenOnly?: boolean);
    private onOpen;
    private onClose;
    private onError;
    private onNewPacket;
    static extractBitfield(byte: number): boolean[];
    static createSlaveStatusPayload(flags: STATUS_RESPONSE_BYTE0_BITFIELD[], emergencyStop?: boolean): number[];
    static getNextCounter(counter: number): number;
    open(): void;
    close(): void;
    sendBreak(delay: number, callback: () => void): void;
    sendPacket(packet: HCPPacket, delay?: number): Promise<void>;
    processMessage(packet: HCPPacket): ResponsePayload | null;
    static unpackBroadcast(packet: HCPPacket): Uint8Array;
    processSlaveCommand(packet: HCPPacket): ResponsePayload;
    pushCommand(flags: STATUS_RESPONSE_BYTE0_BITFIELD[], emergencyStop?: boolean): Promise<HCPPacket>;
}