edilkamin 1.7.2 → 1.7.4

package/dist/esm/{library.test.js → src/library.test.js}

@@ -8,7 +8,6 @@ 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";
@@ -24,15 +23,20 @@ const createGzippedBuffer = (data) => {
         data: Array.from(compressed),
     };
 };
+/**
+ * Helper to create a mock Response object for fetch.
+ */
+const mockResponse = (data, status = 200) => ({
+    ok: status >= 200 && status < 300,
+    status,
+    statusText: status >= 200 && status < 300 ? "OK" : "Error",
+    json: () => Promise.resolve(data),
+});
 describe("library", () => {
-    let axiosStub;
+    let fetchStub;
     const expectedToken = "mockJwtToken";
     beforeEach(() => {
-        axiosStub = sinon.stub(axios, "create").returns({
-            get: sinon.stub(),
-            put: sinon.stub(),
-            // eslint-disable-next-line  @typescript-eslint/no-explicit-any
-        });
+        fetchStub = sinon.stub(globalThis, "fetch");
     });
     afterEach(() => {
         sinon.restore();
@@ -182,29 +186,25 @@ describe("library", () => {
             "getTargetTemperature",
             "setTargetTemperature",
         ];
-        it("should create API methods with the correct baseURL", () => {
-            const baseURL = "https://example.com/api";
+        it("should create API methods with the correct baseURL", () => __awaiter(void 0, void 0, void 0, function* () {
+            const baseURL = "https://example.com/api/";
+            fetchStub.resolves(mockResponse({ test: "data" }));
             const api = configure(baseURL);
-            assert.deepEqual(axiosStub.args, [
-                [
-                    {
-                        baseURL,
-                    },
-                ],
-            ]);
             assert.deepEqual(Object.keys(api), expectedApi);
-        });
-        it("should create API methods with the default baseURL", () => {
+            // Verify baseURL is used when making a request
+            yield api.deviceInfo(expectedToken, "mockMac");
+            assert.ok(fetchStub.calledOnce);
+            assert.ok(fetchStub.firstCall.args[0].startsWith(baseURL));
+        }));
+        it("should create API methods with the default baseURL", () => __awaiter(void 0, void 0, void 0, function* () {
+            fetchStub.resolves(mockResponse({ test: "data" }));
             const api = configure();
-            assert.deepEqual(axiosStub.args, [
-                [
-                    {
-                        baseURL: API_URL,
-                    },
-                ],
-            ]);
             assert.deepEqual(Object.keys(api), expectedApi);
-        });
+            // Verify default baseURL is used when making a request
+            yield api.deviceInfo(expectedToken, "mockMac");
+            assert.ok(fetchStub.calledOnce);
+            assert.ok(fetchStub.firstCall.args[0].startsWith(API_URL));
+        }));
     });
     describe("API Methods", () => {
         const mockDeviceInfo = {
@@ -222,19 +222,16 @@ describe("library", () => {
                 },
             },
         };
-        it("should call axios for deviceInfo", () => __awaiter(void 0, void 0, void 0, function* () {
-            const mockAxios = {
-                get: sinon.stub().resolves({ data: mockDeviceInfo }),
-            };
-            axiosStub.returns(mockAxios);
-            const api = configure("https://example.com/api");
+        it("should call fetch for deviceInfo", () => __awaiter(void 0, void 0, void 0, function* () {
+            fetchStub.resolves(mockResponse(mockDeviceInfo));
+            const api = configure("https://example.com/api/");
             const result = yield api.deviceInfo(expectedToken, "mockMacAddress");
-            assert.deepEqual(mockAxios.get.args, [
-                [
-                    "device/mockMacAddress/info",
-                    { headers: { Authorization: `Bearer ${expectedToken}` } },
-                ],
-            ]);
+            assert.ok(fetchStub.calledOnce);
+            assert.equal(fetchStub.firstCall.args[0], "https://example.com/api/device/mockMacAddress/info");
+            assert.deepEqual(fetchStub.firstCall.args[1], {
+                method: "GET",
+                headers: { Authorization: `Bearer ${expectedToken}` },
+            });
             assert.deepEqual(result, mockDeviceInfo);
         }));
         // Tests for setPowerOn and setPowerOff
@@ -250,28 +247,25 @@ describe("library", () => {
                 expectedValue: 0,
             },
         ].forEach(({ method, call, expectedValue }) => {
-            it(`should call axios for ${method}`, () => __awaiter(void 0, void 0, void 0, function* () {
-                const mockAxios = {
-                    put: sinon.stub().resolves({ status: 200 }),
-                };
-                axiosStub.returns(mockAxios);
-                const api = configure("https://example.com/api");
+            it(`should call fetch for ${method}`, () => __awaiter(void 0, void 0, void 0, function* () {
+                fetchStub.resolves(mockResponse({ success: true }));
+                const api = configure("https://example.com/api/");
                 // Invoke the method using the mapped call function
-                const result = yield call(api);
-                assert.deepEqual(mockAxios.put.args, [
-                    [
-                        "mqtt/command",
-                        {
-                            mac_address: "mockMacAddress",
-                            name: "power",
-                            value: expectedValue,
-                        },
-                        {
-                            headers: { Authorization: "Bearer mockToken" },
-                        },
-                    ],
-                ]);
-                assert.equal(result.status, 200);
+                yield call(api);
+                assert.ok(fetchStub.calledOnce);
+                assert.equal(fetchStub.firstCall.args[0], "https://example.com/api/mqtt/command");
+                assert.deepEqual(fetchStub.firstCall.args[1], {
+                    method: "PUT",
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: "Bearer mockToken",
+                    },
+                    body: JSON.stringify({
+                        mac_address: "mockMacAddress",
+                        name: "power",
+                        value: expectedValue,
+                    }),
+                });
             }));
         });
         const getterTests = [
@@ -292,19 +286,16 @@ describe("library", () => {
             },
         ];
         getterTests.forEach(({ method, call, expectedResult }) => {
-            it(`should call axios and return the correct value for ${method}`, () => __awaiter(void 0, void 0, void 0, function* () {
-                const mockAxios = {
-                    get: sinon.stub().resolves({ data: mockDeviceInfo }),
-                };
-                axiosStub.returns(mockAxios);
-                const api = configure("https://example.com/api");
+            it(`should call fetch and return the correct value for ${method}`, () => __awaiter(void 0, void 0, void 0, function* () {
+                fetchStub.resolves(mockResponse(mockDeviceInfo));
+                const api = configure("https://example.com/api/");
                 const result = yield call(api, expectedToken, "mockMacAddress");
-                assert.deepEqual(mockAxios.get.args, [
-                    [
-                        "device/mockMacAddress/info",
-                        { headers: { Authorization: `Bearer ${expectedToken}` } },
-                    ],
-                ]);
+                assert.ok(fetchStub.calledOnce);
+                assert.equal(fetchStub.firstCall.args[0], "https://example.com/api/device/mockMacAddress/info");
+                assert.deepEqual(fetchStub.firstCall.args[1], {
+                    method: "GET",
+                    headers: { Authorization: `Bearer ${expectedToken}` },
+                });
                 assert.equal(result, expectedResult);
             }));
         });
@@ -320,119 +311,100 @@ describe("library", () => {
             },
         ];
         setterTests.forEach(({ method, call, payload }) => {
-            it(`should call axios and send the correct payload for ${method}`, () => __awaiter(void 0, void 0, void 0, function* () {
-                const mockAxios = {
-                    put: sinon.stub().resolves({ status: 200 }),
-                };
-                axiosStub.returns(mockAxios);
-                const api = configure("https://example.com/api");
-                const result = yield call(api, expectedToken, "mockMacAddress", payload.value);
-                assert.deepEqual(mockAxios.put.args, [
-                    [
-                        "mqtt/command",
-                        Object.assign({ mac_address: "mockMacAddress" }, payload),
-                        {
-                            headers: { Authorization: `Bearer ${expectedToken}` },
-                        },
-                    ],
-                ]);
-                assert.equal(result.status, 200);
+            it(`should call fetch and send the correct payload for ${method}`, () => __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", payload.value);
+                assert.ok(fetchStub.calledOnce);
+                assert.equal(fetchStub.firstCall.args[0], "https://example.com/api/mqtt/command");
+                assert.deepEqual(fetchStub.firstCall.args[1], {
+                    method: "PUT",
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${expectedToken}`,
+                    },
+                    body: JSON.stringify(Object.assign({ mac_address: "mockMacAddress" }, payload)),
+                });
             }));
         });
     });
     describe("registerDevice", () => {
         it("should call POST /device with correct payload", () => __awaiter(void 0, void 0, void 0, function* () {
-            const mockResponse = {
+            const mockResponseData = {
                 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");
+            fetchStub.resolves(mockResponse(mockResponseData));
+            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);
+            assert.ok(fetchStub.calledOnce);
+            assert.equal(fetchStub.firstCall.args[0], "https://example.com/api/device");
+            assert.deepEqual(fetchStub.firstCall.args[1], {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${expectedToken}`,
+                },
+                body: JSON.stringify({
+                    macAddress: "AABBCCDDEEFF",
+                    deviceName: "Test Stove",
+                    deviceRoom: "Living Room",
+                    serialNumber: "EDK123",
+                }),
+            });
+            assert.deepEqual(result, mockResponseData);
         }));
         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");
+            fetchStub.resolves(mockResponse({}));
+            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");
+            const body = JSON.parse(fetchStub.firstCall.args[1].body);
+            assert.equal(body.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");
+            fetchStub.resolves(mockResponse({}));
+            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, "");
+            const body = JSON.parse(fetchStub.firstCall.args[1].body);
+            assert.equal(body.deviceName, "");
+            assert.equal(body.deviceRoom, "");
         }));
     });
     describe("editDevice", () => {
         it("should call PUT /device/{mac} with correct payload", () => __awaiter(void 0, void 0, void 0, function* () {
-            const mockResponse = {
+            const mockResponseData = {
                 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");
+            fetchStub.resolves(mockResponse(mockResponseData));
+            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);
+            assert.ok(fetchStub.calledOnce);
+            assert.equal(fetchStub.firstCall.args[0], "https://example.com/api/device/AABBCCDDEEFF");
+            assert.deepEqual(fetchStub.firstCall.args[1], {
+                method: "PUT",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${expectedToken}`,
+                },
+                body: JSON.stringify({
+                    deviceName: "Updated Name",
+                    deviceRoom: "Basement",
+                }),
+            });
+            assert.deepEqual(result, mockResponseData);
         }));
         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");
+            fetchStub.resolves(mockResponse({}));
+            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, "");
+            const body = JSON.parse(fetchStub.firstCall.args[1].body);
+            assert.equal(body.deviceName, "");
+            assert.equal(body.deviceRoom, "");
         }));
     });
     describe("deviceInfo with compressed responses", () => {
@@ -441,7 +413,7 @@ describe("library", () => {
                 commands: { power: true },
                 temperatures: { enviroment: 19, board: 25 },
             };
-            const mockResponse = {
+            const mockResponseData = {
                 status: createGzippedBuffer(statusData),
                 nvm: {
                     user_parameters: {
@@ -449,11 +421,8 @@ describe("library", () => {
                     },
                 },
             };
-            const mockAxios = {
-                get: sinon.stub().resolves({ data: mockResponse }),
-            };
-            axiosStub.returns(mockAxios);
-            const api = configure("https://example.com/api");
+            fetchStub.resolves(mockResponse(mockResponseData));
+            const api = configure("https://example.com/api/");
             const result = yield api.deviceInfo(expectedToken, "mockMacAddress");
             assert.deepEqual(result.status, statusData);
         }));
@@ -467,18 +436,15 @@ describe("library", () => {
                     is_sound_active: true,
                 },
             };
-            const mockResponse = {
+            const mockResponseData = {
                 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");
+            fetchStub.resolves(mockResponse(mockResponseData));
+            const api = configure("https://example.com/api/");
             const result = yield api.deviceInfo(expectedToken, "mockMacAddress");
             assert.deepEqual(result.nvm, nvmData);
         }));
@@ -496,15 +462,12 @@ describe("library", () => {
                     is_sound_active: false,
                 },
             };
-            const mockResponse = {
+            const mockResponseData = {
                 status: createGzippedBuffer(statusData),
                 nvm: createGzippedBuffer(nvmData),
             };
-            const mockAxios = {
-                get: sinon.stub().resolves({ data: mockResponse }),
-            };
-            axiosStub.returns(mockAxios);
-            const api = configure("https://example.com/api");
+            fetchStub.resolves(mockResponse(mockResponseData));
+            const api = configure("https://example.com/api/");
             const result = yield api.deviceInfo(expectedToken, "mockMacAddress");
             assert.deepEqual(result.status, statusData);
             assert.deepEqual(result.nvm, nvmData);
@@ -514,15 +477,12 @@ describe("library", () => {
                 commands: { power: true },
                 temperatures: { enviroment: 19 },
             };
-            const mockResponse = {
+            const mockResponseData = {
                 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");
+            fetchStub.resolves(mockResponse(mockResponseData));
+            const api = configure("https://example.com/api/");
             const result = yield api.getPower(expectedToken, "mockMacAddress");
             assert.equal(result, true);
         }));
@@ -531,15 +491,12 @@ describe("library", () => {
                 commands: { power: true },
                 temperatures: { enviroment: 19, board: 25 },
             };
-            const mockResponse = {
+            const mockResponseData = {
                 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");
+            fetchStub.resolves(mockResponse(mockResponseData));
+            const api = configure("https://example.com/api/");
             const result = yield api.getEnvironmentTemperature(expectedToken, "mockMacAddress");
             assert.equal(result, 19);
         }));
@@ -549,17 +506,37 @@ describe("library", () => {
                     enviroment_1_temperature: 22,
                 },
             };
-            const mockResponse = {
+            const mockResponseData = {
                 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");
+            fetchStub.resolves(mockResponse(mockResponseData));
+            const api = configure("https://example.com/api/");
             const result = yield api.getTargetTemperature(expectedToken, "mockMacAddress");
             assert.equal(result, 22);
         }));
     });
+    describe("Error Handling", () => {
+        const errorTests = [
+            { status: 400, statusText: "Bad Request" },
+            { status: 401, statusText: "Unauthorized" },
+            { status: 404, statusText: "Not Found" },
+            { status: 500, statusText: "Internal Server Error" },
+        ];
+        errorTests.forEach(({ status, statusText }) => {
+            it(`should throw error when fetch returns ${status}`, () => __awaiter(void 0, void 0, void 0, function* () {
+                const errorResponse = {
+                    ok: false,
+                    status,
+                    statusText,
+                    json: () => Promise.resolve({ error: statusText }),
+                };
+                fetchStub.resolves(errorResponse);
+                const api = configure("https://example.com/api/");
+                yield assert.rejects(() => __awaiter(void 0, void 0, void 0, function* () { return api.deviceInfo(expectedToken, "mockMac"); }), {
+                    message: `HTTP ${status}: ${statusText}`,
+                });
+            }));
+        });
+    });
 });

package/dist/esm/src/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/src/serial-utils.test.d.ts

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

package/dist/esm/src/token-storage.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Custom storage adapter for AWS Amplify that persists to file system.
+ * Used for CLI to maintain sessions between invocations.
+ */
+export declare const createFileStorage: () => {
+    setItem: (key: string, value: string) => Promise<void>;
+    getItem: (key: string) => Promise<string | null>;
+    removeItem: (key: string) => Promise<void>;
+    clear: () => Promise<void>;
+};
+/**
+ * Clears all stored session data.
+ */
+export declare const clearSession: () => Promise<void>;

package/dist/esm/src/types.d.ts

@@ -0,0 +1,73 @@
+/**
+ * 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;
+}
+interface TemperaturesType {
+    board: number;
+    enviroment: number;
+}
+interface StatusType {
+    commands: CommandsType;
+    temperatures: TemperaturesType;
+}
+interface UserParametersType {
+    enviroment_1_temperature: number;
+    enviroment_2_temperature: number;
+    enviroment_3_temperature: number;
+    is_auto: boolean;
+    is_sound_active: boolean;
+}
+interface DeviceInfoType {
+    status: StatusType;
+    nvm: {
+        user_parameters: 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/dist/esm/src/types.js

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