/* auto-generated by NAPI-RS */
/* eslint-disable */
/**
 *  Physical serial port in ASCII mode. Factory for device clients.
 * Manages a physical serial port connection in ASCII mode.
 * This class is a factory for creating lightweight `AsyncSerialModbusClient` instances
 * that are bound to a specific unit ID and share the underlying serial connection.
 *
 * Use the static `open` method to establish a connection.
 */
export declare class AsyncAsciiTransport {
  /**
   *  Opens the serial port in ASCII mode.
   * Opens a serial port and establishes a connection in ASCII mode.
   * @param options Options for the serial ASCII transport.
   * @param options.portPath The path to the serial port (e.g., '/dev/ttyUSB0', 'COM3').
   * @param options.baudRate The baud rate for the serial communication.
   * @returns A `Promise` that resolves to an `AsyncAsciiTransport` instance.
   */
  static open(options: AsciiTransportOptions): Promise<AsyncAsciiTransport>;
  /**
   *  Creates a device client bound to the specified unit ID.
   * Creates a lightweight device client that communicates through this transport.
   * The client is bound to a specific Modbus unit ID.
   * @param options Options specifying the unit ID.
   */
  createClient(options: CreateClientOptions): AsyncSerialModbusClient;
  /**
   *  Sets the per-request timeout in milliseconds.
   * Sets the timeout for individual Modbus requests made through this transport.
   * @param timeout_ms The timeout duration in milliseconds.
   */
  setRequestTimeout(timeoutMs: number): void;
  /**
   *  Clears the per-request timeout.
   * Clears any previously set per-request timeout.
   */
  clearRequestTimeout(): void;
  /**
   *  Returns whether there are pending requests.
   * Checks if there are any Modbus requests currently in-flight on this transport.
   */
  readonly pendingRequests: boolean;
  /**
   *  Closes the transport.
   * Closes the underlying serial port connection.
   */
  close(): Promise<void>;
  /**
   *  Reconnects the transport after a disconnect.
   * Attempts to re-establish the serial connection if it has been closed.
   */
  reconnect(): Promise<void>;
}

/**
 *  Physical serial port in RTU mode. Factory for device clients.
 * Manages a physical serial port connection in RTU mode.
 * This class is a factory for creating lightweight `AsyncSerialModbusClient` instances
 * that are bound to a specific unit ID and share the underlying serial connection.
 *
 * Use the static `open` method to establish a connection.
 */
export declare class AsyncRtuTransport {
  /**
   *  Opens the serial port in RTU mode.
   * Opens a serial port and establishes a connection in RTU mode.
   * @param options Options for the serial RTU transport.
   * @param options.portPath The path to the serial port (e.g., '/dev/ttyUSB0', 'COM3').
   * @param options.baudRate The baud rate for the serial communication.
   * @returns A `Promise` that resolves to an `AsyncRtuTransport` instance.
   */
  static open(options: RtuTransportOptions): Promise<AsyncRtuTransport>;
  /**
   *  Creates a device client bound to the specified unit ID.
   * Creates a lightweight device client that communicates through this transport.
   * The client is bound to a specific Modbus unit ID.
   * @param options Options specifying the unit ID.
   */
  createClient(options: CreateClientOptions): AsyncSerialModbusClient;
  /**
   *  Sets the per-request timeout in milliseconds.
   * Sets the timeout for individual Modbus requests made through this transport.
   * @param timeout_ms The timeout duration in milliseconds.
   */
  setRequestTimeout(timeoutMs: number): void;
  /**
   *  Clears the per-request timeout.
   * Clears any previously set per-request timeout.
   */
  clearRequestTimeout(): void;
  /**
   *  Returns whether there are pending requests.
   * Checks if there are any Modbus requests currently in-flight on this transport.
   */
  readonly pendingRequests: boolean;
  /**
   *  Closes the transport.
   * Closes the underlying serial port connection.
   */
  close(): Promise<void>;
  /**
   *  Reconnects the transport after a disconnect.
   * Attempts to re-establish the serial connection if it has been closed.
   */
  reconnect(): Promise<void>;
}

/**
 *  Lightweight device client sharing the serial transport.
 * A lightweight Modbus client that sends requests for a specific unit ID
 * over a shared `AsyncRtuTransport` or `AsyncAsciiTransport`.
 */
export declare class AsyncSerialModbusClient {
  /**
   *  Returns whether there are pending requests.
   * Checks if there are any Modbus requests currently in-flight for this client.
   */
  readonly pendingRequests: boolean;
  /**
   *  Checks if the client is connected to the transport.
   * Checks if the underlying client transport connection is active.
   */
  isConnected(): boolean;
  /**
   *  Reads holding registers (FC03).
   * Reads one or more holding registers (Function Code 03).
   * @param options Options for reading registers.
   * @param options.address The starting register address.
   * @param options.quantity The number of registers to read.
   * @param options.signal An optional `AbortSignal` to cancel the operation.
   */
  readHoldingRegisters(options: ReadRegistersOptions): Promise<Uint16Array>;
  /**
   *  Reads input registers (FC04).
   * Reads one or more input registers (Function Code 04).
   * @param options Options for reading registers.
   * @param options.address The starting register address.
   * @param options.quantity The number of registers to read.
   * @param options.signal An optional `AbortSignal` to cancel the operation.
   */
  readInputRegisters(options: ReadRegistersOptions): Promise<Uint16Array>;
  /**
   *  Writes a single register (FC06).
   * Writes a single holding register (Function Code 06).
   * @param options Options for writing a single register.
   * @param options.address The register address.
   * @param options.value The 16-bit value to write.
   * @param options.signal An optional `AbortSignal` to cancel the operation.
   */
  writeSingleRegister(options: WriteSingleRegisterOptions): Promise<void>;
  /**
   *  Writes multiple registers (FC16).
   * Writes multiple consecutive holding registers (Function Code 16).
   * @param options Options for writing multiple registers.
   * @param options.address The starting register address.
   * @param options.values An array of 16-bit values to write.
   * @param options.signal An optional `AbortSignal` to cancel the operation.
   */
  writeMultipleRegisters(options: WriteMultipleRegistersOptions): Promise<void>;
  /**
   *  Reads and writes multiple registers atomically (FC23).
   * Performs an atomic read/write operation on multiple registers (Function Code 23).
   * @param options Options for the read/write operation.
   * @param options.read_address The starting address for the read operation.
   * @param options.read_quantity The number of registers to read.
   * @param options.write_address The starting address for the write operation.
   * @param options.write_values An array of 16-bit values to write.
   * @param options.signal An optional `AbortSignal` to cancel the operation.
   */
  readWriteMultipleRegisters(options: ReadWriteMultipleRegistersOptions): Promise<Uint16Array>;
  /**
   *  Reads coils (FC01).
   * Reads the status of one or more coils (Function Code 01).
   * @param {ReadBitsOptions} options - Options for reading bits.
   * @param {number} options.address - The starting coil address.
   * @param {number} options.quantity - The number of coils to read.
   * @param {AbortSignal} [options.signal] - An optional cancellation signal.
   * @returns {Promise<CoilState[]>} - A promise that resolves to an array representing the coil states.
   *
   * @example
   * ```javascript
   * const coils = await client.readCoils({ address: 0, quantity: 8 });
   * console.log(coils); // e.g., [CoilState.On, CoilState.Off, ...]
   * ```
   */
  readCoils(options: ReadBitsOptions): Promise<CoilState[]>;
  /**
   *  Writes a single coil (FC05).
   * Writes a single coil (Function Code 05).
   * @param {WriteSingleCoilOptions} options - Options for writing a single coil.
   * @param {number} options.address - The coil address.
   * @param {CoilState} options.value - The coil state to write.
   * @param {AbortSignal} [options.signal] - An optional cancellation signal.
   * @returns {`Promise<void>`} - A promise that resolves when the write is complete.
   *
   * @example
   * ```javascript
   * await client.writeSingleCoil({ address: 10, value: CoilState.On });
   * ```
   */
  writeSingleCoil(options: WriteSingleCoilOptions): Promise<void>;
  /**
   *  Writes multiple coils (FC15).
   * Writes multiple consecutive coils (Function Code 15).
   * @param {WriteMultipleCoilsOptions} options - Options for writing multiple coils.
   * @param {number} options.address - The starting coil address.
   * @param {CoilState[]} options.values - An array of coil states to write.
   * @param {AbortSignal} [options.signal] - An optional cancellation signal.
   * @returns {`Promise<void>`} - A promise that resolves when the write is complete.
   *
   * @example
   * ```javascript
   * await client.writeMultipleCoils({ address: 20, values: [CoilState.On, CoilState.Off] });
   * ```
   */
  writeMultipleCoils(options: WriteMultipleCoilsOptions): Promise<void>;
  /**
   *  Reads discrete inputs (FC02).
   * Reads the status of one or more discrete inputs (Function Code 02).
   * @param {ReadBitsOptions} options - Options for reading bits.
   * @param {number} options.address - The starting discrete input address.
   * @param {number} options.quantity - The number of discrete inputs to read.
   * @param {AbortSignal} [options.signal] - An optional cancellation signal.
   * @returns {Promise<CoilState[]>} - A promise that resolves to an array of states.
   *
   * @example
   * ```javascript
   * const inputs = await client.readDiscreteInputs({ address: 0, quantity: 4 });
   * ```
   */
  readDiscreteInputs(options: ReadBitsOptions): Promise<CoilState[]>;
  /**
   *  Reads FIFO queue (FC24).
   * Reads from a FIFO queue register (Function Code 24).
   * @param options Options for reading the FIFO queue.
   * @param options.address The FIFO pointer address.
   * @param options.signal An optional `AbortSignal` to cancel the operation.
   *
   * @example
   * ```javascript
   * const fifoContents = await client.readFifoQueue({ address: 42 });
   * ```
   */
  readFifoQueue(options: ReadFifoQueueOptions): Promise<FifoQueueResponse>;
  /**
   *  Reads file records (FC20).
   * Reads one or more file records (Function Code 20).
   * @param options Options for reading file records.
   * @param options.requests An array of file record read sub-requests.
   * @param options.signal An optional `AbortSignal` to cancel the operation.
   *
   * @example
   * ```javascript
   * const records = await client.readFileRecord({
   *   requests: [
   *     { fileNumber: 4, recordNumber: 1, recordLength: 2 }
   *   ]
   * });
   * ```
   */
  readFileRecord(options: ReadFileRecordOptions): Promise<Uint16Array[]>;
  /**
   *  Writes file records (FC21).
   * Writes one or more file records (Function Code 21).
   * @param options Options for writing file records.
   * @param options.requests An array of file record write sub-requests.
   * @param options.signal An optional `AbortSignal` to cancel the operation.
   */
  writeFileRecord(options: WriteFileRecordOptions): Promise<void>;
  /**
   *  Reads exception status (FC07).
   * Reads the device's exception status byte (Function Code 07).
   */
  readExceptionStatus(): Promise<number>;
  /**
   *  Sends a diagnostics request (FC08).
   * Executes a diagnostic function on the device (Function Code 08).
   * @param options Options for the diagnostics request.
   * @param options.sub_function The diagnostic sub-function code.
   * @param options.data Data to be sent with the request.
   * @param options.signal An optional `AbortSignal` to cancel the operation.
   */
  diagnostics(options: DiagnosticsOptions): Promise<DiagnosticsResponse>;
  /**
   *  Reads device identification (FC43/MEI14).
   * Reads device identification information (Function Code 43, MEI 14).
   * @param options Options for reading device identification.
   * @param options.read_device_id_code The category of objects to read (e.g., basic, regular).
   * @param options.object_id The ID of the first object to read.
   * @param options.signal An optional `AbortSignal` to cancel the operation.
   */
  readDeviceIdentification(options: ReadDeviceIdentificationOptions): Promise<DeviceIdentificationResponse>;
}

/**
 *  Async Modbus Serial server supporting RTU and ASCII transports.
 * An asynchronous Modbus server that listens on a serial port for incoming requests.
 * It supports both RTU and ASCII transport modes.
 * Use the static `bindRtu` or `bindAscii` methods to create and start a server instance.
 */
export declare class AsyncSerialModbusServer {
  /**
   * Creates and starts a new Modbus RTU server on a serial port.
   *
   * @param {SerialServerOptions} options Server configuration options.
   * @param {string} options.portPath The path to the serial port (e.g., '/dev/ttyUSB0', 'COM3').
   * @param {number} options.baudRate The communication speed (e.g., 9600, 19200).
   * @param {number} options.unitId The Modbus unit ID the server will respond to.
   * @param {number} [options.dataBits] Optional number of data bits (5, 6, 7, or 8). Defaults to 8.
   * @param {string} [options.parity] Optional parity setting ('none', 'even', 'odd'). Defaults to 'none'.
   * @param {number} [options.stopBits] Optional number of stop bits (1 or 2). Defaults to 1.
   * @param {number} [options.responseTimeoutMs] Optional response timeout in milliseconds. Defaults to 1000.
   *
   * @param {ServerHandlers} handlers An object containing callback functions to handle Modbus requests.
   * @returns {`Promise<AsyncSerialModbusServer>`} A `Promise` that resolves to a running `AsyncSerialModbusServer` instance.
   */
  static bindRtu(options: SerialServerOptions, handlers: ServerHandlers): Promise<AsyncSerialModbusServer>;
  /**
   * Creates and starts a new Modbus ASCII server on a serial port.
   *
   * @param {SerialServerOptions} options Server configuration options.
   * @param {string} options.portPath The path to the serial port (e.g., '/dev/ttyUSB0', 'COM3').
   * @param {number} options.baudRate The communication speed (e.g., 9600, 19200).
   * @param {number} options.unitId The Modbus unit ID the server will respond to.
   * @param {number} [options.dataBits] Optional number of data bits (7 or 8). Defaults to 8.
   * @param {string} [options.parity] Optional parity setting ('none', 'even', 'odd'). Defaults to 'none'.
   * @param {number} [options.stopBits] Optional number of stop bits (1 or 2). Defaults to 1.
   * @param {number} [options.responseTimeoutMs] Optional response timeout in milliseconds. Defaults to 1000.
   *
   * @param {ServerHandlers} handlers An object containing callback functions to handle Modbus requests.
   * @returns {`Promise<AsyncSerialModbusServer>`} A `Promise` that resolves to a running `AsyncSerialModbusServer` instance.
   */
  static bindAscii(options: SerialServerOptions, handlers: ServerHandlers): Promise<AsyncSerialModbusServer>;
  /**
   *  Stops the server.
   * Stops the server and closes the serial port.
   */
  shutdown(): Promise<void>;
}

/**
 * Async Modbus TCP gateway.
 *
 * Forwards incoming Modbus requests to downstream servers based on unit ID routing.
 */
export declare class AsyncTcpGateway {
  /**
   * Creates and starts a new TCP gateway.
   *
   * @param {GatewayBindOptions} options - Gateway bind options.
   * @param {string} options.host - Bind host address (e.g., "0.0.0.0").
   * @param {number} options.port - Bind port.
   *
   * @param {GatewayConfig} config - Gateway configuration including downstreams and routes.
   * @param {DownstreamConfig[]} config.downstreams - List of downstream servers.
   * @param {RouteEntry[]} config.routes - Routing table mapping unit IDs to downstream channels.
   * @returns {`Promise<AsyncTcpGateway>`} A promise that resolves to the running gateway instance.
   */
  static bind(options: GatewayBindOptions, config: GatewayConfig): Promise<AsyncTcpGateway>;
  /** Stops the gateway. */
  shutdown(): Promise<void>;
}

/**
 *  Lightweight device client sharing the TCP transport.
 * A lightweight Modbus client that sends requests for a specific unit ID
 * over a shared `AsyncTcpTransport`.
 */
export declare class AsyncTcpModbusClient {
  /**
   *  Returns whether there are pending requests.
   * Checks if there are any Modbus requests currently in-flight for this client.
   */
  readonly pendingRequests: boolean;
  /**
   *  Checks if the client is connected to the server.
   * Checks if the underlying client transport connection is active.
   */
  isConnected(): boolean;
  /**
   *  Reads holding registers (FC03).
   * Reads one or more holding registers (Function Code 03).
   * @param options Options for reading registers.
   * @param options.address The starting register address.
   * @param options.quantity The number of registers to read.
   * @param options.signal An optional `AbortSignal` to cancel the operation.
   */
  readHoldingRegisters(options: ReadRegistersOptions): Promise<Uint16Array>;
  /**
   *  Reads input registers (FC04).
   * Reads one or more input registers (Function Code 04).
   * @param options Options for reading registers.
   * @param options.address The starting register address.
   * @param options.quantity The number of registers to read.
   * @param options.signal An optional `AbortSignal` to cancel the operation.
   */
  readInputRegisters(options: ReadRegistersOptions): Promise<Uint16Array>;
  /**
   *  Writes a single register (FC06).
   * Writes a single holding register (Function Code 06).
   * @param options Options for writing a single register.
   * @param options.address The register address.
   * @param options.value The 16-bit value to write.
   * @param options.signal An optional `AbortSignal` to cancel the operation.
   */
  writeSingleRegister(options: WriteSingleRegisterOptions): Promise<void>;
  /**
   *  Writes multiple registers (FC16).
   * Writes multiple consecutive holding registers (Function Code 16).
   * @param options Options for writing multiple registers.
   * @param options.address The starting register address.
   * @param options.values An array of 16-bit values to write.
   * @param options.signal An optional `AbortSignal` to cancel the operation.
   */
  writeMultipleRegisters(options: WriteMultipleRegistersOptions): Promise<void>;
  /**
   *  Reads and writes multiple registers atomically (FC23).
   * Performs an atomic read/write operation on multiple registers (Function Code 23).
   * @param options Options for the read/write operation.
   * @param options.read_address The starting address for the read operation.
   * @param options.read_quantity The number of registers to read.
   * @param options.write_address The starting address for the write operation.
   * @param options.write_values An array of 16-bit values to write.
   * @param options.signal An optional `AbortSignal` to cancel the operation.
   */
  readWriteMultipleRegisters(options: ReadWriteMultipleRegistersOptions): Promise<Uint16Array>;
  /**
   *  Reads coils (FC01).
   * Reads the status of one or more coils (Function Code 01).
   * @param {ReadBitsOptions} options - Options for reading bits.
   * @param {number} options.address - The starting coil address.
   * @param {number} options.quantity - The number of coils to read.
   * @param {AbortSignal} [options.signal] - An optional cancellation signal.
   * @returns {Promise<CoilState[]>} - A promise that resolves to an array representing the coil states.
   *
   * @example
   * ```javascript
   * const coils = await client.readCoils({ address: 0, quantity: 8 });
   * console.log(coils); // e.g., [1, 0, 1, ...]
   * ```
   */
  readCoils(options: ReadBitsOptions): Promise<CoilState[]>;
  /**
   *  Writes a single coil (FC05).
   * Writes a single coil (Function Code 05).
   * @param {WriteSingleCoilOptions} options - Options for writing a single coil.
   * @param {number} options.address - The coil address.
   * @param {CoilState} options.value - The coil state to write.
   * @param {AbortSignal} [options.signal] - An optional cancellation signal.
   * @returns {`Promise<void>`} - A promise that resolves when the write is complete.
   *
   * @example
   * ```javascript
   * await client.writeSingleCoil({ address: 10, value: CoilState.On });
   * ```
   */
  writeSingleCoil(options: WriteSingleCoilOptions): Promise<void>;
  /**
   *  Writes multiple coils (FC15).
   * Writes multiple consecutive coils (Function Code 15).
   * @param {WriteMultipleCoilsOptions} options - Options for writing multiple coils.
   * @param {number} options.address - The starting coil address.
   * @param {CoilState[]} options.values - An array of coil states to write.
   * @param {AbortSignal} [options.signal] - An optional cancellation signal.
   * @returns {`Promise<void>`} - A promise that resolves when the write is complete.
   *
   * @example
   * ```javascript
   * await client.writeMultipleCoils({ address: 20, values: [CoilState.On, CoilState.Off] });
   * ```
   */
  writeMultipleCoils(options: WriteMultipleCoilsOptions): Promise<void>;
  /**
   *  Reads discrete inputs (FC02).
   * Reads the status of one or more discrete inputs (Function Code 02).
   * @param {ReadBitsOptions} options - Options for reading bits.
   * @param {number} options.address - The starting discrete input address.
   * @param {number} options.quantity - The number of discrete inputs to read.
   * @param {AbortSignal} [options.signal] - An optional cancellation signal.
   * @returns {Promise<DiscreteInputState[]>} - A promise that resolves to an array of states.
   *
   * @example
   * ```javascript
   * const inputs = await client.readDiscreteInputs({ address: 0, quantity: 4 });
   * ```
   */
  readDiscreteInputs(options: ReadBitsOptions): Promise<DiscreteInputState[]>;
  /**
   *  Reads FIFO queue (FC24).
   * Reads from a FIFO queue register (Function Code 24).
   * @param options Options for reading the FIFO queue.
   * @param options.address The FIFO pointer address.
   * @param options.signal An optional `AbortSignal` to cancel the operation.
   *
   * @example
   * ```javascript
   * const fifoContents = await client.readFifoQueue({ address: 42 });
   * ```
   */
  readFifoQueue(options: ReadFifoQueueOptions): Promise<FifoQueueResponse>;
  /**
   *  Reads file records (FC20).
   * Reads one or more file records (Function Code 20).
   * @param options Options for reading file records.
   * @param options.requests An array of file record read sub-requests.
   * @param options.signal An optional `AbortSignal` to cancel the operation.
   *
   * @example
   * ```javascript
   * const records = await client.readFileRecord({
   *   requests: [
   *     { fileNumber: 4, recordNumber: 1, recordLength: 2 }
   *   ]
   * });
   * ```
   */
  readFileRecord(options: ReadFileRecordOptions): Promise<Uint16Array[]>;
  /**
   *  Writes file records (FC21).
   * Writes one or more file records (Function Code 21).
   * @param options Options for writing file records.
   * @param options.requests An array of file record write sub-requests.
   * @param options.signal An optional `AbortSignal` to cancel the operation.
   */
  writeFileRecord(options: WriteFileRecordOptions): Promise<void>;
  /**
   *  Reads exception status (FC07).
   * Reads the device's exception status byte (Function Code 07).
   */
  readExceptionStatus(): Promise<number>;
  /**
   *  Sends a diagnostics request (FC08).
   * Executes a diagnostic function on the device (Function Code 08).
   * @param options Options for the diagnostics request.
   * @param options.sub_function The diagnostic sub-function code.
   * @param options.data Data to be sent with the request.
   * @param options.signal An optional `AbortSignal` to cancel the operation.
   */
  diagnostics(options: DiagnosticsOptions): Promise<DiagnosticsResponse>;
  /**
   *  Reads device identification (FC43/MEI14).
   * Reads device identification information (Function Code 43, MEI 14).
   * @param options Options for reading device identification.
   * @param options.read_device_id_code The category of objects to read (e.g., basic, regular).
   * @param options.object_id The ID of the first object to read.
   * @param options.signal An optional `AbortSignal` to cancel the operation.
   */
  readDeviceIdentification(options: ReadDeviceIdentificationOptions): Promise<DeviceIdentificationResponse>;
}

/**
 *  Async Modbus TCP server.
 *
 *  Binds to a TCP port and handles incoming Modbus requests using JS callbacks.
 * An asynchronous Modbus TCP server that listens for incoming client connections.
 */
export declare class AsyncTcpModbusServer {
  /**
   *  Creates and starts a new TCP server.
   * Creates and starts a new Modbus TCP server.
   *
   * @param {TcpServerOptions} options Server bind options.
   * @param {string} options.host The host address to bind to (e.g., '0.0.0.0').
   * @param {number} options.port The TCP port to listen on.
   * @param {number} options.unitId The Modbus unit ID the server will respond to.
   * @param {ServerHandlers} handlers An object containing callback functions to handle Modbus requests.
   * @returns {`Promise<AsyncTcpModbusServer>`} A `Promise` that resolves to a running `AsyncTcpModbusServer` instance.
   */
  static bind(options: TcpServerOptions, handlers: ServerHandlers): Promise<AsyncTcpModbusServer>;
  /**
   *  Stops the server.
   * Stops the server and closes all active connections.
   */
  shutdown(): Promise<void>;
}

/**
 *  Physical TCP socket connection to a Modbus device or gateway.
 * Manages a physical TCP socket connection to a Modbus device or gateway.
 * This class is a factory for creating lightweight `AsyncTcpModbusClient` instances
 * that are bound to a specific unit ID and share the underlying TCP connection.
 *
 * Use the static `connect` method to establish a connection.
 */
export declare class AsyncTcpTransport {
  /**
   *  Connects to a Modbus TCP device or gateway.
   * Establishes a connection to a Modbus TCP device or gateway.
   *
   * @param options - Connection options including host, port, and timeout settings.
   * @param options.host - Target host address (IP or hostname).
   * @param options.port - Target TCP port (typically 502).
   */
  static connect(options: TcpTransportOptions): Promise<AsyncTcpTransport>;
  /**
   *  Creates a device client bound to the specified unit ID.
   * Creates a lightweight device client that communicates through this transport.
   * The client is bound to a specific Modbus unit ID.
   *
   * @param options - Options specifying the unit ID.
   */
  createClient(options: CreateClientOptions): AsyncTcpModbusClient;
  /**
   *  Sets the per-request timeout in milliseconds.
   * Sets the timeout for individual Modbus requests made through this transport.
   *
   * @param timeout_ms - The timeout duration in milliseconds.
   */
  setRequestTimeout(timeoutMs: number): void;
  /**
   *  Clears the per-request timeout.
   * Clears any previously set per-request timeout, reverting to the default behavior.
   */
  clearRequestTimeout(): void;
  /**
   *  Returns whether there are pending requests.
   * Checks if there are any Modbus requests currently in-flight on this transport.
   */
  readonly pendingRequests: boolean;
  /**
   *  Closes the connection.
   * Closes the underlying TCP connection and shuts down the transport.
   */
  close(): Promise<void>;
  /**
   *  Reconnects the transport after a disconnect.
   * Attempts to re-establish the TCP connection if it has been closed.
   */
  reconnect(): Promise<void>;
}

/** Connection options for the serial ASCII transport. */
export interface AsciiTransportOptions {
  /** Serial port path (e.g., "/dev/ttyUSB0", "COM3"). */
  portPath: string;
  /** Baud rate (e.g., 9600, 19200, 38400, 57600, 115200). */
  baudRate: number;
  /** Data bits (5, 6, 7, or 8). */
  dataBits?: 5 | 6 | 7 | 8;
  /** Parity ("none", "even", "odd"). */
  parity?: 'none' | 'even' | 'odd';
  /** Stop bits (1 or 2). */
  stopBits?: 1 | 2;
  /** Response timeout in milliseconds. */
  responseTimeoutMs?: number;
  /** Per-request timeout in milliseconds. Note: This feature is currently ineffective and is reserved for future implementation. A GitHub RFC discussion is open to decide whether to implement or remove it. */
  requestTimeoutMs?: number;
  /** Number of retry attempts on failure (0 = none). Default: 0. */
  retryAttempts?: number;
  /** Delay between retry attempts in milliseconds. */
  retryDelayMs?: number;
  /** Backoff strategy: "immediate", "fixed", or "exponential". Default: "immediate". Note: This feature is currently ineffective and is reserved for future implementation. A GitHub RFC discussion is open to decide whether to implement or remove it. */
  retryBackoffStrategy?: string;
}

/** Represents a Modbus coil or discrete input state. */
export enum CoilState {
  /** Coil is OFF (wire value: 0). */
  Off = 0,
  /** Coil is ON (wire value: 1). */
  On = 1
}

/** Options for creating a client bound to a specific unit ID. */
export interface CreateClientOptions {
  /** Modbus unit ID (slave address) from 1 to 247. */
  unitId: number;
}

/** Device identification object. */
export interface DeviceIdentificationObject {
  /** The object ID. */
  id: number;
  /** The value of the object, represented as a string. */
  value: string;
}

/** Response from device identification request. */
export interface DeviceIdentificationResponse {
  /** The conformity level of the device. */
  conformityLevel: number;
  /** Indicates if more objects are available to be read. */
  moreFollows: boolean;
  /** The ID of the next object to read if moreFollows is true. */
  nextObjectId: number;
  /** An array of device identification objects. */
  objects: Array<DeviceIdentificationObject>;
}

/** Options for diagnostics request. */
export interface DiagnosticsOptions {
  /** Diagnostic sub-function code. */
  subFunction: number;
  /** Data to be sent with the diagnostics request. */
  data?: Uint16Array;
  /** An optional `AbortSignal` to cancel the asynchronous operation. */
  signal?: AbortSignal;
}

/** Handler request for diagnostics. */
export interface DiagnosticsRequest {
  /** The unit ID of the device that sent the request. */
  unitId: number;
  /** The diagnostic sub-function code to execute. */
  subFunction: number;
  /** Data sent with the diagnostics request. */
  data: Uint16Array;
}

/** Response from diagnostics request. */
export interface DiagnosticsResponse {
  /** The sub-function code from the request. */
  subFunction: number;
  /** The data returned by the diagnostics function. */
  data: Uint16Array;
}

/** Downstream server configuration. */
export interface DownstreamConfig {
  /** Downstream server host. */
  host: string;
  /** Downstream server port. */
  port: number;
}

/** Response from reading FIFO queue. */
export interface FifoQueueResponse {
  /** The number of 16-bit values in the queue. */
  count: number;
  /** Queue values. */
  values: Uint16Array;
}

/** A single file record read sub-request. */
export interface FileRecordReadRequest {
  /** The file number (1-65535). */
  fileNumber: number;
  /** The starting record number within the file. */
  recordNumber: number;
  /** The number of records to read. */
  recordLength: number;
}

/** A single file record read sub-request on the server side. */
export interface FileRecordReadServerSubRequest {
  /** The file number (1-65535). */
  fileNumber: number;
  /** The starting record number within the file. */
  recordNumber: number;
  /** The number of records to read. */
  recordLength: number;
}

/** A single file record write sub-request. */
export interface FileRecordWriteRequest {
  /** The file number (1-65535). */
  fileNumber: number;
  /** The starting record number within the file. */
  recordNumber: number;
  /** The record data to write, as an array of 16-bit values. */
  recordData: Uint16Array;
}

/** A single file record write sub-request on the server side. */
export interface FileRecordWriteSubRequest {
  /** The file number (1-65535). */
  fileNumber: number;
  /** The starting record number within the file. */
  recordNumber: number;
  /** The record data to write, as an array of 16-bit values. */
  recordData: Uint16Array;
}

/** Gateway bind options. */
export interface GatewayBindOptions {
  /** Bind host address (e.g., "0.0.0.0"). */
  host: string;
  /** Bind port. */
  port: number;
}

/** Gateway configuration. */
export interface GatewayConfig {
  /** List of downstream servers. */
  downstreams: Array<DownstreamConfig>;
  /** Routing table mapping unit IDs to downstream channels. */
  routes: Array<RouteEntry>;
}

/** Options for modifying a register with a bitwise mask (FC22). */
export interface MaskWriteRegisterOptions {
  /** Target register address. */
  address: number;
  /** Bitwise AND mask. */
  andMask: number;
  /** Bitwise OR mask. */
  orMask: number;
  /** An optional `AbortSignal` to cancel the asynchronous operation. */
  signal?: AbortSignal;
}

/** Standard Modbus exception codes. */
export enum ModbusExceptionCode {
  /** Function code received in the query is not an allowable action for the server. */
  IllegalFunction = 1,
  /** The data address received in the query is not an allowable address for the server. */
  IllegalDataAddress = 2,
  /** A value contained in the query data field is not an allowable value for the server. */
  IllegalDataValue = 3,
  /** An unrecoverable error occurred while the server was attempting to perform the requested action. */
  ServerDeviceFailure = 4,
  /** The server has accepted the request and is processing it, but a long duration of time will be required. */
  Acknowledge = 5,
  /** The server is engaged in processing a long-duration program command. */
  SlaveDeviceBusy = 6,
  /** The server attempted to read record file, but detected a parity error in the memory. */
  MemoryParityError = 8,
  /** Specialized for gateways: The gateway was unable to allocate an internal communication path. */
  GatewayPathUnavailable = 10,
  /** Specialized for gateways: No response was received from the target device. */
  GatewayTargetDeviceFailedToRespond = 11
}

/** Options for reading coils or discrete inputs. */
export interface ReadBitsOptions {
  /** Starting address. */
  address: number;
  /** Number of bits (coils or discrete inputs) to read. */
  quantity: number;
  /** An optional `AbortSignal` to cancel the asynchronous operation. */
  signal?: AbortSignal;
}

/** Handler request for reading coils. */
export interface ReadCoilsRequest {
  /** The unit ID of the device that sent the request. */
  unitId: number;
  /** The starting address of the coils to read. */
  address: number;
  /** The number of coils to read. */
  quantity: number;
}

/** Options for device identification. */
export interface ReadDeviceIdentificationOptions {
  /** Read device ID code (1=basic, 2=regular, 3=extended, 4=individual). */
  readDeviceIdCode?: number;
  /** The ID of the first object to read. */
  objectId?: number;
  /** An optional `AbortSignal` to cancel the asynchronous operation. */
  signal?: AbortSignal;
}

/** Request parameters for reading device identification (MEI FC43/14). */
export interface ReadDeviceIdentificationRequest {
  /** Target device address. */
  unitId: number;
  /** Read device ID code (1, 2, 3, or 4). */
  readDeviceIdCode: number;
  /** Starting object ID (0 to 255). */
  objectId: number;
}

/** Handler request for reading discrete inputs. */
export interface ReadDiscreteInputsRequest {
  /** The unit ID of the device that sent the request. */
  unitId: number;
  /** The starting address of the discrete inputs to read. */
  address: number;
  /** The number of discrete inputs to read. */
  quantity: number;
}

/** Handler request for reading exception status. */
export interface ReadExceptionStatusRequest {
  /** The unit ID of the device that sent the request. */
  unitId: number;
}

/** Options for reading FIFO queue. */
export interface ReadFifoQueueOptions {
  /** FIFO pointer address. */
  address: number;
  /** An optional `AbortSignal` to cancel the asynchronous operation. */
  signal?: AbortSignal;
}

/** Handler request for reading FIFO queue. */
export interface ReadFifoQueueRequest {
  /** The unit ID of the device that sent the request. */
  unitId: number;
  /** The address of the FIFO queue pointer register. */
  address: number;
}

/** Options for reading file records. */
export interface ReadFileRecordOptions {
  /** An array of file record read sub-requests. */
  requests: Array<FileRecordReadRequest>;
  /** An optional `AbortSignal` to cancel the asynchronous operation. */
  signal?: AbortSignal;
}

/** Handler request for reading file records. */
export interface ReadFileRecordRequest {
  /** The unit ID of the device that sent the request. */
  unitId: number;
  /** An array of file record read sub-requests. */
  requests: Array<FileRecordReadServerSubRequest>;
}

/** Handler request for reading holding registers. */
export interface ReadHoldingRegistersRequest {
  /** The unit ID of the device that sent the request. */
  unitId: number;
  /** The starting address of the holding registers to read. */
  address: number;
  /** The number of holding registers to read. */
  quantity: number;
}

/** Handler request for reading input registers. */
export interface ReadInputRegistersRequest {
  /** The unit ID of the device that sent the request. */
  unitId: number;
  /** The starting address of the input registers to read. */
  address: number;
  /** The number of input registers to read. */
  quantity: number;
}

/** Options for reading registers. */
export interface ReadRegistersOptions {
  /** Starting register address. */
  address: number;
  /** Number of registers to read (quantity). */
  quantity: number;
  /** An optional `AbortSignal` to cancel the asynchronous operation. */
  signal?: AbortSignal;
}

/** Options for read/write multiple registers (FC23). */
export interface ReadWriteMultipleRegistersOptions {
  /** Starting address for read operation. */
  readAddress: number;
  /** Number of registers to read (quantity). */
  readQuantity: number;
  /** Starting address for write operation. */
  writeAddress: number;
  /** An array of 16-bit values to write. */
  writeValues: Uint16Array;
  /** An optional `AbortSignal` to cancel the asynchronous operation. */
  signal?: AbortSignal;
}

/** Handler request for read/write multiple registers (FC23). */
export interface ReadWriteMultipleRegistersRequest {
  /** The unit ID of the device that sent the request. */
  unitId: number;
  /** The starting address for the read operation. */
  readAddress: number;
  /** The number of registers to read. */
  readQuantity: number;
  /** The starting address for the write operation. */
  writeAddress: number;
  /** The array of 16-bit values to write. */
  writeValues: Uint16Array;
}

/** Route entry mapping unit ID to a downstream channel. */
export interface RouteEntry {
  /** Modbus unit ID (1-247). */
  unitId: number;
  /** Index into the downstreams array. */
  channel: number;
}

/** Connection options for the serial RTU transport. */
export interface RtuTransportOptions {
  /** Serial port path (e.g., "/dev/ttyUSB0", "COM3"). */
  portPath: string;
  /** Baud rate (e.g., 9600, 19200, 38400, 57600, 115200). */
  baudRate: number;
  /** Data bits (5, 6, 7, or 8). */
  dataBits?: 5 | 6 | 7 | 8;
  /** Parity ("none", "even", "odd"). */
  parity?: 'none' | 'even' | 'odd';
  /** Stop bits (1 or 2). */
  stopBits?: 1 | 2;
  /** Response timeout in milliseconds. */
  responseTimeoutMs?: number;
  /** Per-request timeout in milliseconds. Note: This feature is currently ineffective and is reserved for future implementation. A GitHub RFC discussion is open to decide whether to implement or remove it. */
  requestTimeoutMs?: number;
  /** Number of retry attempts on failure (0 = none). Default: 0. */
  retryAttempts?: number;
  /** Delay between retry attempts in milliseconds. */
  retryDelayMs?: number;
  /** Backoff strategy: "immediate", "fixed", or "exponential". Default: "immediate". Note: This feature is currently ineffective and is reserved for future implementation. A GitHub RFC discussion is open to decide whether to implement or remove it. */
  retryBackoffStrategy?: string;
}

/** Server bind options for serial port. */
export interface SerialServerOptions {
  /** Serial port path (e.g., "/dev/ttyUSB0", "COM3"). */
  portPath: string;
  /** Baud rate (e.g., 9600, 19200, 38400, 57600, 115200). */
  baudRate: number;
  /** Data bits (5, 6, 7, or 8). */
  dataBits?: 5 | 6 | 7 | 8;
  /** Parity ("none", "even", "odd"). */
  parity?: 'none' | 'even' | 'odd';
  /** Stop bits (1 or 2). */
  stopBits?: 1 | 2;
  /** Modbus unit ID (1-247) for the server to respond to. */
  unitId: number;
  /** Response timeout in milliseconds. */
  responseTimeoutMs?: number;
}

/** Handler response for diagnostics. */
export interface ServerDiagnosticsResponse {
  /** The sub-function code from the request. */
  subFunction: number;
  /** The data to be returned by the diagnostics function. */
  data: Uint16Array;
}

/** Server bind options. */
export interface TcpServerOptions {
  /** Bind host address (e.g., "0.0.0.0"). */
  host: string;
  /** Bind port. */
  port: number;
  /** Modbus unit ID to respond to. */
  unitId: number;
}

/** Connection options for the TCP transport. */
export interface TcpTransportOptions {
  /** Target host address (IP or hostname). */
  host: string;
  /** Target TCP port (typically 502). */
  port: number;
  /** Per-request timeout in milliseconds. Note: This feature is currently ineffective and is reserved for future implementation. A GitHub RFC discussion is open to decide whether to implement or remove it. */
  requestTimeoutMs?: number;
  /** Number of retry attempts on failure. Default: 0 (no retries). */
  retryAttempts?: number;
  /** Delay between retry attempts in milliseconds. */
  retryDelayMs?: number;
  /** Backoff strategy for retries: "immediate", "fixed", or "exponential". Default: "immediate". Note: This feature is currently ineffective and is reserved for future implementation. A GitHub RFC discussion is open to decide whether to implement or remove it. */
  retryBackoffStrategy?: string;
}

/** Options for writing file records. */
export interface WriteFileRecordOptions {
  /** An array of file record write sub-requests. */
  requests: Array<FileRecordWriteRequest>;
  /** An optional `AbortSignal` to cancel the asynchronous operation. */
  signal?: AbortSignal;
}

/** Handler request for writing file records. */
export interface WriteFileRecordRequest {
  /** The unit ID of the device that sent the request. */
  unitId: number;
  /** An array of file record write sub-requests. */
  requests: Array<FileRecordWriteSubRequest>;
}

/** Options for writing multiple coils. */
export interface WriteMultipleCoilsOptions {
  /** Starting coil address. */
  address: number;
  /** An array of coil states to write. */
  values: Array<CoilState>;
  /** An optional `AbortSignal` to cancel the asynchronous operation. */
  signal?: AbortSignal;
}

/** Handler request for writing multiple coils. */
export interface WriteMultipleCoilsRequest {
  /** The unit ID of the device that sent the request. */
  unitId: number;
  /** The starting address of the coils to write to. */
  address: number;
  /** The array of coil states to write. */
  values: CoilState[];
}

/** Options for writing multiple registers. */
export interface WriteMultipleRegistersOptions {
  /** The starting register address. */
  address: number;
  /** An array of 16-bit values to write. */
  values: Uint16Array;
  /** An optional `AbortSignal` to cancel the asynchronous operation. */
  signal?: AbortSignal;
}

/** Handler request for writing multiple registers. */
export interface WriteMultipleRegistersRequest {
  /** The unit ID of the device that sent the request. */
  unitId: number;
  /** The starting address of the registers to write to. */
  address: number;
  /** The array of 16-bit values to write. */
  values: Uint16Array;
}

/** Options for writing a single coil. */
export interface WriteSingleCoilOptions {
  /** The coil address. */
  address: number;
  /** The coil state (CoilState.On = 1, CoilState.Off = 0). */
  value: CoilState;
  /** An optional `AbortSignal` to cancel the asynchronous operation. */
  signal?: AbortSignal;
}

/** Handler request for writing a single coil. */
export interface WriteSingleCoilRequest {
  /** The unit ID of the device that sent the request. */
  unitId: number;
  /** The address of the coil to write to. */
  address: number;
  /** The coil state (CoilState.On = 1, CoilState.Off = 0). */
  value: CoilState;
}

/** Options for writing a single register. */
export interface WriteSingleRegisterOptions {
  /** The register address. */
  address: number;
  /** The 16-bit value to write. */
  value: number;
  /** An optional `AbortSignal` to cancel the asynchronous operation. */
  signal?: AbortSignal;
}

/** Handler request for writing a single register. */
export interface WriteSingleRegisterRequest {
  /** The unit ID of the device that sent the request. */
  unitId: number;
  /** The address of the register to write to. */
  address: number;
  /** The 16-bit value to write. */
  value: number;
}

/** Represents a Modbus discrete input pin state (alias for CoilState). */
export type DiscreteInputState = CoilState;
export declare const DiscreteInputState: typeof CoilState;

/** Modbus exception returned from a server handler. */
export interface ModbusException {
  /** The Modbus exception code. */
  exceptionCode: ModbusExceptionCode | number;
}

/**
 * Callback functions to handle Modbus server requests.
 * 
 * Each handler corresponds to a specific Modbus function code. If a handler is not provided,
 * the server will respond with an "Illegal Function" exception (0x01).
 * 
 * Handlers can return the expected data directly or return a Promise for async operations.
 * To return a Modbus exception, return an object matching the `ModbusException` interface.
 */
export interface ServerHandlers {
  /**
   * Handle Read Coils (FC 01).
   * @param req The request object.
   * @param req.address The starting coil address (0x0000 to 0xFFFF).
   * @param req.quantity The number of coils to read (1 to 2000).
   * @returns An array of booleans representing the coil states, or a ModbusException.
   */
  onReadCoils?: (req: ReadCoilsRequest) => CoilState[] | ModbusException | Promise<CoilState[] | ModbusException>;

  /**
   * Handle Read Discrete Inputs (FC 02).
   * @param req The request object.
   * @param req.address The starting discrete input address (0x0000 to 0xFFFF).
   * @param req.quantity The number of inputs to read (1 to 2000).
   * @returns An array of discrete input states, or a ModbusException.
   */
  onReadDiscreteInputs?: (req: ReadDiscreteInputsRequest) => DiscreteInputState[] | ModbusException | Promise<DiscreteInputState[] | ModbusException>;

  /**
   * Handle Read Holding Registers (FC 03).
   * @param req The request object.
   * @param req.address The starting holding register address (0x0000 to 0xFFFF).
   * @param req.quantity The number of registers to read (1 to 125).
   * @returns An array of 16-bit numbers representing the registers, or a ModbusException.
   */
  onReadHoldingRegisters?: (req: ReadHoldingRegistersRequest) => Uint16Array | ModbusException | Promise<Uint16Array | ModbusException>;

  /**
   * Handle Read Input Registers (FC 04).
   * @param req The request object.
   * @param req.address The starting input register address (0x0000 to 0xFFFF).
   * @param req.quantity The number of registers to read (1 to 125).
   * @returns An array of 16-bit numbers representing the registers, or a ModbusException.
   */
  onReadInputRegisters?: (req: ReadInputRegistersRequest) => Uint16Array | ModbusException | Promise<Uint16Array | ModbusException>;

  /**
   * Handle Write Single Coil (FC 05).
   * @param req The request object.
   * @param req.address The address of the coil to write (0x0000 to 0xFFFF).
   * @param req.value The boolean value to write (true for ON, false for OFF).
   * @returns void on success, or a ModbusException.
   */
  onWriteSingleCoil?: (req: WriteSingleCoilRequest) => void | ModbusException | Promise<void | ModbusException>;

  /**
   * Handle Write Single Register (FC 06).
   * @param req The request object.
   * @param req.address The address of the register to write (0x0000 to 0xFFFF).
   * @param req.value The 16-bit value to write.
   * @returns void on success, or a ModbusException.
   */
  onWriteSingleRegister?: (req: WriteSingleRegisterRequest) => void | ModbusException | Promise<void | ModbusException>;

  /**
   * Handle Read Exception Status (FC 07).
   * @param req The read exception status request object (empty).
   * @returns An 8-bit exception status byte, or a ModbusException.
   */
  onReadExceptionStatus?: (req: ReadExceptionStatusRequest) => number | ModbusException | Promise<number | ModbusException>;

  /**
   * Handle Diagnostics (FC 08).
   * @param req The diagnostics request object.
   * @param req.subFunction The 16-bit sub-function code.
   * @param req.data The 16-bit data payload for the sub-function.
   * @returns A response containing the sub-function and data, or a ModbusException.
   */
  onDiagnostics?: (req: DiagnosticsRequest) => ServerDiagnosticsResponse | ModbusException | Promise<ServerDiagnosticsResponse | ModbusException>;

  /**
   * Handle Write Multiple Coils (FC 15).
   * @param req The request object.
   * @param req.address The starting address of the coils to write.
   * @param req.values An array of booleans to write.
   * @returns void on success, or a ModbusException.
   */
  onWriteMultipleCoils?: (req: WriteMultipleCoilsRequest) => void | ModbusException | Promise<void | ModbusException>;

  /**
   * Handle Write Multiple Registers (FC 16).
   * @param req The request object.
   * @param req.address The starting address of the registers to write.
   * @param req.values An array of 16-bit numbers to write.
   * @returns void on success, or a ModbusException.
   */
  onWriteMultipleRegisters?: (req: WriteMultipleRegistersRequest) => void | ModbusException | Promise<void | ModbusException>;

  /**
   * Handle Read File Record (FC 20).
   * @param req The request object.
   * @param req.requests An array of sub-requests, each with `fileNumber`, `recordNumber`, and `recordLength`.
   * @returns An array of register arrays for each sub-request, or a ModbusException.
   */
  onReadFileRecord?: (req: ReadFileRecordRequest) => Uint16Array[] | ModbusException | Promise<Uint16Array[] | ModbusException>;

  /**
   * Handle Write File Record (FC 21).
   * @param req The request object.
   * @param req.requests An array of sub-requests, each with `fileNumber`, `recordNumber`, and `recordData` (a Uint16Array).
   * @returns void on success, or a ModbusException.
   */
  onWriteFileRecord?: (req: WriteFileRecordRequest) => void | ModbusException | Promise<void | ModbusException>;

  /**
   * Handle Read/Write Multiple Registers (FC 23).
   * @param req The request containing addresses and values to read and write.
   * @param req.readAddress The starting address for the read operation.
   * @param req.readQuantity The number of registers to read.
   * @param req.writeAddress The starting address for the write operation.
   * @param req.values An array of 16-bit numbers to write.
   * @returns An array of 16-bit numbers read, or a ModbusException.
   */
  onReadWriteMultipleRegisters?: (req: ReadWriteMultipleRegistersRequest) => Uint16Array | ModbusException | Promise<Uint16Array | ModbusException>;

  /**
   * Handle Read FIFO Queue (FC 24).
   * @param req The request object containing the FIFO pointer `address`.
   * @returns An array of 16-bit numbers from the queue, or a ModbusException.
   */
  onReadFifoQueue?: (req: ReadFifoQueueRequest) => Uint16Array | ModbusException | Promise<Uint16Array | ModbusException>;

  /**
   * Handle Read Device Identification (FC 43/14).
   * @param req The request object.
   * @returns Device identification response, or a ModbusException.
   */
  onReadDeviceIdentification?: (req: ReadDeviceIdentificationRequest) => DeviceIdentificationResponse | ModbusException | Promise<DeviceIdentificationResponse | ModbusException>;
}

/**
 * Stable error codes for identifying Modbus-related errors.
 * These can be used with the `getModbusErrorCode` helper to check for specific error types.
 */
export declare const ModbusErrorCode: {
  /** A Modbus exception response was received from the server (e.g., illegal function). */
  readonly EXCEPTION: 'MODBUS_EXCEPTION';
  /** The request timed out waiting for a response. */
  readonly TIMEOUT: 'MODBUS_TIMEOUT';
  /** A transport-level error occurred (e.g., framing error, checksum mismatch). */
  readonly TRANSPORT: 'MODBUS_TRANSPORT';
  /** An invalid argument was provided to a client or server function. */
  readonly INVALID_ARGUMENT: 'MODBUS_INVALID_ARGUMENT';
  /** The underlying connection was closed. */
  readonly CONNECTION_CLOSED: 'MODBUS_CONNECTION_CLOSED';
  /** An unexpected internal error occurred within the library. */
  readonly INTERNAL: 'MODBUS_INTERNAL';
};

/**
 * Extracts a stable error code from a Modbus error object.
 * @param err The error object.
 * @returns The corresponding code from `ModbusErrorCode`, or undefined if not a Modbus error.
 */
export declare function getModbusErrorCode(err: Error): string | undefined;

export {
  WasmWsTransport,
  WasmWsModbusClient,
  WasmWsModbusServer,
  WasmSerialModbusClient,
  WasmSerialModbusServer,
  WasmSerialPortHandle,
  WasmRtuTransport,
  WasmAsciiTransport,
  WasmServerTransportKind,
  requestSerialPort
} from 'modbus-rs-wasm';

/** Represents a Modbus discrete input pin state (alias for CoilState). */
export type DiscreteInputState = CoilState;
export declare const DiscreteInputState: typeof CoilState;

/** Modbus exception returned from a server handler. */
export interface ModbusException {
  /** The Modbus exception code. */
  exceptionCode: ModbusExceptionCode | number;
}

/**
 * Callback functions to handle Modbus server requests.
 * 
 * Each handler corresponds to a specific Modbus function code. If a handler is not provided,
 * the server will respond with an "Illegal Function" exception (0x01).
 * 
 * Handlers can return the expected data directly or return a Promise for async operations.
 * To return a Modbus exception, return an object matching the `ModbusException` interface.
 */
export interface ServerHandlers {
  /**
   * Handle Read Coils (FC 01).
   * @param req The request object.
   * @param req.address The starting coil address (0x0000 to 0xFFFF).
   * @param req.quantity The number of coils to read (1 to 2000).
   * @returns An array of booleans representing the coil states, or a ModbusException.
   */
  onReadCoils?: (req: ReadCoilsRequest) => CoilState[] | ModbusException | Promise<CoilState[] | ModbusException>;

  /**
   * Handle Read Discrete Inputs (FC 02).
   * @param req The request object.
   * @param req.address The starting discrete input address (0x0000 to 0xFFFF).
   * @param req.quantity The number of inputs to read (1 to 2000).
   * @returns An array of discrete input states, or a ModbusException.
   */
  onReadDiscreteInputs?: (req: ReadDiscreteInputsRequest) => DiscreteInputState[] | ModbusException | Promise<DiscreteInputState[] | ModbusException>;

  /**
   * Handle Read Holding Registers (FC 03).
   * @param req The request object.
   * @param req.address The starting holding register address (0x0000 to 0xFFFF).
   * @param req.quantity The number of registers to read (1 to 125).
   * @returns An array of 16-bit numbers representing the registers, or a ModbusException.
   */
  onReadHoldingRegisters?: (req: ReadHoldingRegistersRequest) => Uint16Array | ModbusException | Promise<Uint16Array | ModbusException>;

  /**
   * Handle Read Input Registers (FC 04).
   * @param req The request object.
   * @param req.address The starting input register address (0x0000 to 0xFFFF).
   * @param req.quantity The number of registers to read (1 to 125).
   * @returns An array of 16-bit numbers representing the registers, or a ModbusException.
   */
  onReadInputRegisters?: (req: ReadInputRegistersRequest) => Uint16Array | ModbusException | Promise<Uint16Array | ModbusException>;

  /**
   * Handle Write Single Coil (FC 05).
   * @param req The request object.
   * @param req.address The address of the coil to write (0x0000 to 0xFFFF).
   * @param req.value The boolean value to write (true for ON, false for OFF).
   * @returns void on success, or a ModbusException.
   */
  onWriteSingleCoil?: (req: WriteSingleCoilRequest) => void | ModbusException | Promise<void | ModbusException>;

  /**
   * Handle Write Single Register (FC 06).
   * @param req The request object.
   * @param req.address The address of the register to write (0x0000 to 0xFFFF).
   * @param req.value The 16-bit value to write.
   * @returns void on success, or a ModbusException.
   */
  onWriteSingleRegister?: (req: WriteSingleRegisterRequest) => void | ModbusException | Promise<void | ModbusException>;

  /**
   * Handle Read Exception Status (FC 07).
   * @param req The read exception status request object (empty).
   * @returns An 8-bit exception status byte, or a ModbusException.
   */
  onReadExceptionStatus?: (req: ReadExceptionStatusRequest) => number | ModbusException | Promise<number | ModbusException>;

  /**
   * Handle Diagnostics (FC 08).
   * @param req The diagnostics request object.
   * @param req.subFunction The 16-bit sub-function code.
   * @param req.data The 16-bit data payload for the sub-function.
   * @returns A response containing the sub-function and data, or a ModbusException.
   */
  onDiagnostics?: (req: DiagnosticsRequest) => ServerDiagnosticsResponse | ModbusException | Promise<ServerDiagnosticsResponse | ModbusException>;

  /**
   * Handle Write Multiple Coils (FC 15).
   * @param req The request object.
   * @param req.address The starting address of the coils to write.
   * @param req.values An array of booleans to write.
   * @returns void on success, or a ModbusException.
   */
  onWriteMultipleCoils?: (req: WriteMultipleCoilsRequest) => void | ModbusException | Promise<void | ModbusException>;

  /**
   * Handle Write Multiple Registers (FC 16).
   * @param req The request object.
   * @param req.address The starting address of the registers to write.
   * @param req.values An array of 16-bit numbers to write.
   * @returns void on success, or a ModbusException.
   */
  onWriteMultipleRegisters?: (req: WriteMultipleRegistersRequest) => void | ModbusException | Promise<void | ModbusException>;

  /**
   * Handle Read File Record (FC 20).
   * @param req The request object.
   * @param req.requests An array of sub-requests, each with `fileNumber`, `recordNumber`, and `recordLength`.
   * @returns An array of register arrays for each sub-request, or a ModbusException.
   */
  onReadFileRecord?: (req: ReadFileRecordRequest) => Uint16Array[] | ModbusException | Promise<Uint16Array[] | ModbusException>;

  /**
   * Handle Write File Record (FC 21).
   * @param req The request object.
   * @param req.requests An array of sub-requests, each with `fileNumber`, `recordNumber`, and `recordData` (a Uint16Array).
   * @returns void on success, or a ModbusException.
   */
  onWriteFileRecord?: (req: WriteFileRecordRequest) => void | ModbusException | Promise<void | ModbusException>;

  /**
   * Handle Read/Write Multiple Registers (FC 23).
   * @param req The request containing addresses and values to read and write.
   * @param req.readAddress The starting address for the read operation.
   * @param req.readQuantity The number of registers to read.
   * @param req.writeAddress The starting address for the write operation.
   * @param req.values An array of 16-bit numbers to write.
   * @returns An array of 16-bit numbers read, or a ModbusException.
   */
  onReadWriteMultipleRegisters?: (req: ReadWriteMultipleRegistersRequest) => Uint16Array | ModbusException | Promise<Uint16Array | ModbusException>;

  /**
   * Handle Read FIFO Queue (FC 24).
   * @param req The request object containing the FIFO pointer `address`.
   * @returns An array of 16-bit numbers from the queue, or a ModbusException.
   */
  onReadFifoQueue?: (req: ReadFifoQueueRequest) => Uint16Array | ModbusException | Promise<Uint16Array | ModbusException>;

  /**
   * Handle Read Device Identification (FC 43/14).
   * @param req The request object.
   * @returns Device identification response, or a ModbusException.
   */
  onReadDeviceIdentification?: (req: ReadDeviceIdentificationRequest) => DeviceIdentificationResponse | ModbusException | Promise<DeviceIdentificationResponse | ModbusException>;
}

/**
 * Stable error codes for identifying Modbus-related errors.
 * These can be used with the `getModbusErrorCode` helper to check for specific error types.
 */
export declare const ModbusErrorCode: {
  /** A Modbus exception response was received from the server (e.g., illegal function). */
  readonly EXCEPTION: 'MODBUS_EXCEPTION';
  /** The request timed out waiting for a response. */
  readonly TIMEOUT: 'MODBUS_TIMEOUT';
  /** A transport-level error occurred (e.g., framing error, checksum mismatch). */
  readonly TRANSPORT: 'MODBUS_TRANSPORT';
  /** An invalid argument was provided to a client or server function. */
  readonly INVALID_ARGUMENT: 'MODBUS_INVALID_ARGUMENT';
  /** The underlying connection was closed. */
  readonly CONNECTION_CLOSED: 'MODBUS_CONNECTION_CLOSED';
  /** An unexpected internal error occurred within the library. */
  readonly INTERNAL: 'MODBUS_INTERNAL';
};

/**
 * Extracts a stable error code from a Modbus error object.
 * @param err The error object.
 * @returns The corresponding code from `ModbusErrorCode`, or undefined if not a Modbus error.
 */
export declare function getModbusErrorCode(err: Error): string | undefined;

export {
  WasmWsTransport,
  WasmWsModbusClient,
  WasmWsModbusServer,
  WasmSerialModbusClient,
  WasmSerialModbusServer,
  WasmSerialPortHandle,
  WasmRtuTransport,
  WasmAsciiTransport,
  WasmServerTransportKind,
  requestSerialPort
} from 'modbus-rs-wasm';