matterbridge-roborock-vacuum-plugin-regions 1.1.1-jb.1

package/dist/roborockCommunication/RESTAPI/roborockIoTApi.js

@@ -0,0 +1,95 @@
+import axios from 'axios';
+import crypto from 'node:crypto';
+import { debugStringify } from 'matterbridge/logger';
+export class RoborockIoTApi {
+    logger;
+    api;
+    constructor(userdata, logger) {
+        this.logger = logger;
+        this.api = axios.create({ baseURL: userdata.rriot.r.a });
+        this.api.interceptors.request.use((config) => {
+            try {
+                const timestamp = Math.floor(Date.now() / 1000);
+                const nonce = crypto
+                    .randomBytes(6)
+                    .toString('base64')
+                    .substring(0, 6)
+                    .replace(/[+/]/g, (m) => (m === '+' ? 'X' : 'Y'));
+                const url = this.api ? new URL(this.api.getUri(config)).pathname : '';
+                const data = [userdata.rriot.u, userdata.rriot.s, nonce, timestamp, crypto.createHash('md5').update(url).digest('hex'), '', ''].join(':');
+                const hmac = crypto.createHmac('sha256', userdata.rriot.h).update(data).digest('base64');
+                config.headers['Authorization'] = `Hawk id="${userdata.rriot.u}", s="${userdata.rriot.s}", ts="${timestamp}", nonce="${nonce}", mac="${hmac}"`;
+            }
+            catch (error) {
+                this.logger.error(`Failed to initialize RESTAPI ${error ? debugStringify(error) : 'undefined'}`);
+            }
+            return config;
+        });
+    }
+    async getHome(homeId) {
+        const result = await this.api.get(`user/homes/${homeId}`);
+        const apiResponse = result.data;
+        if (apiResponse.result) {
+            return apiResponse.result;
+        }
+        else {
+            this.logger.error('Failed to retrieve the home data');
+            return undefined;
+        }
+    }
+    async getHomev2(homeId) {
+        const result = await this.api.get('v2/user/homes/' + homeId);
+        const apiResponse = result.data;
+        if (apiResponse.result) {
+            return apiResponse.result;
+        }
+        else {
+            this.logger.error('Failed to retrieve the home data');
+            return undefined;
+        }
+    }
+    async getHomev3(homeId) {
+        const result = await this.api.get('v3/user/homes/' + homeId);
+        const apiResponse = result.data;
+        if (apiResponse.result) {
+            return apiResponse.result;
+        }
+        else {
+            this.logger.error('Failed to retrieve the home data');
+            return undefined;
+        }
+    }
+    async getScenes(homeId) {
+        const result = await this.api.get('user/scene/home/' + homeId);
+        const apiResponse = result.data;
+        if (apiResponse.result) {
+            return apiResponse.result;
+        }
+        else {
+            this.logger.error('Failed to retrieve scene');
+            return undefined;
+        }
+    }
+    async startScene(sceneId) {
+        const result = await this.api.post(`user/scene/${sceneId}/execute`);
+        const apiResponse = result.data;
+        if (apiResponse.result) {
+            return apiResponse.result;
+        }
+        else {
+            this.logger.error('Failed to execute scene');
+            return undefined;
+        }
+    }
+    async getCustom(url) {
+        const result = await this.api.get(url);
+        const apiResponse = result.data;
+        if (apiResponse.result) {
+            return apiResponse.result;
+        }
+        else {
+            this.logger.error('Failed to execute scene');
+            return undefined;
+        }
+    }
+}

package/dist/roborockCommunication/Zenum/additionalPropCode.js

@@ -0,0 +1,4 @@
+export var AdditionalPropCode;
+(function (AdditionalPropCode) {
+    AdditionalPropCode[AdditionalPropCode["map_change"] = 4] = "map_change";
+})(AdditionalPropCode || (AdditionalPropCode = {}));

package/dist/roborockCommunication/Zenum/authenticateResponseCode.js

@@ -0,0 +1,7 @@
+export var AuthenticateResponseCode;
+(function (AuthenticateResponseCode) {
+    AuthenticateResponseCode[AuthenticateResponseCode["Success"] = 200] = "Success";
+    AuthenticateResponseCode[AuthenticateResponseCode["AccountNotFound"] = 2008] = "AccountNotFound";
+    AuthenticateResponseCode[AuthenticateResponseCode["InvalidCode"] = 2018] = "InvalidCode";
+    AuthenticateResponseCode[AuthenticateResponseCode["RateLimited"] = 9002] = "RateLimited";
+})(AuthenticateResponseCode || (AuthenticateResponseCode = {}));

package/dist/roborockCommunication/Zenum/dockType.js

@@ -0,0 +1,4 @@
+export var DockType;
+(function (DockType) {
+    DockType[DockType["qrevo_curv_dock"] = 17] = "qrevo_curv_dock";
+})(DockType || (DockType = {}));

package/dist/roborockCommunication/Zenum/operationStatusCode.js

@@ -0,0 +1,44 @@
+export var OperationStatusCode;
+(function (OperationStatusCode) {
+    OperationStatusCode[OperationStatusCode["Unknown"] = 0] = "Unknown";
+    OperationStatusCode[OperationStatusCode["Initiating"] = 1] = "Initiating";
+    OperationStatusCode[OperationStatusCode["Sleeping"] = 2] = "Sleeping";
+    OperationStatusCode[OperationStatusCode["Idle"] = 3] = "Idle";
+    OperationStatusCode[OperationStatusCode["RemoteControl"] = 4] = "RemoteControl";
+    OperationStatusCode[OperationStatusCode["Cleaning"] = 5] = "Cleaning";
+    OperationStatusCode[OperationStatusCode["ReturningDock"] = 6] = "ReturningDock";
+    OperationStatusCode[OperationStatusCode["ManualMode"] = 7] = "ManualMode";
+    OperationStatusCode[OperationStatusCode["Charging"] = 8] = "Charging";
+    OperationStatusCode[OperationStatusCode["ChargingError"] = 9] = "ChargingError";
+    OperationStatusCode[OperationStatusCode["Paused"] = 10] = "Paused";
+    OperationStatusCode[OperationStatusCode["SpotCleaning"] = 11] = "SpotCleaning";
+    OperationStatusCode[OperationStatusCode["InError"] = 12] = "InError";
+    OperationStatusCode[OperationStatusCode["ShuttingDown"] = 13] = "ShuttingDown";
+    OperationStatusCode[OperationStatusCode["Updating"] = 14] = "Updating";
+    OperationStatusCode[OperationStatusCode["ReturnToDock"] = 15] = "ReturnToDock";
+    OperationStatusCode[OperationStatusCode["GoTo"] = 16] = "GoTo";
+    OperationStatusCode[OperationStatusCode["ZoneClean"] = 17] = "ZoneClean";
+    OperationStatusCode[OperationStatusCode["RoomClean"] = 18] = "RoomClean";
+    OperationStatusCode[OperationStatusCode["EmptyingDustContainer"] = 22] = "EmptyingDustContainer";
+    OperationStatusCode[OperationStatusCode["WashingTheMop"] = 23] = "WashingTheMop";
+    OperationStatusCode[OperationStatusCode["WashingTheMop2"] = 25] = "WashingTheMop2";
+    OperationStatusCode[OperationStatusCode["GoingToWashTheMop"] = 26] = "GoingToWashTheMop";
+    OperationStatusCode[OperationStatusCode["InCall"] = 28] = "InCall";
+    OperationStatusCode[OperationStatusCode["Mapping"] = 29] = "Mapping";
+    OperationStatusCode[OperationStatusCode["SOMETHING_NEED_TO_FIGUREOUT"] = 30] = "SOMETHING_NEED_TO_FIGUREOUT";
+    OperationStatusCode[OperationStatusCode["Patrol"] = 32] = "Patrol";
+    OperationStatusCode[OperationStatusCode["FullyCharged"] = 100] = "FullyCharged";
+    OperationStatusCode[OperationStatusCode["DeviceOffline"] = 101] = "DeviceOffline";
+    OperationStatusCode[OperationStatusCode["Locked"] = 103] = "Locked";
+    OperationStatusCode[OperationStatusCode["AirDryingStopping"] = 202] = "AirDryingStopping";
+    OperationStatusCode[OperationStatusCode["RobotStatusMopping"] = 6301] = "RobotStatusMopping";
+    OperationStatusCode[OperationStatusCode["CleanMopCleaning"] = 6302] = "CleanMopCleaning";
+    OperationStatusCode[OperationStatusCode["CleanMopMopping"] = 6303] = "CleanMopMopping";
+    OperationStatusCode[OperationStatusCode["RoomMopping"] = 6304] = "RoomMopping";
+    OperationStatusCode[OperationStatusCode["RoomCleanMopCleaning"] = 6305] = "RoomCleanMopCleaning";
+    OperationStatusCode[OperationStatusCode["RoomCleanMopMopping"] = 6306] = "RoomCleanMopMopping";
+    OperationStatusCode[OperationStatusCode["ZoneMopping"] = 6307] = "ZoneMopping";
+    OperationStatusCode[OperationStatusCode["ZoneCleanMopCleaning"] = 6308] = "ZoneCleanMopCleaning";
+    OperationStatusCode[OperationStatusCode["ZoneCleanMopMopping"] = 6309] = "ZoneCleanMopMopping";
+    OperationStatusCode[OperationStatusCode["BackToDockWashingDuster"] = 6310] = "BackToDockWashingDuster";
+})(OperationStatusCode || (OperationStatusCode = {}));

package/dist/roborockCommunication/Zenum/vacuumAndDockErrorCode.js

@@ -0,0 +1,68 @@
+export var VacuumErrorCode;
+(function (VacuumErrorCode) {
+    VacuumErrorCode[VacuumErrorCode["None"] = 0] = "None";
+    VacuumErrorCode[VacuumErrorCode["LidarBlocked"] = 1] = "LidarBlocked";
+    VacuumErrorCode[VacuumErrorCode["BumperStuck"] = 2] = "BumperStuck";
+    VacuumErrorCode[VacuumErrorCode["WheelsSuspended"] = 3] = "WheelsSuspended";
+    VacuumErrorCode[VacuumErrorCode["CliffSensorError"] = 4] = "CliffSensorError";
+    VacuumErrorCode[VacuumErrorCode["MainBrushJammed"] = 5] = "MainBrushJammed";
+    VacuumErrorCode[VacuumErrorCode["SideBrushJammed"] = 6] = "SideBrushJammed";
+    VacuumErrorCode[VacuumErrorCode["WheelsJammed"] = 7] = "WheelsJammed";
+    VacuumErrorCode[VacuumErrorCode["RobotTrapped"] = 8] = "RobotTrapped";
+    VacuumErrorCode[VacuumErrorCode["NoDustbin"] = 9] = "NoDustbin";
+    VacuumErrorCode[VacuumErrorCode["StrainerError"] = 10] = "StrainerError";
+    VacuumErrorCode[VacuumErrorCode["CompassError"] = 11] = "CompassError";
+    VacuumErrorCode[VacuumErrorCode["LowBattery"] = 12] = "LowBattery";
+    VacuumErrorCode[VacuumErrorCode["ChargingError"] = 13] = "ChargingError";
+    VacuumErrorCode[VacuumErrorCode["BatteryError"] = 14] = "BatteryError";
+    VacuumErrorCode[VacuumErrorCode["WallSensorDirty"] = 15] = "WallSensorDirty";
+    VacuumErrorCode[VacuumErrorCode["RobotTilted"] = 16] = "RobotTilted";
+    VacuumErrorCode[VacuumErrorCode["SideBrushError"] = 17] = "SideBrushError";
+    VacuumErrorCode[VacuumErrorCode["FanError"] = 18] = "FanError";
+    VacuumErrorCode[VacuumErrorCode["DockNotConnectedToPower"] = 19] = "DockNotConnectedToPower";
+    VacuumErrorCode[VacuumErrorCode["OpticalFlowSensorDirt"] = 20] = "OpticalFlowSensorDirt";
+    VacuumErrorCode[VacuumErrorCode["VerticalBumperPressed"] = 21] = "VerticalBumperPressed";
+    VacuumErrorCode[VacuumErrorCode["DockLocatorError"] = 22] = "DockLocatorError";
+    VacuumErrorCode[VacuumErrorCode["ReturnToDockFail"] = 23] = "ReturnToDockFail";
+    VacuumErrorCode[VacuumErrorCode["NogoZoneDetected"] = 24] = "NogoZoneDetected";
+    VacuumErrorCode[VacuumErrorCode["CameraError"] = 25] = "CameraError";
+    VacuumErrorCode[VacuumErrorCode["WallSensorError"] = 26] = "WallSensorError";
+    VacuumErrorCode[VacuumErrorCode["VibrariseJammed"] = 27] = "VibrariseJammed";
+    VacuumErrorCode[VacuumErrorCode["RobotOnCarpet"] = 28] = "RobotOnCarpet";
+    VacuumErrorCode[VacuumErrorCode["FilterBlocked"] = 29] = "FilterBlocked";
+    VacuumErrorCode[VacuumErrorCode["InvisibleWallDetected"] = 30] = "InvisibleWallDetected";
+    VacuumErrorCode[VacuumErrorCode["CannotCrossCarpet"] = 31] = "CannotCrossCarpet";
+    VacuumErrorCode[VacuumErrorCode["InternalError"] = 32] = "InternalError";
+    VacuumErrorCode[VacuumErrorCode["CleanAutoEmptyDock"] = 34] = "CleanAutoEmptyDock";
+    VacuumErrorCode[VacuumErrorCode["AutoEmptyDockVoltage"] = 35] = "AutoEmptyDockVoltage";
+    VacuumErrorCode[VacuumErrorCode["MoppingRollerJammed"] = 36] = "MoppingRollerJammed";
+    VacuumErrorCode[VacuumErrorCode["MoppingRollerNotLowered"] = 37] = "MoppingRollerNotLowered";
+    VacuumErrorCode[VacuumErrorCode["ClearWaterBoxHoare"] = 38] = "ClearWaterBoxHoare";
+    VacuumErrorCode[VacuumErrorCode["DirtyWaterBoxHoare"] = 39] = "DirtyWaterBoxHoare";
+    VacuumErrorCode[VacuumErrorCode["SinkStrainerHoare"] = 40] = "SinkStrainerHoare";
+    VacuumErrorCode[VacuumErrorCode["ClearWaterTankEmpty"] = 41] = "ClearWaterTankEmpty";
+    VacuumErrorCode[VacuumErrorCode["ClearBrushInstalledProperly"] = 42] = "ClearBrushInstalledProperly";
+    VacuumErrorCode[VacuumErrorCode["ClearBrushPositioningError"] = 43] = "ClearBrushPositioningError";
+    VacuumErrorCode[VacuumErrorCode["FilterScreenException"] = 44] = "FilterScreenException";
+    VacuumErrorCode[VacuumErrorCode["MoppingRollerJammed2"] = 45] = "MoppingRollerJammed2";
+    VacuumErrorCode[VacuumErrorCode["UpWaterException"] = 48] = "UpWaterException";
+    VacuumErrorCode[VacuumErrorCode["DrainWaterException"] = 49] = "DrainWaterException";
+    VacuumErrorCode[VacuumErrorCode["TemperatureProtection"] = 51] = "TemperatureProtection";
+    VacuumErrorCode[VacuumErrorCode["CleanCarouselException"] = 52] = "CleanCarouselException";
+    VacuumErrorCode[VacuumErrorCode["CleanCarouselWaterFull"] = 53] = "CleanCarouselWaterFull";
+    VacuumErrorCode[VacuumErrorCode["WaterCarriageDrop"] = 54] = "WaterCarriageDrop";
+    VacuumErrorCode[VacuumErrorCode["CheckCleanCarouse"] = 55] = "CheckCleanCarouse";
+    VacuumErrorCode[VacuumErrorCode["AudioError"] = 56] = "AudioError";
+})(VacuumErrorCode || (VacuumErrorCode = {}));
+export var DockErrorCode;
+(function (DockErrorCode) {
+    DockErrorCode[DockErrorCode["None"] = 0] = "None";
+    DockErrorCode[DockErrorCode["DuctBlockage"] = 34] = "DuctBlockage";
+    DockErrorCode[DockErrorCode["WaterEmpty"] = 38] = "WaterEmpty";
+    DockErrorCode[DockErrorCode["WasteWaterTankFull"] = 39] = "WasteWaterTankFull";
+    DockErrorCode[DockErrorCode["MaintenanceBrushJammed"] = 42] = "MaintenanceBrushJammed";
+    DockErrorCode[DockErrorCode["DirtyTankLatchOpen"] = 44] = "DirtyTankLatchOpen";
+    DockErrorCode[DockErrorCode["NoDustbin"] = 46] = "NoDustbin";
+    DockErrorCode[DockErrorCode["CleaningTankFullOrBlocked"] = 53] = "CleaningTankFullOrBlocked";
+})(DockErrorCode || (DockErrorCode = {}));
+export const SUPPORTED_ATTACHMENTS = ['WATERTANK', 'MOP'];

package/dist/roborockCommunication/Zmodel/apiResponse.js

@@ -0,0 +1 @@
+export {};

package/dist/roborockCommunication/Zmodel/authenticateFlowState.js

@@ -0,0 +1 @@
+export {};

package/dist/roborockCommunication/Zmodel/authenticateResponse.js

@@ -0,0 +1 @@
+export {};

package/dist/roborockCommunication/Zmodel/baseURL.js

@@ -0,0 +1 @@
+export {};

package/dist/roborockCommunication/Zmodel/batteryMessage.js

@@ -0,0 +1 @@
+export {};

package/dist/roborockCommunication/Zmodel/device.js

@@ -0,0 +1 @@
+export {};

package/dist/roborockCommunication/Zmodel/deviceModel.js

@@ -0,0 +1,28 @@
+export var DeviceModel;
+(function (DeviceModel) {
+    DeviceModel["Q5"] = "roborock.vacuum.a34";
+    DeviceModel["Q5_PRO"] = "roborock.vacuum.a72";
+    DeviceModel["S5"] = "roborock.vacuum.s5";
+    DeviceModel["S5_MAX"] = "roborock.vacuum.s5e";
+    DeviceModel["S6"] = "roborock.vacuum.s6";
+    DeviceModel["S6_MAXV"] = "roborock.vacuum.a10";
+    DeviceModel["S6_PURE"] = "roborock.vacuum.a08";
+    DeviceModel["Q7"] = "roborock.vacuum.a40";
+    DeviceModel["Q7_PLUS"] = "roborock.vacuum.axx";
+    DeviceModel["Q7_MAX"] = "roborock.vacuum.a38";
+    DeviceModel["S7"] = "roborock.vacuum.a15";
+    DeviceModel["S7_MAXV"] = "roborock.vacuum.a27";
+    DeviceModel["S7_MAXV_ULTRA"] = "roborock.vacuum.a65";
+    DeviceModel["S7_PRO_ULTRA"] = "roborock.vacuum.a62";
+    DeviceModel["Q8_MAX"] = "roborock.vacuum.a73";
+    DeviceModel["S8"] = "roborock.vacuum.a51";
+    DeviceModel["S8_PRO_ULTRA"] = "roborock.vacuum.a70";
+    DeviceModel["S8_MAXV_ULTRA"] = "roborock.vacuum.a97";
+    DeviceModel["QREVO_MASTER"] = "roborock.vacuum.a117";
+    DeviceModel["QREVO_CURV"] = "roborock.vacuum.a135";
+    DeviceModel["QREVO_S"] = "roborock.vacuum.a104";
+    DeviceModel["QREVO_PRO"] = "roborock.vacuum.a101";
+    DeviceModel["QREVO_MAXV"] = "roborock.vacuum.a87";
+    DeviceModel["QREVO_EDGE_5V1"] = "roborock.vacuum.a187";
+    DeviceModel["QREVO_EDGE_5AE"] = "roborock.vacuum.xxxx";
+})(DeviceModel || (DeviceModel = {}));

package/dist/roborockCommunication/Zmodel/deviceSchema.js

@@ -0,0 +1 @@
+export {};

package/dist/roborockCommunication/Zmodel/deviceStatus.js

@@ -0,0 +1,22 @@
+import { DockInfo } from './dockInfo.js';
+import { VacuumError } from './vacuumError.js';
+export class DeviceStatus {
+    errorStatus;
+    message;
+    constructor(message) {
+        this.message = message[0];
+        this.errorStatus = new VacuumError(this.message.error_code, this.message.dock_error_status);
+    }
+    getBattery() {
+        return this.message.battery;
+    }
+    getVacuumErrorCode() {
+        return this.message.error_code;
+    }
+    getDockInfo() {
+        return new DockInfo(this.message.dock_type);
+    }
+    getDockErrorCode() {
+        return this.message.dock_error_status;
+    }
+}

package/dist/roborockCommunication/Zmodel/dockInfo.js

@@ -0,0 +1,6 @@
+export class DockInfo {
+    dockType;
+    constructor(dockType) {
+        this.dockType = dockType;
+    }
+}

package/dist/roborockCommunication/Zmodel/home.js

@@ -0,0 +1 @@
+export {};

package/dist/roborockCommunication/Zmodel/homeInfo.js

@@ -0,0 +1 @@
+export {};

package/dist/roborockCommunication/Zmodel/map.js

@@ -0,0 +1 @@
+export {};

package/dist/roborockCommunication/Zmodel/mapInfo.js

@@ -0,0 +1,29 @@
+import decodeComponent from '../helper/nameDecoder.js';
+export class MapInfo {
+    maps = [];
+    allRooms = [];
+    constructor(multimap) {
+        this.maps = multimap.map_info.map((mapInfo) => {
+            const rooms = mapInfo.rooms?.map((room) => ({
+                id: room.id,
+                globalId: parseInt(room.iot_name_id),
+                iot_name_id: room.iot_name_id,
+                tag: room.tag,
+                displayName: room.iot_name,
+                mapId: mapInfo.mapFlag,
+            })) ?? [];
+            this.allRooms.push(...rooms);
+            return {
+                id: mapInfo.mapFlag,
+                name: decodeComponent(mapInfo.name),
+                rooms,
+            };
+        });
+    }
+    getById(id) {
+        return this.maps.find((m) => m.id === id)?.name;
+    }
+    getByName(name) {
+        return this.maps.find((m) => m.name?.toLowerCase() === name.toLowerCase())?.id;
+    }
+}

package/dist/roborockCommunication/Zmodel/messageResult.js

@@ -0,0 +1,7 @@
+export var CarpetCleanMode;
+(function (CarpetCleanMode) {
+    CarpetCleanMode[CarpetCleanMode["Avoid"] = 0] = "Avoid";
+    CarpetCleanMode[CarpetCleanMode["Ignore"] = 2] = "Ignore";
+    CarpetCleanMode[CarpetCleanMode["Cross"] = 3] = "Cross";
+    CarpetCleanMode[CarpetCleanMode["DynamicLift"] = 200] = "DynamicLift";
+})(CarpetCleanMode || (CarpetCleanMode = {}));

package/dist/roborockCommunication/Zmodel/multipleMap.js

@@ -0,0 +1 @@
+export {};

package/dist/roborockCommunication/Zmodel/networkInfo.js

@@ -0,0 +1 @@
+export {};

package/dist/roborockCommunication/Zmodel/product.js

@@ -0,0 +1 @@
+export {};

package/dist/roborockCommunication/Zmodel/room.js

@@ -0,0 +1 @@
+export {};

package/dist/roborockCommunication/Zmodel/roomInfo.js

@@ -0,0 +1,22 @@
+import decodeComponent from '../helper/nameDecoder.js';
+export class RoomInfo {
+    rooms = [];
+    constructor(roomInfo, roomData) {
+        this.rooms = roomData
+            .map((entry) => {
+            return { id: entry[0], globalId: entry[1] };
+        })
+            .map((entry) => {
+            return {
+                id: entry.id,
+                room: roomInfo.find((el) => el.id == entry.globalId),
+            };
+        })
+            .map((entry) => {
+            return {
+                id: entry.id,
+                name: decodeComponent(entry.room?.name)?.toLowerCase(),
+            };
+        });
+    }
+}

package/dist/roborockCommunication/Zmodel/scene.js

@@ -0,0 +1,16 @@
+export class Scene {
+    id;
+    name;
+    param;
+    enabled;
+    extra;
+    type;
+}
+export class SceneItem {
+    id;
+    type;
+    name;
+    entityId;
+    param;
+    finishDpIds;
+}

package/dist/roborockCommunication/Zmodel/userData.js

@@ -0,0 +1 @@
+export {};

package/dist/roborockCommunication/Zmodel/vacuumError.js

@@ -0,0 +1,27 @@
+import { DockErrorCode, VacuumErrorCode } from '../Zenum/vacuumAndDockErrorCode.js';
+export class VacuumError {
+    vacuumErrorCode;
+    dockErrorCode;
+    constructor(errorCode, dockErrorCode) {
+        this.vacuumErrorCode = errorCode;
+        this.dockErrorCode = dockErrorCode;
+    }
+    hasError() {
+        return this.vacuumErrorCode != 0 || this.dockErrorCode != 0;
+    }
+    isStuck() {
+        return this.vacuumErrorCode === VacuumErrorCode.RobotTrapped;
+    }
+    isBatteryLow() {
+        return this.vacuumErrorCode === VacuumErrorCode.LowBattery;
+    }
+    isBinFull() {
+        return this.vacuumErrorCode === VacuumErrorCode.CleanAutoEmptyDock || this.dockErrorCode == DockErrorCode.DuctBlockage;
+    }
+    isCleanWaterEmpty() {
+        return this.vacuumErrorCode === VacuumErrorCode.ClearWaterTankEmpty || this.dockErrorCode == DockErrorCode.WaterEmpty;
+    }
+    isWasteWaterFull() {
+        return this.dockErrorCode == DockErrorCode.WasteWaterTankFull;
+    }
+}

package/dist/roborockCommunication/broadcast/abstractClient.js

@@ -0,0 +1,55 @@
+import { MessageDeserializer } from '../helper/messageDeserializer.js';
+import { MessageSerializer } from '../helper/messageSerializer.js';
+import { ChainedConnectionListener } from './listener/implementation/chainedConnectionListener.js';
+import { ChainedMessageListener } from './listener/implementation/chainedMessageListener.js';
+import { SyncMessageListener } from './listener/implementation/syncMessageListener.js';
+import { ConnectionStateListener } from './listener/implementation/connectionStateListener.js';
+export class AbstractClient {
+    isInDisconnectingStep = false;
+    retryCount = 0;
+    connectionListeners = new ChainedConnectionListener();
+    messageListeners = new ChainedMessageListener();
+    serializer;
+    deserializer;
+    context;
+    connected = false;
+    logger;
+    syncMessageListener;
+    constructor(logger, context) {
+        this.context = context;
+        this.serializer = new MessageSerializer(this.context, logger);
+        this.deserializer = new MessageDeserializer(this.context, logger);
+        this.syncMessageListener = new SyncMessageListener(logger);
+        this.messageListeners.register(this.syncMessageListener);
+        this.logger = logger;
+    }
+    initializeConnectionStateListener() {
+        const connectionStateListener = new ConnectionStateListener(this.logger, this, this.clientName, this.shouldReconnect);
+        this.connectionListeners.register(connectionStateListener);
+    }
+    async get(duid, request) {
+        return new Promise((resolve, reject) => {
+            this.syncMessageListener.waitFor(request.messageId, request, (response) => resolve(response), reject);
+            this.send(duid, request);
+        })
+            .then((result) => {
+            return result;
+        })
+            .catch((error) => {
+            this.logger.error(error.message);
+            return undefined;
+        });
+    }
+    registerDevice(duid, localKey, pv, nonce) {
+        this.context.registerDevice(duid, localKey, pv, nonce);
+    }
+    registerConnectionListener(listener) {
+        this.connectionListeners.register(listener);
+    }
+    registerMessageListener(listener) {
+        this.messageListeners.register(listener);
+    }
+    isConnected() {
+        return this.connected;
+    }
+}