edilkamin 1.6.1 → 1.7.2

package/.github/workflows/cli-tests.yml

@@ -10,7 +10,7 @@ jobs:
     timeout-minutes: 5
     strategy:
       matrix:
-        node-version: [20.x, 22.x]
+        node-version: [20.x, 22.x, 24.x]
     steps:
       - uses: actions/checkout@v6
       - uses: actions/setup-node@v6

package/.github/workflows/documentation.yml

@@ -12,7 +12,7 @@ jobs:
       - uses: actions/checkout@v6
       - uses: actions/setup-node@v6
         with:
-          node-version: "22.x"
+          node-version: "24.x"
       - name: git config
         run: |
           git config user.name documentation-deploy-action

package/.github/workflows/publish.yml

@@ -4,6 +4,10 @@ on:
   push:
   pull_request:
 
+permissions:
+  id-token: write
+  contents: read
+
 jobs:
   build:
     runs-on: ubuntu-latest
@@ -12,12 +16,10 @@ jobs:
       - uses: actions/checkout@v6
       - uses: actions/setup-node@v6
         with:
-          node-version: "22.x"
+          node-version: "24.x"
           registry-url: "https://registry.npmjs.org"
       - run: yarn install
       - run: yarn build
       - run: npm publish --dry-run
       - run: npm publish
         if: startsWith(github.ref, 'refs/tags/')
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NODE_AUTH_TOKEN }}

package/.github/workflows/tests.yml

@@ -10,7 +10,7 @@ jobs:
     timeout-minutes: 5
     strategy:
       matrix:
-        node-version: [20.x, 22.x]
+        node-version: [20.x, 22.x, 24.x]
     steps:
       - uses: actions/checkout@v6
       - uses: actions/setup-node@v6

package/README.md

@@ -1,9 +1,9 @@
 # Edilkamin.js
 
-[![Tests](https://github.com/AndreMiras/edilkamin.js/workflows/Tests/badge.svg)](https://github.com/AndreMiras/edilkamin.js/actions/workflows/tests.yml)
+[![Tests](htts://github.com/AndreMiras/edilkamin.js/actions/workflows/tests.yml/badge.svg)](https://github.com/AndreMiras/edilkamin.js/actions/workflows/tests.yml)
 [![CLI Tests](https://github.com/AndreMiras/edilkamin.js/actions/workflows/cli-tests.yml/badge.svg)](https://github.com/AndreMiras/edilkamin.js/actions/workflows/cli-tests.yml)
 [![codecov](https://codecov.io/gh/AndreMiras/edilkamin.js/graph/badge.svg?token=YG3LKXNZWU)](https://app.codecov.io/gh/AndreMiras/edilkamin.js/tree/main)
-[![Documentation](https://github.com/AndreMiras/edilkamin.js/workflows/Documentation/badge.svg)](https://github.com/AndreMiras/edilkamin.js/actions/workflows/documentation.yml)
+[![Documentation](https://github.com/AndreMiras/edilkamin.js/actions/workflows/documentation.yml/badge.svg)](https://github.com/AndreMiras/edilkamin.js/actions/workflows/documentation.yml)
 [![npm version](https://badge.fury.io/js/edilkamin.svg)](https://badge.fury.io/js/edilkamin)
 
 This is a library for the [Reverse Engineered](docs/ReverseEngineering.md) "The Mind" Edilkamin API.
@@ -31,11 +31,26 @@ Basic usage:
 import { signIn, deviceInfo, setPowerOff } from "edilkamin";
 
 const macAddress = "aabbccddeeff";
-const token = signIn(username, password);
-deviceInfo(token, macAddress).then(console.log);
-setPowerOff(token, macAddress).then(console.log);
+const token = await signIn(username, password);
+console.log(await deviceInfo(token, macAddress));
+console.log(await setPowerOff(token, macAddress));
 ```
 
+For long-running applications, use `getSession()` to automatically refresh tokens:
+
+```js
+import { signIn, getSession, deviceInfo } from "edilkamin";
+
+// Authenticate once
+await signIn(username, password);
+
+// Get current session (auto-refreshes if expired)
+const token = await getSession();
+console.log(await deviceInfo(token, macAddress));
+```
+
+Sessions persist for ~30 days without re-authentication. Call `getSession()` to retrieve fresh tokens as needed.
+
 It's also possible to change the default backend URL:
 
 ```js
@@ -43,8 +58,8 @@ import { signIn, configure } from "edilkamin";
 
 const baseUrl = "https://my-proxy.com/";
 const { deviceInfo, setPower } = configure(baseUrl);
-deviceInfo(token, macAddress).then(console.log);
-setPower(token, macAddress, 0).then(console.log);
+console.log(await deviceInfo(token, macAddress));
+console.log(await setPower(token, macAddress, 0));
 ```
 
 ## CLI
@@ -52,7 +67,14 @@ setPower(token, macAddress, 0).then(console.log);
 The library includes a CLI tool that is useful for debugging.
 
 ```sh
+# First time: provide credentials to authenticate
 yarn cli deviceInfo --mac $MAC --username $USERNAME --password $PASSWORD
+
+# Subsequent calls: session persists, credentials optional
+yarn cli deviceInfo --mac $MAC
+
+# Clear stored session
+yarn cli logout
 ```
 
 Or with `npx` once the library is installed:
@@ -61,6 +83,38 @@ Or with `npx` once the library is installed:
 npx edilkamin deviceInfo --mac $MAC --username $USERNAME --password $PASSWORD
 ```
 
+The CLI stores session data in `~/.edilkamin/session.json` and automatically refreshes tokens when needed. Sessions remain valid for ~30 days.
+
+## API Versions
+
+This library supports both the new and legacy Edilkamin API endpoints.
+
+### CLI Usage
+
+```sh
+# New API (default)
+yarn cli deviceInfo --mac $MAC --username $USERNAME --password $PASSWORD
+
+# Legacy API
+yarn cli deviceInfo --mac $MAC --username $USERNAME --password $PASSWORD --legacy
+```
+
+### Library Usage
+
+```js
+import { configure, signIn, OLD_API_URL, NEW_API_URL } from "edilkamin";
+
+// New API (default)
+const token = await signIn(username, password);
+const api = configure();
+
+// Legacy API
+const legacyToken = await signIn(username, password, true);
+const legacyApi = configure(OLD_API_URL);
+```
+
+> **Note**: The legacy API uses AWS API Gateway and may be deprecated in the future.
+
 ## Motivations
 
 - providing an open source web alternative

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

@@ -0,0 +1,25 @@
+import { BufferEncodedType } from "./types";
+/**
+ * Type guard to check if a value is a serialized Node.js Buffer.
+ * Node.js Buffers serialize to JSON as: {type: "Buffer", data: [...]}
+ *
+ * @param value - The value to check
+ * @returns True if the value is a Buffer-encoded object
+ */
+declare const isBuffer: (value: unknown) => value is BufferEncodedType;
+/**
+ * Decompresses a Buffer-encoded gzip object and parses the resulting JSON.
+ *
+ * @param bufferObj - A serialized Buffer object containing gzip data
+ * @returns The decompressed and parsed JSON data, or the original object on failure
+ */
+declare const decompressBuffer: (bufferObj: BufferEncodedType) => unknown;
+/**
+ * Recursively processes an API response to decompress any Buffer-encoded fields.
+ * Handles nested objects and arrays, preserving structure while decompressing.
+ *
+ * @param data - The API response data to process
+ * @returns The processed data with all Buffer fields decompressed
+ */
+declare const processResponse: <T>(data: T) => T;
+export { decompressBuffer, isBuffer, processResponse };

package/dist/esm/buffer-utils.js

@@ -0,0 +1,70 @@
+import pako from "pako";
+/**
+ * Type guard to check if a value is a serialized Node.js Buffer.
+ * Node.js Buffers serialize to JSON as: {type: "Buffer", data: [...]}
+ *
+ * @param value - The value to check
+ * @returns True if the value is a Buffer-encoded object
+ */
+const isBuffer = (value) => {
+    return (typeof value === "object" &&
+        value !== null &&
+        "type" in value &&
+        value.type === "Buffer" &&
+        "data" in value &&
+        Array.isArray(value.data));
+};
+/**
+ * Decompresses a Buffer-encoded gzip object and parses the resulting JSON.
+ *
+ * @param bufferObj - A serialized Buffer object containing gzip data
+ * @returns The decompressed and parsed JSON data, or the original object on failure
+ */
+const decompressBuffer = (bufferObj) => {
+    try {
+        // Convert data array to Uint8Array for pako
+        const compressed = new Uint8Array(bufferObj.data);
+        // Decompress with gzip
+        const decompressed = pako.ungzip(compressed, { to: "string" });
+        // Parse JSON
+        return JSON.parse(decompressed);
+    }
+    catch (error) {
+        // Log warning but return original to maintain backward compatibility
+        console.warn("Failed to decompress buffer:", error);
+        return bufferObj;
+    }
+};
+/**
+ * Recursively processes an API response to decompress any Buffer-encoded fields.
+ * Handles nested objects and arrays, preserving structure while decompressing.
+ *
+ * @param data - The API response data to process
+ * @returns The processed data with all Buffer fields decompressed
+ */
+const processResponse = (data) => {
+    if (data === null || data === undefined) {
+        return data;
+    }
+    // Check if this is a Buffer object
+    if (isBuffer(data)) {
+        const decompressed = decompressBuffer(data);
+        // Recursively process the decompressed result (may contain nested buffers)
+        return processResponse(decompressed);
+    }
+    // Recursively process arrays
+    if (Array.isArray(data)) {
+        return data.map((item) => processResponse(item));
+    }
+    // Recursively process objects
+    if (typeof data === "object") {
+        const processed = {};
+        for (const [key, value] of Object.entries(data)) {
+            processed[key] = processResponse(value);
+        }
+        return processed;
+    }
+    // Primitive value, return as-is
+    return data;
+};
+export { decompressBuffer, isBuffer, processResponse };

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

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

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

@@ -0,0 +1,181 @@
+import { strict as assert } from "assert";
+import pako from "pako";
+import sinon from "sinon";
+import { decompressBuffer, isBuffer, processResponse } from "./buffer-utils";
+/**
+ * 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("buffer-utils", () => {
+    afterEach(() => {
+        sinon.restore();
+    });
+    describe("isBuffer", () => {
+        it("should detect valid Buffer objects", () => {
+            const buffer = { type: "Buffer", data: [31, 139, 8, 0] };
+            assert.ok(isBuffer(buffer));
+        });
+        it("should detect empty Buffer objects", () => {
+            const buffer = { type: "Buffer", data: [] };
+            assert.ok(isBuffer(buffer));
+        });
+        it("should reject non-Buffer objects with wrong type", () => {
+            assert.ok(!isBuffer({ type: "NotBuffer", data: [] }));
+        });
+        it("should reject objects without type field", () => {
+            assert.ok(!isBuffer({ data: [1, 2, 3] }));
+        });
+        it("should reject objects without data field", () => {
+            assert.ok(!isBuffer({ type: "Buffer" }));
+        });
+        it("should reject objects with non-array data", () => {
+            assert.ok(!isBuffer({ type: "Buffer", data: "not an array" }));
+        });
+        it("should reject null", () => {
+            assert.ok(!isBuffer(null));
+        });
+        it("should reject undefined", () => {
+            assert.ok(!isBuffer(undefined));
+        });
+        it("should reject primitives", () => {
+            assert.ok(!isBuffer("string"));
+            assert.ok(!isBuffer(123));
+            assert.ok(!isBuffer(true));
+        });
+    });
+    describe("decompressBuffer", () => {
+        it("should decompress gzipped JSON buffer", () => {
+            const originalData = { test: "value", nested: { key: 123 } };
+            const bufferObj = createGzippedBuffer(originalData);
+            const result = decompressBuffer(bufferObj);
+            assert.deepEqual(result, originalData);
+        });
+        it("should handle gzipped arrays", () => {
+            const originalData = [1, 2, 3, "test"];
+            const bufferObj = createGzippedBuffer(originalData);
+            const result = decompressBuffer(bufferObj);
+            assert.deepEqual(result, originalData);
+        });
+        it("should handle gzipped strings", () => {
+            const originalData = "test string";
+            const bufferObj = createGzippedBuffer(originalData);
+            const result = decompressBuffer(bufferObj);
+            assert.equal(result, originalData);
+        });
+        it("should return original value if decompression fails", () => {
+            const consoleWarnStub = sinon.stub(console, "warn");
+            const invalidBuffer = { type: "Buffer", data: [1, 2, 3] };
+            const result = decompressBuffer(invalidBuffer);
+            assert.deepEqual(result, invalidBuffer);
+            assert.ok(consoleWarnStub.calledOnce);
+        });
+        it("should return original value if JSON parsing fails", () => {
+            const consoleWarnStub = sinon.stub(console, "warn");
+            // Create valid gzip but invalid JSON
+            const invalidJson = "not valid json {";
+            const compressed = pako.gzip(invalidJson);
+            const bufferObj = {
+                type: "Buffer",
+                data: Array.from(compressed),
+            };
+            const result = decompressBuffer(bufferObj);
+            assert.deepEqual(result, bufferObj);
+            assert.ok(consoleWarnStub.calledOnce);
+        });
+    });
+    describe("processResponse", () => {
+        it("should pass through null", () => {
+            assert.equal(processResponse(null), null);
+        });
+        it("should pass through undefined", () => {
+            assert.equal(processResponse(undefined), undefined);
+        });
+        it("should pass through primitives", () => {
+            assert.equal(processResponse("string"), "string");
+            assert.equal(processResponse(123), 123);
+            assert.equal(processResponse(true), true);
+        });
+        it("should pass through plain objects", () => {
+            const obj = { key: "value", nested: { num: 42 } };
+            assert.deepEqual(processResponse(obj), obj);
+        });
+        it("should pass through plain arrays", () => {
+            const arr = [1, "two", { three: 3 }];
+            assert.deepEqual(processResponse(arr), arr);
+        });
+        it("should decompress Buffer at root level", () => {
+            const originalData = { decompressed: true };
+            const buffer = createGzippedBuffer(originalData);
+            const result = processResponse(buffer);
+            assert.deepEqual(result, originalData);
+        });
+        it("should decompress nested Buffer fields", () => {
+            const statusData = { commands: { power: true } };
+            const response = {
+                plain: "data",
+                status: createGzippedBuffer(statusData),
+            };
+            const result = processResponse(response);
+            assert.equal(result.plain, "data");
+            assert.deepEqual(result.status, statusData);
+        });
+        it("should recursively decompress deeply nested Buffers", () => {
+            const innerData = { value: 42 };
+            const middleData = { inner: createGzippedBuffer(innerData) };
+            const response = {
+                outer: createGzippedBuffer(middleData),
+            };
+            const result = processResponse(response);
+            assert.deepEqual(result, { outer: { inner: { value: 42 } } });
+        });
+        it("should handle arrays containing Buffers", () => {
+            const itemData = { id: 1 };
+            const response = {
+                items: [createGzippedBuffer(itemData), { id: 2 }],
+            };
+            const result = processResponse(response);
+            assert.deepEqual(result.items, [{ id: 1 }, { id: 2 }]);
+        });
+        it("should handle mixed compressed and uncompressed fields", () => {
+            const compressedStatus = { commands: { power: true } };
+            const response = {
+                status: createGzippedBuffer(compressedStatus),
+                nvm: { user_parameters: { temperature: 22 } },
+                plain_field: "unchanged",
+            };
+            const result = processResponse(response);
+            assert.deepEqual(result.status, compressedStatus);
+            assert.deepEqual(result.nvm, { user_parameters: { temperature: 22 } });
+            assert.equal(result.plain_field, "unchanged");
+        });
+        it("should handle real-world DeviceInfo structure with compressed status", () => {
+            const statusData = {
+                commands: { power: true },
+                temperatures: { board: 25, enviroment: 20 },
+            };
+            const nvmData = {
+                user_parameters: {
+                    enviroment_1_temperature: 22,
+                    enviroment_2_temperature: 0,
+                    enviroment_3_temperature: 0,
+                    is_auto: false,
+                    is_sound_active: true,
+                },
+            };
+            const response = {
+                status: createGzippedBuffer(statusData),
+                nvm: createGzippedBuffer(nvmData),
+            };
+            const result = processResponse(response);
+            assert.deepEqual(result.status, statusData);
+            assert.deepEqual(result.nvm, nvmData);
+        });
+    });
+});

package/dist/esm/cli.js

@@ -11,7 +11,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { Command } from "commander";
 import readline from "readline";
 import { version } from "../package.json";
-import { configure, signIn } from "./library";
+import { NEW_API_URL, OLD_API_URL } from "./constants";
+import { configure, configureAmplify, getSession, signIn } from "./library";
+import { clearSession, createFileStorage } from "./token-storage";
 const promptPassword = () => {
     const rl = readline.createInterface({
         input: process.stdin,
@@ -36,11 +38,12 @@ const promptPassword = () => {
 };
 /**
  * Adds common options (username and password) to a command.
+ * Username is optional if a session already exists.
  * @param command The command to which options should be added.
  * @returns The command with options added.
  */
 const addAuthOptions = (command) => command
-    .requiredOption("-u, --username <username>", "Username")
+    .option("-u, --username <username>", "Username (optional if session exists)")
     .option("-p, --password <password>", "Password");
 /**
  * Adds MAC address option to a command.
@@ -48,17 +51,39 @@ const addAuthOptions = (command) => command
  * @returns The command with the MAC address option added.
  */
 const addMacOption = (command) => command.requiredOption("-m, --mac <macAddress>", "MAC address of the device");
+/**
+ * Adds legacy API option to a command.
+ * @param command The command to which the legacy option should be added.
+ * @returns The command with the legacy option added.
+ */
+const addLegacyOption = (command) => command.option("--legacy", "Use legacy API endpoint (old AWS Gateway)");
 /**
  * Handles common authentication and API initialization logic.
+ * Tries to use existing session first, falls back to sign-in if needed.
  * @param options The options passed from the CLI command.
  * @returns An object containing the normalized MAC, JWT token, and configured API instance.
  */
 const initializeCommand = (options) => __awaiter(void 0, void 0, void 0, function* () {
-    const { username, password, mac } = options;
+    const { username, password, mac, legacy = false } = options;
     const normalizedMac = mac.replace(/:/g, "");
-    const pwd = password || (yield promptPassword());
-    const jwtToken = yield signIn(username, pwd);
-    const api = configure();
+    // Initialize file storage for session persistence
+    const storage = createFileStorage();
+    configureAmplify(storage);
+    let jwtToken;
+    try {
+        // Try to get existing session first
+        jwtToken = yield getSession(false, legacy);
+    }
+    catch (_a) {
+        // No session, need to sign in
+        if (!username) {
+            throw new Error("No session found. Please provide --username to sign in.");
+        }
+        const pwd = password || (yield promptPassword());
+        jwtToken = yield signIn(username, pwd, legacy);
+    }
+    const apiUrl = legacy ? OLD_API_URL : NEW_API_URL;
+    const api = configure(apiUrl);
     return { normalizedMac, jwtToken, api };
 });
 /**
@@ -88,12 +113,28 @@ const createProgram = () => {
         .description("CLI tool for interacting with the Edilkamin API")
         .version(version);
     // Command: signIn
-    addAuthOptions(program.command("signIn").description("Sign in and retrieve a JWT token")).action((options) => __awaiter(void 0, void 0, void 0, function* () {
+    program
+        .command("signIn")
+        .description("Sign in and retrieve a JWT token")
+        .requiredOption("-u, --username <username>", "Username")
+        .option("-p, --password <password>", "Password")
+        .action((options) => __awaiter(void 0, void 0, void 0, function* () {
         const { username, password } = options;
+        // Initialize file storage for session persistence
+        const storage = createFileStorage();
+        configureAmplify(storage);
         const pwd = password || (yield promptPassword());
         const jwtToken = yield signIn(username, pwd);
         console.log("JWT Token:", jwtToken);
     }));
+    // Command: logout
+    program
+        .command("logout")
+        .description("Clear stored session")
+        .action(() => __awaiter(void 0, void 0, void 0, function* () {
+        yield clearSession();
+        console.log("Session cleared successfully");
+    }));
     // Generic getter commands
     [
         {
@@ -117,7 +158,7 @@ const createProgram = () => {
             getter: (api, jwtToken, mac) => api.getTargetTemperature(jwtToken, mac),
         },
     ].forEach(({ commandName, description, getter }) => {
-        addMacOption(addAuthOptions(program.command(commandName).description(description))).action((options) => executeGetter(options, getter));
+        addLegacyOption(addMacOption(addAuthOptions(program.command(commandName).description(description)))).action((options) => executeGetter(options, getter));
     });
     // Generic setter commands
     [
@@ -132,8 +173,68 @@ const createProgram = () => {
             setter: (api, jwtToken, mac, value) => api.setTargetTemperature(jwtToken, mac, value),
         },
     ].forEach(({ commandName, description, setter }) => {
-        addMacOption(addAuthOptions(program.command(commandName).description(description)).requiredOption("-v, --value <number>", "Value to set", parseFloat)).action((options) => executeSetter(options, setter));
+        addLegacyOption(addMacOption(addAuthOptions(program.command(commandName).description(description)).requiredOption("-v, --value <number>", "Value to set", parseFloat))).action((options) => executeSetter(options, setter));
     });
+    // Command: register
+    addLegacyOption(addAuthOptions(program
+        .command("register")
+        .description("Register a device with your account")))
+        .requiredOption("-m, --mac <macAddress>", "MAC address of the device")
+        .requiredOption("-s, --serial <serialNumber>", "Device serial number")
+        .requiredOption("-n, --name <deviceName>", "Device name")
+        .requiredOption("-r, --room <deviceRoom>", "Room name")
+        .action((options) => __awaiter(void 0, void 0, void 0, function* () {
+        const { username, password, mac, serial, name, room, legacy = false, } = options;
+        const normalizedMac = mac.replace(/:/g, "");
+        // Initialize file storage for session persistence
+        const storage = createFileStorage();
+        configureAmplify(storage);
+        let jwtToken;
+        try {
+            jwtToken = yield getSession(false, legacy);
+        }
+        catch (_a) {
+            if (!username) {
+                throw new Error("No session found. Please provide --username to sign in.");
+            }
+            const pwd = password || (yield promptPassword());
+            jwtToken = yield signIn(username, pwd, legacy);
+        }
+        const apiUrl = legacy ? OLD_API_URL : NEW_API_URL;
+        const api = configure(apiUrl);
+        const result = yield api.registerDevice(jwtToken, normalizedMac, serial, name, room);
+        console.log("Device registered successfully:");
+        console.log(JSON.stringify(result, null, 2));
+    }));
+    // Command: editDevice
+    addLegacyOption(addMacOption(addAuthOptions(program
+        .command("editDevice")
+        .description("Update device name and room"))))
+        .requiredOption("-n, --name <deviceName>", "Device name")
+        .requiredOption("-r, --room <deviceRoom>", "Room name")
+        .action((options) => __awaiter(void 0, void 0, void 0, function* () {
+        const { username, password, mac, name, room, legacy = false } = options;
+        const normalizedMac = mac.replace(/:/g, "");
+        // Initialize file storage for session persistence
+        const storage = createFileStorage();
+        configureAmplify(storage);
+        let jwtToken;
+        try {
+            jwtToken = yield getSession(false, legacy);
+        }
+        catch (_a) {
+            if (!username) {
+                throw new Error("No session found. Please provide --username to sign in.");
+            }
+            const pwd = password || (yield promptPassword());
+            jwtToken = yield signIn(username, pwd, legacy);
+        }
+        const apiUrl = legacy ? OLD_API_URL : NEW_API_URL;
+        const api = configure(apiUrl);
+        const result = yield api.editDevice(jwtToken, normalizedMac, name, room);
+        console.log("Device updated successfully:");
+        console.log(JSON.stringify(result, null, 2));
+    }));
     return program;
 };
 const main = () => {

package/dist/esm/constants.d.ts

@@ -1,2 +1,4 @@
+declare const OLD_API_URL = "https://fxtj7xkgc6.execute-api.eu-central-1.amazonaws.com/prod/";
+declare const NEW_API_URL = "https://the-mind-api.edilkamin.com/";
 declare const API_URL = "https://the-mind-api.edilkamin.com/";
-export { API_URL };
+export { API_URL, NEW_API_URL, OLD_API_URL };

package/dist/esm/constants.js

@@ -1,2 +1,4 @@
-const API_URL = "https://the-mind-api.edilkamin.com/";
-export { API_URL };
+const OLD_API_URL = "https://fxtj7xkgc6.execute-api.eu-central-1.amazonaws.com/prod/";
+const NEW_API_URL = "https://the-mind-api.edilkamin.com/";
+const API_URL = NEW_API_URL;
+export { API_URL, NEW_API_URL, OLD_API_URL };

package/dist/esm/index.d.ts

@@ -1,4 +1,7 @@
-export { API_URL } from "./constants";
-export { configure, signIn } from "./library";
-export { CommandsType, DeviceInfoType, StatusType, TemperaturesType, UserParametersType, } from "./types";
-export declare const deviceInfo: (jwtToken: string, macAddress: string) => Promise<import("./types").DeviceInfoType>, setPower: (jwtToken: string, macAddress: string, value: number) => Promise<import("axios").AxiosResponse<any, any, {}>>, setPowerOff: (jwtToken: string, macAddress: string) => Promise<import("axios").AxiosResponse<any, any, {}>>, setPowerOn: (jwtToken: string, macAddress: string) => Promise<import("axios").AxiosResponse<any, any, {}>>, 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<import("axios").AxiosResponse<any, any, {}>>;
+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 { clearSession } from "./token-storage";
+export { BufferEncodedType, CommandsType, DeviceAssociationBody, DeviceAssociationResponse, DeviceInfoRawType, DeviceInfoType, 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<import("axios").AxiosResponse<any, any, {}>>, setPowerOff: (jwtToken: string, macAddress: string) => Promise<import("axios").AxiosResponse<any, any, {}>>, setPowerOn: (jwtToken: string, macAddress: string) => Promise<import("axios").AxiosResponse<any, any, {}>>, 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<import("axios").AxiosResponse<any, any, {}>>;

package/dist/esm/index.js

@@ -1,4 +1,7 @@
 import { configure } from "./library";
-export { API_URL } from "./constants";
-export { configure, signIn } from "./library";
-export const { deviceInfo, setPower, setPowerOff, setPowerOn, getPower, getEnvironmentTemperature, getTargetTemperature, setTargetTemperature, } = configure();
+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 { clearSession } from "./token-storage";
+export const { deviceInfo, registerDevice, editDevice, setPower, setPowerOff, setPowerOn, getPower, getEnvironmentTemperature, getTargetTemperature, setTargetTemperature, } = configure();