@evops/lightwaverf 0.0.9 → 1.0.1

package/.dist/LightwaveAccount.d.ts

@@ -0,0 +1,11 @@
+import Debug, { Debugger } from "debug";
+import { LightwaveDevice } from "./LightwaveDevice";
+export declare class LightwaveAccount {
+    debug: Debug.Debugger;
+    email: string;
+    pin: string;
+    mainDebug: Debug.Debugger;
+    constructor(debug: Debugger, email: string, pin: string);
+    getConfiguration(callback?: (devices: LightwaveDevice[], error: any) => void): Promise<LightwaveDevice[] | undefined>;
+    parseRooms(lightwaveResponse: any, callback?: (devices: LightwaveDevice[], error: Error | null) => void): LightwaveDevice[] | undefined;
+}

package/.dist/LightwaveAccount.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LightwaveAccount = void 0;
+const LightwaveDevice_1 = require("./LightwaveDevice");
+class LightwaveAccount {
+    debug;
+    email;
+    pin;
+    mainDebug;
+    constructor(debug, email, pin) {
+        if (!email || !pin) {
+            throw "No email or pin specified. The server configuration (rooms, devices, etc.) cannot be obtained";
+        }
+        this.mainDebug = debug;
+        this.debug = debug.extend("account");
+        this.email = email;
+        this.pin = pin;
+    }
+    async getConfiguration(callback) {
+        this.debug("Getting rooms from LightWave");
+        var self = this;
+        var host = "https://control-api.lightwaverf.com";
+        function assertResponse(response) {
+            if (!response.ok) {
+                throw new Error("Network response was not ok: " + response.statusText);
+            }
+            return response.json();
+        }
+        let token = "";
+        try {
+            this.debug("Fetching token from LightWave", {
+                url: host + "/v1/user?password=****&username=****",
+            });
+            const userResponse = await fetch(host + "/v1/user?password=" + this.pin + "&username=" + this.email);
+            this.debug("User response: %O", userResponse);
+            const userData = await assertResponse(userResponse);
+            const authResponse = await fetch(host + "/v1/auth?application_key=" + userData.application_key);
+            const authData = await assertResponse(authResponse);
+            token = authData.token;
+            const deviceTypeResponse = await fetch(host + "/v1/device_type?nested=1", {
+                headers: {
+                    "X-LWRF-token": token,
+                    "X-LWRF-platform": "ios",
+                    "X-LWRF-skin": "lightwaverf",
+                },
+            });
+            const something = await assertResponse(deviceTypeResponse);
+            const userProfileResponse = await fetch(host + "/v1/user_profile?nested=1", {
+                headers: {
+                    "X-LWRF-token": token,
+                    "X-LWRF-platform": "ios",
+                    "X-LWRF-skin": "lightwaverf",
+                },
+            });
+            const userProfileData = await assertResponse(userProfileResponse);
+            return self.parseRooms(userProfileData, callback);
+        }
+        catch (error) {
+            this.debug("Error fetching configuration: %O", error);
+            if (!callback) {
+                throw error;
+            }
+            callback([], error);
+        }
+    }
+    parseRooms(lightwaveResponse, callback) {
+        this.debug("Parsing lightwaveResponse: ", lightwaveResponse.content.estates[0].locations[0].zones[0].rooms[0]
+            .devices);
+        const home = lightwaveResponse.content.estates[0].locations[0].zones[0];
+        const devices = [];
+        for (var i = 0; i < home.rooms.length; i++) {
+            var r = home.rooms[i];
+            this.debug("Room " + r.name + " with " + r.devices.length + " devices");
+            // Get device types
+            //   O: On/Off Switch
+            //   D: Dimmer
+            //   R: Radiator(s)
+            //   P: Open/Close
+            //   I: Inactive (i.e. not configured)
+            //   m: Mood (inactive)
+            //   M: Mood (active)
+            //   o: All Off
+            var deviceTypeMapping = new Map();
+            deviceTypeMapping.set(1, LightwaveDevice_1.LightwaveDeviceType.OnOff);
+            deviceTypeMapping.set(2, LightwaveDevice_1.LightwaveDeviceType.Dimmer);
+            deviceTypeMapping.set(3, LightwaveDevice_1.LightwaveDeviceType.OnOff);
+            for (var j = 0; j < r.devices.length; j++) {
+                var d = r.devices[j];
+                const device = new LightwaveDevice_1.LightwaveDevice(this.mainDebug, r.room_number, d.device_number, r.name, d.name, deviceTypeMapping.get(d.device_type_id));
+                devices.push(device);
+            }
+        }
+        if (!callback) {
+            return devices;
+        }
+        callback(devices, null);
+    }
+}
+exports.LightwaveAccount = LightwaveAccount;

package/.dist/LightwaveAccount.test.d.ts

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

package/.dist/LightwaveAccount.test.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const debug_1 = __importDefault(require("debug"));
+const fetch_vcr_1 = __importDefault(require("fetch-vcr"));
+const vitest_1 = require("vitest");
+const LightwaveAccount_1 = require("./LightwaveAccount");
+(0, vitest_1.describe)("LightwaveAccount tests", () => {
+    fetch_vcr_1.default.configure({
+        fixturePath: __dirname + "/.fixtures",
+        mode: "playback",
+    });
+    global.fetch = fetch_vcr_1.default;
+    (0, vitest_1.beforeEach)(() => {
+        // Setup code if needed
+        process.env.DEBUG = "lightwave*";
+        debug_1.default.enable(process.env.DEBUG);
+    });
+    (0, vitest_1.it)("should parse configuration into rooms", async () => {
+        const account = new LightwaveAccount_1.LightwaveAccount((0, debug_1.default)("lightwave-rf:test"), "some@user.com", "1234");
+        const devices = await account.getConfiguration();
+        (0, vitest_1.expect)(devices?.length).toBe(20);
+    });
+});

package/.dist/LightwaveDevice.d.ts

@@ -0,0 +1,21 @@
+import debug from "debug";
+export interface ILightwaveDevice {
+    roomId: number;
+    deviceId: number;
+    roomName: string;
+    deviceName: string;
+    deviceType: string;
+}
+export declare enum LightwaveDeviceType {
+    Dimmer = "D",
+    OnOff = "O"
+}
+export declare class LightwaveDevice implements ILightwaveDevice {
+    roomId: number;
+    deviceId: number;
+    roomName: string;
+    deviceName: string;
+    deviceType: LightwaveDeviceType;
+    debug: debug.Debugger;
+    constructor(debug: debug.Debugger, roomId: number, deviceId: number, roomName: string, deviceName: string, deviceType: LightwaveDeviceType);
+}

package/.dist/LightwaveDevice.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LightwaveDevice = exports.LightwaveDeviceType = void 0;
+var LightwaveDeviceType;
+(function (LightwaveDeviceType) {
+    LightwaveDeviceType["Dimmer"] = "D";
+    LightwaveDeviceType["OnOff"] = "O";
+})(LightwaveDeviceType || (exports.LightwaveDeviceType = LightwaveDeviceType = {}));
+class LightwaveDevice {
+    roomId;
+    deviceId;
+    roomName;
+    deviceName;
+    deviceType;
+    debug;
+    constructor(debug, roomId, deviceId, roomName, deviceName, deviceType) {
+        this.debug = debug.extend(deviceName);
+        this.roomId = roomId;
+        this.deviceId = deviceId;
+        this.roomName = roomName;
+        this.deviceName = deviceName;
+        this.deviceType = deviceType;
+    }
+}
+exports.LightwaveDevice = LightwaveDevice;

package/{dist → .dist}/LightwaveMessageProcessor.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import "./LightwaveTransaction";
 declare interface LightwaveMessageProcessor {
     process(message: Buffer): any;

package/{dist/LightwaveTextMessageProcessor.d.ts → .dist/LightwaveMessageProcessorForJson.d.ts}

@@ -1,8 +1,7 @@
-/// <reference types="node" />
 import { Debugger } from "debug";
-import "./LightwaveTransaction";
 import LightwaveMessageProcessor from "./LightwaveMessageProcessor";
-export default class LightwaveTextMessageProcessor implements LightwaveMessageProcessor {
+import "./LightwaveTransaction";
+export declare class LightwaveMessageProcessorForJson implements LightwaveMessageProcessor {
     debug: Debugger;
     constructor(debug: Debugger);
     process(message: Buffer): any;

package/.dist/LightwaveMessageProcessorForJson.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LightwaveMessageProcessorForJson = void 0;
+require("./LightwaveTransaction");
+class LightwaveMessageProcessorForJson {
+    debug;
+    constructor(debug) {
+        this.debug = debug.extend("jsonMessageProcessor");
+    }
+    process(message) {
+        this.debug("Processing message");
+        const textMessage = message.toString("utf-8").replace("*!", "");
+        const json = JSON.parse(textMessage);
+        const response = json;
+        response.id = json.trans;
+        response.error = json.error ?? null;
+        return response;
+    }
+    canProcess(message) {
+        this.debug("Checking if can process message");
+        return message.toString("utf-8").startsWith("*!");
+    }
+}
+exports.LightwaveMessageProcessorForJson = LightwaveMessageProcessorForJson;

package/{dist/LightwaveJsonMessageProcessor.d.ts → .dist/LightwaveMessageProcessorForText.d.ts}

@@ -1,8 +1,7 @@
-/// <reference types="node" />
 import { Debugger } from "debug";
-import "./LightwaveTransaction";
 import LightwaveMessageProcessor from "./LightwaveMessageProcessor";
-export declare class LightwaveJsonMessageProcessor implements LightwaveMessageProcessor {
+import "./LightwaveTransaction";
+export default class LightwaveMessageProcessorForText implements LightwaveMessageProcessor {
     debug: Debugger;
     constructor(debug: Debugger);
     process(message: Buffer): any;

package/{dist/LightwaveTextMessageProcessor.js → .dist/LightwaveMessageProcessorForText.js}

@@ -1,13 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 require("./LightwaveTransaction");
-class LightwaveTextMessageProcessor {
+class LightwaveMessageProcessorForText {
+    debug;
     constructor(debug) {
-        this.debug = debug.extend('textMessageProcessor');
+        this.debug = debug.extend("textMessageProcessor");
     }
     process(message) {
-        this.debug('Processing message');
-        const textMessage = message.toString('utf-8');
+        this.debug("Processing message");
+        const textMessage = message.toString("utf-8");
         var parts = textMessage.split(",");
         var trans = parts.splice(0, 1);
         var content = parts.join(",").replace(/(\r\n|\n|\r)/gm, "");
@@ -19,7 +20,7 @@ class LightwaveTextMessageProcessor {
     }
     canProcess(message) {
         this.debug("Checking if can process message");
-        return message.toString('utf-8').endsWith("\n");
+        return message.toString("utf-8").endsWith("\n");
     }
 }
-exports.default = LightwaveTextMessageProcessor;
+exports.default = LightwaveMessageProcessorForText;

package/.dist/LightwaveRFClient.d.ts

@@ -0,0 +1,35 @@
+import { Debugger } from "debug";
+import events from "events";
+import { LightwaveTransaction } from "./LightwaveTransaction";
+declare interface LightwaveRFClientInterface {
+    on(event: "ready", listener: (client: LightwaveRFClient) => void): this;
+    on(event: "deviceTurnedOn", listener: (room: number, device: number) => void): this;
+    on(event: "deviceTurnedOff", listener: (room: number, device: number) => void): this;
+    on(event: "deviceDimmed", listener: (room: number, device: number, dimPercentage: number) => void): this;
+    on(event: "registered", listener: () => void): this;
+}
+export declare class LightwaveRFClient extends events.EventEmitter implements LightwaveRFClientInterface {
+    private ip;
+    private senderSocket;
+    private receiverSocket;
+    private commandQueue;
+    private messageProcessors;
+    private debug;
+    private transactionListeners;
+    delay: number;
+    serial?: string;
+    mac?: string;
+    model?: string;
+    uptime?: number;
+    version?: string;
+    constructor(debug: Debugger, ip?: string);
+    connect(): Promise<void>;
+    disconnect(): Promise<[void, void]>;
+    private checkRegistration;
+    send(message: string | Buffer, callback?: (transaction: LightwaveTransaction | null, error: Error) => void): void;
+    private processSendQueue;
+    private exec;
+    private processRawMessage;
+    private processLightwaveMessage;
+}
+export {};

package/.dist/LightwaveRFClient.js

@@ -0,0 +1,217 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LightwaveRFClient = void 0;
+const dgram_1 = __importDefault(require("dgram"));
+const events_1 = __importDefault(require("events"));
+const LightwaveMessageProcessorForJson_1 = require("./LightwaveMessageProcessorForJson");
+const LightwaveMessageProcessorForText_1 = __importDefault(require("./LightwaveMessageProcessorForText"));
+const Queue_1 = require("./Queue");
+const LIGHTWAVE_LINK_SEND_PORT = 9760;
+const LIGHTWAVE_LINK_RECEIVE_PORT = 9761;
+class LightwaveRFClient extends events_1.default.EventEmitter {
+    ip;
+    senderSocket;
+    receiverSocket;
+    commandQueue = new Queue_1.Queue();
+    messageProcessors = [];
+    debug;
+    transactionListeners = new Map();
+    delay = 125;
+    serial;
+    mac;
+    model;
+    uptime;
+    version;
+    constructor(debug, ip = "255.255.255.255") {
+        super();
+        this.ip = ip;
+        this.debug = debug.extend("client");
+        this.senderSocket = dgram_1.default.createSocket("udp4");
+        this.senderSocket.unref();
+        this.receiverSocket = dgram_1.default.createSocket("udp4");
+        this.receiverSocket.unref();
+        this.messageProcessors.push(new LightwaveMessageProcessorForJson_1.LightwaveMessageProcessorForJson(this.debug));
+        this.messageProcessors.push(new LightwaveMessageProcessorForText_1.default(this.debug));
+    }
+    async connect() {
+        const { promise, resolve, reject } = Promise.withResolvers();
+        this.senderSocket.bind();
+        this.senderSocket.once("listening", () => {
+            this.receiverSocket.bind(LIGHTWAVE_LINK_RECEIVE_PORT);
+        });
+        this.debug("Binding receiver socket on address %s and port %d", this.ip, LIGHTWAVE_LINK_RECEIVE_PORT);
+        this.receiverSocket.on("message", (buffer) => {
+            this.debug("RAW: %o", buffer.toString("utf-8"));
+        });
+        this.receiverSocket.on("message", this.processRawMessage.bind(this));
+        this.receiverSocket.once("listening", () => {
+            this.debug("Receiver socket bound", this.receiverSocket.address());
+            resolve();
+        });
+        this.receiverSocket.on("error", (err) => {
+            reject(new Error("Error binding receiver socket", {
+                cause: err,
+            }));
+        });
+        return promise;
+    }
+    async disconnect() {
+        this.receiverSocket.removeAllListeners();
+        this.senderSocket.removeAllListeners();
+        const { promise: senderPromise, resolve: senderResolve } = Promise.withResolvers();
+        const { promise: receiverPromise, resolve: receiverResolve } = Promise.withResolvers();
+        this.senderSocket.close(senderResolve);
+        this.receiverSocket.close(receiverResolve);
+        return Promise.all([senderPromise, receiverPromise]);
+    }
+    checkRegistration() {
+        this.debug("Checking registration");
+        this.send("@H", (transaction, error) => {
+            if (error) {
+                this.debug("Error: %o", error);
+            }
+            this.debug(transaction);
+            this.emit("ready", this);
+        });
+    }
+    send(message, callback) {
+        const transaction = Math.round(Math.random() * Math.pow(10, 8));
+        const messageWithTransaction = `${transaction},${message}`;
+        const transactionDebug = this.debug.extend("tx:" + transaction);
+        this.transactionListeners.set(transaction, {
+            message: message,
+            debug: transactionDebug,
+            delay: this.delay,
+            callback: callback,
+        });
+        this.debug("Queueing message: %s", messageWithTransaction);
+        this.commandQueue.add({
+            id: transaction,
+            message: messageWithTransaction,
+            debug: transactionDebug,
+            callback,
+        });
+        this.processSendQueue();
+    }
+    async processSendQueue() {
+        if (this.commandQueue.busy) {
+            setTimeout(this.processSendQueue.bind(this), this.delay);
+            return;
+        }
+        const command = this.commandQueue.next();
+        if (!command)
+            return;
+        this.commandQueue.busy = true;
+        const transactionListener = this.transactionListeners.get(command.id);
+        const originalCallback = transactionListener.callback;
+        transactionListener.callback = (transaction, error) => {
+            this.commandQueue.busy = false;
+            originalCallback?.(transaction, error);
+            setTimeout(this.processSendQueue.bind(this), this.delay);
+        };
+        // If we didn't hear back within the timeout
+        setTimeout(() => {
+            const listener = this.transactionListeners.get(command.id);
+            if (!listener)
+                return;
+            originalCallback?.(null, new Error("Execution expired"));
+            this.transactionListeners.delete(command.id);
+            this.processSendQueue();
+        }, 5000);
+        const transactionDebug = this.debug.extend(`transaction:${command?.id}`);
+        transactionDebug("Starting new transaction");
+        this.exec(command.message);
+    }
+    exec(message) {
+        if (message === undefined)
+            return;
+        this.debug("Sending message: %s to %s on port %d", message, this.ip, LIGHTWAVE_LINK_SEND_PORT);
+        this.senderSocket.setBroadcast(this.ip === "255.255.255.255");
+        this.senderSocket.send(message, LIGHTWAVE_LINK_SEND_PORT, this.ip, (error, bytes) => {
+            if (error) {
+                this.debug("Message send errror: %o", error);
+            }
+            this.debug("Message sent: %s, length: %d", message, bytes);
+        });
+    }
+    processRawMessage(message, remoteInfo) {
+        this.debug("Message has come through from %o", remoteInfo);
+        this.debug("Message received: %o", message.toString("ascii"));
+        for (const messageProcessor of this.messageProcessors) {
+            if (messageProcessor.canProcess(message)) {
+                this.debug("Message can be processed by %s", messageProcessor.constructor.name);
+                const lightwaveMessage = messageProcessor.process(message);
+                this.processLightwaveMessage(lightwaveMessage);
+                return;
+            }
+        }
+        throw "Message cannot be processed";
+    }
+    processLightwaveMessage(lightwaveMessage) {
+        this.debug("Processing lightwave message: %o", lightwaveMessage);
+        this.debug("Current listeners: %o", this.transactionListeners);
+        this.debug("Link response fn", lightwaveMessage.fn);
+        // update info from link
+        if (lightwaveMessage.serial) {
+            this.serial ??= lightwaveMessage.serial;
+        }
+        if (lightwaveMessage.mac) {
+            this.mac ??= lightwaveMessage.mac;
+        }
+        if (lightwaveMessage.model) {
+            this.model ??= lightwaveMessage.prod;
+        }
+        if (lightwaveMessage.uptime) {
+            this.uptime = lightwaveMessage.uptime;
+        }
+        if (lightwaveMessage.ip) {
+            this.ip = lightwaveMessage.ip;
+        }
+        if (lightwaveMessage.fw) {
+            this.version ??= lightwaveMessage.fw;
+        }
+        // *!{"trans":530,"mac":"03:13:8D","time":1762607959,"pkt":"error","fn":"nonRegistered","payload":"Not yet registered. See WifiLink."}
+        if (lightwaveMessage.fn) {
+        }
+        // *!{"trans":531,"mac":"03:13:8D","time":1762607962,"type":"link","prod":"wfl","pairType":"local","msg":"success","class":"","serial":""}
+        if (lightwaveMessage.type === "link" &&
+            lightwaveMessage.msg === "success") {
+            this.emit("registered");
+        }
+        if (lightwaveMessage.fn === "on") {
+            this.emit("deviceTurnedOn", lightwaveMessage.room, lightwaveMessage.dev);
+        }
+        if (lightwaveMessage.fn === "off") {
+            this.emit("deviceTurnedOff", lightwaveMessage.room, lightwaveMessage.dev);
+        }
+        if (lightwaveMessage.fn === "dim") {
+            this.emit("deviceDimmed", lightwaveMessage.room, lightwaveMessage.dev, Math.round((lightwaveMessage.param / 32) * 100));
+        }
+        const listener = this.transactionListeners.get(lightwaveMessage.id);
+        if (!listener)
+            return;
+        if (lightwaveMessage.error?.match(/^ERR,6,/)) {
+            listener.delay = listener.delay * 2;
+            const msg = `${lightwaveMessage.id},!${listener.message}`;
+            this.debug("message errorred, retrying: %o, %o with delay: %o", msg, listener, listener.delay);
+            setTimeout(() => {
+                this.exec(msg);
+            }, Math.round(listener.delay));
+            return;
+        }
+        this.commandQueue.busy = false;
+        if (listener) {
+            listener.debug("Found transaction listener");
+            listener.callback(lightwaveMessage, null);
+            listener.debug("Transaction completed, removing listener");
+            this.transactionListeners.delete(lightwaveMessage.id);
+        }
+        else {
+            this.debug("Listener not found for message: %o", lightwaveMessage);
+        }
+    }
+}
+exports.LightwaveRFClient = LightwaveRFClient;

package/.dist/LightwaveRFClient.test.d.ts

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

package/.dist/LightwaveRFClient.test.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const debug_1 = __importDefault(require("debug"));
+const vitest_1 = require("vitest");
+const LightwaveRFClient_1 = require("./LightwaveRFClient");
+(0, vitest_1.describe)("LightwaveRFClient tests", () => {
+    let client;
+    (0, vitest_1.beforeEach)(async () => {
+        const { promise, resolve, reject } = Promise.withResolvers();
+        const logger = (0, debug_1.default)("lightwave:test");
+        logger("Starting LightwaveRFClient test");
+        client = new LightwaveRFClient_1.LightwaveRFClient(logger);
+        await client.connect();
+    });
+    (0, vitest_1.afterEach)(async () => {
+        return client.disconnect();
+    });
+    (0, vitest_1.it)("should initialize correctly", async () => {
+        process.stderr.write(process.env.DEBUG + "\n");
+    });
+});

package/{dist → .dist}/Queue.d.ts

@@ -3,5 +3,5 @@ export declare class Queue<T> {
     busy: boolean;
     get length(): number;
     add(item: T): void;
-    receive(): T | undefined;
+    next(): T | undefined;
 }

package/{dist → .dist}/Queue.js

@@ -2,17 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Queue = void 0;
 class Queue {
-    constructor() {
-        this.items = [];
-        this.busy = false;
-    }
+    items = [];
+    busy = false;
     get length() {
         return this.items.length;
     }
     add(item) {
         this.items.push(item);
     }
-    receive() {
+    next() {
         return this.items.shift();
     }
 }

package/.dist/index.d.ts

@@ -0,0 +1,58 @@
+import debug from "debug";
+import { EventEmitter } from "events";
+import { LightwaveAccount } from "./LightwaveAccount";
+import { ILightwaveDevice, LightwaveDevice } from "./LightwaveDevice";
+import { LightwaveRFClient } from "./LightwaveRFClient";
+export { LightwaveDeviceType } from "./LightwaveDevice";
+export { type ILightwaveDevice };
+declare class LightwaveRFConfiguration {
+    timeout?: number;
+    ip?: string;
+    file?: any;
+    host?: any;
+    email?: any;
+    pin?: any;
+}
+declare interface ILightwaveRF {
+    on(event: "deviceTurnedOn", listener: (roomId: number, deviceId: number) => void): this;
+    on(event: "deviceTurnedOff", listener: (roomId: number, deviceId: number) => void): this;
+    on(event: "deviceDimmed", listener: (roomId: number, deviceId: number, percentage: number) => void): this;
+}
+interface LightwaveEvents {
+    deviceTurnedOn: [number, number];
+    deviceTurnedOff: [number, number];
+    deviceDimmed: [number, number, number];
+}
+/** * LightwaveRF API
+ *
+ * @param object config The config
+ *
+ * An instance of the LightwaveRF API
+ */
+export default class LightwaveRF extends EventEmitter<LightwaveEvents> implements ILightwaveRF {
+    timeout: number;
+    queue: any;
+    ready: boolean;
+    awaitRegistrration: boolean;
+    currentTransactionNumber: number;
+    devices: Array<LightwaveDevice>;
+    messageCounter: number;
+    config: LightwaveRFConfiguration;
+    responseListeners: Map<number, any>;
+    lwClient: LightwaveRFClient;
+    lwAccount: LightwaveAccount;
+    debug: debug.Debugger;
+    constructor({ email, pin, ip, timeout }: LightwaveRFConfiguration);
+    get serial(): string | undefined;
+    get mac(): string | undefined;
+    get uptime(): number | undefined;
+    get model(): string | undefined;
+    get version(): string | undefined;
+    getDevices(): Promise<LightwaveDevice[]>;
+    turnOn({ roomId, deviceId, roomName, deviceName }: ILightwaveDevice): Promise<void>;
+    turnOff({ roomId, deviceId, roomName, deviceName }: ILightwaveDevice): Promise<void>;
+    dim({ roomId, deviceId, roomName, deviceName }: ILightwaveDevice, percentage: number): Promise<void>;
+    connect(): Promise<void>;
+    isRegistered(): Promise<boolean>;
+    ensureRegistration(): Promise<void>;
+}