@jakobgoerke/ac-infinity-client 0.2.1 → 0.3.1

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

@@ -1,61 +1,155 @@
 import { z } from 'zod';
 import { DeviceMode, DeviceType } from './Device';
 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 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.ZodEnum<typeof DeviceType>;
+    loadType: z.ZodNumber;
     portName: z.ZodString;
+    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;
     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;
 }, {
     speak: number;
     port: number;
     curMode: DeviceMode;
-    loadType: DeviceType;
+    loadType: number;
     portName: string;
+    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;
     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>;
+        loadType: z.ZodNumber;
         portName: z.ZodString;
+        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;
         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;
     }, {
         speak: number;
         port: number;
         curMode: DeviceMode;
-        loadType: DeviceType;
+        loadType: number;
         portName: string;
+        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: {
         port: number;
         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;
     }[];
 }, {
     temperature: number;
@@ -65,9 +159,21 @@ export declare const ControllerDeviceInfoSchema: z.ZodPipe<z.ZodObject<{
         port: number;
         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;
     }[];
+    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;
@@ -76,42 +182,85 @@ export declare const ControllerSchema: z.ZodPipe<z.ZodObject<{
     devType: z.ZodEnum<typeof ControllerDeviceType>;
     devPortCount: z.ZodNumber;
     devVersion: z.ZodNumber;
+    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.ZodPipe<z.ZodObject<{
         temperature: z.ZodNumber;
+        temperatureF: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
         humidity: 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>;
+            loadType: z.ZodNumber;
             portName: z.ZodString;
+            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;
             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;
         }, {
             speak: number;
             port: number;
             curMode: DeviceMode;
-            loadType: DeviceType;
+            loadType: number;
             portName: string;
+            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: {
             port: number;
             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;
         }[];
     }, {
         temperature: number;
@@ -121,32 +270,58 @@ export declare const ControllerSchema: z.ZodPipe<z.ZodObject<{
             port: number;
             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;
         }[];
+        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: {
-        temperature: number;
-        humidity: number;
-        vpd: number;
         ports: {
+            deviceType: DeviceType;
             port: number;
             currentLevel: number;
             currentMode: DeviceMode;
-            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;
+        }[];
+        temperature: number;
+        temperatureF: number | null;
+        humidity: number;
+        vpd: number;
+        sensors: {
+            port: number;
+            type: SensorType;
+            value: number | null;
         }[];
     };
-    id: string;
-    code: string;
-    name: string;
-    type: ControllerDeviceType;
-    totalPorts: number;
-    version: number;
 }, {
     devId: string;
     devCode: string;
@@ -159,17 +334,33 @@ export declare const ControllerSchema: z.ZodPipe<z.ZodObject<{
     hardwareVersion: string;
     deviceInfo: {
         temperature: number;
+        temperatureF: number | null;
         humidity: number;
         vpd: number;
         ports: {
             port: number;
             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;
         }[];
     };
+    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>;

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;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"}
+{"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,40 +1,137 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ControllerSchema = exports.ControllerDeviceInfoSchema = exports.ControllerPortSchema = exports.ControllerDeviceType = 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["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.enum(Device_1.DeviceType),
+    loadType: zod_1.z.number(),
     portName: zod_1.z.string(),
+    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,
-    deviceType: v.loadType,
+    /** 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(),
     vpdnums: zod_1.z.number(),
     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({
@@ -44,17 +141,30 @@ exports.ControllerSchema = zod_1.z
     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, ...rest }) => ({
+    .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,
 }));