import { Transform, TransformCallback } from "stream";
export declare class HCPPacket extends Uint8Array {
    static fromBuffer(buffer: number[] | Uint8Array, validate?: boolean): HCPPacket;
    get address(): number;
    get lengthNibble(): number;
    get counterNibble(): number;
    get header(): Uint8Array;
    get payload(): Uint8Array;
    get crc(): number;
    private _validate;
    equals(other: Uint8Array | number[]): boolean;
    computeCRC(): number;
    isValid(): boolean;
    hex(): string;
    static fromData(addressByte: number, counterNibble: number, payload: number[] | Buffer | Uint8Array, crc?: number, validate?: boolean): HCPPacket;
}
export interface PacketFilterParams {
    packetTimeout?: number;
    filterMaxLength?: boolean;
    filterBreaks?: boolean;
}
export declare class PacketFilter extends Transform {
    /**
     * Filtering for valid chunks based on timing
     * and other HCP characteristics
     */
    buffer: Buffer;
    timeout: number;
    timer: NodeJS.Timeout | null;
    filterMaxLength: boolean;
    filterBreaks: boolean;
    constructor({ packetTimeout, filterMaxLength, filterBreaks, }?: PacketFilterParams);
    protected _initBuffer(): Buffer;
    protected _resetBuffer: () => void;
    _clearTimeout(): void;
    _filter(chunk: Buffer): Buffer;
    _transform(chunk: Buffer, encoding: BufferEncoding, callback: TransformCallback): void;
}
export declare class SimpleHCPPacketParser extends PacketFilter {
    /**
     * Iterates over read bytes one by one.
     * Drops all bytes if packet is invalid
     * So it can miss valid packets in case of glitches
     */
    started: boolean;
    offset: number;
    packetLength: number;
    constructor(options?: PacketFilterParams);
    _initBuffer(): Buffer;
    _resetBuffer: () => void;
    _resetPacket(): void;
    _parseCurrentByte(byte: number): boolean;
    _transform(chunk: Buffer, encoding: BufferEncoding, cb: TransformCallback): void;
}
export declare class BatchHCPPacketParser extends PacketFilter {
    /**
     * Iterates over each chunk of read bytes to find valid packet as early as possible
     * Might create false positive packets in case of CRC collision
     */
    offset: number;
    tested: boolean[];
    minUntestedIdx: number;
    constructor(options?: PacketFilterParams);
    _initBuffer(): Buffer;
    _resetBuffer: () => void;
    _resetTestedArray(): void;
    _pop_buffer(nbElements: number): void;
    _testPacket(offset: number, length: number): boolean;
    _testPacketRange(fromByteIdx: number, untilByteIdx: number): number;
    _transform(bytes: Buffer, _encoding: BufferEncoding, cb: TransformCallback): void;
}