meross-iot 0.1.0

package/lib/model/exception.js

@@ -0,0 +1,363 @@
+'use strict';
+
+/**
+ * Base error class for all Meross errors.
+ *
+ * Provides a common interface for error handling with errorCode property to
+ * identify specific API error conditions. All library-specific errors extend
+ * this class to enable instanceof checks and consistent error handling
+ * throughout the library.
+ *
+ * @class
+ * @extends Error
+ * @property {number|null} errorCode - API error code (if available)
+ */
+class MerossError extends Error {
+    constructor(message, errorCode = null) {
+        super(message);
+        this.name = this.constructor.name;
+        this.errorCode = errorCode;
+        Error.captureStackTrace(this, this.constructor);
+    }
+}
+
+/**
+ * Authentication related errors (error codes 1000-1008).
+ *
+ * Thrown when authentication fails due to invalid credentials, account issues,
+ * or authentication service problems. Indicates the login request cannot be
+ * completed with the provided credentials.
+ *
+ * Base class for authentication errors. HTTP-specific auth errors are in
+ * lib/model/http/exception.js.
+ *
+ * @class
+ * @extends MerossError
+ * @property {number} errorCode - API error code (1000-1008)
+ */
+class AuthenticationError extends MerossError {
+    constructor(message, errorCode) {
+        super(message || 'Authentication failed', errorCode);
+    }
+}
+
+/**
+ * API limit reached error (error code 1042).
+ *
+ * Thrown when the API rate limit has been exceeded. Meross enforces rate limits
+ * to prevent abuse and ensure service stability. Requests should be throttled
+ * to stay within the allowed rate. Retry after a delay or reduce request frequency.
+ *
+ * @class
+ * @extends MerossError
+ * @property {number} errorCode - Always 1042
+ */
+class ApiLimitReachedError extends MerossError {
+    constructor(message) {
+        super(message || 'API top limit reached', 1042);
+    }
+}
+
+/**
+ * Resource access denied error (error code 1043).
+ *
+ * Thrown when access to a resource is denied due to insufficient permissions.
+ * The account may not have access to the requested device or resource, or the
+ * resource may not exist. Verify the resource exists and the account has
+ * appropriate permissions.
+ *
+ * @class
+ * @extends MerossError
+ * @property {number} errorCode - Always 1043
+ */
+class ResourceAccessDeniedError extends MerossError {
+    constructor(message) {
+        super(message || 'Resource access deny', 1043);
+    }
+}
+
+/**
+ * Device command timeout error.
+ *
+ * Thrown when a device command doesn't receive a response within the timeout period.
+ * Indicates the device may be offline, unreachable, or experiencing network issues
+ * that prevent timely communication. Check device connectivity and network status.
+ *
+ * @class
+ * @extends MerossError
+ * @property {string|null} deviceUuid - UUID of the device that timed out
+ * @property {number|null} timeout - Timeout duration in milliseconds
+ * @property {Object|null} command - Command information (method, namespace, etc.)
+ */
+class CommandTimeoutError extends MerossError {
+    constructor(message, deviceUuid = null, timeout = null, command = null) {
+        super(message || 'Command timeout occurred');
+        this.deviceUuid = deviceUuid;
+        this.timeout = timeout;
+        this.command = command;
+    }
+}
+
+/**
+ * Device command error (device returned an error response).
+ *
+ * Thrown when a device command fails and the device returns an error response.
+ * The command was received and processed by the device, but the device rejected
+ * it or encountered an error during execution. Check the errorPayload for
+ * device-specific error details.
+ *
+ * @class
+ * @extends MerossError
+ * @property {Object|null} errorPayload - Error payload from device response
+ * @property {string|null} deviceUuid - UUID of the device that returned the error
+ */
+class CommandError extends MerossError {
+    constructor(message, errorPayload = null, deviceUuid = null) {
+        super(message || 'Device command failed');
+        this.errorPayload = errorPayload;
+        this.deviceUuid = deviceUuid;
+    }
+}
+
+/**
+ * MQTT connection/communication error.
+ *
+ * Thrown when MQTT connection or communication fails. Can occur due to network
+ * issues, MQTT broker unavailability, connection timeouts, or protocol errors
+ * during message transmission. Check network connectivity and MQTT broker status.
+ *
+ * @class
+ * @extends MerossError
+ * @property {string|null} topic - MQTT topic related to the error
+ * @property {Object|null} mqttMessage - MQTT message related to the error
+ */
+class MqttError extends MerossError {
+    constructor(message, topic = null, mqttMessage = null) {
+        super(message || 'MQTT error occurred');
+        this.topic = topic;
+        this.mqttMessage = mqttMessage;
+    }
+}
+
+/**
+ * Device not connected error.
+ *
+ * Thrown when attempting to send a command to a device that is not connected.
+ * Commands can only be sent after the device has established a connection and
+ * emitted the 'connected' event. Wait for the device to connect before sending commands.
+ *
+ * @class
+ * @extends MerossError
+ * @property {string|null} deviceUuid - UUID of the device that is not connected
+ */
+class UnconnectedError extends MerossError {
+    constructor(message, deviceUuid = null) {
+        super(message || 'Device is not connected');
+        this.deviceUuid = deviceUuid;
+    }
+}
+
+/**
+ * Unknown or unsupported device type error.
+ *
+ * Thrown when a device operation is attempted on a device type that doesn't
+ * support the requested feature or when the device type is not recognized.
+ * Indicates a mismatch between the requested operation and device capabilities.
+ * Verify the device type supports the requested operation.
+ *
+ * @class
+ * @extends MerossError
+ * @property {string|null} deviceType - Device type that is unsupported
+ */
+class UnknownDeviceTypeError extends MerossError {
+    constructor(message, deviceType = null) {
+        super(message || 'Unknown or unsupported device type');
+        this.deviceType = deviceType;
+    }
+}
+
+/**
+ * Handles token-related error codes.
+ *
+ * Maps token expiration and token limit error codes to appropriate error
+ * classes. Token errors indicate authentication token issues that require
+ * re-authentication or token management.
+ *
+ * @private
+ * @param {number} errorCode - The error code
+ * @param {string} message - Error message
+ * @returns {MerossError|null} Error instance or null if not a token error
+ */
+function _handleTokenErrors(errorCode, message) {
+    const { TokenExpiredError, TooManyTokensError } = require('./http/exception');
+
+    if (errorCode === 1019 || errorCode === 1022 || errorCode === 1200) {
+        return new TokenExpiredError(message, errorCode);
+    }
+    if (errorCode === 1301) {
+        return new TooManyTokensError(message);
+    }
+    return null;
+}
+
+/**
+ * Handles authentication error codes (1000-1008).
+ *
+ * Maps authentication error codes to AuthenticationError instances. These
+ * errors indicate login failures due to invalid credentials or account issues.
+ *
+ * @private
+ * @param {number} errorCode - The error code
+ * @param {string} message - Error message
+ * @returns {MerossError|null} Error instance or null if not an auth error
+ */
+function _handleAuthenticationErrors(errorCode, message) {
+    if (errorCode >= 1000 && errorCode <= 1008) {
+        return new AuthenticationError(message, errorCode);
+    }
+    return null;
+}
+
+/**
+ * Handles MFA-related error codes.
+ *
+ * Maps multi-factor authentication error codes to appropriate error classes.
+ * MFA errors indicate issues with two-factor authentication during login.
+ *
+ * @private
+ * @param {number} errorCode - The error code
+ * @param {string} message - Error message
+ * @returns {MerossError|null} Error instance or null if not an MFA error
+ */
+function _handleMFAErrors(errorCode, message) {
+    const { MFARequiredError, WrongMFAError } = require('./http/exception');
+
+    if (errorCode === 1032) {
+        return new WrongMFAError(message);
+    }
+    if (errorCode === 1033) {
+        return new MFARequiredError(message);
+    }
+    return null;
+}
+
+/**
+ * Handles domain and API limit/access error codes.
+ *
+ * Maps domain configuration errors and API limit/access errors to appropriate
+ * error classes. Domain errors indicate incorrect API/MQTT domain configuration,
+ * while limit errors indicate rate limiting or permission issues.
+ *
+ * @private
+ * @param {number} errorCode - The error code
+ * @param {string} message - Error message
+ * @param {Object} context - Additional context
+ * @returns {MerossError|null} Error instance or null if not a domain/limit error
+ */
+function _handleDomainAndLimitErrors(errorCode, message, context) {
+    const { BadDomainError } = require('./http/exception');
+
+    if (errorCode === 1030) {
+        return new BadDomainError(message, context.apiDomain, context.mqttDomain);
+    }
+    if (errorCode === 1042) {
+        return new ApiLimitReachedError(message);
+    }
+    if (errorCode === 1043) {
+        return new ResourceAccessDeniedError(message);
+    }
+    return null;
+}
+
+/**
+ * Handles HTTP status code-based errors.
+ *
+ * Maps HTTP status codes to appropriate error classes. HTTP errors indicate
+ * server-side issues or authentication problems at the HTTP protocol level.
+ *
+ * @private
+ * @param {number} httpStatusCode - HTTP status code
+ * @param {number} errorCode - The API error code
+ * @param {string} message - Error message
+ * @returns {MerossError|null} Error instance or null if not an HTTP error
+ */
+function _handleHttpStatusErrors(httpStatusCode, errorCode, message) {
+    const { HttpApiError, UnauthorizedError } = require('./http/exception');
+
+    if (httpStatusCode === 401) {
+        return new UnauthorizedError(message, errorCode, httpStatusCode);
+    }
+    if (httpStatusCode && httpStatusCode >= 400) {
+        return new HttpApiError(message, errorCode, httpStatusCode);
+    }
+    return null;
+}
+
+/**
+ * Maps error codes to appropriate error classes.
+ *
+ * Converts API error codes into specific error class instances based on the
+ * error code value and context. Provides consistent error handling by mapping
+ * numeric codes to typed error objects with appropriate properties. This
+ * centralizes error handling logic and ensures all errors are properly typed.
+ *
+ * @param {number} errorCode - The error code from API response
+ * @param {Object} [context={}] - Additional context
+ * @param {string} [context.info] - Error message from API
+ * @param {string} [context.deviceUuid] - Device UUID (for device-related errors)
+ * @param {number} [context.httpStatusCode] - HTTP status code
+ * @param {string} [context.apiDomain] - API domain (for BadDomainError)
+ * @param {string} [context.mqttDomain] - MQTT domain (for BadDomainError)
+ * @returns {MerossError} Appropriate error instance
+ */
+function mapErrorCodeToError(errorCode, context = {}) {
+    const { info, httpStatusCode } = context;
+    const { getErrorMessage } = require('./http/error-codes');
+    const message = info || getErrorMessage(errorCode);
+
+    // Check token-related errors
+    const tokenError = _handleTokenErrors(errorCode, message);
+    if (tokenError) {
+        return tokenError;
+    }
+
+    // Check authentication errors
+    const authError = _handleAuthenticationErrors(errorCode, message);
+    if (authError) {
+        return authError;
+    }
+
+    // Check MFA errors
+    const mfaError = _handleMFAErrors(errorCode, message);
+    if (mfaError) {
+        return mfaError;
+    }
+
+    // Check domain and API limit errors
+    const domainError = _handleDomainAndLimitErrors(errorCode, message, context);
+    if (domainError) {
+        return domainError;
+    }
+
+    // Check HTTP status code errors
+    const httpError = _handleHttpStatusErrors(httpStatusCode, errorCode, message);
+    if (httpError) {
+        return httpError;
+    }
+
+    // Default: return generic MerossError
+    return new MerossError(`${errorCode} (${getErrorMessage(errorCode)})${info ? ` - ${info}` : ''}`, errorCode);
+}
+
+module.exports = {
+    MerossError,
+    AuthenticationError,
+    ApiLimitReachedError,
+    ResourceAccessDeniedError,
+    CommandTimeoutError,
+    CommandError,
+    MqttError,
+    UnconnectedError,
+    UnknownDeviceTypeError,
+    mapErrorCodeToError
+};

package/lib/model/http/device.js

@@ -0,0 +1,215 @@
+'use strict';
+
+const { OnlineStatus } = require('../enums');
+const { DEFAULT_MQTT_HOST, DEFAULT_MQTT_PORT } = require('../constants');
+const { extractDomain, extractPort } = require('../../utilities/network');
+
+/**
+ * Represents device information from the HTTP API
+ *
+ * This class encapsulates device metadata retrieved from the Meross HTTP API,
+ * including device identification, versions, channels, and network configuration.
+ * It provides helper methods for extracting MQTT connection information.
+ *
+ * @class
+ * @example
+ * // Use fromDict() to create instances
+ * const deviceInfo = HttpDeviceInfo.fromDict({
+ *     uuid: '12345',
+ *     dev_name: 'My Device',
+ *     device_type: 'mss310',
+ *     online_status: 1,
+ *     channels: []
+ * });
+ */
+class HttpDeviceInfo {
+    /**
+     * Creates an HttpDeviceInfo instance from a dictionary object.
+     * Normalizes incoming keys (handles camelCase and snake_case) to camelCase.
+     * This is the only way to create instances.
+     *
+     * @static
+     * @param {Object} jsonDict - Raw API response object with any key format
+     * @param {string} [jsonDict.uuid] - Device UUID
+     * @param {string} [jsonDict.devName] - Device name (camelCase)
+     * @param {string} [jsonDict.dev_name] - Device name (snake_case)
+     * @param {string} [jsonDict.deviceType] - Device type (camelCase)
+     * @param {string} [jsonDict.device_type] - Device type (snake_case)
+     * @param {Array<Object>} [jsonDict.channels] - Raw channels array from API
+     * @param {string} [jsonDict.fmwareVersion] - Firmware version (camelCase)
+     * @param {string} [jsonDict.fmware_version] - Firmware version (snake_case)
+     * @param {string} [jsonDict.hdwareVersion] - Hardware version (camelCase)
+     * @param {string} [jsonDict.hdware_version] - Hardware version (snake_case)
+     * @param {string} [jsonDict.domain] - MQTT domain
+     * @param {string} [jsonDict.reservedDomain] - Reserved MQTT domain (camelCase)
+     * @param {string} [jsonDict.reserved_domain] - Reserved MQTT domain (snake_case)
+     * @param {string} [jsonDict.subType] - Device sub-type (camelCase)
+     * @param {string} [jsonDict.sub_type] - Device sub-type (snake_case)
+     * @param {number|Date|string} [jsonDict.bindTime] - Device bind timestamp (camelCase)
+     * @param {number|Date|string} [jsonDict.bind_time] - Device bind timestamp (snake_case)
+     * @param {string} [jsonDict.skillNumber] - Skill number (camelCase)
+     * @param {string} [jsonDict.skill_number] - Skill number (snake_case)
+     * @param {string} [jsonDict.userDevIcon] - User device icon (camelCase)
+     * @param {string} [jsonDict.user_dev_icon] - User device icon (snake_case)
+     * @param {number} [jsonDict.iconType] - Icon type (camelCase)
+     * @param {number} [jsonDict.icon_type] - Icon type (snake_case)
+     * @param {string} [jsonDict.region] - Device region
+     * @param {string} [jsonDict.devIconId] - Device icon ID (camelCase)
+     * @param {string} [jsonDict.dev_icon_id] - Device icon ID (snake_case)
+     * @param {number} [jsonDict.onlineStatus] - Online status (camelCase)
+     * @param {number} [jsonDict.online_status] - Online status (snake_case)
+     * @returns {HttpDeviceInfo} New HttpDeviceInfo instance
+     */
+    static fromDict(jsonDict) {
+        if (!jsonDict || typeof jsonDict !== 'object') {
+            throw new Error('Device info dictionary is required');
+        }
+
+        // The Meross API returns properties in inconsistent formats (camelCase vs snake_case).
+        // This mapping allows us to accept either format and normalize to camelCase for internal use.
+        const propertyMappings = {
+            uuid: ['uuid'],
+            devName: ['devName', 'dev_name'],
+            deviceType: ['deviceType', 'device_type'],
+            channels: ['channels'],
+            fmwareVersion: ['fmwareVersion', 'fmware_version'],
+            hdwareVersion: ['hdwareVersion', 'hdware_version'],
+            domain: ['domain'],
+            reservedDomain: ['reservedDomain', 'reserved_domain'],
+            subType: ['subType', 'sub_type'],
+            bindTime: ['bindTime', 'bind_time'],
+            skillNumber: ['skillNumber', 'skill_number'],
+            userDevIcon: ['userDevIcon', 'user_dev_icon'],
+            iconType: ['iconType', 'icon_type'],
+            region: ['region'],
+            devIconId: ['devIconId', 'dev_icon_id'],
+            onlineStatus: ['onlineStatus', 'online_status']
+        };
+
+        // Normalize properties by checking alternatives in priority order (camelCase first, then snake_case).
+        // This ensures consistent property names regardless of API response format.
+        const normalized = {};
+        for (const [camelKey, alternatives] of Object.entries(propertyMappings)) {
+            for (const key of alternatives) {
+                if (jsonDict[key] !== null && jsonDict[key] !== undefined) {
+                    normalized[camelKey] = jsonDict[key];
+                    break;
+                }
+            }
+        }
+
+        // Use Object.create() instead of a constructor to allow static factory pattern.
+        // This prevents accidental instantiation via 'new' and enforces use of fromDict().
+        const instance = Object.create(HttpDeviceInfo.prototype);
+        instance.uuid = normalized.uuid;
+        instance.devName = normalized.devName;
+        instance.deviceType = normalized.deviceType;
+        instance.channels = normalized.channels || [];
+        instance.fmwareVersion = normalized.fmwareVersion;
+        instance.hdwareVersion = normalized.hdwareVersion;
+        instance.domain = normalized.domain;
+        instance.reservedDomain = normalized.reservedDomain;
+        instance.subType = normalized.subType;
+        instance.skillNumber = normalized.skillNumber;
+        instance.userDevIcon = normalized.userDevIcon;
+        instance.iconType = normalized.iconType;
+        instance.region = normalized.region;
+        instance.devIconId = normalized.devIconId;
+
+        // Convert onlineStatus to a number, defaulting to UNKNOWN if invalid or missing.
+        // The API may return non-numeric values or omit the field entirely.
+        if (normalized.onlineStatus !== undefined && normalized.onlineStatus !== null) {
+            if (typeof normalized.onlineStatus === 'number') {
+                instance.onlineStatus = normalized.onlineStatus;
+            } else {
+                instance.onlineStatus = OnlineStatus.UNKNOWN;
+            }
+        } else {
+            instance.onlineStatus = OnlineStatus.UNKNOWN;
+        }
+
+        // Convert bindTime from Unix timestamp (seconds) to Date object.
+        // The API returns timestamps as numbers, but we store them as Date instances for easier manipulation.
+        if (normalized.bindTime !== undefined && normalized.bindTime !== null) {
+            if (typeof normalized.bindTime === 'number') {
+                instance.bindTime = new Date(normalized.bindTime * 1000);
+            } else if (normalized.bindTime instanceof Date) {
+                instance.bindTime = normalized.bindTime;
+            } else if (typeof normalized.bindTime === 'string') {
+                instance.bindTime = new Date(normalized.bindTime);
+            } else {
+                instance.bindTime = null;
+            }
+        } else {
+            instance.bindTime = null;
+        }
+
+        return instance;
+    }
+
+    /**
+     * Converts the instance to a plain object dictionary with camelCase keys
+     *
+     * @returns {Object} Plain object with camelCase property keys
+     */
+    toDict() {
+        return {
+            uuid: this.uuid,
+            devName: this.devName,
+            deviceType: this.deviceType,
+            channels: this.channels,
+            fmwareVersion: this.fmwareVersion,
+            hdwareVersion: this.hdwareVersion,
+            domain: this.domain,
+            reservedDomain: this.reservedDomain,
+            subType: this.subType,
+            bindTime: this.bindTime,
+            skillNumber: this.skillNumber,
+            userDevIcon: this.userDevIcon,
+            iconType: this.iconType,
+            region: this.region,
+            devIconId: this.devIconId,
+            onlineStatus: this.onlineStatus
+        };
+    }
+
+    /**
+     * Gets the MQTT server hostname for this device
+     *
+     * Extracts the hostname from the domain or reservedDomain field.
+     * The domain field is preferred as it represents the active MQTT endpoint,
+     * while reservedDomain is a fallback. Defaults to a standard hostname if neither is available.
+     *
+     * @returns {string} MQTT hostname
+     */
+    getMqttHost() {
+        if (this.domain) {
+            return extractDomain(this.domain);
+        }
+        if (this.reservedDomain) {
+            return extractDomain(this.reservedDomain);
+        }
+        return DEFAULT_MQTT_HOST;
+    }
+
+    /**
+     * Gets the MQTT server port for this device
+     *
+     * Extracts the port from the domain or reservedDomain field.
+     * The domain field is preferred as it represents the active MQTT endpoint,
+     * while reservedDomain is a fallback. Defaults to a standard port if neither is available.
+     *
+     * @returns {number} MQTT port number
+     */
+    getMqttPort() {
+        if (this.domain) {
+            return extractPort(this.domain, DEFAULT_MQTT_PORT);
+        }
+        if (this.reservedDomain) {
+            return extractPort(this.reservedDomain, DEFAULT_MQTT_PORT);
+        }
+        return DEFAULT_MQTT_PORT;
+    }
+}
+
+module.exports = HttpDeviceInfo;

package/lib/model/http/error-codes.js

@@ -0,0 +1,121 @@
+'use strict';
+
+/**
+ * Error code to message mapping
+ *
+ * Maps Meross API error codes to human-readable error messages. These messages
+ * are provided by the Meross API and used as default error messages when the
+ * API doesn't provide a custom message.
+ *
+ * @module errorcodes
+ */
+
+const errorMessages = {
+    500: 'The selected timezone is not supported',
+    1000: 'Wrong or missing user',
+    1001: 'Wrong or missing password',
+    1002: 'Account does not exist',
+    1003: 'This account has been disabled or deleted',
+    1004: 'Wrong email or password',
+    1005: 'Invalid email address',
+    1006: 'Bad password format',
+    1007: 'User already exists',
+    1008: 'This email is not registered',
+    1009: 'Email send failed',
+    1011: 'Wrong Ticket',
+    1012: 'Code Overdue',
+    1013: 'Wrong Code',
+    1014: 'Duplicate password',
+    1015: 'Same email when changing account email',
+    1019: 'Token expired',
+    1021: 'Unknown error',
+    1022: 'Token error',
+    1023: 'Unknown error',
+    1024: 'Unknown error',
+    1025: 'Unknown error',
+    1026: 'Unknown error',
+    1027: 'Unknown error',
+    1028: 'Requested too frequently',
+    1030: 'Redirect app to login other than this region',
+    1031: 'Username does not match',
+    1032: 'Invalid MFA code. Please use a current MFA code.',
+    1033: 'MFA is activated for the account but MFA code not provided. Please provide a current MFA code.',
+    1035: 'Operation is locked',
+    1041: 'Repeat checkin',
+    1042: 'API Top limit reached',
+    1043: 'Resource access deny',
+    1200: 'Token has expired',
+    1201: 'Server was unable to generate token',
+    1202: 'Unknown error',
+    1203: 'Unknown error',
+    1204: 'Unknown error',
+    1210: 'Unknown error',
+    1211: 'Unknown error',
+    1212: 'Unknown error',
+    1213: 'Unknown error',
+    1214: 'Unknown error',
+    1215: 'Unknown error',
+    1226: 'Unknown error',
+    1227: 'Unknown error',
+    1228: 'Unknown error',
+    1229: 'Unknown error',
+    1230: 'Unknown error',
+    1231: 'Unknown error',
+    1232: 'Unknown error',
+    1233: 'Unknown error',
+    1255: 'The number of remote control boards exceeded the limit',
+    1256: 'Compatible mode having',
+    1257: 'Compatible mode not having',
+    1301: 'You have issued too many tokens without logging out and your account might have been temporarily disabled.',
+    1400: 'Unknown error',
+    1401: 'Unknown error',
+    1402: 'Unknown error',
+    1403: 'Unknown error',
+    1500: 'Unknown error',
+    1501: 'Unknown error',
+    1502: 'Unknown error',
+    1503: 'Unknown error',
+    1504: 'Unknown error',
+    1601: 'Unknown error',
+    1602: 'Unknown error',
+    1603: 'Unknown error',
+    1604: 'Unknown error',
+    1605: 'Unknown error',
+    1700: 'Unknown error',
+    5000: 'Unknown or generic error',
+    5001: 'Unknown or generic error',
+    5002: 'Unknown or generic error',
+    5003: 'Unknown or generic error',
+    5004: 'Unknown or generic error',
+    5020: 'Infrared Remote device is busy',
+    5021: 'Infrared record timeout',
+    5022: 'Infrared record invalid',
+    10001: 'System error',
+    10002: 'Unknown error',
+    10003: 'Serialize error',
+    10006: 'Http common error',
+    20101: 'Invalid parameter',
+    20106: 'Not existing resource',
+    20112: 'Unsupported',
+    20115: 'Send email limit'
+};
+
+/**
+ * Gets the error message for a given error code
+ *
+ * Maps Meross API error codes to human-readable messages. These messages are
+ * standardized by the Meross API documentation and provide context when the API
+ * response doesn't include a custom error message. Returns a generic message for
+ * unmapped codes to ensure callers always receive a meaningful error description.
+ *
+ * @param {number} code - The error code to look up
+ * @returns {string} The error message for the code, or 'Unknown error' if not found
+ */
+function getErrorMessage(code) {
+    return errorMessages[code] || 'Unknown error';
+}
+
+module.exports = {
+    getErrorMessage
+};
+