homebridge-tuya-without-developer-account 1.0.0

package/dist/shared/accessories/ThermostatAccessory.js

@@ -0,0 +1,192 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("../util/util");
+const BaseAccessory_1 = __importDefault(require("./BaseAccessory"));
+const CurrentTemperature_1 = require("./characteristic/CurrentTemperature");
+const TemperatureDisplayUnits_1 = require("./characteristic/TemperatureDisplayUnits");
+const SCHEMA_CODE = {
+    ON: ['switch'],
+    CURRENT_MODE: ['work_state', 'mode'],
+    TARGET_MODE: ['mode'],
+    CURRENT_TEMP: ['temp_current', 'temp_set'],
+    TARGET_TEMP: ['temp_set'],
+    TEMP_UNIT_CONVERT: ['temp_unit_convert', 'c_f'],
+};
+class ThermostatAccessory extends BaseAccessory_1.default {
+    requiredSchema() {
+        return [SCHEMA_CODE.CURRENT_TEMP, SCHEMA_CODE.TARGET_TEMP];
+    }
+    configureServices() {
+        this.configureCurrentState();
+        this.configureTargetState();
+        (0, CurrentTemperature_1.configureCurrentTemperature)(this, this.mainService(), this.getSchema(...SCHEMA_CODE.CURRENT_TEMP));
+        this.configureTargetTemp();
+        (0, TemperatureDisplayUnits_1.configureTempDisplayUnits)(this, this.mainService(), this.getSchema(...SCHEMA_CODE.TEMP_UNIT_CONVERT));
+    }
+    mainService() {
+        return this.accessory.getService(this.Service.Thermostat)
+            || this.accessory.addService(this.Service.Thermostat);
+    }
+    configureCurrentState() {
+        const { OFF, HEAT, COOL } = this.Characteristic.CurrentHeatingCoolingState;
+        this.mainService().getCharacteristic(this.Characteristic.CurrentHeatingCoolingState)
+            .onGet(() => {
+            const on = this.getStatus('switch');
+            if (on && on.value === false) {
+                return OFF;
+            }
+            const schema = this.getSchema(...SCHEMA_CODE.CURRENT_MODE);
+            if (!schema) {
+                // If don't support mode, compare current and target temp.
+                const currentSchema = this.getSchema(...SCHEMA_CODE.CURRENT_TEMP);
+                const targetSchema = this.getSchema(...SCHEMA_CODE.TARGET_TEMP);
+                if (!currentSchema || !targetSchema) {
+                    return OFF;
+                }
+                const current = this.getStatus(currentSchema.code);
+                const target = this.getStatus(targetSchema.code);
+                if (target.value > current.value) {
+                    return HEAT;
+                }
+                else if (target.value < current.value) {
+                    return COOL;
+                }
+                else {
+                    return OFF;
+                }
+            }
+            const status = this.getStatus(schema.code);
+            if (status.value === 'hot' || status.value === 'opened' || status.value === 'heating') {
+                return HEAT;
+            }
+            else if (status.value === 'cold' ||
+                status.value === 'eco' ||
+                status.value === 'idle' ||
+                status.value === 'window_opened') {
+                return COOL;
+            }
+            // Don't know how to display unsupported work mode.
+            return OFF;
+        });
+    }
+    configureTargetState() {
+        const { OFF, HEAT, COOL, AUTO } = this.Characteristic.TargetHeatingCoolingState;
+        const validValues = [AUTO];
+        // Thermostat valve may not support 'Power Off'
+        if (this.getStatus('switch')) {
+            validValues.push(OFF);
+        }
+        const schema = this.getSchema(...SCHEMA_CODE.TARGET_MODE);
+        const property = schema?.property;
+        if (property) {
+            if (property.range.includes('hot')) {
+                validValues.push(HEAT);
+            }
+            if (property.range.includes('cold') || property.range.includes('eco')) {
+                validValues.push(COOL);
+            }
+        }
+        this.mainService().getCharacteristic(this.Characteristic.TargetHeatingCoolingState)
+            .onGet(() => {
+            const on = this.getStatus('switch');
+            if (on && on.value === false) {
+                return OFF;
+            }
+            if (!schema) {
+                // If don't support mode, display auto.
+                return AUTO;
+            }
+            const status = this.getStatus(schema.code);
+            if (status.value === 'hot') {
+                return HEAT;
+            }
+            else if (status.value === 'cold' || status.value === 'eco') {
+                return COOL;
+            }
+            else if (status.value === 'auto' || status.value === 'temp_auto') {
+                return AUTO;
+            }
+            // Don't know how to display unsupported mode.
+            return AUTO;
+        })
+            .onSet(async (value) => {
+            const commands = [];
+            // Thermostat valve may not support 'Power Off'
+            const on = this.getStatus('switch');
+            if (on) {
+                if (value === OFF) {
+                    commands.push({
+                        code: 'switch',
+                        value: false,
+                    });
+                }
+                else if (on.value === false) {
+                    commands.push({
+                        code: 'switch',
+                        value: true,
+                    });
+                }
+            }
+            if (schema) {
+                if ((value === HEAT) && property.range.includes('hot')) {
+                    commands.push({ code: schema.code, value: 'hot' });
+                }
+                else if (value === COOL) {
+                    if (property.range.includes('eco')) {
+                        commands.push({ code: schema.code, value: 'eco' });
+                    }
+                    else if (property.range.includes('cold')) {
+                        commands.push({ code: schema.code, value: 'cold' });
+                    }
+                }
+                else if ((value === AUTO) && property.range.includes('auto')) {
+                    commands.push({ code: schema.code, value: 'auto' });
+                }
+            }
+            if (commands.length !== 0) {
+                await this.sendCommands(commands);
+            }
+        })
+            .setProps({ validValues });
+    }
+    // FIXME: For some reason, a limit is being imposed on the target temperature.
+    // Request to those who have the actual product: Please investigate whether ./characteristic/TargetTemperature can be used.
+    configureTargetTemp() {
+        const schema = this.getSchema(...SCHEMA_CODE.TARGET_TEMP);
+        if (!schema) {
+            this.log.warn('TargetTemperature not supported.');
+            return;
+        }
+        const property = schema.property;
+        let multiple = Math.pow(10, property.scale);
+        let props = {
+            minValue: Math.max(10, property.min / multiple),
+            maxValue: Math.min(38, property.max / multiple),
+            minStep: Math.max(0.1, property.step / multiple),
+        };
+        if (props.maxValue <= props.minValue) {
+            this.log.warn('Invalid schema: %o, props will be reset to the default value.', schema);
+            multiple = 1;
+            props = { minValue: 10, maxValue: 38, minStep: 1 };
+        }
+        this.log.debug('Set props for TargetTemperature:', props);
+        this.mainService().getCharacteristic(this.Characteristic.TargetTemperature)
+            .onGet(() => {
+            const status = this.getStatus(schema.code);
+            const temp = status.value / multiple;
+            return (0, util_1.limit)(temp, props.minValue, props.maxValue);
+        })
+            .onSet(async (value) => {
+            await this.sendCommands([{
+                    code: schema.code,
+                    value: value * multiple,
+                }]);
+        })
+            .setProps(props);
+    }
+}
+exports.default = ThermostatAccessory;
+//# sourceMappingURL=ThermostatAccessory.js.map

package/dist/shared/accessories/TowerRackAccessory.js

@@ -0,0 +1,157 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseAccessory_1 = __importDefault(require("./BaseAccessory"));
+const CurrentTemperature_1 = require("./characteristic/CurrentTemperature");
+const TargetTemperature_1 = require("./characteristic/TargetTemperature");
+const TemperatureDisplayUnits_1 = require("./characteristic/TemperatureDisplayUnits");
+const SCHEMA_CODE = {
+    ON: ['switch'],
+    TARGET_TEMP: ['temp_set'],
+    TARGET_MODE: ['mode'],
+    TEMP_UNIT_CONVERT: ['temp_unit_convert', 'c_f'],
+    CURRENT_TEMP: ['temp_current', 'temp_set'],
+    CURRENT_MODE: ['work_state', 'mode'],
+};
+class TowelRackAccessory extends BaseAccessory_1.default {
+    requiredSchema() {
+        return [SCHEMA_CODE.CURRENT_TEMP, SCHEMA_CODE.TARGET_TEMP];
+    }
+    configureServices() {
+        this.configureCurrentState();
+        this.configureTargetState();
+        (0, CurrentTemperature_1.configureCurrentTemperature)(this, this.mainService(), this.getSchema(...SCHEMA_CODE.CURRENT_TEMP));
+        (0, TargetTemperature_1.configureTargetTemperature)(this, this.mainService(), this.getSchema(...SCHEMA_CODE.TARGET_TEMP));
+        (0, TemperatureDisplayUnits_1.configureTempDisplayUnits)(this, this.mainService(), this.getSchema(...SCHEMA_CODE.TEMP_UNIT_CONVERT));
+    }
+    mainService() {
+        return this.accessory.getService(this.Service.Thermostat)
+            || this.accessory.addService(this.Service.Thermostat);
+    }
+    configureCurrentState() {
+        const { OFF, HEAT, COOL } = this.Characteristic.CurrentHeatingCoolingState;
+        this.mainService().getCharacteristic(this.Characteristic.CurrentHeatingCoolingState)
+            .onGet(() => {
+            const on = this.getStatus('switch');
+            if (on && on.value === false) {
+                return OFF;
+            }
+            const schema = this.getSchema(...SCHEMA_CODE.CURRENT_MODE);
+            if (!schema) {
+                // If don't support mode, compare current and target temp.
+                const currentSchema = this.getSchema(...SCHEMA_CODE.CURRENT_TEMP);
+                const targetSchema = this.getSchema(...SCHEMA_CODE.TARGET_TEMP);
+                if (!currentSchema || !targetSchema) {
+                    return OFF;
+                }
+                const current = this.getStatus(currentSchema.code);
+                const target = this.getStatus(targetSchema.code);
+                if (target.value > current.value) {
+                    return HEAT;
+                }
+                else if (target.value < current.value) {
+                    return COOL;
+                }
+                else {
+                    return OFF;
+                }
+            }
+            const status = this.getStatus(schema.code);
+            if (status.value === 'hot' || status.value === 'opened' || status.value === 'heating') {
+                return HEAT;
+            }
+            else if (status.value === 'cold' ||
+                status.value === 'eco' ||
+                status.value === 'idle' ||
+                status.value === 'window_opened') {
+                return COOL;
+            }
+            // Don't know how to display unsupported work mode.
+            return OFF;
+        });
+    }
+    configureTargetState() {
+        const { OFF, HEAT, COOL, AUTO } = this.Characteristic.TargetHeatingCoolingState;
+        const validValues = [AUTO];
+        // Thermostat valve may not support 'Power Off'
+        if (this.getStatus('switch')) {
+            validValues.push(OFF);
+        }
+        const schema = this.getSchema(...SCHEMA_CODE.TARGET_MODE);
+        const property = schema?.property;
+        if (property) {
+            if (property.range.includes('hot')) {
+                validValues.push(HEAT);
+            }
+            if (property.range.includes('cold') || property.range.includes('eco')) {
+                validValues.push(COOL);
+            }
+        }
+        this.mainService().getCharacteristic(this.Characteristic.TargetHeatingCoolingState)
+            .onGet(() => {
+            const on = this.getStatus('switch');
+            if (on && on.value === false) {
+                return OFF;
+            }
+            if (!schema) {
+                // If don't support mode, display auto.
+                return AUTO;
+            }
+            const status = this.getStatus(schema.code);
+            if (status.value === 'hot') {
+                return HEAT;
+            }
+            else if (status.value === 'cold' || status.value === 'eco') {
+                return COOL;
+            }
+            else if (status.value === 'auto' || status.value === 'temp_auto') {
+                return AUTO;
+            }
+            // Don't know how to display unsupported mode.
+            return AUTO;
+        })
+            .onSet(async (value) => {
+            const commands = [];
+            // Thermostat valve may not support 'Power Off'
+            const on = this.getStatus('switch');
+            if (on) {
+                if (value === OFF) {
+                    commands.push({
+                        code: 'switch',
+                        value: false,
+                    });
+                }
+                else if (on.value === false) {
+                    commands.push({
+                        code: 'switch',
+                        value: true,
+                    });
+                }
+            }
+            if (schema) {
+                if ((value === HEAT) && property.range.includes('hot')) {
+                    commands.push({ code: schema.code, value: 'hot' });
+                }
+                else if (value === COOL) {
+                    if (property.range.includes('eco')) {
+                        commands.push({ code: schema.code, value: 'eco' });
+                    }
+                    else if (property.range.includes('cold')) {
+                        commands.push({ code: schema.code, value: 'cold' });
+                    }
+                }
+                else if ((value === AUTO) && property.range.includes('auto')) {
+                    commands.push({ code: schema.code, value: 'auto' });
+                }
+            }
+            if (commands.length !== 0) {
+                await this.sendCommands(commands);
+            }
+        })
+            .setProps({ validValues });
+    }
+}
+exports.default = TowelRackAccessory;
+//# sourceMappingURL=TowerRackAccessory.js.map

package/dist/shared/accessories/ValveAccessory.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const TuyaDevice_1 = require("../../cloud/device/TuyaDevice");
+const BaseAccessory_1 = __importDefault(require("./BaseAccessory"));
+const Active_1 = require("./characteristic/Active");
+const Name_1 = require("./characteristic/Name");
+const SCHEMA_CODE = {
+    ON: ['switch', 'switch_1'],
+};
+class ValveAccessory extends BaseAccessory_1.default {
+    requiredSchema() {
+        return [SCHEMA_CODE.ON];
+    }
+    configureServices() {
+        const oldService = this.accessory.getService(this.Service.Valve);
+        if (oldService && oldService?.subtype === undefined) {
+            this.platform.log.warn('Remove old service:', oldService.UUID);
+            this.accessory.removeService(oldService);
+        }
+        const schema = SCHEMA_CODE.ON.map(code => this.getSchema(code))
+            .filter((s) => !!s && s.type === TuyaDevice_1.TuyaDeviceSchemaType.Boolean);
+        for (const _schema of schema) {
+            const name = (schema.length === 1) ? this.device.name : _schema.code;
+            this.configureValve(_schema, name);
+        }
+    }
+    configureValve(schema, name) {
+        const service = this.accessory.getService(schema.code)
+            || this.accessory.addService(this.Service.Valve, name, schema.code);
+        (0, Name_1.configureName)(this, service, name);
+        service.setCharacteristic(this.Characteristic.ValveType, this.Characteristic.ValveType.IRRIGATION);
+        const { NOT_IN_USE, IN_USE } = this.Characteristic.InUse;
+        service.getCharacteristic(this.Characteristic.InUse)
+            .onGet(() => {
+            const status = this.getStatus(schema.code);
+            return status.value ? IN_USE : NOT_IN_USE;
+        });
+        (0, Active_1.configureActive)(this, service, schema);
+    }
+}
+exports.default = ValveAccessory;
+//# sourceMappingURL=ValveAccessory.js.map

package/dist/shared/accessories/VibrationSensorAccessory.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseAccessory_1 = __importDefault(require("./BaseAccessory"));
+const SCHEMA_CODE = {
+    STATE: ['shock_state'],
+};
+class VibrationSensorAccessory extends BaseAccessory_1.default {
+    requiredSchema() {
+        return [SCHEMA_CODE.STATE];
+    }
+    configureServices() {
+        this.getMotionService().setCharacteristic(this.Characteristic.MotionDetected, false);
+    }
+    getMotionService() {
+        return this.accessory.getService(this.Service.MotionSensor)
+            || this.accessory.addService(this.Service.MotionSensor);
+    }
+    async onDeviceStatusUpdate(status) {
+        super.onDeviceStatusUpdate(status);
+        const motionSchema = this.getSchema(...SCHEMA_CODE.STATE);
+        const motionStatus = status.find(_status => _status.code === motionSchema.code);
+        if (motionStatus) {
+            this.onMotionDetected(motionStatus);
+        }
+    }
+    onMotionDetected(status) {
+        if (!this.initialized) {
+            return;
+        }
+        if (status.value !== 'vibration' && status.value !== 'drop') {
+            return;
+        }
+        this.log.info('Motion event:', status.value);
+        const characteristic = this.getMotionService().getCharacteristic(this.Characteristic.MotionDetected);
+        characteristic.updateValue(true);
+        if (this.timer) {
+            clearTimeout(this.timer);
+        }
+        this.timer = setTimeout(() => characteristic.updateValue(false), 3 * 1000);
+    }
+}
+exports.default = VibrationSensorAccessory;
+//# sourceMappingURL=VibrationSensorAccessory.js.map

package/dist/shared/accessories/WeatherStationAccessory.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseAccessory_1 = __importDefault(require("./BaseAccessory"));
+class TemperatureHumiditySensorAccessory extends BaseAccessory_1.default {
+    configureServices() {
+        const { temperatureSchemas, humiditySchemas } = this.getDynamicSchemaCodes();
+        temperatureSchemas.forEach((schema, index) => {
+            const serviceName = `Temperature Sensor ${index + 1}`;
+            const serviceSubtype = `temperature_sensor_${index + 1}`;
+            const service = this.accessory.getServiceById(this.Service.TemperatureSensor, serviceSubtype) ||
+                this.accessory.addService(this.Service.TemperatureSensor, serviceName, serviceSubtype);
+            service
+                .getCharacteristic(this.Characteristic.CurrentTemperature)
+                .onGet(() => {
+                const status = this.getStatus(schema.code);
+                if (status) {
+                    const property = this.getSchema(schema.code)?.property;
+                    const multiple = Math.pow(10, property.scale || 0);
+                    return Math.min(Math.max(status.value / multiple, -100), 100);
+                }
+                return 0; // Default value if no status is found
+            });
+        });
+        humiditySchemas.forEach((schema, index) => {
+            const serviceName = `Humidity Sensor ${index + 1}`;
+            const serviceSubtype = `humidity_sensor_${index + 1}`;
+            const service = this.accessory.getServiceById(this.Service.HumiditySensor, serviceSubtype) ||
+                this.accessory.addService(this.Service.HumiditySensor, serviceName, serviceSubtype);
+            service
+                .getCharacteristic(this.Characteristic.CurrentRelativeHumidity)
+                .onGet(() => {
+                const status = this.getStatus(schema.code);
+                if (status) {
+                    return status.value;
+                }
+                return 0; // Default value if no status is found
+            });
+        });
+    }
+    getDynamicSchemaCodes() {
+        const temperatureSchemas = [];
+        const humiditySchemas = [];
+        this.device.schema.forEach((schema) => {
+            if (schema.code.includes('ToutCh')) {
+                temperatureSchemas.push(schema);
+            }
+            else if (schema.code.includes('HoutCh')) {
+                humiditySchemas.push(schema);
+            }
+        });
+        return { temperatureSchemas, humiditySchemas };
+    }
+}
+exports.default = TemperatureHumiditySensorAccessory;
+//# sourceMappingURL=WeatherStationAccessory.js.map

package/dist/shared/accessories/WetBulbGlobeTemperatureAccessory.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseAccessory_1 = __importDefault(require("./BaseAccessory"));
+const TemperatureHumiditySensorAccessory_1 = __importDefault(require("./TemperatureHumiditySensorAccessory"));
+const CurrentWetBulbGlobeTemperature_1 = require("./characteristic/CurrentWetBulbGlobeTemperature");
+const SCHEMA_CODE = {
+    CURRENT_TEMP: ['va_temperature', 'temp_value'],
+    CURRENT_HUMIDITY: ['va_humidity', 'humidity_value'],
+};
+class WetBulbGlobeTemperatureAccessory extends BaseAccessory_1.default {
+    requiredSchema() {
+        return [SCHEMA_CODE.CURRENT_TEMP, SCHEMA_CODE.CURRENT_HUMIDITY];
+    }
+    configureServices() {
+        const helperAcessory = new TemperatureHumiditySensorAccessory_1.default(this.platform, this.accessory);
+        (0, CurrentWetBulbGlobeTemperature_1.configureCurrentWetBulbGlobeTemperature)(helperAcessory);
+    }
+}
+exports.default = WetBulbGlobeTemperatureAccessory;
+//# sourceMappingURL=WetBulbGlobeTemperatureAccessory.js.map

package/dist/shared/accessories/WhiteNoiseLightAccessory.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseAccessory_1 = __importDefault(require("./BaseAccessory"));
+const On_1 = require("./characteristic/On");
+const Light_1 = require("./characteristic/Light");
+const SCHEMA_CODE = {
+    LIGHT_ON: ['switch_led'],
+    LIGHT_COLOR: ['colour_data'],
+    MUSIC_ON: ['switch_music'],
+};
+class WhiteNoiseLightAccessory extends BaseAccessory_1.default {
+    requiredSchema() {
+        return [SCHEMA_CODE.LIGHT_ON, SCHEMA_CODE.MUSIC_ON];
+    }
+    configureServices() {
+        // Light
+        if (this.lightServiceType() === this.Service.Lightbulb) {
+            (0, Light_1.configureLight)(this, this.lightService(), this.getSchema(...SCHEMA_CODE.LIGHT_ON), undefined, undefined, this.lightColorSchema(), undefined);
+        }
+        else if (this.lightServiceType() === this.Service.Switch) {
+            (0, On_1.configureOn)(this, undefined, this.getSchema(...SCHEMA_CODE.LIGHT_ON));
+            const unusedService = this.accessory.getService(this.Service.Lightbulb);
+            unusedService && this.accessory.removeService(unusedService);
+        }
+        // White Noise
+        (0, On_1.configureOn)(this, undefined, this.getSchema(...SCHEMA_CODE.MUSIC_ON));
+    }
+    lightColorSchema() {
+        const colorSchema = this.getSchema(...SCHEMA_CODE.LIGHT_COLOR);
+        if (!colorSchema) {
+            return;
+        }
+        const { h, s, v } = (colorSchema.property || {});
+        if (!h || !s || !v) {
+            // Set sensible defaults for missing properties
+            colorSchema.property = {
+                h: { min: 0, scale: 0, unit: '', max: 360, step: 1 },
+                s: { min: 0, scale: 0, unit: '', max: 1000, step: 1 },
+                v: { min: 0, scale: 0, unit: '', max: 1000, step: 1 },
+            };
+        }
+        return colorSchema;
+    }
+    lightServiceType() {
+        if (this.lightColorSchema()) {
+            return this.Service.Lightbulb;
+        }
+        return this.Service.Switch;
+    }
+    lightService() {
+        return (this.accessory.getService(this.Service.Lightbulb) ||
+            this.accessory.addService(this.Service.Lightbulb));
+    }
+}
+exports.default = WhiteNoiseLightAccessory;
+//# sourceMappingURL=WhiteNoiseLightAccessory.js.map

package/dist/shared/accessories/WindowAccessory.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const WindowCoveringAccessory_1 = __importDefault(require("./WindowCoveringAccessory"));
+class WindowAccessory extends WindowCoveringAccessory_1.default {
+    mainService() {
+        return this.accessory.getService(this.Service.Window)
+            || this.accessory.addService(this.Service.Window);
+    }
+}
+exports.default = WindowAccessory;
+//# sourceMappingURL=WindowAccessory.js.map