@ray-js/robot-data-stream 0.0.14 → 0.0.15-beta.1

package/lib/mqtt/type/fun.js

@@ -0,0 +1,145 @@
+import "core-js/modules/esnext.iterator.map.js";
+// protocol-validator.ts
+
+import { MqttError } from '../promise';
+
+// 导入各个协议的 schema 和验证函数
+import { setCarpetCleanSchema } from './protocols/carpetCleanProtocol';
+import { addCarpetSchema, deleteCarpetSchema, queryCarpetSchema, setCarpetSchema, updateCarpetSchema, validateAddCarpet, validateSetCarpet, validateUpdateCarpet } from './protocols/carpetProtocol';
+import { setDeviceModelSchema } from './protocols/deviceModelProtocol';
+import { requestFurnitureListSchema, setFurnitureModelSchema } from './protocols/furnitureModelProtocol';
+import { changeCurrentMapSchema, deleteHistoryMapSchema, saveMapSchema } from './protocols/historyMapProtocol';
+import { pointsSchema, roomIdSchema, originSchema } from './protocols/partDivisionProtocol';
+import { setPartMergeSchema } from './protocols/partMergeProtocol';
+import { checkPasswordSchema, setPasswordSchema } from './protocols/passwordProtocol';
+import { setQuietHoursSchema } from './protocols/quietHoursProtocol';
+import { setRoomPropertySchema, validateSetRoomProperty } from './protocols/roomPropertyProtocol';
+import { requestScheduleSchema, setScheduleSchema, validateSetSchedule } from './protocols/scheduleProtocol';
+import { setSelectRoomCleanSchema } from './protocols/selectRoomCleanProtocol';
+import { setSpotCleanSchema, validateSetSpotClean } from './protocols/spotCleanProtocol';
+import { setVirtualAreaSchema } from './protocols/virtualAreaProtocol';
+import { setVirtualWallSchema } from './protocols/virtualWallProtocol';
+import { setVoiceSchema } from './protocols/voiceProtocol';
+import { setWifiMapSchema } from './protocols/wifiMapProtocol';
+import { setZoneCleanSchema } from './protocols/zoneCleanProtocol';
+
+/**
+ * 验证失败错误代码
+ * -2 表示数据验证失败
+ */
+const VALIDATION_ERROR_CODE = -2;
+
+// 协议定义 - 从各个协议文件导入
+export const ProtocolSchemas = {
+  query_carpet: queryCarpetSchema,
+  add_carpet: addCarpetSchema,
+  update_carpet: updateCarpetSchema,
+  delete_carpet: deleteCarpetSchema,
+  set_carpet: setCarpetSchema,
+  set_schedule: setScheduleSchema,
+  request_schedule: requestScheduleSchema,
+  set_zone_clean: setZoneCleanSchema,
+  set_wifi_map: setWifiMapSchema,
+  set_voice: setVoiceSchema,
+  set_virtual_wall: setVirtualWallSchema,
+  set_virtual_area: setVirtualAreaSchema,
+  set_spot_clean: setSpotCleanSchema,
+  set_select_room_clean: setSelectRoomCleanSchema,
+  set_quiet_hours: setQuietHoursSchema,
+  set_password: setPasswordSchema,
+  check_password: checkPasswordSchema,
+  set_part_merge: setPartMergeSchema,
+  delete_history_map: deleteHistoryMapSchema,
+  save_map: saveMapSchema,
+  change_current_map: changeCurrentMapSchema,
+  request_furniture_list: requestFurnitureListSchema,
+  set_furniture_model: setFurnitureModelSchema,
+  set_device_model: setDeviceModelSchema,
+  set_carpet_clean: setCarpetCleanSchema,
+  set_room_property: setRoomPropertySchema
+};
+
+// 协议验证函数类型
+
+// 协议注册表 - 将协议名称映射到验证函数
+const protocolValidators = {
+  add_carpet: validateAddCarpet,
+  update_carpet: validateUpdateCarpet,
+  set_carpet: validateSetCarpet,
+  set_schedule: validateSetSchedule,
+  set_spot_clean: validateSetSpotClean,
+  set_room_property: validateSetRoomProperty
+  // query_carpet 没有自定义验证逻辑，不需要注册
+  // delete_carpet 没有自定义验证逻辑，不需要注册
+  // request_schedule 没有自定义验证逻辑，不需要注册
+};
+
+// 类型导出
+
+// 验证器类
+export class MiniProtocolValidator {
+  validate(protocol, data) {
+    const schema = ProtocolSchemas[protocol];
+
+    // 使用 zod/mini 的 safeParse 进行基础验证
+    const result = schema.safeParse(data);
+    if (!result.success) {
+      // 验证失败，抛出 MqttError
+      throw new MqttError(`协议 ${protocol} ${JSON.stringify(data)} 验证失败:\n` + result.error.issues.map(e => `  ${e.path.join('.')}: ${e.message}`).join('\n'), {
+        errCode: VALIDATION_ERROR_CODE,
+        reqType: protocol
+      });
+    }
+    const validatedData = result.data;
+
+    // 自定义逻辑验证 - 根据协议名称调用对应的验证函数
+    const validator = protocolValidators[protocol];
+    if (validator) {
+      validator(validatedData);
+    }
+    return validatedData;
+  }
+
+  /**
+   * 验证 set_part_division 的三个独立参数
+   * @param points 分隔点数组
+   * @param roomId 房间ID（可以是 int 或 string）
+   * @param origin 地图原点坐标
+   * @returns 验证后的数据对象
+   */
+  validateSetPartDivision(points, roomId, origin) {
+    // 分别验证三个参数
+    const pointsResult = pointsSchema.safeParse(points);
+    if (!pointsResult.success) {
+      throw new MqttError(`协议 set_part_division points 参数验证失败:\n` + pointsResult.error.issues.map(e => `  ${e.path.join('.')}: ${e.message}`).join('\n'), {
+        errCode: VALIDATION_ERROR_CODE,
+        reqType: 'set_part_division'
+      });
+    }
+    const roomIdResult = roomIdSchema.safeParse(roomId);
+    if (!roomIdResult.success) {
+      throw new MqttError(`协议 set_part_division roomId 参数验证失败:\n` + roomIdResult.error.issues.map(e => `  ${e.path.join('.')}: ${e.message}`).join('\n'), {
+        errCode: VALIDATION_ERROR_CODE,
+        reqType: 'set_part_division'
+      });
+    }
+    const originResult = originSchema.safeParse(origin);
+    if (!originResult.success) {
+      throw new MqttError(`协议 set_part_division origin 参数验证失败:\n` + originResult.error.issues.map(e => `  ${e.path.join('.')}: ${e.message}`).join('\n'), {
+        errCode: VALIDATION_ERROR_CODE,
+        reqType: 'set_part_division'
+      });
+    }
+
+    // 组合成对象并验证整体结构
+    const data = {
+      points: pointsResult.data,
+      roomId: roomIdResult.data,
+      origin: originResult.data
+    };
+    return data;
+  }
+}
+
+// 导出验证器实例
+export const validator = new MiniProtocolValidator();

package/lib/mqtt/type/index.d.ts

@@ -1,11 +1,4 @@
 export * from './requestType';
-export interface BaseResponse {
-    success: boolean;
-    errCode: number;
-    reqType: string;
-    version: string;
-    taskId: string;
-}
 /**
  * MQTT 协议号枚举
  */

package/lib/mqtt/type/index.js

@@ -1,5 +1,4 @@
 export * from './requestType';
-// 设备接口响应的统一标准结构
 
 /**
  * MQTT 协议号枚举

package/lib/mqtt/type/protocols/base.d.ts

@@ -0,0 +1,5 @@
+import * as z from 'zod/mini';
+export declare const Point: any;
+export declare const RoomPreferenceFieldsSchema: any;
+export declare const BaseResponseSchema: any;
+export type BaseResponse = z.infer<typeof BaseResponseSchema>;

package/lib/mqtt/type/protocols/base.js

@@ -0,0 +1,32 @@
+import * as z from 'zod/mini';
+
+// 基础类型
+export const Point = z.object({
+  x: z.number(),
+  y: z.number()
+});
+
+// RoomPreference 相关字段 Schema
+export const RoomPreferenceFieldsSchema = z.object({
+  // 吸力， closed - 关闭 gentle - 安静 normal - 正常 strong - 强劲 max - 超强 ，默认值为''
+  suctions: z.optional(z.array(z.string())),
+  // 拖地水量 "closed"- 关闭,"low"-低,"middle"-中,"high"-高,默认值为''
+  cisterns: z.optional(z.array(z.string())),
+  // 清扫次数 默认值1
+  cleanCounts: z.optional(z.array(z.int())),
+  // 拖地模式 1:开启Y型拖地 0:关闭Y型拖地  -1 未设置 默认值-1
+  yMops: z.optional(z.array(z.int())),
+  // 扫拖模式 "only_sweep":仅扫,"only_mop"：仅拖,"both_work"：扫拖同时,"clean_before_mop"：先扫后拖，默认值为'only_sweep'
+  sweepMopModes: z.optional(z.array(z.string())),
+  // 房间id集合
+  ids: z.optional(z.array(z.int()))
+});
+
+// BaseResponse Schema（用于响应类型）
+export const BaseResponseSchema = z.object({
+  success: z.boolean(),
+  errCode: z.number(),
+  reqType: z.string(),
+  version: z.string(),
+  taskId: z.string()
+});

package/lib/mqtt/type/protocols/carpetCleanProtocol.d.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod/mini';
+export declare const setCarpetCleanSchema: any;
+declare const carpetCleanResponseSchema: any;
+export type SetCarpetCleanData = z.infer<typeof setCarpetCleanSchema>;
+export type CarpetCleanResponse = z.infer<typeof carpetCleanResponseSchema>;
+export type TRequestCarpetClean = () => Promise<CarpetCleanResponse>;
+export type TSetCarpetClean = (data: SetCarpetCleanData) => Promise<CarpetCleanResponse>;
+export {};

package/lib/mqtt/type/protocols/carpetCleanProtocol.js

@@ -0,0 +1,16 @@
+import { z } from 'zod/mini';
+import { BaseResponseSchema } from './base';
+
+// 设置地毯清扫参数 Schema
+export const setCarpetCleanSchema = z.object({
+  ids: z.array(z.number()) // 地毯ID数组，注意: .min()放在数组元素上
+});
+
+// 地毯清扫响应 Schema
+const carpetCleanResponseSchema = z.extend(BaseResponseSchema, {
+  ids: z.array(z.number())
+});
+
+// 类型导出
+
+// 函数类型定义

package/lib/mqtt/type/protocols/carpetProtocol.d.ts

@@ -0,0 +1,41 @@
+import * as z from 'zod/mini';
+import { BaseResponse } from './base';
+export declare const queryCarpetSchema: any;
+export declare const addCarpetSchema: any;
+export declare const updateCarpetSchema: any;
+export declare const deleteCarpetSchema: any;
+export declare const setCarpetSchema: any;
+declare const addCarpetResponseSchema: any;
+declare const carpetQueryResponseSchema: any;
+export type QueryCarpetData = z.infer<typeof queryCarpetSchema>;
+export type AddCarpetData = z.infer<typeof addCarpetSchema>;
+export type UpdateCarpetData = z.infer<typeof updateCarpetSchema>;
+export type DeleteCarpetData = z.infer<typeof deleteCarpetSchema>;
+export type SetCarpetData = z.infer<typeof setCarpetSchema>;
+export type AddCarpetResponse = z.infer<typeof addCarpetResponseSchema>;
+export type CarpetQueryResponse = z.infer<typeof carpetQueryResponseSchema>;
+/**
+ * 验证添加地毯协议数据
+ * @param data 已验证基础 schema 的数据
+ * @throws MqttError 验证失败时抛出
+ */
+export declare function validateAddCarpet(data: AddCarpetData): void;
+/**
+ * 验证更新地毯协议数据
+ * @param data 已验证基础 schema 的数据
+ * @throws MqttError 验证失败时抛出
+ */
+export declare function validateUpdateCarpet(data: UpdateCarpetData): void;
+/**
+ * 验证设置地毯协议数据
+ * @param data 已验证基础 schema 的数据
+ * @throws MqttError 验证失败时抛出
+ */
+export declare function validateSetCarpet(data: SetCarpetData): void;
+export type TQueryCarpet = (data?: QueryCarpetData) => Promise<CarpetQueryResponse>;
+export type TAddCarpet = (data: AddCarpetData) => Promise<AddCarpetResponse>;
+export type TUpdateCarpet = (data: UpdateCarpetData) => Promise<BaseResponse>;
+export type TDeleteCarpet = (data: DeleteCarpetData) => Promise<BaseResponse>;
+export type TSetCarpet = (data: SetCarpetData) => Promise<CarpetQueryResponse>;
+export type SetCarpetInput = SetCarpetData;
+export {};

package/lib/mqtt/type/protocols/carpetProtocol.js

@@ -0,0 +1,202 @@
+import * as z from 'zod/mini';
+import { MqttError } from '../../promise';
+import { BaseResponseSchema, Point } from './base';
+
+/**
+ * 验证失败错误代码
+ * -2 表示数据验证失败
+ */
+const VALIDATION_ERROR_CODE = -2;
+
+// 形状类型
+const ShapeType = z.union([z.literal('rectangle'), z.literal('round'), z.literal('custom')]);
+
+// 请求查询地毯参数 Schema（目前为空，但保留扩展性）
+export const queryCarpetSchema = z.object({});
+
+// 添加地毯参数 Schema
+export const addCarpetSchema = z.object({
+  shape: z.array(ShapeType),
+  polygons: z.array(z.array(Point)),
+  num: z.number(),
+  type: z.array(z.number()),
+  cleanMode: z.array(z.number()),
+  autoBoost: z.optional(z.array(z.number())),
+  fineCleaning: z.optional(z.array(z.number())),
+  sideBrushRotating: z.optional(z.array(z.number()))
+});
+
+// 更新地毯参数 Schema（所有字段都是可选的，除了 ids）
+export const updateCarpetSchema = z.object({
+  ids: z.array(z.number()),
+  shape: z.optional(z.array(ShapeType)),
+  type: z.optional(z.array(z.number())),
+  cleanMode: z.optional(z.array(z.number())),
+  autoBoost: z.optional(z.array(z.number())),
+  fineCleaning: z.optional(z.array(z.number())),
+  sideBrushRotating: z.optional(z.array(z.number())),
+  polygons: z.optional(z.array(z.array(Point)))
+});
+
+// 删除地毯参数 Schema
+export const deleteCarpetSchema = z.object({
+  ids: z.array(z.number())
+});
+
+// 设置地毯参数 Schema
+export const setCarpetSchema = z.object({
+  num: z.int().check(z.gte(0), z.lte(100)),
+  polygons: z.array(z.array(Point).check(z.minLength(3))),
+  cleanMode: z.array(z.int().check(z.gte(0), z.lte(10))),
+  shape: z.array(ShapeType),
+  ids: z.array(z.int()),
+  type: z.optional(z.array(z.int())),
+  autoBoost: z.optional(z.array(z.int())),
+  fineCleaning: z.optional(z.array(z.int())),
+  sideBrushRotating: z.optional(z.array(z.int()))
+});
+
+// 添加地毯响应 Schema
+const addCarpetResponseSchema = z.extend(BaseResponseSchema, {
+  // 返回的地毯ID数组
+  ids: z.array(z.int())
+});
+
+// 地毯查询响应 Schema
+const carpetQueryResponseSchema = z.extend(BaseResponseSchema, {
+  // 地毯数量
+  num: z.int(),
+  // 轮廓点集合（字符串格式）
+  polygons: z.array(z.string()),
+  // 清洁属性
+  cleanMode: z.optional(z.array(z.int())),
+  // 形状
+  shape: z.optional(z.array(z.string())),
+  // 材质
+  type: z.optional(z.array(z.int())),
+  // 地毯ID数组
+  ids: z.optional(z.array(z.int())),
+  // 自动增压
+  autoBoost: z.optional(z.array(z.int())),
+  // 精细清扫
+  fineCleaning: z.optional(z.array(z.int())),
+  // 边刷旋转
+  sideBrushRotating: z.optional(z.array(z.int()))
+});
+
+// 类型导出
+
+/**
+ * 验证添加地毯协议数据
+ * @param data 已验证基础 schema 的数据
+ * @throws MqttError 验证失败时抛出
+ */
+export function validateAddCarpet(data) {
+  const {
+    num
+  } = data;
+
+  // 验证数组长度一致性
+  const validateLength = (name, array) => {
+    if (array.length !== num) {
+      throw new MqttError(`${name} 长度必须为 ${num}，实际为 ${array.length}`, {
+        errCode: VALIDATION_ERROR_CODE,
+        reqType: 'add_carpet'
+      });
+    }
+  };
+  validateLength('shape', data.shape);
+  validateLength('polygons', data.polygons);
+  validateLength('type', data.type);
+  validateLength('cleanMode', data.cleanMode);
+  if (data.autoBoost) {
+    validateLength('autoBoost', data.autoBoost);
+  }
+  if (data.fineCleaning) {
+    validateLength('fineCleaning', data.fineCleaning);
+  }
+  if (data.sideBrushRotating) {
+    validateLength('sideBrushRotating', data.sideBrushRotating);
+  }
+}
+
+/**
+ * 验证更新地毯协议数据
+ * @param data 已验证基础 schema 的数据
+ * @throws MqttError 验证失败时抛出
+ */
+export function validateUpdateCarpet(data) {
+  const num = data.ids.length;
+
+  // 验证数组长度一致性（如果提供了数组字段）
+  const validateLength = (name, array) => {
+    if (array.length !== num) {
+      throw new MqttError(`${name} 长度必须为 ${num}，实际为 ${array.length}`, {
+        errCode: VALIDATION_ERROR_CODE,
+        reqType: 'update_carpet'
+      });
+    }
+  };
+  if (data.shape) {
+    validateLength('shape', data.shape);
+  }
+  if (data.type) {
+    validateLength('type', data.type);
+  }
+  if (data.cleanMode) {
+    validateLength('cleanMode', data.cleanMode);
+  }
+  if (data.polygons) {
+    validateLength('polygons', data.polygons);
+  }
+  if (data.autoBoost) {
+    validateLength('autoBoost', data.autoBoost);
+  }
+  if (data.fineCleaning) {
+    validateLength('fineCleaning', data.fineCleaning);
+  }
+  if (data.sideBrushRotating) {
+    validateLength('sideBrushRotating', data.sideBrushRotating);
+  }
+}
+
+/**
+ * 验证设置地毯协议数据
+ * @param data 已验证基础 schema 的数据
+ * @throws MqttError 验证失败时抛出
+ */
+export function validateSetCarpet(data) {
+  const {
+    num
+  } = data;
+
+  // 验证数组长度一致性
+  const validateLength = (name, array) => {
+    if (array.length !== num) {
+      throw new MqttError(`${name} 长度必须为 ${num}，实际为 ${array.length}`, {
+        errCode: VALIDATION_ERROR_CODE,
+        reqType: 'set_carpet'
+      });
+    }
+  };
+  validateLength('polygons', data.polygons);
+  validateLength('cleanMode', data.cleanMode);
+  validateLength('shape', data.shape);
+  validateLength('ids', data.ids);
+  if (data.type) {
+    validateLength('type', data.type);
+  }
+  if (data.autoBoost) {
+    validateLength('autoBoost', data.autoBoost);
+  }
+  if (data.fineCleaning) {
+    validateLength('fineCleaning', data.fineCleaning);
+  }
+  if (data.sideBrushRotating) {
+    validateLength('sideBrushRotating', data.sideBrushRotating);
+  }
+}
+
+// 函数类型定义
+
+// 导出 SetCarpetInput 类型别名（向后兼容）

package/lib/mqtt/type/protocols/devInfoProtocol.d.ts

@@ -0,0 +1,5 @@
+import * as z from 'zod/mini';
+declare const devInfoResponseSchema: any;
+export type DevInfoResponse = z.infer<typeof devInfoResponseSchema>;
+export type TRequestDevInfo = () => Promise<DevInfoResponse>;
+export {};

package/lib/mqtt/type/protocols/devInfoProtocol.js

@@ -0,0 +1,12 @@
+import * as z from 'zod/mini';
+import { BaseResponseSchema } from './base';
+
+// 设备信息响应 Schema
+const devInfoResponseSchema = z.extend(BaseResponseSchema, {
+  // 设备信息的 JSON 字符串
+  info: z.string()
+});
+
+// 类型导出
+
+// 函数类型定义

package/lib/mqtt/type/protocols/deviceModelProtocol.d.ts

@@ -0,0 +1,8 @@
+import * as z from 'zod/mini';
+export declare const setDeviceModelSchema: any;
+declare const deviceModelResponseSchema: any;
+export type SetDeviceModelData = z.infer<typeof setDeviceModelSchema>;
+export type DeviceModelResponse = z.infer<typeof deviceModelResponseSchema>;
+export type TRequestDeviceList = () => Promise<DeviceModelResponse>;
+export type TSetDeviceModel = (data: SetDeviceModelData) => Promise<DeviceModelResponse>;
+export {};

package/lib/mqtt/type/protocols/deviceModelProtocol.js

@@ -0,0 +1,34 @@
+import * as z from 'zod/mini';
+import { BaseResponseSchema } from './base';
+
+// 设备模型信息 Schema
+const deviceModelInfoSchema = z.object({
+  id: z.int(),
+  // 设备模型ID
+  modelType: z.int(),
+  // 设备模型类型
+  scale: z.number(),
+  // 设备模型缩放比例
+  size: z.tuple([z.number(), z.number(), z.number()]),
+  // 设备模型尺寸
+  rotation: z.tuple([z.number(), z.number(), z.number()]),
+  // 设备模型旋转角度
+  position: z.tuple([z.number(), z.number(), z.number()]),
+  // 设备模型位置
+  subDevId: z.string() // 当前设备模型所关联的设备ID
+});
+
+// 设置设备模型参数 Schema
+export const setDeviceModelSchema = z.object({
+  modelInfos: z.array(deviceModelInfoSchema) // 设备模型信息数组
+});
+
+// 设备模型响应 Schema
+const deviceModelResponseSchema = z.extend(BaseResponseSchema, {
+  // 设备模型信息数组
+  modelInfo: z.array(deviceModelInfoSchema)
+});
+
+// 类型导出
+
+// 函数类型定义

package/lib/mqtt/type/protocols/furnitureModelProtocol.d.ts

@@ -0,0 +1,10 @@
+import * as z from 'zod/mini';
+export declare const requestFurnitureListSchema: any;
+export declare const setFurnitureModelSchema: any;
+declare const furnitureModelResponseSchema: any;
+type RequestFurnitureListData = z.infer<typeof requestFurnitureListSchema>;
+type SetFurnitureModelData = z.infer<typeof setFurnitureModelSchema>;
+export type FurnitureModelResponse = z.infer<typeof furnitureModelResponseSchema>;
+export type TRequestFurnitureList = (data?: RequestFurnitureListData) => Promise<FurnitureModelResponse>;
+export type TSetFurnitureModel = (data: SetFurnitureModelData) => Promise<FurnitureModelResponse>;
+export {};

package/lib/mqtt/type/protocols/furnitureModelProtocol.js

@@ -0,0 +1,35 @@
+import * as z from 'zod/mini';
+import { BaseResponseSchema } from './base';
+
+// 家具模型信息 Schema
+const furnitureModelInfoSchema = z.object({
+  id: z.int(),
+  // 家具模型ID
+  modelType: z.int(),
+  // 家具模型类型
+  scale: z.number(),
+  // 家具模型缩放比例
+  size: z.tuple([z.number(), z.number(), z.number()]),
+  // 家具模型尺寸
+  rotation: z.tuple([z.number(), z.number(), z.number()]),
+  // 家具模型旋转角度
+  position: z.tuple([z.number(), z.number(), z.number()]) // 家具模型位置
+});
+
+// 请求家具列表参数 Schema（目前为空，但保留扩展性）
+export const requestFurnitureListSchema = z.object({});
+
+// 设置家具模型参数 Schema
+export const setFurnitureModelSchema = z.object({
+  modelInfos: z.array(furnitureModelInfoSchema) // 家具模型信息数组
+});
+
+// 家具模型响应 Schema
+const furnitureModelResponseSchema = z.extend(BaseResponseSchema, {
+  // 家具模型信息数组
+  modelInfo: z.array(furnitureModelInfoSchema)
+});
+
+// 类型导出
+
+// 函数类型定义

package/lib/mqtt/type/protocols/historyMapProtocol.d.ts

@@ -0,0 +1,17 @@
+import * as z from 'zod/mini';
+import { BaseResponseSchema } from './base';
+export declare const deleteHistoryMapSchema: any;
+export declare const saveMapSchema: any;
+export declare const changeCurrentMapSchema: any;
+declare const saveMapResponseSchema: any;
+declare const changeCurrentMapResponseSchema: any;
+export type DeleteHistoryMapData = z.infer<typeof deleteHistoryMapSchema>;
+export type SaveMapData = z.infer<typeof saveMapSchema>;
+export type ChangeCurrentMapData = z.infer<typeof changeCurrentMapSchema>;
+export type DeleteMapResponse = z.infer<typeof BaseResponseSchema>;
+export type SaveMapResponse = z.infer<typeof saveMapResponseSchema>;
+export type UseMapResponse = z.infer<typeof changeCurrentMapResponseSchema>;
+export type TDeleteHistoryMap = (mapId: number) => Promise<DeleteMapResponse>;
+export type TSaveMap = (data?: SaveMapData) => Promise<SaveMapResponse>;
+export type TChangeCurrentMap = (mapId: number, url: string) => Promise<UseMapResponse>;
+export {};

package/lib/mqtt/type/protocols/historyMapProtocol.js

@@ -0,0 +1,37 @@
+import * as z from 'zod/mini';
+import { BaseResponseSchema } from './base';
+
+// 删除历史地图参数 Schema
+export const deleteHistoryMapSchema = z.object({
+  mapId: z.int() // 地图ID
+});
+
+// 保存当前地图参数 Schema
+export const saveMapSchema = z.object({
+  oper: z.int() // 操作类型：0 表示保存
+});
+
+// 更改当前使用的地图参数 Schema
+export const changeCurrentMapSchema = z.object({
+  mapId: z.int(),
+  // 地图ID
+  url: z.string(),
+  // 地图URL
+  urlLen: z.int() // URL 长度
+});
+
+// 保存地图响应 Schema
+const saveMapResponseSchema = z.extend(BaseResponseSchema, {
+  // 保存后的地图ID
+  mapId: z.int()
+});
+
+// 更改当前地图响应 Schema
+const changeCurrentMapResponseSchema = z.extend(BaseResponseSchema, {
+  // 当前使用的地图ID
+  mapId: z.int()
+});
+
+// 类型导出
+
+// 函数类型定义

package/lib/mqtt/type/protocols/index.d.ts

@@ -0,0 +1,20 @@
+export * from './scheduleProtocol';
+export * from './carpetProtocol';
+export * from './zoneCleanProtocol';
+export * from './wifiMapProtocol';
+export * from './voiceProtocol';
+export * from './virtualWallProtocol';
+export * from './virtualAreaProtocol';
+export * from './spotCleanProtocol';
+export * from './selectRoomCleanProtocol';
+export * from './resetMapProtocol';
+export * from './quietHoursProtocol';
+export * from './passwordProtocol';
+export * from './partMergeProtocol';
+export * from './partDivisionProtocol';
+export * from './historyMapProtocol';
+export * from './furnitureModelProtocol';
+export * from './deviceModelProtocol';
+export * from './carpetCleanProtocol';
+export * from './devInfoProtocol';
+export * from './roomPropertyProtocol';