@jiangtaste/baiwei-sdk 1.0.0

package/dist/services/GatewayService.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GatewayService = void 0;
+const types_1 = require("../types");
+const BaseService_1 = require("./BaseService");
+/** 网关级操作封装，例如允许设备入网。 */
+class GatewayService extends BaseService_1.BaseService {
+    constructor(session) {
+        super(session);
+    }
+    discovery() {
+        // TODO: Implement device discovery
+    }
+    /** 打开入网窗口，允许新 Zigbee 设备在指定时间内加入。 */
+    async permitZigbeeJoin(time = 60) {
+        return this.request({
+            msgClass: types_1.MsgClass.GATEWAY_MGMT,
+            msgName: types_1.MsgName.ZB_NET_OPEN,
+            msgType: types_1.MsgType.SET,
+            payload: { time },
+        });
+    }
+    /** 提前关闭入网窗口。 */
+    async stopZigbeeJoin() {
+        return this.request({
+            msgClass: types_1.MsgClass.GATEWAY_MGMT,
+            msgName: types_1.MsgName.ZB_NET_OPEN,
+            msgType: types_1.MsgType.SET,
+            payload: { time: 0 },
+        });
+    }
+}
+exports.GatewayService = GatewayService;

package/dist/services/RoomService.d.ts

@@ -0,0 +1,11 @@
+import { BaiweiSession } from "../core/BaiweiSession";
+import { Room, RoomList } from "../types";
+import { BaseService } from "./BaseService";
+/** 房间查询封装。 */
+export declare class RoomService extends BaseService {
+    constructor(session: BaiweiSession);
+    list(): Promise<RoomList>;
+    /** 返回拍平后的房间数组，便于业务层直接使用。 */
+    listRooms(): Promise<Room[]>;
+    getRoomById(roomId: number): Promise<Room | undefined>;
+}

package/dist/services/RoomService.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoomService = void 0;
+const types_1 = require("../types");
+const BaseService_1 = require("./BaseService");
+/** 房间查询封装。 */
+class RoomService extends BaseService_1.BaseService {
+    constructor(session) {
+        super(session);
+    }
+    async list() {
+        return this.request({
+            msgClass: types_1.MsgClass.ROOM_MGMT,
+            msgName: types_1.MsgName.ROOM_QUERY,
+        });
+    }
+    /** 返回拍平后的房间数组，便于业务层直接使用。 */
+    async listRooms() {
+        const response = await this.list();
+        return response.room_list ?? [];
+    }
+    async getRoomById(roomId) {
+        const rooms = await this.listRooms();
+        return rooms.find((room) => room.id === roomId);
+    }
+}
+exports.RoomService = RoomService;

package/dist/services/SceneService.d.ts

@@ -0,0 +1,12 @@
+import { BaiweiSession } from "../core/BaiweiSession";
+import { Scene, SceneList } from "../types";
+import { BaseService } from "./BaseService";
+/** 场景查询与触发封装。 */
+export declare class SceneService extends BaseService {
+    constructor(session: BaiweiSession);
+    list(): Promise<SceneList>;
+    /** 触发指定场景。 */
+    call(sceneId: number): Promise<unknown>;
+    listScenes(): Promise<Scene[]>;
+    getSceneById(sceneId: number): Promise<Scene | undefined>;
+}

package/dist/services/SceneService.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SceneService = void 0;
+const types_1 = require("../types");
+const BaseService_1 = require("./BaseService");
+/** 场景查询与触发封装。 */
+class SceneService extends BaseService_1.BaseService {
+    constructor(session) {
+        super(session);
+    }
+    async list() {
+        return this.request({
+            msgClass: types_1.MsgClass.SCENE_MGMT,
+            msgName: types_1.MsgName.SCENE_LIST,
+        });
+    }
+    /** 触发指定场景。 */
+    async call(sceneId) {
+        return this.request({
+            msgClass: types_1.MsgClass.SCENE_MGMT,
+            msgName: types_1.MsgName.SCENE_CALL,
+            msgType: types_1.MsgType.SET,
+            payload: {
+                scene: {
+                    id: sceneId,
+                },
+            },
+        });
+    }
+    async listScenes() {
+        const response = await this.list();
+        return response.scene_list ?? [];
+    }
+    async getSceneById(sceneId) {
+        const scenes = await this.listScenes();
+        return scenes.find((scene) => scene.id === sceneId);
+    }
+}
+exports.SceneService = SceneService;

package/dist/services/UserService.d.ts

@@ -0,0 +1,21 @@
+import { BaiweiSession } from "../core/BaiweiSession";
+import { AdminLoginOptions, UserLoginOptions, UserPasswordLoginOptions, UserResponse } from "../types";
+import { BaseService } from "./BaseService";
+/** 用户登录封装，主要职责是换取并保存 token。 */
+export declare class UserService extends BaseService {
+    constructor(session: BaiweiSession);
+    /**
+     * 统一登录入口。
+     * - 传字符串或空值：按管理员密码登录
+     * - 传 `{ userName, userPwd }`：按普通用户账号密码登录
+     * - 传 `{ userPwd }`：按管理员密码登录
+     */
+    login(options?: string | UserLoginOptions): Promise<UserResponse>;
+    /** 管理员登录：当前协议只要求管理员密码。 */
+    loginAsAdmin(options?: AdminLoginOptions): Promise<UserResponse>;
+    /** 普通用户登录：显式传用户名和密码。 */
+    loginAsUser(options: UserPasswordLoginOptions): Promise<UserResponse>;
+    /** 登录成功后把 token 写回 session，供后续请求复用。 */
+    private storeToken;
+    private isUserPasswordLogin;
+}

package/dist/services/UserService.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserService = void 0;
+const types_1 = require("../types");
+const BaseService_1 = require("./BaseService");
+/** 用户登录封装，主要职责是换取并保存 token。 */
+class UserService extends BaseService_1.BaseService {
+    constructor(session) {
+        super(session);
+    }
+    /**
+     * 统一登录入口。
+     * - 传字符串或空值：按管理员密码登录
+     * - 传 `{ userName, userPwd }`：按普通用户账号密码登录
+     * - 传 `{ userPwd }`：按管理员密码登录
+     */
+    async login(options) {
+        if (typeof options === "string" || options === undefined) {
+            return this.loginAsAdmin({ userPwd: options });
+        }
+        if (this.isUserPasswordLogin(options)) {
+            return this.loginAsUser(options);
+        }
+        return this.loginAsAdmin(options);
+    }
+    /** 管理员登录：当前协议只要求管理员密码。 */
+    async loginAsAdmin(options = {}) {
+        const res = await this.request({
+            msgClass: types_1.MsgClass.USER_MGMT,
+            msgName: types_1.MsgName.USER_LOGIN,
+            payload: {
+                user: {
+                    appId: types_1.DEFAULT_APP_ID,
+                    user_pwd: options.userPwd ?? "888888",
+                },
+            },
+        });
+        this.storeToken(res);
+        return res;
+    }
+    /** 普通用户登录：显式传用户名和密码。 */
+    async loginAsUser(options) {
+        const res = await this.request({
+            msgClass: types_1.MsgClass.USER_MGMT,
+            msgName: types_1.MsgName.USER_LOGIN,
+            payload: {
+                user: {
+                    appId: types_1.DEFAULT_APP_ID,
+                    user_name: options.userName,
+                    user_pwd: options.userPwd,
+                },
+            },
+        });
+        this.storeToken(res);
+        return res;
+    }
+    /** 登录成功后把 token 写回 session，供后续请求复用。 */
+    storeToken(res) {
+        if (res?.user?.token) {
+            this.session.updateToken(res.user.token);
+        }
+        else {
+            throw new Error("Login failed: no token received");
+        }
+    }
+    isUserPasswordLogin(options) {
+        return "userName" in options;
+    }
+}
+exports.UserService = UserService;

package/dist/transport/TcpClient.d.ts

@@ -0,0 +1,38 @@
+import EventEmitter from "events";
+import { BaiweiTcpOptions } from "../types";
+/**
+ * TCP 传输层。
+ * 负责 socket 生命周期、帧编解码、断线重连和协议级容错。
+ */
+export declare class TcpClient extends EventEmitter {
+    private options;
+    private socket;
+    private reconnectTimer?;
+    private destroyed;
+    private connected;
+    private connecting;
+    private manualClose;
+    private cache;
+    private log;
+    constructor(options: BaiweiTcpOptions);
+    /** 建立底层 socket 连接；如果已连接或正在连接则直接复用当前状态。 */
+    connect(): void;
+    isConnected(): boolean;
+    /** 把 JSON 对象编码后写入 TCP 连接。 */
+    send(data: Record<string, any>): Promise<void>;
+    /** 处理背压：write 返回 false 时等待 drain。 */
+    private writeAsync;
+    /** 按百微协议格式封包：MAGIC + 长度 + JSON body。 */
+    private encode;
+    /** 从字节流中持续切出完整协议帧，并恢复成 JSON 消息。 */
+    private decode;
+    /** 主动断开连接时关闭自动重连语义。 */
+    disconnect(): void;
+    /** 协议解析失败时清空缓存并销毁连接，回到干净状态。 */
+    private handleProtocolError;
+    /** 彻底销毁客户端实例，通常只在进程退出或彻底弃用时调用。 */
+    destroy(): void;
+    /** 异常关闭后按配置延迟重连。 */
+    scheduleReconnect(): void;
+    private clearReconnectTimer;
+}

package/dist/transport/TcpClient.js

@@ -0,0 +1,315 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TcpClient = void 0;
+const events_1 = __importDefault(require("events"));
+const node_net_1 = require("node:net");
+const logger_1 = require("../utils/logger");
+const MAGIC = "@#$%";
+const HEADER_SIZE = MAGIC.length + 4;
+/**
+ * TCP 传输层。
+ * 负责 socket 生命周期、帧编解码、断线重连和协议级容错。
+ */
+class TcpClient extends events_1.default {
+    options;
+    socket = null;
+    reconnectTimer;
+    destroyed = false;
+    connected = false;
+    connecting = false;
+    manualClose = false;
+    cache = Buffer.alloc(0);
+    log;
+    constructor(options) {
+        super();
+        this.log = (0, logger_1.createLogger)(options.logger);
+        this.options = {
+            autoReconnect: true,
+            reconnectInterval: 5_000,
+            maxPacketSize: 0xffff, // 64KB (protocol uses 2-byte length)
+            maxCacheSize: 0xffff * 4, // 256KB (4x max packet)
+            keepAlive: true,
+            keepAliveInitialDelay: 15_000,
+            noDelay: true,
+            ...options
+        };
+        // Protocol length field is 2 bytes (encoded as 4 ASCII hex chars). Hard cap at 0xFFFF.
+        if (!this.options.maxPacketSize || this.options.maxPacketSize <= 0) {
+            this.options.maxPacketSize = 0xffff;
+        }
+        if (this.options.maxPacketSize > 0xffff) {
+            this.options.maxPacketSize = 0xffff;
+        }
+        if (!this.options.maxCacheSize || this.options.maxCacheSize <= 0) {
+            this.options.maxCacheSize = this.options.maxPacketSize * 4;
+        }
+        // Ensure cache cap is always >= max packet size.
+        if (this.options.maxCacheSize < this.options.maxPacketSize) {
+            this.options.maxCacheSize = this.options.maxPacketSize;
+        }
+    }
+    /** 建立底层 socket 连接；如果已连接或正在连接则直接复用当前状态。 */
+    connect() {
+        if (this.destroyed)
+            return;
+        if (this.connected || this.connecting)
+            return;
+        if (this.socket)
+            return;
+        this.connecting = true;
+        const socket = new node_net_1.Socket();
+        this.socket = socket;
+        if (this.options.noDelay)
+            socket.setNoDelay(true);
+        if (this.options.keepAlive) {
+            socket.setKeepAlive(true, this.options.keepAliveInitialDelay);
+        }
+        socket.on("connect", () => {
+            this.connecting = false;
+            this.connected = true;
+            this.clearReconnectTimer();
+            this.log.info("Tcp Client: connected");
+            this.emit("connected");
+        });
+        socket.on("error", (err) => {
+            this.connecting = false;
+            this.log.info("Tcp Client: error", err);
+            this.emit("error", err);
+            if (!this.destroyed && !this.manualClose && this.options.autoReconnect) {
+                this.scheduleReconnect();
+            }
+        });
+        socket.on("close", (hadError) => {
+            this.connecting = false;
+            this.connected = false;
+            this.socket = null;
+            this.log.info("TCP closed: ", hadError);
+            this.emit("disconnected", hadError);
+            const shouldReconnect = !this.destroyed && !this.manualClose && this.options.autoReconnect;
+            this.manualClose = false;
+            if (shouldReconnect) {
+                this.scheduleReconnect();
+            }
+        });
+        socket.on("data", (chunk) => {
+            const messages = this.decode(chunk);
+            for (const message of messages) {
+                this.emit("message", message);
+            }
+        });
+        socket.connect({
+            host: this.options.host,
+            port: this.options.port,
+        });
+    }
+    isConnected() {
+        return this.connected;
+    }
+    /** 把 JSON 对象编码后写入 TCP 连接。 */
+    async send(data) {
+        if (this.options.debug) {
+            this.log.info("\n>>>>>>>>>>>>>>>>>>>>");
+            this.log.info(JSON.stringify(data), "\n");
+        }
+        if (!this.socket || !this.connected) {
+            throw new Error("TcpClient not connected");
+        }
+        const buffer = this.encode(data);
+        await this.writeAsync(buffer);
+    }
+    /** 处理背压：write 返回 false 时等待 drain。 */
+    writeAsync(buffer) {
+        return new Promise((resolve, reject) => {
+            const socket = this.socket;
+            if (!socket || !this.connected) {
+                reject(new Error("TcpClient not connected"));
+                return;
+            }
+            const onError = (err) => {
+                cleanup();
+                reject(err);
+            };
+            const onDrain = () => {
+                cleanup();
+                resolve();
+            };
+            const cleanup = () => {
+                socket.off("error", onError);
+                socket.off("drain", onDrain);
+            };
+            socket.on("error", onError);
+            const ok = socket.write(buffer);
+            if (ok) {
+                cleanup();
+                resolve();
+                return;
+            }
+            socket.on("drain", onDrain);
+        });
+    }
+    /** 按百微协议格式封包：MAGIC + 长度 + JSON body。 */
+    encode(data) {
+        const body = Buffer.from(JSON.stringify(data), "utf-8");
+        const totalLength = body.length + HEADER_SIZE;
+        // Protocol length field is uint16 (4 ASCII hex chars). Prevent overflow/wrap.
+        if (totalLength > 0xffff) {
+            throw new Error(`Packet too large for protocol: totalLength=${totalLength} (max 65535)`);
+        }
+        if (totalLength > (this.options.maxPacketSize ?? 0xffff)) {
+            throw new Error(`Packet exceeds maxPacketSize: totalLength=${totalLength}, maxPacketSize=${this.options.maxPacketSize}`);
+        }
+        const lenBuf = Buffer.allocUnsafe(2);
+        lenBuf.writeUint16BE(totalLength, 0);
+        const lenHex = lenBuf.toString("hex").toUpperCase(); // 4个 hex 字符
+        const lenAscii = Buffer.from(lenHex, "ascii"); // 4个 ASCII
+        const header = Buffer.concat([Buffer.from(MAGIC), lenAscii]);
+        const buffer = Buffer.concat([header, body]);
+        return buffer;
+    }
+    /** 从字节流中持续切出完整协议帧，并恢复成 JSON 消息。 */
+    decode(chunk) {
+        const messages = [];
+        // For debug, avoid dumping huge buffers
+        if (this.options.debug) {
+            this.log.info("\n<<<<<<<<<<<<<<<<<<<<");
+            const preview = chunk.subarray(0, Math.min(chunk.length, 512));
+            this.log.info(`chunkBytes=${chunk.length} previewHex=${preview.toString("hex")}`);
+        }
+        // Append to cache
+        if (chunk && chunk.length > 0) {
+            this.cache = Buffer.concat([this.cache, chunk]);
+        }
+        const expectedMagic = Buffer.from(MAGIC, "ascii");
+        // Hard cache cap
+        if (this.cache.length > (this.options.maxCacheSize ?? 0)) {
+            this.handleProtocolError(`Cache overflow: cacheLength=${this.cache.length}, maxCacheSize=${this.options.maxCacheSize}`);
+            return messages;
+        }
+        while (true) {
+            const buffer = this.cache;
+            // Need at least header
+            if (buffer.length < HEADER_SIZE) {
+                return messages;
+            }
+            // Resync MAGIC if needed
+            const magicBuf = buffer.subarray(0, MAGIC.length);
+            if (!magicBuf.equals(expectedMagic)) {
+                const idx = buffer.indexOf(expectedMagic, 1);
+                if (idx === -1) {
+                    // Keep a small tail in case MAGIC spans chunks
+                    const keep = Math.max(0, MAGIC.length - 1);
+                    this.cache = buffer.subarray(Math.max(0, buffer.length - keep));
+                    return messages;
+                }
+                this.cache = buffer.subarray(idx);
+                continue;
+            }
+            // Parse length (ASCII hex, fixed 4 chars)
+            const lenAsciiBuf = buffer.subarray(MAGIC.length, MAGIC.length + 4);
+            const lenHex = lenAsciiBuf.toString("ascii");
+            if (!/^[0-9a-fA-F]{4}$/.test(lenHex)) {
+                this.handleProtocolError(`Invalid length field (not 4 hex chars): "${lenHex}"`);
+                return messages;
+            }
+            const totalLength = parseInt(lenHex, 16);
+            if (!Number.isFinite(totalLength) || totalLength <= 0) {
+                this.handleProtocolError(`Invalid total length parsed from header: ${totalLength}`);
+                return messages;
+            }
+            if (totalLength < HEADER_SIZE) {
+                this.handleProtocolError(`Invalid total length: ${totalLength}, smaller than HEADER_SIZE: ${HEADER_SIZE}`);
+                return messages;
+            }
+            if (totalLength > (this.options.maxPacketSize ?? 0)) {
+                this.handleProtocolError(`Packet too large: totalLength=${totalLength}, maxPacketSize=${this.options.maxPacketSize}`);
+                return messages;
+            }
+            // Wait for more bytes
+            if (buffer.length < totalLength) {
+                return messages;
+            }
+            const bodyBuf = buffer.subarray(HEADER_SIZE, totalLength);
+            if (bodyBuf.length === 0) {
+                // Consume frame, continue
+                this.cache = buffer.subarray(totalLength);
+                continue;
+            }
+            const bodyStr = bodyBuf.toString("utf-8");
+            try {
+                const json = JSON.parse(bodyStr);
+                messages.push(json);
+                // Consume frame and continue parsing next frame (if any)
+                this.cache = buffer.subarray(totalLength);
+            }
+            catch (err) {
+                this.handleProtocolError(`Invalid JSON body in packet: ${err.message}`);
+                return messages;
+            }
+        }
+    }
+    /** 主动断开连接时关闭自动重连语义。 */
+    disconnect() {
+        this.manualClose = true;
+        this.connecting = false;
+        this.clearReconnectTimer();
+        if (!this.socket) {
+            this.connected = false;
+            return;
+        }
+        this.socket.destroy();
+    }
+    /** 协议解析失败时清空缓存并销毁连接，回到干净状态。 */
+    handleProtocolError(reason) {
+        if (this.options.debug) {
+            console.error(`[TcpClient] Protocol error: ${reason}`);
+        }
+        this.cache = Buffer.alloc(0);
+        // Bubble up a specialized event for callers that care
+        this.emit("protocol_error", new Error(reason));
+        // Tear down the socket to get back to a clean state
+        if (this.socket) {
+            try {
+                this.socket.destroy();
+            }
+            catch {
+                // ignore
+            }
+        }
+    }
+    /** 彻底销毁客户端实例，通常只在进程退出或彻底弃用时调用。 */
+    destroy() {
+        this.destroyed = true;
+        this.manualClose = true;
+        this.connecting = false;
+        this.connected = false;
+        this.clearReconnectTimer();
+        if (this.socket) {
+            this.socket.destroy();
+            this.socket.removeAllListeners();
+            this.socket = null;
+        }
+        this.removeAllListeners();
+    }
+    /** 异常关闭后按配置延迟重连。 */
+    scheduleReconnect() {
+        if (this.destroyed)
+            return;
+        this.log.info("TCP reconnecting...");
+        if (this.reconnectTimer)
+            return;
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = undefined;
+            this.connect();
+        }, this.options.reconnectInterval);
+    }
+    clearReconnectTimer() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = undefined;
+        }
+    }
+}
+exports.TcpClient = TcpClient;

package/dist/types/device-catalog.d.ts

@@ -0,0 +1,42 @@
+/** 设备目录与设备基础信息定义。 */
+export declare enum BaiweiProductType {
+    ON_OFF_LIGHT = "On/Off Light",
+    ON_OFF_SWITCH = "On/Off Switch",
+    WINDOW_COVER = "Window Covering Device",
+    IAS_ZONE = "IAS Zone",
+    AIR_BOX = "Air Box",
+    SCENE_SELECTOR = "Scene Selector",
+    AC_GATEWAY = "AC gateway",
+    NEW_WIND = "New wind controller",
+    FLOOR_HEAT = "Floor heat controller"
+}
+export interface DeviceQuery {
+    type_list: DeviceTypeList[];
+}
+export interface DeviceTypeList {
+    product_type: BaiweiProductType;
+    device_list: BaiweiDevice[];
+}
+export interface BaiweiDevice {
+    device_id: string;
+    product_id: number;
+    device_attr: string;
+    device_name: string;
+    room_id: number;
+    network_type: number;
+    create_time: string;
+    acoutside_id: number;
+    acgateway_id: number;
+    product_type: string;
+    product_name: string;
+    node_id: number;
+    endpoint: number;
+    address: number;
+    sn: string;
+    mac: string;
+    com: string;
+    node_type: string;
+    soft_ver: string;
+    hard_ver: string;
+    model: string;
+}

package/dist/types/device-catalog.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaiweiProductType = void 0;
+/** 设备目录与设备基础信息定义。 */
+var BaiweiProductType;
+(function (BaiweiProductType) {
+    BaiweiProductType["ON_OFF_LIGHT"] = "On/Off Light";
+    BaiweiProductType["ON_OFF_SWITCH"] = "On/Off Switch";
+    BaiweiProductType["WINDOW_COVER"] = "Window Covering Device";
+    BaiweiProductType["IAS_ZONE"] = "IAS Zone";
+    BaiweiProductType["AIR_BOX"] = "Air Box";
+    BaiweiProductType["SCENE_SELECTOR"] = "Scene Selector";
+    BaiweiProductType["AC_GATEWAY"] = "AC gateway";
+    BaiweiProductType["NEW_WIND"] = "New wind controller";
+    BaiweiProductType["FLOOR_HEAT"] = "Floor heat controller";
+})(BaiweiProductType || (exports.BaiweiProductType = BaiweiProductType = {}));

package/dist/types/device-state.d.ts

@@ -0,0 +1,56 @@
+/** 设备状态与各类具体状态载荷定义。 */
+export interface DeviceStateList<T> {
+    device_list: BaiweiDeviceState<T>[];
+}
+export interface BaiweiDeviceState<T = any> {
+    device_id: string;
+    device_status: T;
+}
+export interface BaiweiDeviceStateReport<T = any> {
+    device: BaiweiDeviceState<T>;
+}
+export interface ACStatus {
+    state: string;
+    acoutside_id: number;
+    acgateway_id: number;
+    sys_mode: string;
+    coolpoint: number;
+    heatpoint: number;
+    wind_level: string;
+    curr_temp: number;
+    err_code: number;
+}
+export interface FloorHeatStatus {
+    state: string;
+    sys_mode: string;
+    work_mode: string;
+    lock_mode: string;
+    temp: number;
+    coolpoint: number;
+    heatpoint: number;
+}
+export interface IASZoneStatus {
+    state: string;
+    status: string;
+}
+export interface NewWindStatus {
+    state: string;
+    sys_mode: string;
+    work_mode: string;
+    lock_mode: string;
+    temp: number;
+    coolpoint: number;
+    heatpoint: number;
+}
+export interface LightState {
+    state: string;
+}
+export interface SceneStatus {
+    sceneId: number;
+    status: number;
+    state: string;
+}
+export interface WindowCoverStatus {
+    state: string;
+    level: number;
+}