njs-modbus 1.5.0 → 2.0.0

package/dist/index.d.ts

@@ -2,6 +2,61 @@ import EventEmitter from 'node:events';
 import { SocketConstructorOpts, SocketConnectOpts, NetConnectOpts, ListenOptions } from 'node:net';
 import { SocketOptions, BindOptions } from 'node:dgram';
 
+type Callback$1<T> = (error: Error | null, value: T) => void;
+type FConvertPromise<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; may be 1 byte (number) or multi-byte (number[]) per device spec. */
+    serverId?: number | number[];
+    runIndicatorStatus?: boolean;
+    additionalData?: number[];
+}
+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 `null` from a predictor to signal "need more bytes before I can decide".
+ * 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). */
+    predictRequestLength: (buffer: Buffer) => number | null;
+    /** Predict total RTU frame length for an incoming response (master-side framing). */
+    predictResponseLength: (buffer: Buffer) => number | null;
+    /**
+     * 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?: FConvertPromise<(data: Buffer, unit: number) => Buffer>;
+}
+
 declare enum ErrorCode {
     ILLEGAL_FUNCTION = 1,
     ILLEGAL_DATA_ADDRESS = 2,
@@ -13,13 +68,91 @@ declare enum ErrorCode {
     GATEWAY_PATH_UNAVAILABLE = 10,
     GATEWAY_TARGET_DEVICE_FAILED_TO_RESPOND = 11
 }
-declare function getErrorByCode(code: ErrorCode): Error;
+/** Internal error codes for programmatic error handling. */
+declare const ModbusErrorCode: {
+    readonly TIMEOUT: "ETIMEOUT";
+    readonly INVALID_RESPONSE: "EINVALID_RESPONSE";
+    readonly INSUFFICIENT_DATA: "EINSUFFICIENT_DATA";
+    readonly MASTER_CLOSED: "EMASTER_CLOSED";
+    readonly MASTER_DESTROYED: "EMASTER_DESTROYED";
+    readonly CONCURRENT_NOT_TCP: "ECONCURRENT_NOT_TCP";
+    readonly PORT_DESTROYED: "EPORT_DESTROYED";
+    readonly PORT_ALREADY_OPEN: "EPORT_ALREADY_OPEN";
+    readonly PORT_NOT_OPEN: "EPORT_NOT_OPEN";
+    readonly NOT_SUPPORTED: "ENOT_SUPPORTED";
+    readonly INVALID_DATA: "EINVALID_DATA";
+    readonly INVALID_HEX: "EINVALID_HEX";
+    readonly CRC_MISMATCH: "ECRC_MISMATCH";
+    readonly LRC_MISMATCH: "ELRC_MISMATCH";
+    readonly INCOMPLETE_FRAME: "EINCOMPLETE_FRAME";
+    readonly T1_5_EXCEEDED: "ET1_5_EXCEEDED";
+    readonly UNKNOWN_FC: "EUNKNOWN_FC";
+    readonly INVALID_ROLE: "EINVALID_ROLE";
+    readonly RANGE: "ERANGE";
+};
+declare class ModbusError extends Error {
+    readonly code: string;
+    constructor(code: string, 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
+}
+/** 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;
+};
+
+interface PhysicalConnection {
+    readonly id: string | number;
+}
 interface AbstractPhysicalLayerEvents {
-    data: [data: Buffer, response: (data: Buffer) => Promise<void>];
+    data: [data: Buffer, response: (data: Buffer) => Promise<void>, connection: PhysicalConnection];
     write: [data: Buffer];
     error: [error: Error];
+    'connection-close': [connection: PhysicalConnection];
     close: [];
 }
 declare abstract class AbstractPhysicalLayer extends EventEmitter<AbstractPhysicalLayerEvents> {
@@ -60,6 +193,8 @@ interface SerialPhysicalLayerOptions {
 declare class SerialPhysicalLayer extends AbstractPhysicalLayer {
     TYPE: 'SERIAL' | 'NET';
     private _serialport;
+    private _connection;
+    private _isOpening;
     private _destroyed;
     private _baudRate;
     get isOpen(): boolean;
@@ -75,8 +210,11 @@ declare class SerialPhysicalLayer extends AbstractPhysicalLayer {
 declare class TcpClientPhysicalLayer extends AbstractPhysicalLayer {
     TYPE: 'SERIAL' | 'NET';
     private _socket;
+    private _connection;
     private _isOpen;
+    private _isOpening;
     private _destroyed;
+    private _socketOptions?;
     get isOpen(): boolean;
     get destroyed(): boolean;
     constructor(options?: SocketConstructorOpts);
@@ -90,8 +228,10 @@ declare class TcpServerPhysicalLayer extends AbstractPhysicalLayer {
     TYPE: 'SERIAL' | 'NET';
     private _server;
     private _isOpen;
+    private _isOpening;
     private _destroyed;
-    private _sockets;
+    private _connections;
+    private _serverOptions?;
     get isOpen(): boolean;
     get destroyed(): boolean;
     constructor(options?: NetConnectOpts);
@@ -101,123 +241,151 @@ declare class TcpServerPhysicalLayer extends AbstractPhysicalLayer {
     destroy(): Promise<void>;
 }
 
+interface UdpPhysicalLayerOptions {
+    /** dgram Socket creation options. */
+    socket?: Partial<SocketOptions>;
+    /**
+     * Provided → client mode (send to this single remote, filter inbound).
+     * Omitted → server mode (bind locally, accept from any rinfo).
+     */
+    remote?: {
+        port?: number;
+        address?: string;
+    };
+    /**
+     * Server mode only. Each unique rinfo (`address:port`) gets its own
+     * `PhysicalConnection`; if no datagram arrives within this many ms, the
+     * connection is evicted (`connection-close` emitted, upper-layer framing
+     * state released). Default 30000. Set 0 to disable eviction.
+     */
+    idleTimeout?: number;
+}
 declare class UdpPhysicalLayer extends AbstractPhysicalLayer {
     TYPE: 'SERIAL' | 'NET';
     private _socket;
+    private _connections;
     private _isOpen;
+    private _isOpening;
     private _destroyed;
+    private _socketOptions?;
     private _port;
     private _address?;
+    private _idleTimeout;
     isServer: boolean;
     get isOpen(): boolean;
     get destroyed(): boolean;
-    /**
-     *
-     * @param options
-     * @param remote If omitted, as server.
-     * Otherwise as client.
-     */
-    constructor(options?: Partial<SocketOptions>, remote?: {
-        port?: number;
-        address?: string;
-    });
+    constructor(options?: UdpPhysicalLayerOptions);
     open(options?: BindOptions): Promise<void>;
+    private _handleMessage;
     write(data: Buffer): Promise<void>;
     close(): Promise<void>;
     destroy(): Promise<void>;
 }
 
-type FConvertPromise<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: number[];
-}
-interface ServerId {
-    serverId?: number;
-    runIndicatorStatus?: boolean;
-    additionalData?: number[];
-}
-interface DeviceIdentification {
-    readDeviceIDCode: number;
-    conformityLevel: number;
-    moreFollows: boolean;
-    nextObjectId: number;
-    objects: {
-        id: number;
-        value: string;
-    }[];
-}
-
 interface AbstractApplicationLayerEvents {
     framing: [frame: ApplicationDataUnit & {
         buffer: Buffer;
-    }, response: (data: Buffer) => Promise<void>];
+    }, response: (data: Buffer) => Promise<void>, connection: PhysicalConnection];
+    'framing-error': [error: Error];
 }
 declare abstract class AbstractApplicationLayer extends EventEmitter<AbstractApplicationLayerEvents> {
-    abstract startWaitingResponse(preCheck: ((frame: ApplicationDataUnit & {
-        buffer: Buffer;
-    }) => boolean | number | undefined)[], callback: (error: Error | null, frame?: ApplicationDataUnit & {
-        buffer: Buffer;
-    }) => void): void;
-    abstract stopWaitingResponse(): void;
+    abstract readonly PROTOCOL: 'TCP' | 'RTU' | 'ASCII';
+    private _role?;
+    get role(): 'MASTER' | 'SLAVE';
+    set role(value: 'MASTER' | 'SLAVE');
+    flush(): void;
+    addCustomFunctionCode(cfc: CustomFunctionCode): void;
+    removeCustomFunctionCode(fc: number): void;
     abstract encode(data: ApplicationDataUnit): Buffer;
     abstract destroy(): void;
 }
 
-declare class RtuApplicationLayer extends AbstractApplicationLayer {
-    private _waitingResponse?;
-    private _timerThreePointFive?;
-    private _bufferRx;
-    private _removeAllListeners;
-    constructor(physicalLayer: SerialPhysicalLayer | TcpServerPhysicalLayer | TcpClientPhysicalLayer | UdpPhysicalLayer, 
+interface AsciiApplicationLayerOptions {
     /**
-     * The time interval between two frames, support two formats:
-     * - bit: `48bit` as default
-     * - millisecond: `20ms`
+     * 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`.
      */
-    intervalBetweenFrames?: `${number}bit` | `${number}ms`);
+    lenientHex?: boolean;
+}
+declare class AsciiApplicationLayer extends AbstractApplicationLayer {
+    readonly PROTOCOL: "ASCII";
+    readonly lenientHex: boolean;
+    private _states;
+    private _removeAllListeners;
+    constructor(physicalLayer: SerialPhysicalLayer | TcpServerPhysicalLayer | TcpClientPhysicalLayer | UdpPhysicalLayer, options?: AsciiApplicationLayerOptions);
+    private getState;
+    flush(): void;
     private framing;
-    startWaitingResponse(preCheck: ((frame: ApplicationDataUnit & {
-        buffer: Buffer;
-    }) => boolean | number | undefined)[], callback: (error: Error | null, frame?: ApplicationDataUnit & {
-        buffer: Buffer;
-    }) => void): void;
-    stopWaitingResponse(): void;
     encode(data: ApplicationDataUnit): Buffer;
     destroy(): void;
 }
 
-declare class AsciiApplicationLayer extends AbstractApplicationLayer {
-    private _waitingResponse?;
-    private _status;
-    private _frame;
+interface RtuApplicationLayerOptions {
+    /**
+     * Inter-frame silence (Modbus RTU t3.5). Defaults to `{ unit: 'bit', value: 38.5 }`
+     * for serial (3.5 character times × 11 bits/char per Modbus V1.02 §2.5.1.1);
+     * ignored for TCP/UDP transports.
+     * - `{ unit: 'bit', value: 38.5 }` — spec bit-time approximation
+     * - `{ unit: 'ms', value: 20 }` — explicit milliseconds
+     *
+     * Per Modbus V1.02 §2.5.1.1, at baud rates > 19200 the spec uses a fixed
+     * 1.75 ms regardless of the bit value supplied.
+     */
+    intervalBetweenFrames?: {
+        unit: 'bit' | 'ms';
+        value: number;
+    };
+    /**
+     * Inter-character timeout (Modbus RTU t1.5). Opt-in; **disabled** by default
+     * because Node.js `setTimeout` precision (~1 ms minimum, ~15.6 ms on Windows)
+     * is too coarse to reliably honor t1.5 at common baud rates without
+     * false-positive frame discards. When set, a mid-frame gap exceeding this
+     * duration discards the in-progress buffer and emits `framing-error`.
+     * Only takes effect on serial transports.
+     *
+     * - `{ unit: 'bit', value: 21 }` — bit-time approximation (~1.5 char times)
+     * - `{ unit: 'ms', value: 1 }` — explicit milliseconds
+     *
+     * Per Modbus V1.02 §2.5.1.1, at baud rates > 19200 the spec uses a fixed
+     * 0.75 ms regardless of the bit value supplied.
+     */
+    interCharTimeout?: {
+        unit: 'bit' | 'ms';
+        value: number;
+    };
+}
+declare class RtuApplicationLayer extends AbstractApplicationLayer {
+    readonly PROTOCOL: "RTU";
+    private _states;
+    private _customFunctionCodes;
     private _removeAllListeners;
-    constructor(physicalLayer: SerialPhysicalLayer | TcpServerPhysicalLayer | TcpClientPhysicalLayer | UdpPhysicalLayer);
-    private framing;
-    startWaitingResponse(preCheck: ((frame: ApplicationDataUnit & {
-        buffer: Buffer;
-    }) => boolean | number | undefined)[], callback: (error: Error | null, frame?: ApplicationDataUnit & {
-        buffer: Buffer;
-    }) => void): void;
-    stopWaitingResponse(): void;
+    private _threePointFiveT;
+    private _onePointFiveT;
+    constructor(physicalLayer: SerialPhysicalLayer | TcpServerPhysicalLayer | TcpClientPhysicalLayer | UdpPhysicalLayer, options?: RtuApplicationLayerOptions);
+    private getState;
+    private clearStateTimers;
+    private clearState;
+    flush(): void;
+    addCustomFunctionCode(cfc: CustomFunctionCode): void;
+    removeCustomFunctionCode(fc: number): void;
+    private flushBuffer;
+    private tryExtract;
+    private checkExpected;
+    private crcMatches;
+    private deliverFrame;
     encode(data: ApplicationDataUnit): Buffer;
     destroy(): void;
 }
 
 declare class TcpApplicationLayer extends AbstractApplicationLayer {
-    private _waitingResponse?;
+    readonly PROTOCOL: "TCP";
     private _transactionId;
+    private _buffers;
     private _removeAllListeners;
     constructor(physicalLayer: TcpServerPhysicalLayer | TcpClientPhysicalLayer | UdpPhysicalLayer);
-    private framing;
-    startWaitingResponse(preCheck: ((frame: ApplicationDataUnit & {
-        buffer: Buffer;
-    }) => boolean | number | undefined)[], callback: (error: Error | null, frame?: ApplicationDataUnit & {
-        buffer: Buffer;
-    }) => void): void;
-    stopWaitingResponse(): void;
+    private tryExtract;
+    private processFrame;
     encode(data: ApplicationDataUnit): Buffer;
     destroy(): void;
 }
@@ -233,14 +401,32 @@ interface ReturnValue<T> {
     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;
+}
 declare class ModbusMaster<A extends AbstractApplicationLayer, P extends AbstractPhysicalLayer> extends EventEmitter<ModbusMasterEvents> {
     private applicationLayer;
     private physicalLayer;
+    private _masterSession;
+    private _queue;
+    private _draining;
+    private _nextTid;
+    private _closed;
     timeout: number;
+    readonly concurrent: boolean;
     get isOpen(): boolean;
     get destroyed(): boolean;
-    constructor(applicationLayer: A, physicalLayer: P, timeout?: number);
-    private waitResponse;
+    constructor(applicationLayer: A, physicalLayer: P, options?: ModbusMasterOptions);
+    private send;
+    private _drain;
+    private _exchange;
     private writeFC1Or2;
     writeFC1: this['readCoils'];
     readCoils(unit: 0, address: number, length: number, timeout?: number): Promise<void>;
@@ -268,8 +454,8 @@ declare class ModbusMaster<A extends AbstractApplicationLayer, P extends Abstrac
     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, timeout?: number): Promise<void>;
-    reportServerId(unit: number, timeout?: number): Promise<ReturnValue<ServerId>>;
+    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<{
@@ -294,11 +480,31 @@ declare class ModbusMaster<A extends AbstractApplicationLayer, P extends Abstrac
     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(...args: Parameters<P['open']>): Promise<void>;
     close(): Promise<void>;
     destroy(): Promise<void>;
 }
 
+type Frame = ApplicationDataUnit & {
+    buffer: Buffer;
+};
+type PreCheck = (frame: Frame) => boolean | number | undefined;
+type Callback = (error: Error | null, frame?: Frame) => void;
+declare class MasterSession {
+    private _waiters;
+    start(key: string | number, preCheck: PreCheck[], callback: Callback): void;
+    stop(key: string | number): void;
+    stopAll(error: Error): void;
+    has(key: string | number): boolean;
+    handleFrame(frame: Frame): void;
+    handleError(error: Error): void;
+    private runPreChecks;
+}
+
 interface ModbusSlaveModel {
     unit?: number;
     /**
@@ -307,7 +513,7 @@ interface ModbusSlaveModel {
      * If provide the return value, use this value as data of `PDU` to respond.
      * Otherwise keep the default read and write behavior.
      */
-    interceptor?: FConvertPromise<(fc: number, data: number[]) => number[] | undefined>;
+    interceptor?: FConvertPromise<(fc: number, data: Buffer) => Buffer | undefined>;
     readDiscreteInputs?: FConvertPromise<(address: number, length: number) => boolean[]>;
     readCoils?: FConvertPromise<(address: number, length: number) => boolean[]>;
     writeSingleCoil?: FConvertPromise<(address: number, value: boolean) => void>;
@@ -341,15 +547,25 @@ interface ModbusSlaveEvents {
     error: [error: Error];
     close: [];
 }
+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;
+}
 declare class ModbusSlave<A extends AbstractApplicationLayer, P extends AbstractPhysicalLayer> extends EventEmitter<ModbusSlaveEvents> {
     private applicationLayer;
     private physicalLayer;
     models: Map<number, ModbusSlaveModel>;
-    private _processing;
-    private _queue;
+    readonly concurrent: boolean;
+    private _queues;
+    private _customFunctionCodes;
+    private _locks;
     get isOpen(): boolean;
     get destroyed(): boolean;
-    constructor(applicationLayer: A, physicalLayer: P);
+    constructor(applicationLayer: A, physicalLayer: P, options?: ModbusSlaveOptions);
     private handleFC1;
     private handleFC2;
     private handleFC3;
@@ -366,13 +582,16 @@ declare class ModbusSlave<A extends AbstractApplicationLayer, P extends Abstract
     private _drain;
     private _processFrame;
     private _intercept;
+    private withAddressLock;
     private _handleFC;
     add(model: ModbusSlaveModel): void;
     remove(unit: number): void;
+    addCustomFunctionCode(cfc: CustomFunctionCode): void;
+    removeCustomFunctionCode(fc: number): void;
     open(...args: Parameters<P['open']>): Promise<void>;
     close(): Promise<void>;
     destroy(): Promise<void>;
 }
 
-export { AbstractApplicationLayer, AbstractPhysicalLayer, AsciiApplicationLayer, ErrorCode, ModbusMaster, ModbusSlave, RtuApplicationLayer, SerialPhysicalLayer, TcpApplicationLayer, TcpClientPhysicalLayer, TcpServerPhysicalLayer, UdpPhysicalLayer, getCodeByError, getErrorByCode };
-export type { ModbusSlaveModel };
+export { AbstractApplicationLayer, AbstractPhysicalLayer, AsciiApplicationLayer, COIL_OFF, COIL_ON, ConformityLevel, EXCEPTION_OFFSET, ErrorCode, FunctionCode, LIMITS, MEI_READ_DEVICE_ID, MasterSession, ModbusError, ModbusErrorCode, ModbusMaster, ModbusSlave, ReadDeviceIDCode, RtuApplicationLayer, SerialPhysicalLayer, TcpApplicationLayer, TcpClientPhysicalLayer, TcpServerPhysicalLayer, UdpPhysicalLayer, getCodeByError, getErrorByCode };
+export type { ApplicationDataUnit, AsciiApplicationLayerOptions, Callback$1 as Callback, CustomFunctionCode, DeviceIdentification, FConvertPromise, ModbusMasterOptions, ModbusSlaveModel, ModbusSlaveOptions, PhysicalConnection, RtuApplicationLayerOptions, ServerId };