meross-iot 0.1.0

package/lib/model/push/hub-sensor-temphum.js

@@ -0,0 +1,62 @@
+'use strict';
+
+const GenericPushNotification = require('./generic');
+
+/**
+ * Push notification for hub temperature/humidity sensor updates.
+ *
+ * Emitted when a hub temperature/humidity sensor subdevice sends temperature or humidity
+ * readings. Routed to the appropriate subdevice by the hub device.
+ *
+ * @class
+ * @extends GenericPushNotification
+ * @example
+ * hubDevice.on('pushNotification', (notification) => {
+ *     if (notification instanceof HubSensorTempHumPushNotification) {
+ *         const tempHumData = notification.tempHumData;
+ *         tempHumData.forEach(sensor => {
+ *             console.log('Temp/Hum sensor update:', sensor.id);
+ *             console.log('Temperature:', sensor.temperature);
+ *             console.log('Humidity:', sensor.humidity);
+ *         });
+ *     }
+ * });
+ */
+class HubSensorTempHumPushNotification extends GenericPushNotification {
+    /**
+     * Creates a new HubSensorTempHumPushNotification instance.
+     *
+     * @param {string} originatingDeviceUuid - UUID of the hub device that sent the notification
+     * @param {Object} rawData - Raw notification data from the device
+     * @param {Object|Array} [rawData.tempHum] - Temperature/humidity data (single object or array)
+     * @param {string|number} [rawData.tempHum.id] - Subdevice ID
+     * @param {number} [rawData.tempHum.temperature] - Temperature reading
+     * @param {number} [rawData.tempHum.humidity] - Humidity reading
+     */
+    constructor(originatingDeviceUuid, rawData) {
+        super('Appliance.Hub.Sensor.TempHum', originatingDeviceUuid, rawData);
+
+        // Devices may send single objects or arrays; normalize to array for consistent processing
+        const tempHumRaw = rawData?.tempHum;
+        const tempHum = GenericPushNotification.normalizeToArray(tempHumRaw);
+
+        // Update rawData so routing logic receives normalized structure
+        if (rawData && tempHumRaw !== tempHum) {
+            rawData.tempHum = tempHum;
+        }
+
+        this._tempHumData = tempHum;
+    }
+
+    /**
+     * Gets the temperature/humidity data array.
+     *
+     * @returns {Array} Array of temperature/humidity objects (empty array if no data)
+     */
+    get tempHumData() {
+        return this._tempHumData;
+    }
+}
+
+module.exports = HubSensorTempHumPushNotification;
+

package/lib/model/push/hub-subdevicelist.js

@@ -0,0 +1,50 @@
+'use strict';
+
+const GenericPushNotification = require('./generic');
+
+/**
+ * Push notification for hub subdevice list updates.
+ *
+ * Emitted when a hub's subdevice list changes (e.g., subdevice added, removed, or updated).
+ * Contains the updated list of subdevices registered with the hub.
+ *
+ * @class
+ * @extends GenericPushNotification
+ * @example
+ * hubDevice.on('pushNotification', (notification) => {
+ *     if (notification instanceof HubSubdeviceListPushNotification) {
+ *         const subdevices = notification.subdeviceListData;
+ *         console.log('Subdevice list updated. Total subdevices:', subdevices.length);
+ *         subdevices.forEach(subdevice => {
+ *             console.log('Subdevice:', subdevice.id, subdevice.type);
+ *         });
+ *     }
+ * });
+ */
+class HubSubdeviceListPushNotification extends GenericPushNotification {
+    /**
+     * Creates a new HubSubdeviceListPushNotification instance.
+     *
+     * @param {string} originatingDeviceUuid - UUID of the hub device that sent the notification
+     * @param {Object} rawData - Raw notification data from the device
+     * @param {Object|Array} [rawData.subdeviceList] - Subdevice list data
+     * @param {Array} [rawData.subdeviceList.subdevice] - Array of subdevice objects (if nested structure)
+     */
+    constructor(originatingDeviceUuid, rawData) {
+        super('Appliance.Hub.SubdeviceList', originatingDeviceUuid, rawData);
+
+        this._subdeviceListData = rawData?.subdeviceList || rawData?.subdeviceList?.subdevice || [];
+    }
+
+    /**
+     * Gets the subdevice list data array.
+     *
+     * @returns {Array} Array of subdevice objects (empty array if no data)
+     */
+    get subdeviceListData() {
+        return this._subdeviceListData;
+    }
+}
+
+module.exports = HubSubdeviceListPushNotification;
+

package/lib/model/push/hub-togglex.js

@@ -0,0 +1,60 @@
+'use strict';
+
+const GenericPushNotification = require('./generic');
+
+/**
+ * Push notification for hub subdevice toggle (on/off) state changes.
+ *
+ * Emitted when a hub subdevice's toggle state changes.
+ * Routed to the appropriate subdevice by the hub device.
+ *
+ * @class
+ * @extends GenericPushNotification
+ * @example
+ * hubDevice.on('pushNotification', (notification) => {
+ *     if (notification instanceof HubToggleXPushNotification) {
+ *         const toggleData = notification.togglexData;
+ *         toggleData.forEach(toggle => {
+ *             console.log(`Subdevice ${toggle.id} channel ${toggle.channel} is now ${toggle.onoff === 1 ? 'on' : 'off'}`);
+ *         });
+ *     }
+ * });
+ */
+class HubToggleXPushNotification extends GenericPushNotification {
+    /**
+     * Creates a new HubToggleXPushNotification instance.
+     *
+     * @param {string} originatingDeviceUuid - UUID of the hub device that sent the notification
+     * @param {Object} rawData - Raw notification data from the device
+     * @param {Object|Array} [rawData.togglex] - Toggle state data (single object or array)
+     * @param {string|number} [rawData.togglex.id] - Subdevice ID
+     * @param {number} [rawData.togglex.channel] - Channel number
+     * @param {number} [rawData.togglex.onoff] - On/off state (0=off, 1=on)
+     */
+    constructor(originatingDeviceUuid, rawData) {
+        super('Appliance.Hub.ToggleX', originatingDeviceUuid, rawData);
+
+        // Devices may send single objects or arrays; normalize to array for consistent processing
+        const togglexRaw = rawData?.togglex;
+        const togglex = GenericPushNotification.normalizeToArray(togglexRaw);
+
+        // Update rawData so routing logic receives normalized structure
+        if (rawData && togglexRaw !== togglex) {
+            rawData.togglex = togglex;
+        }
+
+        this._togglexData = togglex;
+    }
+
+    /**
+     * Gets the toggle state data array.
+     *
+     * @returns {Array} Array of toggle state objects (empty array if no data)
+     */
+    get togglexData() {
+        return this._togglexData;
+    }
+}
+
+module.exports = HubToggleXPushNotification;
+

package/lib/model/push/index.js

@@ -0,0 +1,81 @@
+/**
+ * @module lib/model/push
+ * @description
+ * Push notification classes for handling real-time updates from Meross devices.
+ *
+ * Provides classes for parsing and handling various types of push notifications sent by
+ * Meross devices via MQTT. These notifications enable real-time event handling without
+ * polling, covering device state changes, alarms, hub subdevice updates, and configuration
+ * changes. Each notification type extends GenericPushNotification and provides type-specific
+ * data accessors and change extraction methods.
+ *
+ * @example
+ * const { parsePushNotification, ToggleXPushNotification } = require('./lib/model/push');
+ *
+ * device.on('pushNotification', (notification) => {
+ *     if (notification instanceof ToggleXPushNotification) {
+ *         console.log('Toggle state changed');
+ *     }
+ * });
+ */
+
+'use strict';
+
+const GenericPushNotification = require('./generic');
+const OnlinePushNotification = require('./online');
+const AlarmPushNotification = require('./alarm');
+const BindPushNotification = require('./bind');
+const UnbindPushNotification = require('./unbind');
+const WaterLeakPushNotification = require('./water-leak');
+const HubOnlinePushNotification = require('./hub-online');
+const HubToggleXPushNotification = require('./hub-togglex');
+const HubBatteryPushNotification = require('./hub-battery');
+const HubSensorAllPushNotification = require('./hub-sensor-all');
+const HubSensorTempHumPushNotification = require('./hub-sensor-temphum');
+const HubSensorAlertPushNotification = require('./hub-sensor-alert');
+const HubSensorSmokePushNotification = require('./hub-sensor-smoke');
+const HubMts100AllPushNotification = require('./hub-mts100-all');
+const HubMts100ModePushNotification = require('./hub-mts100-mode');
+const HubMts100TemperaturePushNotification = require('./hub-mts100-temperature');
+const HubSubdeviceListPushNotification = require('./hub-subdevicelist');
+const SensorLatestXPushNotification = require('./sensor-latestx');
+const TimerXPushNotification = require('./timerx');
+const TriggerXPushNotification = require('./triggerx');
+const ToggleXPushNotification = require('./togglex');
+const PresenceStudyPushNotification = require('./presence-study');
+const DiffuserLightPushNotification = require('./diffuser-light');
+const DiffuserSprayPushNotification = require('./diffuser-spray');
+const { HardwareInfo, FirmwareInfo, TimeInfo } = require('./common');
+const { parsePushNotification } = require('./factory');
+
+module.exports = {
+    GenericPushNotification,
+    OnlinePushNotification,
+    AlarmPushNotification,
+    BindPushNotification,
+    UnbindPushNotification,
+    WaterLeakPushNotification,
+    HubOnlinePushNotification,
+    HubToggleXPushNotification,
+    HubBatteryPushNotification,
+    HubSensorAllPushNotification,
+    HubSensorTempHumPushNotification,
+    HubSensorAlertPushNotification,
+    HubSensorSmokePushNotification,
+    HubMts100AllPushNotification,
+    HubMts100ModePushNotification,
+    HubMts100TemperaturePushNotification,
+    HubSubdeviceListPushNotification,
+    SensorLatestXPushNotification,
+    TimerXPushNotification,
+    TriggerXPushNotification,
+    ToggleXPushNotification,
+    PresenceStudyPushNotification,
+    DiffuserLightPushNotification,
+    DiffuserSprayPushNotification,
+    HardwareInfo,
+    FirmwareInfo,
+    TimeInfo,
+    parsePushNotification
+};
+

package/lib/model/push/online.js

@@ -0,0 +1,53 @@
+'use strict';
+
+const GenericPushNotification = require('./generic');
+
+/**
+ * Push notification for device online status changes.
+ *
+ * Emitted when a device's connection status changes (online, offline, or upgrade mode).
+ * Devices send this notification to report their connection state to the Meross cloud.
+ *
+ * @class
+ * @extends GenericPushNotification
+ * @example
+ * device.on('pushNotification', (notification) => {
+ *     if (notification instanceof OnlinePushNotification) {
+ *         console.log('Device status changed:', notification.status);
+ *         // status: 0=not online, 1=online, 2=offline, 3=upgrading
+ *     }
+ * });
+ */
+class OnlinePushNotification extends GenericPushNotification {
+    /**
+     * Creates a new OnlinePushNotification instance.
+     *
+     * @param {string} originatingDeviceUuid - UUID of the device that sent the notification
+     * @param {Object} rawData - Raw notification data from the device
+     * @param {Object} [rawData.online] - Online status data
+     * @param {number} [rawData.online.status] - Online status value (from OnlineStatus enum)
+     */
+    constructor(originatingDeviceUuid, rawData) {
+        super('Appliance.System.Online', originatingDeviceUuid, rawData);
+    }
+
+    /**
+     * Gets the online status value.
+     *
+     * Explicitly checks for null/undefined to distinguish between missing data and
+     * a valid zero value (not online).
+     *
+     * @returns {number|undefined} Status value (0=not online, 1=online, 2=offline, 3=upgrading, -1=unknown) or undefined if not available
+     * @see {@link module:lib/enums.OnlineStatus} for status constants
+     */
+    get status() {
+        const statusValue = this._rawData?.online?.status;
+        if (statusValue === undefined || statusValue === null) {
+            return undefined;
+        }
+        return statusValue;
+    }
+}
+
+module.exports = OnlinePushNotification;
+

package/lib/model/push/presence-study.js

@@ -0,0 +1,61 @@
+'use strict';
+
+const GenericPushNotification = require('./generic');
+
+/**
+ * Push notification for presence sensor study/calibration status changes.
+ *
+ * Emitted when a presence sensor's study/calibration mode status changes (e.g., study mode
+ * started or stopped). Contains the updated study status for one or more channels.
+ *
+ * @class
+ * @extends GenericPushNotification
+ * @example
+ * device.on('pushNotification', (notification) => {
+ *     if (notification instanceof PresenceStudyPushNotification) {
+ *         const studyData = notification.studyData;
+ *         studyData.forEach(study => {
+ *             console.log(`Channel ${study.channel} study status: ${study.status === 1 ? 'active' : 'inactive'}`);
+ *             console.log(`Study value: ${study.value}`);
+ *         });
+ *     }
+ * });
+ */
+class PresenceStudyPushNotification extends GenericPushNotification {
+    /**
+     * Creates a new PresenceStudyPushNotification instance.
+     *
+     * @param {string} originatingDeviceUuid - UUID of the device that sent the notification
+     * @param {Object} rawData - Raw notification data from the device
+     * @param {Object|Array} [rawData.study] - Study status data (single object or array)
+     * @param {number} [rawData.study.channel] - Channel number
+     * @param {number} [rawData.study.value] - Study mode value (typically 1-3)
+     * @param {number} [rawData.study.status] - Study status (0 = stop/inactive, 1 = start/active)
+     */
+    constructor(originatingDeviceUuid, rawData) {
+        super('Appliance.Control.Presence.Study', originatingDeviceUuid, rawData);
+
+        // Devices may send single objects or arrays; normalize to array for consistent processing
+        const studyRaw = rawData?.study;
+        const study = GenericPushNotification.normalizeToArray(studyRaw);
+
+        // Update rawData so routing logic receives normalized structure
+        if (rawData && studyRaw !== study) {
+            rawData.study = study;
+        }
+
+        this._studyData = study;
+    }
+
+    /**
+     * Gets the study status data array.
+     *
+     * @returns {Array} Array of study status objects (empty array if no data)
+     */
+    get studyData() {
+        return this._studyData;
+    }
+}
+
+module.exports = PresenceStudyPushNotification;
+

package/lib/model/push/sensor-latestx.js

@@ -0,0 +1,106 @@
+'use strict';
+
+const GenericPushNotification = require('./generic');
+const { PresenceState } = require('../enums');
+
+/**
+ * Push notification for latest sensor readings (including lux/illuminance).
+ *
+ * Emitted when a hub sensor subdevice sends latest readings for temperature, humidity, and light.
+ * Routed to the appropriate subdevice by the hub device.
+ *
+ * @class
+ * @extends GenericPushNotification
+ * @example
+ * hubDevice.on('pushNotification', (notification) => {
+ *     if (notification instanceof SensorLatestXPushNotification) {
+ *         const latestData = notification.latestData;
+ *         latestData.forEach(sensor => {
+ *             console.log('Latest sensor readings:', sensor.subId);
+ *         });
+ *     }
+ * });
+ */
+class SensorLatestXPushNotification extends GenericPushNotification {
+    /**
+     * Creates a new SensorLatestXPushNotification instance.
+     *
+     * @param {string} originatingDeviceUuid - UUID of the hub device that sent the notification
+     * @param {Object} rawData - Raw notification data from the device
+     * @param {Object|Array} [rawData.latest] - Latest sensor readings (single object or array)
+     * @param {string|number} [rawData.latest.subId] - Subdevice ID (note: uses subId, not id)
+     * @param {number} [rawData.latest.channel] - Channel number
+     * @param {Object} [rawData.latest.data] - Sensor data containing temp, humi, and light arrays
+     */
+    constructor(originatingDeviceUuid, rawData) {
+        super('Appliance.Control.Sensor.LatestX', originatingDeviceUuid, rawData);
+
+        // Devices may send single objects or arrays; normalize to array for consistent processing
+        const latestRaw = rawData?.latest;
+        const latest = GenericPushNotification.normalizeToArray(latestRaw);
+
+        // Update rawData so routing logic receives normalized structure
+        if (rawData && latestRaw !== latest) {
+            rawData.latest = latest;
+        }
+
+        this._latestData = latest;
+    }
+
+    /**
+     * Gets the latest sensor readings data array.
+     *
+     * @returns {Array} Array of latest sensor reading objects (empty array if no data)
+     */
+    get latestData() {
+        return this._latestData;
+    }
+
+    /**
+     * Extracts presence sensor changes from this notification.
+     *
+     * Converts raw device data format (presence arrays, light arrays) to normalized change
+     * format used by subscription managers. Maps presence values to boolean isPresent and
+     * extracts distance, timestamp, and light readings.
+     *
+     * @returns {Object} Changes object with presence sensor data, e.g., { presence: { 0: {...} } }
+     */
+    extractChanges() {
+        const changes = {};
+        if (!this._latestData || this._latestData.length === 0) {
+            return changes;
+        }
+
+        changes.presence = {};
+        this._latestData.forEach(entry => {
+            if (!entry || !entry.data) {
+                return;
+            }
+            const channel = entry.channel !== undefined ? entry.channel : 0;
+            const presenceChange = {};
+
+            if (entry.data.presence && Array.isArray(entry.data.presence) && entry.data.presence.length > 0) {
+                const presenceData = entry.data.presence[0];
+                presenceChange.isPresent = presenceData.value === PresenceState.PRESENCE;
+                presenceChange.distance = presenceData.distance;
+                presenceChange.timestamp = presenceData.timestamp;
+                presenceChange.times = presenceData.times;
+            }
+
+            if (entry.data.light && Array.isArray(entry.data.light) && entry.data.light.length > 0) {
+                const lightData = entry.data.light[0];
+                presenceChange.light = lightData.value;
+                presenceChange.lightTimestamp = lightData.timestamp;
+            }
+
+            if (Object.keys(presenceChange).length > 0) {
+                changes.presence[channel] = presenceChange;
+            }
+        });
+
+        return changes;
+    }
+}
+
+module.exports = SensorLatestXPushNotification;
+

package/lib/model/push/timerx.js

@@ -0,0 +1,63 @@
+'use strict';
+
+const GenericPushNotification = require('./generic');
+
+/**
+ * Push notification for timer configuration changes.
+ *
+ * Emitted when a device's timer configuration changes (e.g., timer added, modified,
+ * deleted, or triggered). Contains the updated timer data.
+ *
+ * @class
+ * @extends GenericPushNotification
+ * @example
+ * device.on('pushNotification', (notification) => {
+ *     if (notification instanceof TimerXPushNotification) {
+ *         const timerData = notification.timerxData;
+ *         timerData.forEach(timer => {
+ *             console.log('Timer updated:', timer.id, timer.enable === 1 ? 'enabled' : 'disabled');
+ *         });
+ *     }
+ * });
+ */
+class TimerXPushNotification extends GenericPushNotification {
+    /**
+     * Creates a new TimerXPushNotification instance.
+     *
+     * @param {string} originatingDeviceUuid - UUID of the device that sent the notification
+     * @param {Object} rawData - Raw notification data from the device
+     * @param {Object|Array} [rawData.timerx] - Timer data (single object or array)
+     * @param {string|number} [rawData.timerx.id] - Timer identifier
+     * @param {number} [rawData.timerx.channel] - Channel number
+     * @param {number} [rawData.timerx.enable] - Enabled state (0=disabled, 1=enabled)
+     * @param {number} [rawData.timerx.type] - Timer type
+     * @param {number} [rawData.timerx.time] - Time value
+     * @param {number} [rawData.timerx.week] - Weekday mask
+     */
+    constructor(originatingDeviceUuid, rawData) {
+        super('Appliance.Control.TimerX', originatingDeviceUuid, rawData);
+
+        // Devices may send single objects or arrays; normalize to array for consistent processing
+        const timerxRaw = rawData?.timerx;
+        const timerx = GenericPushNotification.normalizeToArray(timerxRaw);
+
+        // Update rawData so routing logic receives normalized structure
+        if (rawData && timerxRaw !== timerx) {
+            rawData.timerx = timerx;
+        }
+
+        this._timerxData = timerx;
+    }
+
+    /**
+     * Gets the timer data array.
+     *
+     * @returns {Array} Array of timer objects (empty array if no data)
+     */
+    get timerxData() {
+        return this._timerxData;
+    }
+}
+
+module.exports = TimerXPushNotification;
+

package/lib/model/push/togglex.js

@@ -0,0 +1,78 @@
+'use strict';
+
+const GenericPushNotification = require('./generic');
+
+/**
+ * Push notification for toggle (on/off) state changes.
+ *
+ * Emitted when a device's toggle state changes (e.g., a smart plug is turned on or off).
+ * Contains the updated toggle state for one or more channels.
+ *
+ * @class
+ * @extends GenericPushNotification
+ * @example
+ * device.on('pushNotification', (notification) => {
+ *     if (notification instanceof ToggleXPushNotification) {
+ *         const toggleData = notification.togglexData;
+ *         toggleData.forEach(toggle => {
+ *             console.log(`Channel ${toggle.channel} is now ${toggle.onoff === 1 ? 'on' : 'off'}`);
+ *         });
+ *     }
+ * });
+ */
+class ToggleXPushNotification extends GenericPushNotification {
+    /**
+     * Creates a new ToggleXPushNotification instance.
+     *
+     * @param {string} originatingDeviceUuid - UUID of the device that sent the notification
+     * @param {Object} rawData - Raw notification data from the device
+     * @param {Object|Array} [rawData.togglex] - Toggle state data (single object or array)
+     * @param {number} [rawData.togglex.channel] - Channel number
+     * @param {number} [rawData.togglex.onoff] - On/off state (0=off, 1=on)
+     */
+    constructor(originatingDeviceUuid, rawData) {
+        super('Appliance.Control.ToggleX', originatingDeviceUuid, rawData);
+
+        // Devices may send single objects or arrays; normalize to array for consistent processing
+        const togglexRaw = rawData?.togglex;
+        const togglex = GenericPushNotification.normalizeToArray(togglexRaw);
+
+        // Update rawData so routing logic receives normalized structure
+        if (rawData && togglexRaw !== togglex) {
+            rawData.togglex = togglex;
+        }
+
+        this._togglexData = togglex;
+    }
+
+    /**
+     * Gets the toggle state data array.
+     *
+     * @returns {Array} Array of toggle state objects (empty array if no data)
+     */
+    get togglexData() {
+        return this._togglexData;
+    }
+
+    /**
+     * Extracts toggle state changes from this notification.
+     *
+     * Converts raw device data format (onoff: 0/1) to normalized change format (boolean)
+     * used by subscription managers, keyed by channel number.
+     *
+     * @returns {Object} Changes object with toggle state, e.g., { toggle: { 0: true, 1: false } }
+     */
+    extractChanges() {
+        const changes = {};
+        if (this._togglexData && this._togglexData.length > 0) {
+            changes.toggle = {};
+            this._togglexData.forEach(item => {
+                changes.toggle[item.channel] = item.onoff === 1;
+            });
+        }
+        return changes;
+    }
+}
+
+module.exports = ToggleXPushNotification;
+

package/lib/model/push/triggerx.js

@@ -0,0 +1,62 @@
+'use strict';
+
+const GenericPushNotification = require('./generic');
+
+/**
+ * Push notification for trigger configuration changes.
+ *
+ * Emitted when a device's trigger configuration changes (e.g., trigger added, modified,
+ * deleted, or activated). Contains the updated trigger data.
+ *
+ * @class
+ * @extends GenericPushNotification
+ * @example
+ * device.on('pushNotification', (notification) => {
+ *     if (notification instanceof TriggerXPushNotification) {
+ *         const triggerData = notification.triggerxData;
+ *         triggerData.forEach(trigger => {
+ *             console.log('Trigger updated:', trigger.id, trigger.enable === 1 ? 'enabled' : 'disabled');
+ *         });
+ *     }
+ * });
+ */
+class TriggerXPushNotification extends GenericPushNotification {
+    /**
+     * Creates a new TriggerXPushNotification instance.
+     *
+     * @param {string} originatingDeviceUuid - UUID of the device that sent the notification
+     * @param {Object} rawData - Raw notification data from the device
+     * @param {Object|Array} [rawData.triggerx] - Trigger data (single object or array)
+     * @param {string|number} [rawData.triggerx.id] - Trigger identifier
+     * @param {number} [rawData.triggerx.channel] - Channel number
+     * @param {number} [rawData.triggerx.enable] - Enabled state (0=disabled, 1=enabled)
+     * @param {number} [rawData.triggerx.type] - Trigger type
+     * @param {Object} [rawData.triggerx.rule] - Trigger rule configuration
+     */
+    constructor(originatingDeviceUuid, rawData) {
+        super('Appliance.Control.TriggerX', originatingDeviceUuid, rawData);
+
+        // Devices may send single objects or arrays; normalize to array for consistent processing
+        const triggerxRaw = rawData?.triggerx;
+        const triggerx = GenericPushNotification.normalizeToArray(triggerxRaw);
+
+        // Update rawData so routing logic receives normalized structure
+        if (rawData && triggerxRaw !== triggerx) {
+            rawData.triggerx = triggerx;
+        }
+
+        this._triggerxData = triggerx;
+    }
+
+    /**
+     * Gets the trigger data array.
+     *
+     * @returns {Array} Array of trigger objects (empty array if no data)
+     */
+    get triggerxData() {
+        return this._triggerxData;
+    }
+}
+
+module.exports = TriggerXPushNotification;
+