edilkamin 1.7.4 → 1.9.0

package/.github/dependabot.yml

@@ -11,7 +11,11 @@ updates:
     open-pull-requests-limit: 5
     commit-message:
       prefix: ":arrow_up:"
-
+    # Ignore non-LTS Node.js versions for @types/node
+    # Update this when bumping to the next LTS (e.g., 26.x -> ignore 27.x)
+    ignore:
+      - dependency-name: "@types/node"
+        versions: ["25.x"]
   # GitHub Actions dependencies
   - package-ecosystem: "github-actions"
     directory: "/"

package/README.md

@@ -115,12 +115,96 @@ const legacyApi = configure(OLD_API_URL);
 
 > **Note**: The legacy API uses AWS API Gateway and may be deprecated in the future.
 
+## Bluetooth Device Discovery
+
+For automatic device discovery in web browsers, use the `edilkamin/bluetooth` subpath export.
+
+### Quick Example (Web)
+
+```javascript
+import { scanForDevices } from "edilkamin/bluetooth";
+import { deviceInfo, signIn } from "edilkamin";
+
+// Scan for nearby stoves (requires user gesture)
+const devices = await scanForDevices();
+const { wifiMac } = devices[0];
+
+// Use discovered MAC for API calls
+const token = await signIn(username, password);
+const info = await deviceInfo(token, wifiMac);
+```
+
+### MAC Address Helper
+
+The core library includes a helper to convert BLE MAC to WiFi MAC:
+
+```javascript
+import { bleToWifiMac } from "edilkamin";
+
+// BLE MAC from Bluetooth scan
+const bleMac = "A8:03:2A:FE:D5:0A";
+
+// WiFi MAC for API calls (BLE - 2)
+const wifiMac = bleToWifiMac(bleMac); // "a8032afed508"
+```
+
 ## Motivations
 
 - providing an open source web alternative
   to the [proprietary mobile app](https://play.google.com/store/apps/details?id=com.edilkamin.stufe)
 - improving the interoperability (Nest, HomeAssistant...)
 
+## Device Control Methods
+
+The library provides comprehensive control over Edilkamin stoves:
+
+### Power Control
+
+```js
+setPowerOn(token, mac); // Turn on
+setPowerOff(token, mac); // Turn off
+setPower(token, mac, 1); // 1=on, 0=off
+getPower(token, mac); // Returns boolean
+setPowerLevel(token, mac, 3); // Set power level (1-5)
+getPowerLevel(token, mac); // Returns 1-5
+```
+
+### Fan Speed
+
+```js
+setFan1Speed(token, mac, 3); // Set fan 1 speed (0-5)
+setFan2Speed(token, mac, 3); // Set fan 2 speed (0-5)
+setFan3Speed(token, mac, 3); // Set fan 3 speed (0-5)
+getFan1Speed(token, mac); // Get fan 1 speed
+getFan2Speed(token, mac); // Get fan 2 speed
+getFan3Speed(token, mac); // Get fan 3 speed
+```
+
+### Operating Modes
+
+```js
+setAirkare(token, mac, true); // Enable/disable air quality mode
+setRelax(token, mac, true); // Enable/disable comfort mode
+setStandby(token, mac, true); // Enable/disable standby mode
+getStandby(token, mac); // Get standby status
+setStandbyTime(token, mac, 30); // Set standby timer (minutes)
+getStandbyTime(token, mac); // Get standby timer
+setAuto(token, mac, true); // Enable/disable auto mode
+getAuto(token, mac); // Get auto mode status
+```
+
+### Temperature Control
+
+```js
+setTargetTemperature(token, mac, 22); // Set zone 1 temperature
+getTargetTemperature(token, mac); // Get zone 1 target
+getEnvironmentTemperature(token, mac); // Get ambient temperature
+setEnvironment2Temperature(token, mac, 20); // Set zone 2 temperature
+getEnvironment2Temperature(token, mac); // Get zone 2 target
+setEnvironment3Temperature(token, mac, 18); // Set zone 3 temperature
+getEnvironment3Temperature(token, mac); // Get zone 3 target
+```
+
 ## Roadmap
 
 - [x] AWS Amplify/ Cognito authentication
@@ -128,10 +212,14 @@ const legacyApi = configure(OLD_API_URL);
 - [x] authenticated endpoint call
 - [ ] ~list stoves~
 - [x] turn stove on/off
-- [ ] set temperature
+- [x] set temperature
+- [x] power level control
+- [x] fan speed control
+- [x] operating modes (Airkare, Relax, Standby, Auto)
+- [x] multi-zone temperature control
 
 ## Limitations
 
-It seems like there's no endpoint to list stoves associated to a user.
-The way the official app seem to work is by probing the stove via bluetooth.
-Then cache the stove MAC address to a local database for later use.
+- **No server-side device listing**: The API doesn't provide an endpoint to list stoves associated to a user.
+- **Bluetooth discovery available**: Use `edilkamin/bluetooth` for web browser device discovery, similar to the official app.
+- **Manual MAC entry fallback**: For unsupported browsers or CLI, users can find the BLE MAC with different means and use `bleToWifiMac()` to calculate the WiFi MAC for API calls.

package/dist/cjs/package.json

@@ -1,6 +1,6 @@
 {
     "name": "edilkamin",
-    "version": "1.7.4",
+    "version": "1.9.0",
     "description": "",
     "main": "dist/cjs/src/index.js",
     "module": "dist/esm/src/index.js",
@@ -15,6 +15,16 @@
                 "types": "./dist/cjs/src/index.d.ts",
                 "default": "./dist/cjs/src/index.js"
             }
+        },
+        "./bluetooth": {
+            "import": {
+                "types": "./dist/esm/src/bluetooth.d.ts",
+                "default": "./dist/esm/src/bluetooth.js"
+            },
+            "require": {
+                "types": "./dist/cjs/src/bluetooth.d.ts",
+                "default": "./dist/cjs/src/bluetooth.js"
+            }
         }
     },
     "scripts": {
@@ -60,9 +70,10 @@
         "@eslint/eslintrc": "^3.2.0",
         "@eslint/js": "^9.16.0",
         "@types/mocha": "^10.0.10",
-        "@types/node": "^25.0.2",
+        "@types/node": "^24",
         "@types/pako": "^2.0.4",
-        "@types/sinon": "^17.0.3",
+        "@types/sinon": "^21.0.0",
+        "@types/web-bluetooth": "^0.0.21",
         "@typescript-eslint/eslint-plugin": "^8.17.0",
         "@typescript-eslint/parser": "^8.17.0",
         "esbuild": "^0.27.1",
@@ -73,12 +84,12 @@
         "mocha": "^11.7.5",
         "nyc": "^17.1.0",
         "prettier": "^3.7.4",
-        "sinon": "^19.0.2",
+        "sinon": "^21.0.1",
         "ts-node": "^10.9.1",
         "typedoc": "^0.28.15",
         "typescript": "^5.7.2"
     },
     "optionalDependencies": {
-        "commander": "^12.1.0"
+        "commander": "^14.0.2"
     }
 }

package/dist/cjs/src/bluetooth-utils.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Converts a BLE MAC address to WiFi MAC address.
+ * The WiFi MAC is the BLE MAC minus 2 in hexadecimal.
+ *
+ * @param bleMac - BLE MAC address (with or without colons/dashes)
+ * @returns WiFi MAC address in lowercase without separators
+ *
+ * @example
+ * bleToWifiMac("A8:03:2A:FE:D5:0A") // returns "a8032afed508"
+ * bleToWifiMac("a8032afed50a")      // returns "a8032afed508"
+ */
+declare const bleToWifiMac: (bleMac: string) => string;
+export { bleToWifiMac };

package/dist/cjs/src/bluetooth-utils.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bleToWifiMac = void 0;
+/**
+ * Converts a BLE MAC address to WiFi MAC address.
+ * The WiFi MAC is the BLE MAC minus 2 in hexadecimal.
+ *
+ * @param bleMac - BLE MAC address (with or without colons/dashes)
+ * @returns WiFi MAC address in lowercase without separators
+ *
+ * @example
+ * bleToWifiMac("A8:03:2A:FE:D5:0A") // returns "a8032afed508"
+ * bleToWifiMac("a8032afed50a")      // returns "a8032afed508"
+ */
+const bleToWifiMac = (bleMac) => {
+    // Remove colons, dashes, and convert to lowercase
+    const normalized = bleMac.replace(/[:-]/g, "").toLowerCase();
+    // Validate MAC address format (12 hex characters)
+    if (!/^[0-9a-f]{12}$/.test(normalized)) {
+        throw new Error(`Invalid MAC address format: ${bleMac}`);
+    }
+    // Convert to number, subtract 2, convert back to hex
+    const bleValue = BigInt(`0x${normalized}`);
+    const wifiValue = bleValue - BigInt(2);
+    // Pad to 12 characters and return lowercase
+    return wifiValue.toString(16).padStart(12, "0");
+};
+exports.bleToWifiMac = bleToWifiMac;

package/dist/cjs/src/bluetooth-utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/src/bluetooth-utils.test.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = require("assert");
+const bluetooth_utils_1 = require("./bluetooth-utils");
+describe("bleToWifiMac", () => {
+    it("converts BLE MAC with colons to WiFi MAC", () => {
+        assert_1.strict.equal((0, bluetooth_utils_1.bleToWifiMac)("A8:03:2A:FE:D5:0A"), "a8032afed508");
+    });
+    it("converts BLE MAC without separators", () => {
+        assert_1.strict.equal((0, bluetooth_utils_1.bleToWifiMac)("a8032afed50a"), "a8032afed508");
+    });
+    it("converts BLE MAC with dashes", () => {
+        assert_1.strict.equal((0, bluetooth_utils_1.bleToWifiMac)("A8-03-2A-FE-D5-0A"), "a8032afed508");
+    });
+    it("handles lowercase input", () => {
+        assert_1.strict.equal((0, bluetooth_utils_1.bleToWifiMac)("a8:03:2a:fe:d5:0a"), "a8032afed508");
+    });
+    it("handles edge case where subtraction crosses byte boundary", () => {
+        // FF:FF:FF:FF:FF:01 - 2 = FF:FF:FF:FF:FE:FF
+        assert_1.strict.equal((0, bluetooth_utils_1.bleToWifiMac)("FF:FF:FF:FF:FF:01"), "fffffffffeff");
+    });
+    it("handles minimum value edge case", () => {
+        // 00:00:00:00:00:02 - 2 = 00:00:00:00:00:00
+        assert_1.strict.equal((0, bluetooth_utils_1.bleToWifiMac)("00:00:00:00:00:02"), "000000000000");
+    });
+    it("throws on invalid MAC format - too short", () => {
+        assert_1.strict.throws(() => (0, bluetooth_utils_1.bleToWifiMac)("A8:03:2A"), /Invalid MAC address format/);
+    });
+    it("throws on invalid MAC format - invalid characters", () => {
+        assert_1.strict.throws(() => (0, bluetooth_utils_1.bleToWifiMac)("G8:03:2A:FE:D5:0A"), /Invalid MAC address format/);
+    });
+    it("throws on empty string", () => {
+        assert_1.strict.throws(() => (0, bluetooth_utils_1.bleToWifiMac)(""), /Invalid MAC address format/);
+    });
+});

package/dist/cjs/src/bluetooth.d.ts

@@ -0,0 +1,40 @@
+import { DiscoveredDevice } from "./types";
+/** Device name broadcast by Edilkamin stoves */
+declare const EDILKAMIN_DEVICE_NAME = "EDILKAMIN_EP";
+/** GATT Service UUID for Edilkamin devices (0xABF0) */
+declare const EDILKAMIN_SERVICE_UUID = 44016;
+/**
+ * Check if Web Bluetooth API is available in the current browser.
+ *
+ * @returns true if Web Bluetooth is supported
+ */
+declare const isWebBluetoothSupported: () => boolean;
+/**
+ * Scan for nearby Edilkamin stoves using the Web Bluetooth API.
+ *
+ * This function triggers the browser's Bluetooth device picker dialog,
+ * filtered to show only devices named "EDILKAMIN_EP".
+ *
+ * Note: Web Bluetooth requires:
+ * - HTTPS or localhost
+ * - User gesture (button click)
+ * - Chrome/Edge/Opera (not Firefox/Safari)
+ *
+ * @returns Promise resolving to array of discovered devices
+ * @throws Error if Web Bluetooth is not supported or user cancels
+ *
+ * @example
+ * const devices = await scanForDevices();
+ * console.log(devices[0].wifiMac); // Use this for API calls
+ */
+declare const scanForDevices: () => Promise<DiscoveredDevice[]>;
+/**
+ * Scan for devices with a custom filter.
+ * Advanced function for users who need more control over device selection.
+ *
+ * @param options - Web Bluetooth requestDevice options
+ * @returns Promise resolving to the selected BluetoothDevice
+ */
+declare const scanWithOptions: (options: RequestDeviceOptions) => Promise<BluetoothDevice>;
+export { EDILKAMIN_DEVICE_NAME, EDILKAMIN_SERVICE_UUID, isWebBluetoothSupported, scanForDevices, scanWithOptions, };
+export type { DiscoveredDevice } from "./types";

package/dist/cjs/src/bluetooth.js

@@ -0,0 +1,107 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanWithOptions = exports.scanForDevices = exports.isWebBluetoothSupported = exports.EDILKAMIN_SERVICE_UUID = exports.EDILKAMIN_DEVICE_NAME = void 0;
+const bluetooth_utils_1 = require("./bluetooth-utils");
+/** Device name broadcast by Edilkamin stoves */
+const EDILKAMIN_DEVICE_NAME = "EDILKAMIN_EP";
+exports.EDILKAMIN_DEVICE_NAME = EDILKAMIN_DEVICE_NAME;
+/** GATT Service UUID for Edilkamin devices (0xABF0) */
+const EDILKAMIN_SERVICE_UUID = 0xabf0;
+exports.EDILKAMIN_SERVICE_UUID = EDILKAMIN_SERVICE_UUID;
+/**
+ * Check if Web Bluetooth API is available in the current browser.
+ *
+ * @returns true if Web Bluetooth is supported
+ */
+const isWebBluetoothSupported = () => {
+    return typeof navigator !== "undefined" && "bluetooth" in navigator;
+};
+exports.isWebBluetoothSupported = isWebBluetoothSupported;
+/**
+ * Scan for nearby Edilkamin stoves using the Web Bluetooth API.
+ *
+ * This function triggers the browser's Bluetooth device picker dialog,
+ * filtered to show only devices named "EDILKAMIN_EP".
+ *
+ * Note: Web Bluetooth requires:
+ * - HTTPS or localhost
+ * - User gesture (button click)
+ * - Chrome/Edge/Opera (not Firefox/Safari)
+ *
+ * @returns Promise resolving to array of discovered devices
+ * @throws Error if Web Bluetooth is not supported or user cancels
+ *
+ * @example
+ * const devices = await scanForDevices();
+ * console.log(devices[0].wifiMac); // Use this for API calls
+ */
+const scanForDevices = () => __awaiter(void 0, void 0, void 0, function* () {
+    if (!isWebBluetoothSupported()) {
+        throw new Error("Web Bluetooth API is not supported in this browser. " +
+            "Use Chrome, Edge, or Opera on desktop/Android. " +
+            "On iOS, use the Bluefy browser app.");
+    }
+    try {
+        // Request device - this opens the browser's device picker
+        const device = yield navigator.bluetooth.requestDevice({
+            filters: [{ name: EDILKAMIN_DEVICE_NAME }],
+            optionalServices: [EDILKAMIN_SERVICE_UUID],
+        });
+        // Extract BLE MAC from device ID if available
+        // Note: device.id format varies by platform, may need adjustment
+        const bleMac = device.id || "";
+        const name = device.name || EDILKAMIN_DEVICE_NAME;
+        // Calculate WiFi MAC for API calls
+        let wifiMac = "";
+        if (bleMac && /^[0-9a-f:-]{12,17}$/i.test(bleMac)) {
+            try {
+                wifiMac = (0, bluetooth_utils_1.bleToWifiMac)(bleMac);
+            }
+            catch (_a) {
+                // device.id may not be a valid MAC format on all platforms
+                wifiMac = "";
+            }
+        }
+        const discoveredDevice = {
+            bleMac,
+            wifiMac,
+            name,
+            // RSSI not directly available from requestDevice
+        };
+        return [discoveredDevice];
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            if (error.name === "NotFoundError") {
+                // User cancelled the device picker
+                return [];
+            }
+            throw error;
+        }
+        throw new Error("Unknown error during Bluetooth scan");
+    }
+});
+exports.scanForDevices = scanForDevices;
+/**
+ * Scan for devices with a custom filter.
+ * Advanced function for users who need more control over device selection.
+ *
+ * @param options - Web Bluetooth requestDevice options
+ * @returns Promise resolving to the selected BluetoothDevice
+ */
+const scanWithOptions = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!isWebBluetoothSupported()) {
+        throw new Error("Web Bluetooth API is not supported in this browser.");
+    }
+    return navigator.bluetooth.requestDevice(options);
+});
+exports.scanWithOptions = scanWithOptions;

package/dist/cjs/src/cli.js

@@ -153,6 +153,11 @@ const createProgram = () => {
             description: "Retrieve device power status",
             getter: (api, jwtToken, mac) => api.getPower(jwtToken, mac),
         },
+        {
+            commandName: "getPowerLevel",
+            description: "Retrieve manual power level (1-5)",
+            getter: (api, jwtToken, mac) => api.getPowerLevel(jwtToken, mac),
+        },
         {
             commandName: "getEnvironmentTemperature",
             description: "Retrieve environment temperature",
@@ -163,6 +168,66 @@ const createProgram = () => {
             description: "Retrieve target temperature",
             getter: (api, jwtToken, mac) => api.getTargetTemperature(jwtToken, mac),
         },
+        {
+            commandName: "getFan1Speed",
+            description: "Retrieve fan 1 speed",
+            getter: (api, jwtToken, mac) => api.getFan1Speed(jwtToken, mac),
+        },
+        {
+            commandName: "getFan2Speed",
+            description: "Retrieve fan 2 speed",
+            getter: (api, jwtToken, mac) => api.getFan2Speed(jwtToken, mac),
+        },
+        {
+            commandName: "getFan3Speed",
+            description: "Retrieve fan 3 speed",
+            getter: (api, jwtToken, mac) => api.getFan3Speed(jwtToken, mac),
+        },
+        {
+            commandName: "getStandby",
+            description: "Retrieve Standby mode status",
+            getter: (api, jwtToken, mac) => api.getStandby(jwtToken, mac),
+        },
+        {
+            commandName: "getStandbyTime",
+            description: "Retrieve standby waiting time in minutes",
+            getter: (api, jwtToken, mac) => api.getStandbyTime(jwtToken, mac),
+        },
+        {
+            commandName: "getAuto",
+            description: "Retrieve Auto mode status",
+            getter: (api, jwtToken, mac) => api.getAuto(jwtToken, mac),
+        },
+        {
+            commandName: "getEnvironment2Temperature",
+            description: "Retrieve Environment 2 target temperature",
+            getter: (api, jwtToken, mac) => api.getEnvironment2Temperature(jwtToken, mac),
+        },
+        {
+            commandName: "getEnvironment3Temperature",
+            description: "Retrieve Environment 3 target temperature",
+            getter: (api, jwtToken, mac) => api.getEnvironment3Temperature(jwtToken, mac),
+        },
+        {
+            commandName: "getMeasureUnit",
+            description: "Retrieve temperature unit (true=Fahrenheit, false=Celsius)",
+            getter: (api, jwtToken, mac) => api.getMeasureUnit(jwtToken, mac),
+        },
+        {
+            commandName: "getLanguage",
+            description: "Retrieve display language code (0-9)",
+            getter: (api, jwtToken, mac) => api.getLanguage(jwtToken, mac),
+        },
+        {
+            commandName: "getPelletInReserve",
+            description: "Retrieve pellet reserve status (true=low/reserve, false=ok)",
+            getter: (api, jwtToken, mac) => api.getPelletInReserve(jwtToken, mac),
+        },
+        {
+            commandName: "getPelletAutonomyTime",
+            description: "Retrieve estimated pellet autonomy time",
+            getter: (api, jwtToken, mac) => api.getPelletAutonomyTime(jwtToken, mac),
+        },
     ].forEach(({ commandName, description, getter }) => {
         addLegacyOption(addMacOption(addAuthOptions(program.command(commandName).description(description)))).action((options) => executeGetter(options, getter));
     });
@@ -173,11 +238,76 @@ const createProgram = () => {
             description: "Set the power state of the device (1 for ON, 0 for OFF)",
             setter: (api, jwtToken, mac, value) => api.setPower(jwtToken, mac, value),
         },
+        {
+            commandName: "setPowerLevel",
+            description: "Set manual power level (1-5)",
+            setter: (api, jwtToken, mac, value) => api.setPowerLevel(jwtToken, mac, value),
+        },
         {
             commandName: "setTargetTemperature",
             description: "Set the target temperature (degree celsius) for a device",
             setter: (api, jwtToken, mac, value) => api.setTargetTemperature(jwtToken, mac, value),
         },
+        {
+            commandName: "setFan1Speed",
+            description: "Set fan 1 speed (0-5)",
+            setter: (api, jwtToken, mac, value) => api.setFan1Speed(jwtToken, mac, value),
+        },
+        {
+            commandName: "setFan2Speed",
+            description: "Set fan 2 speed (0-5)",
+            setter: (api, jwtToken, mac, value) => api.setFan2Speed(jwtToken, mac, value),
+        },
+        {
+            commandName: "setFan3Speed",
+            description: "Set fan 3 speed (0-5)",
+            setter: (api, jwtToken, mac, value) => api.setFan3Speed(jwtToken, mac, value),
+        },
+        {
+            commandName: "setAirkare",
+            description: "Enable/disable Airkare mode (1=on, 0=off)",
+            setter: (api, jwtToken, mac, value) => api.setAirkare(jwtToken, mac, value === 1),
+        },
+        {
+            commandName: "setRelax",
+            description: "Enable/disable Relax mode (1=on, 0=off)",
+            setter: (api, jwtToken, mac, value) => api.setRelax(jwtToken, mac, value === 1),
+        },
+        {
+            commandName: "setStandby",
+            description: "Enable/disable Standby mode (1=on, 0=off)",
+            setter: (api, jwtToken, mac, value) => api.setStandby(jwtToken, mac, value === 1),
+        },
+        {
+            commandName: "setStandbyTime",
+            description: "Set standby waiting time in minutes",
+            setter: (api, jwtToken, mac, value) => api.setStandbyTime(jwtToken, mac, value),
+        },
+        {
+            commandName: "setAuto",
+            description: "Enable/disable Auto mode (1=on, 0=off)",
+            setter: (api, jwtToken, mac, value) => api.setAuto(jwtToken, mac, value === 1),
+        },
+        {
+            commandName: "setEnvironment2Temperature",
+            description: "Set Environment 2 target temperature (degrees Celsius)",
+            setter: (api, jwtToken, mac, value) => api.setEnvironment2Temperature(jwtToken, mac, value),
+        },
+        {
+            commandName: "setEnvironment3Temperature",
+            description: "Set Environment 3 target temperature (degrees Celsius)",
+            setter: (api, jwtToken, mac, value) => api.setEnvironment3Temperature(jwtToken, mac, value),
+        },
+        {
+            commandName: "setMeasureUnit",
+            description: "Set temperature unit (1=Fahrenheit, 0=Celsius)",
+            setter: (api, jwtToken, mac, value) => api.setMeasureUnit(jwtToken, mac, value === 1),
+        },
+        {
+            commandName: "setLanguage",
+            description: "Set display language (0=IT,1=FR,2=EN,3=ES,4=PT,5=DA,6=NL,7=DE,8=HU,9=PL)",
+            setter: (api, jwtToken, mac, value) => api.setLanguage(jwtToken, mac, value),
+        },
     ].forEach(({ commandName, description, setter }) => {
         addLegacyOption(addMacOption(addAuthOptions(program.command(commandName).description(description)).requiredOption("-v, --value <number>", "Value to set", parseFloat))).action((options) => executeSetter(options, setter));
     });

package/dist/cjs/src/index.d.ts

@@ -1,6 +1,7 @@
+export { bleToWifiMac } from "./bluetooth-utils";
 export { decompressBuffer, isBuffer, processResponse } from "./buffer-utils";
 export { API_URL, NEW_API_URL, OLD_API_URL } from "./constants";
 export { configure, getSession, signIn } from "./library";
 export { serialNumberDisplay, serialNumberFromHex, serialNumberToHex, } from "./serial-utils";
-export { BufferEncodedType, CommandsType, DeviceAssociationBody, DeviceAssociationResponse, DeviceInfoRawType, DeviceInfoType, EditDeviceAssociationBody, StatusType, TemperaturesType, UserParametersType, } from "./types";
+export { BufferEncodedType, CommandsType, DeviceAssociationBody, DeviceAssociationResponse, DeviceInfoRawType, DeviceInfoType, DiscoveredDevice, EditDeviceAssociationBody, StatusType, TemperaturesType, UserParametersType, } from "./types";
 export declare const deviceInfo: (jwtToken: string, macAddress: string) => Promise<import("./types").DeviceInfoType>, registerDevice: (jwtToken: string, macAddress: string, serialNumber: string, deviceName?: string, deviceRoom?: string) => Promise<import("./types").DeviceAssociationResponse>, editDevice: (jwtToken: string, macAddress: string, deviceName?: string, deviceRoom?: string) => Promise<import("./types").DeviceAssociationResponse>, setPower: (jwtToken: string, macAddress: string, value: number) => Promise<unknown>, setPowerOff: (jwtToken: string, macAddress: string) => Promise<unknown>, setPowerOn: (jwtToken: string, macAddress: string) => Promise<unknown>, getPower: (jwtToken: string, macAddress: string) => Promise<boolean>, getEnvironmentTemperature: (jwtToken: string, macAddress: string) => Promise<number>, getTargetTemperature: (jwtToken: string, macAddress: string) => Promise<number>, setTargetTemperature: (jwtToken: string, macAddress: string, temperature: number) => Promise<unknown>;

package/dist/cjs/src/index.js

@@ -1,8 +1,10 @@
 "use strict";
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.setTargetTemperature = exports.getTargetTemperature = exports.getEnvironmentTemperature = exports.getPower = exports.setPowerOn = exports.setPowerOff = exports.setPower = exports.editDevice = exports.registerDevice = exports.deviceInfo = exports.serialNumberToHex = exports.serialNumberFromHex = exports.serialNumberDisplay = exports.signIn = exports.getSession = exports.configure = exports.OLD_API_URL = exports.NEW_API_URL = exports.API_URL = exports.processResponse = exports.isBuffer = exports.decompressBuffer = void 0;
+exports.setTargetTemperature = exports.getTargetTemperature = exports.getEnvironmentTemperature = exports.getPower = exports.setPowerOn = exports.setPowerOff = exports.setPower = exports.editDevice = exports.registerDevice = exports.deviceInfo = exports.serialNumberToHex = exports.serialNumberFromHex = exports.serialNumberDisplay = exports.signIn = exports.getSession = exports.configure = exports.OLD_API_URL = exports.NEW_API_URL = exports.API_URL = exports.processResponse = exports.isBuffer = exports.decompressBuffer = exports.bleToWifiMac = void 0;
 const library_1 = require("./library");
+var bluetooth_utils_1 = require("./bluetooth-utils");
+Object.defineProperty(exports, "bleToWifiMac", { enumerable: true, get: function () { return bluetooth_utils_1.bleToWifiMac; } });
 var buffer_utils_1 = require("./buffer-utils");
 Object.defineProperty(exports, "decompressBuffer", { enumerable: true, get: function () { return buffer_utils_1.decompressBuffer; } });
 Object.defineProperty(exports, "isBuffer", { enumerable: true, get: function () { return buffer_utils_1.isBuffer; } });

package/dist/cjs/src/library.d.ts

@@ -48,8 +48,34 @@ declare const configure: (baseURL?: string) => {
     setPowerOff: (jwtToken: string, macAddress: string) => Promise<unknown>;
     setPowerOn: (jwtToken: string, macAddress: string) => Promise<unknown>;
     getPower: (jwtToken: string, macAddress: string) => Promise<boolean>;
+    setPowerLevel: (jwtToken: string, macAddress: string, level: number) => Promise<unknown>;
+    getPowerLevel: (jwtToken: string, macAddress: string) => Promise<number>;
+    setFan1Speed: (jwtToken: string, macAddress: string, speed: number) => Promise<unknown>;
+    setFan2Speed: (jwtToken: string, macAddress: string, speed: number) => Promise<unknown>;
+    setFan3Speed: (jwtToken: string, macAddress: string, speed: number) => Promise<unknown>;
+    getFan1Speed: (jwtToken: string, macAddress: string) => Promise<number>;
+    getFan2Speed: (jwtToken: string, macAddress: string) => Promise<number>;
+    getFan3Speed: (jwtToken: string, macAddress: string) => Promise<number>;
+    setAirkare: (jwtToken: string, macAddress: string, enabled: boolean) => Promise<unknown>;
+    setRelax: (jwtToken: string, macAddress: string, enabled: boolean) => Promise<unknown>;
+    setStandby: (jwtToken: string, macAddress: string, enabled: boolean) => Promise<unknown>;
+    getStandby: (jwtToken: string, macAddress: string) => Promise<boolean>;
+    setStandbyTime: (jwtToken: string, macAddress: string, minutes: number) => Promise<unknown>;
+    getStandbyTime: (jwtToken: string, macAddress: string) => Promise<number>;
+    setAuto: (jwtToken: string, macAddress: string, enabled: boolean) => Promise<unknown>;
+    getAuto: (jwtToken: string, macAddress: string) => Promise<boolean>;
     getEnvironmentTemperature: (jwtToken: string, macAddress: string) => Promise<number>;
     getTargetTemperature: (jwtToken: string, macAddress: string) => Promise<number>;
     setTargetTemperature: (jwtToken: string, macAddress: string, temperature: number) => Promise<unknown>;
+    setEnvironment2Temperature: (jwtToken: string, macAddress: string, temperature: number) => Promise<unknown>;
+    getEnvironment2Temperature: (jwtToken: string, macAddress: string) => Promise<number>;
+    setEnvironment3Temperature: (jwtToken: string, macAddress: string, temperature: number) => Promise<unknown>;
+    getEnvironment3Temperature: (jwtToken: string, macAddress: string) => Promise<number>;
+    setMeasureUnit: (jwtToken: string, macAddress: string, isFahrenheit: boolean) => Promise<unknown>;
+    getMeasureUnit: (jwtToken: string, macAddress: string) => Promise<boolean>;
+    setLanguage: (jwtToken: string, macAddress: string, languageCode: number) => Promise<unknown>;
+    getLanguage: (jwtToken: string, macAddress: string) => Promise<number>;
+    getPelletInReserve: (jwtToken: string, macAddress: string) => Promise<boolean>;
+    getPelletAutonomyTime: (jwtToken: string, macAddress: string) => Promise<number>;
 };
 export { configure, configureAmplify, createAuthService, getSession, headers, signIn, };