qolsys-controller 0.0.62__py3-none-any.whl → 0.0.87__py3-none-any.whl

qolsys_controller/controller.py

@@ -2,7 +2,6 @@
 from __future__ import annotations
 
 import asyncio
-import base64
 import contextlib
 import json
 import logging
@@ -19,10 +18,11 @@ 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, ZwaveCommand, ZwaveDeviceClass
-from .errors import QolsysMqttError, QolsysSslError
+from .enum_zwave import ThermostatFanMode, ThermostatMode, ThermostatSetpointMode, ZwaveCommandClass, ZwaveDeviceClass
+from .errors import QolsysMqttError, QolsysSslError, QolsysUserCodeError
 from .mdns import QolsysMDNS
 from .mqtt_command_queue import QolsysMqttCommandQueue
 from .observable import QolsysObservable
@@ -53,6 +53,7 @@ class QolsysController:
         self.certificate_exchange_server: asyncio.Server | None = None
         self._task_manager = QolsysTaskManager()
         self._mqtt_command_queue = QolsysMqttCommandQueue()
+        self._zone_id: str = "1"
 
         # MQTT Client
         self.aiomqtt: aiomqtt.Client | None = None
@@ -201,14 +202,10 @@ class QolsysController:
                     # Subscribe to MQTT commands send to panel by other devices
                     await self.aiomqtt.subscribe("mastermeid", qos=self.settings.mqtt_qos)
 
-                    # Subscribe to all topics
-                    # await self.aiomqtt.subscribe("#", qos=self.settings.mqtt_qos)
-
                 self._task_manager.run(self.mqtt_listen_task(), self._mqtt_task_listen_label)
                 self._task_manager.run(self.mqtt_ping_task(), self._mqtt_task_ping_label)
 
                 response_connect = await self.command_connect()
-
                 self.panel.imei = response_connect.get("master_imei", "")
                 self.panel.product_type = response_connect.get("primary_product_type", "")
 
@@ -285,14 +282,7 @@ class QolsysController:
                 if message.topic.matches("ZWAVE_RESPONSE"):  # noqa: SIM102
                     if isinstance(message.payload, bytes):
                         data = json.loads(message.payload.decode())
-                        zwave = data.get("ZWAVE_RESPONSE", "")
-                        decoded_payload = base64.b64decode(zwave.get("ZWAVE_PAYLOAD", "")).hex()
-                        LOGGER.debug(
-                            "Z-Wave Response: Node(%s) - Status(%s) - Payload(%s)",
-                            zwave.get("NODE_ID", ""),
-                            zwave.get("ZWAVE_COMMAND_STATUS", ""),
-                            decoded_payload,
-                        )
+                        self.panel.parse_zwave_message(data)
 
         except aiomqtt.MqttError as err:
             self.connected = False
@@ -618,7 +608,7 @@ class QolsysController:
             user_id = self.panel.check_user(user_code)
             if user_id == -1:
                 LOGGER.debug("MQTT: disarm command error - user_code error")
-                return None
+                raise QolsysUserCodeError()
 
         async def get_mqtt_disarm_command(silent_disarming: bool) -> str:
             if partition.alarm_state == PartitionAlarmState.ALARM:
@@ -688,12 +678,12 @@ class QolsysController:
             LOGGER.debug("MQTT: arm command error - Unknow Partition")
             return None
 
-        if self.panel.SECURE_ARMING == "true" and self.settings.check_user_code_on_arm:
-            # Do local user code verification to arm if secure arming is enabled
+        if self.settings.check_user_code_on_arm:
+            # Do local user code verification to arm
             user_id = self.panel.check_user(user_code)
             if user_id == -1:
                 LOGGER.debug("MQTT: arm command error - user_code error")
-                return None
+                raise QolsysUserCodeError()
 
         exitSoundValue = "ON"
         if not exit_sounds:
@@ -758,6 +748,141 @@ 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": 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,
+        }
+
+        ipc_request = [
+            {
+                "dataType": "string",
+                "dataValue": json.dumps(virtual_command),
+            }
+        ]
+
+        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)
+        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")
+
+        partition = self.state.partition(partition_id)
+        if not partition:
+            LOGGER.debug("MQTT: command_panel_trigger_police Error - Unknow Partition: %s", partition_id)
+            return None
+
+        trigger_command = {
+            "operation_name": "generate_emergency",
+            "partitionID": int(partition_id),
+            "zoneID": int(self._zone_id),
+            "emergencyType": "Silent Police Emergency" if silent else "Police Emergency",
+            "operation_source": 1,
+            "macAddress": self.settings.random_mac,
+        }
+
+        ipc_request = [
+            {
+                "dataType": "string",
+                "dataValue": json.dumps(trigger_command),
+            }
+        ]
+
+        command = MQTTCommand_Panel(self)
+        command.append_ipc_request(ipc_request)
+        response = await command.send_command()
+        LOGGER.debug("MQTT: Receiving panel_trigger_police command")
+        return response
+
+    async def command_panel_trigger_auxilliary(self, partition_id: str, silent: bool) -> dict[str, Any] | None:
+        LOGGER.debug("MQTT: Sending panel_trigger_auxilliary command")
+
+        partition = self.state.partition(partition_id)
+        if not partition:
+            LOGGER.debug("MQTT: command_panel_trigger_auxilliary Error - Unknow Partition: %s", partition_id)
+            return None
+
+        trigger_command = {
+            "operation_name": "generate_emergency",
+            "partitionID": int(partition_id),
+            "zoneID": int(self._zone_id),
+            "emergencyType": "Silent Auxiliary Emergency" if silent else "Auxiliary Emergency",
+            "operation_source": 1,
+            "macAddress": self.settings.random_mac,
+        }
+
+        ipc_request = [
+            {
+                "dataType": "string",
+                "dataValue": json.dumps(trigger_command),
+            }
+        ]
+
+        command = MQTTCommand_Panel(self)
+        command.append_ipc_request(ipc_request)
+        response = await command.send_command()
+        LOGGER.debug("MQTT: Receiving panel_trigger_auxilliary command")
+        return response
+
+    async def command_panel_trigger_fire(self, partition_id: str) -> dict[str, Any] | None:
+        LOGGER.debug("MQTT: Sending panel_trigger_fire command")
+
+        partition = self.state.partition(partition_id)
+        if not partition:
+            LOGGER.debug("MQTT: command_panel_trigger_fire Error - Unknow Partition: %s", partition_id)
+            return None
+
+        trigger_command = {
+            "operation_name": "generate_emergency",
+            "partitionID": int(partition_id),
+            "zoneID": int(self._zone_id),
+            "emergencyType": "Fire Emergency",
+            "operation_source": 1,
+            "macAddress": self.settings.random_mac,
+        }
+
+        ipc_request = [
+            {
+                "dataType": "string",
+                "dataValue": json.dumps(trigger_command),
+            }
+        ]
+
+        command = MQTTCommand_Panel(self)
+        command.append_ipc_request(ipc_request)
+        response = await command.send_command()
+        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)
         zwave_node = self.state.zwave_device(node_id)
@@ -774,7 +899,7 @@ class QolsysController:
         if status:
             level = 255
 
-        command = MQTTCommand_ZWave(self, node_id, [ZwaveCommand.SwitchBinary, 1, level])
+        command = MQTTCommand_ZWave(self, node_id, [ZwaveCommandClass.SwitchBinary, 1, level])
         response = await command.send_command()
         LOGGER.debug("MQTT: Receiving set_zwave_switch_binary command")
         return response
@@ -791,7 +916,7 @@ class QolsysController:
             LOGGER.error("switch_multilevel_set used on invalid %s", zwave_node.generic_device_type)
             return None
 
-        command = MQTTCommand_ZWave(self, node_id, [ZwaveCommand.SwitchMultilevel, 1, level])
+        command = MQTTCommand_ZWave(self, node_id, [ZwaveCommandClass.SwitchMultilevel, 1, level])
         response = await command.send_command()
         LOGGER.debug("MQTT: Receiving set_zwave_multilevel_switch command")
         return response
@@ -809,37 +934,123 @@ class QolsysController:
         if locked:
             lock_mode = 255
 
-        command = MQTTCommand_ZWave(self, node_id, [ZwaveCommand.DoorLock, 1, lock_mode])
+        command = MQTTCommand_ZWave(self, node_id, [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, 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, [ZwaveCommand.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,
+        #    0x03,  # SET
+        #    mode.value,
+        #    pss,
+        # ] + list(temp_bytes)
+
+        zwave_bytes2: list[int] = [
+            0x43,  # Thermostat Setpoint
+            0x01,  # SET
+            setpointmode.value,
+            pss,
+        ] + list(temp_bytes)
+
+        # zwave_bytes3: list[int] = [
+        #    0x43,  # Thermostat Setpoint
+        #    0x03,  # SET
+        #    0x03,  # Furnace
+        #    pss,
+        # ] + list(temp_bytes)
+
+        # zwave_bytes4: list[int] = [
+        #    0x43,  # Thermostat Setpoint
+        #    0x01,  # SET
+        #    0x03,  # Furnace
+        #    pss,
+        # ] + list(temp_bytes)
+
+        # LOGGER.debug(
+        #    "MQTT: Sending zwave_thermostat_setpoint_set 0x03 - Node(%s) - Mode(%s) - Setpoint(%s): %s",
+        #    node_id,
+        #    mode.value,
+        #    setpoint,
+        #    zwave_bytes,
+        # )
+        # command = MQTTCommand_ZWave(self, node_id, zwave_bytes)
+        # response = await command.send_command()
+        # LOGGER.debug("MQTT: Receiving zwave_thermostat_mode_set command:%s", response)
+
+        LOGGER.debug(
+            "MQTT: Sending zwave_thermostat_setpoint_set 0x01 - Node(%s) - Mode(%s) - Setpoint(%s): %s",
+            node_id,
+            mode.value,
+            setpoint,
+            zwave_bytes2,
+        )
+        command = MQTTCommand_ZWave(self, node_id, zwave_bytes2)
         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)
+
+        # LOGGER.debug(
+        #    "MQTT: Sending zwave_thermostat_setpoint_set 0x03 - Node(%s) - Mode(%s) - Setpoint(%s): %s",
+        #    node_id,
+        #    0x03,
+        #    setpoint,
+        #    zwave_bytes3,
+        # )
+        # command = MQTTCommand_ZWave(self, node_id, zwave_bytes3)
+        # response = await command.send_command()
+        # LOGGER.debug("MQTT: Receiving zwave_thermostat_mode_set command:%s", response)
+
+        # LOGGER.debug(
+        #    "MQTT: Sending zwave_thermostat_setpoint_set 0x01 - Node(%s) - Mode(%s) - Setpoint(%s): %s",
+        #    node_id,
+        #    0x03,
+        #    setpoint,
+        #    zwave_bytes4,
+        # )
+        # command = MQTTCommand_ZWave(self, node_id, zwave_bytes4)
+        # response = await command.send_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:
         LOGGER.debug("MQTT: Sending zwave_thermostat_mode_set command - Node(%s) - Mode(%s)", node_id, mode)
 
-        zwave_node = self.state.zwave_device(node_id)
-        if not zwave_node:
-            LOGGER.error("thermostat_mode_set - Invalid node_id %s", node_id)
+        thermostat = self.state.zwave_thermostat(node_id)
+        if not thermostat:
+            LOGGER.error("zwave_thermostat_mode_set - Invalid node_id %s", node_id)
             return None
 
-        command = MQTTCommand_ZWave(self, node_id, [ZwaveCommand.ThermostatMode, 1, 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)])
         response = await command.send_command()
         LOGGER.debug("MQTT: Receiving zwave_thermostat_mode_set command")
         return response
@@ -852,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, [ZwaveCommand.ThermostatFanMode, 1, fan_mode])
+        command = MQTTCommand_ZWave(self, node_id, [ZwaveCommandClass.ThermostatFanMode, 1, fan_mode])
         response = await command.send_command()
         LOGGER.debug("MQTT: Receiving zwave_thermostat_fan_mode_set command")
         return response

qolsys_controller/database/db.py

@@ -155,6 +155,42 @@ class QolsysDB:
     def cursor(self) -> sqlite3.Cursor:
         return self._cursor
 
+    def get_users(self) -> list[dict[str, str]]:
+        self.cursor.execute(f"SELECT * FROM {self.table_user.table} ORDER BY _id")
+        self.db.commit()
+
+        users = []
+        columns = [description[0] for description in self.cursor.description]
+        for row in self.cursor.fetchall():
+            row_dict = dict(zip(columns, row, strict=True))
+            users.append(row_dict)
+
+        return users
+
+    def get_master_slave(self) -> list[dict[str, str]]:
+        self.cursor.execute(f"SELECT * FROM {self.table_master_slave.table}")
+        self.db.commit()
+
+        masterslave = []
+        columns = [description[0] for description in self.cursor.description]
+        for row in self.cursor.fetchall():
+            row_dict = dict(zip(columns, row, strict=True))
+            masterslave.append(row_dict)
+
+        return masterslave
+
+    def get_iqremote_settings(self) -> list[dict[str, str]]:
+        self.cursor.execute(f"SELECT * FROM {self.table_iqremotesettings.table}")
+        self.db.commit()
+
+        iqremote_settings = []
+        columns = [description[0] for description in self.cursor.description]
+        for row in self.cursor.fetchall():
+            row_dict = dict(zip(columns, row, strict=True))
+            iqremote_settings.append(row_dict)
+
+        return iqremote_settings
+
     def get_scenes(self) -> list[dict[str, str]]:
         self.cursor.execute(f"SELECT * FROM {self.table_scene.table} ORDER BY scene_id")
         self.db.commit()
@@ -179,6 +215,18 @@ 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.db.commit()
+
+        devices = []
+        columns = [description[0] for description in self.cursor.description]
+        for row in self.cursor.fetchall():
+            row_dict = dict(zip(columns, row, strict=True))
+            devices.append(row_dict)
+
+        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.db.commit()
@@ -191,6 +239,18 @@ 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.db.commit()
+
+        devices = []
+        columns = [description[0] for description in self.cursor.description]
+        for row in self.cursor.fetchall():
+            row_dict = dict(zip(columns, row, strict=True))
+            devices.append(row_dict)
+
+        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.db.commit()

qolsys_controller/database/table.py

@@ -79,6 +79,7 @@ class QolsysTable:
                 LOGGER.warning("Please Report")
                 return
 
+            # Select only known columns
             full_data = {col: data.get(col, "") for col in self._columns}
 
             new_columns = []

qolsys_controller/database/table_alarmedsensor.py

@@ -26,6 +26,8 @@ class QolsysTableAlarmedSensor(QolsysTable):
             "priority",
             "aseb_type",
             "alarm_time",
+            "version",
+            "opr",
         ]
 
         self._create_table()

qolsys_controller/database/table_history.py

@@ -27,9 +27,9 @@ class QolsysTableHistory(QolsysTable):
             "feature1",
             "feature2",
             "device_id",
-            # "History Bulk Insert",
+            # "history_bulk_insert",
             "Partition",
-            # "History Device Names List",
+            # "History_Device_Names_List",
             # "History Bypass Event",
         ]
 

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/database/table_thermostat.py

@@ -40,6 +40,7 @@ class QolsysTableThermostat(QolsysTable):
             "thermostat_mode_updated_time",
             "fan_mode_updated_time",
             "set_point_mode_updated_time",
+            "setpoint_capabilites",
             "target_cool_temp_updated_time",
             "target_heat_temp_updated_time",
             "current_temp_updated_time",
@@ -47,6 +48,8 @@ class QolsysTableThermostat(QolsysTable):
             "endpoint",
             "paired_status",
             "configuration_parameter",
+            "operating_state",
+            "fan_state",
         ]
 
         self._create_table()

qolsys_controller/database/table_virtual_device.py

@@ -12,10 +12,22 @@ class QolsysTableVirtualDevice(QolsysTable):
         self._uri = "content://com.qolsys.qolsysprovider.VirtualDeviceContentProvider/virtual_device"
         self._table = "virtual_device"
         self._abort_on_error = False
-        self._implemented = False
+        self._implemented = True
 
         self._columns = [
             "_id",
+            "version",
+            "opr",
+            "partition_id",
+            "device_id",
+            "name",
+            "type",
+            "func_list",
+            "create_time",
+            "created_by",
+            "update_time",
+            "updated_by",
+            "device_zone_list",
         ]
 
         self._create_table()

qolsys_controller/database/table_zwave_node.py

@@ -79,6 +79,9 @@ class QolsysTableZwaveNode(QolsysTable):
             "sound_switch_info",
             "long_range_nodeid",
             "hide_device_info",
+            "meter_capabilities",
+            "multisensor_capabilities",
+            "central_scene_supported",
         ]
 
         self._create_table()

qolsys_controller/enum.py

@@ -44,6 +44,7 @@ class PartitionAlarmType(StrEnum):
     STAY_INSTANT_MOTION = "stayinstantmotion"
     STAY_DELAY_MOTION = "staydelaymotion"
     AWAY_DELAY_MOTION = "awaydelaymotion"
+    EMPTY = ""
 
 
 class ZoneStatus(StrEnum):
@@ -57,11 +58,13 @@ class ZoneStatus(StrEnum):
     NORMAL = "Normal"
     UNREACHABLE = "Unreachable"
     TAMPERED = "Tampered"
-    SYNCHONIZING = "Synchonizing"
+    SYNCHRONIZING = "Synchronizing"
     CONNECTED = "connected"
     DISCONNECTED = "disconnected"
     FAILURE = "Failure"
     NOT_NETWORKED = "Not Networked"
+    DISARM = "Disarm"
+    ARM_AWAY = "Arm-Away"
 
 
 class DeviceCapability(StrEnum):
@@ -130,6 +133,7 @@ class ZoneSensorGroup(StrEnum):
     STAY_INSTANT_MOTION = "stayinstantmotion"
     STAY_DELAY_MOTION = "staydelaymotion"
     AWAY_DELAY_MOTION = "awaydelaymotion"
+    WATER = "WaterSensor"
 
     # TAKEOVER = "" #TBD
     # GARAGE_TILT_SAFETY = "" # TBD

qolsys_controller/enum_adc.py

@@ -0,0 +1,28 @@
+from enum import Enum, IntEnum
+
+
+class vdFuncType(IntEnum):
+    BINARY_ACTUATOR = 1
+    MULTISTATE_ACTUATOR = 2
+    LEVEL = 3
+    STATUS = 4
+    MOMENTARY_ACTION = 5
+    MODE_SELECTOR = 6
+    EVENT = 7
+
+
+class vdFuncName(Enum):
+    OPEN_CLOSE = "Open/Close"
+    LOCK_UNLOCK = "Lock/Unlock"
+    ON_OFF = "On/Off"
+
+
+class vdFuncLocalControl(IntEnum):
+    NONE = 0
+    STATUS_ONLY = 1
+    FULL_CONTROL = 2
+
+
+class vdFuncState(IntEnum):
+    ON = 0
+    OFF = 1