@@ -182,11 +182,11 @@ def auto_softener(self) -> bool | None:
             return self.softener_type is not None and self.softener_type != ZeoSoftenerType.empty
         return self.softener_set
 
-    async def _set_enum(self, dp: RoborockZeoProtocol, enum_cls: type[_T], value: _T) -> dict[RoborockZeoProtocol, Any]:
+    async def _set_enum(self, dp: RoborockZeoProtocol, enum_cls: type[_T], value: _T) -> None:
         """Validate *value* against *enum_cls* and send it to the device."""
         if not isinstance(value, enum_cls):
             raise TypeError(f"Expected {enum_cls.__name__}, got {type(value).__name__}")
-        return await self._send({dp: int(value)})
+        await self._send({dp: int(value)})
 
     # -- Start-parameter setters (TEST-ONLY) --------------------------------
     #
@@ -201,51 +201,51 @@ async def _set_enum(self, dp: RoborockZeoProtocol, enum_cls: type[_T], value: _T
     #
     # They are retained purely as a test/debug convenience.
 
-    async def set_mode(self, mode: ZeoMode) -> dict[RoborockZeoProtocol, Any]:
+    async def set_mode(self, mode: ZeoMode) -> None:
         """Set the current mode (DP 204). Test-only: carried by START."""
-        return await self._set_enum(RoborockZeoProtocol.MODE, ZeoMode, mode)
+        await self._set_enum(RoborockZeoProtocol.MODE, ZeoMode, mode)
 
-    async def set_program(self, program: ZeoProgram) -> dict[RoborockZeoProtocol, Any]:
+    async def set_program(self, program: ZeoProgram) -> None:
         """Set the current programme (DP 205). Test-only: carried by START."""
-        return await self._set_enum(RoborockZeoProtocol.PROGRAM, ZeoProgram, program)
+        await self._set_enum(RoborockZeoProtocol.PROGRAM, ZeoProgram, program)
 
     # -- Washer-specific setters --------------------------------------------
 
-    async def set_temperature(self, temperature: ZeoTemperature) -> dict[RoborockZeoProtocol, Any]:
+    async def set_temperature(self, temperature: ZeoTemperature) -> None:
         """Set the wash temperature (DP 207). Test-only: carried by START."""
-        return await self._set_enum(RoborockZeoProtocol.TEMP, ZeoTemperature, temperature)
+        await self._set_enum(RoborockZeoProtocol.TEMP, ZeoTemperature, temperature)
 
-    async def set_rinse(self, rinse: ZeoRinse) -> dict[RoborockZeoProtocol, Any]:
+    async def set_rinse(self, rinse: ZeoRinse) -> None:
         """Set the rinse count (DP 208). Test-only: carried by START."""
-        return await self._set_enum(RoborockZeoProtocol.RINSE_TIMES, ZeoRinse, rinse)
+        await self._set_enum(RoborockZeoProtocol.RINSE_TIMES, ZeoRinse, rinse)
 
-    async def set_spin(self, spin: ZeoSpin) -> dict[RoborockZeoProtocol, Any]:
+    async def set_spin(self, spin: ZeoSpin) -> None:
         """Set the spin speed (DP 209). Test-only: carried by START."""
-        return await self._set_enum(RoborockZeoProtocol.SPIN_LEVEL, ZeoSpin, spin)
+        await self._set_enum(RoborockZeoProtocol.SPIN_LEVEL, ZeoSpin, spin)
 
-    async def set_drying_mode(self, drying_mode: ZeoDryingMode) -> dict[RoborockZeoProtocol, Any]:
+    async def set_drying_mode(self, drying_mode: ZeoDryingMode) -> None:
         """Set the drying mode (DP 210). Test-only: carried by START."""
-        return await self._set_enum(RoborockZeoProtocol.DRYING_MODE, ZeoDryingMode, drying_mode)
+        await self._set_enum(RoborockZeoProtocol.DRYING_MODE, ZeoDryingMode, drying_mode)
 
-    async def set_soak(self, soak: ZeoSoak) -> dict[RoborockZeoProtocol, Any]:
+    async def set_soak(self, soak: ZeoSoak) -> None:
         """Set the soak level (DP 233). Test-only: carried by START."""
-        return await self._set_enum(RoborockZeoProtocol.SOAK, ZeoSoak, soak)
+        await self._set_enum(RoborockZeoProtocol.SOAK, ZeoSoak, soak)
 
-    async def set_dry_and_care(self, dry_and_care: ZeoDryAndCare) -> dict[RoborockZeoProtocol, Any]:
+    async def set_dry_and_care(self, dry_and_care: ZeoDryAndCare) -> None:
         """Set the dry-and-care mode (DP 244). Test-only: carried by START."""
-        return await self._set_enum(RoborockZeoProtocol.DRY_CARE_MODE, ZeoDryAndCare, dry_and_care)
+        await self._set_enum(RoborockZeoProtocol.DRY_CARE_MODE, ZeoDryAndCare, dry_and_care)
 
     # -- Dryer-specific setters ---------------------------------------------
 
-    async def set_drying_method(self, drying_method: ZeoDryingMethod) -> dict[RoborockZeoProtocol, Any]:
+    async def set_drying_method(self, drying_method: ZeoDryingMethod) -> None:
         """Set the drying method (DP 256). Test-only: carried by START."""
-        return await self._set_enum(RoborockZeoProtocol.DRYING_METHOD, ZeoDryingMethod, drying_method)
+        await self._set_enum(RoborockZeoProtocol.DRYING_METHOD, ZeoDryingMethod, drying_method)
 
-    async def set_steam_volume(self, steam_volume: ZeoSteamVolume) -> dict[RoborockZeoProtocol, Any]:
+    async def set_steam_volume(self, steam_volume: ZeoSteamVolume) -> None:
         """Set the steam volume (DP 257). Test-only: carried by START."""
-        return await self._set_enum(RoborockZeoProtocol.STEAM_VOLUME, ZeoSteamVolume, steam_volume)
+        await self._set_enum(RoborockZeoProtocol.STEAM_VOLUME, ZeoSteamVolume, steam_volume)
 
-    async def set_detergent_type(self, detergent_type: ZeoDetergentType) -> dict[RoborockZeoProtocol, Any]:
+    async def set_detergent_type(self, detergent_type: ZeoDetergentType) -> None:
         """Set the detergent type (DP 213), optionally toggling auto-dosing."""
         e = int(detergent_type)
         dps: dict[RoborockZeoProtocol, Any]
@@ -264,9 +264,9 @@ async def set_detergent_type(self, detergent_type: ZeoDetergentType) -> dict[Rob
                 RoborockZeoProtocol.DETERGENT_SET: 0 if e == 0 else 1,
                 RoborockZeoProtocol.DETERGENT_TYPE: e,
             }
-        return await self._send(dps)
+        await self._send(dps)
 
-    async def set_softener_type(self, softener_type: ZeoSoftenerType) -> dict[RoborockZeoProtocol, Any]:
+    async def set_softener_type(self, softener_type: ZeoSoftenerType) -> None:
         """Set the softener type (DP 214)."""
         e = int(softener_type)
         dps: dict[RoborockZeoProtocol, Any]
@@ -285,60 +285,60 @@ async def set_softener_type(self, softener_type: ZeoSoftenerType) -> dict[Roboro
                 RoborockZeoProtocol.SOFTENER_SET: 0 if e == 0 else 1,
                 RoborockZeoProtocol.SOFTENER_TYPE: e,
             }
-        return await self._send(dps)
+        await self._send(dps)
 
-    async def set_detergent_box_type(self, expansion_type: ZeoDetergentExpansionType) -> dict[RoborockZeoProtocol, Any]:
+    async def set_detergent_box_type(self, expansion_type: ZeoDetergentExpansionType) -> None:
         """Set the detergent expansion type (DP 248)."""
         dps = {RoborockZeoProtocol.DETERGENT_EXPANSION_TYPE: int(expansion_type)}
-        return await self._send(dps)
+        await self._send(dps)
 
-    async def set_softener_box_type(self, expansion_type: ZeoSoftenerExpansionType) -> dict[RoborockZeoProtocol, Any]:
+    async def set_softener_box_type(self, expansion_type: ZeoSoftenerExpansionType) -> None:
         """Set the softener expansion type (DP 245)."""
         dps = {RoborockZeoProtocol.SOFTENER_EXPANSION_TYPE: int(expansion_type)}
-        return await self._send(dps)
+        await self._send(dps)
 
     async def set_cleanser_config(
         self,
         auto_detergent: bool,
         auto_softener: bool,
         detergent_type: ZeoDetergentType,
         softener_type: ZeoSoftenerType,
-    ) -> dict[RoborockZeoProtocol, Any]:
+    ) -> None:
         """Set the full cleanser config in one command (DP 211/212/213/214)."""
         dps: dict[RoborockZeoProtocol, Any] = {
             RoborockZeoProtocol.DETERGENT_SET: 1 if auto_detergent else 0,
             RoborockZeoProtocol.SOFTENER_SET: 1 if auto_softener else 0,
             RoborockZeoProtocol.DETERGENT_TYPE: int(detergent_type),
             RoborockZeoProtocol.SOFTENER_TYPE: int(softener_type),
         }
-        return await self._send(dps)
+        await self._send(dps)
 
-    async def set_voice_volume(self, volume: int) -> dict[RoborockZeoProtocol, Any]:
+    async def set_voice_volume(self, volume: int) -> None:
         """Set the voice volume (DP 10009)."""
         dps = {RoborockZeoProtocol.VOICE_VOLUME: json.dumps({"snd_volume": volume})}
-        return await self._send(dps)
+        await self._send(dps)
 
-    async def set_voice_switch(self, enabled: bool) -> dict[RoborockZeoProtocol, Any]:
+    async def set_voice_switch(self, enabled: bool) -> None:
         """Enable/disable voice assistant (DP 10301)."""
         dps = {RoborockZeoProtocol.VOICE_SWITCH: json.dumps({"speech_switch": 1 if enabled else 0})}
-        return await self._send(dps)
+        await self._send(dps)
 
-    async def delete_voice_record(self, record_id: str) -> dict[RoborockZeoProtocol, Any]:
+    async def delete_voice_record(self, record_id: str) -> None:
         """Delete a voice record by id (DP 10304)."""
         dps = {RoborockZeoProtocol.VOICE_RECORD_DELETE: json.dumps({"dialog_delete": record_id})}
-        return await self._send(dps)
+        await self._send(dps)
 
-    async def set_sound_package(self, package: dict[str, Any]) -> dict[RoborockZeoProtocol, Any]:
+    async def set_sound_package(self, package: dict[str, Any]) -> None:
         """Set the sound package (DP 10003)."""
         dps = {RoborockZeoProtocol.SET_SOUND_PACKAGE: json.dumps(package)}
-        return await self._send(dps)
+        await self._send(dps)
 
     async def set_silent_mode(
         self,
         enabled: bool,
         start_time: datetime.time,
         end_time: datetime.time,
-    ) -> dict[RoborockZeoProtocol, Any]:
+    ) -> None:
         """Enable or disable silent mode with the given quiet hours.
 
         The three DPs (240/241/242) must be sent together.
@@ -354,7 +354,7 @@ async def set_silent_mode(
             RoborockZeoProtocol.SILENT_MODE_START_TIME: start_time.hour * 60 + start_time.minute,
             RoborockZeoProtocol.SILENT_MODE_END_TIME: end_time.hour * 60 + end_time.minute,
         }
-        return await self._send(dps)
+        await self._send(dps)
 
     # -- Plain boolean switch setters ---------------------------------------
     #
@@ -364,110 +364,110 @@ async def set_silent_mode(
     # corresponding feature bit (or series whitelist); gated setters raise
     # :class:`ValueError` when the device does not support the feature.
 
-    async def _set_bool(self, dp: RoborockZeoProtocol, enabled: bool) -> dict[RoborockZeoProtocol, Any]:
+    async def _set_bool(self, dp: RoborockZeoProtocol, enabled: bool) -> None:
         """Send a boolean DP as its integer ``1``/``0`` (confirmed wire format)."""
-        return await self._send({dp: 1 if enabled else 0})
+        await self._send({dp: 1 if enabled else 0})
 
-    async def set_child_lock(self, enabled: bool) -> dict[RoborockZeoProtocol, Any]:
+    async def set_child_lock(self, enabled: bool) -> None:
         """Enable/disable the child lock (DP 206)."""
-        return await self._set_bool(RoborockZeoProtocol.CHILD_LOCK, enabled)
+        await self._set_bool(RoborockZeoProtocol.CHILD_LOCK, enabled)
 
-    async def set_sound(self, enabled: bool) -> dict[RoborockZeoProtocol, Any]:
+    async def set_sound(self, enabled: bool) -> None:
         """Enable/disable the audible beeper (DP 223)."""
-        return await self._set_bool(RoborockZeoProtocol.SOUND_SET, enabled)
+        await self._set_bool(RoborockZeoProtocol.SOUND_SET, enabled)
 
-    async def set_dirt_detection(self, enabled: bool) -> dict[RoborockZeoProtocol, Any]:
+    async def set_dirt_detection(self, enabled: bool) -> None:
         """Enable/disable dirt detection (DP 215).
 
         Requires the ``dirt_detection`` feature bit.
         """
         features = self._features()
         if features is not None and not features.dirt_detection:
             raise ValueError("This device does not support dirt detection")
-        return await self._set_bool(RoborockZeoProtocol.DIRT_DETECTION_SWITCH, enabled)
+        await self._set_bool(RoborockZeoProtocol.DIRT_DETECTION_SWITCH, enabled)
 
-    async def set_default_setting(self, enabled: bool) -> dict[RoborockZeoProtocol, Any]:
+    async def set_default_setting(self, enabled: bool) -> None:
         """Set the default setting (DP 225)."""
-        return await self._set_bool(RoborockZeoProtocol.DEFAULT_SETTING, enabled)
+        await self._set_bool(RoborockZeoProtocol.DEFAULT_SETTING, enabled)
 
-    async def set_uv_light(self, enabled: bool) -> dict[RoborockZeoProtocol, Any]:
+    async def set_uv_light(self, enabled: bool) -> None:
         """Enable/disable the UV light (DP 228).
 
         Requires UV-light support for the device series.
         """
         if not supports_uv_light(self._model):
             raise ValueError("This device does not support UV light")
-        return await self._set_bool(RoborockZeoProtocol.UV_LIGHT, enabled)
+        await self._set_bool(RoborockZeoProtocol.UV_LIGHT, enabled)
 
-    async def set_smart_hosting(self, enabled: bool) -> dict[RoborockZeoProtocol, Any]:
+    async def set_smart_hosting(self, enabled: bool) -> None:
         """Enable/disable smart hosting (DP 235).
 
         Requires the ``smart_hosting`` feature bit.
         """
         features = self._features()
         if features is not None and not features.smart_hosting:
             raise ValueError("This device does not support smart hosting")
-        return await self._set_bool(RoborockZeoProtocol.SMART_HOSTING, enabled)
+        await self._set_bool(RoborockZeoProtocol.SMART_HOSTING, enabled)
 
-    async def set_smile_light(self, enabled: bool) -> dict[RoborockZeoProtocol, Any]:
+    async def set_smile_light(self, enabled: bool) -> None:
         """Enable/disable the smile light (DP 247).
 
         Requires the ``smile_light`` feature bit.
         """
         features = self._features()
         if features is not None and not features.smile_light:
             raise ValueError("This device does not support smile light")
-        return await self._set_bool(RoborockZeoProtocol.SMILE_LIGHT_STATUS, enabled)
+        await self._set_bool(RoborockZeoProtocol.SMILE_LIGHT_STATUS, enabled)
 
-    async def set_fluff_cleaned(self, enabled: bool) -> dict[RoborockZeoProtocol, Any]:
+    async def set_fluff_cleaned(self, enabled: bool) -> None:
         """Mark the fluff filter as cleaned (DP 249).
 
         Requires the ``fluff_clean_notification`` feature bit.
         """
         features = self._features()
         if features is not None and not features.fluff_clean_notification:
             raise ValueError("This device does not support fluff cleaning")
-        return await self._set_bool(RoborockZeoProtocol.FLUFF_CLEANED, enabled)
+        await self._set_bool(RoborockZeoProtocol.FLUFF_CLEANED, enabled)
 
-    async def set_power_light(self, enabled: bool) -> dict[RoborockZeoProtocol, Any]:
+    async def set_power_light(self, enabled: bool) -> None:
         """Enable/disable the power-button indicator light (DP 251).
 
         Requires the ``power_button_indicator_light`` feature bit.
         """
         features = self._features()
         if features is not None and not features.power_button_indicator_light:
             raise ValueError("This device does not support the power indicator light")
-        return await self._set_bool(RoborockZeoProtocol.POWER_LIGHT, enabled)
+        await self._set_bool(RoborockZeoProtocol.POWER_LIGHT, enabled)
 
-    async def set_ion_deodorization(self, enabled: bool) -> dict[RoborockZeoProtocol, Any]:
+    async def set_ion_deodorization(self, enabled: bool) -> None:
         """Enable/disable ion deodorization (DP 258). Test-only: carried by START.
 
         Requires the ``ion_deodorization`` feature bit.
         """
         features = self._features()
         if features is not None and not features.ion_deodorization:
             raise ValueError("This device does not support ion deodorization")
-        return await self._set_bool(RoborockZeoProtocol.ION_DEODORIZATION, enabled)
+        await self._set_bool(RoborockZeoProtocol.ION_DEODORIZATION, enabled)
 
-    async def set_wash_dry_linked(self, enabled: bool) -> dict[RoborockZeoProtocol, Any]:
+    async def set_wash_dry_linked(self, enabled: bool) -> None:
         """Enable/disable the wash-dry linkage (DP 255). Test-only: carried by START.
 
         Requires the ``wash_dry_linkage`` feature bit.
         """
         features = self._features()
         if features is not None and not features.wash_dry_linkage:
             raise ValueError("This device does not support wash-dry linkage")
-        return await self._set_bool(RoborockZeoProtocol.WASH_DRY_LINKED, enabled)
+        await self._set_bool(RoborockZeoProtocol.WASH_DRY_LINKED, enabled)
 
     async def _send(
         self,
         dps: dict[RoborockZeoProtocol, Any],
         qos: MqttQos = MqttQos.AT_MOST_ONCE,
-    ) -> dict[RoborockZeoProtocol, Any]:
+    ) -> None:
         """Send already wire-formatted DPs over the device channel."""
-        return await send_decoded_command(self._channel, dps, value_encoder=lambda x: x, qos=qos)
+        await send_decoded_command(self._channel, dps, value_encoder=lambda x: x, qos=qos)
 
-    async def save_cloud_program(self, params: ZeoStartParams) -> dict[RoborockZeoProtocol, Any]:
+    async def save_cloud_program(self, params: ZeoStartParams) -> None:
         """Save the current programme parameters as a cloud custom program.
 
         Sends Mode/Program (and the optional Soak/Temperature/Rinse/Spin/
@@ -482,24 +482,24 @@ async def save_cloud_program(self, params: ZeoStartParams) -> dict[RoborockZeoPr
             dps[RoborockZeoProtocol.SAVE_ADAPTED_CLOUD_PROGRAM] = 1
         else:
             dps[RoborockZeoProtocol.CUSTOM_PARAM_SAVE] = 1
-        return await self._send(dps, MqttQos.AT_LEAST_ONCE)
+        await self._send(dps, MqttQos.AT_LEAST_ONCE)
 
-    async def save_panel_program(self, params: ZeoStartParams) -> dict[RoborockZeoProtocol, Any]:
+    async def save_panel_program(self, params: ZeoStartParams) -> None:
         """Save the current programme parameters as a panel program (DP 252).
 
         Same parameter set as :meth:`save_cloud_program`, but the trigger
         signal is ``PanelProgramParamsSet``(252) instead.
         """
         dps = build_param_dps(params)
         dps[RoborockZeoProtocol.PANEL_PROGRAM_PARAMS_SET] = 1
-        return await self._send(dps, MqttQos.AT_LEAST_ONCE)
+        await self._send(dps, MqttQos.AT_LEAST_ONCE)
 
-    async def load_cloud_program(self) -> dict[RoborockZeoProtocol, Any]:
+    async def load_cloud_program(self) -> None:
         """Apply the currently saved cloud custom program (DP 222 = 1).
 
         This only sends the trigger signal ``CUSTOM_PARAM_GET``(222) with an
         integer ``1``. The device responds by pushing the current program's
         32-bit bitfield back on DP 222 (see ``ZeoCustomMode.from_raw``).
         """
         dps: dict[RoborockZeoProtocol, Any] = {RoborockZeoProtocol.CUSTOM_PARAM_GET: 1}
-        return await self._send(dps, MqttQos.AT_LEAST_ONCE)
+        await self._send(dps, MqttQos.AT_LEAST_ONCE)