homebridge-bond 3.2.9

package/dist/Services.js

@@ -0,0 +1,218 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlameService = exports.WindowCoveringService = exports.ButtonService = exports.SwitchService = exports.LightbulbService = exports.FanService = void 0;
+const Device_1 = require("./interface/Device");
+const Observer_1 = require("./Observer");
+class FanService {
+    constructor(platform, accessory) {
+        let service = accessory.getService(platform.Service.Fan);
+        const device = accessory.context.device;
+        if (service === undefined) {
+            service = accessory.addService(platform.Service.Fan, accessory.displayName);
+        }
+        this.on = service.getCharacteristic(platform.Characteristic.On);
+        if (Device_1.Device.canSetSpeed(device)) {
+            this.rotationSpeed = service.getCharacteristic(platform.Characteristic.RotationSpeed);
+        }
+        if (Device_1.Device.hasReverseSwitch(device)) {
+            this.rotationDirection = service.getCharacteristic(platform.Characteristic.RotationDirection);
+        }
+    }
+}
+exports.FanService = FanService;
+class LightbulbService {
+    constructor(platform, accessory, name, subType) {
+        let service = accessory.getService(platform.Service.Lightbulb);
+        const device = accessory.context.device;
+        if (subType) {
+            service = accessory.getServiceById(platform.Service.Lightbulb, subType);
+        }
+        if (service === undefined) {
+            service = accessory.addService(platform.Service.Lightbulb, name, subType);
+        }
+        this.on = service.getCharacteristic(platform.Characteristic.On);
+        const brightness = service.getCharacteristic(platform.Characteristic.Brightness);
+        if (Device_1.Device.LThasBrightness(device)) {
+            this.brightness = brightness;
+        }
+        else {
+            // Fixing bug from 3.1.0 where brightness was added to lights unintentionally
+            service.removeCharacteristic(brightness);
+        }
+        this.subType = subType;
+    }
+    updateState(state) {
+        if (this.subType === 'UpLight') {
+            this.on.updateValue(state.up_light === 1 && state.light === 1);
+        }
+        else if (this.subType === 'DownLight') {
+            this.on.updateValue(state.down_light === 1 && state.light === 1);
+        }
+        else {
+            this.on.updateValue(state.light === 1);
+        }
+        if (this.brightness && state.brightness) {
+            this.brightness.updateValue(state.brightness);
+        }
+    }
+    observe(platform, bond, accessory) {
+        const device = accessory.context.device;
+        this.observeLight(platform, bond, device, accessory);
+        this.observeLightBrightness(platform, bond, device, accessory);
+    }
+    observeLight(platform, bond, device, accessory) {
+        Observer_1.Observer.set(this.on, (value, callback) => {
+            let promise;
+            const subtype = this.subType;
+            if (subtype === 'UpLight') {
+                promise = bond.api.toggleUpLight(device, callback);
+            }
+            else if (subtype === 'DownLight') {
+                promise = bond.api.toggleDownLight(device, callback);
+            }
+            else {
+                promise = bond.api.toggleLight(device, callback);
+            }
+            promise
+                .then(() => {
+                platform.debug(accessory, `Set light power: ${value}`);
+            })
+                .catch((error) => {
+                platform.error(accessory, `Error setting light power: ${error}`);
+            });
+        });
+    }
+    observeLightBrightness(platform, bond, device, accessory) {
+        if (!this.brightness) {
+            return;
+        }
+        Observer_1.Observer.set(this.brightness, (value, callback) => {
+            if (value === 0) {
+                // Value of 0 is the same as turning the light off. 
+                // Ignore and complete callback.
+                callback(null);
+                return;
+            }
+            bond.api.setBrightness(device, value, callback)
+                .then(() => {
+                platform.debug(accessory, `Set light brightness: ${value}`);
+            })
+                .catch((error) => {
+                platform.error(accessory, `Error setting light brightness: ${error}`);
+            });
+        });
+    }
+}
+exports.LightbulbService = LightbulbService;
+class SwitchService {
+    constructor(platform, accessory, name, subType) {
+        // Check for service by subtype
+        let service = accessory.getServiceById(platform.Service.Switch, subType);
+        if (service === undefined) {
+            service = accessory.addService(platform.Service.Switch, name, subType);
+        }
+        // Set the subtype if not defined
+        if (service.subtype === undefined) {
+            service.subtype = subType;
+        }
+        this.on = service.getCharacteristic(platform.Characteristic.On);
+        this.subType = subType;
+    }
+}
+exports.SwitchService = SwitchService;
+// ButtonService is a switch that resets itself after 500ms. This provides a 
+// button like experience that isn't available in homebridge.
+class ButtonService {
+    constructor(platform, accessory, name, subType) {
+        // Check for service by subtype
+        let service = accessory.getServiceById(platform.Service.Switch, subType);
+        if (service === undefined) {
+            service = accessory.addService(platform.Service.Switch, name, subType);
+        }
+        // Set the subtype if not defined
+        if (service.subtype === undefined) {
+            service.subtype = subType;
+        }
+        this.on = service.getCharacteristic(platform.Characteristic.On);
+        this.on.setValue(false);
+        this.on.on('set', () => {
+            const timer = setInterval(() => {
+                this.on.updateValue(false);
+                clearInterval(timer);
+            }, 500);
+        });
+        this.subType = subType;
+    }
+}
+exports.ButtonService = ButtonService;
+class WindowCoveringService {
+    constructor(platform, accessory) {
+        let service = accessory.getService(platform.Service.WindowCovering);
+        if (service === undefined) {
+            service = accessory.addService(platform.Service.WindowCovering, accessory.displayName);
+        }
+        this.currentPosition = service.getCharacteristic(platform.Characteristic.CurrentPosition);
+        this.targetPosition = service.getCharacteristic(platform.Characteristic.TargetPosition);
+        this.positionState = service.getCharacteristic(platform.Characteristic.PositionState);
+    }
+}
+exports.WindowCoveringService = WindowCoveringService;
+class FlameService {
+    constructor(platform, accessory, name, subType) {
+        let service = accessory.getService(platform.Service.Lightbulb);
+        const device = accessory.context.device;
+        if (subType) {
+            service = accessory.getServiceById(platform.Service.Lightbulb, subType);
+        }
+        if (service === undefined) {
+            service = accessory.addService(platform.Service.Lightbulb, name, subType);
+        }
+        this.on = service.getCharacteristic(platform.Characteristic.On);
+        if (Device_1.Device.FPhasFlame(device)) {
+            const flame = service.getCharacteristic(platform.Characteristic.Brightness);
+            this.flame = flame;
+        }
+    }
+    updateState(state) {
+        if (this.flame && state.flame) {
+            this.flame.updateValue(state.flame);
+        }
+    }
+    observe(platform, bond, accessory) {
+        const device = accessory.context.device;
+        this.observePower(platform, bond, device, accessory);
+        this.observeFlame(platform, bond, device, accessory);
+    }
+    observePower(platform, bond, device, accessory) {
+        Observer_1.Observer.set(this.on, (value, callback) => {
+            bond.api.togglePower(device, callback)
+                .then(() => {
+                platform.debug(accessory, `Set flame power: ${value}`);
+            })
+                .catch((error) => {
+                platform.error(accessory, `Error setting flame power: ${error}`);
+            });
+        });
+    }
+    observeFlame(platform, bond, device, accessory) {
+        if (!this.flame) {
+            return;
+        }
+        Observer_1.Observer.set(this.flame, (value, callback) => {
+            if (value === 0) {
+                // Value of 0 is the same as turning the flame off. 
+                // Ignore and complete callback.
+                callback(null);
+                return;
+            }
+            bond.api.setFlame(device, value, callback)
+                .then(() => {
+                platform.debug(accessory, `Set flame brightness: ${value}`);
+            })
+                .catch((error) => {
+                platform.error(accessory, `Error setting flame brightness: ${error}`);
+            });
+        });
+    }
+}
+exports.FlameService = FlameService;

package/dist/accessories/CeilingFanAccessory.js

@@ -0,0 +1,344 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CeilingFanAccessory = void 0;
+const Device_1 = require("../interface/Device");
+const Services_1 = require("../Services");
+const Observer_1 = require("../Observer");
+class CeilingFanAccessory {
+    constructor(platform, accessory, bond) {
+        const config = platform.config;
+        this.platform = platform;
+        this.accessory = accessory;
+        const fanSpeedValues = config.fan_speed_values;
+        const includeDimmer = config.include_dimmer;
+        const includeToggle = config.include_toggle_state;
+        const device = accessory.context.device;
+        this.values = Device_1.Device.fanSpeeds(device);
+        this.minStep = Math.floor(100 / this.values.length);
+        this.maxValue = this.minStep * this.values.length;
+        if (fanSpeedValues) {
+            this.minStep = 1;
+            this.maxValue = this.values.length;
+        }
+        this.fanService = new Services_1.FanService(platform, accessory);
+        if (device.properties.max_speed === undefined) {
+            if (Device_1.Device.canIncreaseDecreaseSpeed(device)) {
+                this.increaseSpeedService = new Services_1.ButtonService(platform, accessory, `${accessory.displayName} Increase Speed`, 'IncreaseSpeed');
+                this.decreaseSpeedService = new Services_1.ButtonService(platform, accessory, `${accessory.displayName} Decrease Speed`, 'DecreaseSpeed');
+            }
+            else {
+                this.removeService(`${accessory.displayName} Increase Speed`);
+                this.removeService(`${accessory.displayName} Decrease Speed`);
+                this.platform.error(accessory, 'Fan Speed is not supported (missing max_speed property or IncreaseSpeed/DescreaseSpeed actions).');
+            }
+        }
+        if (Device_1.Device.CFhasUpDownLight(device)) {
+            this.upLightService = new Services_1.LightbulbService(platform, accessory, `${accessory.displayName} Up Light`, 'UpLight');
+            this.downLightService = new Services_1.LightbulbService(platform, accessory, `${accessory.displayName} Down Light`, 'DownLight');
+            if (includeToggle) {
+                this.toggleUpLightService = new Services_1.ButtonService(platform, accessory, 'Toggle Up Light State', 'ToggleUpLight');
+                this.toggleDownLightService = new Services_1.ButtonService(platform, accessory, 'Toggle Down Light State', 'ToggleDownLight');
+            }
+            else {
+                // Remove services if previously added
+                this.removeService('Toggle Up Light State');
+                this.removeService('Toggle Down Light State');
+            }
+            if (includeDimmer && Device_1.Device.HasDimmer(device)) {
+                this.upLightDimmerService = new Services_1.SwitchService(platform, accessory, `${accessory.displayName} Up Light Dimmer`, 'UpLight');
+                this.downLightDimmerService = new Services_1.SwitchService(platform, accessory, `${accessory.displayName} Down Light Dimmer`, 'DownLight');
+            }
+            else {
+                // Remove services if previously added
+                this.removeService(`${accessory.displayName} Up Light Dimmer`);
+                this.removeService(`${accessory.displayName} Down Light Dimmer`);
+            }
+        }
+        else if (Device_1.Device.CFhasLightbulb(device)) {
+            this.lightService = new Services_1.LightbulbService(platform, accessory, `${accessory.displayName} Light`);
+            if (includeToggle) {
+                this.toggleLightService = new Services_1.ButtonService(platform, accessory, 'Toggle Light State', 'ToggleState');
+            }
+            else {
+                this.removeService('Toggle Light State');
+            }
+            if (includeDimmer && Device_1.Device.HasDimmer(device)) {
+                this.dimmerService = new Services_1.SwitchService(platform, accessory, `${accessory.displayName} Dimmer`, 'Dimmer');
+            }
+            else {
+                // Remove service if previously added
+                this.removeService(`${accessory.displayName} Dimmer`);
+            }
+        }
+        if (includeDimmer && Device_1.Device.HasSeparateDimmers(device)) {
+            this.increaseBrightnessService = new Services_1.SwitchService(platform, accessory, `${accessory.displayName} Increase Brightness`, 'IncreaseBrightness');
+            this.decreaseBrightnessService = new Services_1.SwitchService(platform, accessory, `${accessory.displayName} Decrease Brightness`, 'DecreaseBrightness');
+        }
+        else {
+            // Remove service if previously added
+            this.removeService(`${accessory.displayName} Increase Brightness`);
+            this.removeService(`${accessory.displayName} Decrease Brightness`);
+        }
+        this.observe(bond);
+    }
+    updateState(state) {
+        // Power
+        this.fanService.on.updateValue(state.power === 1);
+        // Speed
+        if (this.fanService.rotationSpeed) {
+            let value = 0;
+            if (state.speed && state.power === 1) {
+                const index = this.values.indexOf(state.speed) + 1;
+                const step = index * this.minStep;
+                value = step;
+            }
+            this.fanService.rotationSpeed.updateValue(value);
+        }
+        // Rotation direction
+        if (this.fanService.rotationDirection) {
+            let direction = 0;
+            if (state.direction) {
+                // Bond state direction is 1 / -1, Homekit direction is 1 / 0
+                direction = state.direction === 1 ? 1 : 0;
+                this.fanService.rotationDirection.updateValue(direction);
+            }
+        }
+        // Light
+        if (this.lightService) {
+            this.lightService.updateState(state);
+        }
+        // Up Light
+        if (this.upLightService) {
+            this.upLightService.updateState(state);
+        }
+        // Down Light
+        if (this.downLightService) {
+            this.downLightService.updateState(state);
+        }
+    }
+    observe(bond) {
+        const device = this.accessory.context.device;
+        this.observeFanPower(bond, device);
+        this.observeFanSpeed(bond, device);
+        this.observeFanDirection(bond, device);
+        this.observeFanIncreaseSpeed(bond, device);
+        this.observeFanDecreaseSpeed(bond, device);
+        if (this.lightService) {
+            this.lightService.observe(this.platform, bond, this.accessory);
+        }
+        this.observeLightToggle(bond, device, this.toggleLightService);
+        this.observeLightDimmer(bond, device, this.dimmerService);
+        if (this.upLightService) {
+            this.upLightService.observe(this.platform, bond, this.accessory);
+        }
+        this.observeLightToggle(bond, device, this.toggleUpLightService);
+        this.observeLightDimmer(bond, device, this.upLightDimmerService);
+        if (this.downLightService) {
+            this.downLightService.observe(this.platform, bond, this.accessory);
+        }
+        this.observeLightToggle(bond, device, this.toggleDownLightService);
+        this.observeLightDimmer(bond, device, this.downLightDimmerService);
+        this.observeLightIncreaseBrightness(bond, device, this.decreaseBrightnessService);
+        this.observeLightDecreaseBrightness(bond, device, this.increaseBrightnessService);
+        // Set initial state
+        bond.api.getState(device.id).then(state => {
+            this.updateState(state);
+        });
+    }
+    observeFanPower(bond, device) {
+        if (!Device_1.Device.hasOffOn(device)) {
+            this.platform.error(this.accessory, 'CeilingFanAccessory does not have required actions for fan service.');
+            return;
+        }
+        Observer_1.Observer.set(this.fanService.on, (value, callback) => {
+            bond.api.toggleFan(device, value, callback)
+                .then(() => {
+                this.platform.debug(this.accessory, `Set fan power: ${value}`);
+            })
+                .catch((error) => {
+                this.platform.error(this.accessory, `Error setting fan power: ${error}`);
+            });
+        });
+    }
+    observeFanSpeed(bond, device) {
+        if (!this.fanService.rotationSpeed) {
+            return;
+        }
+        const props = {
+            maxValue: this.maxValue,
+            minStep: this.minStep,
+        };
+        this.fanService.rotationSpeed.setProps(props);
+        Observer_1.Observer.set(this.fanService.rotationSpeed, (step, callback) => {
+            if (step === 0) {
+                // Step of 0 is the same as turning the fan off. This is handled in the fan power observer
+                callback(null);
+                return;
+            }
+            const index = step / this.minStep - 1;
+            const speed = this.values[index];
+            bond.api.setFanSpeed(device, speed, callback)
+                .then(() => {
+                this.platform.debug(this.accessory, `Set fan speed: ${speed}`);
+            })
+                .catch((error) => {
+                this.platform.error(this.accessory, `Error setting fan speed: ${error}`);
+            });
+        });
+    }
+    observeFanDirection(bond, device) {
+        if (!this.fanService.rotationDirection) {
+            return;
+        }
+        Observer_1.Observer.set(this.fanService.rotationDirection, (value, callback) => {
+            bond.api.toggleDirection(device, callback)
+                .then(() => {
+                this.platform.debug(this.accessory, `Set fan direction: ${value}`);
+            })
+                .catch((error) => {
+                this.platform.error(this.accessory, `Error setting fan direction: ${error}`);
+            });
+        });
+    }
+    observeFanIncreaseSpeed(bond, device) {
+        if (!this.increaseSpeedService) {
+            return;
+        }
+        Observer_1.Observer.set(this.increaseSpeedService.on, (value, callback) => {
+            bond.api.increaseSpeed(device, callback)
+                .then(() => {
+                this.platform.debug(this.accessory, `Increased fan speed: ${value}`);
+            })
+                .catch((error) => {
+                this.platform.error(this.accessory, `Error increasing fan speed: ${error}`);
+            });
+        });
+    }
+    observeFanDecreaseSpeed(bond, device) {
+        if (!this.decreaseSpeedService) {
+            return;
+        }
+        Observer_1.Observer.set(this.decreaseSpeedService.on, (value, callback) => {
+            bond.api.decreaseSpeed(device, callback)
+                .then(() => {
+                this.platform.debug(this.accessory, `Decreased fan speed: ${value}`);
+            })
+                .catch((error) => {
+                this.platform.error(this.accessory, `Error decreasing fan speed: ${error}`);
+            });
+        });
+    }
+    observeLightToggle(bond, device, service) {
+        if (!service) {
+            return;
+        }
+        Observer_1.Observer.set(service.on, (_, callback) => {
+            let promise;
+            const subtype = service.subType;
+            if (subtype === 'UpLight') {
+                promise = bond.api.toggleState(device, 'up_light', callback);
+            }
+            else if (subtype === 'DownLight') {
+                promise = bond.api.toggleState(device, 'down_light', callback);
+            }
+            else {
+                promise = bond.api.toggleState(device, 'light', callback);
+            }
+            promise
+                .then(() => {
+                this.platform.debug(this.accessory, 'Light state toggled');
+            })
+                .catch((error) => {
+                this.platform.error(this.accessory, `Error toggling light state: ${error}`);
+            });
+        });
+    }
+    observeLightDimmer(bond, device, service) {
+        if (!service) {
+            return;
+        }
+        Observer_1.Observer.set(service.on, (value, callback) => {
+            let promise;
+            if (value === true) {
+                const subtype = service.subType;
+                if (subtype === 'UpLight') {
+                    promise = bond.api.startUpLightDimmer(device, callback);
+                }
+                else if (subtype === 'DownLight') {
+                    promise = bond.api.startDownLightDimmer(device, callback);
+                }
+                else {
+                    promise = bond.api.startDimmer(device, callback);
+                }
+            }
+            else {
+                promise = bond.api.stop(device, callback);
+            }
+            promise
+                .then(() => {
+                this.platform.debug(this.accessory, `Toggled dimmer: ${value}`);
+            })
+                .catch((error) => {
+                this.platform.error(this.accessory, `Error toggling dimmer: ${error}`);
+            });
+        });
+    }
+    observeLightIncreaseBrightness(bond, device, downService) {
+        if (!this.increaseBrightnessService) {
+            return;
+        }
+        Observer_1.Observer.set(this.increaseBrightnessService.on, (value, callback) => {
+            let promise;
+            if (value === true) {
+                if (downService) {
+                    bond.api.stop(device);
+                    downService.on.updateValue(false);
+                }
+                promise = bond.api.startIncreasingBrightness(device, callback);
+            }
+            else {
+                promise = bond.api.stop(device, callback);
+            }
+            promise
+                .then(() => {
+                this.platform.debug(this.accessory, `Increased Brightness: ${value}`);
+            })
+                .catch((error) => {
+                this.platform.error(this.accessory, `Error increasing brightness: ${error}`);
+            });
+        });
+    }
+    observeLightDecreaseBrightness(bond, device, upService) {
+        if (!this.decreaseBrightnessService) {
+            return;
+        }
+        Observer_1.Observer.set(this.decreaseBrightnessService.on, (value, callback) => {
+            let promise;
+            if (value === true) {
+                if (upService) {
+                    bond.api.stop(device);
+                    upService.on.updateValue(false);
+                }
+                promise = bond.api.startDecreasingBrightness(device, callback);
+            }
+            else {
+                promise = bond.api.stop(device, callback);
+            }
+            promise
+                .then(() => {
+                this.platform.debug(this.accessory, `Decreased Brightness: ${value}`);
+            })
+                .catch((error) => {
+                this.platform.error(this.accessory, `Error decreasing brightness: ${error}`);
+            });
+        });
+    }
+    removeService(serviceName) {
+        const service = this.accessory.getService(serviceName);
+        if (service) {
+            this.accessory.removeService(service);
+            this.platform.log(`Removing Service ${serviceName}`);
+        }
+    }
+}
+exports.CeilingFanAccessory = CeilingFanAccessory;

package/dist/accessories/FireplaceAccessory.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FireplaceAccessory = void 0;
+const Device_1 = require("../interface/Device");
+const Observer_1 = require("../Observer");
+const Services_1 = require("../Services");
+class FireplaceAccessory {
+    constructor(platform, accessory, bond) {
+        this.platform = platform;
+        this.accessory = accessory;
+        this.flameService = new Services_1.FlameService(platform, accessory, accessory.displayName, 'Flame');
+        if (platform.config.include_toggle_state) {
+            this.toggleStateService = new Services_1.ButtonService(platform, accessory, 'Toggle State', 'ToggleState');
+        }
+        else {
+            this.removeService('Toggle State');
+        }
+        this.observe(bond);
+    }
+    updateState(state) {
+        this.flameService.updateState(state);
+    }
+    observe(bond) {
+        const device = this.accessory.context.device;
+        if (Device_1.Device.FPhasToggle(device)) {
+            this.flameService.observe(this.platform, bond, this.accessory);
+        }
+        else {
+            this.platform.error(this.accessory, 'FireplaceAccessory does not have required TogglePower action.');
+        }
+        this.observeToggle(bond);
+        // Set initial state
+        bond.api.getState(device.id).then(state => {
+            this.updateState(state);
+        });
+    }
+    observeToggle(bond) {
+        if (!this.toggleStateService) {
+            return;
+        }
+        const device = this.accessory.context.device;
+        Observer_1.Observer.set(this.toggleStateService.on, (_, callback) => {
+            bond.api.toggleState(device, 'power', callback)
+                .then(() => {
+                this.platform.debug(this.accessory, `${device.name} power state toggled`);
+            })
+                .catch((error) => {
+                this.platform.error(this.accessory, `Error toggling power state: ${error}`);
+            });
+        });
+    }
+    removeService(serviceName) {
+        const service = this.accessory.getService(serviceName);
+        if (service) {
+            this.accessory.removeService(service);
+        }
+    }
+}
+exports.FireplaceAccessory = FireplaceAccessory;

package/dist/accessories/GenericAccessory.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenericAccessory = void 0;
+const Device_1 = require("../interface/Device");
+const Observer_1 = require("../Observer");
+const Services_1 = require("../Services");
+class GenericAccessory {
+    constructor(platform, accessory, bond) {
+        this.platform = platform;
+        this.accessory = accessory;
+        this.switchService = new Services_1.SwitchService(platform, accessory, accessory.displayName, 'Power');
+        if (platform.config.include_toggle_state) {
+            this.toggleStateService = new Services_1.ButtonService(platform, accessory, 'Toggle State', 'ToggleState');
+        }
+        else {
+            this.removeService('Toggle State');
+        }
+        this.observe(bond);
+        this.observeToggle(bond);
+    }
+    updateState(state) {
+        this.switchService.on.updateValue(state.power === 1);
+    }
+    observe(bond) {
+        const device = this.accessory.context.device;
+        if (!Device_1.Device.GXhasToggle(device)) {
+            this.platform.error(this.accessory, 'GenericAccessory does not have required TogglePower action.');
+            return;
+        }
+        // Set initial state
+        bond.api.getState(device.id).then(state => {
+            this.updateState(state);
+        });
+        Observer_1.Observer.set(this.switchService.on, (value, callback) => {
+            bond.api.togglePower(device, callback)
+                .then(() => {
+                this.platform.debug(this.accessory, `Toggled power: ${value}`);
+            })
+                .catch((error) => {
+                this.platform.error(this.accessory, `Error toggling power: ${error}`);
+            });
+        });
+    }
+    observeToggle(bond) {
+        if (!this.toggleStateService) {
+            return;
+        }
+        const device = this.accessory.context.device;
+        Observer_1.Observer.set(this.toggleStateService.on, (_, callback) => {
+            bond.api.toggleState(device, 'power', callback)
+                .then(() => {
+                this.platform.debug(this.accessory, `${device.name} power state toggled`);
+            })
+                .catch((error) => {
+                this.platform.error(this.accessory, `Error toggling power state: ${error}`);
+            });
+        });
+    }
+    removeService(serviceName) {
+        const service = this.accessory.getService(serviceName);
+        if (service) {
+            this.accessory.removeService(service);
+        }
+    }
+}
+exports.GenericAccessory = GenericAccessory;