homeassistant 2025.8.2__py3-none-any.whl → 2025.9.0__py3-none-any.whl

homeassistant/components/zwave_js/config_flow.py

@@ -35,6 +35,7 @@ from homeassistant.const import CONF_NAME, CONF_URL
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.data_entry_flow import AbortFlow
 from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers import selector
 from homeassistant.helpers.hassio import is_hassio
 from homeassistant.helpers.service_info.hassio import HassioServiceInfo
 from homeassistant.helpers.service_info.usb import UsbServiceInfo
@@ -88,6 +89,8 @@ ADDON_USER_INPUT_MAP = {
     CONF_ADDON_LR_S2_AUTHENTICATED_KEY: CONF_LR_S2_AUTHENTICATED_KEY,
 }
 
+CONF_ADDON_RF_REGION = "rf_region"
+
 EXAMPLE_SERVER_URL = "ws://localhost:3000"
 ON_SUPERVISOR_SCHEMA = vol.Schema({vol.Optional(CONF_USE_ADDON, default=True): bool})
 MIN_MIGRATION_SDK_VERSION = AwesomeVersion("6.61")
@@ -103,6 +106,19 @@ ZWAVE_JS_UI_MIGRATION_INSTRUCTIONS = (
     "#how-to-migrate-from-one-adapter-to-a-new-adapter-using-z-wave-js-ui"
 )
 
+RF_REGIONS = [
+    "Australia/New Zealand",
+    "China",
+    "Europe",
+    "Hong Kong",
+    "India",
+    "Israel",
+    "Japan",
+    "Korea",
+    "Russia",
+    "USA",
+]
+
 
 def get_manual_schema(user_input: dict[str, Any]) -> vol.Schema:
     """Return a schema for the manual step."""
@@ -195,10 +211,12 @@ class ZWaveJSConfigFlow(ConfigFlow, domain=DOMAIN):
         self.backup_data: bytes | None = None
         self.backup_filepath: Path | None = None
         self.use_addon = False
+        self._addon_config_updates: dict[str, Any] = {}
         self._migrating = False
         self._reconfigure_config_entry: ZwaveJSConfigEntry | None = None
         self._usb_discovery = False
         self._recommended_install = False
+        self._rf_region: str | None = None
 
     async def async_step_install_addon(
         self, user_input: dict[str, Any] | None = None
@@ -236,6 +254,21 @@ class ZWaveJSConfigFlow(ConfigFlow, domain=DOMAIN):
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
         """Start Z-Wave JS add-on."""
+        if self.hass.config.country is None and (
+            not self._rf_region or self._rf_region == "Automatic"
+        ):
+            # If the country is not set, we need to check the RF region add-on config.
+            addon_info = await self._async_get_addon_info()
+            rf_region: str | None = addon_info.options.get(CONF_ADDON_RF_REGION)
+            self._rf_region = rf_region
+            if rf_region is None or rf_region == "Automatic":
+                # If the RF region is not set, we need to ask the user to select it.
+                return await self.async_step_rf_region()
+        if config_updates := self._addon_config_updates:
+            # If we have updates to the add-on config, set them before starting the add-on.
+            self._addon_config_updates = {}
+            await self._async_set_addon_config(config_updates)
+
         if not self.start_task:
             self.start_task = self.hass.async_create_task(self._async_start_addon())
 
@@ -629,6 +662,33 @@ class ZWaveJSConfigFlow(ConfigFlow, domain=DOMAIN):
             return await self.async_step_on_supervisor({CONF_USE_ADDON: True})
         return await self.async_step_on_supervisor()
 
+    async def async_step_rf_region(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle RF region selection step."""
+        if user_input is not None:
+            # Store the selected RF region
+            self._addon_config_updates[CONF_ADDON_RF_REGION] = self._rf_region = (
+                user_input["rf_region"]
+            )
+            return await self.async_step_start_addon()
+
+        schema = vol.Schema(
+            {
+                vol.Required("rf_region"): selector.SelectSelector(
+                    selector.SelectSelectorConfig(
+                        options=RF_REGIONS,
+                        mode=selector.SelectSelectorMode.DROPDOWN,
+                    )
+                ),
+            }
+        )
+
+        return self.async_show_form(
+            step_id="rf_region",
+            data_schema=schema,
+        )
+
     async def async_step_on_supervisor(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
@@ -728,7 +788,7 @@ class ZWaveJSConfigFlow(ConfigFlow, domain=DOMAIN):
                     CONF_ADDON_LR_S2_AUTHENTICATED_KEY: self.lr_s2_authenticated_key,
                 }
 
-                await self._async_set_addon_config(addon_config_updates)
+                self._addon_config_updates = addon_config_updates
                 return await self.async_step_start_addon()
 
             # Network already exists, go to security keys step
@@ -799,7 +859,7 @@ class ZWaveJSConfigFlow(ConfigFlow, domain=DOMAIN):
                 CONF_ADDON_LR_S2_AUTHENTICATED_KEY: self.lr_s2_authenticated_key,
             }
 
-            await self._async_set_addon_config(addon_config_updates)
+            self._addon_config_updates = addon_config_updates
             return await self.async_step_start_addon()
 
         data_schema = vol.Schema(
@@ -1004,7 +1064,7 @@ class ZWaveJSConfigFlow(ConfigFlow, domain=DOMAIN):
         if user_input is not None:
             if self.usb_path:
                 # USB discovery was used, so the device is already known.
-                await self._async_set_addon_config({CONF_ADDON_DEVICE: self.usb_path})
+                self._addon_config_updates[CONF_ADDON_DEVICE] = self.usb_path
                 return await self.async_step_start_addon()
             # Now that the old controller is gone, we can scan for serial ports again
             return await self.async_step_choose_serial_port()
@@ -1136,6 +1196,8 @@ class ZWaveJSConfigFlow(ConfigFlow, domain=DOMAIN):
                 CONF_ADDON_LR_S2_AUTHENTICATED_KEY: self.lr_s2_authenticated_key,
             }
 
+            addon_config_updates = self._addon_config_updates | addon_config_updates
+            self._addon_config_updates = {}
             await self._async_set_addon_config(addon_config_updates)
 
             if addon_info.state == AddonState.RUNNING and not self.restart_addon:
@@ -1207,7 +1269,7 @@ class ZWaveJSConfigFlow(ConfigFlow, domain=DOMAIN):
         """Choose a serial port."""
         if user_input is not None:
             self.usb_path = user_input[CONF_USB_PATH]
-            await self._async_set_addon_config({CONF_ADDON_DEVICE: self.usb_path})
+            self._addon_config_updates[CONF_ADDON_DEVICE] = self.usb_path
             return await self.async_step_start_addon()
 
         try:

homeassistant/components/zwave_js/const.py

@@ -92,7 +92,6 @@ ATTR_CURRENT_VALUE = "current_value"
 ATTR_CURRENT_VALUE_RAW = "current_value_raw"
 ATTR_DESCRIPTION = "description"
 ATTR_EVENT_SOURCE = "event_source"
-ATTR_CONFIG_ENTRY_ID = "config_entry_id"
 ATTR_PARTIAL_DICT_MATCH = "partial_dict_match"
 
 # service constants

homeassistant/components/zwave_js/cover.py

@@ -299,11 +299,23 @@ class ZWaveMultilevelSwitchCover(CoverPositionMixin):
 
         # Entity class attributes
         self._attr_device_class = CoverDeviceClass.WINDOW
-        if self.info.platform_hint and self.info.platform_hint.startswith("shutter"):
+        if (
+            isinstance(self.info, ZwaveDiscoveryInfo)
+            and self.info.platform_hint
+            and self.info.platform_hint.startswith("shutter")
+        ):
             self._attr_device_class = CoverDeviceClass.SHUTTER
-        elif self.info.platform_hint and self.info.platform_hint.startswith("blind"):
+        elif (
+            isinstance(self.info, ZwaveDiscoveryInfo)
+            and self.info.platform_hint
+            and self.info.platform_hint.startswith("blind")
+        ):
             self._attr_device_class = CoverDeviceClass.BLIND
-        elif self.info.platform_hint and self.info.platform_hint.startswith("gate"):
+        elif (
+            isinstance(self.info, ZwaveDiscoveryInfo)
+            and self.info.platform_hint
+            and self.info.platform_hint.startswith("gate")
+        ):
             self._attr_device_class = CoverDeviceClass.GATE
 
 

homeassistant/components/zwave_js/discovery.py

@@ -3,9 +3,8 @@
 from __future__ import annotations
 
 from collections.abc import Generator
-from dataclasses import asdict, dataclass, field
-from enum import StrEnum
-from typing import TYPE_CHECKING, Any, cast
+from dataclasses import dataclass
+from typing import cast
 
 from awesomeversion import AwesomeVersion
 from zwave_js_server.const import (
@@ -55,6 +54,7 @@ from homeassistant.const import EntityCategory, Platform
 from homeassistant.core import callback
 from homeassistant.helpers.device_registry import DeviceEntry
 
+from .binary_sensor import DISCOVERY_SCHEMAS as BINARY_SENSOR_SCHEMAS
 from .const import COVER_POSITION_PROPERTY_KEYS, COVER_TILT_PROPERTY_KEYS, LOGGER
 from .discovery_data_template import (
     BaseDiscoverySchemaDataTemplate,
@@ -65,108 +65,20 @@ from .discovery_data_template import (
     FixedFanValueMappingDataTemplate,
     NumericSensorDataTemplate,
 )
-from .helpers import ZwaveValueID
-
-if TYPE_CHECKING:
-    from _typeshed import DataclassInstance
-
-
-class ValueType(StrEnum):
-    """Enum with all value types."""
-
-    ANY = "any"
-    BOOLEAN = "boolean"
-    NUMBER = "number"
-    STRING = "string"
-
-
-class DataclassMustHaveAtLeastOne:
-    """A dataclass that must have at least one input parameter that is not None."""
-
-    def __post_init__(self: DataclassInstance) -> None:
-        """Post dataclass initialization."""
-        if all(val is None for val in asdict(self).values()):
-            raise ValueError("At least one input parameter must not be None")
-
-
-@dataclass
-class FirmwareVersionRange(DataclassMustHaveAtLeastOne):
-    """Firmware version range dictionary."""
-
-    min: str | None = None
-    max: str | None = None
-    min_ver: AwesomeVersion | None = field(default=None, init=False)
-    max_ver: AwesomeVersion | None = field(default=None, init=False)
-
-    def __post_init__(self) -> None:
-        """Post dataclass initialization."""
-        super().__post_init__()
-        if self.min:
-            self.min_ver = AwesomeVersion(self.min)
-        if self.max:
-            self.max_ver = AwesomeVersion(self.max)
-
-
-@dataclass
-class ZwaveDiscoveryInfo:
-    """Info discovered from (primary) ZWave Value to create entity."""
-
-    # node to which the value(s) belongs
-    node: ZwaveNode
-    # the value object itself for primary value
-    primary_value: ZwaveValue
-    # bool to specify whether state is assumed and events should be fired on value
-    # update
-    assumed_state: bool
-    # the home assistant platform for which an entity should be created
-    platform: Platform
-    # helper data to use in platform setup
-    platform_data: Any
-    # additional values that need to be watched by entity
-    additional_value_ids_to_watch: set[str]
-    # hint for the platform about this discovered entity
-    platform_hint: str | None = ""
-    # data template to use in platform logic
-    platform_data_template: BaseDiscoverySchemaDataTemplate | None = None
-    # bool to specify whether entity should be enabled by default
-    entity_registry_enabled_default: bool = True
-    # the entity category for the discovered entity
-    entity_category: EntityCategory | None = None
-
-
-@dataclass
-class ZWaveValueDiscoverySchema(DataclassMustHaveAtLeastOne):
-    """Z-Wave Value discovery schema.
-
-    The Z-Wave Value must match these conditions.
-    Use the Z-Wave specifications to find out the values for these parameters:
-    https://github.com/zwave-js/specs/tree/master
-    """
+from .entity import NewZwaveDiscoveryInfo
+from .models import (
+    FirmwareVersionRange,
+    NewZWaveDiscoverySchema,
+    ValueType,
+    ZwaveDiscoveryInfo,
+    ZWaveValueDiscoverySchema,
+    ZwaveValueID,
+)
 
-    # [optional] the value's command class must match ANY of these values
-    command_class: set[int] | None = None
-    # [optional] the value's endpoint must match ANY of these values
-    endpoint: set[int] | None = None
-    # [optional] the value's property must match ANY of these values
-    property: set[str | int] | None = None
-    # [optional] the value's property name must match ANY of these values
-    property_name: set[str] | None = None
-    # [optional] the value's property key must match ANY of these values
-    property_key: set[str | int | None] | None = None
-    # [optional] the value's property key must NOT match ANY of these values
-    not_property_key: set[str | int | None] | None = None
-    # [optional] the value's metadata_type must match ANY of these values
-    type: set[str] | None = None
-    # [optional] the value's metadata_readable must match this value
-    readable: bool | None = None
-    # [optional] the value's metadata_writeable must match this value
-    writeable: bool | None = None
-    # [optional] the value's states map must include ANY of these key/value pairs
-    any_available_states: set[tuple[int, str]] | None = None
-    # [optional] the value's value must match this value
-    value: Any | None = None
-    # [optional] the value's metadata_stateful must match this value
-    stateful: bool | None = None
+NEW_DISCOVERY_SCHEMAS: dict[Platform, list[NewZWaveDiscoverySchema]] = {
+    Platform.BINARY_SENSOR: BINARY_SENSOR_SCHEMAS,
+}
+SUPPORTED_PLATFORMS = tuple(NEW_DISCOVERY_SCHEMAS)
 
 
 @dataclass
@@ -760,7 +672,7 @@ DISCOVERY_SCHEMAS = [
         platform=Platform.SELECT,
         hint="multilevel_switch",
         manufacturer_id={0x0084},
-        product_id={0x0107, 0x0108, 0x010B, 0x0205},
+        product_id={0x0107, 0x0108, 0x0109, 0x010B, 0x0205},
         product_type={0x0311, 0x0313, 0x0331, 0x0341, 0x0343},
         primary_value=SWITCH_MULTILEVEL_CURRENT_VALUE_SCHEMA,
         data_template=BaseDiscoverySchemaDataTemplate(
@@ -1316,7 +1228,7 @@ DISCOVERY_SCHEMAS = [
 @callback
 def async_discover_node_values(
     node: ZwaveNode, device: DeviceEntry, discovered_value_ids: dict[str, set[str]]
-) -> Generator[ZwaveDiscoveryInfo]:
+) -> Generator[ZwaveDiscoveryInfo | NewZwaveDiscoveryInfo]:
     """Run discovery on ZWave node and return matching (primary) values."""
     for value in node.values.values():
         # We don't need to rediscover an already processed value_id
@@ -1327,9 +1239,19 @@ def async_discover_node_values(
 @callback
 def async_discover_single_value(
     value: ZwaveValue, device: DeviceEntry, discovered_value_ids: dict[str, set[str]]
-) -> Generator[ZwaveDiscoveryInfo]:
+) -> Generator[ZwaveDiscoveryInfo | NewZwaveDiscoveryInfo]:
     """Run discovery on a single ZWave value and return matching schema info."""
-    for schema in DISCOVERY_SCHEMAS:
+    # Temporary workaround for new schemas
+    schemas: tuple[ZWaveDiscoverySchema | NewZWaveDiscoverySchema, ...] = (
+        *(
+            new_schema
+            for _schemas in NEW_DISCOVERY_SCHEMAS.values()
+            for new_schema in _schemas
+        ),
+        *DISCOVERY_SCHEMAS,
+    )
+
+    for schema in schemas:
         # abort if attribute(s) already discovered
         if value.value_id in discovered_value_ids[device.id]:
             continue
@@ -1458,18 +1380,38 @@ def async_discover_single_value(
             )
 
         # all checks passed, this value belongs to an entity
-        yield ZwaveDiscoveryInfo(
-            node=value.node,
-            primary_value=value,
-            assumed_state=schema.assumed_state,
-            platform=schema.platform,
-            platform_hint=schema.hint,
-            platform_data_template=schema.data_template,
-            platform_data=resolved_data,
-            additional_value_ids_to_watch=additional_value_ids_to_watch,
-            entity_registry_enabled_default=schema.entity_registry_enabled_default,
-            entity_category=schema.entity_category,
-        )
+
+        discovery_info: ZwaveDiscoveryInfo | NewZwaveDiscoveryInfo
+
+        # Temporary workaround for new schemas
+        if isinstance(schema, NewZWaveDiscoverySchema):
+            discovery_info = NewZwaveDiscoveryInfo(
+                node=value.node,
+                primary_value=value,
+                assumed_state=schema.assumed_state,
+                platform=schema.platform,
+                platform_data_template=schema.data_template,
+                platform_data=resolved_data,
+                additional_value_ids_to_watch=additional_value_ids_to_watch,
+                entity_class=schema.entity_class,
+                entity_description=schema.entity_description,
+            )
+
+        else:
+            discovery_info = ZwaveDiscoveryInfo(
+                node=value.node,
+                primary_value=value,
+                assumed_state=schema.assumed_state,
+                platform=schema.platform,
+                platform_hint=schema.hint,
+                platform_data_template=schema.data_template,
+                platform_data=resolved_data,
+                additional_value_ids_to_watch=additional_value_ids_to_watch,
+                entity_registry_enabled_default=schema.entity_registry_enabled_default,
+                entity_category=schema.entity_category,
+            )
+
+        yield discovery_info
 
         # prevent re-discovery of the (primary) value if not allowed
         if not schema.allow_multi:
@@ -1615,6 +1557,25 @@ def check_value(
         )
     ):
         return False
+    if (
+        schema.any_available_states_keys is not None
+        and value.metadata.states is not None
+        and not any(
+            str(key) in value.metadata.states
+            for key in schema.any_available_states_keys
+        )
+    ):
+        return False
+    # check available cc specific
+    if (
+        schema.any_available_cc_specific is not None
+        and value.metadata.cc_specific is not None
+        and not any(
+            key in value.metadata.cc_specific and value.metadata.cc_specific[key] == val
+            for key, val in schema.any_available_cc_specific
+        )
+    ):
+        return False
     # check value
     if schema.value is not None and value.value not in schema.value:
         return False

homeassistant/components/zwave_js/discovery_data_template.py

@@ -90,11 +90,9 @@ from zwave_js_server.const.command_class.multilevel_sensor import (
     MultilevelSensorType,
 )
 from zwave_js_server.exceptions import UnknownValueData
-from zwave_js_server.model.node import Node as ZwaveNode
 from zwave_js_server.model.value import (
     ConfigurationValue as ZwaveConfigurationValue,
     Value as ZwaveValue,
-    get_value_id_str,
 )
 from zwave_js_server.util.command_class.energy_production import (
     get_energy_production_parameter,
@@ -159,7 +157,7 @@ from .const import (
     ENTITY_DESC_KEY_UV_INDEX,
     ENTITY_DESC_KEY_VOLTAGE,
 )
-from .helpers import ZwaveValueID
+from .models import BaseDiscoverySchemaDataTemplate, ZwaveValueID
 
 ENERGY_PRODUCTION_DEVICE_CLASS_MAP: dict[str, list[EnergyProductionParameter]] = {
     ENTITY_DESC_KEY_ENERGY_PRODUCTION_TIME: [EnergyProductionParameter.TOTAL_TIME],
@@ -264,49 +262,6 @@ MULTILEVEL_SENSOR_UNIT_MAP: dict[str, list[MultilevelSensorScaleType]] = {
 _LOGGER = logging.getLogger(__name__)
 
 
-@dataclass
-class BaseDiscoverySchemaDataTemplate:
-    """Base class for discovery schema data templates."""
-
-    static_data: Any | None = None
-
-    def resolve_data(self, value: ZwaveValue) -> Any:
-        """Resolve helper class data for a discovered value.
-
-        Can optionally be implemented by subclasses if input data needs to be
-        transformed once discovered Value is available.
-        """
-        return {}
-
-    def values_to_watch(self, resolved_data: Any) -> Iterable[ZwaveValue | None]:
-        """Return list of all ZwaveValues resolved by helper that should be watched.
-
-        Should be implemented by subclasses only if there are values to watch.
-        """
-        return []
-
-    def value_ids_to_watch(self, resolved_data: Any) -> set[str]:
-        """Return list of all Value IDs resolved by helper that should be watched.
-
-        Not to be overwritten by subclasses.
-        """
-        return {val.value_id for val in self.values_to_watch(resolved_data) if val}
-
-    @staticmethod
-    def _get_value_from_id(
-        node: ZwaveNode, value_id_obj: ZwaveValueID
-    ) -> ZwaveValue | ZwaveConfigurationValue | None:
-        """Get a ZwaveValue from a node using a ZwaveValueDict."""
-        value_id = get_value_id_str(
-            node,
-            value_id_obj.command_class,
-            value_id_obj.property_,
-            endpoint=value_id_obj.endpoint,
-            property_key=value_id_obj.property_key,
-        )
-        return node.values.get(value_id)
-
-
 @dataclass
 class DynamicCurrentTempClimateDataTemplate(BaseDiscoverySchemaDataTemplate):
     """Data template class for Z-Wave JS Climate entities with dynamic current temps."""

homeassistant/components/zwave_js/entity.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 from collections.abc import Sequence
+from dataclasses import dataclass
 from typing import Any
 
 from zwave_js_server.exceptions import BaseZwaveJSServerError
@@ -18,16 +19,33 @@ from homeassistant.core import callback
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
-from homeassistant.helpers.entity import Entity
+from homeassistant.helpers.entity import Entity, EntityDescription
 from homeassistant.helpers.typing import UNDEFINED
 
 from .const import DOMAIN, EVENT_VALUE_UPDATED, LOGGER
-from .discovery import ZwaveDiscoveryInfo
+from .discovery_data_template import BaseDiscoverySchemaDataTemplate
 from .helpers import get_device_id, get_unique_id, get_valueless_base_unique_id
+from .models import PlatformZwaveDiscoveryInfo, ZwaveDiscoveryInfo
 
 EVENT_VALUE_REMOVED = "value removed"
 
 
+@dataclass(kw_only=True)
+class NewZwaveDiscoveryInfo(PlatformZwaveDiscoveryInfo):
+    """Info discovered from (primary) ZWave Value to create entity.
+
+    This is the new discovery info that will replace ZwaveDiscoveryInfo.
+    """
+
+    entity_class: type[ZWaveBaseEntity]
+    # the entity description to use
+    entity_description: EntityDescription
+    # helper data to use in platform setup
+    platform_data: Any = None
+    # data template to use in platform logic
+    platform_data_template: BaseDiscoverySchemaDataTemplate | None = None
+
+
 class ZWaveBaseEntity(Entity):
     """Generic Entity Class for a Z-Wave Device."""
 
@@ -35,7 +53,10 @@ class ZWaveBaseEntity(Entity):
     _attr_has_entity_name = True
 
     def __init__(
-        self, config_entry: ConfigEntry, driver: Driver, info: ZwaveDiscoveryInfo
+        self,
+        config_entry: ConfigEntry,
+        driver: Driver,
+        info: ZwaveDiscoveryInfo | NewZwaveDiscoveryInfo,
     ) -> None:
         """Initialize a generic Z-Wave device entity."""
         self.config_entry = config_entry
@@ -52,12 +73,14 @@ class ZWaveBaseEntity(Entity):
         # Entity class attributes
         self._attr_name = self.generate_name()
         self._attr_unique_id = get_unique_id(driver, self.info.primary_value.value_id)
-        if self.info.entity_registry_enabled_default is False:
-            self._attr_entity_registry_enabled_default = False
-        if self.info.entity_category is not None:
-            self._attr_entity_category = self.info.entity_category
-        if self.info.assumed_state:
-            self._attr_assumed_state = True
+        if isinstance(info, NewZwaveDiscoveryInfo):
+            self.entity_description = info.entity_description
+        else:
+            if (enabled_default := info.entity_registry_enabled_default) is False:
+                self._attr_entity_registry_enabled_default = enabled_default
+            if (entity_category := info.entity_category) is not None:
+                self._attr_entity_category = entity_category
+        self._attr_assumed_state = self.info.assumed_state
         # device is precreated in main handler
         self._attr_device_info = DeviceInfo(
             identifiers={get_device_id(driver, self.info.node)},

homeassistant/components/zwave_js/helpers.py

@@ -60,16 +60,6 @@ DRIVER_READY_EVENT_TIMEOUT = 60
 SERVER_VERSION_TIMEOUT = 10
 
 
-@dataclass
-class ZwaveValueID:
-    """Class to represent a value ID."""
-
-    property_: str | int
-    command_class: int
-    endpoint: int | None = None
-    property_key: str | int | None = None
-
-
 @dataclass
 class ZwaveValueMatcher:
     """Class to allow matching a Z-Wave Value."""

homeassistant/components/zwave_js/migrate.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from dataclasses import dataclass
 import logging
 
+from zwave_js_server.const import CommandClass
 from zwave_js_server.model.driver import Driver
 from zwave_js_server.model.node import Node
 from zwave_js_server.model.value import Value as ZwaveValue
@@ -14,8 +15,8 @@ from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers import device_registry as dr, entity_registry as er
 
 from .const import DOMAIN
-from .discovery import ZwaveDiscoveryInfo
 from .helpers import get_unique_id, get_valueless_base_unique_id
+from .models import PlatformZwaveDiscoveryInfo
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -140,7 +141,7 @@ def async_migrate_discovered_value(
     registered_unique_ids: set[str],
     device: dr.DeviceEntry,
     driver: Driver,
-    disc_info: ZwaveDiscoveryInfo,
+    disc_info: PlatformZwaveDiscoveryInfo,
 ) -> None:
     """Migrate unique ID for entity/entities tied to discovered value."""
 
@@ -162,7 +163,7 @@ def async_migrate_discovered_value(
 
     if (
         disc_info.platform == Platform.BINARY_SENSOR
-        and disc_info.platform_hint == "notification"
+        and disc_info.primary_value.command_class == CommandClass.NOTIFICATION
     ):
         for state_key in disc_info.primary_value.metadata.states:
             # ignore idle key (0)