njs-modbus 3.1.1 → 3.3.0

package/dist/src/layers/application/tcp-application-layer.d.ts

@@ -1,16 +0,0 @@
-import type { AbstractPhysicalConnection } from '../physical';
-import { AbstractApplicationLayer } from './abstract-application-layer';
-export declare class TcpApplicationLayer extends AbstractApplicationLayer {
-    readonly PROTOCOL: "TCP";
-    readonly ROLE: 'MASTER' | 'SLAVE';
-    private _connection;
-    private _transactionId;
-    private _buffer;
-    private _cleanupFns;
-    get connection(): AbstractPhysicalConnection;
-    constructor(role: 'MASTER' | 'SLAVE', connection: AbstractPhysicalConnection);
-    private tryExtract;
-    private processFrame;
-    flush(): void;
-    encode(unit: number, fc: number, data: Buffer, transaction?: number): Buffer;
-}

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

@@ -1,50 +0,0 @@
-import type { SerialPhysicalLayer } from './serial-physical-layer';
-import type { TcpClientPhysicalLayer } from './tcp-client-physical-layer';
-import type { TcpServerPhysicalLayer } from './tcp-server-physical-layer';
-import type { UdpClientPhysicalLayer } from './udp-client-physical-layer';
-import type { UdpServerPhysicalLayer } from './udp-server-physical-layer';
-import type { PhysicalConnectionState, PhysicalState } from './vars';
-import EventEmitter from 'node:events';
-interface AbstractPhysicalConnectionEvents {
-    data: [data: Buffer];
-    close: [];
-}
-/**
- * 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.
- */
-export 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;
-}
-export interface AbstractPhysicalLayerEvents {
-    open: [];
-    connect: [connection: AbstractPhysicalConnection];
-    close: [];
-    error: [error: Error];
-}
-/**
- * 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.
- */
-export 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;
-}
-export {};

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

@@ -1,12 +0,0 @@
-export type { AbstractPhysicalLayerEvents } from './abstract-physical-layer';
-export type { PhysicalConfig, OpenArgs } from './utils';
-export type { TcpServerPhysicalLayerOptions } from './tcp-server-physical-layer';
-export type { UdpServerPhysicalLayerOptions } from './udp-server-physical-layer';
-export { AbstractPhysicalConnection, AbstractPhysicalLayer } from './abstract-physical-layer';
-export { SerialPhysicalLayer } from './serial-physical-layer';
-export { TcpClientPhysicalLayer } from './tcp-client-physical-layer';
-export { TcpServerPhysicalLayer } from './tcp-server-physical-layer';
-export { UdpClientPhysicalLayer } from './udp-client-physical-layer';
-export { UdpServerPhysicalLayer } from './udp-server-physical-layer';
-export { PhysicalState, PhysicalConnectionState } from './vars';
-export { createPhysicalLayer } from './utils';

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,20 +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(cb?: (err?: Error | null) => void): void;
-    open(options: SocketConnectOpts, 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,29 +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(cb?: (err?: Error | null) => void): void;
-    open(options: ListenOptions, 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,34 +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(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;
-}

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

@@ -1,51 +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(cb?: (err?: Error | null) => void): void;
-    open(options: BindOptions, 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>;
-}