qolsys-controller 0.0.76__tar.gz → 0.3.2__tar.gz

qolsys_controller-0.3.2/.github/dependabot.yml

@@ -0,0 +1,11 @@
+# To get started with Dependabot version updates, you'll need to specify which
+# package ecosystems to update and where the package manifests are located.
+# Please see the documentation for all configuration options:
+# https://docs.github.com/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file
+
+version: 2
+updates:
+  - package-ecosystem: "pip" # See documentation for possible values
+    directory: "/" # Location of package manifests
+    schedule:
+      interval: "weekly"

{qolsys_controller-0.0.76 → qolsys_controller-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qolsys-controller
-Version: 0.0.76
+Version: 0.3.2
 Summary: A Python module that emulates a virtual IQ Remote device, enabling full local control of a Qolsys IQ Panel
 Project-URL: Homepage, https://github.com/EHylands/QolsysController
 Project-URL: Issues, https://github.com/EHylands/QolsysController/issues

{qolsys_controller-0.0.76 → qolsys_controller-0.3.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "qolsys-controller"
-version = "0.0.76"
+version = "0.3.2"
 authors = [
   { name="Eric Hylands", email="" },
 ]

{qolsys_controller-0.0.76 → qolsys_controller-0.3.2}/qolsys_controller/adc_service_garagedoor.py

@@ -32,4 +32,4 @@ class QolsysAdcGarageDoorService(QolsysAdcService):
         )
 
     def is_open(self) -> bool:
-        return self.func_state == vdFuncState.ON
+        return self.func_state == 0

{qolsys_controller-0.0.76 → qolsys_controller-0.3.2}/qolsys_controller/controller.py

@@ -18,9 +18,10 @@ from qolsys_controller.mqtt_command import (
     MQTTCommand_Panel,
     MQTTCommand_ZWave,
 )
+from qolsys_controller.zwave_thermostat import QolsysThermostat
 
 from .enum import PartitionAlarmState, PartitionArmingType, PartitionSystemStatus
-from .enum_zwave import ThermostatFanMode, ThermostatMode, ZwaveCommandClass, ZwaveDeviceClass
+from .enum_zwave import ThermostatFanMode, ThermostatMode, ThermostatSetpointMode, ZwaveCommandClass
 from .errors import QolsysMqttError, QolsysSslError, QolsysUserCodeError
 from .mdns import QolsysMDNS
 from .mqtt_command_queue import QolsysMqttCommandQueue
@@ -60,6 +61,7 @@ class QolsysController:
         self._mqtt_task_listen_label: str = "mqtt_task_listen"
         self._mqtt_task_connect_label: str = "mqtt_task_connect"
         self._mqtt_task_ping_label: str = "mqtt_task_ping"
+        self._mqtt_task_zwave_meter_update_label: str = "mqtt_task_zwave_meter_update"
 
     @property
     def state(self) -> QolsysState:
@@ -151,32 +153,43 @@ class QolsysController:
         self._task_manager.cancel(self._mqtt_task_listen_label)
         self._task_manager.cancel(self._mqtt_task_ping_label)
         self._task_manager.cancel(self._mqtt_task_config_label)
+        self._task_manager.cancel(self._mqtt_task_zwave_meter_update_label)
 
         self.connected = False
         self.connected_observer.notify()
 
     async def mqtt_connect_task(self, reconnect: bool, run_forever: bool) -> None:
-        # Configure TLS parameters for MQTT connection
-        tls_params = aiomqtt.TLSParameters(
-            ca_certs=str(self._pki.qolsys_cer_file_path),
-            certfile=str(self._pki.secure_file_path),
-            keyfile=str(self._pki.key_file_path),
-            cert_reqs=ssl.CERT_REQUIRED,
-            tls_version=ssl.PROTOCOL_TLSv1_2,
-            ciphers="ALL:@SECLEVEL=0",
-        )
+        # Configure TLS context for MQTT connection
+        def create_tls_context(self: QolsysController) -> ssl.SSLContext:
+            ctx = ssl.create_default_context(
+                purpose=ssl.Purpose.SERVER_AUTH,
+                cafile=str(self._pki.qolsys_cer_file_path),
+            )
+            ctx.set_ciphers("DEFAULT:@SECLEVEL=0")
+            ctx.minimum_version = ssl.TLSVersion.TLSv1_2
+            ctx.check_hostname = False
+            ctx.verify_mode = ssl.CERT_NONE
+            ctx.load_cert_chain(
+                certfile=str(self._pki.secure_file_path),
+                keyfile=str(self._pki.key_file_path),
+            )
+            return ctx
+
+        loop = asyncio.get_running_loop()
+        ctx = await loop.run_in_executor(None, create_tls_context, self)
 
         LOGGER.debug("MQTT: Connecting ...")
 
         self._task_manager.cancel(self._mqtt_task_listen_label)
         self._task_manager.cancel(self._mqtt_task_ping_label)
+        self._task_manager.cancel(self._mqtt_task_zwave_meter_update_label)
 
         while True:
             try:
                 self.aiomqtt = aiomqtt.Client(
                     hostname=self.settings.panel_ip,
                     port=8883,
-                    tls_params=tls_params,
+                    tls_context=ctx,
                     tls_insecure=True,
                     clean_session=True,
                     timeout=self.settings.mqtt_timeout,
@@ -213,11 +226,14 @@ class QolsysController:
 
                 response_database = await self.command_sync_database()
                 LOGGER.debug("MQTT: Updating State from syncdatabase")
-                self.panel.load_database(response_database.get("fulldbdata"))  # type: ignore[arg-type]
+                await self.panel.load_database(response_database.get("fulldbdata"))
                 self.panel.dump()
                 self.state.dump()
 
                 self.connected = True
+
+                self._task_manager.run(self.mqtt_zwave_meter_update(), self._mqtt_task_zwave_meter_update_label)
+
                 self.connected_observer.notify()
 
                 if not run_forever:
@@ -258,6 +274,19 @@ class QolsysController:
 
             await asyncio.sleep(self.settings.mqtt_ping)
 
+    async def mqtt_zwave_meter_update(self) -> None:
+        while True:
+            if self.aiomqtt is not None and self.connected:
+                LOGGER.debug("Updating Z-Wave Energy Clamps")
+                with contextlib.suppress(aiomqtt.MqttError):
+                    for energy_clamp in self.state.zwave_meters:
+                        for meter in energy_clamp.meter_endpoints:
+                            zwave_command = MQTTCommand_ZWave(
+                                self, energy_clamp.node_id, meter.endpoint, [ZwaveCommandClass.Meter, 0x01]
+                            )
+                            await zwave_command.send_command()
+            await asyncio.sleep(60)
+
     async def mqtt_listen_task(self) -> None:
         try:
             async for message in self.aiomqtt.messages:  # type: ignore[union-attr]
@@ -747,6 +776,70 @@ class QolsysController:
         LOGGER.debug("MQTT: Receiving execute_scene command")
         return response
 
+    async def command_panel_virtual_device_action(self, device_id: str, state: int) -> dict[str, Any] | None:
+        LOGGER.debug("MQTT: Sending virtual_device command")
+
+        garage_door = self.state.adc_device(device_id)
+        if not garage_door:
+            LOGGER.error("Invalid Virtual Garage Door Id: %s", device_id)
+
+        device_list = {
+            "virtualDeviceList": [
+                {
+                    "virtualDeviceId": int(device_id),
+                    "virtualDeviceFunctionList": [
+                        {
+                            "vdFuncId": 1,
+                            "vdFuncState": state,
+                            "vdFuncBackendTimestamp": int(time.time() * 1000),
+                            "vdFuncType": 1,
+                        }
+                    ],
+                }
+            ]
+        }
+
+        virtual_command = {
+            "operation_name": "send_virtual_device_description",
+            "virtual_device_operation": 4,
+            "virtual_device_description": json.dumps(device_list),
+            "operation_source": 0,
+        }
+
+        virtual_command2 = {
+            "operation_name": "send_virtual_device_description",
+            "virtual_device_operation": 5,
+            "virtual_device_description": json.dumps(device_list),
+            "operation_source": 0,
+        }
+
+        ipc_request = [
+            {
+                "dataType": "string",
+                "dataValue": json.dumps(virtual_command),
+            }
+        ]
+
+        ipc_request2 = [
+            {
+                "dataType": "string",
+                "dataValue": json.dumps(virtual_command2),
+            }
+        ]
+
+        LOGGER.debug("virtual command: %s", virtual_command)
+        command = MQTTCommand_Panel(self)
+        command.append_ipc_request(ipc_request)
+        response = await command.send_command()
+        LOGGER.debug("MQTT: Receiving virtual_device command: %s", response)
+
+        LOGGER.debug("virtual command: %s", virtual_command2)
+        command2 = MQTTCommand_Panel(self)
+        command2.append_ipc_request(ipc_request2)
+        response2 = await command2.send_command()
+        LOGGER.debug("MQTT: Receiving virtual_device command: %s", response2)
+        return response
+
     async def command_panel_trigger_police(self, partition_id: str, silent: bool) -> dict[str, Any] | None:
         LOGGER.debug("MQTT: Sending panel_trigger_police command")
 
@@ -837,28 +930,28 @@ class QolsysController:
         LOGGER.debug("MQTT: Receiving panel_trigger_fire command")
         return response
 
-    async def command_zwave_switch_binary_set(self, node_id: str, status: bool) -> dict[str, Any] | None:
-        LOGGER.debug("MQTT: Sending set_zwave_switch_binary command  - Node(%s) - Status(%s)", node_id, status)
+    async def command_zwave_switch_binary_set(self, node_id: str, endpoint: str, status: bool) -> dict[str, Any] | None:
+        LOGGER.debug("MQTT: Sending set_zwave_switch_binar#y command  - Node(%s) - Status(%s)", node_id, status)
         zwave_node = self.state.zwave_device(node_id)
 
         if not zwave_node:
             LOGGER.error("switch_binary_set - Invalid node_id %s", node_id)
             return None
 
-        if zwave_node.generic_device_type not in (ZwaveDeviceClass.SwitchBinary, ZwaveDeviceClass.RemoteSwitchBinary):
-            LOGGER.error("switch_binary_set used on invalid %s", zwave_node.generic_device_type)
+        if ZwaveCommandClass.SwitchBinary not in zwave_node.command_class_list:
+            LOGGER.error("Z-Wave node does not support switch_binary_set")
             return None
 
         level = 0
         if status:
             level = 255
 
-        command = MQTTCommand_ZWave(self, node_id, [ZwaveCommandClass.SwitchBinary, 1, level])
+        command = MQTTCommand_ZWave(self, node_id, endpoint, [ZwaveCommandClass.SwitchBinary, 1, level])
         response = await command.send_command()
         LOGGER.debug("MQTT: Receiving set_zwave_switch_binary command")
         return response
 
-    async def command_zwave_switch_multilevel_set(self, node_id: str, level: int) -> dict[str, Any] | None:
+    async def command_zwave_switch_multilevel_set(self, node_id: str, endpoint: str, level: int) -> dict[str, Any] | None:
         LOGGER.debug("MQTT: Sending switch_multilevel_set command  - Node(%s) - Level(%s)", node_id, level)
 
         zwave_node = self.state.zwave_device(node_id)
@@ -866,16 +959,16 @@ class QolsysController:
             LOGGER.error("switch_multilevel_set - Invalid node_id %s", node_id)
             return None
 
-        if zwave_node.generic_device_type not in (ZwaveDeviceClass.SwitchMultilevel, ZwaveDeviceClass.RemoteSwitchMultilevel):
-            LOGGER.error("switch_multilevel_set used on invalid %s", zwave_node.generic_device_type)
+        if ZwaveCommandClass.SwitchMultilevel not in zwave_node.command_class_list:
+            LOGGER.error("Z-Wave node does not support switch_multilevel_set")
             return None
 
-        command = MQTTCommand_ZWave(self, node_id, [ZwaveCommandClass.SwitchMultilevel, 1, level])
+        command = MQTTCommand_ZWave(self, node_id, endpoint, [ZwaveCommandClass.SwitchMultilevel, 1, level])
         response = await command.send_command()
         LOGGER.debug("MQTT: Receiving set_zwave_multilevel_switch command")
         return response
 
-    async def command_zwave_doorlock_set(self, node_id: str, locked: bool) -> dict[str, Any] | None:
+    async def command_zwave_doorlock_set(self, node_id: str, endpoint: str, locked: bool) -> dict[str, Any] | None:
         LOGGER.debug("MQTT: Sending zwave_doorlock_set command - Node(%s) - Locked(%s)", node_id, locked)
 
         zwave_node = self.state.zwave_device(node_id)
@@ -883,34 +976,68 @@ class QolsysController:
             LOGGER.error("doorlock_set - Invalid node_id %s", node_id)
             return None
 
+        if ZwaveCommandClass.DoorLock not in zwave_node.command_class_list:
+            LOGGER.error("Z-Wave node does not support zwave_doorlock_set")
+            return None
+
         # 0 unlocked, 255 locked
         lock_mode = 0
         if locked:
             lock_mode = 255
 
-        command = MQTTCommand_ZWave(self, node_id, [ZwaveCommandClass.DoorLock, 1, lock_mode])
+        command = MQTTCommand_ZWave(self, node_id, endpoint, [ZwaveCommandClass.DoorLock, 1, lock_mode])
         response = await command.send_command()
         LOGGER.debug("MQTT: Receiving zwave_doorlock_set command")
         return response
 
     async def command_zwave_thermostat_setpoint_set(
-        self, node_id: str, mode: ThermostatMode, setpoint: float
+        self, node_id: str, endpoint: str, mode: ThermostatSetpointMode, setpoint: int
     ) -> dict[str, Any] | None:
-        LOGGER.debug(
-            "MQTT: Sending zwave_thermostat_setpoint_set - Node(%s) - Mode(%s) - Setpoint(%s)", node_id, mode, setpoint
-        )
-
         zwave_node = self.state.zwave_device(node_id)
         if not zwave_node:
             LOGGER.error("thermostat_setpoint_set - Invalid node_id %s", node_id)
             return None
 
-        command = MQTTCommand_ZWave(self, node_id, [ZwaveCommandClass.ThermostatSetPoint, 1, mode, int(setpoint)])
+        if not isinstance(zwave_node, QolsysThermostat):
+            LOGGER.error("thermostat_setpoint_set - Z-Wave node is not a thermostat %s", node_id)
+            return None
+
+        scale: int = 0
+        if zwave_node.thermostat_device_temp_unit == "F":
+            scale = 1
+
+        precision: int = 1
+        size: int = 2
+        pss = (precision << 5) | (scale << 3) | size
+        temp_int = int(round(setpoint * (10**precision)))
+        temp_bytes = temp_int.to_bytes(size, byteorder="big", signed=True)
+
+        setpointmode = ThermostatSetpointMode.HEATING
+        if mode == ThermostatSetpointMode.COOLING:
+            setpointmode = mode
+
+        zwave_bytes: list[int] = [
+            0x43,  # Thermostat Setpoint
+            0x01,  # SET
+            setpointmode.value,
+            pss,
+        ] + list(temp_bytes)
+
+        LOGGER.debug(
+            "MQTT: Sending zwave_thermostat_setpoint_set - Node(%s) - Mode(%s) - Setpoint(%s): %s",
+            node_id,
+            mode.value,
+            setpoint,
+            zwave_bytes,
+        )
+        command = MQTTCommand_ZWave(self, node_id, endpoint, zwave_bytes)
         response = await command.send_command()
-        LOGGER.debug("MQTT: Receiving zwave_thermostat_mode_set command")
+        LOGGER.debug("MQTT: Receiving zwave_thermostat_mode_set command:%s", response)
         return response
 
-    async def command_zwave_thermostat_mode_set(self, node_id: str, mode: ThermostatMode) -> dict[str, Any] | None:
+    async def command_zwave_thermostat_mode_set(
+        self, node_id: str, endpoint: str, mode: ThermostatMode
+    ) -> dict[str, Any] | None:
         LOGGER.debug("MQTT: Sending zwave_thermostat_mode_set command - Node(%s) - Mode(%s)", node_id, mode)
 
         thermostat = self.state.zwave_thermostat(node_id)
@@ -918,16 +1045,17 @@ class QolsysController:
             LOGGER.error("zwave_thermostat_mode_set - Invalid node_id %s", node_id)
             return None
 
-        LOGGER.debug("thermostat_mode: %s", int(mode))
         if mode not in thermostat.available_thermostat_mode():
             LOGGER.error("thermostat_mode_set - Invalid mode %s", mode)
 
-        command = MQTTCommand_ZWave(self, node_id, [ZwaveCommandClass.ThermostatMode, 1, int(mode)])
+        command = MQTTCommand_ZWave(self, node_id, endpoint, [ZwaveCommandClass.ThermostatMode, 1, int(mode)])
         response = await command.send_command()
         LOGGER.debug("MQTT: Receiving zwave_thermostat_mode_set command")
         return response
 
-    async def command_zwave_thermostat_fan_mode_set(self, node_id: str, fan_mode: ThermostatFanMode) -> dict[str, Any] | None:
+    async def command_zwave_thermostat_fan_mode_set(
+        self, node_id: str, endpoint: str, fan_mode: ThermostatFanMode
+    ) -> dict[str, Any] | None:
         LOGGER.debug("MQTT: Sending zwave_thermostat_fan_mode_set command - Node(%s) - FanMode(%s)", node_id, fan_mode)
 
         zwave_node = self.state.zwave_device(node_id)
@@ -935,7 +1063,7 @@ class QolsysController:
             LOGGER.error("thermostat_fan_mode_set - Invalid node_id %s", node_id)
             return None
 
-        command = MQTTCommand_ZWave(self, node_id, [ZwaveCommandClass.ThermostatFanMode, 1, fan_mode])
+        command = MQTTCommand_ZWave(self, node_id, endpoint, [ZwaveCommandClass.ThermostatFanMode, 1, fan_mode])
         response = await command.send_command()
         LOGGER.debug("MQTT: Receiving zwave_thermostat_fan_mode_set command")
         return response

{qolsys_controller-0.0.76 → qolsys_controller-0.3.2}/qolsys_controller/database/db.py

@@ -216,7 +216,7 @@ class QolsysDB:
         return partitions
 
     def get_adc_devices(self) -> list[dict[str, str]]:
-        self.cursor.execute(f"SELECT * FROM {self.table_virtual_device.table} ORDER BY device_id")
+        self.cursor.execute(f"SELECT * FROM {self.table_virtual_device.table} ORDER BY CAST(device_id AS INTEGER)")
         self.db.commit()
 
         devices = []
@@ -228,7 +228,7 @@ class QolsysDB:
         return devices
 
     def get_zwave_devices(self) -> list[dict[str, str]]:
-        self.cursor.execute(f"SELECT * FROM {self.table_zwave_node.table} ORDER BY node_id")
+        self.cursor.execute(f"SELECT * FROM {self.table_zwave_node.table} ORDER BY CAST(node_id AS INTEGER)")
         self.db.commit()
 
         devices = []
@@ -240,7 +240,7 @@ class QolsysDB:
         return devices
 
     def get_zwave_other_devices(self) -> list[dict[str, str]]:
-        self.cursor.execute(f"SELECT * FROM {self.table_zwave_other.table} ORDER BY node_id")
+        self.cursor.execute(f"SELECT * FROM {self.table_zwave_other.table} ORDER BY CAST(node_id AS INTEGER)")
         self.db.commit()
 
         devices = []
@@ -252,7 +252,7 @@ class QolsysDB:
         return devices
 
     def get_locks(self) -> list[dict[str, str]]:
-        self.cursor.execute(f"SELECT * FROM {self.table_doorlock.table} ORDER BY node_id")
+        self.cursor.execute(f"SELECT * FROM {self.table_doorlock.table} ORDER BY CAST(node_id AS INTEGER)")
         self.db.commit()
 
         locks = []
@@ -264,7 +264,7 @@ class QolsysDB:
         return locks
 
     def get_thermostats(self) -> list[dict[str, str]]:
-        self.cursor.execute(f"SELECT * FROM {self.table_thermostat.table} ORDER BY node_id")
+        self.cursor.execute(f"SELECT * FROM {self.table_thermostat.table} ORDER BY CAST(node_id AS INTEGER)")
         self.db.commit()
 
         thermostats = []
@@ -276,7 +276,7 @@ class QolsysDB:
         return thermostats
 
     def get_dimmers(self) -> list[dict[str, str]]:
-        self.cursor.execute(f"SELECT * FROM {self.table_dimmer.table} ORDER BY node_id")
+        self.cursor.execute(f"SELECT * FROM {self.table_dimmer.table} ORDER BY CAST(node_id AS INTEGER)")
         self.db.commit()
 
         dimmers = []
@@ -288,7 +288,7 @@ class QolsysDB:
         return dimmers
 
     def get_zones(self) -> list[dict[str, str]]:
-        self.cursor.execute(f"SELECT * FROM {self.table_sensor.table} ORDER BY zoneid")
+        self.cursor.execute(f"SELECT * FROM {self.table_sensor.table} ORDER BY CAST(zoneid AS INTEGER)")
         self.db.commit()
 
         zones = []
@@ -390,7 +390,7 @@ class QolsysDB:
 
         return None
 
-    def load_db(self, database: list[dict[str, Any]]) -> None:
+    def load_db(self, database: Any | None) -> None:
         self.clear_db()
 
         if not database:

{qolsys_controller-0.0.76 → qolsys_controller-0.3.2}/qolsys_controller/database/table_sensor.py

@@ -65,6 +65,8 @@ class QolsysTableSensor(QolsysTable):
             "extras",
             "allowspeaker",
             "firmware_version",
+            "radio_version",
+            "radio_id",
         ]
 
         self._create_table()

{qolsys_controller-0.0.76 → qolsys_controller-0.3.2}/qolsys_controller/database/table_smartsocket.py

@@ -12,10 +12,21 @@ class QolsysTableSmartSocket(QolsysTable):
         self._uri = "content://com.qolsys.qolsysprovider.SmartSocketsContentProvider/smartsocket"
         self._table = "smartsocket"
         self._abort_on_error = False
-        self._implemented = False
+        self._implemented = True
 
         self._columns = [
             "_id",
+            "created_by",
+            "created_date",
+            "last_updated_date",
+            "node_id",
+            "paired_status",
+            "power_usage",
+            "status",
+            "updated_by",
+            "socket_id",
+            "socket_name",
+            "current_usagevoltage_usage",
         ]
 
         self._create_table()

{qolsys_controller-0.0.76 → qolsys_controller-0.3.2}/qolsys_controller/database/table_thermostat.py

@@ -49,6 +49,7 @@ class QolsysTableThermostat(QolsysTable):
             "paired_status",
             "configuration_parameter",
             "operating_state",
+            "fan_state",
         ]
 
         self._create_table()

{qolsys_controller-0.0.76 → qolsys_controller-0.3.2}/qolsys_controller/database/table_user.py

@@ -39,6 +39,7 @@ class QolsysTableUser(QolsysTable):
             "tag_flag",
             "check_in_time",
             "user_feature1",
+            "user_feature2",
         ]
 
         self._create_table()

{qolsys_controller-0.0.76 → qolsys_controller-0.3.2}/qolsys_controller/database/table_zwave_node.py

@@ -51,12 +51,12 @@ class QolsysTableZwaveNode(QolsysTable):
             "node_battery_level_updated_time",
             "basic_report_updated_time",
             "switch_multilevel_report_updated_time",
-            "multi_channel_details",
             "rediscover_status",
             "last_rediscover_time",
             "neighbour_info",
             "last_node_test_time",
             "notification_capabilities",
+            "multi_channel_details",
             "endpoint",
             "endpoint_details",
             "device_wakeup_time",
@@ -80,6 +80,8 @@ class QolsysTableZwaveNode(QolsysTable):
             "long_range_nodeid",
             "hide_device_info",
             "meter_capabilities",
+            "multisensor_capabilities",
+            "central_scene_supported",
         ]
 
         self._create_table()

{qolsys_controller-0.0.76 → qolsys_controller-0.3.2}/qolsys_controller/enum.py

@@ -1,6 +1,16 @@
 from enum import StrEnum
 
 
+class QolsysEvent(StrEnum):
+    EVENT_PANEL_PARTITION_ADD = "EVENT_PANEL_PARTITION_ADD"
+    EVENT_PANEL_ZONE_ADD = "EVENT_PANEL_ZONE_ADD"
+    EVENT_PANEL_DOORBELL = "EVENT_PANEL_DOORBELL"
+    EVENT_PANEL_CHIME = "EVENT_PANEL_CHIME"
+    EVENT_ZWAVE_DEVICE_ADD = "EVENT_ZWAVE_MULTILEVELSENSOR_ADD"
+    EVENT_ZWAVE_MULTILEVELSENSOR_ADD = "EVENT_ZWAVE_MULTILEVELSENSOR_ADD"
+    EVENT_ZWAVE_METER_ADD = "EVENT_ZWAVE_METER_ADD"
+
+
 class PartitionSystemStatus(StrEnum):
     ARM_STAY = "ARM-STAY"
     ARM_AWAY = "ARM-AWAY"
@@ -48,22 +58,24 @@ class PartitionAlarmType(StrEnum):
 
 
 class ZoneStatus(StrEnum):
+    ACTIVE = "Active"
+    ACTIVATED = "Activated"
     ALARMED = "Alarmed"
-    OPEN = "Open"
+    ARM_AWAY = "Arm-Away"
+    ARM_STAY = "Arm-Stay"
     CLOSED = "Closed"
-    ACTIVE = "Active"
+    CONNECTED = "connected"
+    DISARM = "Disarm"
+    OPEN = "Open"
     INACTIVE = "Inactive"
-    ACTIVATED = "Activated"
     IDLE = "Idle"
     NORMAL = "Normal"
     UNREACHABLE = "Unreachable"
     TAMPERED = "Tampered"
     SYNCHRONIZING = "Synchronizing"
-    CONNECTED = "connected"
     DISCONNECTED = "disconnected"
     FAILURE = "Failure"
     NOT_NETWORKED = "Not Networked"
-    DISARM = "Disarm"
 
 
 class DeviceCapability(StrEnum):
@@ -71,37 +83,39 @@ class DeviceCapability(StrEnum):
     WIFI = "WiFi"
     POWERG = "POWERG"
     ZWAVE = "Z-Wave"
+    S_LINE = "S-Line"
 
 
 class ZoneSensorType(StrEnum):
-    DOOR_WINDOW = "Door_Window"
+    AUXILIARY_PENDANT = "Auxiliary Pendant"
+    BLUETOOTH = "Bluetooth"
+    CO_DETECTOR = "CODetector"
     DOORBELL = "Doorbell"
-    MOTION = "Motion"
+    DOOR_WINDOW = "Door_Window"
+    DOOR_WINDOW_M = "Door_Window_M"
+    FREEZE = "Freeze"
     GLASS_BREAK = "GlassBreak"
+    # HARDWIRE_TRANSLATOR = "" # TBD
+    HEAT = "Heat"
+    # HIGH_TEMPERATURE = "" # TBD
     KEY_FOB = "KeyFob"
     KEYPAD = "Keypad"
-    AUXILIARY_PENDANT = "Auxiliary Pendant"
-    SMOKE_DETECTOR = "SmokeDetector"
-    CO_DETECTOR = "CODetector"
-    # HARDWIRE_TRANSLATOR = "" # TBD
+    MOTION = "Motion"
+    # OCCUPANCY = ""  #TBD
+    PANEL_GLASS_BREAK = "Panel Glass Break"
+    PANEL_MOTION = "Panel Motion"
     # WIRELESS_TRANSLATOR = "" #TBD
-    TEMPERATURE = "Temperature"
-    HEAT = "Heat"
-    WATER = "Water"
+    SIREN = "Siren"
     SHOCK = "Shock"
-    FREEZE = "Freeze"
-    TILT = "Tilt"
+    SMOKE_DETECTOR = "SmokeDetector"
     SMOKE_M = "Smoke_M"
-    # DOOR_WINDOW_M = "" #TBD
-    # OCCUPANCY = ""  #TBD
-    SIREN = "Siren"
-    # HIGH_TEMPERATURE = "" # TBD
-    PANEL_MOTION = "Panel Motion"
-    PANEL_GLASS_BREAK = "Panel Glass Break"
-    BLUETOOTH = "Bluetooth"
     TAKEOVER_MODULE = "TakeoverModule"
-    TRANSLATOR = "Translator"
     TAMPER = "Tamper Sensor"
+    TEMPERATURE = "Temperature"
+    TILT = "Tilt"
+    TRANSLATOR = "Translator"
+    UNKNOWN = "Unknown"
+    WATER = "Water"
 
 
 class ZoneSensorGroup(StrEnum):