@jakobgoerke/ac-infinity-client 0.1.1 → 0.2.1

package/build/src/AcInfinityClient.d.ts

@@ -1,9 +1,10 @@
-import { Controller, User, DeviceModeSettings, DeviceSettings } from './types';
+import type { Controller, DeviceModeSettings, DeviceSettings, User } from './types';
 export declare enum Url {
     AUTH = "/user/appUserLogin",
-    CONTROLLERS = "/user/devInfoListAll",
-    DEVICE_SETTINGS = "/dev/getDevSetting",
-    DEVICE_MODE_SETTINGS = "/dev/getdevModeSettingList"
+    GET_CONTROLLERS = "/user/devInfoListAll",
+    GET_DEVICE_SETTINGS = "/dev/getDevSetting",
+    GET_DEVICE_MODE_SETTINGS = "/dev/getdevModeSettingList",
+    SET_DEVICE_MODE_SETTINGS = "/dev/addDevMode"
 }
 export interface Response<T> {
     code: number;
@@ -14,9 +15,12 @@ export interface AuthParams {
     password: string;
 }
 interface GetDeviceParams {
-    deviceId: string;
+    controllerId: string;
     port: number;
 }
+interface SetDeviceModeSettingsParams extends GetDeviceParams {
+    settings: Pick<Partial<DeviceModeSettings>, 'levelWhileOn'>;
+}
 declare class AcInfinityClient {
     constructor(args: AuthParams);
     private api;
@@ -24,11 +28,13 @@ declare class AcInfinityClient {
     private email;
     private password;
     authenticate(): Promise<User>;
+    private ensureSuccess;
     getControllers(): Promise<Controller[]>;
-    getDeviceSettings({ deviceId, port }: GetDeviceParams): Promise<DeviceSettings>;
-    getDeviceModeSettings({ deviceId, port }: GetDeviceParams): Promise<DeviceModeSettings>;
+    getDeviceSettings({ controllerId, port }: GetDeviceParams): Promise<DeviceSettings>;
+    getDeviceModeSettings({ controllerId, port }: GetDeviceParams): Promise<DeviceModeSettings>;
+    setDeviceModeSettings({ controllerId, port, settings }: SetDeviceModeSettingsParams): Promise<void>;
     static build(args: AuthParams): Promise<AcInfinityClient>;
 }
 export { AcInfinityClient };
-export type { Controller, User, DeviceModeSettings, DeviceSettings };
+export type { Controller, DeviceModeSettings, DeviceSettings, User };
 //# sourceMappingURL=AcInfinityClient.d.ts.map

package/build/src/AcInfinityClient.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AcInfinityClient.d.ts","sourceRoot":"","sources":["../../src/AcInfinityClient.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,UAAU,EAEV,IAAI,EAGJ,kBAAkB,EAClB,cAAc,EAEf,MAAM,SAAS,CAAC;AAGjB,oBAAY,GAAG;IACb,IAAI,uBAAuB;IAC3B,WAAW,yBAAyB;IACpC,eAAe,uBAAuB;IACtC,oBAAoB,+BAA+B;CACpD;AAED,MAAM,WAAW,QAAQ,CAAC,CAAC;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,CAAC,CAAC;CACT;AAED,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,UAAU,eAAe;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,cAAM,gBAAgB;gBACR,IAAI,EAAE,UAAU;IAiB5B,OAAO,CAAC,GAAG,CAAgB;IAC3B,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,QAAQ,CAAS;IAEZ,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IAiB7B,cAAc,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC;IAQvC,iBAAiB,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,EAAE,eAAe,GAAG,OAAO,CAAC,cAAc,CAAC;IAS/E,qBAAqB,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,EAAE,eAAe,GAAG,OAAO,CAAC,kBAAkB,CAAC;WASvF,KAAK,CAAC,IAAI,EAAE,UAAU;CAKpC;AAED,OAAO,EAAE,gBAAgB,EAAE,CAAC;AAC5B,YAAY,EAAE,UAAU,EAAE,IAAI,EAAE,kBAAkB,EAAE,cAAc,EAAE,CAAC"}
+{"version":3,"file":"AcInfinityClient.d.ts","sourceRoot":"","sources":["../../src/AcInfinityClient.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,kBAAkB,EAA2B,cAAc,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAG7G,oBAAY,GAAG;IACb,IAAI,uBAAuB;IAC3B,eAAe,yBAAyB;IACxC,mBAAmB,uBAAuB;IAC1C,wBAAwB,+BAA+B;IACvD,wBAAwB,oBAAoB;CAC7C;AAED,MAAM,WAAW,QAAQ,CAAC,CAAC;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,CAAC,CAAC;CACT;AAOD,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,UAAU,eAAe;IACvB,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,UAAU,2BAA4B,SAAQ,eAAe;IAC3D,QAAQ,EAAE,IAAI,CAAC,OAAO,CAAC,kBAAkB,CAAC,EAAE,cAAc,CAAC,CAAC;CAC7D;AAED,cAAM,gBAAgB;gBACR,IAAI,EAAE,UAAU;IAiB5B,OAAO,CAAC,GAAG,CAAgB;IAC3B,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,QAAQ,CAAS;IAEZ,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IAiB1C,OAAO,CAAC,aAAa;IAMR,cAAc,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC;IAQvC,iBAAiB,CAAC,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,eAAe,GAAG,OAAO,CAAC,cAAc,CAAC;IASnF,qBAAqB,CAAC,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,eAAe,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAS3F,qBAAqB,CAAC,EAAE,YAAY,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,2BAA2B,GAAG,OAAO,CAAC,IAAI,CAAC;WAanG,KAAK,CAAC,IAAI,EAAE,UAAU;CAKpC;AAED,OAAO,EAAE,gBAAgB,EAAE,CAAC;AAC5B,YAAY,EAAE,UAAU,EAAE,kBAAkB,EAAE,cAAc,EAAE,IAAI,EAAE,CAAC"}

package/build/src/AcInfinityClient.js

@@ -5,14 +5,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AcInfinityClient = exports.Url = void 0;
 const axios_1 = __importDefault(require("axios"));
-const types_1 = require("./types");
 const errors_1 = require("./errors");
+const types_1 = require("./types");
 var Url;
 (function (Url) {
     Url["AUTH"] = "/user/appUserLogin";
-    Url["CONTROLLERS"] = "/user/devInfoListAll";
-    Url["DEVICE_SETTINGS"] = "/dev/getDevSetting";
-    Url["DEVICE_MODE_SETTINGS"] = "/dev/getdevModeSettingList";
+    Url["GET_CONTROLLERS"] = "/user/devInfoListAll";
+    Url["GET_DEVICE_SETTINGS"] = "/dev/getDevSetting";
+    Url["GET_DEVICE_MODE_SETTINGS"] = "/dev/getdevModeSettingList";
+    Url["SET_DEVICE_MODE_SETTINGS"] = "/dev/addDevMode";
 })(Url || (exports.Url = Url = {}));
 class AcInfinityClient {
     constructor(args) {
@@ -41,30 +42,45 @@ class AcInfinityClient {
             throw new errors_1.AuthenticationError();
         }
         const user = types_1.UserSchema.parse(response.data.data);
-        this.token = user.appId;
-        this.api.defaults.headers.common['token'] = user.appId;
+        this.token = user.id;
+        this.api.defaults.headers.common.token = user.id;
         return user;
     }
+    ensureSuccess(response) {
+        if (response.code !== 200) {
+            throw new Error(`API request failed [code="${response.code}", msg="${response.msg}"]`);
+        }
+    }
     async getControllers() {
-        const response = await this.api.post(Url.CONTROLLERS, {
+        const response = await this.api.post(Url.GET_CONTROLLERS, {
             userId: this.token,
         });
         return response.data.data.map((device) => types_1.ControllerSchema.parse(device));
     }
-    async getDeviceSettings({ deviceId, port }) {
-        const response = await this.api.post(Url.DEVICE_SETTINGS, {
-            devId: deviceId,
+    async getDeviceSettings({ controllerId, port }) {
+        const response = await this.api.post(Url.GET_DEVICE_SETTINGS, {
+            devId: controllerId,
             port,
         });
         return types_1.DeviceSettingsSchema.parse(response.data.data);
     }
-    async getDeviceModeSettings({ deviceId, port }) {
-        const response = await this.api.post(Url.DEVICE_MODE_SETTINGS, {
-            devId: deviceId,
+    async getDeviceModeSettings({ controllerId, port }) {
+        const response = await this.api.post(Url.GET_DEVICE_MODE_SETTINGS, {
+            devId: controllerId,
             port,
         });
         return types_1.DeviceModeSettingsSchema.parse(response.data.data);
     }
+    async setDeviceModeSettings({ controllerId, port, settings }) {
+        const rawCurrentSettings = await this.api.post(Url.GET_DEVICE_MODE_SETTINGS, {
+            devId: controllerId,
+            port,
+        });
+        const vendorChanges = (0, types_1.encodeDeviceModeSettings)(settings);
+        const payload = { ...rawCurrentSettings.data.data, ...vendorChanges };
+        const response = await this.api.post(Url.SET_DEVICE_MODE_SETTINGS, payload);
+        this.ensureSuccess(response.data);
+    }
     static async build(args) {
         const instance = new AcInfinityClient(args);
         await instance.authenticate();

package/build/src/types/Controller.d.ts

@@ -1,154 +1,152 @@
 import { z } from 'zod';
 import { DeviceMode, DeviceType } from './Device';
-declare enum ControllerDeviceType {
+export declare enum ControllerDeviceType {
     UIS_CONTROLLER_69_PRO = 11,
     UIS_CONTROLLER_69_PRO_PLUS = 10
 }
-export declare const ControllerPortSchema: z.ZodObject<{
-    loadType: z.ZodNativeEnum<typeof DeviceType>;
-    curMode: z.ZodNativeEnum<typeof DeviceMode>;
-    port: z.ZodNumber;
+export declare const ControllerPortSchema: z.ZodPipe<z.ZodObject<{
     speak: z.ZodNumber;
+    port: z.ZodNumber;
+    curMode: z.ZodEnum<typeof DeviceMode>;
+    loadType: z.ZodEnum<typeof DeviceType>;
     portName: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    loadType: DeviceType;
-    curMode: DeviceMode;
+}, z.core.$strip>, z.ZodTransform<{
     port: number;
-    speak: number;
-    portName: string;
+    currentLevel: number;
+    currentMode: DeviceMode;
+    deviceType: DeviceType;
+    deviceName: string;
 }, {
-    loadType: DeviceType;
-    curMode: DeviceMode;
-    port: number;
     speak: number;
+    port: number;
+    curMode: DeviceMode;
+    loadType: DeviceType;
     portName: string;
-}>;
-export type ControllerPort = z.infer<typeof ControllerPortSchema>;
-export declare const ControllerDeviceInfoSchema: z.ZodObject<{
+}>>;
+export declare const ControllerDeviceInfoSchema: z.ZodPipe<z.ZodObject<{
     temperature: z.ZodNumber;
     humidity: z.ZodNumber;
-    ports: z.ZodArray<z.ZodObject<{
-        loadType: z.ZodNativeEnum<typeof DeviceType>;
-        curMode: z.ZodNativeEnum<typeof DeviceMode>;
-        port: z.ZodNumber;
+    vpdnums: z.ZodNumber;
+    ports: z.ZodArray<z.ZodPipe<z.ZodObject<{
         speak: z.ZodNumber;
+        port: z.ZodNumber;
+        curMode: z.ZodEnum<typeof DeviceMode>;
+        loadType: z.ZodEnum<typeof DeviceType>;
         portName: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        loadType: DeviceType;
-        curMode: DeviceMode;
+    }, z.core.$strip>, z.ZodTransform<{
         port: number;
-        speak: number;
-        portName: string;
+        currentLevel: number;
+        currentMode: DeviceMode;
+        deviceType: DeviceType;
+        deviceName: string;
     }, {
-        loadType: DeviceType;
-        curMode: DeviceMode;
-        port: number;
         speak: number;
+        port: number;
+        curMode: DeviceMode;
+        loadType: DeviceType;
         portName: string;
-    }>, "many">;
-    vpdnums: z.ZodNumber;
-}, "strip", z.ZodTypeAny, {
+    }>>>;
+}, z.core.$strip>, z.ZodTransform<{
     temperature: number;
     humidity: number;
+    vpd: number;
     ports: {
-        loadType: DeviceType;
-        curMode: DeviceMode;
         port: number;
-        speak: number;
-        portName: string;
+        currentLevel: number;
+        currentMode: DeviceMode;
+        deviceType: DeviceType;
+        deviceName: string;
     }[];
-    vpdnums: number;
 }, {
     temperature: number;
     humidity: number;
+    vpdnums: number;
     ports: {
-        loadType: DeviceType;
-        curMode: DeviceMode;
         port: number;
-        speak: number;
-        portName: string;
+        currentLevel: number;
+        currentMode: DeviceMode;
+        deviceType: DeviceType;
+        deviceName: string;
     }[];
-    vpdnums: number;
-}>;
-export type ControllerDeviceInfo = z.infer<typeof ControllerDeviceInfoSchema>;
-export declare const ControllerSchema: z.ZodObject<{
+}>>;
+export declare const ControllerSchema: z.ZodPipe<z.ZodObject<{
     devId: z.ZodString;
     devCode: z.ZodString;
     devName: z.ZodString;
-    devType: z.ZodNativeEnum<typeof ControllerDeviceType>;
+    devType: z.ZodEnum<typeof ControllerDeviceType>;
     devPortCount: z.ZodNumber;
     devVersion: z.ZodNumber;
-    online: z.ZodBoolean;
+    online: z.ZodCoercedBoolean<unknown>;
     firmwareVersion: z.ZodString;
     hardwareVersion: z.ZodString;
-    deviceInfo: z.ZodObject<{
+    deviceInfo: z.ZodPipe<z.ZodObject<{
         temperature: z.ZodNumber;
         humidity: z.ZodNumber;
-        ports: z.ZodArray<z.ZodObject<{
-            loadType: z.ZodNativeEnum<typeof DeviceType>;
-            curMode: z.ZodNativeEnum<typeof DeviceMode>;
-            port: z.ZodNumber;
+        vpdnums: z.ZodNumber;
+        ports: z.ZodArray<z.ZodPipe<z.ZodObject<{
             speak: z.ZodNumber;
+            port: z.ZodNumber;
+            curMode: z.ZodEnum<typeof DeviceMode>;
+            loadType: z.ZodEnum<typeof DeviceType>;
             portName: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            loadType: DeviceType;
-            curMode: DeviceMode;
+        }, z.core.$strip>, z.ZodTransform<{
             port: number;
-            speak: number;
-            portName: string;
+            currentLevel: number;
+            currentMode: DeviceMode;
+            deviceType: DeviceType;
+            deviceName: string;
         }, {
-            loadType: DeviceType;
-            curMode: DeviceMode;
-            port: number;
             speak: number;
+            port: number;
+            curMode: DeviceMode;
+            loadType: DeviceType;
             portName: string;
-        }>, "many">;
-        vpdnums: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
+        }>>>;
+    }, z.core.$strip>, z.ZodTransform<{
         temperature: number;
         humidity: number;
+        vpd: number;
         ports: {
-            loadType: DeviceType;
-            curMode: DeviceMode;
             port: number;
-            speak: number;
-            portName: string;
+            currentLevel: number;
+            currentMode: DeviceMode;
+            deviceType: DeviceType;
+            deviceName: string;
         }[];
-        vpdnums: number;
     }, {
         temperature: number;
         humidity: number;
+        vpdnums: number;
         ports: {
-            loadType: DeviceType;
-            curMode: DeviceMode;
             port: number;
-            speak: number;
-            portName: string;
+            currentLevel: number;
+            currentMode: DeviceMode;
+            deviceType: DeviceType;
+            deviceName: string;
         }[];
-        vpdnums: number;
-    }>;
-}, "strip", z.ZodTypeAny, {
-    devId: string;
-    devCode: string;
-    devName: string;
-    devType: ControllerDeviceType;
-    devPortCount: number;
-    devVersion: number;
+    }>>;
+}, z.core.$strip>, z.ZodTransform<{
     online: boolean;
     firmwareVersion: string;
     hardwareVersion: string;
     deviceInfo: {
         temperature: number;
         humidity: number;
+        vpd: number;
         ports: {
-            loadType: DeviceType;
-            curMode: DeviceMode;
             port: number;
-            speak: number;
-            portName: string;
+            currentLevel: number;
+            currentMode: DeviceMode;
+            deviceType: DeviceType;
+            deviceName: string;
         }[];
-        vpdnums: number;
     };
+    id: string;
+    code: string;
+    name: string;
+    type: ControllerDeviceType;
+    totalPorts: number;
+    version: number;
 }, {
     devId: string;
     devCode: string;
@@ -162,16 +160,17 @@ export declare const ControllerSchema: z.ZodObject<{
     deviceInfo: {
         temperature: number;
         humidity: number;
+        vpd: number;
         ports: {
-            loadType: DeviceType;
-            curMode: DeviceMode;
             port: number;
-            speak: number;
-            portName: string;
+            currentLevel: number;
+            currentMode: DeviceMode;
+            deviceType: DeviceType;
+            deviceName: string;
         }[];
-        vpdnums: number;
     };
-}>;
+}>>;
+export type ControllerPort = z.infer<typeof ControllerPortSchema>;
+export type ControllerDeviceInfo = z.infer<typeof ControllerDeviceInfoSchema>;
 export type Controller = z.infer<typeof ControllerSchema>;
-export {};
 //# sourceMappingURL=Controller.d.ts.map

package/build/src/types/Controller.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Controller.d.ts","sourceRoot":"","sources":["../../../src/types/Controller.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAElD,aAAK,oBAAoB;IACvB,qBAAqB,KAAK;IAC1B,0BAA0B,KAAK;CAChC;AAED,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;EAM/B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKrC,CAAC;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAW3B,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC"}
+{"version":3,"file":"Controller.d.ts","sourceRoot":"","sources":["../../../src/types/Controller.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAElD,oBAAY,oBAAoB;IAC9B,qBAAqB,KAAK;IAC1B,0BAA0B,KAAK;CAChC;AAED,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;GAc5B,CAAC;AAEN,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAYlC,CAAC;AAEN,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqBxB,CAAC;AAEN,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAC9E,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC"}

package/build/src/types/Controller.js

@@ -1,35 +1,60 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ControllerSchema = exports.ControllerDeviceInfoSchema = exports.ControllerPortSchema = void 0;
+exports.ControllerSchema = exports.ControllerDeviceInfoSchema = exports.ControllerPortSchema = exports.ControllerDeviceType = void 0;
 const zod_1 = require("zod");
 const Device_1 = require("./Device");
 var ControllerDeviceType;
 (function (ControllerDeviceType) {
     ControllerDeviceType[ControllerDeviceType["UIS_CONTROLLER_69_PRO"] = 11] = "UIS_CONTROLLER_69_PRO";
     ControllerDeviceType[ControllerDeviceType["UIS_CONTROLLER_69_PRO_PLUS"] = 10] = "UIS_CONTROLLER_69_PRO_PLUS";
-})(ControllerDeviceType || (ControllerDeviceType = {}));
-exports.ControllerPortSchema = zod_1.z.object({
-    loadType: zod_1.z.nativeEnum(Device_1.DeviceType),
-    curMode: zod_1.z.nativeEnum(Device_1.DeviceMode),
-    port: zod_1.z.number().positive(),
+})(ControllerDeviceType || (exports.ControllerDeviceType = ControllerDeviceType = {}));
+exports.ControllerPortSchema = zod_1.z
+    .object({
     speak: zod_1.z.number(),
+    port: zod_1.z.number().positive(),
+    curMode: zod_1.z.enum(Device_1.DeviceMode),
+    loadType: zod_1.z.enum(Device_1.DeviceType),
     portName: zod_1.z.string(),
-});
-exports.ControllerDeviceInfoSchema = zod_1.z.object({
+})
+    .transform((v) => ({
+    port: v.port,
+    currentLevel: v.speak,
+    currentMode: v.curMode,
+    deviceType: v.loadType,
+    deviceName: v.portName,
+}));
+exports.ControllerDeviceInfoSchema = zod_1.z
+    .object({
     temperature: zod_1.z.number(),
     humidity: zod_1.z.number(),
-    ports: zod_1.z.array(exports.ControllerPortSchema),
     vpdnums: zod_1.z.number(),
-});
-exports.ControllerSchema = zod_1.z.object({
+    ports: zod_1.z.array(exports.ControllerPortSchema),
+})
+    .transform((v) => ({
+    temperature: v.temperature / 100,
+    humidity: v.humidity / 100,
+    vpd: v.vpdnums / 100,
+    ports: v.ports,
+}));
+exports.ControllerSchema = zod_1.z
+    .object({
     devId: zod_1.z.string(),
     devCode: zod_1.z.string(),
     devName: zod_1.z.string(),
-    devType: zod_1.z.nativeEnum(ControllerDeviceType),
+    devType: zod_1.z.enum(ControllerDeviceType),
     devPortCount: zod_1.z.number().positive(),
     devVersion: zod_1.z.number(),
     online: zod_1.z.coerce.boolean(),
     firmwareVersion: zod_1.z.string(),
     hardwareVersion: zod_1.z.string(),
     deviceInfo: exports.ControllerDeviceInfoSchema,
-});
+})
+    .transform(({ devId, devCode, devName, devType, devPortCount, devVersion, ...rest }) => ({
+    id: devId,
+    code: devCode,
+    name: devName,
+    type: devType,
+    totalPorts: devPortCount,
+    version: devVersion,
+    ...rest,
+}));

package/build/src/types/Device.d.ts

@@ -1,24 +1,342 @@
 import { z } from 'zod';
 export declare enum DeviceType {
-    'GROW_LIGHT' = 1,
-    'HUMIDIFIER' = 2,
-    'DEHUMIDIFIER' = 3,
-    'HEATER' = 4,
-    'AIR_CONDITION' = 5,
-    'FAN' = 6
+    GROW_LIGHT = 1,
+    HUMIDIFIER = 2,
+    DEHUMIDIFIER = 3,
+    HEATER = 4,
+    AIR_CONDITION = 5,
+    FAN = 6
 }
 export declare enum DeviceMode {
-    'OFF' = 1,
-    'ON' = 2,
-    'AUTO' = 3,
-    'TIMER_TO_ON' = 4,
-    'TIMER_TO_OFF' = 5,
-    'CYCLE' = 6,
-    'SCHEDULE' = 7,
-    'VPD' = 8
+    OFF = 1,
+    ON = 2,
+    AUTO = 3,
+    TIMER_TO_ON = 4,
+    TIMER_TO_OFF = 5,
+    CYCLE = 6,
+    SCHEDULE = 7,
+    VPD = 8
 }
-export declare const DeviceSettingsSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export declare const DeviceSettingsSchema: z.ZodPipe<z.ZodObject<{
+    devId: z.ZodString;
+    devMacAddr: z.ZodNullable<z.ZodString>;
+    externalPort: z.ZodNumber;
+    offSpead: z.ZodNumber;
+    onSpead: z.ZodNumber;
+    onSelfSpead: z.ZodNumber;
+    ecUnit: z.ZodNumber;
+    tdsUnit: z.ZodNumber;
+    settingMode: z.ZodNumber;
+    vpdSettingMode: z.ZodNumber;
+    atType: z.ZodEnum<typeof DeviceMode>;
+    setId: z.ZodNullable<z.ZodString>;
+    port: z.ZodNumber;
+    devName: z.ZodNullable<z.ZodString>;
+    devLight: z.ZodNumber;
+    hasBacklightSwitch: z.ZodNumber;
+    backlightSwitch: z.ZodNumber;
+    hasKeytoneSwitch: z.ZodNumber;
+    keytoneSwitch: z.ZodNumber;
+    devCth: z.ZodNumber;
+    devCt: z.ZodNumber;
+    devCth2: z.ZodNullable<z.ZodNumber>;
+    devCt2: z.ZodNullable<z.ZodNumber>;
+    devCh: z.ZodNumber;
+    devTt: z.ZodNumber;
+    devTh: z.ZodNumber;
+    devCompany: z.ZodNumber;
+    devTth: z.ZodNumber;
+    vpdCth: z.ZodNumber;
+    vpdCt: z.ZodNumber;
+    vpdTransition: z.ZodNumber;
+    portResistance: z.ZodNullable<z.ZodNumber>;
+    devBth: z.ZodNumber;
+    devBt: z.ZodNumber;
+    devBh: z.ZodNumber;
+    devBvpd: z.ZodNumber;
+    isFlag: z.ZodNumber;
+    devTimeZone: z.ZodNullable<z.ZodString>;
+    loadType: z.ZodNumber;
+    tempCompare: z.ZodNumber;
+    humiCompare: z.ZodNumber;
+    onTimeSwitch: z.ZodNumber;
+    onTime: z.ZodNumber;
+    sensorSettingStr: z.ZodNullable<z.ZodString>;
+    sensorSetting: z.ZodNullable<z.ZodUnknown>;
+    sensorTransBuffStr: z.ZodNullable<z.ZodString>;
+    sensorTransBuff: z.ZodNullable<z.ZodUnknown>;
+    portParamData: z.ZodNullable<z.ZodString>;
+    photocellSwitch: z.ZodNumber;
+    isOpenDoseTime: z.ZodNumber;
+    onDoseTime: z.ZodNumber;
+    offDoseTime: z.ZodNumber;
+    isOnMinMaxTime: z.ZodNumber;
+    onMinTime: z.ZodNumber;
+    onMaxTime: z.ZodNumber;
+    ecOrTds: z.ZodNumber;
+    interchangeSensor: z.ZodNumber;
+    subDeviceId: z.ZodNullable<z.ZodString>;
+    subDeviceVersion: z.ZodNullable<z.ZodString>;
+    subDeviceType: z.ZodNullable<z.ZodNumber>;
+    supportOta: z.ZodNullable<z.ZodUnknown>;
+    otaUpdating: z.ZodNullable<z.ZodUnknown>;
+    secFucStatus: z.ZodNumber;
+    secFucDevtype: z.ZodNumber;
+    secFucDevEffect: z.ZodNumber;
+    secFucParamNums: z.ZodNumber;
+    secFucParams: z.ZodNullable<z.ZodUnknown>;
+    secFucReportTime: z.ZodNumber;
+    toward: z.ZodNullable<z.ZodUnknown>;
+    powerState: z.ZodNullable<z.ZodUnknown>;
+    updateAllPort: z.ZodBoolean;
+    timestamp: z.ZodNullable<z.ZodUnknown>;
+    calibrationTime: z.ZodNullable<z.ZodUnknown>;
+    fieldSet: z.ZodArray<z.ZodUnknown>;
+    plantCode: z.ZodNumber;
+    potSize: z.ZodNumber;
+    plantingNum: z.ZodNumber;
+    devCl: z.ZodNullable<z.ZodUnknown>;
+    devCsm1: z.ZodNullable<z.ZodUnknown>;
+    devCsm2: z.ZodNullable<z.ZodUnknown>;
+    devCsm3: z.ZodNullable<z.ZodUnknown>;
+    devCsm4: z.ZodNullable<z.ZodUnknown>;
+    uuidSta: z.ZodNumber;
+    uuidType: z.ZodNullable<z.ZodUnknown>;
+    uuid: z.ZodNullable<z.ZodString>;
+    matterCode: z.ZodNullable<z.ZodString>;
+    matterSta: z.ZodNullable<z.ZodUnknown>;
+}, z.core.$strip>, z.ZodTransform<{
+    id: string;
+    port: number;
+    levelWhileOff: number;
+    levelWhileOn: number;
+    mode: DeviceMode;
+}, {
+    devId: string;
+    devMacAddr: string | null;
+    externalPort: number;
+    offSpead: number;
+    onSpead: number;
+    onSelfSpead: number;
+    ecUnit: number;
+    tdsUnit: number;
+    settingMode: number;
+    vpdSettingMode: number;
+    atType: DeviceMode;
+    setId: string | null;
+    port: number;
+    devName: string | null;
+    devLight: number;
+    hasBacklightSwitch: number;
+    backlightSwitch: number;
+    hasKeytoneSwitch: number;
+    keytoneSwitch: number;
+    devCth: number;
+    devCt: number;
+    devCth2: number | null;
+    devCt2: number | null;
+    devCh: number;
+    devTt: number;
+    devTh: number;
+    devCompany: number;
+    devTth: number;
+    vpdCth: number;
+    vpdCt: number;
+    vpdTransition: number;
+    portResistance: number | null;
+    devBth: number;
+    devBt: number;
+    devBh: number;
+    devBvpd: number;
+    isFlag: number;
+    devTimeZone: string | null;
+    loadType: number;
+    tempCompare: number;
+    humiCompare: number;
+    onTimeSwitch: number;
+    onTime: number;
+    sensorSettingStr: string | null;
+    sensorSetting: unknown;
+    sensorTransBuffStr: string | null;
+    sensorTransBuff: unknown;
+    portParamData: string | null;
+    photocellSwitch: number;
+    isOpenDoseTime: number;
+    onDoseTime: number;
+    offDoseTime: number;
+    isOnMinMaxTime: number;
+    onMinTime: number;
+    onMaxTime: number;
+    ecOrTds: number;
+    interchangeSensor: number;
+    subDeviceId: string | null;
+    subDeviceVersion: string | null;
+    subDeviceType: number | null;
+    supportOta: unknown;
+    otaUpdating: unknown;
+    secFucStatus: number;
+    secFucDevtype: number;
+    secFucDevEffect: number;
+    secFucParamNums: number;
+    secFucParams: unknown;
+    secFucReportTime: number;
+    toward: unknown;
+    powerState: unknown;
+    updateAllPort: boolean;
+    timestamp: unknown;
+    calibrationTime: unknown;
+    fieldSet: unknown[];
+    plantCode: number;
+    potSize: number;
+    plantingNum: number;
+    devCl: unknown;
+    devCsm1: unknown;
+    devCsm2: unknown;
+    devCsm3: unknown;
+    devCsm4: unknown;
+    uuidSta: number;
+    uuidType: unknown;
+    uuid: string | null;
+    matterCode: string | null;
+    matterSta: unknown;
+}>>;
+export declare const DeviceModeSettingsSchema: z.ZodPipe<z.ZodObject<{
+    devId: z.ZodString;
+    devMacAddr: z.ZodNullable<z.ZodString>;
+    externalPort: z.ZodNumber;
+    offSpead: z.ZodNumber;
+    onSpead: z.ZodNumber;
+    onSelfSpead: z.ZodNumber;
+    ecUnit: z.ZodNumber;
+    tdsUnit: z.ZodNumber;
+    settingMode: z.ZodNumber;
+    vpdSettingMode: z.ZodNumber;
+    atType: z.ZodEnum<typeof DeviceMode>;
+    acitveTimerOff: z.ZodNumber;
+    acitveTimerOn: z.ZodNumber;
+    activeCycleOff: z.ZodNumber;
+    activeCycleOn: z.ZodNumber;
+    activeHh: z.ZodNumber;
+    activeHt: z.ZodNumber;
+    activeHtVpd: z.ZodNumber;
+    activeHtVpdNums: z.ZodNumber;
+    activeLh: z.ZodNumber;
+    activeLt: z.ZodNumber;
+    activeLtVpd: z.ZodNumber;
+    activeLtVpdNums: z.ZodNumber;
+    co2FanHighSwitch: z.ZodNumber;
+    co2FanHighValue: z.ZodNumber;
+    co2LowSwitch: z.ZodNumber;
+    co2LowValue: z.ZodNumber;
+    devHh: z.ZodNumber;
+    devHt: z.ZodNumber;
+    devHtf: z.ZodNumber;
+    devLh: z.ZodNumber;
+    devLt: z.ZodNumber;
+    devLtf: z.ZodNumber;
+    ecTdsLowSwitchEc: z.ZodNumber;
+    ecTdsLowSwitchTds: z.ZodNumber;
+    ecTdsLowValueEcUs: z.ZodNumber;
+    ecTdsLowValueTdsPpm: z.ZodNumber;
+    isOpenAutomation: z.ZodNumber;
+    modeType: z.ZodNumber;
+    moistureLowSwitch: z.ZodNumber;
+    moistureLowValue: z.ZodNumber;
+    onlyUpdateSpeed: z.ZodNumber;
+    phHighSwitch: z.ZodNumber;
+    phHighValue: z.ZodNumber;
+    phLowSwitch: z.ZodNumber;
+    phLowValue: z.ZodNumber;
+    schedEndtTime: z.ZodNumber;
+    schedStartTime: z.ZodNumber;
+    surplus: z.ZodNullable<z.ZodNumber>;
+    targetHumi: z.ZodNumber;
+    targetHumiSwitch: z.ZodNumber;
+    targetTSwitch: z.ZodNumber;
+    targetTemp: z.ZodNumber;
+    targetTempF: z.ZodNumber;
+    targetVpd: z.ZodNumber;
+    targetVpdSwitch: z.ZodNumber;
+    waterLevelLowSwitch: z.ZodNumber;
+    waterTempHighSwitch: z.ZodNumber;
+    waterTempHighValue: z.ZodNumber;
+    waterTempHighValueF: z.ZodNumber;
+    waterTempLowSwitch: z.ZodNumber;
+    waterTempLowValue: z.ZodNumber;
+    waterTempLowValueF: z.ZodNumber;
+}, z.core.$strip>, z.ZodTransform<{
+    id: string;
+    port: number;
+    levelWhileOff: number;
+    levelWhileOn: number;
+    mode: DeviceMode;
+}, {
+    devId: string;
+    devMacAddr: string | null;
+    externalPort: number;
+    offSpead: number;
+    onSpead: number;
+    onSelfSpead: number;
+    ecUnit: number;
+    tdsUnit: number;
+    settingMode: number;
+    vpdSettingMode: number;
+    atType: DeviceMode;
+    acitveTimerOff: number;
+    acitveTimerOn: number;
+    activeCycleOff: number;
+    activeCycleOn: number;
+    activeHh: number;
+    activeHt: number;
+    activeHtVpd: number;
+    activeHtVpdNums: number;
+    activeLh: number;
+    activeLt: number;
+    activeLtVpd: number;
+    activeLtVpdNums: number;
+    co2FanHighSwitch: number;
+    co2FanHighValue: number;
+    co2LowSwitch: number;
+    co2LowValue: number;
+    devHh: number;
+    devHt: number;
+    devHtf: number;
+    devLh: number;
+    devLt: number;
+    devLtf: number;
+    ecTdsLowSwitchEc: number;
+    ecTdsLowSwitchTds: number;
+    ecTdsLowValueEcUs: number;
+    ecTdsLowValueTdsPpm: number;
+    isOpenAutomation: number;
+    modeType: number;
+    moistureLowSwitch: number;
+    moistureLowValue: number;
+    onlyUpdateSpeed: number;
+    phHighSwitch: number;
+    phHighValue: number;
+    phLowSwitch: number;
+    phLowValue: number;
+    schedEndtTime: number;
+    schedStartTime: number;
+    surplus: number | null;
+    targetHumi: number;
+    targetHumiSwitch: number;
+    targetTSwitch: number;
+    targetTemp: number;
+    targetTempF: number;
+    targetVpd: number;
+    targetVpdSwitch: number;
+    waterLevelLowSwitch: number;
+    waterTempHighSwitch: number;
+    waterTempHighValue: number;
+    waterTempHighValueF: number;
+    waterTempLowSwitch: number;
+    waterTempLowValue: number;
+    waterTempLowValueF: number;
+}>>;
 export type DeviceSettings = z.infer<typeof DeviceSettingsSchema>;
-export declare const DeviceModeSettingsSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
 export type DeviceModeSettings = z.infer<typeof DeviceModeSettingsSchema>;
+export type DeviceModeSettingsInput = z.input<typeof DeviceModeSettingsSchema>;
+export declare function encodeDeviceModeSettings(settings: Partial<DeviceModeSettings>): Partial<DeviceModeSettingsInput>;
 //# sourceMappingURL=Device.d.ts.map

package/build/src/types/Device.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Device.d.ts","sourceRoot":"","sources":["../../../src/types/Device.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,oBAAY,UAAU;IACpB,YAAY,IAAI;IAChB,YAAY,IAAI;IAChB,cAAc,IAAI;IAClB,QAAQ,IAAI;IACZ,eAAe,IAAI;IACnB,KAAK,IAAI;CACV;AAED,oBAAY,UAAU;IACpB,KAAK,IAAI;IACT,IAAI,IAAI;IACR,MAAM,IAAI;IACV,aAAa,IAAI;IACjB,cAAc,IAAI;IAClB,OAAO,IAAI;IACX,UAAU,IAAI;IACd,KAAK,IAAI;CACV;AAED,eAAO,MAAM,oBAAoB,gDAAe,CAAC;AACjD,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE,eAAO,MAAM,wBAAwB,gDAAe,CAAC;AACrD,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC"}
+{"version":3,"file":"Device.d.ts","sourceRoot":"","sources":["../../../src/types/Device.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,oBAAY,UAAU;IACpB,UAAU,IAAI;IACd,UAAU,IAAI;IACd,YAAY,IAAI;IAChB,MAAM,IAAI;IACV,aAAa,IAAI;IACjB,GAAG,IAAI;CACR;AAED,oBAAY,UAAU;IACpB,GAAG,IAAI;IACP,EAAE,IAAI;IACN,IAAI,IAAI;IACR,WAAW,IAAI;IACf,YAAY,IAAI;IAChB,KAAK,IAAI;IACT,QAAQ,IAAI;IACZ,GAAG,IAAI;CACR;AA0BD,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+E9B,CAAC;AAEJ,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDlC,CAAC;AAEJ,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE/E,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,OAAO,CAAC,kBAAkB,CAAC,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAIhH"}

package/build/src/types/Device.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DeviceModeSettingsSchema = exports.DeviceSettingsSchema = exports.DeviceMode = exports.DeviceType = void 0;
+exports.encodeDeviceModeSettings = encodeDeviceModeSettings;
 const zod_1 = require("zod");
 var DeviceType;
 (function (DeviceType) {
@@ -22,5 +23,164 @@ var DeviceMode;
     DeviceMode[DeviceMode["SCHEDULE"] = 7] = "SCHEDULE";
     DeviceMode[DeviceMode["VPD"] = 8] = "VPD";
 })(DeviceMode || (exports.DeviceMode = DeviceMode = {}));
-exports.DeviceSettingsSchema = zod_1.z.object({});
-exports.DeviceModeSettingsSchema = zod_1.z.object({});
+const DeviceBaseInputSchema = zod_1.z.object({
+    devId: zod_1.z.string(),
+    devMacAddr: zod_1.z.string().nullable(),
+    externalPort: zod_1.z.number(),
+    offSpead: zod_1.z.number().min(0).max(10),
+    onSpead: zod_1.z.number().min(0).max(10),
+    onSelfSpead: zod_1.z.number(),
+    ecUnit: zod_1.z.number(),
+    tdsUnit: zod_1.z.number(),
+    settingMode: zod_1.z.number(),
+    vpdSettingMode: zod_1.z.number(),
+    atType: zod_1.z.enum(DeviceMode),
+});
+const transformDeviceBase = ({ devId, externalPort, offSpead, onSpead, atType }) => ({
+    id: devId,
+    port: externalPort,
+    levelWhileOff: offSpead,
+    levelWhileOn: onSpead,
+    mode: atType,
+});
+exports.DeviceSettingsSchema = DeviceBaseInputSchema.extend({
+    setId: zod_1.z.string().nullable(),
+    port: zod_1.z.number(),
+    devName: zod_1.z.string().nullable(),
+    devLight: zod_1.z.number(),
+    hasBacklightSwitch: zod_1.z.number(),
+    backlightSwitch: zod_1.z.number(),
+    hasKeytoneSwitch: zod_1.z.number(),
+    keytoneSwitch: zod_1.z.number(),
+    devCth: zod_1.z.number(),
+    devCt: zod_1.z.number(),
+    devCth2: zod_1.z.number().nullable(),
+    devCt2: zod_1.z.number().nullable(),
+    devCh: zod_1.z.number(),
+    devTt: zod_1.z.number(),
+    devTh: zod_1.z.number(),
+    devCompany: zod_1.z.number(),
+    devTth: zod_1.z.number(),
+    vpdCth: zod_1.z.number(),
+    vpdCt: zod_1.z.number(),
+    vpdTransition: zod_1.z.number(),
+    portResistance: zod_1.z.number().nullable(),
+    devBth: zod_1.z.number(),
+    devBt: zod_1.z.number(),
+    devBh: zod_1.z.number(),
+    devBvpd: zod_1.z.number(),
+    isFlag: zod_1.z.number(),
+    devTimeZone: zod_1.z.string().nullable(),
+    loadType: zod_1.z.number(),
+    tempCompare: zod_1.z.number(),
+    humiCompare: zod_1.z.number(),
+    onTimeSwitch: zod_1.z.number(),
+    onTime: zod_1.z.number(),
+    sensorSettingStr: zod_1.z.string().nullable(),
+    sensorSetting: zod_1.z.unknown().nullable(),
+    sensorTransBuffStr: zod_1.z.string().nullable(),
+    sensorTransBuff: zod_1.z.unknown().nullable(),
+    portParamData: zod_1.z.string().nullable(),
+    photocellSwitch: zod_1.z.number(),
+    isOpenDoseTime: zod_1.z.number(),
+    onDoseTime: zod_1.z.number(),
+    offDoseTime: zod_1.z.number(),
+    isOnMinMaxTime: zod_1.z.number(),
+    onMinTime: zod_1.z.number(),
+    onMaxTime: zod_1.z.number(),
+    ecOrTds: zod_1.z.number(),
+    interchangeSensor: zod_1.z.number(),
+    subDeviceId: zod_1.z.string().nullable(),
+    subDeviceVersion: zod_1.z.string().nullable(),
+    subDeviceType: zod_1.z.number().nullable(),
+    supportOta: zod_1.z.unknown().nullable(),
+    otaUpdating: zod_1.z.unknown().nullable(),
+    secFucStatus: zod_1.z.number(),
+    secFucDevtype: zod_1.z.number(),
+    secFucDevEffect: zod_1.z.number(),
+    secFucParamNums: zod_1.z.number(),
+    secFucParams: zod_1.z.unknown().nullable(),
+    secFucReportTime: zod_1.z.number(),
+    toward: zod_1.z.unknown().nullable(),
+    powerState: zod_1.z.unknown().nullable(),
+    updateAllPort: zod_1.z.boolean(),
+    timestamp: zod_1.z.unknown().nullable(),
+    calibrationTime: zod_1.z.unknown().nullable(),
+    fieldSet: zod_1.z.array(zod_1.z.unknown()),
+    plantCode: zod_1.z.number(),
+    potSize: zod_1.z.number(),
+    plantingNum: zod_1.z.number(),
+    devCl: zod_1.z.unknown().nullable(),
+    devCsm1: zod_1.z.unknown().nullable(),
+    devCsm2: zod_1.z.unknown().nullable(),
+    devCsm3: zod_1.z.unknown().nullable(),
+    devCsm4: zod_1.z.unknown().nullable(),
+    uuidSta: zod_1.z.number(),
+    uuidType: zod_1.z.unknown().nullable(),
+    uuid: zod_1.z.string().nullable(),
+    matterCode: zod_1.z.string().nullable(),
+    matterSta: zod_1.z.unknown().nullable(),
+}).transform((v) => ({
+    ...transformDeviceBase(v),
+}));
+exports.DeviceModeSettingsSchema = DeviceBaseInputSchema.extend({
+    acitveTimerOff: zod_1.z.number(),
+    acitveTimerOn: zod_1.z.number(),
+    activeCycleOff: zod_1.z.number(),
+    activeCycleOn: zod_1.z.number(),
+    activeHh: zod_1.z.number(),
+    activeHt: zod_1.z.number(),
+    activeHtVpd: zod_1.z.number(),
+    activeHtVpdNums: zod_1.z.number(),
+    activeLh: zod_1.z.number(),
+    activeLt: zod_1.z.number(),
+    activeLtVpd: zod_1.z.number(),
+    activeLtVpdNums: zod_1.z.number(),
+    co2FanHighSwitch: zod_1.z.number(),
+    co2FanHighValue: zod_1.z.number(),
+    co2LowSwitch: zod_1.z.number(),
+    co2LowValue: zod_1.z.number(),
+    devHh: zod_1.z.number(),
+    devHt: zod_1.z.number(),
+    devHtf: zod_1.z.number(),
+    devLh: zod_1.z.number(),
+    devLt: zod_1.z.number(),
+    devLtf: zod_1.z.number(),
+    ecTdsLowSwitchEc: zod_1.z.number(),
+    ecTdsLowSwitchTds: zod_1.z.number(),
+    ecTdsLowValueEcUs: zod_1.z.number(),
+    ecTdsLowValueTdsPpm: zod_1.z.number(),
+    isOpenAutomation: zod_1.z.number(),
+    modeType: zod_1.z.number(),
+    moistureLowSwitch: zod_1.z.number(),
+    moistureLowValue: zod_1.z.number(),
+    onlyUpdateSpeed: zod_1.z.number(),
+    phHighSwitch: zod_1.z.number(),
+    phHighValue: zod_1.z.number(),
+    phLowSwitch: zod_1.z.number(),
+    phLowValue: zod_1.z.number(),
+    schedEndtTime: zod_1.z.number(),
+    schedStartTime: zod_1.z.number(),
+    surplus: zod_1.z.number().nullable(),
+    targetHumi: zod_1.z.number(),
+    targetHumiSwitch: zod_1.z.number(),
+    targetTSwitch: zod_1.z.number(),
+    targetTemp: zod_1.z.number(),
+    targetTempF: zod_1.z.number(),
+    targetVpd: zod_1.z.number(),
+    targetVpdSwitch: zod_1.z.number(),
+    waterLevelLowSwitch: zod_1.z.number(),
+    waterTempHighSwitch: zod_1.z.number(),
+    waterTempHighValue: zod_1.z.number(),
+    waterTempHighValueF: zod_1.z.number(),
+    waterTempLowSwitch: zod_1.z.number(),
+    waterTempLowValue: zod_1.z.number(),
+    waterTempLowValueF: zod_1.z.number(),
+}).transform((v) => ({
+    ...transformDeviceBase(v),
+}));
+function encodeDeviceModeSettings(settings) {
+    return {
+        onSpead: settings.levelWhileOn,
+    };
+}

package/build/src/types/User.d.ts

@@ -1,16 +1,16 @@
 import { z } from 'zod';
-export declare const UserSchema: z.ZodObject<{
+export declare const UserSchema: z.ZodPipe<z.ZodObject<{
     appId: z.ZodString;
     nickName: z.ZodString;
-    appEmail: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    appId: string;
-    nickName: string;
-    appEmail: string;
+    appEmail: z.ZodEmail;
+}, z.core.$strip>, z.ZodTransform<{
+    id: string;
+    username: string;
+    email: string;
 }, {
     appId: string;
     nickName: string;
     appEmail: string;
-}>;
+}>>;
 export type User = z.infer<typeof UserSchema>;
 //# sourceMappingURL=User.d.ts.map

package/build/src/types/User.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"User.d.ts","sourceRoot":"","sources":["../../../src/types/User.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,UAAU;;;;;;;;;;;;EAIrB,CAAC;AACH,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC"}
+{"version":3,"file":"User.d.ts","sourceRoot":"","sources":["../../../src/types/User.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,UAAU;;;;;;;;;;;;GAUlB,CAAC;AAEN,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC"}

package/build/src/types/User.js

@@ -2,8 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UserSchema = void 0;
 const zod_1 = require("zod");
-exports.UserSchema = zod_1.z.object({
+exports.UserSchema = zod_1.z
+    .object({
     appId: zod_1.z.string(),
     nickName: zod_1.z.string(),
-    appEmail: zod_1.z.string().email(),
-});
+    appEmail: zod_1.z.email(),
+})
+    .transform(({ appId, nickName, appEmail }) => ({
+    id: appId,
+    username: nickName,
+    email: appEmail,
+}));

package/build/src/types/index.d.ts

@@ -1,4 +1,7 @@
-export * from './Controller';
-export * from './Device';
-export * from './User';
+export type { Controller, ControllerDeviceInfo, ControllerPort } from './Controller';
+export { ControllerDeviceType, ControllerSchema } from './Controller';
+export type { DeviceModeSettings, DeviceModeSettingsInput, DeviceSettings } from './Device';
+export { DeviceMode, DeviceModeSettingsSchema, DeviceSettingsSchema, DeviceType, encodeDeviceModeSettings } from './Device';
+export type { User } from './User';
+export { UserSchema } from './User';
 //# sourceMappingURL=index.d.ts.map

package/build/src/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/types/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,UAAU,CAAC;AACzB,cAAc,QAAQ,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/types/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,UAAU,EAAE,oBAAoB,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AACrF,OAAO,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACtE,YAAY,EAAE,kBAAkB,EAAE,uBAAuB,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC5F,OAAO,EAAE,UAAU,EAAE,wBAAwB,EAAE,oBAAoB,EAAE,UAAU,EAAE,wBAAwB,EAAE,MAAM,UAAU,CAAC;AAC5H,YAAY,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AACnC,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC"}

package/build/src/types/index.js

@@ -1,19 +1,14 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./Controller"), exports);
-__exportStar(require("./Device"), exports);
-__exportStar(require("./User"), exports);
+exports.UserSchema = exports.encodeDeviceModeSettings = exports.DeviceType = exports.DeviceSettingsSchema = exports.DeviceModeSettingsSchema = exports.DeviceMode = exports.ControllerSchema = exports.ControllerDeviceType = void 0;
+var Controller_1 = require("./Controller");
+Object.defineProperty(exports, "ControllerDeviceType", { enumerable: true, get: function () { return Controller_1.ControllerDeviceType; } });
+Object.defineProperty(exports, "ControllerSchema", { enumerable: true, get: function () { return Controller_1.ControllerSchema; } });
+var Device_1 = require("./Device");
+Object.defineProperty(exports, "DeviceMode", { enumerable: true, get: function () { return Device_1.DeviceMode; } });
+Object.defineProperty(exports, "DeviceModeSettingsSchema", { enumerable: true, get: function () { return Device_1.DeviceModeSettingsSchema; } });
+Object.defineProperty(exports, "DeviceSettingsSchema", { enumerable: true, get: function () { return Device_1.DeviceSettingsSchema; } });
+Object.defineProperty(exports, "DeviceType", { enumerable: true, get: function () { return Device_1.DeviceType; } });
+Object.defineProperty(exports, "encodeDeviceModeSettings", { enumerable: true, get: function () { return Device_1.encodeDeviceModeSettings; } });
+var User_1 = require("./User");
+Object.defineProperty(exports, "UserSchema", { enumerable: true, get: function () { return User_1.UserSchema; } });

package/package.json

@@ -1,32 +1,37 @@
 {
   "name": "@jakobgoerke/ac-infinity-client",
-  "version": "0.1.1",
+  "version": "0.2.1",
   "main": "./build/src",
   "types": "./build/src/index.d.ts",
   "repository": "git@github.com:jakobgoerke/ac-infinity-client.git",
   "author": "revdev <mail@revdev.me>",
   "license": "GPL-3.0-or-later",
-  "dependencies": {
-    "axios": "1.7.7",
-    "rimraf": "6.0.1",
-    "zod": "3.23.8"
-  },
   "files": [
     "package.json",
     "build/src/**"
   ],
+  "dependencies": {
+    "axios": "1.13.5",
+    "zod": "4.3.6"
+  },
   "devDependencies": {
-    "@jest/globals": "29.7.0",
-    "@tsconfig/node22": "22.0.0",
-    "@types/jest": "29.5.13",
-    "jest": "29.7.0",
-    "ts-jest": "29.2.5",
-    "typescript": "5.6.2"
+    "@biomejs/biome": "2.4.4",
+    "@jest/globals": "30.2.0",
+    "@tsconfig/node24": "24.0.4",
+    "@types/jest": "30.0.0",
+    "@types/node": "25.3.0",
+    "jest": "30.2.0",
+    "rimraf": "6.1.3",
+    "ts-jest": "29.4.6",
+    "ts-node": "10.9.2",
+    "typescript": "5.9.3"
   },
   "scripts": {
     "build": "rimraf build && tsc -p .",
     "watch": "tsc -p . --watch",
     "test": "jest",
-    "coverage": "jest --coverage"
-  }
-}
+    "coverage": "jest --coverage",
+    "lint": "biome check"
+  },
+  "packageManager": "yarn@4.12.0"
+}