@jakobgoerke/ac-infinity-client 0.1.1 → 0.3.0

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

@@ -1,153 +1,326 @@
 import { z } from 'zod';
 import { DeviceMode, DeviceType } from './Device';
-declare enum ControllerDeviceType {
+export declare enum ControllerDeviceType {
+    CONTROLLER_67 = 1,
+    CONTROLLER_69 = 7,
+    CONTROLLER_69_WIFI = 8,
     UIS_CONTROLLER_69_PRO = 11,
-    UIS_CONTROLLER_69_PRO_PLUS = 10
+    UIS_CONTROLLER_69_PRO_PLUS = 18,
+    UIS_CONTROLLER_AI_PLUS = 20
 }
-export declare const ControllerPortSchema: z.ZodObject<{
-    loadType: z.ZodNativeEnum<typeof DeviceType>;
-    curMode: z.ZodNativeEnum<typeof DeviceMode>;
-    port: z.ZodNumber;
+export declare enum SensorType {
+    TEMPERATURE_F = 0,
+    TEMPERATURE_C = 1,
+    HUMIDITY = 2,
+    VPD = 3,
+    ZONE_TEMPERATURE_F = 4,
+    ZONE_TEMPERATURE_C = 5,
+    ZONE_HUMIDITY = 6,
+    ZONE_VPD = 7,
+    LEAF_TEMPERATURE_F = 8,
+    LEAF_TEMPERATURE_C = 9,
+    SOIL_MOISTURE = 10,
+    CO2 = 11,
+    LIGHT = 12,
+    PH = 13,
+    EC_US = 14,
+    EC_MS = 15,
+    TDS_PPM = 16,
+    TDS_PPT = 17,
+    WATER_TEMPERATURE_F = 18,
+    WATER_TEMPERATURE_C = 19,
+    WATER_LEVEL = 20
+}
+export declare const ControllerSensorSchema: z.ZodPipe<z.ZodObject<{
+    accessPort: z.ZodNumber;
+    sensorType: z.ZodNumber;
+    sensorPrecision: z.ZodNumber;
+    sensorData: z.ZodNumber;
+}, z.core.$strip>, z.ZodTransform<{
+    port: number;
+    type: SensorType;
+    value: number | null;
+}, {
+    accessPort: number;
+    sensorType: number;
+    sensorPrecision: number;
+    sensorData: number;
+}>>;
+export declare const ControllerPortSchema: z.ZodPipe<z.ZodObject<{
     speak: z.ZodNumber;
+    port: z.ZodNumber;
+    curMode: z.ZodEnum<typeof DeviceMode>;
+    loadType: z.ZodNumber;
     portName: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    loadType: DeviceType;
-    curMode: DeviceMode;
+    portResistance: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    online: z.ZodCoercedBoolean<unknown>;
+    remainTime: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strip>, z.ZodTransform<{
     port: number;
-    speak: number;
-    portName: string;
+    currentLevel: number;
+    currentMode: DeviceMode;
+    /** NONE when no type is assigned, the controller schema then recognizes it by resistance */
+    deviceType: DeviceType;
+    deviceName: string;
+    /** id resistor of the plugged in device, in ohms */
+    resistance: number | null;
+    online: boolean;
+    /** seconds left until the current timer, cycle or schedule step switches */
+    remainingTime: number | null;
 }, {
-    loadType: DeviceType;
-    curMode: DeviceMode;
-    port: number;
     speak: number;
+    port: number;
+    curMode: DeviceMode;
+    loadType: number;
     portName: string;
-}>;
-export type ControllerPort = z.infer<typeof ControllerPortSchema>;
-export declare const ControllerDeviceInfoSchema: z.ZodObject<{
+    online: boolean;
+    portResistance?: number | null | undefined;
+    remainTime?: number | null | undefined;
+}>>;
+export declare const ControllerDeviceInfoSchema: z.ZodPipe<z.ZodObject<{
     temperature: z.ZodNumber;
+    temperatureF: z.ZodOptional<z.ZodNullable<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.ZodNumber;
         portName: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        loadType: DeviceType;
-        curMode: DeviceMode;
+        portResistance: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        online: z.ZodCoercedBoolean<unknown>;
+        remainTime: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    }, z.core.$strip>, z.ZodTransform<{
         port: number;
-        speak: number;
-        portName: string;
+        currentLevel: number;
+        currentMode: DeviceMode;
+        /** NONE when no type is assigned, the controller schema then recognizes it by resistance */
+        deviceType: DeviceType;
+        deviceName: string;
+        /** id resistor of the plugged in device, in ohms */
+        resistance: number | null;
+        online: boolean;
+        /** seconds left until the current timer, cycle or schedule step switches */
+        remainingTime: number | null;
     }, {
-        loadType: DeviceType;
-        curMode: DeviceMode;
-        port: number;
         speak: number;
+        port: number;
+        curMode: DeviceMode;
+        loadType: number;
         portName: string;
-    }>, "many">;
-    vpdnums: z.ZodNumber;
-}, "strip", z.ZodTypeAny, {
+        online: boolean;
+        portResistance?: number | null | undefined;
+        remainTime?: number | null | undefined;
+    }>>>;
+    sensors: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodPipe<z.ZodObject<{
+        accessPort: z.ZodNumber;
+        sensorType: z.ZodNumber;
+        sensorPrecision: z.ZodNumber;
+        sensorData: z.ZodNumber;
+    }, z.core.$strip>, z.ZodTransform<{
+        port: number;
+        type: SensorType;
+        value: number | null;
+    }, {
+        accessPort: number;
+        sensorType: number;
+        sensorPrecision: number;
+        sensorData: number;
+    }>>>>>;
+}, z.core.$strip>, z.ZodTransform<{
     temperature: number;
+    temperatureF: number | null;
     humidity: number;
+    vpd: number;
     ports: {
-        loadType: DeviceType;
-        curMode: DeviceMode;
         port: number;
-        speak: number;
-        portName: string;
+        currentLevel: number;
+        currentMode: DeviceMode;
+        /** NONE when no type is assigned, the controller schema then recognizes it by resistance */
+        deviceType: DeviceType;
+        deviceName: string;
+        /** id resistor of the plugged in device, in ohms */
+        resistance: number | null;
+        online: boolean;
+        /** seconds left until the current timer, cycle or schedule step switches */
+        remainingTime: number | null;
+    }[];
+    sensors: {
+        port: number;
+        type: SensorType;
+        value: number | null;
     }[];
-    vpdnums: number;
 }, {
     temperature: number;
     humidity: number;
+    vpdnums: number;
     ports: {
-        loadType: DeviceType;
-        curMode: DeviceMode;
         port: number;
-        speak: number;
-        portName: string;
+        currentLevel: number;
+        currentMode: DeviceMode;
+        /** NONE when no type is assigned, the controller schema then recognizes it by resistance */
+        deviceType: DeviceType;
+        deviceName: string;
+        /** id resistor of the plugged in device, in ohms */
+        resistance: number | null;
+        online: boolean;
+        /** seconds left until the current timer, cycle or schedule step switches */
+        remainingTime: number | null;
     }[];
-    vpdnums: number;
-}>;
-export type ControllerDeviceInfo = z.infer<typeof ControllerDeviceInfoSchema>;
-export declare const ControllerSchema: z.ZodObject<{
+    temperatureF?: number | null | undefined;
+    sensors?: {
+        port: number;
+        type: SensorType;
+        value: number | null;
+    }[] | null | undefined;
+}>>;
+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;
+    devMacAddr: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    zoneId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    wifiName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    online: z.ZodCoercedBoolean<unknown>;
     firmwareVersion: z.ZodString;
     hardwareVersion: z.ZodString;
-    deviceInfo: z.ZodObject<{
+    deviceInfo: z.ZodPipe<z.ZodObject<{
         temperature: z.ZodNumber;
+        temperatureF: z.ZodOptional<z.ZodNullable<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.ZodNumber;
             portName: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            loadType: DeviceType;
-            curMode: DeviceMode;
+            portResistance: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            online: z.ZodCoercedBoolean<unknown>;
+            remainTime: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        }, z.core.$strip>, z.ZodTransform<{
             port: number;
-            speak: number;
-            portName: string;
+            currentLevel: number;
+            currentMode: DeviceMode;
+            /** NONE when no type is assigned, the controller schema then recognizes it by resistance */
+            deviceType: DeviceType;
+            deviceName: string;
+            /** id resistor of the plugged in device, in ohms */
+            resistance: number | null;
+            online: boolean;
+            /** seconds left until the current timer, cycle or schedule step switches */
+            remainingTime: number | null;
         }, {
-            loadType: DeviceType;
-            curMode: DeviceMode;
-            port: number;
             speak: number;
+            port: number;
+            curMode: DeviceMode;
+            loadType: number;
             portName: string;
-        }>, "many">;
-        vpdnums: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
+            online: boolean;
+            portResistance?: number | null | undefined;
+            remainTime?: number | null | undefined;
+        }>>>;
+        sensors: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodPipe<z.ZodObject<{
+            accessPort: z.ZodNumber;
+            sensorType: z.ZodNumber;
+            sensorPrecision: z.ZodNumber;
+            sensorData: z.ZodNumber;
+        }, z.core.$strip>, z.ZodTransform<{
+            port: number;
+            type: SensorType;
+            value: number | null;
+        }, {
+            accessPort: number;
+            sensorType: number;
+            sensorPrecision: number;
+            sensorData: number;
+        }>>>>>;
+    }, z.core.$strip>, z.ZodTransform<{
         temperature: number;
+        temperatureF: number | null;
         humidity: number;
+        vpd: number;
         ports: {
-            loadType: DeviceType;
-            curMode: DeviceMode;
             port: number;
-            speak: number;
-            portName: string;
+            currentLevel: number;
+            currentMode: DeviceMode;
+            /** NONE when no type is assigned, the controller schema then recognizes it by resistance */
+            deviceType: DeviceType;
+            deviceName: string;
+            /** id resistor of the plugged in device, in ohms */
+            resistance: number | null;
+            online: boolean;
+            /** seconds left until the current timer, cycle or schedule step switches */
+            remainingTime: number | null;
+        }[];
+        sensors: {
+            port: number;
+            type: SensorType;
+            value: number | null;
         }[];
-        vpdnums: number;
     }, {
         temperature: number;
         humidity: number;
+        vpdnums: number;
         ports: {
-            loadType: DeviceType;
-            curMode: DeviceMode;
             port: number;
-            speak: number;
-            portName: string;
+            currentLevel: number;
+            currentMode: DeviceMode;
+            /** NONE when no type is assigned, the controller schema then recognizes it by resistance */
+            deviceType: DeviceType;
+            deviceName: string;
+            /** id resistor of the plugged in device, in ohms */
+            resistance: number | null;
+            online: boolean;
+            /** seconds left until the current timer, cycle or schedule step switches */
+            remainingTime: number | null;
         }[];
-        vpdnums: number;
-    }>;
-}, "strip", z.ZodTypeAny, {
-    devId: string;
-    devCode: string;
-    devName: string;
-    devType: ControllerDeviceType;
-    devPortCount: number;
-    devVersion: number;
+        temperatureF?: number | null | undefined;
+        sensors?: {
+            port: number;
+            type: SensorType;
+            value: number | null;
+        }[] | null | undefined;
+    }>>;
+}, z.core.$strip>, z.ZodTransform<{
     online: boolean;
     firmwareVersion: string;
     hardwareVersion: string;
+    id: string;
+    code: string;
+    name: string;
+    type: ControllerDeviceType;
+    totalPorts: number;
+    version: number;
+    macAddress: string | null;
+    timeZone: string | null;
+    wifiName: string | null;
     deviceInfo: {
+        ports: {
+            deviceType: DeviceType;
+            port: number;
+            currentLevel: number;
+            currentMode: DeviceMode;
+            deviceName: string;
+            /** id resistor of the plugged in device, in ohms */
+            resistance: number | null;
+            online: boolean;
+            /** seconds left until the current timer, cycle or schedule step switches */
+            remainingTime: number | null;
+        }[];
         temperature: number;
+        temperatureF: number | null;
         humidity: number;
-        ports: {
-            loadType: DeviceType;
-            curMode: DeviceMode;
+        vpd: number;
+        sensors: {
             port: number;
-            speak: number;
-            portName: string;
+            type: SensorType;
+            value: number | null;
         }[];
-        vpdnums: number;
     };
 }, {
     devId: string;
@@ -161,17 +334,34 @@ export declare const ControllerSchema: z.ZodObject<{
     hardwareVersion: string;
     deviceInfo: {
         temperature: number;
+        temperatureF: number | null;
         humidity: number;
+        vpd: number;
         ports: {
-            loadType: DeviceType;
-            curMode: DeviceMode;
             port: number;
-            speak: number;
-            portName: string;
+            currentLevel: number;
+            currentMode: DeviceMode;
+            /** NONE when no type is assigned, the controller schema then recognizes it by resistance */
+            deviceType: DeviceType;
+            deviceName: string;
+            /** id resistor of the plugged in device, in ohms */
+            resistance: number | null;
+            online: boolean;
+            /** seconds left until the current timer, cycle or schedule step switches */
+            remainingTime: number | null;
+        }[];
+        sensors: {
+            port: number;
+            type: SensorType;
+            value: number | null;
         }[];
-        vpdnums: number;
     };
-}>;
+    devMacAddr?: string | null | undefined;
+    zoneId?: string | null | undefined;
+    wifiName?: string | null | undefined;
+}>>;
+export type ControllerSensor = z.infer<typeof ControllerSensorSchema>;
+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,aAAa,IAAI;IACjB,aAAa,IAAI;IACjB,kBAAkB,IAAI;IACtB,qBAAqB,KAAK;IAC1B,0BAA0B,KAAK;IAC/B,sBAAsB,KAAK;CAC5B;AAKD,oBAAY,UAAU;IACpB,aAAa,IAAI;IACjB,aAAa,IAAI;IACjB,QAAQ,IAAI;IACZ,GAAG,IAAI;IACP,kBAAkB,IAAI;IACtB,kBAAkB,IAAI;IACtB,aAAa,IAAI;IACjB,QAAQ,IAAI;IACZ,kBAAkB,IAAI;IACtB,kBAAkB,IAAI;IACtB,aAAa,KAAK;IAClB,GAAG,KAAK;IACR,KAAK,KAAK;IACV,EAAE,KAAK;IACP,KAAK,KAAK;IACV,KAAK,KAAK;IACV,OAAO,KAAK;IACZ,OAAO,KAAK;IACZ,mBAAmB,KAAK;IACxB,mBAAmB,KAAK;IACxB,WAAW,KAAK;CACjB;AAqDD,eAAO,MAAM,sBAAsB;;;;;;;UAST,UAAU;;;;;;;GAE/B,CAAC;AAEN,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;IAe7B,4FAA4F;gBACjD,UAAU;;IAErD,oDAAoD;;;IAGpD,4EAA4E;;;;;;;;;;;GAE3E,CAAC;AAEN,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;QAVnC,4FAA4F;oBACjD,UAAU;;QAErD,oDAAoD;;;QAGpD,4EAA4E;;;;;;;;;;;;;;;;;;;cAzBtD,UAAU;;;;;;;;;;;;;;;;;QAmBhC,4FAA4F;oBACjD,UAAU;;QAErD,oDAAoD;;;QAGpD,4EAA4E;;;;;cAzBtD,UAAU;;;;;;;;;;;QAmBhC,4FAA4F;oBACjD,UAAU;;QAErD,oDAAoD;;;QAGpD,4EAA4E;;;;;;cAzBtD,UAAU;;;GA6C/B,CAAC;AAEN,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YA5BzB,4FAA4F;wBACjD,UAAU;;YAErD,oDAAoD;;;YAGpD,4EAA4E;;;;;;;;;;;;;;;;;;;kBAzBtD,UAAU;;;;;;;;;;;;;;;;;YAmBhC,4FAA4F;wBACjD,UAAU;;YAErD,oDAAoD;;;YAGpD,4EAA4E;;;;;kBAzBtD,UAAU;;;;;;;;;;;YAmBhC,4FAA4F;wBACjD,UAAU;;YAErD,oDAAoD;;;YAGpD,4EAA4E;;;;;;kBAzBtD,UAAU;;;;;;;;;;;;;;;;;;;;;;;;YAsBhC,oDAAoD;;;YAGpD,4EAA4E;;;;;;;;;kBAzBtD,UAAU;;;;;;;;;;;;;;;;;;;;;;;YAmBhC,4FAA4F;wBACjD,UAAU;;YAErD,oDAAoD;;;YAGpD,4EAA4E;;;;;kBAzBtD,UAAU;;;;;;;GAiF/B,CAAC;AAEN,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,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,170 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ControllerSchema = exports.ControllerDeviceInfoSchema = exports.ControllerPortSchema = void 0;
+exports.ControllerSchema = exports.ControllerDeviceInfoSchema = exports.ControllerPortSchema = exports.ControllerSensorSchema = exports.SensorType = exports.ControllerDeviceType = void 0;
 const zod_1 = require("zod");
 const Device_1 = require("./Device");
 var ControllerDeviceType;
 (function (ControllerDeviceType) {
+    ControllerDeviceType[ControllerDeviceType["CONTROLLER_67"] = 1] = "CONTROLLER_67";
+    ControllerDeviceType[ControllerDeviceType["CONTROLLER_69"] = 7] = "CONTROLLER_69";
+    ControllerDeviceType[ControllerDeviceType["CONTROLLER_69_WIFI"] = 8] = "CONTROLLER_69_WIFI";
     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[ControllerDeviceType["UIS_CONTROLLER_69_PRO_PLUS"] = 18] = "UIS_CONTROLLER_69_PRO_PLUS";
+    ControllerDeviceType[ControllerDeviceType["UIS_CONTROLLER_AI_PLUS"] = 20] = "UIS_CONTROLLER_AI_PLUS";
+})(ControllerDeviceType || (exports.ControllerDeviceType = ControllerDeviceType = {}));
+// these controllers report pumps as PUMP instead of WATER_PUMP
+const PUMP_CONTROLLERS = [ControllerDeviceType.UIS_CONTROLLER_69_PRO, ControllerDeviceType.UIS_CONTROLLER_69_PRO_PLUS];
+var SensorType;
+(function (SensorType) {
+    SensorType[SensorType["TEMPERATURE_F"] = 0] = "TEMPERATURE_F";
+    SensorType[SensorType["TEMPERATURE_C"] = 1] = "TEMPERATURE_C";
+    SensorType[SensorType["HUMIDITY"] = 2] = "HUMIDITY";
+    SensorType[SensorType["VPD"] = 3] = "VPD";
+    SensorType[SensorType["ZONE_TEMPERATURE_F"] = 4] = "ZONE_TEMPERATURE_F";
+    SensorType[SensorType["ZONE_TEMPERATURE_C"] = 5] = "ZONE_TEMPERATURE_C";
+    SensorType[SensorType["ZONE_HUMIDITY"] = 6] = "ZONE_HUMIDITY";
+    SensorType[SensorType["ZONE_VPD"] = 7] = "ZONE_VPD";
+    SensorType[SensorType["LEAF_TEMPERATURE_F"] = 8] = "LEAF_TEMPERATURE_F";
+    SensorType[SensorType["LEAF_TEMPERATURE_C"] = 9] = "LEAF_TEMPERATURE_C";
+    SensorType[SensorType["SOIL_MOISTURE"] = 10] = "SOIL_MOISTURE";
+    SensorType[SensorType["CO2"] = 11] = "CO2";
+    SensorType[SensorType["LIGHT"] = 12] = "LIGHT";
+    SensorType[SensorType["PH"] = 13] = "PH";
+    SensorType[SensorType["EC_US"] = 14] = "EC_US";
+    SensorType[SensorType["EC_MS"] = 15] = "EC_MS";
+    SensorType[SensorType["TDS_PPM"] = 16] = "TDS_PPM";
+    SensorType[SensorType["TDS_PPT"] = 17] = "TDS_PPT";
+    SensorType[SensorType["WATER_TEMPERATURE_F"] = 18] = "WATER_TEMPERATURE_F";
+    SensorType[SensorType["WATER_TEMPERATURE_C"] = 19] = "WATER_TEMPERATURE_C";
+    SensorType[SensorType["WATER_LEVEL"] = 20] = "WATER_LEVEL";
+})(SensorType || (exports.SensorType = SensorType = {}));
+// outlet ports report their device type with this bit set
+const OUTLET_FLAG = 0x80;
+// ports without an assigned device type are recognized by the id resistor in the plug, in ohms
+const RESISTANCE_RANGES = [
+    [380, 420, Device_1.DeviceType.GROW_LIGHT],
+    [3135, 3465, Device_1.DeviceType.GROW_LIGHT],
+    [4845, 10500, Device_1.DeviceType.FAN],
+    [10501, 12600, Device_1.DeviceType.HUMIDIFIER],
+    [12601, 14385, Device_1.DeviceType.DEHUMIDIFIER],
+    [16591, 18900, Device_1.DeviceType.HEATER],
+    [18901, 21525, Device_1.DeviceType.AIR_CONDITION],
+    [35100, 42900, Device_1.DeviceType.DEHUMIDIFIER],
+];
+const PUMP_RESISTANCE_RANGE = [1350, 1650];
+const deviceTypeByResistance = (resistance, controllerType) => {
+    if (resistance === null) {
+        return Device_1.DeviceType.NONE;
+    }
+    const ohms = resistance < 0 ? resistance & 0xffff : resistance;
+    const [pumpMin, pumpMax] = PUMP_RESISTANCE_RANGE;
+    if (ohms >= pumpMin && ohms <= pumpMax) {
+        return PUMP_CONTROLLERS.includes(controllerType) ? Device_1.DeviceType.PUMP : Device_1.DeviceType.WATER_PUMP;
+    }
+    return RESISTANCE_RANGES.find(([min, max]) => ohms >= min && ohms <= max)?.[2] ?? Device_1.DeviceType.NONE;
+};
+// the vendor reports this value for a sensor that has no reading
+const SENSOR_NO_DATA = -32768;
+const decodeSensorValue = (data, precision) => {
+    if (data === SENSOR_NO_DATA) {
+        return null;
+    }
+    switch (precision) {
+        case 0:
+            return data * 10;
+        case 2:
+            return data / 10;
+        case 3:
+            return data / 100;
+        default:
+            return data;
+    }
+};
+exports.ControllerSensorSchema = zod_1.z
+    .object({
+    accessPort: zod_1.z.number(),
+    sensorType: zod_1.z.number(),
+    sensorPrecision: zod_1.z.number(),
+    sensorData: zod_1.z.number(),
+})
+    .transform((v) => ({
+    port: v.accessPort,
+    type: v.sensorType,
+    value: decodeSensorValue(v.sensorData, v.sensorPrecision),
+}));
+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.number(),
     portName: zod_1.z.string(),
-});
-exports.ControllerDeviceInfoSchema = zod_1.z.object({
+    portResistance: zod_1.z.number().nullish(),
+    online: zod_1.z.coerce.boolean(),
+    remainTime: zod_1.z.number().nullish(),
+})
+    .transform((v) => ({
+    port: v.port,
+    currentLevel: v.speak,
+    currentMode: v.curMode,
+    /** NONE when no type is assigned, the controller schema then recognizes it by resistance */
+    deviceType: (v.loadType & ~OUTLET_FLAG),
+    deviceName: v.portName,
+    /** id resistor of the plugged in device, in ohms */
+    resistance: v.portResistance ?? null,
+    online: v.online,
+    /** seconds left until the current timer, cycle or schedule step switches */
+    remainingTime: v.remainTime ?? null,
+}));
+exports.ControllerDeviceInfoSchema = zod_1.z
+    .object({
     temperature: zod_1.z.number(),
+    temperatureF: zod_1.z.number().nullish(),
     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),
+    sensors: zod_1.z.array(exports.ControllerSensorSchema).nullish(),
+})
+    .transform((v) => ({
+    temperature: v.temperature / 100,
+    temperatureF: v.temperatureF == null ? null : v.temperatureF / 100,
+    humidity: v.humidity / 100,
+    vpd: v.vpdnums / 100,
+    ports: v.ports,
+    sensors: v.sensors ?? [],
+}));
+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(),
+    devMacAddr: zod_1.z.string().nullish(),
+    zoneId: zod_1.z.string().nullish(),
+    wifiName: zod_1.z.string().nullish(),
     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, devMacAddr, zoneId, wifiName, deviceInfo, ...rest }) => ({
+    id: devId,
+    code: devCode,
+    name: devName,
+    type: devType,
+    totalPorts: devPortCount,
+    version: devVersion,
+    macAddress: devMacAddr ?? null,
+    timeZone: zoneId ?? null,
+    wifiName: wifiName ?? null,
+    deviceInfo: {
+        ...deviceInfo,
+        ports: deviceInfo.ports.map((port) => ({
+            ...port,
+            deviceType: port.deviceType || deviceTypeByResistance(port.resistance, devType),
+        })),
+    },
+    ...rest,
+}));