edilkamin 1.8.0 → 1.10.0

package/dist/esm/src/library.js

@@ -161,6 +161,171 @@ const setPowerOff = (baseURL) =>
  * console.log(response);
  */
 (jwtToken, macAddress) => setPower(baseURL)(jwtToken, macAddress, 0);
+const setPowerLevel = (baseURL) => 
+/**
+ * Sets the manual power level of the device.
+ *
+ * @param {string} jwtToken - The JWT token for authentication.
+ * @param {string} macAddress - The MAC address of the device.
+ * @param {number} level - The power level (1-5).
+ * @returns {Promise<unknown>} - A promise that resolves to the command response.
+ */
+(jwtToken, macAddress, level) => mqttCommand(baseURL)(jwtToken, macAddress, {
+    name: "power_level",
+    value: level,
+});
+const getPowerLevel = (baseURL) => 
+/**
+ * Retrieves the current manual power level of the device.
+ *
+ * @param {string} jwtToken - The JWT token for authentication.
+ * @param {string} macAddress - The MAC address of the device.
+ * @returns {Promise<number>} - A promise that resolves to the power level (1-5).
+ */
+(jwtToken, macAddress) => __awaiter(void 0, void 0, void 0, function* () {
+    const info = yield deviceInfo(baseURL)(jwtToken, macAddress);
+    return info.nvm.user_parameters.manual_power;
+});
+const setFanSpeed = (baseURL) => 
+/**
+ * Sets the speed of a fan by index.
+ *
+ * @param {string} jwtToken - The JWT token for authentication.
+ * @param {string} macAddress - The MAC address of the device.
+ * @param {1 | 2 | 3} fanIndex - The fan index (1, 2, or 3).
+ * @param {number} speed - The fan speed (0-5, 0=auto on some models).
+ * @returns {Promise<unknown>} - A promise that resolves to the command response.
+ */
+(jwtToken, macAddress, fanIndex, speed) => mqttCommand(baseURL)(jwtToken, macAddress, {
+    name: `fan_${fanIndex}_speed`,
+    value: speed,
+});
+const getFanSpeed = (baseURL) => 
+/**
+ * Retrieves the current speed of a fan by index.
+ *
+ * @param {string} jwtToken - The JWT token for authentication.
+ * @param {string} macAddress - The MAC address of the device.
+ * @param {1 | 2 | 3} fanIndex - The fan index (1, 2, or 3).
+ * @returns {Promise<number>} - A promise that resolves to the fan speed.
+ */
+(jwtToken, macAddress, fanIndex) => __awaiter(void 0, void 0, void 0, function* () {
+    const info = yield deviceInfo(baseURL)(jwtToken, macAddress);
+    const fields = {
+        1: info.nvm.user_parameters.fan_1_ventilation,
+        2: info.nvm.user_parameters.fan_2_ventilation,
+        3: info.nvm.user_parameters.fan_3_ventilation,
+    };
+    return fields[fanIndex];
+});
+// Fan speed aliases for convenience
+const setFan1Speed = (baseURL) => (jwtToken, macAddress, speed) => setFanSpeed(baseURL)(jwtToken, macAddress, 1, speed);
+const setFan2Speed = (baseURL) => (jwtToken, macAddress, speed) => setFanSpeed(baseURL)(jwtToken, macAddress, 2, speed);
+const setFan3Speed = (baseURL) => (jwtToken, macAddress, speed) => setFanSpeed(baseURL)(jwtToken, macAddress, 3, speed);
+const getFan1Speed = (baseURL) => (jwtToken, macAddress) => getFanSpeed(baseURL)(jwtToken, macAddress, 1);
+const getFan2Speed = (baseURL) => (jwtToken, macAddress) => getFanSpeed(baseURL)(jwtToken, macAddress, 2);
+const getFan3Speed = (baseURL) => (jwtToken, macAddress) => getFanSpeed(baseURL)(jwtToken, macAddress, 3);
+const setAirkare = (baseURL) => 
+/**
+ * Enables or disables Airkare (air quality) mode.
+ *
+ * @param {string} jwtToken - The JWT token for authentication.
+ * @param {string} macAddress - The MAC address of the device.
+ * @param {boolean} enabled - Whether to enable Airkare mode.
+ * @returns {Promise<unknown>} - A promise that resolves to the command response.
+ */
+(jwtToken, macAddress, enabled) => mqttCommand(baseURL)(jwtToken, macAddress, {
+    name: "airkare_function",
+    value: enabled ? 1 : 0,
+});
+const setRelax = (baseURL) => 
+/**
+ * Enables or disables Relax (comfort) mode.
+ *
+ * @param {string} jwtToken - The JWT token for authentication.
+ * @param {string} macAddress - The MAC address of the device.
+ * @param {boolean} enabled - Whether to enable Relax mode.
+ * @returns {Promise<unknown>} - A promise that resolves to the command response.
+ */
+(jwtToken, macAddress, enabled) => mqttCommand(baseURL)(jwtToken, macAddress, {
+    name: "relax_mode",
+    value: enabled,
+});
+const setStandby = (baseURL) => 
+/**
+ * Enables or disables Standby mode.
+ *
+ * @param {string} jwtToken - The JWT token for authentication.
+ * @param {string} macAddress - The MAC address of the device.
+ * @param {boolean} enabled - Whether to enable Standby mode.
+ * @returns {Promise<unknown>} - A promise that resolves to the command response.
+ */
+(jwtToken, macAddress, enabled) => mqttCommand(baseURL)(jwtToken, macAddress, {
+    name: "standby_mode",
+    value: enabled,
+});
+const getStandby = (baseURL) => 
+/**
+ * Retrieves the current Standby mode status.
+ *
+ * @param {string} jwtToken - The JWT token for authentication.
+ * @param {string} macAddress - The MAC address of the device.
+ * @returns {Promise<boolean>} - A promise that resolves to the standby status.
+ */
+(jwtToken, macAddress) => __awaiter(void 0, void 0, void 0, function* () {
+    const info = yield deviceInfo(baseURL)(jwtToken, macAddress);
+    return info.nvm.user_parameters.is_standby_active;
+});
+const setStandbyTime = (baseURL) => 
+/**
+ * Sets the standby waiting time in minutes.
+ *
+ * @param {string} jwtToken - The JWT token for authentication.
+ * @param {string} macAddress - The MAC address of the device.
+ * @param {number} minutes - The standby waiting time in minutes.
+ * @returns {Promise<unknown>} - A promise that resolves to the command response.
+ */
+(jwtToken, macAddress, minutes) => mqttCommand(baseURL)(jwtToken, macAddress, {
+    name: "standby_time",
+    value: minutes,
+});
+const getStandbyTime = (baseURL) => 
+/**
+ * Retrieves the standby waiting time in minutes.
+ *
+ * @param {string} jwtToken - The JWT token for authentication.
+ * @param {string} macAddress - The MAC address of the device.
+ * @returns {Promise<number>} - A promise that resolves to the standby time in minutes.
+ */
+(jwtToken, macAddress) => __awaiter(void 0, void 0, void 0, function* () {
+    const info = yield deviceInfo(baseURL)(jwtToken, macAddress);
+    return info.nvm.user_parameters.standby_waiting_time;
+});
+const setAuto = (baseURL) => 
+/**
+ * Enables or disables Auto mode for automatic temperature regulation.
+ *
+ * @param {string} jwtToken - The JWT token for authentication.
+ * @param {string} macAddress - The MAC address of the device.
+ * @param {boolean} enabled - Whether to enable Auto mode.
+ * @returns {Promise<unknown>} - A promise that resolves to the command response.
+ */
+(jwtToken, macAddress, enabled) => mqttCommand(baseURL)(jwtToken, macAddress, {
+    name: "auto_mode",
+    value: enabled,
+});
+const getAuto = (baseURL) => 
+/**
+ * Retrieves the current Auto mode status.
+ *
+ * @param {string} jwtToken - The JWT token for authentication.
+ * @param {string} macAddress - The MAC address of the device.
+ * @returns {Promise<boolean>} - A promise that resolves to the auto mode status.
+ */
+(jwtToken, macAddress) => __awaiter(void 0, void 0, void 0, function* () {
+    const info = yield deviceInfo(baseURL)(jwtToken, macAddress);
+    return info.nvm.user_parameters.is_auto;
+});
 const getPower = (baseURL) => 
 /**
  * Retrieves the power status of the device.
@@ -187,29 +352,127 @@ const getEnvironmentTemperature = (baseURL) =>
 });
 const getTargetTemperature = (baseURL) => 
 /**
- * Retrieves the target temperature value set on the device.
+ * Retrieves the target temperature for an environment zone.
  *
  * @param {string} jwtToken - The JWT token for authentication.
  * @param {string} macAddress - The MAC address of the device.
- * @returns {Promise<number>} - A promise that resolves to the target temperature (degree celsius).
+ * @param {1 | 2 | 3} envIndex - The environment zone index (1, 2, or 3).
+ * @returns {Promise<number>} - A promise that resolves to the target temperature (degrees Celsius).
  */
-(jwtToken, macAddress) => __awaiter(void 0, void 0, void 0, function* () {
+(jwtToken, macAddress, envIndex) => __awaiter(void 0, void 0, void 0, function* () {
     const info = yield deviceInfo(baseURL)(jwtToken, macAddress);
-    return info.nvm.user_parameters.enviroment_1_temperature;
+    const fields = {
+        1: info.nvm.user_parameters.enviroment_1_temperature,
+        2: info.nvm.user_parameters.enviroment_2_temperature,
+        3: info.nvm.user_parameters.enviroment_3_temperature,
+    };
+    return fields[envIndex];
 });
 const setTargetTemperature = (baseURL) => 
 /**
- * Sends a command to set the target temperature (degree celsius) of a device.
+ * Sets the target temperature for an environment zone.
  *
  * @param {string} jwtToken - The JWT token for authentication.
  * @param {string} macAddress - The MAC address of the device.
- * @param {number} temperature - The desired target temperature (degree celsius).
- * @returns {Promise<string>} - A promise that resolves to the command response.
+ * @param {1 | 2 | 3} envIndex - The environment zone index (1, 2, or 3).
+ * @param {number} temperature - The desired target temperature (degrees Celsius).
+ * @returns {Promise<unknown>} - A promise that resolves to the command response.
  */
-(jwtToken, macAddress, temperature) => mqttCommand(baseURL)(jwtToken, macAddress, {
-    name: "enviroment_1_temperature",
+(jwtToken, macAddress, envIndex, temperature) => mqttCommand(baseURL)(jwtToken, macAddress, {
+    name: `enviroment_${envIndex}_temperature`,
     value: temperature,
 });
+// Environment temperature aliases for convenience
+const setEnvironment1Temperature = (baseURL) => (jwtToken, macAddress, temperature) => setTargetTemperature(baseURL)(jwtToken, macAddress, 1, temperature);
+const setEnvironment2Temperature = (baseURL) => (jwtToken, macAddress, temperature) => setTargetTemperature(baseURL)(jwtToken, macAddress, 2, temperature);
+const setEnvironment3Temperature = (baseURL) => (jwtToken, macAddress, temperature) => setTargetTemperature(baseURL)(jwtToken, macAddress, 3, temperature);
+const getEnvironment1Temperature = (baseURL) => (jwtToken, macAddress) => getTargetTemperature(baseURL)(jwtToken, macAddress, 1);
+const getEnvironment2Temperature = (baseURL) => (jwtToken, macAddress) => getTargetTemperature(baseURL)(jwtToken, macAddress, 2);
+const getEnvironment3Temperature = (baseURL) => (jwtToken, macAddress) => getTargetTemperature(baseURL)(jwtToken, macAddress, 3);
+const setMeasureUnit = (baseURL) => 
+/**
+ * Sets the temperature measurement unit (Celsius or Fahrenheit).
+ *
+ * @param {string} jwtToken - The JWT token for authentication.
+ * @param {string} macAddress - The MAC address of the device.
+ * @param {boolean} isFahrenheit - true for Fahrenheit, false for Celsius.
+ * @returns {Promise<unknown>} - A promise that resolves to the command response.
+ */
+(jwtToken, macAddress, isFahrenheit) => mqttCommand(baseURL)(jwtToken, macAddress, {
+    name: "measure_unit",
+    value: isFahrenheit,
+});
+const getMeasureUnit = (baseURL) => 
+/**
+ * Retrieves the current temperature measurement unit setting.
+ *
+ * @param {string} jwtToken - The JWT token for authentication.
+ * @param {string} macAddress - The MAC address of the device.
+ * @returns {Promise<boolean>} - A promise that resolves to true if Fahrenheit, false if Celsius.
+ */
+(jwtToken, macAddress) => __awaiter(void 0, void 0, void 0, function* () {
+    const info = yield deviceInfo(baseURL)(jwtToken, macAddress);
+    return info.nvm.user_parameters.is_fahrenheit;
+});
+const setLanguage = (baseURL) => 
+/**
+ * Sets the display language of the device.
+ *
+ * Language codes:
+ * 0=Italian, 1=French, 2=English, 3=Spanish, 4=Portuguese,
+ * 5=Danish, 6=Dutch, 7=German, 8=Hungarian, 9=Polish
+ *
+ * @param {string} jwtToken - The JWT token for authentication.
+ * @param {string} macAddress - The MAC address of the device.
+ * @param {number} languageCode - The language code (0-9).
+ * @returns {Promise<unknown>} - A promise that resolves to the command response.
+ */
+(jwtToken, macAddress, languageCode) => mqttCommand(baseURL)(jwtToken, macAddress, {
+    name: "language",
+    value: languageCode,
+});
+const getLanguage = (baseURL) => 
+/**
+ * Retrieves the current display language setting.
+ *
+ * Language codes:
+ * 0=Italian, 1=French, 2=English, 3=Spanish, 4=Portuguese,
+ * 5=Danish, 6=Dutch, 7=German, 8=Hungarian, 9=Polish
+ *
+ * @param {string} jwtToken - The JWT token for authentication.
+ * @param {string} macAddress - The MAC address of the device.
+ * @returns {Promise<number>} - A promise that resolves to the language code (0-9).
+ */
+(jwtToken, macAddress) => __awaiter(void 0, void 0, void 0, function* () {
+    const info = yield deviceInfo(baseURL)(jwtToken, macAddress);
+    return info.nvm.user_parameters.language;
+});
+const getPelletInReserve = (baseURL) => 
+/**
+ * Retrieves the pellet reserve status.
+ * Returns true if pellet level is low (in reserve), false if pellet level is ok.
+ *
+ * @param {string} jwtToken - The JWT token for authentication.
+ * @param {string} macAddress - The MAC address of the device.
+ * @returns {Promise<boolean>} - A promise that resolves to the pellet reserve status.
+ */
+(jwtToken, macAddress) => __awaiter(void 0, void 0, void 0, function* () {
+    const info = yield deviceInfo(baseURL)(jwtToken, macAddress);
+    return info.status.flags.is_pellet_in_reserve;
+});
+const getPelletAutonomyTime = (baseURL) => 
+/**
+ * Retrieves the estimated pellet autonomy time.
+ * Represents the estimated time remaining with current pellet level.
+ *
+ * @param {string} jwtToken - The JWT token for authentication.
+ * @param {string} macAddress - The MAC address of the device.
+ * @returns {Promise<number>} - A promise that resolves to the autonomy time (likely in minutes or hours).
+ */
+(jwtToken, macAddress) => __awaiter(void 0, void 0, void 0, function* () {
+    const info = yield deviceInfo(baseURL)(jwtToken, macAddress);
+    return info.status.pellet.autonomy_time;
+});
 const registerDevice = (baseURL) => 
 /**
  * Registers a device with the user's account.
@@ -276,8 +539,38 @@ const configure = (baseURL = API_URL) => ({
     setPowerOff: setPowerOff(baseURL),
     setPowerOn: setPowerOn(baseURL),
     getPower: getPower(baseURL),
+    setPowerLevel: setPowerLevel(baseURL),
+    getPowerLevel: getPowerLevel(baseURL),
+    setFanSpeed: setFanSpeed(baseURL),
+    getFanSpeed: getFanSpeed(baseURL),
+    setFan1Speed: setFan1Speed(baseURL),
+    setFan2Speed: setFan2Speed(baseURL),
+    setFan3Speed: setFan3Speed(baseURL),
+    getFan1Speed: getFan1Speed(baseURL),
+    getFan2Speed: getFan2Speed(baseURL),
+    getFan3Speed: getFan3Speed(baseURL),
+    setAirkare: setAirkare(baseURL),
+    setRelax: setRelax(baseURL),
+    setStandby: setStandby(baseURL),
+    getStandby: getStandby(baseURL),
+    setStandbyTime: setStandbyTime(baseURL),
+    getStandbyTime: getStandbyTime(baseURL),
+    setAuto: setAuto(baseURL),
+    getAuto: getAuto(baseURL),
     getEnvironmentTemperature: getEnvironmentTemperature(baseURL),
     getTargetTemperature: getTargetTemperature(baseURL),
     setTargetTemperature: setTargetTemperature(baseURL),
+    setEnvironment1Temperature: setEnvironment1Temperature(baseURL),
+    getEnvironment1Temperature: getEnvironment1Temperature(baseURL),
+    setEnvironment2Temperature: setEnvironment2Temperature(baseURL),
+    getEnvironment2Temperature: getEnvironment2Temperature(baseURL),
+    setEnvironment3Temperature: setEnvironment3Temperature(baseURL),
+    getEnvironment3Temperature: getEnvironment3Temperature(baseURL),
+    setMeasureUnit: setMeasureUnit(baseURL),
+    getMeasureUnit: getMeasureUnit(baseURL),
+    setLanguage: setLanguage(baseURL),
+    getLanguage: getLanguage(baseURL),
+    getPelletInReserve: getPelletInReserve(baseURL),
+    getPelletAutonomyTime: getPelletAutonomyTime(baseURL),
 });
 export { configure, configureAmplify, createAuthService, getSession, headers, signIn, };

package/dist/esm/src/library.test.js

@@ -182,9 +182,39 @@ describe("library", () => {
             "setPowerOff",
             "setPowerOn",
             "getPower",
+            "setPowerLevel",
+            "getPowerLevel",
+            "setFanSpeed",
+            "getFanSpeed",
+            "setFan1Speed",
+            "setFan2Speed",
+            "setFan3Speed",
+            "getFan1Speed",
+            "getFan2Speed",
+            "getFan3Speed",
+            "setAirkare",
+            "setRelax",
+            "setStandby",
+            "getStandby",
+            "setStandbyTime",
+            "getStandbyTime",
+            "setAuto",
+            "getAuto",
             "getEnvironmentTemperature",
             "getTargetTemperature",
             "setTargetTemperature",
+            "setEnvironment1Temperature",
+            "getEnvironment1Temperature",
+            "setEnvironment2Temperature",
+            "getEnvironment2Temperature",
+            "setEnvironment3Temperature",
+            "getEnvironment3Temperature",
+            "setMeasureUnit",
+            "getMeasureUnit",
+            "setLanguage",
+            "getLanguage",
+            "getPelletInReserve",
+            "getPelletAutonomyTime",
         ];
         it("should create API methods with the correct baseURL", () => __awaiter(void 0, void 0, void 0, function* () {
             const baseURL = "https://example.com/api/";
@@ -215,10 +245,27 @@ describe("library", () => {
                 temperatures: {
                     enviroment: 19,
                 },
+                flags: {
+                    is_pellet_in_reserve: false,
+                },
+                pellet: {
+                    autonomy_time: 180,
+                },
             },
             nvm: {
                 user_parameters: {
                     enviroment_1_temperature: 22,
+                    enviroment_2_temperature: 18,
+                    enviroment_3_temperature: 20,
+                    manual_power: 3,
+                    fan_1_ventilation: 2,
+                    fan_2_ventilation: 3,
+                    fan_3_ventilation: 4,
+                    is_standby_active: true,
+                    standby_waiting_time: 30,
+                    is_auto: true,
+                    is_fahrenheit: false,
+                    language: 2,
                 },
             },
         };
@@ -274,6 +321,26 @@ describe("library", () => {
                 call: (api, token, mac) => api.getPower(token, mac),
                 expectedResult: true,
             },
+            {
+                method: "getPowerLevel",
+                call: (api, token, mac) => api.getPowerLevel(token, mac),
+                expectedResult: 3,
+            },
+            {
+                method: "getFan1Speed",
+                call: (api, token, mac) => api.getFan1Speed(token, mac),
+                expectedResult: 2,
+            },
+            {
+                method: "getFan2Speed",
+                call: (api, token, mac) => api.getFan2Speed(token, mac),
+                expectedResult: 3,
+            },
+            {
+                method: "getFan3Speed",
+                call: (api, token, mac) => api.getFan3Speed(token, mac),
+                expectedResult: 4,
+            },
             {
                 method: "getEnvironmentTemperature",
                 call: (api, token, mac) => api.getEnvironmentTemperature(token, mac),
@@ -281,9 +348,54 @@ describe("library", () => {
             },
             {
                 method: "getTargetTemperature",
-                call: (api, token, mac) => api.getTargetTemperature(token, mac),
+                call: (api, token, mac) => api.getTargetTemperature(token, mac, 1),
                 expectedResult: 22,
             },
+            {
+                method: "getStandby",
+                call: (api, token, mac) => api.getStandby(token, mac),
+                expectedResult: true,
+            },
+            {
+                method: "getStandbyTime",
+                call: (api, token, mac) => api.getStandbyTime(token, mac),
+                expectedResult: 30,
+            },
+            {
+                method: "getAuto",
+                call: (api, token, mac) => api.getAuto(token, mac),
+                expectedResult: true,
+            },
+            {
+                method: "getEnvironment2Temperature",
+                call: (api, token, mac) => api.getEnvironment2Temperature(token, mac),
+                expectedResult: 18,
+            },
+            {
+                method: "getEnvironment3Temperature",
+                call: (api, token, mac) => api.getEnvironment3Temperature(token, mac),
+                expectedResult: 20,
+            },
+            {
+                method: "getMeasureUnit",
+                call: (api, token, mac) => api.getMeasureUnit(token, mac),
+                expectedResult: false,
+            },
+            {
+                method: "getLanguage",
+                call: (api, token, mac) => api.getLanguage(token, mac),
+                expectedResult: 2,
+            },
+            {
+                method: "getPelletInReserve",
+                call: (api, token, mac) => api.getPelletInReserve(token, mac),
+                expectedResult: false,
+            },
+            {
+                method: "getPelletAutonomyTime",
+                call: (api, token, mac) => api.getPelletAutonomyTime(token, mac),
+                expectedResult: 180,
+            },
         ];
         getterTests.forEach(({ method, call, expectedResult }) => {
             it(`should call fetch and return the correct value for ${method}`, () => __awaiter(void 0, void 0, void 0, function* () {
@@ -301,14 +413,78 @@ describe("library", () => {
         });
         // Setter tests
         const setterTests = [
+            {
+                method: "setPowerLevel",
+                call: (api, token, mac, value) => api.setPowerLevel(token, mac, value),
+                payload: {
+                    name: "power_level",
+                    value: 4,
+                },
+            },
+            {
+                method: "setFan1Speed",
+                call: (api, token, mac, value) => api.setFan1Speed(token, mac, value),
+                payload: {
+                    name: "fan_1_speed",
+                    value: 3,
+                },
+            },
+            {
+                method: "setFan2Speed",
+                call: (api, token, mac, value) => api.setFan2Speed(token, mac, value),
+                payload: {
+                    name: "fan_2_speed",
+                    value: 4,
+                },
+            },
+            {
+                method: "setFan3Speed",
+                call: (api, token, mac, value) => api.setFan3Speed(token, mac, value),
+                payload: {
+                    name: "fan_3_speed",
+                    value: 5,
+                },
+            },
             {
                 method: "setTargetTemperature",
-                call: (api, token, mac, value) => api.setTargetTemperature(token, mac, value),
+                call: (api, token, mac, value) => api.setTargetTemperature(token, mac, 1, value),
                 payload: {
                     name: "enviroment_1_temperature",
                     value: 20,
                 },
             },
+            {
+                method: "setStandbyTime",
+                call: (api, token, mac, value) => api.setStandbyTime(token, mac, value),
+                payload: {
+                    name: "standby_time",
+                    value: 45,
+                },
+            },
+            {
+                method: "setEnvironment2Temperature",
+                call: (api, token, mac, value) => api.setEnvironment2Temperature(token, mac, value),
+                payload: {
+                    name: "enviroment_2_temperature",
+                    value: 21,
+                },
+            },
+            {
+                method: "setEnvironment3Temperature",
+                call: (api, token, mac, value) => api.setEnvironment3Temperature(token, mac, value),
+                payload: {
+                    name: "enviroment_3_temperature",
+                    value: 23,
+                },
+            },
+            {
+                method: "setLanguage",
+                call: (api, token, mac, value) => api.setLanguage(token, mac, value),
+                payload: {
+                    name: "language",
+                    value: 2,
+                },
+            },
         ];
         setterTests.forEach(({ method, call, payload }) => {
             it(`should call fetch and send the correct payload for ${method}`, () => __awaiter(void 0, void 0, void 0, function* () {
@@ -327,6 +503,69 @@ describe("library", () => {
                 });
             }));
         });
+        // Boolean setter tests (for mode controls)
+        const booleanSetterTests = [
+            {
+                method: "setAirkare",
+                call: (api, token, mac, enabled) => api.setAirkare(token, mac, enabled),
+                truePayload: { name: "airkare_function", value: 1 },
+                falsePayload: { name: "airkare_function", value: 0 },
+            },
+            {
+                method: "setRelax",
+                call: (api, token, mac, enabled) => api.setRelax(token, mac, enabled),
+                truePayload: { name: "relax_mode", value: true },
+                falsePayload: { name: "relax_mode", value: false },
+            },
+            {
+                method: "setStandby",
+                call: (api, token, mac, enabled) => api.setStandby(token, mac, enabled),
+                truePayload: { name: "standby_mode", value: true },
+                falsePayload: { name: "standby_mode", value: false },
+            },
+            {
+                method: "setAuto",
+                call: (api, token, mac, enabled) => api.setAuto(token, mac, enabled),
+                truePayload: { name: "auto_mode", value: true },
+                falsePayload: { name: "auto_mode", value: false },
+            },
+            {
+                method: "setMeasureUnit",
+                call: (api, token, mac, enabled) => api.setMeasureUnit(token, mac, enabled),
+                truePayload: { name: "measure_unit", value: true },
+                falsePayload: { name: "measure_unit", value: false },
+            },
+        ];
+        booleanSetterTests.forEach(({ method, call, truePayload, falsePayload }) => {
+            it(`should call fetch with correct payload for ${method}(true)`, () => __awaiter(void 0, void 0, void 0, function* () {
+                fetchStub.resolves(mockResponse({ success: true }));
+                const api = configure("https://example.com/api/");
+                yield call(api, expectedToken, "mockMacAddress", true);
+                assert.ok(fetchStub.calledOnce);
+                assert.deepEqual(fetchStub.firstCall.args[1], {
+                    method: "PUT",
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${expectedToken}`,
+                    },
+                    body: JSON.stringify(Object.assign({ mac_address: "mockMacAddress" }, truePayload)),
+                });
+            }));
+            it(`should call fetch with correct payload for ${method}(false)`, () => __awaiter(void 0, void 0, void 0, function* () {
+                fetchStub.resolves(mockResponse({ success: true }));
+                const api = configure("https://example.com/api/");
+                yield call(api, expectedToken, "mockMacAddress", false);
+                assert.ok(fetchStub.calledOnce);
+                assert.deepEqual(fetchStub.firstCall.args[1], {
+                    method: "PUT",
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${expectedToken}`,
+                    },
+                    body: JSON.stringify(Object.assign({ mac_address: "mockMacAddress" }, falsePayload)),
+                });
+            }));
+        });
     });
     describe("registerDevice", () => {
         it("should call POST /device with correct payload", () => __awaiter(void 0, void 0, void 0, function* () {
@@ -512,9 +751,40 @@ describe("library", () => {
             };
             fetchStub.resolves(mockResponse(mockResponseData));
             const api = configure("https://example.com/api/");
-            const result = yield api.getTargetTemperature(expectedToken, "mockMacAddress");
+            const result = yield api.getTargetTemperature(expectedToken, "mockMacAddress", 1);
             assert.equal(result, 22);
         }));
+        it("should work with getPelletInReserve on compressed response", () => __awaiter(void 0, void 0, void 0, function* () {
+            const statusData = {
+                commands: { power: true },
+                temperatures: { enviroment: 19 },
+                flags: { is_pellet_in_reserve: true },
+                pellet: { autonomy_time: 120 },
+            };
+            const mockResponseData = {
+                status: createGzippedBuffer(statusData),
+                nvm: { user_parameters: { enviroment_1_temperature: 22 } },
+            };
+            fetchStub.resolves(mockResponse(mockResponseData));
+            const api = configure("https://example.com/api/");
+            const result = yield api.getPelletInReserve(expectedToken, "mockMacAddress");
+            assert.equal(result, true);
+        }));
+        it("should work with getPelletAutonomyTime on response", () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockResponseData = {
+                status: {
+                    commands: { power: true },
+                    temperatures: { enviroment: 19 },
+                    flags: { is_pellet_in_reserve: false },
+                    pellet: { autonomy_time: 240 },
+                },
+                nvm: { user_parameters: { enviroment_1_temperature: 22 } },
+            };
+            fetchStub.resolves(mockResponse(mockResponseData));
+            const api = configure("https://example.com/api/");
+            const result = yield api.getPelletAutonomyTime(expectedToken, "mockMacAddress");
+            assert.equal(result, 240);
+        }));
     });
     describe("Error Handling", () => {
         const errorTests = [