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

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

@@ -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';

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

@@ -0,0 +1,8 @@
+import * as z from 'zod/mini';
+export declare const pointsSchema: any;
+export declare const roomIdSchema: any;
+export declare const originSchema: any;
+declare const partDivisionResponseSchema: any;
+export type PartDivisionResponse = z.infer<typeof partDivisionResponseSchema>;
+export type TSetPartDivision = (points: z.infer<typeof pointsSchema>, roomId: z.infer<typeof roomIdSchema>, origin: z.infer<typeof originSchema>) => Promise<PartDivisionResponse>;
+export {};

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

@@ -0,0 +1,12 @@
+import * as z from 'zod/mini';
+import { BaseResponseSchema, Point } from './base';
+export const pointsSchema = z.array(Point).check(z.minLength(1));
+export const roomIdSchema = z.union([z.int(), z.string()]);
+export const originSchema = Point;
+
+// 房间分隔响应 Schema（BaseResponseSchema 已包含所有必需字段）
+const partDivisionResponseSchema = BaseResponseSchema;
+
+// 类型导出
+
+// 函数类型定义

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

@@ -0,0 +1,7 @@
+import * as z from 'zod/mini';
+export declare const setPartMergeSchema: any;
+declare const partMergeResponseSchema: any;
+export type SetPartMergeData = z.infer<typeof setPartMergeSchema>;
+export type PartMergeResponse = z.infer<typeof partMergeResponseSchema>;
+export type TSetPartMerge = (data: SetPartMergeData) => Promise<PartMergeResponse>;
+export {};

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

@@ -0,0 +1,12 @@
+import * as z from 'zod/mini';
+import { BaseResponseSchema } from './base';
+
+// 设置分区合并参数 Schema
+export const setPartMergeSchema = z.array(z.union([z.int(), z.string()])).check(z.minLength(2));
+
+// 分区合并响应 Schema（BaseResponseSchema 已包含所有必需字段）
+const partMergeResponseSchema = BaseResponseSchema;
+
+// 类型导出
+
+// 函数类型定义

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

@@ -0,0 +1,11 @@
+import * as z from 'zod/mini';
+export declare const setPasswordSchema: any;
+export declare const checkPasswordSchema: any;
+declare const passwordResponseSchema: any;
+export type SetPasswordData = z.infer<typeof setPasswordSchema>;
+export type CheckPasswordData = z.infer<typeof checkPasswordSchema>;
+export type PasswordResponse = z.infer<typeof passwordResponseSchema>;
+export type TRequestPassword = () => Promise<PasswordResponse>;
+export type TSetPassword = (data: SetPasswordData) => Promise<PasswordResponse>;
+export type TCheckPassword = (data: CheckPasswordData) => Promise<PasswordResponse>;
+export {};

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

@@ -0,0 +1,25 @@
+import * as z from 'zod/mini';
+import { BaseResponseSchema } from './base';
+
+// 设置密码参数 Schema
+export const setPasswordSchema = z.object({
+  password: z.string(),
+  // 密码（MD5 加密后的字符串）
+  oldPassword: z.optional(z.string()),
+  // 旧密码（MD5 加密后的字符串，可选）
+  taskId: z.optional(z.string()) // 任务ID（可选）
+});
+
+// 校验密码参数 Schema
+export const checkPasswordSchema = z.object({
+  password: z.string(),
+  // 密码（MD5 加密后的字符串）
+  taskId: z.optional(z.string()) // 任务ID（可选）
+});
+
+// 密码响应 Schema（基础响应）
+const passwordResponseSchema = BaseResponseSchema;
+
+// 类型导出
+
+// 函数类型定义

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

@@ -0,0 +1,8 @@
+import * as z from 'zod/mini';
+export declare const setQuietHoursSchema: any;
+declare const quietHoursResponseSchema: any;
+export type SetQuietHoursData = z.infer<typeof setQuietHoursSchema>;
+export type QuietHoursResponse = z.infer<typeof quietHoursResponseSchema>;
+export type TRequestQuietHours = () => Promise<QuietHoursResponse>;
+export type TSetQuietHours = (data: SetQuietHoursData) => Promise<QuietHoursResponse>;
+export {};

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

@@ -0,0 +1,35 @@
+import * as z from 'zod/mini';
+import { BaseResponseSchema } from './base';
+
+// 时间对象 Schema
+const timeSchema = z.object({
+  hour: z.int().check(z.gte(0), z.lte(23)),
+  minute: z.int().check(z.gte(0), z.lte(59))
+});
+
+// 设置勿扰模式参数 Schema
+export const setQuietHoursSchema = z.object({
+  startTime: timeSchema,
+  // 开始时间
+  endTime: timeSchema,
+  // 结束时间
+  active: z.int().check(z.gte(0), z.lte(1)),
+  // 1:开启 0:关闭
+  day: z.int(),
+  // 是否有跨天，1:有 0:无
+  version: z.optional(z.string()) // 协议版本（可选）
+});
+
+// 勿扰模式响应 Schema
+const quietHoursResponseSchema = z.extend(BaseResponseSchema, {
+  // 是否激活，0 表示未激活，1 表示激活
+  active: z.int(),
+  // 时间段数组，每个元素为 "开始时间, 结束时间" 的字符串
+  time: z.array(z.string()),
+  // 星期几，1 表示星期一，2 表示星期二，以此类推
+  day: z.int()
+});
+
+// 类型导出
+
+// 函数类型定义

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

@@ -0,0 +1,4 @@
+import * as z from 'zod/mini';
+import { BaseResponseSchema } from './base';
+export type ResetMapResponse = z.infer<typeof BaseResponseSchema>;
+export type TSetResetMap = () => Promise<ResetMapResponse>;

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

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

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

@@ -0,0 +1,14 @@
+import * as z from 'zod/mini';
+export declare const setRoomPropertySchema: any;
+declare const roomPropertyResponseSchema: any;
+/**
+ * 验证设置房间属性协议数据
+ * @param data 已验证基础 schema 的数据
+ * @throws MqttError 验证失败时抛出
+ */
+export declare function validateSetRoomProperty(data: SetRoomPropertyData): void;
+export type TRequestRoomProperty = () => Promise<RoomPropertyResponse>;
+export type TSetRoomProperty = (data: SetRoomPropertyData) => Promise<RoomPropertyResponse>;
+export type SetRoomPropertyData = z.infer<typeof setRoomPropertySchema>;
+export type RoomPropertyResponse = z.infer<typeof roomPropertyResponseSchema>;
+export {};

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

@@ -0,0 +1,113 @@
+import * as z from 'zod/mini';
+import { MqttError } from '../../promise';
+import { BaseResponseSchema } from './base';
+
+/**
+ * 验证失败错误代码
+ * -2 表示数据验证失败
+ */
+const VALIDATION_ERROR_CODE = -2;
+
+// 设置房间属性参数 Schema
+export const setRoomPropertySchema = z.object({
+  // 房间数量（可选，如果不提供则使用 ids.length）
+  num: z.optional(z.int().check(z.gte(1))),
+  // 房间id集合（必需）
+  ids: z.array(z.int()).check(z.minLength(1)),
+  // 吸力
+  suctions: z.optional(z.array(z.string())),
+  // 拖地水量
+  cisterns: z.optional(z.array(z.string())),
+  // 清扫次数
+  cleanCounts: z.optional(z.array(z.int())),
+  // 拖地模式
+  yMops: z.optional(z.array(z.int())),
+  // 扫拖模式
+  sweepMopModes: z.optional(z.array(z.string())),
+  // 房间地板类型
+  floorTypes: z.optional(z.array(z.int())),
+  // 房间名称
+  names: z.optional(z.array(z.string())),
+  // 房间顺序
+  orders: z.optional(z.array(z.int()))
+});
+
+// 房间属性响应 Schema
+const roomPropertyResponseSchema = z.extend(BaseResponseSchema, {
+  // RoomPreferenceFieldsSchema 的字段
+  suctions: z.optional(z.array(z.string())),
+  cisterns: z.optional(z.array(z.string())),
+  cleanCounts: z.optional(z.array(z.int())),
+  yMops: z.optional(z.array(z.int())),
+  sweepMopModes: z.optional(z.array(z.string())),
+  ids: z.optional(z.array(z.int())),
+  // 房间数量
+  num: z.int(),
+  // 地图id
+  mapId: z.int(),
+  // 房间地板类型
+  floorTypes: z.optional(z.array(z.int())),
+  // 房间名称
+  names: z.optional(z.array(z.string())),
+  // 房间顺序
+  orders: z.optional(z.array(z.int()))
+});
+
+/**
+ * 验证设置房间属性协议数据
+ * @param data 已验证基础 schema 的数据
+ * @throws MqttError 验证失败时抛出
+ */
+export function validateSetRoomProperty(data) {
+  const {
+    ids,
+    num
+  } = data;
+  const len = ids.length;
+
+  // 验证 num 与 ids 长度一致（如果提供了 num）
+  if (num !== undefined && num !== len) {
+    throw new MqttError(`num (${num}) must equal ids length (${len})`, {
+      errCode: VALIDATION_ERROR_CODE,
+      reqType: 'set_room_property'
+    });
+  }
+
+  // 验证数组长度一致性（如果提供了数组字段）
+  const validateLength = (name, array) => {
+    if (array.length !== len) {
+      throw new MqttError(`${name} length must be ${len}, actual is ${array.length}`, {
+        errCode: VALIDATION_ERROR_CODE,
+        reqType: 'set_room_property'
+      });
+    }
+  };
+  if (data.suctions) {
+    validateLength('suctions', data.suctions);
+  }
+  if (data.cisterns) {
+    validateLength('cisterns', data.cisterns);
+  }
+  if (data.cleanCounts) {
+    validateLength('cleanCounts', data.cleanCounts);
+  }
+  if (data.yMops) {
+    validateLength('yMops', data.yMops);
+  }
+  if (data.sweepMopModes) {
+    validateLength('sweepMopModes', data.sweepMopModes);
+  }
+  if (data.floorTypes) {
+    validateLength('floorTypes', data.floorTypes);
+  }
+  if (data.names) {
+    validateLength('names', data.names);
+  }
+  if (data.orders) {
+    validateLength('orders', data.orders);
+  }
+}
+
+// 函数类型定义
+
+// 类型导出

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

@@ -0,0 +1,18 @@
+import * as z from 'zod/mini';
+export declare const ScheduleItemSchema: any;
+export declare const setScheduleSchema: any;
+export declare const requestScheduleSchema: any;
+/**
+ * 验证定时任务协议数据
+ * @param data 已验证基础 schema 的数据
+ * @throws MqttError 验证失败时抛出
+ */
+export declare function validateSetSchedule(data: SetScheduleData): void;
+declare const ScheduleResponseSchema: any;
+export type SetScheduleData = z.infer<typeof setScheduleSchema>;
+export type ScheduleResponse = z.infer<typeof ScheduleResponseSchema>;
+export type TRequestSchedule = (message?: {
+    version?: string;
+}) => Promise<ScheduleResponse>;
+export type TSetSchedule = (message: SetScheduleData) => Promise<ScheduleResponse>;
+export {};

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

@@ -0,0 +1,100 @@
+import "core-js/modules/esnext.iterator.constructor.js";
+import "core-js/modules/esnext.iterator.for-each.js";
+import * as z from 'zod/mini';
+import { MqttError } from '../../promise';
+import { BaseResponseSchema, RoomPreferenceFieldsSchema } from './base';
+
+/**
+ * 验证失败错误代码
+ * -2 表示数据验证失败
+ */
+const VALIDATION_ERROR_CODE = -2;
+
+// 定时任务项 Schema
+export const ScheduleItemSchema = z.extend(RoomPreferenceFieldsSchema, {
+  // 定时是否有效，0：定时关闭 1:定时开启
+  active: z.int().check(z.gte(0), z.lte(1)),
+  // 周循环，周一到周日
+  cycle: z.array(z.int().check(z.gte(0), z.lte(6))).check(z.length(7)),
+  // 执行时间, [小时, 分钟]
+  time: z.array(z.int()).check(z.length(2))
+});
+
+// 定时任务数据 Schema
+export const setScheduleSchema = z.object({
+  list: z.array(ScheduleItemSchema).check(z.minLength(0)),
+  num: z.int().check(z.gte(0)),
+  version: z.optional(z.string()) // 版本号
+});
+
+// 请求定时数据的参数 Schema
+export const requestScheduleSchema = z.object({
+  version: z.optional(z.string())
+});
+
+/**
+ * 验证定时任务协议数据
+ * @param data 已验证基础 schema 的数据
+ * @throws MqttError 验证失败时抛出
+ */
+export function validateSetSchedule(data) {
+  const {
+    num,
+    list
+  } = data;
+
+  // 验证 num 必须等于 list.length
+  if (num !== list.length) {
+    throw new MqttError(`num 必须等于 list.length，实际 num=${num}, list.length=${list.length}`, {
+      errCode: VALIDATION_ERROR_CODE,
+      reqType: 'set_schedule'
+    });
+  }
+
+  // 如果 list 为空，直接返回（允许清空所有定时任务）
+  if (list.length === 0) {
+    return;
+  }
+
+  // 验证每个定时任务项
+  list.forEach((item, index) => {
+    // 验证 time 数组的有效性
+    if (item.time.length !== 2) {
+      throw new MqttError(`list[${index}].time 必须包含 2 个元素 [小时, 分钟]`, {
+        errCode: VALIDATION_ERROR_CODE,
+        reqType: 'set_schedule'
+      });
+    }
+    const [hour, minute] = item.time;
+    if (hour < 0 || hour >= 24) {
+      throw new MqttError(`list[${index}].time[0] 小时必须在 0-23 之间，实际为 ${hour}`, {
+        errCode: VALIDATION_ERROR_CODE,
+        reqType: 'set_schedule'
+      });
+    }
+    if (minute < 0 || minute >= 60) {
+      throw new MqttError(`list[${index}].time[1] 分钟必须在 0-59 之间，实际为 ${minute}`, {
+        errCode: VALIDATION_ERROR_CODE,
+        reqType: 'set_schedule'
+      });
+    }
+
+    // 验证 cycle 数组长度
+    if (item.cycle.length !== 7) {
+      throw new MqttError(`list[${index}].cycle 必须包含 7 个元素 (周一到周日)，实际为 ${item.cycle.length}`, {
+        errCode: VALIDATION_ERROR_CODE,
+        reqType: 'set_schedule'
+      });
+    }
+  });
+}
+
+// 定时任务响应 Schema
+const ScheduleResponseSchema = z.extend(BaseResponseSchema, {
+  list: z.array(ScheduleItemSchema),
+  num: z.int().check(z.gte(0))
+});
+
+// 类型导出
+
+// 函数类型定义

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

@@ -0,0 +1,8 @@
+import * as z from 'zod/mini';
+export declare const setSelectRoomCleanSchema: any;
+declare const selectRoomCleanResponseSchema: any;
+export type SetSelectRoomCleanData = z.infer<typeof setSelectRoomCleanSchema>;
+export type SelectRoomCleanResponse = z.infer<typeof selectRoomCleanResponseSchema>;
+export type TRequestSelectRoomClean = () => Promise<SelectRoomCleanResponse>;
+export type TSetSelectRoomClean = (data: SetSelectRoomCleanData) => Promise<SelectRoomCleanResponse>;
+export {};

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

@@ -0,0 +1,40 @@
+import * as z from 'zod/mini';
+import { BaseResponseSchema } from './base';
+
+// 房间信息 Schema
+const roomInfoSchema = z.object({
+  roomId: z.int(),
+  // 房间id
+  suction: z.optional(z.string()),
+  // 吸力， closed - 关闭 gentle - 安静 normal - 正常 strong - 强劲 max - 超强 ，默认值为''
+  cistern: z.string(),
+  // 拖地水量 "closed"- 关闭,"low"-低,"middle"-中,"high"-高,默认值为''
+  cleanTimes: z.optional(z.int()),
+  // 清扫次数 默认值1
+  yMop: z.optional(z.int()),
+  // 拖地模式 1:开启Y型拖地 0:关闭Y型拖地  -1 未设置 默认值-1
+  sweepMopMode: z.optional(z.string()) // 扫拖模式 "only_sweep":仅扫,"only_mop"：仅拖,"both_work"：扫拖同时,"clean_before_mop"：先扫后拖，默认值为'only_sweep'
+});
+
+// 设置选区清扫参数 Schema
+export const setSelectRoomCleanSchema = z.array(roomInfoSchema).check(z.minLength(1)); // 房间信息数组
+
+// 选区清扫响应 Schema
+const selectRoomCleanResponseSchema = z.extend(BaseResponseSchema, {
+  // 房间id
+  ids: z.array(z.int()),
+  // 吸力， 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()))
+});
+
+// 类型导出
+
+// 函数类型定义

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

@@ -0,0 +1,9 @@
+import * as z from 'zod/mini';
+export declare const setSpotCleanSchema: any;
+declare const spotCleanResponseSchema: any;
+export type SetSpotCleanData = z.infer<typeof setSpotCleanSchema>;
+export type SpotCleanResponse = z.infer<typeof spotCleanResponseSchema>;
+export declare function validateSetSpotClean(data: SetSpotCleanData): void;
+export type TRequestSpotClean = () => Promise<SpotCleanResponse>;
+export type TSetSpotClean = (data: SetSpotCleanData) => Promise<SpotCleanResponse>;
+export {};

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

@@ -0,0 +1,72 @@
+import * as z from 'zod/mini';
+import { MqttError } from '../../promise';
+import { BaseResponseSchema, Point, RoomPreferenceFieldsSchema } from './base';
+
+/**
+ * 验证失败错误代码
+ * -2 表示数据验证失败
+ */
+const VALIDATION_ERROR_CODE = -2;
+
+// 设置定点清扫参数 Schema
+export const setSpotCleanSchema = z.extend(RoomPreferenceFieldsSchema, {
+  spots: z.array(Point).check(z.minLength(1)),
+  // 定点清扫的点数组
+  origin: z.optional(Point) // 原点坐标（可选）
+});
+
+// 定点清扫响应 Schema
+const spotCleanResponseSchema = z.extend(BaseResponseSchema, {
+  // RoomPreferenceFieldsSchema 的字段
+  suctions: z.optional(z.array(z.string())),
+  cisterns: z.optional(z.array(z.string())),
+  cleanCounts: z.optional(z.array(z.int())),
+  yMops: z.optional(z.array(z.int())),
+  sweepMopModes: z.optional(z.array(z.string())),
+  ids: z.optional(z.array(z.int())),
+  // 多边形数组（字符串格式）
+  polygons: z.array(z.string()),
+  // 名称数组（可选）
+  names: z.optional(z.array(z.string()))
+});
+
+// 类型导出
+
+// 自定义验证函数：验证数组长度一致性
+export function validateSetSpotClean(data) {
+  const num = data.spots.length;
+
+  // 如果提供了数组字段，检查长度是否一致
+  if (data.suctions && data.suctions.length !== num) {
+    throw new MqttError(`suctions 数组长度 (${data.suctions.length}) 与 spots 数组长度 (${num}) 不一致`, {
+      errCode: VALIDATION_ERROR_CODE,
+      reqType: 'set_spot_clean'
+    });
+  }
+  if (data.cisterns && data.cisterns.length !== num) {
+    throw new MqttError(`cisterns 数组长度 (${data.cisterns.length}) 与 spots 数组长度 (${num}) 不一致`, {
+      errCode: VALIDATION_ERROR_CODE,
+      reqType: 'set_spot_clean'
+    });
+  }
+  if (data.cleanCounts && data.cleanCounts.length !== num) {
+    throw new MqttError(`cleanCounts 数组长度 (${data.cleanCounts.length}) 与 spots 数组长度 (${num}) 不一致`, {
+      errCode: VALIDATION_ERROR_CODE,
+      reqType: 'set_spot_clean'
+    });
+  }
+  if (data.yMops && data.yMops.length !== num) {
+    throw new MqttError(`yMops 数组长度 (${data.yMops.length}) 与 spots 数组长度 (${num}) 不一致`, {
+      errCode: VALIDATION_ERROR_CODE,
+      reqType: 'set_spot_clean'
+    });
+  }
+  if (data.sweepMopModes && data.sweepMopModes.length !== num) {
+    throw new MqttError(`sweepMopModes 数组长度 (${data.sweepMopModes.length}) 与 spots 数组长度 (${num}) 不一致`, {
+      errCode: VALIDATION_ERROR_CODE,
+      reqType: 'set_spot_clean'
+    });
+  }
+}
+
+// 函数类型定义

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

@@ -0,0 +1,8 @@
+import * as z from 'zod/mini';
+export declare const setVirtualAreaSchema: any;
+declare const virtualAreaResponseSchema: any;
+export type SetVirtualAreaData = z.infer<typeof setVirtualAreaSchema>;
+export type VirtualAreaResponse = z.infer<typeof virtualAreaResponseSchema>;
+export type TRequestVirtualArea = () => Promise<VirtualAreaResponse>;
+export type TSetVirtualArea = (data: SetVirtualAreaData) => Promise<VirtualAreaResponse>;
+export {};

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

@@ -0,0 +1,36 @@
+import * as z from 'zod/mini';
+import { BaseResponseSchema, Point } from './base';
+
+// 虚拟区域项 Schema
+const virtualAreaItemSchema = z.object({
+  points: z.array(Point),
+  // 区域点集
+  name: z.string(),
+  // 区域名称
+  mode: z.int() // 模式
+});
+
+// 设置虚拟区域参数 Schema
+export const setVirtualAreaSchema = z.object({
+  data: z.array(virtualAreaItemSchema),
+  // 虚拟区域的数据数组
+  origin: Point // 原点坐标
+});
+
+// 虚拟区域响应 Schema
+const virtualAreaResponseSchema = z.extend(BaseResponseSchema, {
+  // 虚拟区域的数量
+  num: z.int(),
+  // 模式数组，每个元素为一个区域的模式
+  modes: z.array(z.int()),
+  // 多边形数组，每个元素为一个多边形的坐标字符串
+  polygons: z.array(z.string()),
+  // 名称数组，每个元素为一个区域的名称
+  names: z.array(z.string()),
+  // 地图ID
+  mapId: z.int()
+});
+
+// 类型导出
+
+// 函数类型定义

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

@@ -0,0 +1,8 @@
+import * as z from 'zod/mini';
+export declare const setVirtualWallSchema: any;
+declare const virtualWallResponseSchema: any;
+export type SetVirtualWallData = z.infer<typeof setVirtualWallSchema>;
+export type VirtualWallResponse = z.infer<typeof virtualWallResponseSchema>;
+export type TRequestVirtualWall = () => Promise<VirtualWallResponse>;
+export type TSetVirtualWall = (data: SetVirtualWallData) => Promise<VirtualWallResponse>;
+export {};

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

@@ -0,0 +1,25 @@
+import * as z from 'zod/mini';
+import { BaseResponseSchema, Point } from './base';
+
+// 设置虚拟墙参数 Schema
+export const setVirtualWallSchema = z.object({
+  data: z.array(z.array(Point)),
+  // 虚拟墙的点数组（二维数组）
+  origin: Point // 原点坐标
+});
+
+// 虚拟墙响应 Schema
+const virtualWallResponseSchema = z.extend(BaseResponseSchema, {
+  // 虚拟墙的模式
+  modes: z.array(z.int()),
+  // 虚拟墙的数量
+  num: z.int(),
+  // 地图ID
+  mapId: z.int(),
+  // 虚拟墙的点数组（字符串格式）
+  points: z.array(z.string())
+});
+
+// 类型导出
+
+// 函数类型定义

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

@@ -0,0 +1,8 @@
+import * as z from 'zod/mini';
+export declare const setVoiceSchema: any;
+declare const voiceLanguageResponseSchema: any;
+export type SetVoiceData = z.infer<typeof setVoiceSchema>;
+export type VoiceLanguageResponse = z.infer<typeof voiceLanguageResponseSchema>;
+export type TRequestVoiceInUse = () => Promise<VoiceLanguageResponse>;
+export type TSetVoice = (data: SetVoiceData) => Promise<VoiceLanguageResponse>;
+export {};

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

@@ -0,0 +1,23 @@
+import * as z from 'zod/mini';
+import { BaseResponseSchema } from './base';
+
+// 设置语音语言参数 Schema
+export const setVoiceSchema = z.object({
+  id: z.int(),
+  url: z.string(),
+  md5: z.string()
+});
+
+// 语音语言响应 Schema
+const voiceLanguageResponseSchema = z.extend(BaseResponseSchema, {
+  // 语音语言ID
+  id: z.int(),
+  // 进度百分比
+  schedule: z.int(),
+  // 状态码
+  status: z.int()
+});
+
+// 类型导出
+
+// 函数类型定义

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

@@ -0,0 +1,8 @@
+import * as z from 'zod/mini';
+export declare const setWifiMapSchema: any;
+declare const wifiMapResponseSchema: any;
+export type SetWifiMapData = z.infer<typeof setWifiMapSchema>;
+export type WifiMapResponse = z.infer<typeof wifiMapResponseSchema>;
+export type TRequestWifiMap = () => Promise<WifiMapResponse>;
+export type TSetWifiMap = (data: SetWifiMapData) => Promise<WifiMapResponse>;
+export {};