@jakobgoerke/ac-infinity-client 0.2.1 → 0.3.0

package/README.md

@@ -1 +1 @@
-# ac-infinity-client
+# ac-infinity-client

package/build/src/AcInfinityClient.d.ts

@@ -1,25 +1,35 @@
-import type { Controller, DeviceModeSettings, DeviceSettings, User } from './types';
+import type { Controller, DeviceModeSettings, DeviceModeSettingsChanges, DeviceSettings, DeviceSettingsChanges, User } from './types';
 export declare enum Url {
     AUTH = "/user/appUserLogin",
     GET_CONTROLLERS = "/user/devInfoListAll",
+    GET_SHARED_CONTROLLERS = "/user/shareDevList",
+    GET_CONTROLLER = "/dev/getDeviceInfo",
     GET_DEVICE_SETTINGS = "/dev/getDevSetting",
+    SET_DEVICE_SETTINGS = "/dev/updateAdvSetting",
     GET_DEVICE_MODE_SETTINGS = "/dev/getdevModeSettingList",
     SET_DEVICE_MODE_SETTINGS = "/dev/addDevMode"
 }
 export interface Response<T> {
     code: number;
+    msg?: string;
     data: T;
 }
 export interface AuthParams {
     email: string;
     password: string;
 }
-interface GetDeviceParams {
+export interface ControllerParams {
     controllerId: string;
+}
+export interface GetDeviceParams extends ControllerParams {
+    /** 0 addresses the controller itself, 1..n the devices plugged into its ports */
     port: number;
 }
-interface SetDeviceModeSettingsParams extends GetDeviceParams {
-    settings: Pick<Partial<DeviceModeSettings>, 'levelWhileOn'>;
+export interface SetDeviceModeSettingsParams extends GetDeviceParams {
+    settings: DeviceModeSettingsChanges;
+}
+export interface SetDeviceSettingsParams extends GetDeviceParams {
+    settings: DeviceSettingsChanges;
 }
 declare class AcInfinityClient {
     constructor(args: AuthParams);
@@ -28,13 +38,17 @@ declare class AcInfinityClient {
     private email;
     private password;
     authenticate(): Promise<User>;
-    private ensureSuccess;
+    private request;
     getControllers(): Promise<Controller[]>;
+    getSharedControllers(): Promise<Controller[]>;
+    getController({ controllerId }: ControllerParams): Promise<Controller>;
     getDeviceSettings({ controllerId, port }: GetDeviceParams): Promise<DeviceSettings>;
+    setDeviceSettings({ controllerId, port, settings }: SetDeviceSettingsParams): Promise<void>;
+    private getDeviceName;
     getDeviceModeSettings({ controllerId, port }: GetDeviceParams): Promise<DeviceModeSettings>;
     setDeviceModeSettings({ controllerId, port, settings }: SetDeviceModeSettingsParams): Promise<void>;
     static build(args: AuthParams): Promise<AcInfinityClient>;
 }
+export type { Controller, DeviceModeSettings, DeviceModeSettingsChanges, DeviceSettings, DeviceSettingsChanges, User };
 export { AcInfinityClient };
-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":"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"}
+{"version":3,"file":"AcInfinityClient.d.ts","sourceRoot":"","sources":["../../src/AcInfinityClient.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,kBAAkB,EAAE,yBAAyB,EAAE,cAAc,EAAE,qBAAqB,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAUtI,oBAAY,GAAG;IACb,IAAI,uBAAuB;IAC3B,eAAe,yBAAyB;IACxC,sBAAsB,uBAAuB;IAC7C,cAAc,uBAAuB;IACrC,mBAAmB,uBAAuB;IAC1C,mBAAmB,0BAA0B;IAC7C,wBAAwB,+BAA+B;IACvD,wBAAwB,oBAAoB;CAC7C;AAED,MAAM,WAAW,QAAQ,CAAC,CAAC;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,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,MAAM,WAAW,gBAAgB;IAC/B,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,eAAgB,SAAQ,gBAAgB;IACvD,iFAAiF;IACjF,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,2BAA4B,SAAQ,eAAe;IAClE,QAAQ,EAAE,yBAAyB,CAAC;CACrC;AAED,MAAM,WAAW,uBAAwB,SAAQ,eAAe;IAC9D,QAAQ,EAAE,qBAAqB,CAAC;CACjC;AAqBD,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;YAiB5B,OAAO;IAUR,cAAc,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC;IAQvC,oBAAoB,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC;IAQ7C,aAAa,CAAC,EAAE,YAAY,EAAE,EAAE,gBAAgB,GAAG,OAAO,CAAC,UAAU,CAAC;IAQtE,iBAAiB,CAAC,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,eAAe,GAAG,OAAO,CAAC,cAAc,CAAC;IASnF,iBAAiB,CAAC,EAAE,YAAY,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,uBAAuB,GAAG,OAAO,CAAC,IAAI,CAAC;YAe1F,aAAa;IAMd,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;WAYnG,KAAK,CAAC,IAAI,EAAE,UAAU;CAKpC;AAED,YAAY,EAAE,UAAU,EAAE,kBAAkB,EAAE,yBAAyB,EAAE,cAAc,EAAE,qBAAqB,EAAE,IAAI,EAAE,CAAC;AACvH,OAAO,EAAE,gBAAgB,EAAE,CAAC"}

package/build/src/AcInfinityClient.js

@@ -11,10 +11,26 @@ var Url;
 (function (Url) {
     Url["AUTH"] = "/user/appUserLogin";
     Url["GET_CONTROLLERS"] = "/user/devInfoListAll";
+    Url["GET_SHARED_CONTROLLERS"] = "/user/shareDevList";
+    Url["GET_CONTROLLER"] = "/dev/getDeviceInfo";
     Url["GET_DEVICE_SETTINGS"] = "/dev/getDevSetting";
+    Url["SET_DEVICE_SETTINGS"] = "/dev/updateAdvSetting";
     Url["GET_DEVICE_MODE_SETTINGS"] = "/dev/getdevModeSettingList";
     Url["SET_DEVICE_MODE_SETTINGS"] = "/dev/addDevMode";
 })(Url || (exports.Url = Url = {}));
+// fahrenheit values below freezing are raised to 32 before sending mode settings
+const FAHRENHEIT_FIELDS = ['devHtf', 'devLtf', 'targetTempF', 'waterTempHighValueF', 'waterTempLowValueF', 'waterTempTargetValueF'];
+// only send flat values: nested objects and empty fields are left out
+const toFormPayload = (values) => Object.fromEntries(Object.entries(values).filter(([, value]) => value !== null && value !== undefined && typeof value !== 'object'));
+const clampFahrenheit = (payload) => {
+    for (const field of FAHRENHEIT_FIELDS) {
+        const value = payload[field];
+        if (typeof value === 'number' && value < 32) {
+            payload[field] = 32;
+        }
+    }
+    return payload;
+};
 class AcInfinityClient {
     constructor(args) {
         const { email, password } = args;
@@ -46,40 +62,68 @@ class AcInfinityClient {
         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 request(url, params) {
+        const response = await this.api.post(url, params);
+        if (response.data.code !== 200) {
+            throw new errors_1.ApiError(response.data.code, response.data.msg);
         }
+        return response.data.data;
     }
     async getControllers() {
-        const response = await this.api.post(Url.GET_CONTROLLERS, {
+        const controllers = await this.request(Url.GET_CONTROLLERS, {
             userId: this.token,
         });
-        return response.data.data.map((device) => types_1.ControllerSchema.parse(device));
+        return controllers.map((device) => types_1.ControllerSchema.parse(device));
+    }
+    async getSharedControllers() {
+        const controllers = await this.request(Url.GET_SHARED_CONTROLLERS, {
+            userId: this.token,
+        });
+        return controllers.map((device) => types_1.ControllerSchema.parse(device));
+    }
+    async getController({ controllerId }) {
+        const controller = await this.request(Url.GET_CONTROLLER, {
+            devId: controllerId,
+        });
+        return types_1.ControllerSchema.parse(controller);
     }
     async getDeviceSettings({ controllerId, port }) {
-        const response = await this.api.post(Url.GET_DEVICE_SETTINGS, {
+        const settings = await this.request(Url.GET_DEVICE_SETTINGS, {
+            devId: controllerId,
+            port,
+        });
+        return types_1.DeviceSettingsSchema.parse(settings);
+    }
+    async setDeviceSettings({ controllerId, port, settings }) {
+        const vendorChanges = (0, types_1.encodeDeviceSettings)(settings);
+        const currentSettings = await this.request(Url.GET_DEVICE_SETTINGS, {
             devId: controllerId,
             port,
         });
-        return types_1.DeviceSettingsSchema.parse(response.data.data);
+        // the name is required, but often not stored in the settings themselves
+        const devName = vendorChanges.devName ?? currentSettings.devName ?? (await this.getDeviceName({ controllerId, port }));
+        const payload = toFormPayload({ ...currentSettings, ...vendorChanges, devName });
+        await this.request(Url.SET_DEVICE_SETTINGS, payload);
+    }
+    async getDeviceName({ controllerId, port }) {
+        const controller = await this.getController({ controllerId });
+        return port === 0 ? controller.name : controller.deviceInfo.ports.find((p) => p.port === port)?.deviceName;
     }
     async getDeviceModeSettings({ controllerId, port }) {
-        const response = await this.api.post(Url.GET_DEVICE_MODE_SETTINGS, {
+        const settings = await this.request(Url.GET_DEVICE_MODE_SETTINGS, {
             devId: controllerId,
             port,
         });
-        return types_1.DeviceModeSettingsSchema.parse(response.data.data);
+        return types_1.DeviceModeSettingsSchema.parse(settings);
     }
     async setDeviceModeSettings({ controllerId, port, settings }) {
-        const rawCurrentSettings = await this.api.post(Url.GET_DEVICE_MODE_SETTINGS, {
+        const vendorChanges = (0, types_1.encodeDeviceModeSettings)(settings);
+        const currentSettings = await this.request(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);
+        const payload = clampFahrenheit(toFormPayload({ ...currentSettings, ...vendorChanges, onlyUpdateSpeed: 0 }));
+        await this.request(Url.SET_DEVICE_MODE_SETTINGS, payload);
     }
     static async build(args) {
         const instance = new AcInfinityClient(args);

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

@@ -1,5 +1,10 @@
 declare class AuthenticationError extends Error {
     constructor(message?: string);
 }
-export { AuthenticationError };
+declare class ApiError extends Error {
+    readonly code: number;
+    readonly msg?: string | undefined;
+    constructor(code: number, msg?: string | undefined);
+}
+export { ApiError, AuthenticationError };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/errors/index.ts"],"names":[],"mappings":"AAAA,cAAM,mBAAoB,SAAQ,KAAK;gBACzB,OAAO,CAAC,EAAE,MAAM;CAQ7B;AAED,OAAO,EAAE,mBAAmB,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/errors/index.ts"],"names":[],"mappings":"AAAA,cAAM,mBAAoB,SAAQ,KAAK;gBACzB,OAAO,CAAC,EAAE,MAAM;CAQ7B;AAED,cAAM,QAAS,SAAQ,KAAK;aAER,IAAI,EAAE,MAAM;aACZ,GAAG,CAAC,EAAE,MAAM;gBADZ,IAAI,EAAE,MAAM,EACZ,GAAG,CAAC,EAAE,MAAM,YAAA;CAS/B;AAED,OAAO,EAAE,QAAQ,EAAE,mBAAmB,EAAE,CAAC"}

package/build/src/errors/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AuthenticationError = void 0;
+exports.AuthenticationError = exports.ApiError = void 0;
 class AuthenticationError extends Error {
     constructor(message) {
         super(message);
@@ -10,3 +10,16 @@ class AuthenticationError extends Error {
     }
 }
 exports.AuthenticationError = AuthenticationError;
+class ApiError extends Error {
+    code;
+    msg;
+    constructor(code, msg) {
+        super(`API request failed [code="${code}", msg="${msg}"]`);
+        this.code = code;
+        this.msg = msg;
+        this.name = this.constructor.name;
+        Error.captureStackTrace(this, this.constructor);
+        Object.setPrototypeOf(this, ApiError.prototype);
+    }
+}
+exports.ApiError = ApiError;

package/build/src/index.d.ts

@@ -1,2 +1,5 @@
 export * from './AcInfinityClient';
+export * from './errors';
+export type { ControllerDeviceInfo, ControllerPort, ControllerSensor } from './types';
+export { ControllerDeviceType, DeviceMode, DeviceType, SensorType, TemperatureUnit } from './types';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,UAAU,CAAC;AACzB,YAAY,EAAE,oBAAoB,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AACtF,OAAO,EAAE,oBAAoB,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC"}

package/build/src/index.js

@@ -14,4 +14,12 @@ 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 });
+exports.TemperatureUnit = exports.SensorType = exports.DeviceType = exports.DeviceMode = exports.ControllerDeviceType = void 0;
 __exportStar(require("./AcInfinityClient"), exports);
+__exportStar(require("./errors"), exports);
+var types_1 = require("./types");
+Object.defineProperty(exports, "ControllerDeviceType", { enumerable: true, get: function () { return types_1.ControllerDeviceType; } });
+Object.defineProperty(exports, "DeviceMode", { enumerable: true, get: function () { return types_1.DeviceMode; } });
+Object.defineProperty(exports, "DeviceType", { enumerable: true, get: function () { return types_1.DeviceType; } });
+Object.defineProperty(exports, "SensorType", { enumerable: true, get: function () { return types_1.SensorType; } });
+Object.defineProperty(exports, "TemperatureUnit", { enumerable: true, get: function () { return types_1.TemperatureUnit; } });

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"}