homebridge-tuya-without-developer-account 1.0.0

package/dist/shared/accessories/WindowCoveringAccessory.js

@@ -0,0 +1,156 @@
+"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 SCHEMA_CODE = [
+    {
+        NAME: 'control',
+        CURRENT_POSITION: ['percent_state'],
+        TARGET_POSITION_CONTROL: ['control', 'mach_operate'],
+        TARGET_POSITION_PERCENT: ['percent_control', 'position'],
+    },
+    {
+        NAME: 'control_2',
+        CURRENT_POSITION: ['percent_state'],
+        TARGET_POSITION_CONTROL: ['control_2', 'mach_operate'],
+        TARGET_POSITION_PERCENT: ['percent_control_2', 'position'],
+    },
+];
+class WindowCoveringAccessory extends BaseAccessory_1.default {
+    requiredSchema() {
+        return [SCHEMA_CODE[0].TARGET_POSITION_CONTROL]; //, SCHEMA_CODE[1].TARGET_POSITION_CONTROL];
+    }
+    configureServices() {
+        let amount = 1;
+        const schema = this.getSchema('control_2');
+        if (schema) {
+            amount = 2;
+        }
+        this.log.warn('Curtain amount:', amount);
+        for (let i = 0; i < amount; i++) {
+            this.configureCurrentPosition(i);
+            this.configurePositionState(i);
+            if (this.getSchema(...SCHEMA_CODE[i].TARGET_POSITION_PERCENT)) {
+                this.configureTargetPositionPercent(i);
+            }
+            else {
+                this.configureTargetPositionControl(i);
+            }
+        }
+    }
+    configureCurrentPosition(i) {
+        const currentSchema = this.getSchema(...SCHEMA_CODE[i].CURRENT_POSITION);
+        const targetSchema = this.getSchema(...SCHEMA_CODE[i].TARGET_POSITION_PERCENT);
+        const targetControlSchema = this.getSchema(...SCHEMA_CODE[i].TARGET_POSITION_CONTROL);
+        const service = this.accessory.getService(SCHEMA_CODE[i].NAME) ||
+            this.accessory.addService(this.Service.WindowCovering, SCHEMA_CODE[i].NAME, SCHEMA_CODE[i].NAME);
+        service.getCharacteristic(this.Characteristic.CurrentPosition)
+            .onGet(() => {
+            if (currentSchema) {
+                const status = this.getStatus(currentSchema.code);
+                return (0, util_1.limit)(status.value, 0, 100);
+            }
+            else if (targetSchema) {
+                const status = this.getStatus(targetSchema.code);
+                return (0, util_1.limit)(status.value, 0, 100);
+            }
+            const status = this.getStatus(targetControlSchema.code);
+            if (status.value === 'close' || status.value === 'FZ') {
+                return 0;
+            }
+            else if (status.value === 'stop' || status.value === 'STOP') {
+                return 50;
+            }
+            else if (status.value === 'open' || status.value === 'ZZ') {
+                return 100;
+            }
+            this.log.warn('Unknown CurrentPosition:', status.value);
+            return 50;
+        });
+    }
+    configurePositionState(i) {
+        const currentSchema = this.getSchema(...SCHEMA_CODE[i].CURRENT_POSITION);
+        const targetSchema = this.getSchema(...SCHEMA_CODE[i].TARGET_POSITION_PERCENT);
+        const { DECREASING, INCREASING, STOPPED } = this.Characteristic.PositionState;
+        const service = this.accessory.getService(SCHEMA_CODE[i].NAME) ||
+            this.accessory.addService(this.Service.WindowCovering, SCHEMA_CODE[i].NAME, SCHEMA_CODE[i].NAME);
+        service.getCharacteristic(this.Characteristic.PositionState)
+            .onGet(() => {
+            if (!currentSchema || !targetSchema) {
+                return STOPPED;
+            }
+            const currentStatus = this.getStatus(currentSchema.code);
+            const targetStatus = this.getStatus(targetSchema.code);
+            if (targetStatus.value === 100 && currentStatus.value !== 100) {
+                return INCREASING;
+            }
+            else if (targetStatus.value === 0 && currentStatus.value !== 0) {
+                return DECREASING;
+            }
+            else {
+                return STOPPED;
+            }
+        });
+    }
+    configureTargetPositionPercent(i) {
+        const schema = this.getSchema(...SCHEMA_CODE[i].TARGET_POSITION_PERCENT);
+        if (!schema) {
+            return;
+        }
+        const service = this.accessory.getService(SCHEMA_CODE[i].NAME) ||
+            this.accessory.addService(this.Service.WindowCovering, SCHEMA_CODE[i].NAME, SCHEMA_CODE[i].NAME);
+        service.getCharacteristic(this.Characteristic.TargetPosition)
+            .onGet(() => {
+            const status = this.getStatus(schema.code);
+            return (0, util_1.limit)(status.value, 0, 100);
+        })
+            .onSet(async (value) => {
+            await this.sendCommands([{ code: schema.code, value: value }], true);
+        });
+    }
+    configureTargetPositionControl(i) {
+        const schema = this.getSchema(...SCHEMA_CODE[i].TARGET_POSITION_CONTROL);
+        if (!schema) {
+            return;
+        }
+        const isOldSchema = !schema.property.range.includes('open');
+        const service = this.accessory.getService(SCHEMA_CODE[i].NAME) ||
+            this.accessory.addService(this.Service.WindowCovering, SCHEMA_CODE[i].NAME, SCHEMA_CODE[i].NAME);
+        service.getCharacteristic(this.Characteristic.TargetPosition)
+            .onGet(() => {
+            const status = this.getStatus(schema.code);
+            if (status.value === 'close' || status.value === 'FZ') {
+                return 0;
+            }
+            else if (status.value === 'stop' || status.value === 'STOP') {
+                return 50;
+            }
+            else if (status.value === 'open' || status.value === 'ZZ') {
+                return 100;
+            }
+            this.log.warn('Unknown TargetPosition:', status.value);
+            return 50;
+        })
+            .onSet(async (value) => {
+            let control;
+            if (value === 0) {
+                control = isOldSchema ? 'FZ' : 'close';
+            }
+            else if (value === 100) {
+                control = isOldSchema ? 'ZZ' : 'open';
+            }
+            else {
+                control = isOldSchema ? 'STOP' : 'stop';
+            }
+            await this.sendCommands([{ code: schema.code, value: control }], true);
+        })
+            .setProps({
+            minStep: 50,
+        });
+    }
+}
+exports.default = WindowCoveringAccessory;
+//# sourceMappingURL=WindowCoveringAccessory.js.map

package/dist/shared/accessories/WirelessSwitchAccessory.js

@@ -0,0 +1,42 @@
+"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 ProgrammableSwitchEvent_1 = require("./characteristic/ProgrammableSwitchEvent");
+const SCHEMA_CODE = {
+    ON: ['switch_mode1', 'switch1_value'],
+};
+class SwitchAccessory extends BaseAccessory_1.default {
+    requiredSchema() {
+        return [SCHEMA_CODE.ON];
+    }
+    configureServices() {
+        const schema = this.device.schema.filter(schema => schema.code.match(/switch_mode(\d+)/) || schema.code.match(/switch(\d+)_value/));
+        for (const _schema of schema) {
+            const name = (schema.length === 1) ? this.device.name : _schema.code;
+            this.configureSwitch(_schema, name);
+        }
+    }
+    configureSwitch(schema, name) {
+        const service = this.accessory.getService(schema.code)
+            || this.accessory.addService(this.Service.StatelessProgrammableSwitch, name, schema.code);
+        const group = schema.code.match(/switch_mode(\d+)/) || schema.code.match(/switch(\d+)_value/);
+        const index = group[1];
+        service.setCharacteristic(this.Characteristic.ServiceLabelIndex, index);
+        (0, ProgrammableSwitchEvent_1.configureProgrammableSwitchEvent)(this, service, schema);
+    }
+    async onDeviceStatusUpdate(status) {
+        super.onDeviceStatusUpdate(status);
+        for (const _status of status) {
+            const service = this.accessory.getService(_status.code);
+            if (!service) {
+                continue;
+            }
+            (0, ProgrammableSwitchEvent_1.onProgrammableSwitchEvent)(this, service, _status);
+        }
+    }
+}
+exports.default = SwitchAccessory;
+//# sourceMappingURL=WirelessSwitchAccessory.js.map

package/dist/shared/accessories/characteristic/Active.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureActive = configureActive;
+function configureActive(accessory, service, schema) {
+    if (!schema) {
+        return;
+    }
+    const { ACTIVE, INACTIVE } = accessory.Characteristic.Active;
+    service.getCharacteristic(accessory.Characteristic.Active)
+        .onGet(() => {
+        accessory.checkOnlineStatus();
+        const status = accessory.getStatus(schema.code);
+        return status.value ? ACTIVE : INACTIVE;
+    })
+        .onSet(async (value) => {
+        await accessory.sendCommands([{
+                code: schema.code,
+                value: (value === ACTIVE) ? true : false,
+            }], true);
+    });
+}
+//# sourceMappingURL=Active.js.map

package/dist/shared/accessories/characteristic/AirQuality.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureAirQuality = configureAirQuality;
+const TuyaDevice_1 = require("../../../cloud/device/TuyaDevice");
+const util_1 = require("../../util/util");
+function configureAirQuality(accessory, service, airQualitySchema, pm2_5Schema, pm10Schema, vocSchema) {
+    if (!airQualitySchema) {
+        return;
+    }
+    if (!service) {
+        service = accessory.accessory.getService(accessory.Service.AirQualitySensor)
+            || accessory.accessory.addService(accessory.Service.AirQualitySensor);
+    }
+    const property = airQualitySchema.property;
+    const multiple = Math.pow(10, property ? property.scale : 0);
+    const { UNKNOWN, EXCELLENT, GOOD, FAIR, INFERIOR, POOR } = accessory.Characteristic.AirQuality;
+    service.getCharacteristic(accessory.Characteristic.AirQuality)
+        .onGet(() => {
+        const status = accessory.getStatus(airQualitySchema.code);
+        if (airQualitySchema.type === TuyaDevice_1.TuyaDeviceSchemaType.Integer) {
+            const value = (0, util_1.limit)(status.value / multiple, 0, 1000);
+            if (value <= 10) {
+                return EXCELLENT;
+            }
+            else if (value <= 50) {
+                return GOOD;
+            }
+            else if (value <= 100) {
+                return FAIR;
+            }
+            else if (value <= 200) {
+                return INFERIOR;
+            }
+            else {
+                return POOR;
+            }
+        }
+        else if (airQualitySchema.type === TuyaDevice_1.TuyaDeviceSchemaType.Enum) {
+            if (status.value === 'great') {
+                return EXCELLENT;
+            }
+            else if (status.value === 'good') {
+                return GOOD;
+            }
+            else if (status.value === 'mild') {
+                return FAIR;
+            }
+            else if (status.value === 'medium') {
+                return INFERIOR;
+            }
+            else if (status.value === 'severe') {
+                return POOR;
+            }
+        }
+        return UNKNOWN;
+    });
+    pm2_5Schema && configureDensity(accessory, service, accessory.Characteristic.PM2_5Density, pm2_5Schema);
+    pm10Schema && configureDensity(accessory, service, accessory.Characteristic.PM10Density, pm10Schema);
+    vocSchema && configureDensity(accessory, service, accessory.Characteristic.VOCDensity, vocSchema);
+}
+function configureDensity(accessory, service, characteristic, schema) {
+    if (!schema) {
+        return;
+    }
+    const property = schema.property;
+    const multiple = Math.pow(10, property ? property.scale : 0);
+    service.getCharacteristic(characteristic)
+        .onGet(() => {
+        const status = accessory.getStatus(schema.code);
+        const value = (0, util_1.limit)(status.value / multiple, 0, 1000);
+        return value;
+    });
+}
+//# sourceMappingURL=AirQuality.js.map

package/dist/shared/accessories/characteristic/CurrentRelativeHumidity.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureCurrentRelativeHumidity = configureCurrentRelativeHumidity;
+const util_1 = require("../../util/util");
+function configureCurrentRelativeHumidity(accessory, service, schema) {
+    if (!schema) {
+        return;
+    }
+    if (!service) {
+        service = accessory.accessory.getService(accessory.Service.HumiditySensor)
+            || accessory.accessory.addService(accessory.Service.HumiditySensor);
+    }
+    const property = schema.property || {};
+    const props = (0, util_1.toHapProperty)(property);
+    const multiple = Math.pow(10, property['scale'] || 0);
+    service.getCharacteristic(accessory.Characteristic.CurrentRelativeHumidity)
+        .onGet(() => {
+        const status = accessory.getStatus(schema.code);
+        return (0, util_1.limit)(status.value / multiple, props['minValue'], props['maxValue']);
+    })
+        .setProps(props);
+}
+//# sourceMappingURL=CurrentRelativeHumidity.js.map

package/dist/shared/accessories/characteristic/CurrentTemperature.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureCurrentTemperature = configureCurrentTemperature;
+const util_1 = require("../../util/util");
+function configureCurrentTemperature(accessory, service, schema) {
+    if (!schema) {
+        return;
+    }
+    if (!service) {
+        service = accessory.accessory.getService(accessory.Service.TemperatureSensor)
+            || accessory.accessory.addService(accessory.Service.TemperatureSensor);
+    }
+    const property = schema.property || {};
+    const props = (0, util_1.toHapProperty)(property);
+    const multiple = Math.pow(10, property['scale'] || 0);
+    service.getCharacteristic(accessory.Characteristic.CurrentTemperature)
+        .onGet(() => {
+        const status = accessory.getStatus(schema.code);
+        return (0, util_1.limit)(status.value / multiple, props['minValue'], props['maxValue']);
+    })
+        .setProps(props);
+}
+//# sourceMappingURL=CurrentTemperature.js.map

package/dist/shared/accessories/characteristic/CurrentWeather.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureCurrentWeather = configureCurrentWeather;
+function configureCurrentWeather(accessory, weatherCondition) {
+    // First time
+    accessory.log.info('get current weather from Tuya.');
+    const res = accessory.deviceManager.getCurrentWeather(accessory.device.lat, accessory.device.lon);
+    res.then(result => Object.assign(weatherCondition, result));
+    // Controlling API call frequency
+    setInterval(() => {
+        const res = accessory.deviceManager.getCurrentWeather(accessory.device.lat, accessory.device.lon);
+        res.then(result => Object.assign(weatherCondition, result));
+    }, 10 * 60 * 1000); // 10 minutes
+    {
+        let service;
+        if (!service) {
+            service = accessory.accessory.getService(accessory.Service.TemperatureSensor)
+                || accessory.accessory.addService(accessory.Service.TemperatureSensor);
+        }
+        service.getCharacteristic(accessory.Characteristic.CurrentTemperature)
+            .onGet(() => {
+            return weatherCondition.current_weather.temp;
+        })
+            .setProps({
+            unit: '℃',
+            minValue: -273.15,
+            maxValue: 500.0,
+            minStep: 0.1,
+        });
+    }
+    {
+        let service;
+        if (!service) {
+            service = accessory.accessory.getService(accessory.Service.HumiditySensor)
+                || accessory.accessory.addService(accessory.Service.HumiditySensor);
+        }
+        service.getCharacteristic(accessory.Characteristic.CurrentRelativeHumidity)
+            .onGet(() => {
+            return weatherCondition.current_weather.humidity;
+        })
+            .setProps({
+            unit: '%',
+            minValue: 0.0,
+            maxValue: 100.0,
+            minStep: 0.1,
+        });
+    }
+}
+//# sourceMappingURL=CurrentWeather.js.map

package/dist/shared/accessories/characteristic/CurrentWeatherByOpenMeteo.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureCurrentWeatherByOpenMeteo = configureCurrentWeatherByOpenMeteo;
+function configureCurrentWeatherByOpenMeteo(accessory, weatherCondition) {
+    // First time
+    accessory.log.info('get current weather from Open-Meteo.');
+    const res = accessory.deviceManager.getCurrentWeatherByOpenMeteo(accessory.device.lat, accessory.device.lon);
+    res.then(result => Object.assign(weatherCondition, result));
+    // Controlling API call frequency
+    setInterval(() => {
+        const res = accessory.deviceManager.getCurrentWeatherByOpenMeteo(accessory.device.lat, accessory.device.lon);
+        res.then(result => Object.assign(weatherCondition, result));
+    }, 15 * 60 * 1000); // 15 minutes
+    {
+        let service;
+        if (!service) {
+            service = accessory.accessory.getService(accessory.Service.TemperatureSensor)
+                || accessory.accessory.addService(accessory.Service.TemperatureSensor);
+        }
+        service.getCharacteristic(accessory.Characteristic.CurrentTemperature)
+            .onGet(() => {
+            return weatherCondition.current.temperature_2m;
+        })
+            .setProps({
+            unit: weatherCondition.current_units.temperature_2m,
+            minValue: -273.15,
+            maxValue: 500.0,
+            minStep: 0.1,
+        });
+    }
+    {
+        let service;
+        if (!service) {
+            service = accessory.accessory.getService(accessory.Service.HumiditySensor)
+                || accessory.accessory.addService(accessory.Service.HumiditySensor);
+        }
+        service.getCharacteristic(accessory.Characteristic.CurrentRelativeHumidity)
+            .onGet(() => {
+            return weatherCondition.current.relative_humidity_2m;
+        })
+            .setProps({
+            unit: weatherCondition.current_units.relative_humidity_2m,
+            minValue: 0.0,
+            maxValue: 100.0,
+            minStep: 0.1,
+        });
+    }
+}
+//# sourceMappingURL=CurrentWeatherByOpenMeteo.js.map

package/dist/shared/accessories/characteristic/CurrentWetBulbGlobeTemperature.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureCurrentWetBulbGlobeTemperature = configureCurrentWetBulbGlobeTemperature;
+const SCHEMA_CODE = {
+    CURRENT_TEMP: ['va_temperature', 'temp_value'],
+    CURRENT_HUMIDITY: ['va_humidity', 'humidity_value'],
+};
+// Custom Characteristic. Depends on TemperatureHumiditySensorAccessory or somethings like.
+function configureCurrentWetBulbGlobeTemperature(accessory) {
+    const service = accessory.accessory.getService(accessory.Service.TemperatureSensor)
+        || accessory.accessory.addService(accessory.Service.TemperatureSensor);
+    service.getCharacteristic(accessory.Characteristic.CurrentTemperature)
+        .onGet(() => {
+        const rhSchema = accessory.getSchema(...SCHEMA_CODE.CURRENT_HUMIDITY);
+        const rh = accessory.getStatus(rhSchema.code)?.value || 1;
+        const tSchema = accessory.getSchema(...SCHEMA_CODE.CURRENT_TEMP);
+        const t = accessory.getStatus(tSchema.code)?.value || 1;
+        const rhProperty = rhSchema?.property || {};
+        const rhMultiple = Math.pow(10, rhProperty['scale'] || 0);
+        const tProperty = rhSchema?.property || {};
+        const tMultiple = Math.pow(10, tProperty['scale'] || 0);
+        return calculateWBGT(t / tMultiple, rh / rhMultiple).wbgtIndoor;
+    })
+        .setProps({
+        unit: '℃',
+        minValue: -273.15,
+        maxValue: 100,
+        minStep: 0.1,
+    });
+}
+function calculateWBGT(temperature, humidity) {
+    // 湿球温度の近似式（Stullの式）
+    const tw = temperature * Math.atan(0.151977 * Math.sqrt(humidity + 8.313659)) +
+        Math.atan(temperature + humidity) -
+        Math.atan(humidity - 1.676331) +
+        0.00391838 * Math.pow(humidity, 1.5) * Math.atan(0.023101 * humidity) -
+        4.686035;
+    // 屋外（直射日光あり）のWBGT近似式
+    const outdoor = 0.7 * tw + 0.2 * temperature + 0.1 * temperature;
+    // 屋内（直射日光なし）のWBGT近似式
+    const indoor = 0.7 * tw + 0.3 * temperature;
+    return {
+        wetBulbTemp: parseFloat(tw.toFixed(1)),
+        wbgtOutdoor: parseFloat(outdoor.toFixed(1)),
+        wbgtIndoor: parseFloat(indoor.toFixed(1)),
+    };
+}
+//# sourceMappingURL=CurrentWetBulbGlobeTemperature.js.map

package/dist/shared/accessories/characteristic/EnergyUsage.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureEnergyUsage = configureEnergyUsage;
+exports.createAmperesCharacteristic = createAmperesCharacteristic;
+function configureEnergyUsage(api, accessory, service, currentSchema, powerSchema, voltageSchema, totalSchema) {
+    if (currentSchema) {
+        const amperes = createAmperesCharacteristic(api);
+        if (!service.testCharacteristic(amperes)) {
+            service.addCharacteristic(amperes);
+        }
+        service.getCharacteristic(amperes).onGet(createStatusGetter(accessory, currentSchema, isUnit(currentSchema, 'mA') ? 1000 : 0));
+    }
+    if (powerSchema) {
+        const watts = createWattsCharacteristic(api);
+        if (!service.testCharacteristic(watts)) {
+            service.addCharacteristic(watts);
+        }
+        service.getCharacteristic(watts).onGet(createStatusGetter(accessory, powerSchema));
+    }
+    if (voltageSchema) {
+        const volts = createVoltsCharacteristic(api);
+        if (!service.testCharacteristic(volts)) {
+            service.addCharacteristic(volts);
+        }
+        service.getCharacteristic(volts).onGet(createStatusGetter(accessory, voltageSchema));
+    }
+    if (totalSchema) {
+        const kwh = createKilowattHourCharacteristic(api);
+        if (!service.testCharacteristic(kwh)) {
+            service.addCharacteristic(kwh);
+        }
+        service.getCharacteristic(kwh).onGet(createStatusGetter(accessory, totalSchema));
+    }
+}
+function isUnit(schema, ...units) {
+    return units.includes(schema.property.unit);
+}
+function createStatusGetter(accessory, schema, divisor = 1) {
+    const property = schema.property;
+    divisor *= Math.pow(10, property.scale);
+    return () => {
+        const status = accessory.getStatus(schema.code);
+        return status.value / divisor;
+    };
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function createAmperesCharacteristic(api) {
+    return class Amperes extends api.hap.Characteristic {
+        static { this.UUID = 'E863F126-079E-48FF-8F27-9C2605A29F52'; }
+        constructor() {
+            super('Amperes', Amperes.UUID, {
+                format: "float" /* api.hap.Formats.FLOAT */,
+                perms: ["ev" /* api.hap.Perms.NOTIFY */, "pr" /* api.hap.Perms.PAIRED_READ */],
+                unit: 'A',
+            });
+        }
+    };
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function createWattsCharacteristic(api) {
+    return class Watts extends api.hap.Characteristic {
+        static { this.UUID = 'E863F10D-079E-48FF-8F27-9C2605A29F52'; }
+        constructor() {
+            super('Consumption', Watts.UUID, {
+                format: "float" /* api.hap.Formats.FLOAT */,
+                perms: ["ev" /* api.hap.Perms.NOTIFY */, "pr" /* api.hap.Perms.PAIRED_READ */],
+                unit: 'W',
+            });
+        }
+    };
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function createVoltsCharacteristic(api) {
+    return class Volts extends api.hap.Characteristic {
+        static { this.UUID = 'E863F10A-079E-48FF-8F27-9C2605A29F52'; }
+        constructor() {
+            super('Volts', Volts.UUID, {
+                format: "float" /* api.hap.Formats.FLOAT */,
+                perms: ["ev" /* api.hap.Perms.NOTIFY */, "pr" /* api.hap.Perms.PAIRED_READ */],
+                unit: 'V',
+            });
+        }
+    };
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function createKilowattHourCharacteristic(api) {
+    return class KilowattHour extends api.hap.Characteristic {
+        static { this.UUID = 'E863F10C-079E-48FF-8F27-9C2605A29F52'; }
+        constructor() {
+            super('Total Consumption', KilowattHour.UUID, {
+                format: "float" /* api.hap.Formats.FLOAT */,
+                perms: ["ev" /* api.hap.Perms.NOTIFY */, "pr" /* api.hap.Perms.PAIRED_READ */],
+                unit: 'kWh',
+            });
+        }
+    };
+}
+//# sourceMappingURL=EnergyUsage.js.map