matterbridge-roborock-vacuum-plugin 1.0.5

package/dist/platform.js

@@ -0,0 +1,146 @@
+import './extensions/index.js';
+import { MatterbridgeDynamicPlatform } from 'matterbridge';
+import * as axios from 'axios';
+import RoborockService from './roborockService.js';
+import { PLUGIN_NAME } from './settings.js';
+import ClientManager from './clientManager.js';
+import { isSupportedDevice } from './helper.js';
+import { PlatformRunner } from './platformRunner.js';
+import { RoborockVacuumCleaner } from './rvc.js';
+import { configurateBehavior } from './behaviorFactory.js';
+import { RoborockAuthenticateApi, RoborockIoTApi } from './roborockCommunication/index.js';
+import { getSupportedAreas } from './initialData/index.js';
+export class RoborockMatterbridgePlatform extends MatterbridgeDynamicPlatform {
+    robot;
+    rvcInterval;
+    roborockService;
+    clientManager;
+    platformRunner;
+    devices;
+    serialNumber;
+    constructor(matterbridge, log, config) {
+        super(matterbridge, log, config);
+        if (this.verifyMatterbridgeVersion === undefined || typeof this.verifyMatterbridgeVersion !== 'function' || !this.verifyMatterbridgeVersion('3.0.4')) {
+            throw new Error(`This plugin requires Matterbridge version >= "3.0.4". Please update Matterbridge from ${this.matterbridge.matterbridgeVersion} to the latest version in the frontend.`);
+        }
+        this.log.info('Initializing platform:', this.config.name);
+        if (config.whiteList === undefined)
+            config.whiteList = [];
+        if (config.blackList === undefined)
+            config.blackList = [];
+        if (config.enableExperimentalFeature === undefined)
+            config.enableExperimentalFeature = false;
+        this.clientManager = new ClientManager(this.log);
+        this.devices = new Map();
+    }
+    async onStart(reason) {
+        this.log.notice('onStart called with reason:', reason ?? 'none');
+        const self = this;
+        await this.ready;
+        await this.clearSelect();
+        if (this.config.username === undefined || this.config.password === undefined) {
+            this.log.error('"username" and "password" are required in the config');
+            return;
+        }
+        const axiosInstance = axios.default ?? axios;
+        axiosInstance.interceptors.request.use((request) => {
+            self.log.debug('Axios Request:', {
+                method: request.method,
+                url: request.url,
+                data: request.data,
+                headers: request.headers,
+            });
+            return request;
+        });
+        axiosInstance.interceptors.response.use((response) => {
+            self.log.debug('Axios Response:', {
+                status: response.status,
+                data: response.data,
+                headers: response.headers,
+                url: response.config.url,
+            });
+            return response;
+        });
+        this.platformRunner = new PlatformRunner(this);
+        this.roborockService = new RoborockService(() => new RoborockAuthenticateApi(this.log, axiosInstance), (logger, ud) => new RoborockIoTApi(ud, logger), this.config.refreshInterval ?? 60, this.clientManager, this.log);
+        const username = this.config.username;
+        const password = this.config.password;
+        const userData = await this.roborockService.loginWithPassword(username, password);
+        this.log.debug('Initializing - userData:', JSON.stringify(userData));
+        const devices = await this.roborockService.listDevices(username);
+        this.log.notice('Initializing - devices: ', JSON.stringify(devices));
+        let vacuum = undefined;
+        if (this.config.whiteList.length > 0) {
+            const firstDUID = this.config.whiteList[0];
+            vacuum = devices.find((d) => d.duid == firstDUID);
+        }
+        else {
+            vacuum = devices.find((d) => isSupportedDevice(d.data.model));
+        }
+        if (!vacuum) {
+            this.log.error('Initializing: No supported devices found');
+            return;
+        }
+        await this.roborockService.initializeMessageClient(username, vacuum, userData);
+        this.devices.set(vacuum.serialNumber, vacuum);
+        this.serialNumber = vacuum.serialNumber;
+        await this.onConfigurateDevice();
+        this.log.notice('onStart finished');
+    }
+    async onConfigure() {
+        await super.onConfigure();
+        const self = this;
+        this.rvcInterval = setInterval(async () => {
+            self.platformRunner?.requestHomeData();
+        }, (this.config.refreshInterval ?? 60) * 1000 + 100);
+    }
+    async onConfigurateDevice() {
+        this.log.info('onConfigurateDevice start');
+        if (this.platformRunner === undefined || this.roborockService === undefined) {
+            this.log.error('Initializing: PlatformRunner or RoborockService is undefined');
+            return;
+        }
+        const vacuum = this.devices.get(this.serialNumber);
+        const username = this.config.username;
+        if (!vacuum || !username) {
+            this.log.error('Initializing: No supported devices found');
+            return;
+        }
+        const self = this;
+        await this.roborockService.initializeMessageClientForLocal(vacuum);
+        const roomMap = await this.platformRunner.getRoomMapFromDevice(vacuum);
+        this.log.debug('Initializing - roomMap: ', JSON.stringify(roomMap));
+        const behaviorHandler = configurateBehavior(vacuum.data.model, vacuum.duid, this.roborockService, this.log);
+        this.roborockService.setSupportedAreas(vacuum.duid, getSupportedAreas(vacuum.rooms, roomMap, this.log));
+        this.robot = new RoborockVacuumCleaner(username, vacuum, roomMap, this.log);
+        this.robot.configurateHandler(behaviorHandler);
+        this.log.info('vacuum:', JSON.stringify(vacuum));
+        this.setSelectDevice(this.robot.serialNumber ?? '', this.robot.deviceName ?? '', undefined, 'hub');
+        if (this.validateDevice(this.robot.deviceName ?? '')) {
+            await this.registerDevice(this.robot);
+        }
+        this.roborockService.setDeviceNotify(async function (messageSource, homeData) {
+            await self.platformRunner?.updateRobot(messageSource, homeData);
+        });
+        await this.roborockService.activateDeviceNotify(this.robot.device);
+        await self.platformRunner?.requestHomeData();
+        this.log.info('onConfigurateDevice finished');
+    }
+    async onShutdown(reason) {
+        await super.onShutdown(reason);
+        this.log.notice('onShutdown called with reason:', reason ?? 'none');
+        this.rvcInterval && clearInterval(this.rvcInterval);
+        if (this.roborockService)
+            this.roborockService.stopService();
+        if (this.config.unregisterOnShutdown === true)
+            await this.unregisterAllDevices(500);
+    }
+    async onChangeLoggerLevel(logLevel) {
+        this.log.notice(`Change ${PLUGIN_NAME} log level: ${logLevel} (was ${this.log.logLevel})`);
+        this.log.logLevel = logLevel;
+        return Promise.resolve();
+    }
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}

package/dist/platformRunner.js

@@ -0,0 +1,249 @@
+import { RvcRunMode, PowerSource, ServiceArea, RvcOperationalState, RvcCleanMode } from 'matterbridge/matter/clusters';
+import { getVacuumProperty } from './helper.js';
+import { getRunningMode } from './initialData/getSupportedRunModes.js';
+import { state_to_matter_operational_status, state_to_matter_state } from './share/function.js';
+import RoomMap from './model/RoomMap.js';
+import { getBatteryState, getBatteryStatus, getOperationalErrorState } from './initialData/index.js';
+import { NotifyMessageTypes } from './notifyMessageTypes.js';
+import { Protocol } from './roborockCommunication/broadcast/model/protocol.js';
+import { hasDockingStationError, parseDockingStationStatus } from './model/DockingStationStatus.js';
+import { OperationStatusCode } from './roborockCommunication/Zenum/operationStatusCode.js';
+import { getCurrentCleanModeFromFanPowerFunc, getCurrentCleanModeFromWaterBoxModeFunc, getCurrentCleanModeFunc } from './share/runtimeHelper.js';
+export class PlatformRunner {
+    platform;
+    constructor(platform) {
+        this.platform = platform;
+    }
+    async updateRobot(messageSource, homeData) {
+        if (messageSource === NotifyMessageTypes.HomeData) {
+            this.updateFromHomeData(homeData);
+        }
+        else {
+            await this.updateFromMQTTMessage(messageSource, homeData);
+        }
+    }
+    async requestHomeData() {
+        const platform = this.platform;
+        if (!platform.robot || !platform.robot.rrHomeId)
+            return;
+        if (platform.roborockService === undefined)
+            return;
+        const homeData = await platform.roborockService.getHomeDataForUpdating(platform.robot.rrHomeId);
+        await platform.platformRunner?.updateRobot(NotifyMessageTypes.HomeData, homeData);
+    }
+    async getRoomMapFromDevice(device) {
+        const platform = this.platform;
+        const rooms = device?.rooms ?? [];
+        if (device && platform.roborockService) {
+            const roomData = await platform.roborockService.getRoomMappings(device.duid);
+            return new RoomMap(roomData ?? [], rooms);
+        }
+        return new RoomMap([], rooms);
+    }
+    async getRoomMap() {
+        const platform = this.platform;
+        const rooms = platform.robot?.device.rooms ?? [];
+        if (platform.robot?.device === undefined || platform.roborockService === undefined)
+            return undefined;
+        if (platform.robot.roomInfo === undefined) {
+            const roomData = await platform.roborockService.getRoomMappings(platform.robot.device.duid);
+            platform.robot.roomInfo = new RoomMap(roomData ?? [], rooms);
+            return platform.robot.roomInfo;
+        }
+        return platform.robot.roomInfo;
+    }
+    async updateFromMQTTMessage(messageSource, messageData, tracked = false) {
+        const platform = this.platform;
+        const deviceData = platform.robot?.device.data;
+        if (deviceData === undefined) {
+            platform.log.error('Device data is undefined');
+            return;
+        }
+        if (!tracked) {
+            platform.log.debug(`${messageSource} updateFromMQTTMessage: ${JSON.stringify(messageData)}`);
+        }
+        const duid = messageData.duid;
+        if (platform.robot === undefined)
+            return;
+        if (!platform.robot.serialNumber) {
+            platform.log.error('Robot serial number is undefined');
+            return;
+        }
+        if (platform.robot.serialNumber !== duid) {
+            platform.log.notice(`DUID mismatch: ${duid}, device serial number: ${platform.robot.serialNumber}`);
+            return;
+        }
+        switch (messageSource) {
+            case NotifyMessageTypes.ErrorOccurred: {
+                const errorCode = messageData.errorCode;
+                const operationalStateId = getOperationalErrorState(errorCode);
+                if (operationalStateId) {
+                    platform.log.error(`Error occurred: ${errorCode}`);
+                    platform.robot.updateAttribute(RvcOperationalState.Cluster.id, 'operationalState', operationalStateId, platform.log);
+                }
+                break;
+            }
+            case NotifyMessageTypes.BatteryUpdate: {
+                const batteryLevel = messageData.percentage;
+                if (messageData.percentage && batteryLevel) {
+                    platform.robot.updateAttribute(PowerSource.Cluster.id, 'batPercentRemaining', batteryLevel * 2, platform.log);
+                    platform.robot.updateAttribute(PowerSource.Cluster.id, 'batChargeLevel', getBatteryStatus(batteryLevel), platform.log);
+                }
+                break;
+            }
+            case NotifyMessageTypes.LocalMessage: {
+                const data = messageData.statusType;
+                if (data) {
+                    const state = state_to_matter_state(data.state);
+                    if (state) {
+                        platform.robot.updateAttribute(RvcRunMode.Cluster.id, 'currentMode', getRunningMode(deviceData.model, state), platform.log);
+                    }
+                    const currentRoom = data.cleaning_info?.segment_id ?? -1;
+                    const currentMappedAreas = this.platform.roborockService?.getSupportedAreas(duid);
+                    const isMappedArea = currentMappedAreas?.some((x) => x.areaId == currentRoom);
+                    if (currentRoom !== -1 && isMappedArea) {
+                        const roomMap = await this.getRoomMap();
+                        this.platform.log.debug('RoomMap:', JSON.stringify(roomMap));
+                        this.platform.log.debug('CurrentRoom:', currentRoom);
+                        platform.robot.updateAttribute(ServiceArea.Cluster.id, 'currentArea', currentRoom, platform.log);
+                    }
+                    if (data.battery) {
+                        const batteryLevel = data.battery;
+                        platform.robot.updateAttribute(PowerSource.Cluster.id, 'batPercentRemaining', batteryLevel * 2, platform.log);
+                        platform.robot.updateAttribute(PowerSource.Cluster.id, 'batChargeState', getBatteryState(data.state, data.battery), platform.log);
+                        platform.robot.updateAttribute(PowerSource.Cluster.id, 'batChargeLevel', getBatteryStatus(batteryLevel), platform.log);
+                    }
+                    const currentCleanMode = getCurrentCleanModeFunc(deviceData.model)(data.fan_power, data.water_box_mode);
+                    if (currentCleanMode) {
+                        platform.robot.updateAttribute(RvcCleanMode.Cluster.id, 'currentMode', currentCleanMode, platform.log);
+                    }
+                    this.processAdditionalProps(platform.robot, data);
+                }
+                break;
+            }
+            case NotifyMessageTypes.CloudMessage: {
+                var data = messageData.data;
+                if (!data) {
+                    data = messageData;
+                }
+                if (!data)
+                    return;
+                this.handlerCloudMessage(data, duid, deviceData.model);
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    handlerCloudMessage(data, duid, model) {
+        const platform = this.platform;
+        const messageTypes = Object.keys(data.dps).map(Number);
+        const self = this;
+        messageTypes.forEach(async (messageType) => {
+            switch (messageType) {
+                case Protocol.status_update: {
+                    const status = Number(data.dps[messageType]);
+                    const matterState = state_to_matter_state(status);
+                    if (matterState) {
+                        platform.robot.updateAttribute(RvcRunMode.Cluster.id, 'currentMode', getRunningMode(model, matterState), platform.log);
+                    }
+                    const operationalStateId = state_to_matter_operational_status(status);
+                    if (operationalStateId) {
+                        platform.robot.updateAttribute(RvcOperationalState.Cluster.id, 'operationalState', operationalStateId, platform.log);
+                    }
+                    break;
+                }
+                case Protocol.rpc_response: {
+                    const response = data.dps[messageType];
+                    if (!self.isStatusUpdate(response.result)) {
+                        platform.log.notice('Ignore message:', JSON.stringify(data));
+                        return;
+                    }
+                    const roboStatus = response.result[0];
+                    if (roboStatus) {
+                        const message = { duid: duid, statusType: { ...roboStatus } };
+                        platform.log.debug('rpc_response:', JSON.stringify(message));
+                        await self.updateFromMQTTMessage(NotifyMessageTypes.LocalMessage, message, true);
+                    }
+                    break;
+                }
+                case Protocol.suction_power: {
+                    const fanPower = data.dps[messageType];
+                    const currentCleanMode = getCurrentCleanModeFromFanPowerFunc(model)(fanPower);
+                    if (currentCleanMode) {
+                        platform.robot.updateAttribute(RvcCleanMode.Cluster.id, 'currentMode', currentCleanMode, platform.log);
+                    }
+                    break;
+                }
+                case Protocol.water_box_mode: {
+                    const water_box_mode = data.dps[messageType];
+                    const currentCleanMode = getCurrentCleanModeFromWaterBoxModeFunc(model)(water_box_mode);
+                    if (currentCleanMode) {
+                        platform.robot.updateAttribute(RvcCleanMode.Cluster.id, 'currentMode', currentCleanMode, platform.log);
+                    }
+                    break;
+                }
+                case Protocol.additional_props:
+                case Protocol.back_type: {
+                    break;
+                }
+                default: {
+                    platform.log.notice(`Unknown message type: ${Protocol[messageType] ?? messageType} ,`, JSON.stringify(data));
+                    break;
+                }
+            }
+        });
+    }
+    async processAdditionalProps(robot, message) {
+        const platform = this.platform;
+        if (platform.config.enableExperimentalFeature && message.dss !== undefined) {
+            const dss = parseDockingStationStatus(message.dss);
+            this.platform.log.debug('DockingStationStatus:', JSON.stringify(dss));
+            if (dss && hasDockingStationError(dss)) {
+                platform.robot.updateAttribute(RvcOperationalState.Cluster.id, 'operationalState', RvcOperationalState.OperationalState.Error, platform.log);
+            }
+        }
+        if (message.fan_power !== undefined) {
+            const fanPower = message.fan_power;
+        }
+    }
+    isStatusUpdate(result) {
+        return result && Array.isArray(result) && result.length > 0 && result[0].msg_ver !== undefined && result[0].msg_ver !== null;
+    }
+    updateFromHomeData(homeData) {
+        const platform = this.platform;
+        if (platform.robot === undefined)
+            return;
+        const device = homeData.devices.find((d) => d.duid === platform.robot?.serialNumber);
+        const deviceData = platform.robot?.device.data;
+        if (!device || deviceData === undefined) {
+            platform.log.error('Device not found in home data');
+            return;
+        }
+        device.schema = homeData.products.find((prd) => prd.id == device.productId || prd.model == device.data.model)?.schema ?? [];
+        this.platform.log.debug('updateFromHomeData-homeData:', JSON.stringify(homeData));
+        this.platform.log.debug('updateFromHomeData-device:', JSON.stringify(device));
+        const batteryLevel = getVacuumProperty(device, 'battery');
+        if (batteryLevel) {
+            platform.robot.updateAttribute(PowerSource.Cluster.id, 'batPercentRemaining', batteryLevel ? batteryLevel * 2 : 200, platform.log);
+            platform.robot.updateAttribute(PowerSource.Cluster.id, 'batChargeLevel', getBatteryStatus(batteryLevel), platform.log);
+        }
+        const state = getVacuumProperty(device, 'state');
+        const matterState = state_to_matter_state(state);
+        if (!state || !matterState) {
+            return;
+        }
+        this.platform.log.debug(`updateFromHomeData-RvcRunMode code: ${state} name: ${OperationStatusCode[state]}, matterState: ${RvcRunMode.ModeTag[matterState]}`);
+        if (matterState) {
+            platform.robot.updateAttribute(RvcRunMode.Cluster.id, 'currentMode', getRunningMode(deviceData.model, matterState), platform.log);
+        }
+        const operationalStateId = state_to_matter_operational_status(state);
+        if (operationalStateId) {
+            this.platform.log.debug(`updateFromHomeData-OperationalState: ${RvcOperationalState.OperationalState[operationalStateId]}`);
+            platform.robot.updateAttribute(RvcOperationalState.Cluster.id, 'operationalState', operationalStateId, platform.log);
+        }
+        if (batteryLevel) {
+            platform.robot.updateAttribute(PowerSource.Cluster.id, 'batChargeState', getBatteryState(state, batteryLevel), platform.log);
+        }
+    }
+}

package/dist/roborockCommunication/RESTAPI/roborockAuthenticateApi.js

@@ -0,0 +1,73 @@
+import axios from 'axios';
+import crypto from 'crypto';
+import { URLSearchParams } from 'node:url';
+export class RoborockAuthenticateApi {
+    logger;
+    axiosFactory;
+    deviceId;
+    username;
+    authToken;
+    constructor(logger, axiosFactory = axios) {
+        this.deviceId = crypto.randomUUID();
+        this.axiosFactory = axiosFactory;
+        this.logger = logger;
+    }
+    async loginWithPassword(username, password) {
+        const api = await this.getAPIFor(username);
+        const response = await api.post('api/v1/login', new URLSearchParams({
+            username: username,
+            password: password,
+            needtwostepauth: 'false',
+        }).toString());
+        return this.auth(username, response.data);
+    }
+    async getHomeDetails() {
+        if (!this.username || !this.authToken) {
+            return undefined;
+        }
+        const api = await this.getAPIFor(this.username);
+        const response = await api.get('api/v1/getHomeDetail');
+        const apiResponse = response.data;
+        if (!apiResponse.data) {
+            throw new Error('Failed to retrieve the home details');
+        }
+        return apiResponse.data;
+    }
+    async getAPIFor(username) {
+        const baseUrl = await this.getBaseUrl(username);
+        return this.apiForUser(username, baseUrl);
+    }
+    async getBaseUrl(username) {
+        const api = await this.apiForUser(username);
+        const response = await api.post('api/v1/getUrlByEmail', new URLSearchParams({
+            email: username,
+            needtwostepauth: 'false',
+        }).toString());
+        const apiResponse = response.data;
+        if (!apiResponse.data) {
+            throw new Error('Failed to retrieve base URL: ' + apiResponse.msg);
+        }
+        return apiResponse.data.url;
+    }
+    async apiForUser(username, baseUrl = 'https://usiot.roborock.com') {
+        return this.axiosFactory.create({
+            baseURL: baseUrl,
+            headers: {
+                header_clientid: crypto.createHash('md5').update(username).update(this.deviceId).digest('base64'),
+                Authorization: this.authToken,
+            },
+        });
+    }
+    auth(username, response) {
+        const userdata = response.data;
+        if (!userdata || !userdata.token) {
+            throw new Error('Authentication failed: ' + response.msg + ' code: ' + response.code);
+        }
+        this.loginWithAuthToken(username, userdata.token);
+        return userdata;
+    }
+    loginWithAuthToken(username, token) {
+        this.username = username;
+        this.authToken = token;
+    }
+}

package/dist/roborockCommunication/RESTAPI/roborockIoTApi.js

@@ -0,0 +1,61 @@
+import axios from 'axios';
+import crypto from 'crypto';
+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' + JSON.stringify(error));
+            }
+            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;
+        }
+    }
+}

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["Docking"] = 15] = "Docking";
+    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/authenticateResponse.js

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

package/dist/roborockCommunication/Zmodel/baseURL.js

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