edilkamin 1.6.0 → 1.6.2

package/dist/esm/library.js

@@ -11,6 +11,7 @@ import { strict as assert } from "assert";
 import { Amplify } from "aws-amplify";
 import * as amplifyAuth from "aws-amplify/auth";
 import axios from "axios";
+import { processResponse } from "./buffer-utils";
 import { API_URL } from "./constants";
 const amplifyconfiguration = {
     aws_project_region: "eu-central-1",
@@ -23,15 +24,16 @@ const amplifyconfiguration = {
  * @returns {object} - The headers object with the Authorization field.
  */
 const headers = (jwtToken) => ({ Authorization: `Bearer ${jwtToken}` });
+let amplifyConfigured = false;
 /**
  * Configures Amplify if not already configured.
- * Ensures the configuration is only applied once.
+ * Uses a local flag to avoid calling getConfig() which prints a warning.
  */
 const configureAmplify = () => {
-    const currentConfig = Amplify.getConfig();
-    if (Object.keys(currentConfig).length !== 0)
+    if (amplifyConfigured)
         return;
     Amplify.configure(amplifyconfiguration);
+    amplifyConfigured = true;
 };
 /**
  * Creates an authentication service with sign-in functionality.
@@ -43,16 +45,21 @@ const createAuthService = (auth) => {
      * Signs in a user with the provided credentials.
      * @param {string} username - The username of the user.
      * @param {string} password - The password of the user.
+     * @param {boolean} [legacy=false] - If true, returns accessToken for legacy API.
      * @returns {Promise<string>} - The JWT token of the signed-in user.
      * @throws {Error} - If sign-in fails or no tokens are retrieved.
      */
-    const signIn = (username, password) => __awaiter(void 0, void 0, void 0, function* () {
+    const signIn = (username_1, password_1, ...args_1) => __awaiter(void 0, [username_1, password_1, ...args_1], void 0, function* (username, password, legacy = false) {
         configureAmplify();
         yield auth.signOut(); // Ensure the user is signed out first
         const { isSignedIn } = yield auth.signIn({ username, password });
         assert.ok(isSignedIn, "Sign-in failed");
         const { tokens } = yield auth.fetchAuthSession();
         assert.ok(tokens, "No tokens found");
+        if (legacy) {
+            assert.ok(tokens.accessToken, "No access token found");
+            return tokens.accessToken.toString();
+        }
         assert.ok(tokens.idToken, "No ID token found");
         return tokens.idToken.toString();
     });
@@ -63,6 +70,7 @@ const { signIn } = createAuthService(amplifyAuth);
 const deviceInfo = (axiosInstance) => 
 /**
  * Retrieves information about a device by its MAC address.
+ * Automatically decompresses any gzip-compressed Buffer fields in the response.
  *
  * @param {string} jwtToken - The JWT token for authentication.
  * @param {string} macAddress - The MAC address of the device.
@@ -72,7 +80,8 @@ const deviceInfo = (axiosInstance) =>
     const response = yield axiosInstance.get(`device/${macAddress}/info`, {
         headers: headers(jwtToken),
     });
-    return response.data;
+    // Process response to decompress any gzipped Buffer fields
+    return processResponse(response.data);
 });
 const mqttCommand = (axiosInstance) => 
 // eslint-disable-next-line  @typescript-eslint/no-explicit-any
@@ -162,6 +171,47 @@ const setTargetTemperature = (axiosInstance) =>
     name: "enviroment_1_temperature",
     value: temperature,
 });
+const registerDevice = (axiosInstance) => 
+/**
+ * Registers a device with the user's account.
+ * This must be called before other device operations will work on the new API.
+ *
+ * @param {string} jwtToken - The JWT token for authentication.
+ * @param {string} macAddress - The MAC address of the device (colons optional).
+ * @param {string} serialNumber - The device serial number.
+ * @param {string} deviceName - User-friendly name for the device (default: empty string).
+ * @param {string} deviceRoom - Room name for the device (default: empty string).
+ * @returns {Promise<DeviceAssociationResponse>} - A promise that resolves to the registration response.
+ */
+(jwtToken_1, macAddress_1, serialNumber_1, ...args_1) => __awaiter(void 0, [jwtToken_1, macAddress_1, serialNumber_1, ...args_1], void 0, function* (jwtToken, macAddress, serialNumber, deviceName = "", deviceRoom = "") {
+    const body = {
+        macAddress: macAddress.replace(/:/g, ""),
+        deviceName,
+        deviceRoom,
+        serialNumber,
+    };
+    const response = yield axiosInstance.post("device", body, { headers: headers(jwtToken) });
+    return response.data;
+});
+const editDevice = (axiosInstance) => 
+/**
+ * Updates a device's name and room.
+ *
+ * @param {string} jwtToken - The JWT token for authentication.
+ * @param {string} macAddress - The MAC address of the device (colons optional).
+ * @param {string} deviceName - New name for the device (default: empty string).
+ * @param {string} deviceRoom - New room for the device (default: empty string).
+ * @returns {Promise<DeviceAssociationResponse>} - A promise that resolves to the update response.
+ */
+(jwtToken_1, macAddress_1, ...args_1) => __awaiter(void 0, [jwtToken_1, macAddress_1, ...args_1], void 0, function* (jwtToken, macAddress, deviceName = "", deviceRoom = "") {
+    const normalizedMac = macAddress.replace(/:/g, "");
+    const body = {
+        deviceName,
+        deviceRoom,
+    };
+    const response = yield axiosInstance.put(`device/${normalizedMac}`, body, { headers: headers(jwtToken) });
+    return response.data;
+});
 /**
  * Configures the library for API interactions.
  * Initializes API methods with a specified base URL.
@@ -176,6 +226,8 @@ const setTargetTemperature = (axiosInstance) =>
 const configure = (baseURL = API_URL) => {
     const axiosInstance = axios.create({ baseURL });
     const deviceInfoInstance = deviceInfo(axiosInstance);
+    const registerDeviceInstance = registerDevice(axiosInstance);
+    const editDeviceInstance = editDevice(axiosInstance);
     const setPowerInstance = setPower(axiosInstance);
     const setPowerOffInstance = setPowerOff(axiosInstance);
     const setPowerOnInstance = setPowerOn(axiosInstance);
@@ -185,6 +237,8 @@ const configure = (baseURL = API_URL) => {
     const setTargetTemperatureInstance = setTargetTemperature(axiosInstance);
     return {
         deviceInfo: deviceInfoInstance,
+        registerDevice: registerDeviceInstance,
+        editDevice: editDeviceInstance,
         setPower: setPowerInstance,
         setPowerOff: setPowerOffInstance,
         setPowerOn: setPowerOnInstance,

package/dist/esm/library.test.js

@@ -9,9 +9,21 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { strict as assert } from "assert";
 import axios from "axios";
+import pako from "pako";
 import sinon from "sinon";
 import { configure, createAuthService } from "../src/library";
 import { API_URL } from "./constants";
+/**
+ * Helper to create a gzip-compressed Buffer object for testing.
+ */
+const createGzippedBuffer = (data) => {
+    const json = JSON.stringify(data);
+    const compressed = pako.gzip(json);
+    return {
+        type: "Buffer",
+        data: Array.from(compressed),
+    };
+};
 describe("library", () => {
     let axiosStub;
     const expectedToken = "mockJwtToken";
@@ -26,7 +38,7 @@ describe("library", () => {
         sinon.restore();
     });
     describe("signIn", () => {
-        it("should sign in and return the JWT token", () => __awaiter(void 0, void 0, void 0, function* () {
+        it("should sign in and return the ID token by default", () => __awaiter(void 0, void 0, void 0, function* () {
             const expectedUsername = "testuser";
             const expectedPassword = "testpassword";
             const signIn = sinon.stub().resolves({ isSignedIn: true });
@@ -34,6 +46,7 @@ describe("library", () => {
             const fetchAuthSession = sinon.stub().resolves({
                 tokens: {
                     idToken: { toString: () => expectedToken },
+                    accessToken: { toString: () => "accessToken" },
                 },
             });
             const authStub = {
@@ -50,6 +63,28 @@ describe("library", () => {
             ]);
             assert.equal(token, expectedToken);
         }));
+        it("should sign in and return the access token in legacy mode", () => __awaiter(void 0, void 0, void 0, function* () {
+            const expectedUsername = "testuser";
+            const expectedPassword = "testpassword";
+            const signIn = sinon.stub().resolves({ isSignedIn: true });
+            const signOut = sinon.stub();
+            const fetchAuthSession = sinon.stub().resolves({
+                tokens: {
+                    accessToken: { toString: () => expectedToken },
+                    idToken: { toString: () => "idToken" },
+                },
+            });
+            const authStub = {
+                signIn,
+                signOut,
+                fetchAuthSession,
+            };
+            // eslint-disable-next-line  @typescript-eslint/no-explicit-any
+            const authService = createAuthService(authStub);
+            const token = yield authService.signIn(expectedUsername, expectedPassword, true // legacy mode
+            );
+            assert.equal(token, expectedToken);
+        }));
         it("should throw an error if sign-in fails", () => __awaiter(void 0, void 0, void 0, function* () {
             const expectedUsername = "testuser";
             const expectedPassword = "testpassword";
@@ -76,6 +111,8 @@ describe("library", () => {
     describe("configure", () => {
         const expectedApi = [
             "deviceInfo",
+            "registerDevice",
+            "editDevice",
             "setPower",
             "setPowerOff",
             "setPowerOn",
@@ -242,4 +279,226 @@ describe("library", () => {
             }));
         });
     });
+    describe("registerDevice", () => {
+        it("should call POST /device with correct payload", () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockResponse = {
+                macAddress: "AABBCCDDEEFF",
+                deviceName: "Test Stove",
+                deviceRoom: "Living Room",
+                serialNumber: "EDK123",
+            };
+            const mockAxios = {
+                post: sinon.stub().resolves({ data: mockResponse }),
+                get: sinon.stub(),
+                put: sinon.stub(),
+            };
+            axiosStub.returns(mockAxios);
+            const api = configure("https://example.com/api");
+            const result = yield api.registerDevice(expectedToken, "AA:BB:CC:DD:EE:FF", "EDK123", "Test Stove", "Living Room");
+            assert.deepEqual(mockAxios.post.args, [
+                [
+                    "device",
+                    {
+                        macAddress: "AABBCCDDEEFF",
+                        deviceName: "Test Stove",
+                        deviceRoom: "Living Room",
+                        serialNumber: "EDK123",
+                    },
+                    { headers: { Authorization: `Bearer ${expectedToken}` } },
+                ],
+            ]);
+            assert.deepEqual(result, mockResponse);
+        }));
+        it("should normalize MAC address by removing colons", () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockAxios = {
+                post: sinon.stub().resolves({ data: {} }),
+                get: sinon.stub(),
+                put: sinon.stub(),
+            };
+            axiosStub.returns(mockAxios);
+            const api = configure("https://example.com/api");
+            yield api.registerDevice(expectedToken, "AA:BB:CC:DD:EE:FF", "EDK123");
+            assert.equal(mockAxios.post.args[0][1].macAddress, "AABBCCDDEEFF");
+        }));
+        it("should use empty strings as defaults for name and room", () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockAxios = {
+                post: sinon.stub().resolves({ data: {} }),
+                get: sinon.stub(),
+                put: sinon.stub(),
+            };
+            axiosStub.returns(mockAxios);
+            const api = configure("https://example.com/api");
+            yield api.registerDevice(expectedToken, "AABBCCDDEEFF", "EDK123");
+            assert.equal(mockAxios.post.args[0][1].deviceName, "");
+            assert.equal(mockAxios.post.args[0][1].deviceRoom, "");
+        }));
+    });
+    describe("editDevice", () => {
+        it("should call PUT /device/{mac} with correct payload", () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockResponse = {
+                macAddress: "AABBCCDDEEFF",
+                deviceName: "Updated Name",
+                deviceRoom: "Basement",
+                serialNumber: "EDK123",
+            };
+            const mockAxios = {
+                put: sinon.stub().resolves({ data: mockResponse }),
+                get: sinon.stub(),
+                post: sinon.stub(),
+            };
+            axiosStub.returns(mockAxios);
+            const api = configure("https://example.com/api");
+            const result = yield api.editDevice(expectedToken, "AA:BB:CC:DD:EE:FF", "Updated Name", "Basement");
+            assert.deepEqual(mockAxios.put.args, [
+                [
+                    "device/AABBCCDDEEFF",
+                    {
+                        deviceName: "Updated Name",
+                        deviceRoom: "Basement",
+                    },
+                    { headers: { Authorization: `Bearer ${expectedToken}` } },
+                ],
+            ]);
+            assert.deepEqual(result, mockResponse);
+        }));
+        it("should use empty strings as defaults for name and room", () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockAxios = {
+                put: sinon.stub().resolves({ data: {} }),
+                get: sinon.stub(),
+                post: sinon.stub(),
+            };
+            axiosStub.returns(mockAxios);
+            const api = configure("https://example.com/api");
+            yield api.editDevice(expectedToken, "AABBCCDDEEFF");
+            assert.equal(mockAxios.put.args[0][1].deviceName, "");
+            assert.equal(mockAxios.put.args[0][1].deviceRoom, "");
+        }));
+    });
+    describe("deviceInfo with compressed responses", () => {
+        it("should decompress Buffer-encoded status field", () => __awaiter(void 0, void 0, void 0, function* () {
+            const statusData = {
+                commands: { power: true },
+                temperatures: { enviroment: 19, board: 25 },
+            };
+            const mockResponse = {
+                status: createGzippedBuffer(statusData),
+                nvm: {
+                    user_parameters: {
+                        enviroment_1_temperature: 22,
+                    },
+                },
+            };
+            const mockAxios = {
+                get: sinon.stub().resolves({ data: mockResponse }),
+            };
+            axiosStub.returns(mockAxios);
+            const api = configure("https://example.com/api");
+            const result = yield api.deviceInfo(expectedToken, "mockMacAddress");
+            assert.deepEqual(result.status, statusData);
+        }));
+        it("should decompress Buffer-encoded nvm field", () => __awaiter(void 0, void 0, void 0, function* () {
+            const nvmData = {
+                user_parameters: {
+                    enviroment_1_temperature: 22,
+                    enviroment_2_temperature: 0,
+                    enviroment_3_temperature: 0,
+                    is_auto: false,
+                    is_sound_active: true,
+                },
+            };
+            const mockResponse = {
+                status: {
+                    commands: { power: true },
+                    temperatures: { enviroment: 19 },
+                },
+                nvm: createGzippedBuffer(nvmData),
+            };
+            const mockAxios = {
+                get: sinon.stub().resolves({ data: mockResponse }),
+            };
+            axiosStub.returns(mockAxios);
+            const api = configure("https://example.com/api");
+            const result = yield api.deviceInfo(expectedToken, "mockMacAddress");
+            assert.deepEqual(result.nvm, nvmData);
+        }));
+        it("should handle fully compressed response (status and nvm)", () => __awaiter(void 0, void 0, void 0, function* () {
+            const statusData = {
+                commands: { power: false },
+                temperatures: { enviroment: 21, board: 30 },
+            };
+            const nvmData = {
+                user_parameters: {
+                    enviroment_1_temperature: 20,
+                    enviroment_2_temperature: 0,
+                    enviroment_3_temperature: 0,
+                    is_auto: true,
+                    is_sound_active: false,
+                },
+            };
+            const mockResponse = {
+                status: createGzippedBuffer(statusData),
+                nvm: createGzippedBuffer(nvmData),
+            };
+            const mockAxios = {
+                get: sinon.stub().resolves({ data: mockResponse }),
+            };
+            axiosStub.returns(mockAxios);
+            const api = configure("https://example.com/api");
+            const result = yield api.deviceInfo(expectedToken, "mockMacAddress");
+            assert.deepEqual(result.status, statusData);
+            assert.deepEqual(result.nvm, nvmData);
+        }));
+        it("should work with getPower on compressed response", () => __awaiter(void 0, void 0, void 0, function* () {
+            const statusData = {
+                commands: { power: true },
+                temperatures: { enviroment: 19 },
+            };
+            const mockResponse = {
+                status: createGzippedBuffer(statusData),
+                nvm: { user_parameters: { enviroment_1_temperature: 22 } },
+            };
+            const mockAxios = {
+                get: sinon.stub().resolves({ data: mockResponse }),
+            };
+            axiosStub.returns(mockAxios);
+            const api = configure("https://example.com/api");
+            const result = yield api.getPower(expectedToken, "mockMacAddress");
+            assert.equal(result, true);
+        }));
+        it("should work with getEnvironmentTemperature on compressed response", () => __awaiter(void 0, void 0, void 0, function* () {
+            const statusData = {
+                commands: { power: true },
+                temperatures: { enviroment: 19, board: 25 },
+            };
+            const mockResponse = {
+                status: createGzippedBuffer(statusData),
+                nvm: { user_parameters: { enviroment_1_temperature: 22 } },
+            };
+            const mockAxios = {
+                get: sinon.stub().resolves({ data: mockResponse }),
+            };
+            axiosStub.returns(mockAxios);
+            const api = configure("https://example.com/api");
+            const result = yield api.getEnvironmentTemperature(expectedToken, "mockMacAddress");
+            assert.equal(result, 19);
+        }));
+        it("should work with getTargetTemperature on compressed response", () => __awaiter(void 0, void 0, void 0, function* () {
+            const nvmData = {
+                user_parameters: {
+                    enviroment_1_temperature: 22,
+                },
+            };
+            const mockResponse = {
+                status: { commands: { power: true }, temperatures: { enviroment: 19 } },
+                nvm: createGzippedBuffer(nvmData),
+            };
+            const mockAxios = {
+                get: sinon.stub().resolves({ data: mockResponse }),
+            };
+            axiosStub.returns(mockAxios);
+            const api = configure("https://example.com/api");
+            const result = yield api.getTargetTemperature(expectedToken, "mockMacAddress");
+            assert.equal(result, 22);
+        }));
+    });
 });

package/dist/esm/serial-utils.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Converts a raw serial number string to hex-encoded format.
+ * This is useful when serial numbers contain non-printable characters.
+ *
+ * @param serial - The raw serial number string
+ * @returns Hex-encoded string representation
+ *
+ * @example
+ * serialNumberToHex("EDK123") // returns "45444b313233"
+ */
+declare const serialNumberToHex: (serial: string) => string;
+/**
+ * Converts a hex-encoded serial number back to raw string format.
+ *
+ * @param hex - The hex-encoded serial number
+ * @returns Raw serial number string
+ *
+ * @example
+ * serialNumberFromHex("45444b313233") // returns "EDK123"
+ */
+declare const serialNumberFromHex: (hex: string) => string;
+/**
+ * Produces a display-friendly version of a serial number by removing
+ * non-printable characters and collapsing whitespace.
+ *
+ * @param serial - The raw serial number string
+ * @returns Display-friendly serial number
+ *
+ * @example
+ * serialNumberDisplay("EDK\x00123\x1F") // returns "EDK123"
+ */
+declare const serialNumberDisplay: (serial: string) => string;
+export { serialNumberDisplay, serialNumberFromHex, serialNumberToHex };

package/dist/esm/serial-utils.js

@@ -0,0 +1,45 @@
+/**
+ * Converts a raw serial number string to hex-encoded format.
+ * This is useful when serial numbers contain non-printable characters.
+ *
+ * @param serial - The raw serial number string
+ * @returns Hex-encoded string representation
+ *
+ * @example
+ * serialNumberToHex("EDK123") // returns "45444b313233"
+ */
+const serialNumberToHex = (serial) => {
+    return Buffer.from(serial, "utf-8").toString("hex");
+};
+/**
+ * Converts a hex-encoded serial number back to raw string format.
+ *
+ * @param hex - The hex-encoded serial number
+ * @returns Raw serial number string
+ *
+ * @example
+ * serialNumberFromHex("45444b313233") // returns "EDK123"
+ */
+const serialNumberFromHex = (hex) => {
+    return Buffer.from(hex, "hex").toString("utf-8");
+};
+/**
+ * Produces a display-friendly version of a serial number by removing
+ * non-printable characters and collapsing whitespace.
+ *
+ * @param serial - The raw serial number string
+ * @returns Display-friendly serial number
+ *
+ * @example
+ * serialNumberDisplay("EDK\x00123\x1F") // returns "EDK123"
+ */
+const serialNumberDisplay = (serial) => {
+    // Remove non-printable characters (ASCII 0-31, 127)
+    // Keep printable ASCII (32-126) and extended characters
+    return (serial
+        // eslint-disable-next-line no-control-regex
+        .replace(/[\x00-\x1F\x7F]/g, "")
+        .replace(/\s+/g, " ")
+        .trim());
+};
+export { serialNumberDisplay, serialNumberFromHex, serialNumberToHex };

package/dist/esm/serial-utils.test.d.ts

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

package/dist/esm/serial-utils.test.js

@@ -0,0 +1,48 @@
+import { strict as assert } from "assert";
+import { serialNumberDisplay, serialNumberFromHex, serialNumberToHex, } from "./serial-utils";
+describe("serial-utils", () => {
+    describe("serialNumberToHex", () => {
+        it("should convert ASCII string to hex", () => {
+            assert.equal(serialNumberToHex("EDK123"), "45444b313233");
+        });
+        it("should handle empty string", () => {
+            assert.equal(serialNumberToHex(""), "");
+        });
+        it("should convert string with non-printable chars", () => {
+            const input = "EDK\x00123";
+            const hex = serialNumberToHex(input);
+            assert.equal(hex, "45444b00313233");
+        });
+    });
+    describe("serialNumberFromHex", () => {
+        it("should convert hex back to ASCII string", () => {
+            assert.equal(serialNumberFromHex("45444b313233"), "EDK123");
+        });
+        it("should handle empty string", () => {
+            assert.equal(serialNumberFromHex(""), "");
+        });
+        it("should round-trip with toHex", () => {
+            const original = "EDK\x00123\x1F";
+            const hex = serialNumberToHex(original);
+            const restored = serialNumberFromHex(hex);
+            assert.equal(restored, original);
+        });
+    });
+    describe("serialNumberDisplay", () => {
+        it("should remove non-printable characters", () => {
+            assert.equal(serialNumberDisplay("EDK\x00123\x1F"), "EDK123");
+        });
+        it("should collapse whitespace", () => {
+            assert.equal(serialNumberDisplay("EDK  123"), "EDK 123");
+        });
+        it("should trim leading and trailing whitespace", () => {
+            assert.equal(serialNumberDisplay("  EDK123  "), "EDK123");
+        });
+        it("should handle empty string", () => {
+            assert.equal(serialNumberDisplay(""), "");
+        });
+        it("should preserve normal serial numbers", () => {
+            assert.equal(serialNumberDisplay("EDK12345678"), "EDK12345678");
+        });
+    });
+});

package/dist/esm/types.d.ts

@@ -1,3 +1,11 @@
+/**
+ * Represents a Node.js Buffer object serialized to JSON.
+ * This format is used by the Edilkamin API for gzip-compressed fields.
+ */
+interface BufferEncodedType {
+    type: "Buffer";
+    data: number[];
+}
 interface CommandsType {
     power: boolean;
 }
@@ -22,4 +30,44 @@ interface DeviceInfoType {
         user_parameters: UserParametersType;
     };
 }
-export type { CommandsType, DeviceInfoType, StatusType, TemperaturesType, UserParametersType, };
+/**
+ * Raw device info response that may contain Buffer-encoded compressed fields.
+ * Used internally before processing; external callers receive DeviceInfoType.
+ */
+interface DeviceInfoRawType {
+    status: StatusType | BufferEncodedType;
+    nvm: {
+        user_parameters: UserParametersType;
+    } | BufferEncodedType;
+    component_info?: BufferEncodedType | Record<string, unknown>;
+}
+/**
+ * Request body for registering a device with a user account.
+ * All fields are required by the API.
+ */
+interface DeviceAssociationBody {
+    macAddress: string;
+    deviceName: string;
+    deviceRoom: string;
+    serialNumber: string;
+}
+/**
+ * Request body for editing a device's name and room.
+ * MAC address is specified in the URL path, not the body.
+ * Serial number cannot be changed after registration.
+ */
+interface EditDeviceAssociationBody {
+    deviceName: string;
+    deviceRoom: string;
+}
+/**
+ * Response from device registration endpoint.
+ * Structure based on Android app behavior - may need adjustment after testing.
+ */
+interface DeviceAssociationResponse {
+    macAddress: string;
+    deviceName: string;
+    deviceRoom: string;
+    serialNumber: string;
+}
+export type { BufferEncodedType, CommandsType, DeviceAssociationBody, DeviceAssociationResponse, DeviceInfoRawType, DeviceInfoType, EditDeviceAssociationBody, StatusType, TemperaturesType, UserParametersType, };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edilkamin",
-  "version": "1.6.0",
+  "version": "1.6.2",
   "description": "",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
@@ -42,26 +42,28 @@
   },
   "dependencies": {
     "aws-amplify": "^6.10.0",
-    "axios": "^0.26.0"
+    "axios": "^1.13.2",
+    "pako": "^2.1.0"
   },
   "devDependencies": {
     "@aws-amplify/cli": "^7.6.21",
     "@eslint/eslintrc": "^3.2.0",
     "@eslint/js": "^9.16.0",
     "@types/mocha": "^10.0.10",
+    "@types/pako": "^2.0.4",
     "@types/sinon": "^17.0.3",
     "@typescript-eslint/eslint-plugin": "^8.17.0",
     "@typescript-eslint/parser": "^8.17.0",
     "eslint": "^9.16.0",
-    "eslint-config-prettier": "^9.1.0",
+    "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-prettier": "^5.2.1",
     "eslint-plugin-simple-import-sort": "^12.1.1",
-    "mocha": "^10.8.2",
+    "mocha": "^11.7.5",
     "nyc": "^17.1.0",
     "prettier": "^2.5.1",
     "sinon": "^19.0.2",
     "ts-node": "^10.9.1",
-    "typedoc": "^0.27.2",
+    "typedoc": "^0.28.15",
     "typescript": "^5.7.2"
   },
   "optionalDependencies": {