matterbridge-roborock-vacuum-plugin 1.0.5

package/src/platformRunner.ts

@@ -0,0 +1,292 @@
+import { RvcRunMode, PowerSource, ServiceArea, RvcOperationalState, RvcCleanMode } from 'matterbridge/matter/clusters';
+import { getVacuumProperty } from './helper.js';
+import { getRunningMode } from './initialData/getSupportedRunModes.js';
+import { CloudMessageModel } from './model/CloudMessageModel.js';
+import { RoborockMatterbridgePlatform } from './platform.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 { CloudMessageResult } from './roborockCommunication/Zmodel/messageResult.js';
+import { Protocol } from './roborockCommunication/broadcast/model/protocol.js';
+import { DpsPayload } from './roborockCommunication/broadcast/model/dps.js';
+import { RoborockVacuumCleaner } from './rvc.js';
+import { hasDockingStationError, parseDockingStationStatus } from './model/DockingStationStatus.js';
+import { Device, Home } from './roborockCommunication/index.js';
+import { OperationStatusCode } from './roborockCommunication/Zenum/operationStatusCode.js';
+import { getCurrentCleanModeFromFanPowerFunc, getCurrentCleanModeFromWaterBoxModeFunc, getCurrentCleanModeFunc } from './share/runtimeHelper.js';
+
+export class PlatformRunner {
+  platform: RoborockMatterbridgePlatform;
+  constructor(platform: RoborockMatterbridgePlatform) {
+    this.platform = platform;
+  }
+
+  async updateRobot(messageSource: NotifyMessageTypes, homeData: any): Promise<void> {
+    if (messageSource === NotifyMessageTypes.HomeData) {
+      this.updateFromHomeData(homeData);
+    } else {
+      await this.updateFromMQTTMessage(messageSource, homeData);
+    }
+  }
+
+  async requestHomeData(): Promise<void> {
+    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);
+  }
+
+  public async getRoomMapFromDevice(device: Device): Promise<RoomMap> {
+    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(): Promise<RoomMap | undefined> {
+    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;
+  }
+
+  private async updateFromMQTTMessage(messageSource: NotifyMessageTypes, messageData: any, tracked = false): Promise<void> {
+    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;
+    }
+
+    //duid is set as device serial number
+    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 as number;
+        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 as number;
+        if ((messageData.percentage as number) && 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 as CloudMessageResult;
+        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 as number;
+            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 as CloudMessageModel;
+        if (!data) {
+          data = messageData as CloudMessageModel;
+        }
+        if (!data) return;
+        this.handlerCloudMessage(data, duid, deviceData.model);
+        break;
+      }
+
+      default:
+        break;
+    }
+  }
+
+  private handlerCloudMessage(data: CloudMessageModel, duid: string, model: string): void {
+    const platform = this.platform;
+    const messageTypes = Object.keys(data.dps).map(Number);
+    const self = this;
+
+    //Known: 122, 121, 102,
+    //Unknown: 128, 139
+    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] as DpsPayload;
+          //ignore network info
+          if (!self.isStatusUpdate(response.result)) {
+            platform.log.notice('Ignore message:', JSON.stringify(data));
+            return;
+          }
+
+          const roboStatus = response.result[0] as CloudMessageResult;
+          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] as number;
+          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] as number;
+          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: {
+          //TODO: check if this is needed
+          break;
+        }
+        default: {
+          platform.log.notice(`Unknown message type: ${Protocol[messageType] ?? messageType} ,`, JSON.stringify(data));
+          break;
+        }
+      }
+    });
+  }
+
+  private async processAdditionalProps(robot: RoborockVacuumCleaner, message: CloudMessageResult): Promise<void> {
+    //dss -> DockingStationStatus
+    const platform = this.platform;
+    if (platform.config.enableExperimentalFeature && message.dss !== undefined) {
+      const dss = parseDockingStationStatus(message.dss);
+      this.platform.log.debug('DockingStationStatus:', JSON.stringify(dss));
+
+      //Experimental feature
+      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 as number;
+      //robot.updateAttribute(RvcRunMode.Cluster.id, 'fanPower', fanPower, this.platform.log);
+    }
+  }
+
+  private isStatusUpdate(result: any): boolean {
+    return result && Array.isArray(result) && result.length > 0 && (result[0] as CloudMessageResult).msg_ver !== undefined && (result[0] as CloudMessageResult).msg_ver !== null;
+  }
+
+  private updateFromHomeData(homeData: Home): void {
+    const platform = this.platform;
+    if (platform.robot === undefined) return;
+    const device = homeData.devices.find((d: Device) => 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/src/roborockCommunication/RESTAPI/roborockAuthenticateApi.ts

@@ -0,0 +1,98 @@
+import axios, { AxiosInstance, AxiosStatic } from 'axios';
+import crypto from 'crypto';
+import { AnsiLogger } from 'matterbridge/logger';
+import { URLSearchParams } from 'node:url';
+import { AuthenticateResponse } from '../Zmodel/authenticateResponse.js';
+import { BaseUrl } from '../Zmodel/baseURL.js';
+import { HomeInfo } from '../Zmodel/homeInfo.js';
+import { UserData } from '../Zmodel/userData.js';
+
+export class RoborockAuthenticateApi {
+  private readonly logger: AnsiLogger;
+  private axiosFactory: AxiosStatic;
+  private deviceId: string;
+  private username?: string;
+  private authToken?: string;
+
+  constructor(logger: AnsiLogger, axiosFactory: AxiosStatic = axios) {
+    this.deviceId = crypto.randomUUID();
+    this.axiosFactory = axiosFactory;
+    this.logger = logger;
+  }
+
+  async loginWithPassword(username: string, password: string): Promise<UserData> {
+    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(): Promise<HomeInfo | undefined> {
+    if (!this.username || !this.authToken) {
+      return undefined;
+    }
+
+    const api = await this.getAPIFor(this.username);
+    const response = await api.get('api/v1/getHomeDetail');
+
+    const apiResponse: AuthenticateResponse<HomeInfo> = response.data;
+    if (!apiResponse.data) {
+      throw new Error('Failed to retrieve the home details');
+    }
+    return apiResponse.data;
+  }
+
+  private async getAPIFor(username: string): Promise<AxiosInstance> {
+    const baseUrl = await this.getBaseUrl(username);
+    return this.apiForUser(username, baseUrl);
+  }
+
+  private async getBaseUrl(username: string): Promise<string> {
+    const api = await this.apiForUser(username);
+    const response = await api.post(
+      'api/v1/getUrlByEmail',
+      new URLSearchParams({
+        email: username,
+        needtwostepauth: 'false',
+      }).toString(),
+    );
+
+    const apiResponse: AuthenticateResponse<BaseUrl> = response.data;
+    if (!apiResponse.data) {
+      throw new Error('Failed to retrieve base URL: ' + apiResponse.msg);
+    }
+
+    return apiResponse.data.url;
+  }
+
+  private async apiForUser(username: string, baseUrl: string = 'https://usiot.roborock.com'): Promise<AxiosInstance> {
+    return this.axiosFactory.create({
+      baseURL: baseUrl,
+      headers: {
+        header_clientid: crypto.createHash('md5').update(username).update(this.deviceId).digest('base64'),
+        Authorization: this.authToken,
+      },
+    });
+  }
+
+  private auth(username: string, response: AuthenticateResponse<UserData>): UserData {
+    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;
+  }
+
+  private loginWithAuthToken(username: string, token: string): void {
+    this.username = username;
+    this.authToken = token;
+  }
+}

package/src/roborockCommunication/RESTAPI/roborockIoTApi.ts

@@ -0,0 +1,70 @@
+import axios, { AxiosInstance } from 'axios';
+import crypto from 'crypto';
+import { AnsiLogger } from 'matterbridge/logger';
+import { ApiResponse } from '../Zmodel/apiResponse.js';
+import { Home } from '../Zmodel/home.js';
+import { UserData } from '../Zmodel/userData.js';
+
+export class RoborockIoTApi {
+  logger: AnsiLogger;
+  private readonly api: AxiosInstance;
+
+  constructor(userdata: UserData, logger: AnsiLogger) {
+    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: number): Promise<Home | undefined> {
+    const result = await this.api.get(`user/homes/${homeId}`);
+
+    const apiResponse: ApiResponse<Home> = result.data;
+    if (apiResponse.result) {
+      return apiResponse.result;
+    } else {
+      this.logger.error('Failed to retrieve the home data');
+      return undefined;
+    }
+  }
+
+  async getHomev2(homeId: number): Promise<Home | undefined> {
+    const result = await this.api.get('v2/user/homes/' + homeId);
+
+    const apiResponse: ApiResponse<Home> = result.data;
+    if (apiResponse.result) {
+      return apiResponse.result;
+    } else {
+      this.logger.error('Failed to retrieve the home data');
+      return undefined;
+    }
+  }
+
+  async getHomev3(homeId: number): Promise<Home | undefined> {
+    const result = await this.api.get('v3/user/homes/' + homeId);
+
+    const apiResponse: ApiResponse<Home> = result.data;
+    if (apiResponse.result) {
+      return apiResponse.result;
+    } else {
+      this.logger.error('Failed to retrieve the home data');
+      return undefined;
+    }
+  }
+}

package/src/roborockCommunication/Zenum/dockType.ts

@@ -0,0 +1,3 @@
+export enum DockType {
+  qrevo_curv_dock = 17,
+}

package/src/roborockCommunication/Zenum/operationStatusCode.ts

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

package/src/roborockCommunication/Zenum/vacuumAndDockErrorCode.ts

@@ -0,0 +1,68 @@
+export enum VacuumErrorCode {
+  None = 0,
+  LidarBlocked = 1,
+  BumperStuck = 2,
+  WheelsSuspended = 3,
+  CliffSensorError = 4,
+  MainBrushJammed = 5,
+  SideBrushJammed = 6,
+  WheelsJammed = 7,
+  RobotTrapped = 8,
+  NoDustbin = 9,
+  StrainerError = 10,
+  CompassError = 11,
+  LowBattery = 12,
+  ChargingError = 13,
+  BatteryError = 14,
+  WallSensorDirty = 15,
+  RobotTilted = 16,
+  SideBrushError = 17,
+  FanError = 18,
+  DockNotConnectedToPower = 19,
+  OpticalFlowSensorDirt = 20,
+  VerticalBumperPressed = 21,
+  DockLocatorError = 22,
+  ReturnToDockFail = 23,
+  NogoZoneDetected = 24,
+  CameraError = 25,
+  WallSensorError = 26,
+  VibrariseJammed = 27,
+  RobotOnCarpet = 28,
+  FilterBlocked = 29,
+  InvisibleWallDetected = 30,
+  CannotCrossCarpet = 31,
+  InternalError = 32,
+  CleanAutoEmptyDock = 34,
+  AutoEmptyDockVoltage = 35,
+  MoppingRollerJammed = 36, // Wash roller may be jammed
+  MoppingRollerNotLowered = 37, // wash roller not lowered properly
+  ClearWaterBoxHoare = 38,
+  DirtyWaterBoxHoare = 39,
+  SinkStrainerHoare = 40,
+  ClearWaterTankEmpty = 41,
+  ClearBrushInstalledProperly = 42, // Check that the water filter has been correctly installed
+  ClearBrushPositioningError = 43,
+  FilterScreenException = 44, // Clean the dock water filter
+  MoppingRollerJammed2 = 45, // Wash roller may be jammed
+  UpWaterException = 48,
+  DrainWaterException = 49,
+  TemperatureProtection = 51,
+  CleanCarouselException = 52,
+  CleanCarouselWaterFull = 53,
+  WaterCarriageDrop = 54,
+  CheckCleanCarouse = 55,
+  AudioError = 56,
+}
+
+export enum DockErrorCode {
+  None = 0,
+  DuctBlockage = 34, // Duct blockage detected
+  WaterEmpty = 38, // Clean water tank empty
+  WasteWaterTankFull = 39, // Waste water tank full
+  MaintenanceBrushJammed = 42, // Maintenance brush jammed
+  DirtyTankLatchOpen = 44, // Dirty tank latch open
+  NoDustbin = 46, // No dustbin detected
+  CleaningTankFullOrBlocked = 53, // Cleaning tank full or blocked
+}
+
+export const SUPPORTED_ATTACHMENTS = ['WATERTANK', 'MOP'];

package/src/roborockCommunication/Zmodel/apiResponse.ts

@@ -0,0 +1,3 @@
+export interface ApiResponse<T> {
+  result?: T;
+}

package/src/roborockCommunication/Zmodel/authenticateResponse.ts

@@ -0,0 +1,5 @@
+export interface AuthenticateResponse<T> {
+  msg?: string;
+  data?: T;
+  code?: number;
+}

package/src/roborockCommunication/Zmodel/baseURL.ts

@@ -0,0 +1,5 @@
+export interface BaseUrl {
+  url: string;
+  country: string;
+  countrycode: string;
+}

package/src/roborockCommunication/Zmodel/device.ts

@@ -0,0 +1,39 @@
+import { DeviceSchema } from './deviceSchema.js';
+import { Room } from './room.js';
+
+export interface Device {
+  duid: string;
+  name: string;
+  sn: string;
+  serialNumber: string;
+
+  activeTime: number;
+  createTime: number;
+
+  localKey: string;
+
+  /** The protocol version of the robot. */
+  pv: string;
+  online: boolean;
+
+  productId: string;
+
+  rrHomeId: number;
+
+  /** The firmware version of the robot. */
+  fv: string;
+
+  deviceStatus: Record<string, number>;
+  rooms: Room[];
+
+  schema: DeviceSchema[];
+
+  data: {
+    id: string;
+    firmwareVersion: string;
+    serialNumber: string;
+    model: string;
+    category: string;
+    batteryLevel: number;
+  };
+}

package/src/roborockCommunication/Zmodel/deviceModel.ts

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

package/src/roborockCommunication/Zmodel/deviceSchema.ts

@@ -0,0 +1,8 @@
+export interface DeviceSchema {
+  id: number;
+  name: string;
+  code: string;
+  mode: string;
+  type: string;
+  property: any;
+}