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

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

@@ -0,0 +1,14 @@
+import * as z from 'zod/mini';
+import { BaseResponseSchema } from './base';
+
+// 设置 WiFi 地图参数 Schema
+export const setWifiMapSchema = z.object({
+  taskId: z.optional(z.string())
+});
+
+// WiFi 地图响应 Schema（BaseResponseSchema 已包含所有必需字段）
+const wifiMapResponseSchema = BaseResponseSchema;
+
+// 类型导出
+
+// 函数类型定义

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

@@ -0,0 +1,8 @@
+import * as z from 'zod/mini';
+export declare const setZoneCleanSchema: any;
+declare const setZoneCleanResponseSchema: any;
+export type SetZoneCleanData = z.infer<typeof setZoneCleanSchema>;
+export type ZoneCleanResponse = z.infer<typeof setZoneCleanResponseSchema>;
+export type TSetZoneClean = (data: SetZoneCleanData) => Promise<ZoneCleanResponse>;
+export type TRequestZoneClean = () => Promise<ZoneCleanResponse>;
+export {};

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

@@ -0,0 +1,49 @@
+import * as z from 'zod/mini';
+import { BaseResponseSchema, Point } from './base';
+const zoneSchema = z.object({
+  // 区域点集
+  points: z.array(Point),
+  // 区域名称
+  name: z.optional(z.string()),
+  // 区域高级设置
+  advanced: z.optional(z.object({
+    id: z.int(),
+    localSave: z.int(),
+    cleanMode: z.int(),
+    order: z.int(),
+    cleanTimes: z.int(),
+    suction: z.int(),
+    cistern: z.int()
+  }))
+});
+export const setZoneCleanSchema = z.object({
+  zones: z.array(zoneSchema),
+  origin: Point,
+  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()))
+});
+
+// 划区清扫响应 Schema
+const setZoneCleanResponseSchema = z.extend(BaseResponseSchema, {
+  // 区域坐标
+  polygons: z.array(z.string()),
+  // 区域名称
+  names: z.optional(z.array(z.string())),
+  // 吸力， 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/useCarpet.d.ts

@@ -1,73 +1,13 @@
-import { BaseResponse } from './type';
-import { CarpetEnum } from './type/requestType';
-import { Point } from '@ray-js/robot-protocol';
-interface CarpetCommonFields {
-    autoBoost?: number[];
-    fineCleaning?: number[];
-    sideBrushRotating?: number[];
-}
-type CarpetShape = 'rectangle' | 'round';
-type CarpetShapeWithCustom = 'rectangle' | 'round' | 'custom';
-interface AddCarpetInput extends CarpetCommonFields {
-    shape: CarpetShape[];
-    polygons: Array<Point[]>;
-    num: number;
-    type: number[];
-    cleanMode: number[];
-}
-interface AddCarpetResponse extends BaseResponse {
-    reqType: CarpetEnum.add;
-    id: number;
-}
-type TAddCarpet = (carpetInfo: AddCarpetInput) => Promise<AddCarpetResponse>;
-interface UpdateCarpetInfo extends CarpetCommonFields {
-    ids: number[];
-    shape?: CarpetShape[];
-    type?: number[];
-    cleanMode?: number[];
-    polygons?: Array<Point[]>;
-}
-type TUpdateCarpet = (carpetInfo: UpdateCarpetInfo) => Promise<BaseResponse>;
-type TDeleteCarpet = (carpetIds: number[]) => Promise<BaseResponse>;
-interface CarpetQueryResponse extends BaseResponse {
-    reqType: CarpetEnum.query;
-    num: number;
-    polygons: string[];
-    cleanMode: number[];
-    autoBoost?: number[];
-    fineCleaning?: number[];
-    sideBrushRotating?: number[];
-    shape: string[];
-    type: number[];
-    ids: number[];
-}
-type TQueryCarpet = () => Promise<CarpetQueryResponse>;
-export interface SetCarpetInput extends CarpetCommonFields {
-    num: number;
-    polygons: Array<Point[]>;
-    cleanMode: number[];
-    shape: CarpetShapeWithCustom[];
-    ids: number[];
-    type?: number[];
-}
-interface SetCarpetResponse extends BaseResponse {
-    reqType: CarpetEnum.set;
-    num: number;
-    polygons: string[];
-    cleanMode: number[];
-    autoBoost?: number[];
-    fineCleaning?: number[];
-    sideBrushRotating?: number[];
-    shape: string[];
-    ids: number[];
-    type?: number[];
-}
-type TSetCarpet = (carpetInfo: SetCarpetInput) => Promise<SetCarpetResponse>;
-export declare const useCarpet: (devId: string) => {
+import { type TAddCarpet, type TUpdateCarpet, type TDeleteCarpet, type TQueryCarpet, type TSetCarpet } from './type/protocols/carpetProtocol';
+export type { SetCarpetInput, CarpetQueryResponse } from './type/protocols/carpetProtocol';
+/**
+ * 自定义 Hook，用于地毯管理
+ * @returns 包含 addCarpet、updateCarpet、deleteCarpet、queryCarpet、setCarpet 函数的对象
+ */
+export declare const useCarpet: () => {
     addCarpet: TAddCarpet;
     updateCarpet: TUpdateCarpet;
     deleteCarpet: TDeleteCarpet;
     queryCarpet: TQueryCarpet;
     setCarpet: TSetCarpet;
 };
-export {};

package/lib/mqtt/useCarpet.js

@@ -1,51 +1,21 @@
-import "core-js/modules/esnext.iterator.constructor.js";
-import "core-js/modules/esnext.iterator.every.js";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
 import "core-js/modules/esnext.iterator.map.js";
 import { pointsToString } from '../utils';
-import { createSetCommonParams } from './createCommonOptions';
-import { normalResolve } from './promise';
+import { pickBy } from 'lodash-es';
 import { CarpetEnum } from './type/requestType';
+import { useStructuredMessage, handleMqttError } from './hooks/useStructuredMessage';
+import { validator } from './type/fun';
 
-// 公共的地毯属性类型
+// 导出类型供外部使用
 
-// 形状类型定义
-
-// 添加地毯的输入参数（批量添加）
-
-// 添加地毯响应类型
-
-// 更新地毯的输入参数
-
-// 更新地毯发送数据的类型（polygons 已转换为字符串）
-
-// 查询地毯响应类型
-
-// 设置地毯的输入参数
-
-// 设置地毯响应类型
-
-// 验证形状数组的辅助函数
-const validateShape = function (shape, allowedShapes) {
-  let fieldName = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'shape';
-  if (!shape.every(s => allowedShapes.includes(s))) {
-    throw new Error(`${fieldName} must contain only ${allowedShapes.map(s => `"${s}"`).join(', ')}`);
-  }
-};
-
-// 发送 MQTT 消息并返回 Promise 的辅助函数
-const sendMqttMessage = (devId, reqType, message) => {
-  const params = createSetCommonParams({
-    deviceId: devId,
-    reqType,
-    message
-  });
-  ty.device.sendMqttMessage(params);
+/**
+ * 自定义 Hook，用于地毯管理
+ * @returns 包含 addCarpet、updateCarpet、deleteCarpet、queryCarpet、setCarpet 函数的对象
+ */
+export const useCarpet = () => {
   const {
-    taskId
-  } = params.message;
-  return normalResolve(reqType, taskId);
-};
-export const useCarpet = devId => {
+    sendStructuredMessage
+  } = useStructuredMessage();
   /**
    * 添加地毯（批量添加）
    * @param carpetInfo 地毯信息，包含形状数组、轮廓点集合、数量、材质数组和清洁属性数组
@@ -54,172 +24,122 @@ export const useCarpet = devId => {
 
   /**
    * 更新地毯
-   * @param carpetInfo 地毯信息（id 必填，shape、type、cleanMode 可选）
+   * @param carpetInfo 地毯信息（ids 必填，shape、type、cleanMode 可选）
    * @returns Promise<BaseResponse> 响应结果
    */
 
   /**
    * 删除地毯
-   * @param carpetId 地毯ID
+   * @param data 包含地毯ID数组的对象
    * @returns Promise<BaseResponse> 响应结果
    */
 
   /**
    * 查询地毯
+   * @param data 可选参数（目前为空对象）
    * @returns Promise<CarpetQueryResponse> 响应结果，包含地毯数量、轮廓点集合、清洁属性和形状等信息
    */
 
   /**
    * 设置地毯（一次性设置所有地毯）
    * @param carpetInfo 地毯信息，包含数量、轮廓点集合、清洁属性、形状和ID等
-   * @returns Promise<SetCarpetResponse> 响应结果，包含设置后的地毯信息
+   * @returns Promise<CarpetQueryResponse> 响应结果，包含设置后的地毯信息
    */
 
   return {
     addCarpet: carpetInfo => {
-      // 参数验证
-      if (!carpetInfo) {
-        throw new Error('carpetInfo is required');
-      }
-      if (!Array.isArray(carpetInfo.shape) || carpetInfo.shape.length === 0) {
-        throw new Error('carpetInfo.shape is required and must be a non-empty array');
-      }
-      validateShape(carpetInfo.shape, ['rectangle', 'round'], 'carpetInfo.shape');
-      if (!Array.isArray(carpetInfo.polygons) || carpetInfo.polygons.length === 0) {
-        throw new Error('carpetInfo.polygons is required and must be a non-empty array');
-      }
-      if (typeof carpetInfo.num !== 'number' || carpetInfo.num <= 0) {
-        throw new Error('carpetInfo.num is required and must be a positive number');
-      }
-      if (!Array.isArray(carpetInfo.type) || carpetInfo.type.length === 0) {
-        throw new Error('carpetInfo.type is required and must be a non-empty array');
-      }
-      if (!Array.isArray(carpetInfo.cleanMode) || carpetInfo.cleanMode.length === 0) {
-        throw new Error('carpetInfo.cleanMode is required and must be a non-empty array');
-      }
-      try {
-        const sendData = {
-          shape: carpetInfo.shape,
-          polygons: carpetInfo.polygons.map(i => pointsToString(i)),
-          num: carpetInfo.num,
-          type: carpetInfo.type,
-          cleanMode: carpetInfo.cleanMode,
-          autoBoost: carpetInfo.autoBoost,
-          fineCleaning: carpetInfo.fineCleaning,
-          sideBrushRotating: carpetInfo.sideBrushRotating
-        };
-        return sendMqttMessage(devId, CarpetEnum.add, {
-          carpetInfo: sendData
-        });
-      } catch (error) {
-        throw error instanceof Error ? error : new Error('Failed to add carpet');
-      }
+      return new Promise((resolve, reject) => {
+        try {
+          // 使用 TypeBox Schema 进行参数验证
+          const validatedData = validator.validate('add_carpet', carpetInfo);
+          const sendData = {
+            shape: validatedData.shape,
+            polygons: validatedData.polygons.map(i => pointsToString(i)),
+            num: validatedData.num,
+            type: validatedData.type,
+            cleanMode: validatedData.cleanMode,
+            autoBoost: validatedData.autoBoost,
+            fineCleaning: validatedData.fineCleaning,
+            sideBrushRotating: validatedData.sideBrushRotating
+          };
+          sendStructuredMessage(CarpetEnum.add, {
+            carpetInfo: sendData
+          }, resolve, error => reject(handleMqttError(error, 'Failed to add carpet')));
+        } catch (error) {
+          reject(handleMqttError(error, 'Failed to add carpet'));
+        }
+      });
     },
     updateCarpet: carpetInfo => {
-      // 参数验证：只验证 id，其他字段可选
-      if (!carpetInfo || !Array.isArray(carpetInfo.ids) || carpetInfo.ids.length === 0) {
-        throw new Error('carpetInfo.ids is required and must be a non-empty array');
-      }
-
-      // 验证 shape 字段（如果提供）
-      if (carpetInfo.shape !== undefined) {
-        validateShape(carpetInfo.shape, ['rectangle', 'round'], 'carpetInfo.shape');
-      }
-      try {
-        // 构建发送数据，只包含传入的字段
-        const sendData = {
-          ids: carpetInfo.ids
-        };
-
-        // 可选字段：如果存在则添加
-        if (carpetInfo.shape !== undefined) {
-          sendData.shape = carpetInfo.shape;
-        }
-        if (carpetInfo.type !== undefined) {
-          sendData.type = carpetInfo.type;
-        }
-        if (carpetInfo.cleanMode !== undefined) {
-          sendData.cleanMode = carpetInfo.cleanMode;
-        }
-        if (carpetInfo.autoBoost !== undefined) {
-          sendData.autoBoost = carpetInfo.autoBoost;
-        }
-        if (carpetInfo.fineCleaning !== undefined) {
-          sendData.fineCleaning = carpetInfo.fineCleaning;
+      return new Promise((resolve, reject) => {
+        try {
+          // 使用 TypeBox Schema 进行参数验证
+          const validatedData = validator.validate('update_carpet', carpetInfo);
+
+          // 构建发送数据，只包含传入的字段
+          // 先处理需要特殊转换的字段
+          const processedData = _objectSpread(_objectSpread({}, validatedData), validatedData.polygons !== undefined && {
+            polygons: validatedData.polygons.map(i => pointsToString(i))
+          });
+
+          // 使用 lodash pickBy 过滤掉 undefined 值
+          const sendData = pickBy(processedData, value => value !== undefined);
+          sendStructuredMessage(CarpetEnum.update, {
+            carpetInfo: sendData
+          }, resolve, error => reject(handleMqttError(error, 'Failed to update carpet')), CarpetEnum.update);
+        } catch (error) {
+          reject(handleMqttError(error, 'Failed to update carpet'));
         }
-        if (carpetInfo.sideBrushRotating !== undefined) {
-          sendData.sideBrushRotating = carpetInfo.sideBrushRotating;
-        }
-        // 特殊处理 polygons（需要转换）
-        if (carpetInfo.polygons !== undefined) {
-          sendData.polygons = carpetInfo.polygons.map(i => pointsToString(i));
-        }
-        return sendMqttMessage(devId, CarpetEnum.update, {
-          carpetInfo: sendData
-        });
-      } catch (error) {
-        throw error instanceof Error ? error : new Error('Failed to update carpet');
-      }
+      });
     },
-    deleteCarpet: carpetIds => {
-      // 参数验证
-      if (!Array.isArray(carpetIds) || carpetIds.length === 0) {
-        throw new Error('carpetIds is required and must be a non-empty array');
-      }
-      try {
-        return sendMqttMessage(devId, CarpetEnum.delete, {
-          carpetInfo: {
-            ids: carpetIds
-          }
-        });
-      } catch (error) {
-        throw error instanceof Error ? error : new Error('Failed to delete carpet');
-      }
+    deleteCarpet: data => {
+      return new Promise((resolve, reject) => {
+        try {
+          // 使用 TypeBox Schema 进行参数验证
+          const validatedData = validator.validate('delete_carpet', data);
+          sendStructuredMessage(CarpetEnum.delete, {
+            carpetInfo: {
+              ids: validatedData.ids
+            }
+          }, resolve, error => reject(handleMqttError(error, 'Failed to delete carpet')), CarpetEnum.delete);
+        } catch (error) {
+          reject(handleMqttError(error, 'Failed to delete carpet'));
+        }
+      });
     },
-    queryCarpet: () => {
-      try {
-        return sendMqttMessage(devId, CarpetEnum.query, {});
-      } catch (error) {
-        throw error instanceof Error ? error : new Error('Failed to query carpet');
-      }
+    queryCarpet: function () {
+      let data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      return new Promise((resolve, reject) => {
+        try {
+          // 使用 TypeBox Schema 进行参数验证
+          const validatedParams = validator.validate('query_carpet', data);
+          sendStructuredMessage(CarpetEnum.query, validatedParams, resolve, error => reject(handleMqttError(error, 'Failed to query carpet')), CarpetEnum.query);
+        } catch (error) {
+          reject(handleMqttError(error, 'Failed to query carpet'));
+        }
+      });
     },
     setCarpet: carpetInfo => {
-      // 参数验证
-      if (!carpetInfo) {
-        throw new Error('carpetInfo is required');
-      }
-      if (typeof carpetInfo.num !== 'number' || carpetInfo.num <= 0) {
-        throw new Error('carpetInfo.num is required and must be a positive number');
-      }
-      if (!Array.isArray(carpetInfo.polygons) || carpetInfo.polygons.length === 0) {
-        throw new Error('carpetInfo.polygons is required and must be a non-empty array');
-      }
-      if (!Array.isArray(carpetInfo.cleanMode) || carpetInfo.cleanMode.length === 0) {
-        throw new Error('carpetInfo.cleanMode is required and must be a non-empty array');
-      }
-      if (!Array.isArray(carpetInfo.shape) || carpetInfo.shape.length === 0) {
-        throw new Error('carpetInfo.shape is required and must be a non-empty array');
-      }
-      validateShape(carpetInfo.shape, ['rectangle', 'round', 'custom'], 'carpetInfo.shape');
-      if (!Array.isArray(carpetInfo.ids) || carpetInfo.ids.length === 0) {
-        throw new Error('carpetInfo.ids is required and must be a non-empty array');
-      }
-      try {
-        const sendData = {
-          num: carpetInfo.num,
-          polygons: carpetInfo.polygons.map(i => pointsToString(i)),
-          cleanMode: carpetInfo.cleanMode,
-          autoBoost: carpetInfo.autoBoost,
-          fineCleaning: carpetInfo.fineCleaning,
-          sideBrushRotating: carpetInfo.sideBrushRotating,
-          shape: carpetInfo.shape,
-          ids: carpetInfo.ids,
-          type: carpetInfo.type
-        };
-        return sendMqttMessage(devId, CarpetEnum.set, sendData);
-      } catch (error) {
-        throw error instanceof Error ? error : new Error('Failed to set carpet');
-      }
+      return new Promise((resolve, reject) => {
+        try {
+          // 使用 TypeBox Schema 进行参数验证
+          const validatedData = validator.validate('set_carpet', carpetInfo);
+          const sendData = {
+            num: validatedData.num,
+            polygons: validatedData.polygons.map(i => pointsToString(i)),
+            cleanMode: validatedData.cleanMode,
+            autoBoost: validatedData.autoBoost,
+            fineCleaning: validatedData.fineCleaning,
+            sideBrushRotating: validatedData.sideBrushRotating,
+            shape: validatedData.shape,
+            ids: validatedData.ids,
+            type: validatedData.type
+          };
+          sendStructuredMessage(CarpetEnum.set, sendData, resolve, error => reject(handleMqttError(error, 'Failed to set carpet')), CarpetEnum.query);
+        } catch (error) {
+          reject(handleMqttError(error, 'Failed to set carpet'));
+        }
+      });
     }
   };
 };

package/lib/mqtt/useCarpetClean.d.ts

@@ -1,18 +1,9 @@
-import { BaseResponse } from './type';
-import { CarpetCleanEnum } from './type/requestType';
-interface CarpetCleanResponse extends BaseResponse {
-    reqType: CarpetCleanEnum;
-    ids: number[];
-}
-type TSetCarpetClean = (carpetIds: number[]) => Promise<CarpetCleanResponse>;
-type TRequestCarpetClean = () => Promise<CarpetCleanResponse>;
+import { type TRequestCarpetClean, type TSetCarpetClean } from './type/protocols';
 /**
  * 自定义 Hook，用于地毯清扫
- * @param devId 设备ID
  * @returns 包含 requestCarpetClean 和 setCarpetClean 函数的对象
  */
-export declare const useCarpetClean: (devId: string) => {
+export declare const useCarpetClean: () => {
     requestCarpetClean: TRequestCarpetClean;
     setCarpetClean: TSetCarpetClean;
 };
-export {};

package/lib/mqtt/useCarpetClean.js

@@ -1,75 +1,48 @@
-import "core-js/modules/esnext.iterator.constructor.js";
-import "core-js/modules/esnext.iterator.for-each.js";
 // 地毯清扫
-import { createSetCommonParams } from './createCommonOptions';
 import { CarpetCleanEnum } from './type/requestType';
-import { normalResolve } from './promise';
-
-// 地毯清扫响应类型
-
-// 设置地毯清扫函数类型定义
-
-// 请求地毯清扫函数类型定义
-
+import { useStructuredMessage, handleMqttError } from './hooks/useStructuredMessage';
+import { validator } from './type/fun';
 /**
  * 自定义 Hook，用于地毯清扫
- * @param devId 设备ID
  * @returns 包含 requestCarpetClean 和 setCarpetClean 函数的对象
  */
-export const useCarpetClean = devId => {
+export const useCarpetClean = () => {
+  const {
+    sendStructuredMessage
+  } = useStructuredMessage();
+
   /**
    * 请求地毯清扫信息
+   * @param data 可选参数（目前为空对象）
    * @returns Promise<CarpetCleanResponse> 响应结果
    */
 
   /**
    * 设置地毯清扫
-   * @param carpetIds 地毯ID数组
+   * @param data 包含地毯ID数组的对象
    * @returns Promise<CarpetCleanResponse> 响应结果
    */
 
   return {
     requestCarpetClean: () => {
-      try {
-        const params = createSetCommonParams({
-          deviceId: devId,
-          reqType: CarpetCleanEnum.query
-        });
-        ty.device.sendMqttMessage(params);
-        const {
-          taskId
-        } = params.message;
-        return normalResolve(CarpetCleanEnum.query, taskId);
-      } catch (error) {
-        return Promise.reject(error instanceof Error ? error : new Error('Failed to request carpet clean'));
-      }
+      return new Promise((resolve, reject) => {
+        try {
+          sendStructuredMessage(CarpetCleanEnum.query, {}, resolve, error => reject(handleMqttError(error, 'Failed to request carpet clean')), CarpetCleanEnum.query);
+        } catch (error) {
+          reject(handleMqttError(error, 'Failed to request carpet clean'));
+        }
+      });
     },
-    setCarpetClean: carpetIds => {
-      // 参数验证
-      if (!Array.isArray(carpetIds) || carpetIds.length === 0) {
-        throw new Error('carpetIds is required and must be a non-empty array');
-      }
-      carpetIds.forEach((id, index) => {
-        if (typeof id !== 'number') {
-          throw new Error(`carpetIds[${index}] must be a number`);
+    setCarpetClean: data => {
+      return new Promise((resolve, reject) => {
+        try {
+          // 使用 TypeBox Schema 进行参数验证
+          const validatedData = validator.validate('set_carpet_clean', data);
+          sendStructuredMessage(CarpetCleanEnum.set, validatedData, resolve, error => reject(handleMqttError(error, 'Failed to set carpet clean')), CarpetCleanEnum.set);
+        } catch (error) {
+          reject(handleMqttError(error, 'Failed to set carpet clean'));
         }
       });
-      try {
-        const params = createSetCommonParams({
-          deviceId: devId,
-          reqType: CarpetCleanEnum.set,
-          message: {
-            ids: carpetIds
-          }
-        });
-        ty.device.sendMqttMessage(params);
-        const {
-          taskId
-        } = params.message;
-        return normalResolve(CarpetCleanEnum.set, taskId);
-      } catch (error) {
-        throw error instanceof Error ? error : new Error('Failed to set carpet clean');
-      }
     }
   };
 };

package/lib/mqtt/useDevInfo.d.ts

@@ -1,7 +1,9 @@
-import { BaseResponse } from './type';
-export interface DevInfoResponse extends BaseResponse {
-    info: string;
-}
-export declare const useDevInfo: (devId: string) => {
-    requestDevInfo: () => Promise<DevInfoResponse>;
+import { type TRequestDevInfo } from './type/protocols/devInfoProtocol';
+export type { DevInfoResponse } from './type/protocols/devInfoProtocol';
+/**
+ * 自定义 Hook，用于设备信息管理
+ * @returns 包含 requestDevInfo 函数的对象
+ */
+export declare const useDevInfo: () => {
+    requestDevInfo: TRequestDevInfo;
 };