njs-modbus 3.1.0 → 3.2.0

package/dist/src/layers/physical/serial-physical-layer.d.ts

@@ -1,70 +0,0 @@
-import { SerialPort } from 'serialport';
-import { AbstractPhysicalConnection, AbstractPhysicalLayer } from './abstract-physical-layer';
-import { PhysicalConnectionState, PhysicalState } from './vars';
-export 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';
-}
-export declare class SerialPhysicalConnection extends AbstractPhysicalConnection {
-    private _state;
-    private _physicalLayer;
-    private _serialport;
-    private _pendingDestroyCbs;
-    private _cleanupFns;
-    get state(): PhysicalConnectionState;
-    get physicalLayer(): AbstractPhysicalLayer;
-    constructor(physicalLayer: SerialPhysicalLayer, serialport: SerialPort);
-    write(data: Buffer, cb?: (err?: Error | null) => void): void;
-    destroy(cb?: (err?: Error | null) => void): void;
-}
-export 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;
-}

package/dist/src/layers/physical/tcp-client-physical-layer.d.ts

@@ -1,19 +0,0 @@
-import type { SocketConstructorOpts, SocketConnectOpts } from 'node:net';
-import { Socket } from 'node:net';
-import { AbstractPhysicalLayer } from './abstract-physical-layer';
-import { PhysicalState } from './vars';
-export 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(options?: SocketConnectOpts | ((err?: Error | null) => void), cb?: (err?: Error | null) => void): void;
-    close(cb?: (err?: Error | null) => void): void;
-}

package/dist/src/layers/physical/tcp-physical-connection.d.ts

@@ -1,16 +0,0 @@
-import type { AbstractPhysicalLayer } from './abstract-physical-layer';
-import type { Socket } from 'node:net';
-import { AbstractPhysicalConnection } from './abstract-physical-layer';
-import { PhysicalConnectionState } from './vars';
-export declare class TcpPhysicalConnection extends AbstractPhysicalConnection {
-    private _state;
-    private _physicalLayer;
-    private _socket;
-    private _pendingDestroyCbs;
-    private _cleanupFns;
-    get state(): PhysicalConnectionState;
-    get physicalLayer(): AbstractPhysicalLayer;
-    constructor(physicalLayer: AbstractPhysicalLayer, socket: Socket);
-    write(data: Buffer, cb?: (err?: Error | null) => void): void;
-    destroy(cb?: (err?: Error | null) => void): void;
-}

package/dist/src/layers/physical/tcp-server-physical-layer.d.ts

@@ -1,28 +0,0 @@
-import type { Server, ListenOptions, ServerOpts } from 'node:net';
-import { AbstractPhysicalLayer } from './abstract-physical-layer';
-import { PhysicalState } from './vars';
-export 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;
-}
-export 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(options?: ListenOptions | ((err?: Error | null) => void), cb?: (err?: Error | null) => void): void;
-    close(cb?: (err?: Error | null) => void): void;
-}

package/dist/src/layers/physical/udp-client-physical-layer.d.ts

@@ -1,33 +0,0 @@
-import type { Socket, SocketOptions } from 'node:dgram';
-import { AbstractPhysicalConnection, AbstractPhysicalLayer } from './abstract-physical-layer';
-import { PhysicalConnectionState, PhysicalState } from './vars';
-export declare class UdpClientPhysicalConnection extends AbstractPhysicalConnection {
-    private _state;
-    private _physicalLayer;
-    private _socket;
-    private _pendingDestroyCbs;
-    private _cleanupFns;
-    get state(): PhysicalConnectionState;
-    get physicalLayer(): AbstractPhysicalLayer;
-    constructor(physicalLayer: UdpClientPhysicalLayer, socket: Socket);
-    write(data: Buffer, cb?: (err?: Error | null) => void): void;
-    destroy(cb?: (err?: Error | null) => void): void;
-}
-export 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 | null;
-    constructor(options?: Partial<SocketOptions>);
-    open(remote?: {
-        port?: number;
-        address?: string;
-    } | ((err?: Error | null) => void), cb?: (err?: Error | null) => void): void;
-    close(cb?: (err?: Error | null) => void): void;
-}

package/dist/src/layers/physical/udp-server-physical-layer.d.ts

@@ -1,50 +0,0 @@
-import type { BindOptions, RemoteInfo, Socket, SocketOptions } from 'node:dgram';
-import { AbstractPhysicalConnection, AbstractPhysicalLayer } from './abstract-physical-layer';
-import { PhysicalConnectionState, PhysicalState } from './vars';
-export 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>;
-}
-export declare class UdpServerPhysicalConnection extends AbstractPhysicalConnection {
-    private _state;
-    private _physicalLayer;
-    private _socket;
-    private _remote;
-    private _idleTid;
-    private _cleanupFns;
-    get state(): PhysicalConnectionState;
-    get physicalLayer(): AbstractPhysicalLayer;
-    constructor(physicalLayer: UdpServerPhysicalLayer, socket: Socket, remote: RemoteInfo, idleTimeout: number, messageEventDelegation: {
-        add: (listener: (msg: Buffer, rinfo: RemoteInfo) => void) => void;
-        remove: (listener: (...args: any[]) => void) => void;
-    });
-    write(data: Buffer, cb?: (err?: Error | null) => void): void;
-    destroy(cb?: (err?: Error | null) => void): void;
-}
-export 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 | 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(options?: BindOptions | ((err?: Error | null) => void), cb?: (err?: Error | null) => void): void;
-    close(cb?: (err?: Error | null) => void): void;
-}

package/dist/src/layers/physical/utils.d.ts

@@ -1,39 +0,0 @@
-import type { AbstractPhysicalLayer } from './abstract-physical-layer';
-import type { SocketOptions } from 'node:dgram';
-import type { SocketConstructorOpts } from 'node:net';
-import { SerialPhysicalLayer, type SerialPhysicalLayerOptions } from './serial-physical-layer';
-import { TcpClientPhysicalLayer } from './tcp-client-physical-layer';
-import { TcpServerPhysicalLayer, type TcpServerPhysicalLayerOptions } from './tcp-server-physical-layer';
-import { UdpClientPhysicalLayer } from './udp-client-physical-layer';
-import { UdpServerPhysicalLayer, type UdpServerPhysicalLayerOptions } from './udp-server-physical-layer';
-export 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;
-};
-export type OpenArgs<T extends PhysicalConfig> = T extends {
-    type: 'SERIAL';
-} ? Parameters<SerialPhysicalLayer['open']> : T extends {
-    type: 'TCP_CLIENT';
-} ? Parameters<TcpClientPhysicalLayer['open']> : T extends {
-    type: 'TCP_SERVER';
-} ? Parameters<TcpServerPhysicalLayer['open']> : T extends {
-    type: 'UDP_CLIENT';
-} ? Parameters<UdpClientPhysicalLayer['open']> : T extends {
-    type: 'UDP_SERVER';
-} ? Parameters<UdpServerPhysicalLayer['open']> : never;
-export declare function createPhysicalLayer(config: PhysicalConfig): AbstractPhysicalLayer;

package/dist/src/layers/physical/vars.d.ts

@@ -1,11 +0,0 @@
-export declare enum PhysicalState {
-    OPENING = "opening",
-    OPEN = "open",
-    CLOSING = "closing",
-    CLOSED = "closed"
-}
-export declare enum PhysicalConnectionState {
-    CONNECTED = "connected",
-    DESTROYING = "destroying",
-    DESTROYED = "destroyed"
-}

package/dist/src/master/index.d.ts

@@ -1,3 +0,0 @@
-export type { ModbusMasterOptions } from './master';
-export { MasterSession } from './master-session';
-export { ModbusMaster } from './master';

package/dist/src/master/master-session.d.ts

@@ -1,18 +0,0 @@
-import type { ApplicationDataUnit } from '../types';
-type Frame = ApplicationDataUnit & {
-    buffer: Buffer;
-};
-type Callback = (error: Error | null, frame?: Frame) => void;
-export declare const FIFO_KEY: "fifo";
-export 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;
-}
-export {};

package/dist/src/master/master.d.ts

@@ -1,140 +0,0 @@
-import type { AsciiApplicationLayerOptions } from '../layers/application';
-import type { AbstractPhysicalLayer, AbstractPhysicalLayerEvents, OpenArgs, PhysicalConfig } from '../layers/physical';
-import type { CustomFunctionCode, DeviceIdentification, ServerId } from '../types';
-import type { RtuProtocolOptions } from '../utils';
-import EventEmitter from 'node:events';
-import { PhysicalState } from '../layers/physical';
-interface ReturnValue<T> {
-    transaction?: number;
-    unit: number;
-    fc: number;
-    data: T;
-    buffer: Buffer;
-}
-export 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;
-    };
-}
-export declare class ModbusMaster<T extends ModbusMasterOptions = ModbusMasterOptions> extends EventEmitter<AbstractPhysicalLayerEvents> {
-    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 _queueResolves;
-    private _queueRejects;
-    private _queueHead;
-    private _queueLen;
-    private _draining;
-    private _nextTid;
-    private _cleanupFns;
-    private _closePromise;
-    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<boolean[]>>;
-    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<boolean[]>>;
-    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: boolean, timeout?: number): Promise<void>;
-    writeSingleCoil(unit: number, address: number, value: boolean, timeout?: number): Promise<ReturnValue<boolean>>;
-    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: boolean[], timeout?: number): Promise<void>;
-    writeMultipleCoils(unit: number, address: number, value: boolean[], timeout?: number): Promise<ReturnValue<boolean[]>>;
-    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 begin accepting connections.
-     *
-     * 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>;
-}
-export {};

package/dist/src/slave/index.d.ts

@@ -1,2 +0,0 @@
-export type { ModbusSlaveModel, ModbusSlaveOptions } from './slave';
-export { ModbusSlave } from './slave';

package/dist/src/slave/slave.d.ts

@@ -1,119 +0,0 @@
-import type { AsciiApplicationLayerOptions } from '../layers/application';
-import type { AbstractPhysicalLayer, AbstractPhysicalLayerEvents, OpenArgs, PhysicalConfig } from '../layers/physical';
-import type { CustomFunctionCode, MaybeAsyncFunction, ServerId } from '../types';
-import type { RtuProtocolOptions } from '../utils';
-import EventEmitter from 'node:events';
-import { PhysicalState } from '../layers/physical';
-export 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) => boolean[]>;
-    readCoils?: MaybeAsyncFunction<(address: number, length: number) => boolean[]>;
-    writeSingleCoil?: MaybeAsyncFunction<(address: number, value: boolean) => void>;
-    /**
-     * If omitted, defaults to loop and call `writeSingleCoil`.
-     */
-    writeMultipleCoils?: MaybeAsyncFunction<(address: number, value: boolean[]) => void>;
-    readInputRegisters?: MaybeAsyncFunction<(address: number, length: number) => number[]>;
-    readHoldingRegisters?: MaybeAsyncFunction<(address: number, length: number) => number[]>;
-    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][];
-    };
-}
-export 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;
-    };
-}
-export declare class ModbusSlave<T extends ModbusSlaveOptions = ModbusSlaveOptions> extends EventEmitter<AbstractPhysicalLayerEvents> {
-    readonly models: Map<number, ModbusSlaveModel>;
-    readonly concurrent: boolean;
-    private _physicalLayer;
-    private _protocol;
-    private _appLayers;
-    private _customFunctionCodes;
-    private _locks;
-    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;
-    private _withAddressLock;
-    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>;
-}

package/dist/src/types.d.ts

@@ -1,54 +0,0 @@
-export type Callback<T> = (error: Error | null, value: T) => void;
-export type MaybeAsyncFunction<F extends (...args: any) => any> = F extends (...args: infer A) => infer R ? ((...args: A) => Promise<R>) | ((...args: A) => R) : never;
-export interface ApplicationDataUnit {
-    transaction?: number;
-    unit: number;
-    fc: number;
-    data: Buffer;
-}
-export interface ServerId {
-    /** Server ID; may be 1 byte (number) or multi-byte (number[]) per device spec. */
-    serverId?: number[];
-    runIndicatorStatus?: boolean;
-    additionalData?: number[];
-}
-export 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.
- */
-export 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?: MaybeAsyncFunction<(data: Buffer, unit: number) => Buffer>;
-}

package/dist/src/utils/bitsToMs.d.ts

@@ -1,13 +0,0 @@
-/**
- * Convert a number of bits to milliseconds at a given baud rate.
- *
- * Used to derive Modbus RTU timing intervals from bit counts — e.g. 38.5 bits
- * = 3.5 character times at 11 bits/char (t3.5 inter-frame silence), or 16.5
- * bits = 1.5 character times (t1.5 inter-character timeout), per Modbus V1.02
- * §2.5.1.1.
- *
- * @param baudRate Serial port baud rate.
- * @param bits Number of bits to convert.
- * @returns Duration in milliseconds.
- */
-export declare function bitsToMs(baudRate: number, bits: number): number;

package/dist/src/utils/callback.d.ts

@@ -1,8 +0,0 @@
-/**
- * Drain a pending-callback array: invoke each callback with the given error (or null).
- *
- * Handles `null`/`undefined` entries (from optional `cb?` parameters) gracefully.
- * Used by physical layers and connections to resolve queued
- * open / close / destroy callbacks.
- */
-export declare function drainCbs(cbs: (((err?: Error | null) => void) | undefined)[] | null, err?: Error | null): void;

package/dist/src/utils/checkRange.d.ts

@@ -1 +0,0 @@
-export declare function checkRange(value: number | number[], range?: [number, number] | [number, number][]): boolean;

package/dist/src/utils/crc.d.ts

@@ -1 +0,0 @@
-export declare function crc(data: Uint8Array, start?: number, end?: number): number;

package/dist/src/utils/index.d.ts

@@ -1,11 +0,0 @@
-export type { RtuProtocolOptions, ResolvedRtuTiming } from './rtu-timing';
-export { bitsToMs } from './bitsToMs';
-export { drainCbs } from './callback';
-export { checkRange } from './checkRange';
-export { crc } from './crc';
-export { isUint8 } from './isUint8';
-export { lrc } from './lrc';
-export { PREDICT_NEED_MORE, PREDICT_UNKNOWN, predictRtuFrameLength } from './predictRtuFrameLength';
-export { promisifyCb } from './promisify-cb';
-export { resolveRtuTiming } from './rtu-timing';
-export { isWhitelisted } from './whitelist';