njs-modbus 3.4.0 → 4.0.0

package/dist/index.d.ts

@@ -1,867 +0,0 @@
-import { SerialPort } from 'serialport';
-import { Socket, SocketConstructorOpts, SocketConnectOpts, Server, ServerOpts, ListenOptions } from 'node:net';
-import { Socket as Socket$1, SocketOptions, BindOptions } from 'node:dgram';
-import EventEmitter from 'node:events';
-
-type Callback$1<T> = (error: Error | null, value: T) => void;
-type MaybeAsyncFunction<F extends (...args: any) => any> = F extends (...args: infer A) => infer R ? ((...args: A) => Promise<R>) | ((...args: A) => R) : never;
-interface ApplicationDataUnit {
-    transaction?: number;
-    unit: number;
-    fc: number;
-    data: Buffer;
-}
-interface ServerId {
-    /** Server ID as a byte array (e.g. single-byte IDs use `[id]`). */
-    serverId?: number[];
-    runIndicatorStatus?: boolean;
-    /** Additional data bytes. Using Buffer avoids intermediate array conversions. */
-    additionalData?: Buffer;
-}
-interface DeviceIdentification {
-    readDeviceIDCode: number;
-    conformityLevel: number;
-    moreFollows: boolean;
-    nextObjectId: number;
-    objects: {
-        id: number;
-        value: string;
-    }[];
-}
-/**
- * Defines a non-standard / user-defined Modbus function code.
- *
- * Registration paths:
- * - `RtuApplicationLayer.addCustomFunctionCode(cfc)` — framing only.
- * - `ModbusSlave.addCustomFunctionCode(cfc)` — framing + slave-side dispatch via `handle`.
- * - `ModbusMaster.addCustomFunctionCode(cfc)` + `ModbusMaster.sendCustomFC(...)` — framing + request issuance.
- *
- * The two `predict*` callbacks declare how to derive the total RTU frame length
- * (PDU + 2-byte CRC) from leading bytes; they are required so the framing FSM
- * can advance without the deleted sliding-window CRC fallback.
- *
- * Return `0` (`PREDICT_NEED_MORE`) to signal "need more bytes before I can decide".
- * Return `-1` (`PREDICT_UNKNOWN`) to signal "cannot determine the length".
- * Return a positive integer (>= 4, <= 256) for the total frame length.
- */
-interface CustomFunctionCode {
-    fc: number;
-    /**
-     * Predict total RTU frame length for an incoming request (slave-side framing).
-     *
-     * @param getByte — Zero-based accessor; `getByte(i)` returns the byte at offset
-     *   `i` within the candidate frame (0 = unit ID, 1 = function code, …).
-     * @param length — Number of bytes available so far. Use this for bounds checks
-     *   rather than any buffer property.
-     * @returns Total frame length (>= 4, <= 256), `0` if more bytes are needed,
-     *   or `-1` if the length cannot be determined.
-     */
-    predictRequestLength: (getByte: (idx: number) => number, length: number) => number;
-    /**
-     * Predict total RTU frame length for an incoming response (master-side framing).
-     *
-     * @param getByte — Zero-based accessor; `getByte(i)` returns the byte at offset
-     *   `i` within the candidate frame (0 = unit ID, 1 = function code, …).
-     * @param length — Number of bytes available so far. Use this for bounds checks
-     *   rather than any buffer property.
-     * @returns Total frame length (>= 4, <= 256), `0` if more bytes are needed,
-     *   or `-1` if the length cannot be determined.
-     */
-    predictResponseLength: (getByte: (idx: number) => number, length: number) => number;
-    /**
-     * Slave-side handler. Receives PDU payload (bytes after `fc`, before CRC) and
-     * the unit ID being addressed; must return the PDU payload of the response.
-     *
-     * Throwing inside `handle` is turned into a Modbus exception response by the slave.
-     * If `handle` is omitted, the slave returns an ILLEGAL_FUNCTION exception for this FC.
-     */
-    handle?: MaybeAsyncFunction<(data: Buffer, unit: number) => Buffer>;
-}
-
-declare enum ErrorCode {
-    ILLEGAL_FUNCTION = 1,
-    ILLEGAL_DATA_ADDRESS = 2,
-    ILLEGAL_DATA_VALUE = 3,
-    SERVER_DEVICE_FAILURE = 4,
-    ACKNOWLEDGE = 5,
-    SERVER_DEVICE_BUSY = 6,
-    MEMORY_PARITY_ERROR = 8,
-    GATEWAY_PATH_UNAVAILABLE = 10,
-    GATEWAY_TARGET_DEVICE_FAILED_TO_RESPOND = 11
-}
-declare class ModbusError extends Error {
-    readonly code: ErrorCode;
-    constructor(code: ErrorCode, message?: string);
-}
-declare function getErrorByCode(code: ErrorCode): ModbusError;
-declare function getCodeByError(err: Error): ErrorCode;
-
-/**
- * Standard Modbus function codes (V1.1b3 §6).
- */
-declare enum FunctionCode {
-    READ_COILS = 1,
-    READ_DISCRETE_INPUTS = 2,
-    READ_HOLDING_REGISTERS = 3,
-    READ_INPUT_REGISTERS = 4,
-    WRITE_SINGLE_COIL = 5,
-    WRITE_SINGLE_REGISTER = 6,
-    WRITE_MULTIPLE_COILS = 15,
-    WRITE_MULTIPLE_REGISTERS = 16,
-    REPORT_SERVER_ID = 17,
-    MASK_WRITE_REGISTER = 22,
-    READ_WRITE_MULTIPLE_REGISTERS = 23,
-    READ_DEVICE_IDENTIFICATION = 43
-}
-/** Exception response FC = request FC | EXCEPTION_OFFSET (V1.1b3 §7). */
-declare const EXCEPTION_OFFSET = 128;
-/** Coil value encoding for FC 5 / FC 15 (V1.1b3 §6.5/§6.11). */
-declare const COIL_ON = 65280;
-declare const COIL_OFF = 0;
-/** FC 0x2B MEI sub-function selecting Read Device Identification (V1.1b3 §6.21). */
-declare const MEI_READ_DEVICE_ID = 14;
-/** Read Device ID code values inside an FC 0x2B / MEI 0x0E request. */
-declare enum ReadDeviceIDCode {
-    BASIC_STREAM = 1,
-    REGULAR_STREAM = 2,
-    EXTENDED_STREAM = 3,
-    SPECIFIC_ACCESS = 4
-}
-/** Conformity level reported in an FC 0x2B / MEI 0x0E response. */
-declare enum ConformityLevel {
-    BASIC = 129,
-    REGULAR = 130,
-    EXTENDED = 131
-}
-/** Shared empty Buffer to avoid repeated allocations. */
-declare const EMPTY_BUFFER: Buffer<ArrayBuffer>;
-/** Shared no-op function to avoid repeated allocations. */
-declare const NOOP: () => void;
-/** Modbus V1.1b3 PDU quantity limits. */
-declare const LIMITS: {
-    readonly READ_COILS_MIN: 1;
-    readonly READ_COILS_MAX: 2000;
-    readonly READ_REGISTERS_MIN: 1;
-    readonly READ_REGISTERS_MAX: 125;
-    readonly WRITE_COILS_MAX: 1968;
-    readonly WRITE_REGISTERS_MAX: 123;
-    readonly RW_REGISTERS_WRITE_MAX: 121;
-};
-
-declare enum PhysicalState {
-    OPENING = "opening",
-    OPEN = "open",
-    CLOSING = "closing",
-    CLOSED = "closed"
-}
-declare enum PhysicalConnectionState {
-    CONNECTED = "connected",
-    DESTROYING = "destroying",
-    DESTROYED = "destroyed"
-}
-
-interface SerialPhysicalLayerOptions {
-    /** The system path of the serial port you want to open. For example, `/dev/tty.XXX` on Mac/Linux, or `COM1` on Windows */
-    path: string;
-    /**
-     * The baud rate of the port to be opened. This should match one of the commonly available baud rates, such as 110, 300, 1200, 2400, 4800, 9600, 14400, 19200, 38400, 57600, or 115200. Custom rates are supported best effort per platform. The device connected to the serial port is not guaranteed to support the requested baud rate, even if the port itself supports that baud rate.
-     */
-    baudRate: number;
-    /** Must be one of these: 5, 6, 7, or 8. Defaults to 8 */
-    dataBits?: 5 | 6 | 7 | 8;
-    /** Prevent other processes from opening the port. Windows does not currently support `false`. Defaults to true */
-    lock?: boolean;
-    /** Must be 1, 1.5 or 2. Defaults to 1 */
-    stopBits?: 1 | 1.5 | 2;
-    /** Device parity. Defaults to none */
-    parity?: 'none' | 'even' | 'odd' | 'mark' | 'space';
-    /** Flow control Setting. Defaults to false */
-    rtscts?: boolean;
-    /** Flow control Setting. Defaults to false */
-    xon?: boolean;
-    /** Flow control Setting. Defaults to false */
-    xoff?: boolean;
-    /** Flow control Setting. Defaults to false */
-    xany?: boolean;
-    /** drop DTR on close. Defaults to true */
-    hupcl?: boolean;
-    /** The size of the read and write buffers. Defaults to 64k */
-    highWaterMark?: number;
-    /** Emit 'end' on port close. Defaults to false */
-    endOnClose?: boolean;
-    /** see `man termios`. Defaults to 1 (Darwin/Linux only) */
-    vmin?: number;
-    /** see `man termios`. Defaults to 0 (Darwin/Linux only) */
-    vtime?: number;
-    /** RTS mode. Defaults to handshake (Windows only) */
-    rtsMode?: 'handshake' | 'enable' | 'toggle';
-}
-declare class SerialPhysicalLayer extends AbstractPhysicalLayer {
-    readonly TYPE: "SERIAL";
-    private _state;
-    private _connections;
-    private _serialport;
-    private _serialportOpts;
-    private _path;
-    private _baudRate;
-    private _pendingOpenCbs;
-    private _pendingCloseCbs;
-    private _cleanupFns;
-    get state(): PhysicalState;
-    get serialport(): SerialPort | null;
-    get path(): string;
-    get baudRate(): number;
-    constructor(options: SerialPhysicalLayerOptions);
-    open(cb?: (err?: Error | null) => void): void;
-    close(cb?: (err?: Error | null) => void): void;
-}
-
-declare class TcpClientPhysicalLayer extends AbstractPhysicalLayer {
-    readonly TYPE: "TCP_CLIENT";
-    private _state;
-    private _connections;
-    private _socket;
-    private _socketOpts?;
-    private _pendingOpenCbs;
-    private _pendingCloseCbs;
-    private _cleanupFns;
-    get state(): PhysicalState;
-    get socket(): Socket | null;
-    constructor(options?: SocketConstructorOpts);
-    open(cb?: (err?: Error | null) => void): void;
-    open(options: SocketConnectOpts, cb?: (err?: Error | null) => void): void;
-    close(cb?: (err?: Error | null) => void): void;
-}
-
-interface TcpServerPhysicalLayerOptions {
-    /** Allowed client IP addresses. IPv4-mapped IPv6 addresses (e.g., ::ffff:192.168.1.1) are normalized before checking. */
-    whitelist?: string[];
-    /** Maximum number of concurrent connections. When exceeded, new connections are silently dropped by Node.js. */
-    maxConnections?: number;
-    /** Idle timeout in ms. Connection is destroyed if no data is received within this time. 0 = disabled. */
-    idleTimeout?: number;
-    /** Forwarded to `net.createServer()`. */
-    serverOpts?: ServerOpts;
-}
-declare class TcpServerPhysicalLayer extends AbstractPhysicalLayer {
-    readonly TYPE: "TCP_SERVER";
-    private _state;
-    private _connections;
-    private _server;
-    private _opts;
-    private _pendingOpenCbs;
-    private _pendingCloseCbs;
-    private _cleanupFns;
-    get state(): PhysicalState;
-    get server(): Server | null;
-    constructor(options?: TcpServerPhysicalLayerOptions);
-    open(cb?: (err?: Error | null) => void): void;
-    open(options: ListenOptions, cb?: (err?: Error | null) => void): void;
-    close(cb?: (err?: Error | null) => void): void;
-}
-
-declare class UdpClientPhysicalLayer extends AbstractPhysicalLayer {
-    readonly TYPE: "UDP_CLIENT";
-    private _state;
-    private _connections;
-    private _socket;
-    private _socketOpts;
-    private _pendingOpenCbs;
-    private _pendingCloseCbs;
-    private _cleanupFns;
-    get state(): PhysicalState;
-    get socket(): Socket$1 | null;
-    constructor(options?: Partial<SocketOptions>);
-    open(cb?: (err?: Error | null) => void): void;
-    open(remote: {
-        port?: number;
-        address?: string;
-    }, cb?: (err?: Error | null) => void): void;
-    close(cb?: (err?: Error | null) => void): void;
-}
-
-interface UdpServerPhysicalLayerOptions {
-    /** Allowed client IP addresses. IPv4-mapped IPv6 addresses (e.g., ::ffff:192.168.1.1) are normalized before checking. */
-    whitelist?: string[];
-    /** Maximum number of concurrent virtual client connections. When exceeded, datagrams from new clients are silently ignored. */
-    maxConnections?: number;
-    /** Connection idle timeout in ms. Pass `0` to disable eviction. Defaults to 30000. */
-    idleTimeout?: number;
-    /** Forwarded to `dgram.createSocket()`. */
-    socketOpts?: Partial<SocketOptions>;
-}
-declare class UdpServerPhysicalLayer extends AbstractPhysicalLayer {
-    readonly TYPE: "UDP_SERVER";
-    private _state;
-    private _connections;
-    private _socket;
-    private _opts;
-    private _pendingOpenCbs;
-    private _pendingCloseCbs;
-    private _cleanupFns;
-    get state(): PhysicalState;
-    get socket(): Socket$1 | null;
-    constructor(options?: UdpServerPhysicalLayerOptions);
-    /**
-     * Bind the UDP socket and start accepting datagrams.
-     *
-     * @param options Bind options (port, address, etc.). Defaults to port 502.
-     * @param cb Callback invoked when binding completes or fails.
-     */
-    open(cb?: (err?: Error | null) => void): void;
-    open(options: BindOptions, cb?: (err?: Error | null) => void): void;
-    close(cb?: (err?: Error | null) => void): void;
-}
-
-interface AbstractPhysicalConnectionEvents {
-    data: [data: Buffer];
-    close: [];
-    /**
-     * Emitted when raw data has been successfully written to the wire.
-     * The `buffer` is a live reference — mutating it will corrupt the frame
-     * that the connection is still processing. Treat it as read-only.
-     */
-    tx: [buffer: Buffer];
-    /**
-     * Emitted when raw data is received from the wire.
-     * The `buffer` is a live reference — mutating it will corrupt the frame
-     * that the application layer is about to parse. Treat it as read-only.
-     */
-    rx: [buffer: Buffer];
-}
-/**
- * A one-way data transmission channel.
- *
- * State transitions are unidirectional: CONNECTED → DESTROYING → DESTROYED.
- * Once closed, the instance cannot be reused; create a new connection instead.
- */
-declare abstract class AbstractPhysicalConnection extends EventEmitter<AbstractPhysicalConnectionEvents> {
-    abstract readonly state: PhysicalConnectionState;
-    abstract readonly physicalLayer: AbstractPhysicalLayer;
-    abstract write(data: Buffer, cb?: (err?: Error | null) => void): void;
-    abstract destroy(cb?: (err?: Error | null) => void): void;
-}
-interface AbstractPhysicalLayerEvents {
-    open: [];
-    connect: [connection: AbstractPhysicalConnection];
-    close: [];
-    error: [error: Error];
-}
-/** Debug events emitted by individual connections and proxied through Master/Slave. */
-interface ConnectionDebugEvents {
-    /**
-     * Emitted when raw data has been successfully written to the wire.
-     * The `buffer` is a live reference — mutating it will corrupt the frame
-     * that the connection is still processing. Treat it as read-only.
-     */
-    tx: [buffer: Buffer, connection: AbstractPhysicalConnection];
-    /**
-     * Emitted when raw data is received from the wire.
-     * The `buffer` is a live reference — mutating it will corrupt the frame
-     * that the application layer is about to parse. Treat it as read-only.
-     */
-    rx: [buffer: Buffer, connection: AbstractPhysicalConnection];
-}
-/** Application-layer framing events emitted by Master/Slave per connection. */
-interface ConnectionApplicationEvents {
-    framing: [frame: ApplicationDataUnit & {
-        buffer: Buffer;
-    }, connection: AbstractPhysicalConnection];
-    framingError: [error: Error, connection: AbstractPhysicalConnection];
-}
-/**
- * An abstraction over local hardware or network resources.
- *
- * `open()` acquires the resource (serial port, TCP socket, UDP socket, etc.).
- * Once ready, it emits `connect` with an {@link AbstractPhysicalConnection},
- * unifying serial, TCP client, TCP server, and UDP under a single
- * "connection-oriented" model similar to a TCP server accepting sockets.
- */
-declare abstract class AbstractPhysicalLayer extends EventEmitter<AbstractPhysicalLayerEvents> {
-    abstract readonly TYPE: 'SERIAL' | 'TCP_CLIENT' | 'TCP_SERVER' | 'UDP_CLIENT' | 'UDP_SERVER';
-    is(type: 'SERIAL'): this is SerialPhysicalLayer;
-    is(type: 'TCP_CLIENT'): this is TcpClientPhysicalLayer;
-    is(type: 'TCP_SERVER'): this is TcpServerPhysicalLayer;
-    is(type: 'UDP_CLIENT'): this is UdpClientPhysicalLayer;
-    is(type: 'UDP_SERVER'): this is UdpServerPhysicalLayer;
-    abstract readonly state: PhysicalState;
-    /** Last argument is the callback: `(err?: Error | null) => void`. Callback is optional. */
-    abstract open(...args: any[]): void;
-    abstract close(cb?: (err?: Error | null) => void): void;
-}
-
-type PhysicalConfig = {
-    type: 'SERIAL';
-    opts: SerialPhysicalLayerOptions;
-} | {
-    type: 'TCP_CLIENT';
-    socketOpts?: SocketConstructorOpts;
-} | {
-    type: 'TCP_SERVER';
-    opts?: TcpServerPhysicalLayerOptions;
-} | {
-    type: 'UDP_CLIENT';
-    socketOpts?: Partial<SocketOptions>;
-} | {
-    type: 'UDP_SERVER';
-    opts?: UdpServerPhysicalLayerOptions;
-} | {
-    type: 'CUSTOM';
-    layer: AbstractPhysicalLayer;
-};
-/**
- * User-facing arguments for `Master.open()` / `Slave.open()`.
- *
- * These match the physical layer's `open()` signatures **without** the trailing
- * callback — `promisifyCb` appends it internally so the user gets a `Promise`.
- *
- * | Config        | User-facing args                     |
- * |---------------|--------------------------------------|
- * | SERIAL        | `()` — configured at construction    |
- * | TCP_CLIENT    | `(opts?)` — `SocketConnectOpts`      |
- * | TCP_SERVER    | `(opts?)` — `ListenOptions`          |
- * | UDP_CLIENT    | `(remote?)` — `{ port?, address? }`  |
- * | UDP_SERVER    | `(opts?)` — `BindOptions`            |
- * | CUSTOM        | `never` — call `layer.open()` directly |
- */
-type OpenArgs<T extends PhysicalConfig> = T extends {
-    type: 'SERIAL';
-} ? [] : T extends {
-    type: 'TCP_CLIENT';
-} ? [options?: SocketConnectOpts] : T extends {
-    type: 'TCP_SERVER';
-} ? [options?: ListenOptions] : T extends {
-    type: 'UDP_CLIENT';
-} ? [remote?: {
-    port?: number;
-    address?: string;
-}] : T extends {
-    type: 'UDP_SERVER';
-} ? [options?: BindOptions] : never;
-declare function createPhysicalLayer(config: PhysicalConfig): AbstractPhysicalLayer;
-
-/**
- * Application-layer protocol handler bound to a single physical connection.
- *
- * Its lifetime follows the channel: created when the underlying connection is
- * established and discarded when the connection closes. Subclasses implement
- * ASCII, RTU, or TCP framing rules.
- */
-declare abstract class AbstractApplicationLayer {
-    abstract readonly PROTOCOL: 'ASCII' | 'RTU' | 'TCP';
-    abstract ROLE: 'MASTER' | 'SLAVE';
-    abstract readonly connection: AbstractPhysicalConnection;
-    /** Called when a complete frame is decoded. Defaults to no-op. */
-    onFraming: (frame: ApplicationDataUnit & {
-        buffer: Buffer;
-    }) => void;
-    /** Called when a framing error is detected. Defaults to no-op. */
-    onFramingError: (error: Error) => void;
-    flush(): void;
-    addCustomFunctionCode(cfc: CustomFunctionCode): void;
-    removeCustomFunctionCode(fc: number): void;
-    abstract encode(unit: number, fc: number, data: Buffer, transaction?: number): Buffer;
-}
-
-interface AsciiApplicationLayerOptions {
-    /**
-     * Accept lowercase hex digits (`a-f`) in addition to uppercase (`A-F`).
-     * Default false (strict per Modbus V1.1b3 §2.2 — uppercase only).
-     * Non-hex characters are always rejected with a `framing-error`.
-     */
-    lenientHex?: boolean;
-}
-declare class AsciiApplicationLayer extends AbstractApplicationLayer {
-    readonly PROTOCOL: "ASCII";
-    readonly ROLE: 'MASTER' | 'SLAVE';
-    private _connection;
-    private _state;
-    private _cleanupCbs;
-    get connection(): AbstractPhysicalConnection;
-    constructor(role: 'MASTER' | 'SLAVE', connection: AbstractPhysicalConnection, options?: AsciiApplicationLayerOptions);
-    private framing;
-    flush(): void;
-    encode(unit: number, fc: number, data: Buffer, transaction?: number): Buffer;
-}
-
-interface RtuApplicationLayerOptions {
-    /** Inter-frame silence in milliseconds (Modbus RTU t3.5). 0 = disabled (immediate parse). */
-    intervalBetweenFrames?: number;
-    /** Inter-character timeout in milliseconds (Modbus RTU t1.5). Opt-in. */
-    interCharTimeout?: number;
-    /**
-     * Enforces strict Modbus RTU timing. When true, any frame containing a t1.5
-     * inter-character timeout event will be discarded immediately, even if the CRC16 is valid.
-     * @default false
-     */
-    strictTiming?: boolean;
-}
-declare class RtuApplicationLayer extends AbstractApplicationLayer {
-    readonly PROTOCOL: "RTU";
-    readonly ROLE: 'MASTER' | 'SLAVE';
-    private _connection;
-    private _residual;
-    private _residualLen;
-    private _expectedLen;
-    private _t15Time;
-    private _t35Time;
-    private _t15Strict;
-    private _t15Timer?;
-    private _t35Timer?;
-    private _t15Marker;
-    private _customFunctionCodes;
-    private _cleanupCbs;
-    get connection(): AbstractPhysicalConnection;
-    constructor(role: 'MASTER' | 'SLAVE', connection: AbstractPhysicalConnection, options?: RtuApplicationLayerOptions);
-    flush(): void;
-    addCustomFunctionCode(cfc: CustomFunctionCode): void;
-    removeCustomFunctionCode(fc: number): void;
-    encode(unit: number, fc: number, data: Buffer, transaction?: number): Buffer;
-}
-
-declare class TcpApplicationLayer extends AbstractApplicationLayer {
-    readonly PROTOCOL: "TCP";
-    readonly ROLE: 'MASTER' | 'SLAVE';
-    private _connection;
-    private _transactionId;
-    private _residual;
-    private _residualLen;
-    private _expectedLen;
-    private _cleanupCbs;
-    get connection(): AbstractPhysicalConnection;
-    constructor(role: 'MASTER' | 'SLAVE', connection: AbstractPhysicalConnection);
-    flush(): void;
-    encode(unit: number, fc: number, data: Buffer, transaction?: number): Buffer;
-}
-
-/**
- * RTU timing parameter — accepts either:
- * - a bare `number` in milliseconds (`0` to disable the timer entirely)
- * - `{ unit: 'ms', value: N }` — explicit milliseconds (equivalent to bare `N`)
- * - `{ unit: 'bit', value: N }` — bit-time approximation, derived from `baudRate`
- *
- * The bare-number form is the recommended default; the object form exists for
- * specs that quote bit-time. Pass `0` (or `{ unit: 'ms', value: 0 }`) to disable
- * the timer; either form short-circuits the baudRate-derived fallback.
- */
-type RtuTimingValue = number | {
-    unit: 'bit' | 'ms';
-    value: number;
-};
-/** User-facing RTU protocol options (supports both bit and ms units). */
-interface RtuProtocolOptions {
-    /**
-     * Inter-frame silence (Modbus RTU t3.5).
-     *
-     * - `20` or `{ unit: 'ms', value: 20 }` — 20 ms
-     * - `{ unit: 'bit', value: 38.5 }` — spec bit-time approximation (default when `baudRate` is provided)
-     * - `0` — disable t3.5 timing (immediate parse on every chunk; useful for
-     *   lossless transports such as RTU-over-TCP or PTY-based tests where the
-     *   wire's silence semantics do not apply)
-     *
-     * Per Modbus V1.02 §2.5.1.1, at baud rates > 19200 a fixed 1.75 ms is used
-     * regardless of the bit value.
-     */
-    intervalBetweenFrames?: RtuTimingValue;
-    /**
-     * Inter-character timeout (Modbus RTU t1.5). Opt-in; **disabled** by default.
-     *
-     * - `1` or `{ unit: 'ms', value: 1 }` — 1 ms
-     * - `{ unit: 'bit', value: 21 }` — bit-time approximation (~1.5 char times)
-     * - `0` — disable explicitly
-     *
-     * Per Modbus V1.02 §2.5.1.1, at baud rates > 19200 a fixed 0.75 ms is used
-     * regardless of the bit value.
-     */
-    interCharTimeout?: RtuTimingValue;
-    /**
-     * Enforces strict Modbus RTU timing. When true, any frame containing a t1.5
-     * inter-character timeout event will be discarded immediately, even if the
-     * CRC16 is valid.
-     * @default false
-     */
-    strictTiming?: boolean;
-}
-
-interface ReturnValue<T> {
-    transaction?: number;
-    unit: number;
-    fc: number;
-    data: T;
-    buffer: Buffer;
-}
-interface ModbusMasterOptions {
-    /** Per-request timeout in ms. Default 1000. */
-    timeout?: number;
-    /**
-     * Enable pipelined concurrent requests on a single connection.
-     * Only valid for Modbus TCP application layer.
-     * Default false (FIFO queue, requests are serialized).
-     */
-    concurrent?: boolean;
-    physical: PhysicalConfig;
-    protocol: {
-        type: 'RTU';
-        opts?: RtuProtocolOptions;
-    } | {
-        type: 'TCP';
-    } | {
-        type: 'ASCII';
-        opts?: AsciiApplicationLayerOptions;
-    };
-}
-declare class ModbusMaster<T extends ModbusMasterOptions = ModbusMasterOptions> extends EventEmitter<AbstractPhysicalLayerEvents & ConnectionDebugEvents & ConnectionApplicationEvents> {
-    readonly timeout: number;
-    readonly concurrent: boolean;
-    private _masterSession;
-    private _physicalLayer;
-    private _protocol;
-    private _appLayer?;
-    private _customFunctionCodes;
-    private _queueUnits;
-    private _queueFcs;
-    private _queueDatas;
-    private _queueTimeouts;
-    private _queueBroadcasts;
-    private _queueCallbacks;
-    private _queueHead;
-    private _queueLen;
-    private _draining;
-    private _nextTid;
-    private _cleanupFns;
-    private _closePromise;
-    private _nextExchangeId;
-    private _pendingExchanges;
-    private _timerHeap;
-    get state(): PhysicalState;
-    get physicalLayer(): AbstractPhysicalLayer;
-    constructor(options: T);
-    private _createAppLayer;
-    private _send;
-    private _drain;
-    private _processNext;
-    private _exchange;
-    private writeFC1Or2;
-    writeFC1: this['readCoils'];
-    readCoils(unit: 0, address: number, length: number, timeout?: number): Promise<void>;
-    readCoils(unit: number, address: number, length: number, timeout?: number): Promise<ReturnValue<Uint8Array>>;
-    writeFC2: this['readDiscreteInputs'];
-    readDiscreteInputs(unit: 0, address: number, length: number, timeout?: number): Promise<void>;
-    readDiscreteInputs(unit: number, address: number, length: number, timeout?: number): Promise<ReturnValue<Uint8Array>>;
-    private writeFC3Or4;
-    writeFC3: this['readHoldingRegisters'];
-    readHoldingRegisters(unit: 0, address: number, length: number, timeout?: number): Promise<void>;
-    readHoldingRegisters(unit: number, address: number, length: number, timeout?: number): Promise<ReturnValue<number[]>>;
-    writeFC4: this['readInputRegisters'];
-    readInputRegisters(unit: 0, address: number, length: number, timeout?: number): Promise<void>;
-    readInputRegisters(unit: number, address: number, length: number, timeout?: number): Promise<ReturnValue<number[]>>;
-    writeFC5: this['writeSingleCoil'];
-    writeSingleCoil(unit: 0, address: number, value: number, timeout?: number): Promise<void>;
-    writeSingleCoil(unit: number, address: number, value: number, timeout?: number): Promise<ReturnValue<number>>;
-    writeFC6: this['writeSingleRegister'];
-    writeSingleRegister(unit: 0, address: number, value: number, timeout?: number): Promise<void>;
-    writeSingleRegister(unit: number, address: number, value: number, timeout?: number): Promise<ReturnValue<number>>;
-    writeFC15: this['writeMultipleCoils'];
-    writeMultipleCoils(unit: 0, address: number, value: Uint8Array, timeout?: number): Promise<void>;
-    writeMultipleCoils(unit: number, address: number, value: Uint8Array, timeout?: number): Promise<ReturnValue<Uint8Array>>;
-    writeFC16: this['writeMultipleRegisters'];
-    writeMultipleRegisters(unit: 0, address: number, value: number[], timeout?: number): Promise<void>;
-    writeMultipleRegisters(unit: number, address: number, value: number[], timeout?: number): Promise<ReturnValue<number[]>>;
-    handleFC17: this['reportServerId'];
-    reportServerId(unit: 0, serverIdLength?: number, timeout?: number): Promise<void>;
-    reportServerId(unit: number, serverIdLength?: number, timeout?: number): Promise<ReturnValue<ServerId>>;
-    handleFC22: this['maskWriteRegister'];
-    maskWriteRegister(unit: 0, address: number, andMask: number, orMask: number, timeout?: number): Promise<void>;
-    maskWriteRegister(unit: number, address: number, andMask: number, orMask: number, timeout?: number): Promise<ReturnValue<{
-        andMask: number;
-        orMask: number;
-    }>>;
-    handleFC23: this['readAndWriteMultipleRegisters'];
-    readAndWriteMultipleRegisters(unit: 0, read: {
-        address: number;
-        length: number;
-    }, write: {
-        address: number;
-        value: number[];
-    }, timeout?: number): Promise<void>;
-    readAndWriteMultipleRegisters(unit: number, read: {
-        address: number;
-        length: number;
-    }, write: {
-        address: number;
-        value: number[];
-    }, timeout?: number): Promise<ReturnValue<number[]>>;
-    handleFC43_14: this['readDeviceIdentification'];
-    readDeviceIdentification(unit: 0, readDeviceIDCode: number, objectId: number, timeout?: number): Promise<void>;
-    readDeviceIdentification(unit: number, readDeviceIDCode: number, objectId: number, timeout?: number): Promise<ReturnValue<DeviceIdentification>>;
-    addCustomFunctionCode(cfc: CustomFunctionCode): void;
-    removeCustomFunctionCode(fc: number): void;
-    sendCustomFC(unit: 0, fc: number, data: Buffer | number[], timeout?: number): Promise<void>;
-    sendCustomFC(unit: number, fc: number, data: Buffer | number[], timeout?: number): Promise<Buffer>;
-    /**
-     * Open the underlying physical layer and establish a connection.
-     *
-     * A `ModbusMaster` instance can only be opened once. Once {@link close}
-     * is called — explicitly or because the physical layer disconnected —
-     * the instance is permanently closed and cannot be reopened.
-     * Create a new `ModbusMaster` if a new connection is required.
-     */
-    open(...args: OpenArgs<T['physical']>): Promise<void>;
-    private _close;
-    /**
-     * Permanently close the master and release all resources.
-     *
-     * After calling this method the instance is considered dead:
-     * - No further requests can be sent.
-     * - The instance cannot be reopened via {@link open}.
-     * - All event listeners registered on this master are removed.
-     */
-    close(): Promise<void>;
-}
-
-type Frame = ApplicationDataUnit & {
-    buffer: Buffer;
-};
-type Callback = (error: Error | null, frame?: Frame) => void;
-declare class MasterSession {
-    private _waiters;
-    /** Register a callback for `key`. No timer — timeout is managed by the caller. */
-    start(key: string | number, callback: Callback): void;
-    /** Cancel a pending waiter without firing its callback. */
-    stop(key: string | number): void;
-    stopAll(error: Error): void;
-    has(key: string | number): boolean;
-    handleFrame(frame: Frame): void;
-    handleError(error: Error): void;
-}
-
-interface ModbusSlaveModel {
-    unit?: number;
-    /**
-     * Intercept read and write behavior.
-     *
-     * If provide the return value, use this value as data of `PDU` to respond.
-     * Otherwise keep the default read and write behavior.
-     */
-    interceptor?: MaybeAsyncFunction<(fc: number, data: Buffer) => Buffer | undefined>;
-    readDiscreteInputs?: MaybeAsyncFunction<(address: number, length: number) => Uint8Array>;
-    readCoils?: MaybeAsyncFunction<(address: number, length: number) => Uint8Array>;
-    writeSingleCoil?: MaybeAsyncFunction<(address: number, value: number) => void>;
-    /**
-     * If omitted, defaults to loop and call `writeSingleCoil`.
-     */
-    writeMultipleCoils?: MaybeAsyncFunction<(address: number, value: Uint8Array) => void>;
-    /** Return `Uint16Array` to avoid the `Array.from` allocation overhead. */
-    readInputRegisters?: MaybeAsyncFunction<(address: number, length: number) => number[] | Uint16Array>;
-    /** Return `Uint16Array` to avoid the `Array.from` allocation overhead. */
-    readHoldingRegisters?: MaybeAsyncFunction<(address: number, length: number) => number[] | Uint16Array>;
-    writeSingleRegister?: MaybeAsyncFunction<(address: number, value: number) => void>;
-    /**
-     * If omitted, defaults to loop and call `writeSingleRegister`.
-     */
-    writeMultipleRegisters?: MaybeAsyncFunction<(address: number, value: number[]) => void>;
-    /**
-     * If omitted, defaults to call `readHoldingRegisters` and `writeSingleRegister`.
-     */
-    maskWriteRegister?: MaybeAsyncFunction<(address: number, andMask: number, orMask: number) => void>;
-    reportServerId?: MaybeAsyncFunction<() => ServerId>;
-    readDeviceIdentification?: MaybeAsyncFunction<() => {
-        [index: number]: string;
-    }>;
-    getAddressRange?: () => {
-        discreteInputs?: [number, number] | [number, number][];
-        coils?: [number, number] | [number, number][];
-        inputRegisters?: [number, number] | [number, number][];
-        holdingRegisters?: [number, number] | [number, number][];
-    };
-}
-interface ModbusSlaveOptions {
-    /**
-     * Pipelined concurrent processing of requests within one connection.
-     * Only valid for Modbus TCP application layer (TID disambiguates responses).
-     * Default false — per-connection FIFO. RTU/ASCII + concurrent=true throws.
-     */
-    concurrent?: boolean;
-    physical: PhysicalConfig;
-    protocol: {
-        type: 'RTU';
-        opts?: RtuProtocolOptions;
-    } | {
-        type: 'TCP';
-    } | {
-        type: 'ASCII';
-        opts?: AsciiApplicationLayerOptions;
-    };
-}
-declare class ModbusSlave<T extends ModbusSlaveOptions = ModbusSlaveOptions> extends EventEmitter<AbstractPhysicalLayerEvents & ConnectionDebugEvents & ConnectionApplicationEvents> {
-    readonly models: Map<number, ModbusSlaveModel>;
-    readonly concurrent: boolean;
-    private _physicalLayer;
-    private _protocol;
-    private _appLayers;
-    private _customFunctionCodes;
-    private _intervalLocks;
-    private _cleanupFns;
-    private _closePromise;
-    get state(): PhysicalState;
-    get physicalLayer(): AbstractPhysicalLayer;
-    constructor(options: T);
-    private _createAppLayer;
-    private handleFC1;
-    private handleFC2;
-    private handleFC3;
-    private handleFC4;
-    private handleFC5;
-    private handleFC6;
-    private handleFC15;
-    private handleFC16;
-    private handleFC17;
-    private handleFC22;
-    private handleFC23;
-    private handleFC43_14;
-    private responseError;
-    private _drain;
-    private _processFrame;
-    private _intercept;
-    /**
-     * Serialize a code block over the half-open address interval `[lo, hi)`.
-     * The block runs after all previously-installed locks whose intervals
-     * overlap with this one have completed. Two non-overlapping intervals
-     * execute in parallel.
-     *
-     * Locks are tracked in a flat array (`_intervalLocks`); the typical depth
-     * is 0-2 entries, so the linear overlap scan is sub-µs. Compare with the
-     * old per-address Map design, where FC23 writing 121 registers allocated
-     * ~125 objects per request (one Promise.resolve / address + Set + sort +
-     * Promise.all); this version allocates 1-3.
-     */
-    private _withIntervalLock;
-    private _handleFC;
-    private _handleCustomFC;
-    add(model: ModbusSlaveModel): void;
-    remove(unit: number): void;
-    addCustomFunctionCode(cfc: CustomFunctionCode): void;
-    removeCustomFunctionCode(fc: number): void;
-    /**
-     * Open the underlying physical layer and begin accepting connections.
-     *
-     * A `ModbusSlave` instance can only be opened once. Once {@link close}
-     * is called — explicitly or because the physical layer disconnected —
-     * the instance is permanently closed and cannot be reopened.
-     * Create a new `ModbusSlave` if a new server is required.
-     */
-    open(...args: OpenArgs<T['physical']>): Promise<void>;
-    private _close;
-    /**
-     * Permanently close the slave and release all resources.
-     *
-     * After calling this method the instance is considered dead:
-     * - No further requests can be processed.
-     * - The instance cannot be reopened via {@link open}.
-     * - All event listeners registered on this slave are removed.
-     */
-    close(): Promise<void>;
-}
-
-export { AbstractApplicationLayer, AbstractPhysicalConnection, AbstractPhysicalLayer, AsciiApplicationLayer, COIL_OFF, COIL_ON, ConformityLevel, EMPTY_BUFFER, EXCEPTION_OFFSET, ErrorCode, FunctionCode, LIMITS, MEI_READ_DEVICE_ID, MasterSession, ModbusError, ModbusMaster, ModbusSlave, NOOP, PhysicalConnectionState, PhysicalState, ReadDeviceIDCode, RtuApplicationLayer, SerialPhysicalLayer, TcpApplicationLayer, TcpClientPhysicalLayer, TcpServerPhysicalLayer, UdpClientPhysicalLayer, UdpServerPhysicalLayer, createPhysicalLayer, getCodeByError, getErrorByCode };
-export type { AbstractPhysicalLayerEvents, ApplicationDataUnit, AsciiApplicationLayerOptions, Callback$1 as Callback, ConnectionApplicationEvents, ConnectionDebugEvents, CustomFunctionCode, DeviceIdentification, MaybeAsyncFunction, ModbusMasterOptions, ModbusSlaveModel, ModbusSlaveOptions, OpenArgs, PhysicalConfig, RtuApplicationLayerOptions, ServerId, TcpServerPhysicalLayerOptions, UdpServerPhysicalLayerOptions };