/**
 * Base class for all Modbus-related errors.
 * All custom errors in this library extend from this class.
 */
export declare class ModbusError extends Error {
    constructor(message: string);
}
/**
 * Thrown when a Modbus request exceeds the configured timeout period.
 */
export declare class ModbusTimeoutError extends ModbusError {
    constructor(message?: string);
}
/**
 * Thrown when the CRC (Cyclic Redundancy Check) of a received Modbus frame is invalid.
 * Typically occurs in RTU mode due to transmission errors.
 */
export declare class ModbusCRCError extends ModbusError {
    constructor(message?: string);
}
/**
 * Base class for errors related to invalid or malformed Modbus responses.
 */
export declare class ModbusResponseError extends ModbusError {
    constructor(message?: string);
}
/**
 * Thrown when the transport layer returns too many empty reads consecutively.
 * Often indicates a disconnected or unresponsive device.
 */
export declare class ModbusTooManyEmptyReadsError extends ModbusError {
    constructor(message?: string);
}
/**
 * Thrown when the Modbus slave returns an exception response.
 * Contains the original function code and the exception code returned by the device.
 */
export declare class ModbusExceptionError extends ModbusError {
    /** The function code that was sent in the request */
    functionCode: number;
    /** The exception code returned by the slave */
    exceptionCode: number;
    /**
     * Creates a new ModbusExceptionError with a detailed message.
     * @param functionCode - The function code from the original request
     * @param exceptionCode - The exception code returned by the device
     */
    constructor(functionCode: number, exceptionCode: number);
}
/**
 * Thrown when a Modbus operation is interrupted by a transport flush.
 * Commonly used in half-duplex RS485 scenarios to signal that pending data was discarded.
 */
export declare class ModbusFlushError extends ModbusError {
    constructor(message?: string);
}
/**
 * Thrown when an invalid Modbus address (slave ID or register/coil address) is provided.
 */
export declare class ModbusInvalidAddressError extends ModbusError {
    constructor(address: number);
}
/**
 * Thrown when an unsupported or invalid Modbus function code is used.
 */
export declare class ModbusInvalidFunctionCodeError extends ModbusError {
    constructor(functionCode: number);
}
/**
 * Thrown when the quantity of registers or coils is outside the allowed range for a given function.
 */
export declare class ModbusInvalidQuantityError extends ModbusError {
    constructor(quantity: number, min: number, max: number);
}
/**
 * Represents the "Illegal Data Address" exception (Modbus exception code 0x02).
 */
export declare class ModbusIllegalDataAddressError extends ModbusError {
    constructor(address: number, quantity: number);
}
/**
 * Represents the "Illegal Data Value" exception (Modbus exception code 0x03).
 */
export declare class ModbusIllegalDataValueError extends ModbusError {
    constructor(value: number | string, expected: string);
}
/**
 * Represents the "Slave Device Busy" exception (Modbus exception code 0x06).
 */
export declare class ModbusSlaveBusyError extends ModbusError {
    constructor();
}
/**
 * Represents the "Acknowledge" exception (Modbus exception code 0x05).
 * Indicates the slave has accepted the request but needs more time to process it.
 */
export declare class ModbusAcknowledgeError extends ModbusError {
    constructor();
}
/**
 * Represents the "Slave Device Failure" exception (Modbus exception code 0x04).
 */
export declare class ModbusSlaveDeviceFailureError extends ModbusError {
    constructor();
}
/**
 * Thrown when a received Modbus frame cannot be parsed due to malformed structure.
 */
export declare class ModbusMalformedFrameError extends ModbusResponseError {
    constructor(rawData: Buffer | Uint8Array);
}
/**
 * Thrown when the length of a received Modbus frame is incorrect.
 */
export declare class ModbusInvalidFrameLengthError extends ModbusResponseError {
    constructor(received: number, expected: number);
}
/**
 * Thrown in Modbus TCP when the received transaction ID does not match the sent one.
 */
export declare class ModbusInvalidTransactionIdError extends ModbusResponseError {
    constructor(received: number, expected: number);
}
/**
 * Thrown when the function code in the response does not match the one sent in the request.
 */
export declare class ModbusUnexpectedFunctionCodeError extends ModbusResponseError {
    constructor(sent: number, received: number);
}
/**
 * Thrown when the TCP connection is actively refused by the remote host.
 */
export declare class ModbusConnectionRefusedError extends ModbusError {
    constructor(host: string, port: number);
}
/**
 * Thrown when a connection attempt to the Modbus device times out.
 */
export declare class ModbusConnectionTimeoutError extends ModbusError {
    constructor(host: string, port: number, timeout: number);
}
/**
 * Thrown when attempting to perform an operation while no transport connection is established.
 */
export declare class ModbusNotConnectedError extends ModbusError {
    constructor();
}
/**
 * Thrown when attempting to connect while a connection is already active.
 */
export declare class ModbusAlreadyConnectedError extends ModbusError {
    constructor();
}
/**
 * Thrown when data written to a buffer exceeds its maximum allowed size.
 */
export declare class ModbusBufferOverflowError extends ModbusError {
    constructor(size: number, max: number);
}
/**
 * Thrown when not enough data has been received to complete parsing of a response.
 */
export declare class ModbusInsufficientDataError extends ModbusResponseError {
    constructor(received: number, required: number);
}
/**
 * Thrown when data cannot be converted to the expected type (e.g., buffer to number).
 */
export declare class ModbusDataConversionError extends ModbusError {
    constructor(data: unknown, expectedType: string);
}
/**
 * Represents the "Gateway Path Unavailable" exception (Modbus exception code 0x0A).
 */
export declare class ModbusGatewayPathUnavailableError extends ModbusError {
    constructor();
}
/**
 * Represents the "Gateway Target Device Failed to Respond" exception (Modbus exception code 0x0B).
 */
export declare class ModbusGatewayTargetDeviceError extends ModbusError {
    constructor();
}
/**
 * Thrown for invalid starting addresses in read/write operations.
 */
export declare class ModbusInvalidStartingAddressError extends ModbusError {
    constructor(address: number);
}
/**
 * Represents the "Memory Parity Error" exception (Modbus exception code 0x08).
 */
export declare class ModbusMemoryParityError extends ModbusError {
    constructor();
}
/**
 * Thrown when LRC (Longitudinal Redundancy Check) validation fails (ASCII mode).
 */
export declare class ModbusLRCError extends ModbusError {
    constructor(message?: string);
}
/**
 * Generic checksum validation failure.
 */
export declare class ModbusChecksumError extends ModbusError {
    constructor(message?: string);
}
/**
 * Thrown when a parity error is detected on the serial line.
 */
export declare class ModbusParityError extends ModbusError {
    constructor(message?: string);
}
/**
 * Thrown when frame synchronization is lost (e.g., missing start/end markers).
 */
export declare class ModbusSyncError extends ModbusError {
    constructor(message?: string);
}
/**
 * Thrown when frame boundary detection fails.
 */
export declare class ModbusFrameBoundaryError extends ModbusError {
    constructor(message?: string);
}
/**
 * Thrown when the receive buffer has insufficient data (underrun).
 */
export declare class ModbusBufferUnderrunError extends ModbusError {
    constructor(size: number, required: number);
}
/**
 * Thrown when a communication collision is detected (e.g., in multi-master setups).
 */
export declare class ModbusCollisionError extends ModbusError {
    constructor(message?: string);
}
/**
 * Thrown when communication is affected by electrical noise.
 */
export declare class ModbusNoiseError extends ModbusError {
    constructor(message?: string);
}
/**
 * Thrown when the receiver hardware overruns (data arrives faster than it can be processed).
 */
export declare class ModbusOverrunError extends ModbusError {
    constructor(message?: string);
}
/**
 * Thrown when a framing error occurs on the serial line.
 */
export declare class ModbusFramingError extends ModbusError {
    constructor(message?: string);
}
/**
 * Thrown when the time between frames exceeds the allowed inter-frame timeout.
 */
export declare class ModbusInterFrameTimeoutError extends ModbusError {
    constructor(message?: string);
}
/**
 * Thrown when the silent interval (3.5 character times in RTU) is violated.
 */
export declare class ModbusSilentIntervalError extends ModbusError {
    constructor(message?: string);
}
/**
 * Thrown when the configured baud rate does not match the actual rate.
 */
export declare class ModbusBaudRateError extends ModbusError {
    constructor(expected: number, actual: number);
}
/**
 * Thrown when a broadcast operation fails or is not supported in the current context.
 */
export declare class ModbusBroadcastError extends ModbusError {
    constructor(message?: string);
}
/**
 * Thrown when the Modbus gateway is busy.
 */
export declare class ModbusGatewayBusyError extends ModbusError {
    constructor();
}
/**
 * Thrown on data overrun conditions.
 */
export declare class ModbusDataOverrunError extends ModbusError {
    constructor();
}
/**
 * Thrown for configuration-related errors in the Modbus stack.
 */
export declare class ModbusConfigError extends ModbusError {
    constructor(message?: string);
}
/**
 * Generic memory access error.
 */
export declare class ModbusMemoryError extends ModbusError {
    constructor(message?: string);
}
/**
 * Thrown when a stack overflow is detected in low-level operations.
 */
export declare class ModbusStackOverflowError extends ModbusError {
    constructor(message?: string);
}
/**
 * Base class for all transport-specific errors.
 */
export declare class TransportError extends ModbusError {
    constructor(message: string);
}
/**
 * Base class for Web Serial transport errors.
 */
export declare class WebSerialTransportError extends TransportError {
    constructor(message: string);
}
/**
 * Thrown when a connection error occurs with Web Serial API.
 */
export declare class WebSerialConnectionError extends WebSerialTransportError {
    constructor(message: string);
}
/**
 * Thrown when a read operation fails on Web Serial transport.
 */
export declare class WebSerialReadError extends WebSerialTransportError {
    constructor(message: string);
}
/**
 * Thrown when a write operation fails on Web Serial transport.
 */
export declare class WebSerialWriteError extends WebSerialTransportError {
    constructor(message: string);
}
/**
 * Base class for Node.js serial transport errors.
 */
export declare class NodeSerialTransportError extends TransportError {
    constructor(message: string);
}
/**
 * Thrown when a connection error occurs with Node.js serial port.
 */
export declare class NodeSerialConnectionError extends NodeSerialTransportError {
    constructor(message: string);
}
/**
 * Thrown when a read operation fails on Node.js serial transport.
 */
export declare class NodeSerialReadError extends NodeSerialTransportError {
    constructor(message: string);
}
/**
 * Thrown when a write operation fails on Node.js serial transport.
 */
export declare class NodeSerialWriteError extends NodeSerialTransportError {
    constructor(message: string);
}
/**
 * Base class for all PollingManager-related errors.
 */
export declare class PollingManagerError extends ModbusError {
    constructor(message: string);
}
/**
 * Thrown when attempting to add a task with an ID that already exists.
 */
export declare class PollingTaskAlreadyExistsError extends PollingManagerError {
    constructor(id: string);
}
/**
 * Thrown when a requested task ID is not found in the PollingManager.
 */
export declare class PollingTaskNotFoundError extends PollingManagerError {
    constructor(id: string);
}
/**
 * Thrown when task options fail validation (missing id, invalid interval, etc.).
 */
export declare class PollingTaskValidationError extends PollingManagerError {
    constructor(message: string);
}
/**
 * Thrown when an operation violates RS485/RS232 mode constraints.
 */
export declare class RSModeConstraintError extends ModbusError {
    constructor(message: string);
}