@jakobgoerke/ac-infinity-client 0.1.1 → 0.3.0

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,IAAI,IAAI;IACR,UAAU,IAAI;IACd,UAAU,IAAI;IACd,YAAY,IAAI;IAChB,MAAM,IAAI;IACV,aAAa,IAAI;IACjB,GAAG,IAAI;IACP,IAAI,IAAI;IACR,UAAU,IAAI;IACd,aAAa,KAAK;IAClB,YAAY,KAAK;IACjB,YAAY,KAAK;CAClB;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;AAED,oBAAY,eAAe;IACzB,UAAU,IAAI;IACd,OAAO,IAAI;CACZ;AAkDD,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuG9B,CAAC;AAEJ,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAuDnC,4EAA4E;;IAE5E,2BAA2B;;;;;IAK3B,2BAA2B;;;;;IAK3B,gDAAgD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAchD,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAOnB,CAAC;AAEJ,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AACvE,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;AA6B/E,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqExC,CAAC;AAEL,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCpC,CAAC;AAEL,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC;AACxF,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,yBAAyB,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAE9G;AAED,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,qBAAqB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAElG"}

package/build/src/types/Device.js

@@ -1,15 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DeviceModeSettingsSchema = exports.DeviceSettingsSchema = exports.DeviceMode = exports.DeviceType = void 0;
+exports.DeviceSettingsChangesSchema = exports.DeviceModeSettingsChangesSchema = exports.DeviceModeSettingsSchema = exports.DeviceSettingsSchema = exports.TemperatureUnit = exports.DeviceMode = exports.DeviceType = void 0;
+exports.encodeDeviceModeSettings = encodeDeviceModeSettings;
+exports.encodeDeviceSettings = encodeDeviceSettings;
 const zod_1 = require("zod");
 var DeviceType;
 (function (DeviceType) {
+    DeviceType[DeviceType["NONE"] = 0] = "NONE";
     DeviceType[DeviceType["GROW_LIGHT"] = 1] = "GROW_LIGHT";
     DeviceType[DeviceType["HUMIDIFIER"] = 2] = "HUMIDIFIER";
     DeviceType[DeviceType["DEHUMIDIFIER"] = 3] = "DEHUMIDIFIER";
     DeviceType[DeviceType["HEATER"] = 4] = "HEATER";
     DeviceType[DeviceType["AIR_CONDITION"] = 5] = "AIR_CONDITION";
     DeviceType[DeviceType["FAN"] = 6] = "FAN";
+    DeviceType[DeviceType["PUMP"] = 8] = "PUMP";
+    DeviceType[DeviceType["WATER_PUMP"] = 9] = "WATER_PUMP";
+    DeviceType[DeviceType["CO2_GENERATOR"] = 10] = "CO2_GENERATOR";
+    DeviceType[DeviceType["WATER_COOLER"] = 13] = "WATER_COOLER";
+    DeviceType[DeviceType["WATER_HEATER"] = 14] = "WATER_HEATER";
 })(DeviceType || (exports.DeviceType = DeviceType = {}));
 var DeviceMode;
 (function (DeviceMode) {
@@ -22,5 +30,368 @@ 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({});
+var TemperatureUnit;
+(function (TemperatureUnit) {
+    TemperatureUnit[TemperatureUnit["FAHRENHEIT"] = 0] = "FAHRENHEIT";
+    TemperatureUnit[TemperatureUnit["CELSIUS"] = 1] = "CELSIUS";
+})(TemperatureUnit || (exports.TemperatureUnit = TemperatureUnit = {}));
+// the vendor uses this value for a schedule boundary that is not set
+const SCHEDULE_DISABLED = 65535;
+const celsiusToFahrenheit = (celsius) => Math.round((celsius * 9) / 5 + 32);
+const fahrenheitToCelsius = (fahrenheit) => Math.round(((fahrenheit - 32) * 5) / 9);
+const decodeScheduleTime = (minutes) => (minutes === SCHEDULE_DISABLED ? null : minutes);
+const encodeScheduleTime = (minutes) => (minutes === null ? SCHEDULE_DISABLED : minutes);
+const encodeFlag = (value) => (value === undefined ? undefined : Number(value));
+const encodeTemperature = (value) => {
+    if (value?.celsius !== undefined) {
+        return { celsius: value.celsius, fahrenheit: celsiusToFahrenheit(value.celsius) };
+    }
+    if (value?.fahrenheit !== undefined) {
+        return { celsius: fahrenheitToCelsius(value.fahrenheit), fahrenheit: value.fahrenheit };
+    }
+    return { celsius: undefined, fahrenheit: undefined };
+};
+const compact = (value) => Object.fromEntries(Object.entries(value).filter(([, v]) => v !== undefined));
+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.enum(TemperatureUnit),
+    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),
+    name: v.devName,
+    temperatureUnit: v.devCompany,
+    brightness: v.devLight,
+    backlight: v.backlightSwitch !== 0,
+    calibration: {
+        temperatureC: v.devCt,
+        temperatureF: v.devCth,
+        humidity: v.devCh,
+        leafTemperatureC: v.vpdCt,
+        leafTemperatureF: v.vpdCth,
+    },
+    transition: {
+        temperatureC: v.devTt,
+        temperatureF: v.devTth,
+        humidity: v.devTh,
+        vpd: v.vpdTransition,
+    },
+    buffer: {
+        enabled: v.isFlag !== 0,
+        temperatureC: v.devBt,
+        temperatureF: v.devBth,
+        humidity: v.devBh,
+        vpd: v.devBvpd,
+    },
+}));
+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),
+    /** seconds left until the current timer, cycle or schedule step switches */
+    remainingTime: v.surplus,
+    /** durations in seconds */
+    timer: {
+        toOn: v.acitveTimerOn,
+        toOff: v.acitveTimerOff,
+    },
+    /** durations in seconds */
+    cycle: {
+        on: v.activeCycleOn,
+        off: v.activeCycleOff,
+    },
+    /** minutes after midnight, null when not set */
+    schedule: {
+        start: decodeScheduleTime(v.schedStartTime),
+        end: decodeScheduleTime(v.schedEndtTime),
+    },
+    auto: {
+        targetMode: v.settingMode !== 0,
+        highTemperature: { enabled: v.activeHt !== 0, celsius: v.devHt, fahrenheit: v.devHtf },
+        lowTemperature: { enabled: v.activeLt !== 0, celsius: v.devLt, fahrenheit: v.devLtf },
+        highHumidity: { enabled: v.activeHh !== 0, value: v.devHh },
+        lowHumidity: { enabled: v.activeLh !== 0, value: v.devLh },
+        targetTemperature: { enabled: v.targetTSwitch !== 0, celsius: v.targetTemp, fahrenheit: v.targetTempF },
+        targetHumidity: { enabled: v.targetHumiSwitch !== 0, value: v.targetHumi },
+    },
+    /** values in kPa */
+    vpd: {
+        targetMode: v.vpdSettingMode !== 0,
+        high: { enabled: v.activeHtVpd !== 0, value: v.activeHtVpdNums / 10 },
+        low: { enabled: v.activeLtVpd !== 0, value: v.activeLtVpdNums / 10 },
+        target: { enabled: v.targetVpdSwitch !== 0, value: v.targetVpd / 10 },
+    },
+}));
+const LevelSchema = zod_1.z.number().int().min(0).max(10);
+const DurationSchema = zod_1.z.number().int().nonnegative();
+const ScheduleTimeSchema = zod_1.z.number().int().min(0).max(1439).nullable();
+const TemperatureTriggerChangesSchema = zod_1.z
+    .object({
+    enabled: zod_1.z.boolean(),
+    celsius: zod_1.z.number().int().min(0).max(90),
+    fahrenheit: zod_1.z.number().int().min(32).max(194),
+})
+    .partial()
+    .refine((v) => v.celsius === undefined || v.fahrenheit === undefined, { message: 'Provide either celsius or fahrenheit, not both' });
+const HumidityTriggerChangesSchema = zod_1.z
+    .object({
+    enabled: zod_1.z.boolean(),
+    value: zod_1.z.number().int().min(0).max(100),
+})
+    .partial();
+const VpdTriggerChangesSchema = zod_1.z
+    .object({
+    enabled: zod_1.z.boolean(),
+    value: zod_1.z.number().min(0).max(9.9),
+})
+    .partial();
+exports.DeviceModeSettingsChangesSchema = zod_1.z
+    .object({
+    mode: zod_1.z.enum(DeviceMode),
+    levelWhileOn: LevelSchema,
+    levelWhileOff: LevelSchema,
+    timer: zod_1.z.object({ toOn: DurationSchema, toOff: DurationSchema }).partial(),
+    cycle: zod_1.z.object({ on: DurationSchema, off: DurationSchema }).partial(),
+    schedule: zod_1.z.object({ start: ScheduleTimeSchema, end: ScheduleTimeSchema }).partial(),
+    auto: zod_1.z
+        .object({
+        targetMode: zod_1.z.boolean(),
+        highTemperature: TemperatureTriggerChangesSchema,
+        lowTemperature: TemperatureTriggerChangesSchema,
+        highHumidity: HumidityTriggerChangesSchema,
+        lowHumidity: HumidityTriggerChangesSchema,
+        targetTemperature: TemperatureTriggerChangesSchema,
+        targetHumidity: HumidityTriggerChangesSchema,
+    })
+        .partial(),
+    vpd: zod_1.z
+        .object({
+        targetMode: zod_1.z.boolean(),
+        high: VpdTriggerChangesSchema,
+        low: VpdTriggerChangesSchema,
+        target: VpdTriggerChangesSchema,
+    })
+        .partial(),
+})
+    .partial()
+    .transform(({ mode, levelWhileOn, levelWhileOff, timer, cycle, schedule, auto, vpd }) => {
+    const highTemperature = encodeTemperature(auto?.highTemperature);
+    const lowTemperature = encodeTemperature(auto?.lowTemperature);
+    const targetTemperature = encodeTemperature(auto?.targetTemperature);
+    const encodeVpd = (value) => (value === undefined ? undefined : Math.round(value * 10));
+    return compact({
+        atType: mode,
+        onSpead: levelWhileOn,
+        offSpead: levelWhileOff,
+        acitveTimerOn: timer?.toOn,
+        acitveTimerOff: timer?.toOff,
+        activeCycleOn: cycle?.on,
+        activeCycleOff: cycle?.off,
+        schedStartTime: encodeScheduleTime(schedule?.start),
+        schedEndtTime: encodeScheduleTime(schedule?.end),
+        settingMode: encodeFlag(auto?.targetMode),
+        activeHt: encodeFlag(auto?.highTemperature?.enabled),
+        devHt: highTemperature.celsius,
+        devHtf: highTemperature.fahrenheit,
+        activeLt: encodeFlag(auto?.lowTemperature?.enabled),
+        devLt: lowTemperature.celsius,
+        devLtf: lowTemperature.fahrenheit,
+        activeHh: encodeFlag(auto?.highHumidity?.enabled),
+        devHh: auto?.highHumidity?.value,
+        activeLh: encodeFlag(auto?.lowHumidity?.enabled),
+        devLh: auto?.lowHumidity?.value,
+        targetTSwitch: encodeFlag(auto?.targetTemperature?.enabled),
+        targetTemp: targetTemperature.celsius,
+        targetTempF: targetTemperature.fahrenheit,
+        targetHumiSwitch: encodeFlag(auto?.targetHumidity?.enabled),
+        targetHumi: auto?.targetHumidity?.value,
+        vpdSettingMode: encodeFlag(vpd?.targetMode),
+        activeHtVpd: encodeFlag(vpd?.high?.enabled),
+        activeHtVpdNums: encodeVpd(vpd?.high?.value),
+        activeLtVpd: encodeFlag(vpd?.low?.enabled),
+        activeLtVpdNums: encodeVpd(vpd?.low?.value),
+        targetVpdSwitch: encodeFlag(vpd?.target?.enabled),
+        targetVpd: encodeVpd(vpd?.target?.value),
+    });
+});
+exports.DeviceSettingsChangesSchema = zod_1.z
+    .object({
+    name: zod_1.z.string().min(1),
+    temperatureUnit: zod_1.z.enum(TemperatureUnit),
+    brightness: zod_1.z.number().int().nonnegative(),
+    backlight: zod_1.z.boolean(),
+    calibration: zod_1.z
+        .object({
+        temperatureC: zod_1.z.number().int(),
+        temperatureF: zod_1.z.number().int(),
+        humidity: zod_1.z.number().int(),
+    })
+        .partial()
+        .refine((v) => v.temperatureC === undefined || v.temperatureF === undefined, {
+        message: 'Provide either temperatureC or temperatureF, not both',
+    }),
+})
+    .partial()
+    .transform(({ name, temperatureUnit, brightness, backlight, calibration }) => {
+    // the fahrenheit calibration is kept at twice the celsius one
+    const calibrationC = calibration?.temperatureF !== undefined ? Math.trunc(calibration.temperatureF / 2) : calibration?.temperatureC;
+    const calibrationF = calibration?.temperatureC !== undefined ? calibration.temperatureC * 2 : calibration?.temperatureF;
+    return compact({
+        devName: name,
+        devCompany: temperatureUnit,
+        devLight: brightness,
+        backlightSwitch: encodeFlag(backlight),
+        devCt: calibrationC,
+        devCth: calibrationF,
+        devCh: calibration?.humidity,
+    });
+});
+function encodeDeviceModeSettings(settings) {
+    return exports.DeviceModeSettingsChangesSchema.parse(settings);
+}
+function encodeDeviceSettings(settings) {
+    return exports.DeviceSettingsChangesSchema.parse(settings);
+}

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, ControllerSensor } from './Controller';
+export { ControllerDeviceType, ControllerSchema, SensorType } from './Controller';
+export type { DeviceModeSettings, DeviceModeSettingsChanges, DeviceModeSettingsInput, DeviceSettings, DeviceSettingsChanges, DeviceSettingsInput, } from './Device';
+export { DeviceMode, DeviceModeSettingsChangesSchema, DeviceModeSettingsSchema, DeviceSettingsChangesSchema, DeviceSettingsSchema, DeviceType, encodeDeviceModeSettings, encodeDeviceSettings, TemperatureUnit, } 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,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACvG,OAAO,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAClF,YAAY,EACV,kBAAkB,EAClB,yBAAyB,EACzB,uBAAuB,EACvB,cAAc,EACd,qBAAqB,EACrB,mBAAmB,GACpB,MAAM,UAAU,CAAC;AAClB,OAAO,EACL,UAAU,EACV,+BAA+B,EAC/B,wBAAwB,EACxB,2BAA2B,EAC3B,oBAAoB,EACpB,UAAU,EACV,wBAAwB,EACxB,oBAAoB,EACpB,eAAe,GAChB,MAAM,UAAU,CAAC;AAClB,YAAY,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AACnC,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC"}

package/build/src/types/index.js

@@ -1,19 +1,19 @@
 "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.TemperatureUnit = exports.encodeDeviceSettings = exports.encodeDeviceModeSettings = exports.DeviceType = exports.DeviceSettingsSchema = exports.DeviceSettingsChangesSchema = exports.DeviceModeSettingsSchema = exports.DeviceModeSettingsChangesSchema = exports.DeviceMode = exports.SensorType = 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; } });
+Object.defineProperty(exports, "SensorType", { enumerable: true, get: function () { return Controller_1.SensorType; } });
+var Device_1 = require("./Device");
+Object.defineProperty(exports, "DeviceMode", { enumerable: true, get: function () { return Device_1.DeviceMode; } });
+Object.defineProperty(exports, "DeviceModeSettingsChangesSchema", { enumerable: true, get: function () { return Device_1.DeviceModeSettingsChangesSchema; } });
+Object.defineProperty(exports, "DeviceModeSettingsSchema", { enumerable: true, get: function () { return Device_1.DeviceModeSettingsSchema; } });
+Object.defineProperty(exports, "DeviceSettingsChangesSchema", { enumerable: true, get: function () { return Device_1.DeviceSettingsChangesSchema; } });
+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; } });
+Object.defineProperty(exports, "encodeDeviceSettings", { enumerable: true, get: function () { return Device_1.encodeDeviceSettings; } });
+Object.defineProperty(exports, "TemperatureUnit", { enumerable: true, get: function () { return Device_1.TemperatureUnit; } });
+var User_1 = require("./User");
+Object.defineProperty(exports, "UserSchema", { enumerable: true, get: function () { return User_1.UserSchema; } });

package/package.json

@@ -1,32 +1,41 @@
 {
   "name": "@jakobgoerke/ac-infinity-client",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "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.20.0",
+    "zod": "4.6.7"
+  },
   "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.6.2",
+    "@jest/globals": "30.5.2",
+    "@tsconfig/node24": "24.0.5",
+    "@types/jest": "30.0.0",
+    "@types/node": "24.19.2",
+    "jest": "30.5.2",
+    "rimraf": "6.1.3",
+    "ts-jest": "29.4.15",
+    "ts-node": "10.9.2",
+    "typescript": "6.0.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",
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
   }
-}
+}