signalk-shelly2 1.0.0

package/dist/index.js

@@ -0,0 +1,1015 @@
+"use strict";
+/*
+ * Copyright 2025 Scott Bender <scott@scottbender.net>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const camelcase_1 = __importDefault(require("camelcase"));
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const mdns = require('mdns-js');
+const device_1 = require("./device");
+const SERVICE_NAME = 'shelly';
+const deviceKey = (device) => device.id;
+function default_1(app) {
+    const error = app.error;
+    const debug = app.debug;
+    let sentMetaDevices = {};
+    let props;
+    let onStop = [];
+    let startedOnce = false;
+    let stopped = true;
+    let discoveredDevices = {};
+    let browser;
+    const plugin = {
+        start: function (properties) {
+            props = properties;
+            browser = mdns.createBrowser(mdns.tcp(SERVICE_NAME));
+            browser.on('ready', () => {
+                browser.discover();
+            });
+            browser.on('update', async (data) => {
+                if (Array.isArray(data.type) &&
+                    data.type[0].name === SERVICE_NAME &&
+                    data.fullname) {
+                    let deviceId = data.fullname.split('.', 1)[0];
+                    if (discoveredDevices[deviceId]) {
+                        return;
+                    }
+                    const gen = data.txt.find((txt) => txt.startsWith('gen=')).split('=')[1];
+                    if (gen && Number(gen) >= 2) {
+                        const props = getDeviceProps(deviceId);
+                        let device = new device_1.Device(app, plugin, props, data.addresses[0]);
+                        try {
+                            discoveredDevices[deviceId] = device;
+                            if (props?.enabled === false) {
+                                return;
+                            }
+                            await device.connect();
+                        }
+                        catch (error) {
+                            console.error(`Failed to connect to device ${deviceId}`);
+                            console.error(error);
+                            return;
+                        }
+                    }
+                }
+            });
+        },
+        stop: function () {
+            sentMetaDevices = {};
+            onStop.forEach((f) => f());
+            onStop = [];
+            stopped = true;
+            Object.values(discoveredDevices).forEach((device) => {
+                device.disconnect();
+            });
+            discoveredDevices = {};
+            if (browser) {
+                browser.stop();
+                browser = null;
+            }
+        },
+        id: 'signalk-shelly2',
+        name: 'Shelly 2',
+        description: 'Signal K Plugin For Shelly Gen2+ devices',
+        schema: () => {
+            const schema = {
+                type: 'object',
+                properties: {}
+            };
+            let devices = Object.values(discoveredDevices);
+            devices.forEach((device) => {
+                debug(`adding Device ID ${deviceKey(device)} to schema`);
+                let props = (schema.properties[`Device ID ${deviceKey(device)}`] = {
+                    type: 'object',
+                    properties: {
+                        deviceName: {
+                            type: 'string',
+                            title: 'Name',
+                            default: device.name,
+                            readOnly: true
+                        },
+                        deviceModel: {
+                            type: 'string',
+                            title: 'Model',
+                            default: device.model,
+                            readOnly: true
+                        },
+                        deviceAddress: {
+                            type: 'string',
+                            title: 'Address',
+                            default: device.address,
+                            readOnly: true
+                        },
+                        enabled: {
+                            type: 'boolean',
+                            title: 'Enabled',
+                            default: true
+                        },
+                        devicePath: {
+                            type: 'string',
+                            title: 'Device Path',
+                            default: device.name ? (0, camelcase_1.default)(device.name) : deviceKey(device),
+                            description: 'Used to generate the path name, ie. electrical.switches.${devicePath}'
+                        },
+                        displayName: {
+                            type: 'string',
+                            title: 'Display Name (meta)',
+                            default: device.name
+                        }
+                    }
+                });
+                if (device.numSwitches > 1) {
+                    for (let i = 0; i < device.numSwitches; i++) {
+                        const key = `switch${i}`;
+                        let defaultPath;
+                        let description;
+                        defaultPath = i.toString();
+                        description =
+                            'Used to generate the path name, ie electrical.switches.${bankPath}.${switchPath}.state';
+                        props.properties[key] = {
+                            type: 'object',
+                            properties: {
+                                switchPath: {
+                                    type: 'string',
+                                    title: 'Switch Path',
+                                    default: defaultPath,
+                                    description
+                                },
+                                displayName: {
+                                    type: 'string',
+                                    title: 'Display Name (meta)'
+                                },
+                                enabled: {
+                                    type: 'boolean',
+                                    title: 'Enabled',
+                                    default: true
+                                }
+                            }
+                        };
+                    }
+                }
+                /*
+                if ( info.readPaths?.find((prop:any) => {
+                  return typeof prop !== 'string' && prop.notification
+                }) ) {
+                  props.properties.sendNotifications = {
+                    type: 'boolean',
+                    title: 'Send Notifications',
+                    default: true
+                  }
+                }
+                
+                if (info.isRGBW) {
+                  props.properties.presets = {
+                    title: 'Presets',
+                    type: 'array',
+                    items: {
+                      type: 'object',
+                      required: ['name', 'red', 'green', 'blue', 'white', 'bright'],
+                      properties: {
+                        name: {
+                          type: 'string',
+                          title: 'Name'
+                        },
+                        red: {
+                          type: 'number',
+                          title: 'Red',
+                          default: 255
+                        },
+                        green: {
+                          type: 'number',
+                          title: 'Green',
+                          default: 255
+                        },
+                        blue: {
+                          type: 'number',
+                          title: 'Blue',
+                          default: 255
+                        },
+                        white: {
+                          type: 'number',
+                          title: 'White',
+                          default: 255
+                        },
+                        bright: {
+                          type: 'number',
+                          title: 'Brightness',
+                          description:
+                            'Number between 1-100. Set to 0 to preserve current brightness',
+                          default: 100
+                        }
+                      }
+                    }
+                  }
+                }
+                  */
+            });
+            schema.properties.nextGenPassswords = {
+                title: 'Next Gen Device Passwords',
+                type: 'array',
+                items: {
+                    type: 'object',
+                    required: ['id', 'password'],
+                    properties: {
+                        id: {
+                            type: 'string',
+                            title: 'Device Id'
+                        },
+                        password: {
+                            type: 'string',
+                            title: 'Password'
+                        }
+                    }
+                }
+            };
+            return schema;
+        },
+        uiSchema: () => {
+            const uiSchema = {};
+            let devices = Object.values(discoveredDevices);
+            devices.forEach((device) => {
+                uiSchema[`Device ID ${deviceKey(device)}`] = {
+                    password: {
+                        'ui:widget': 'password'
+                    }
+                };
+            });
+            return uiSchema;
+        }
+    };
+    function filterEnabledDevices(devices) {
+        return Object.values(discoveredDevices).filter((device) => {
+            const deviceProps = getDeviceProps(device);
+            return (!deviceProps ||
+                typeof deviceProps.enabled === 'undefined' ||
+                deviceProps.enabled);
+        });
+    }
+    function getDeviceProps(id) {
+        return props[`Device ID ${id}`];
+    }
+    const rgbwPutPaths = [
+        {
+            deviceProp: 'switch',
+            name: 'state',
+            setter: (device, value) => {
+                return device.setColor({
+                    turn: boolString(value)
+                });
+            },
+            convertFrom: (value) => {
+                return value === true ? 1 : 0;
+            }
+        },
+        {
+            //deviceProp: 'gain',
+            name: 'dimmingLevel',
+            setter: (device, value) => {
+                if (device.white > 0) {
+                    let white = device.white / 255;
+                    let gain = device.gain / 100;
+                    if (white < gain) {
+                        white = white + value - gain;
+                    }
+                    else {
+                        white = value;
+                        value = gain + value - white;
+                    }
+                    if (white <= 0) {
+                        white = 0.01;
+                    }
+                    device.setColor({
+                        white: white * 255
+                    });
+                }
+                if (value <= 0) {
+                    value = 0.01;
+                }
+                return device.setColor({
+                    gain: Number((value * 100).toFixed(0))
+                });
+            },
+            getter: (device) => {
+                let value = device.gain / 100;
+                if (device.red === 0 && device.green === 0 && device.blue === 0) {
+                    value = device.white / 255;
+                }
+                else if (device.gain > 0 && device.white > 0) {
+                    value = device.white > device.gain ? device.white / 255 : value;
+                }
+                return Number(value.toFixed(2));
+            },
+            meta: {
+                units: 'ratio',
+                type: 'dimmer',
+                canDimWhenOff: true
+            }
+        },
+        {
+            deviceProp: 'red',
+            setter: (device, value) => {
+                return device.setColor({
+                    red: value
+                });
+            },
+            meta: {
+                units: 'rgbColor',
+                range: [0, 255]
+            }
+        },
+        {
+            deviceProp: 'green',
+            setter: (device, value) => {
+                return device.setColor({
+                    green: value
+                });
+            },
+            meta: {
+                units: 'rgbColor',
+                range: [0, 255]
+            }
+        },
+        {
+            deviceProp: 'blue',
+            setter: (device, value) => {
+                return device.setColor({
+                    blue: value
+                });
+            },
+            meta: {
+                units: 'rgbColor',
+                range: [0, 255]
+            }
+        },
+        {
+            deviceProp: 'white',
+            setter: (device, value) => {
+                return device.setColor({
+                    white: value
+                });
+            },
+            meta: {
+                units: 'rgbColor',
+                range: [0, 255]
+            }
+        },
+        {
+            name: 'preset',
+            getter: (device) => {
+                const deviceProps = getDeviceProps(device);
+                const preset = deviceProps?.presets?.find((preset) => {
+                    return (device.red == preset.red &&
+                        device.green == preset.green &&
+                        device.blue == preset.blue &&
+                        device.white == preset.white &&
+                        (preset.bright === 0 || device.gain == preset.bright));
+                });
+                return preset?.name || 'Unknown';
+            },
+            setter: (device, value) => {
+                const deviceProps = getDeviceProps(device);
+                const preset = deviceProps?.presets.find((preset) => preset.name == value);
+                if (value === 'Unknown' || !preset) {
+                    throw new Error(`invalid value ${value}`);
+                }
+                else {
+                    const params = {
+                        red: preset.red,
+                        green: preset.green,
+                        blue: preset.blue,
+                        white: preset.white,
+                        turn: 'on'
+                    };
+                    if (preset.bright !== 0) {
+                        params.gain = preset.bright;
+                    }
+                    return device.setColor(params);
+                }
+            }
+        }
+    ];
+    const simpleRelayPutPaths = [
+        {
+            deviceProp: 'relay0',
+            name: 'state',
+            setter: (device, value) => {
+                return device.setRelay(0, boolValue(value));
+            },
+            convertFrom: (value) => {
+                return value ? 1 : 0;
+            }
+        }
+    ];
+    const simpleRelayReadPaths = ['input0'];
+    const nextgenSwitchPutPaths = (key) => {
+        return [
+            {
+                deviceProp: key,
+                name: 'state',
+                setter: (device, value) => {
+                    return device[key].set(boolValue(value));
+                },
+                convertFrom: (value) => {
+                    return value.output ? 1 : 0;
+                }
+            }
+        ];
+    };
+    const nextgenSwitchReadPaths = (key) => {
+        return [
+            {
+                key: `${key}.voltage`,
+                path: 'voltage',
+                meta: {
+                    units: 'V'
+                }
+            },
+            {
+                key: `${key}.temperature`,
+                path: 'temperature',
+                converter: nextgenTemperatureConverter,
+                meta: {
+                    units: 'K'
+                }
+            },
+            {
+                key: `${key}.source`,
+                path: 'source',
+                meta: {
+                    units: 'string'
+                }
+            },
+            {
+                key: `${key}.apower`,
+                path: 'apower',
+                meta: {
+                    units: 'W'
+                }
+            },
+            {
+                key: `${key}.current`,
+                path: 'current',
+                meta: {
+                    units: 'A'
+                }
+            },
+            {
+                key: `${key}.pf`,
+                path: 'powerFactor',
+                converter: (val) => {
+                    return val * 1000;
+                },
+                meta: {
+                    units: 'W'
+                }
+            }
+        ];
+    };
+    const nextgenInputPaths = (key) => {
+        return [
+            {
+                key: `${key}.state`,
+                path: key,
+                converter: (value) => {
+                    return value ? 1 : 0;
+                }
+                /*
+                notification: {
+                  handler: (value) => {
+                    return value === true
+                    },
+                  messageOn: 'flood sensor is on',
+                  messageOff: 'flood sensor is off'
+                }
+                */
+            }
+        ];
+    };
+    const simpleRelay = {
+        putPaths: simpleRelayPutPaths,
+        readPaths: simpleRelayReadPaths
+    };
+    const temperatureConverter = (value) => {
+        if (props?.tempUnits === 'C') {
+            return value + 273.15;
+        }
+        else {
+            return ((value - 32) * 5) / 9 + 273.15;
+        }
+    };
+    const nextgenTemperatureConverter = (value) => {
+        return value?.tC + 273.15;
+    };
+    const humidityConverter = (value) => {
+        return value / 100;
+    };
+    const nextgenHumidityConverter = (value) => {
+        return value?.rh / 100;
+    };
+    const deviceTypes = {
+        /* For testing bank stuff */
+        /*
+        'Shelly Plus 1': {
+          nextGen: true,
+          isSwitchBank: true,
+          switchCount: 1,
+          switchKey: 'switch',
+          isDimmable: false,
+          bankReadPaths: nextgenSwitchReadPaths,
+          switchSetter: (device: any, value: any, switchIdx: number) => {
+            return device[`switch${switchIdx}`].set(boolValue(value))
+          },
+          readPaths: [
+            ...nextgenInputPaths('input0')
+          ]
+        },
+        */
+        'Shelly Plus 1': {
+            nextGen: true,
+            putPaths: nextgenSwitchPutPaths('switch0'),
+            readPaths: [
+                ...nextgenSwitchReadPaths('switch0'),
+                ...nextgenInputPaths('input0')
+            ],
+        },
+        'Shelly Plus 1 PM': {
+            nextGen: true,
+            putPaths: nextgenSwitchPutPaths('switch0'),
+            readPaths: [
+                ...nextgenSwitchReadPaths('switch0'),
+                ...nextgenInputPaths('input0')
+            ]
+        },
+        'Shelly Pro 1': {
+            nextGen: true,
+            putPaths: nextgenSwitchPutPaths('switch0'),
+            readPaths: [
+                ...nextgenSwitchReadPaths('switch0'),
+                ...nextgenInputPaths('input0'),
+                ...nextgenInputPaths('input1')
+            ]
+        },
+        'Shelly Pro 1 PM': {
+            nextGen: true,
+            putPaths: nextgenSwitchPutPaths('switch0'),
+            readPaths: [
+                ...nextgenSwitchReadPaths('switch0'),
+                ...nextgenInputPaths('input0'),
+                ...nextgenInputPaths('input1')
+            ]
+        },
+        'Shelly Plus 2 PM': {
+            nextGen: true,
+            isSwitchBank: true,
+            switchCount: 2,
+            switchKey: 'switch',
+            isDimmable: false,
+            bankReadPaths: nextgenSwitchReadPaths,
+            switchSetter: (device, value, switchIdx) => {
+                return device[`switch${switchIdx}`].set(boolValue(value));
+            },
+            readPaths: [
+                ...nextgenInputPaths('input0'),
+                ...nextgenInputPaths('input1')
+            ]
+        },
+        'Shelly Pro 4 PM': {
+            nextGen: true,
+            isSwitchBank: true,
+            switchCount: 4,
+            switchKey: 'switch',
+            isDimmable: false,
+            bankReadPaths: nextgenSwitchReadPaths,
+            switchSetter: (device, value, switchIdx) => {
+                return device[`switch${switchIdx}`].set(boolValue(value));
+            },
+            readPaths: [
+                ...nextgenInputPaths('input0'),
+                ...nextgenInputPaths('input1'),
+                ...nextgenInputPaths('input2'),
+                ...nextgenInputPaths('input3')
+            ]
+        },
+        'Shelly Plus I4': {
+            nextGen: true,
+            readPaths: [
+                ...nextgenInputPaths('input0'),
+                ...nextgenInputPaths('input1'),
+                ...nextgenInputPaths('input2'),
+                ...nextgenInputPaths('input3'),
+            ]
+        },
+        'Shelly Plus Plug US': {
+            nextGen: true,
+            putPaths: nextgenSwitchPutPaths('switch0'),
+            readPaths: [
+                ...nextgenSwitchReadPaths('switch0')
+            ]
+        },
+        'SHSW-1': {
+            putPaths: simpleRelayPutPaths,
+            readPaths: [
+                ...simpleRelayReadPaths,
+                {
+                    key: 'externalTemperature0',
+                    converter: temperatureConverter
+                },
+                {
+                    key: 'externalTemperature1',
+                    converter: temperatureConverter
+                },
+                {
+                    key: 'externalTemperature2',
+                    converter: temperatureConverter
+                }
+            ]
+        },
+        'SHRGBWW-01': {
+            isRGBW: true,
+            putPaths: rgbwPutPaths
+        },
+        'SHRGBW2:white': {
+            isSwitchBank: true,
+            switchCount: 4,
+            switchKey: 'switch',
+            isDimmable: true,
+            canDimWhenOff: true,
+            switchSetter: (device, value, switchIdx) => {
+                return device.setWhite(switchIdx, undefined, value === 1 || value === 'on' || value === 'true' || value === true);
+            },
+            dimmerSetter: (device, value, switchIdx) => {
+                return device.setWhite(switchIdx, Number((value * 100).toFixed(0)), device[`switch${switchIdx}`]);
+            }
+        },
+        'SHRGBW2:color': {
+            isRGBW: true,
+            putPaths: rgbwPutPaths,
+            readPaths: [
+                'mode',
+                'overPower',
+                'input0',
+                'power0',
+                'power1',
+                'power2',
+                'power3'
+            ]
+        },
+        'SHSW-44': {
+            isSwitchBank: true,
+            switchCount: 4,
+            switchKey: 'relay',
+            isDimmable: false,
+            switchSetter: (device, value, switchIdx) => {
+                return device.setRelay(switchIdx, boolValue(value));
+            }
+        },
+        'SHSW-L': {
+            putPaths: simpleRelayPutPaths,
+            readPaths: [
+                ...simpleRelayReadPaths,
+                'input1',
+                'power0',
+                'energyCounter0',
+                'deviceTemperature',
+                'overTemperature'
+            ]
+        },
+        'SHSW-PM': {
+            putPaths: simpleRelayPutPaths,
+            readPaths: [
+                ...simpleRelayReadPaths,
+                'power0',
+                'energyCounter0',
+                'overPower',
+                'overPowerValue',
+                'deviceTemperature',
+                'overTemperature'
+            ]
+        },
+        'SHSW-21:relay': {
+            isSwitchBank: true,
+            switchCount: 2,
+            switchKey: 'relay',
+            isDimmable: false,
+            switchSetter: (device, value, switchIdx) => {
+                return device.setRelay(switchIdx, boolValue(value));
+            },
+            readPaths: [
+                'mode',
+                'energyCounter0',
+                'overPower0',
+                'overPower1',
+                'overPowerValue'
+            ]
+        },
+        'SHUNI-1': {
+            isSwitchBank: true,
+            switchCount: 2,
+            switchKey: 'relay',
+            isDimmable: false,
+            switchSetter: (device, value, switchIdx) => {
+                return device.setRelay(switchIdx, boolValue(value));
+            },
+            readPaths: [
+                'input0',
+                'inputEvent0',
+                'inputEventCounter0',
+                'input1',
+                'inputEvent1',
+                'inputEventCounter1',
+                {
+                    key: 'externalTemperature0',
+                    converter: temperatureConverter
+                },
+                {
+                    key: 'externalTemperature1',
+                    converter: temperatureConverter
+                },
+                {
+                    key: 'externalTemperature2',
+                    converter: temperatureConverter
+                },
+                {
+                    key: 'externalTemperature3',
+                    converter: temperatureConverter
+                },
+                {
+                    key: 'externalTemperature4',
+                    converter: temperatureConverter
+                },
+                'voltage0',
+                {
+                    key: 'externalHumidity',
+                    converter: humidityConverter,
+                    meta: {
+                        units: 'ratio',
+                    }
+                }
+            ]
+        },
+        'SHHT-1': {
+            readPaths: [
+                {
+                    key: 'temperature',
+                    converter: temperatureConverter
+                },
+                {
+                    key: 'humidity',
+                    converter: humidityConverter,
+                    meta: {
+                        units: 'ratio',
+                    }
+                },
+                'battery'
+            ]
+        },
+        'Shelly Plus H&T': {
+            nextGen: true,
+            readPaths: [
+                {
+                    key: 'temperature0',
+                    converter: nextgenTemperatureConverter
+                },
+                {
+                    key: 'humidity0',
+                    converter: nextgenHumidityConverter,
+                    meta: {
+                        units: 'ratio',
+                    }
+                }
+            ]
+        },
+        SHEM: {
+            isSwitchBank: true,
+            switchCount: 1,
+            switchKey: 'relay',
+            isDimmable: false,
+            switchSetter: (device, value, switchIdx) => {
+                return device.setRelay(switchIdx, boolValue(value));
+            },
+            readPaths: [
+                'power0',
+                'energyCounter0',
+                'energyReturned0',
+                'voltage0',
+                'power1',
+                'energyCounter1',
+                'energyReturned1',
+                'voltage1',
+                'overPower'
+            ]
+        },
+        'SHEM-3': {
+            isSwitchBank: true,
+            switchCount: 1,
+            switchKey: 'relay',
+            isDimmable: false,
+            switchSetter: (device, value, switchIdx) => {
+                return device.setRelay(switchIdx, boolValue(value));
+            },
+            readPaths: [
+                'power0',
+                'energyCounter0',
+                'energyReturned0',
+                'powerFactor0',
+                'current0',
+                'voltage0',
+                'power1',
+                'energyCounter1',
+                'energyReturned1',
+                'powerFactor1',
+                'current1',
+                'voltage1',
+                'power2',
+                'energyCounter2',
+                'energyReturned2',
+                'powerFactor2',
+                'current2',
+                'voltage2',
+                'overPower'
+            ]
+        },
+        'SHSW-21:roller': {
+            readPaths: [
+                'mode',
+                'power0',
+                'energyCounter0',
+                'overPower0',
+                'overPower1',
+                'overPowerValue'
+            ],
+            putPaths: [
+                {
+                    deviceProp: 'rollerState',
+                    setter: (device, value) => {
+                        return device.setRollerState(value);
+                    }
+                },
+                {
+                    deviceProp: 'rollerPosition',
+                    setter: (device, value) => {
+                        return device.setRollerPosition(value);
+                    }
+                }
+            ]
+        },
+        'SHSW-22': {
+            isSwitchBank: true,
+            switchCount: 2,
+            switchKey: 'relay',
+            isDimmable: false,
+            switchSetter: (device, value, switchIdx) => {
+                return device.setRelay(switchIdx, boolValue(value));
+            }
+        },
+        'SHPLG2-1': simpleRelay,
+        'SHPLG-S': simpleRelay,
+        'SHPLG-U1': simpleRelay,
+        'SHPLG-1': {
+            putPaths: simpleRelayPutPaths,
+            readPaths: [
+                ...simpleRelayReadPaths,
+                'power0',
+                'energyCounter0',
+                'overPower',
+                'overPowerValue'
+            ]
+        },
+        'SHDW-1': {
+            readPaths: [
+                'state',
+                'vibration',
+                'illuminance',
+                'illuminanceLevel',
+                'sensorError',
+                'battery',
+                'wakeupEvent'
+            ]
+        },
+        'SHDW-2': {
+            readPaths: [
+                {
+                    key: 'state',
+                    notification: {
+                        handler: (value) => {
+                            return value === 1;
+                        },
+                        messageOn: 'is open',
+                        messageOff: 'is closed'
+                    }
+                },
+                'vibration',
+                'illuminance',
+                'illuminanceLevel',
+                'sensorError',
+                'battery',
+                'wakeupEvent',
+                {
+                    key: 'temperature',
+                    converter: temperatureConverter
+                },
+            ]
+        },
+        'SHWT-1': {
+            readPaths: [
+                {
+                    key: 'flood',
+                    notification: {
+                        handler: (value) => {
+                            return value === 1;
+                        },
+                        messageOn: 'flood sensor is on',
+                        messageOff: 'flood sensor is off'
+                    }
+                },
+                'sensorError',
+                'battery',
+                'wakeupEvent',
+                {
+                    key: 'temperature',
+                    converter: temperatureConverter
+                },
+            ]
+        },
+        'SHMOS-01': {
+            readPaths: [
+                {
+                    key: 'motion',
+                    notification: {
+                        handler: (value) => {
+                            return value === 1;
+                        },
+                        messageOn: 'motion detected',
+                        messageOff: 'motion cleared'
+                    }
+                },
+                'vibration',
+                'battery',
+                'illuminance'
+            ],
+        },
+        'SHMOS-02': {
+            readPaths: [
+                {
+                    key: 'motion',
+                    notification: {
+                        handler: (value) => {
+                            return value === 1;
+                        },
+                        messageOn: 'motion detected',
+                        messageOff: 'motion cleared'
+                    }
+                },
+                'vibration',
+                'battery',
+                'illuminance',
+                {
+                    key: 'temperature',
+                    converter: temperatureConverter
+                },
+            ]
+        },
+    };
+    deviceTypes['SHSW-25:roller'] = { ...deviceTypes['SHSW-21:roller'] };
+    deviceTypes['SHSW-25:roller'].readPaths.push('overTemperature');
+    deviceTypes['SHSW-25:roller'].readPaths.push('deviceTemperature');
+    deviceTypes['SHSW-25:relay'] = { ...deviceTypes['SHSW-21:relay'] };
+    deviceTypes['SHSW-25:relay'].readPaths.push('overTemperature');
+    deviceTypes['SHSW-25:relay'].readPaths.push('deviceTemperature');
+    deviceTypes['SH2LED-1'] = { ...deviceTypes['SHRGBWW-01'] };
+    deviceTypes['SH2LED-1'].switchCount = 2;
+    deviceTypes['SHBLB-1:color'] = { ...deviceTypes['SHRGBWW-01'] };
+    deviceTypes['SHBLB-1:white'] = { ...deviceTypes['SHRGBW2:white'] };
+    deviceTypes['SHCB-1:color'] = { ...deviceTypes['SHRGBWW-01'] };
+    deviceTypes['SHCB-1:white'] = { ...deviceTypes['SHRGBW2:white'] };
+    deviceTypes['SHCL-255:color'] = { ...deviceTypes['SHRGBWW-01'] };
+    deviceTypes['SHCL-255:white'] = { ...deviceTypes['SHRGBW2:white'] };
+    deviceTypes['Shelly Pro 2'] = { ...deviceTypes['Shelly Plus 2 PM'] };
+    deviceTypes['Shelly Pro 2 PM'] = { ...deviceTypes['Shelly Plus 2 PM'] };
+    return plugin;
+}
+function boolValue(value) {
+    return value === 1 || value === 'on' || value === 'true' || value === true;
+}
+function boolString(value) {
+    return boolValue(value) ? 'on' : 'off';
+}
+function boolFrom(value) {
+    return value === 'on' ? 1 : 0;
+}
+//# sourceMappingURL=index.js.map