diff --git a/homeassistant/components/google_assistant/trait.py b/homeassistant/components/google_assistant/trait.py
index 95faf7c3321..9d3e1054a88 100644
--- a/homeassistant/components/google_assistant/trait.py
+++ b/homeassistant/components/google_assistant/trait.py
@@ -109,61 +109,42 @@ from .error import ChallengeNeeded, SmartHomeError
 _LOGGER = logging.getLogger(__name__)
 
 PREFIX_TRAITS = "action.devices.traits."
-TRAIT_CAMERA_STREAM = f"{PREFIX_TRAITS}CameraStream"
-TRAIT_ONOFF = f"{PREFIX_TRAITS}OnOff"
-TRAIT_DOCK = f"{PREFIX_TRAITS}Dock"
-TRAIT_STARTSTOP = f"{PREFIX_TRAITS}StartStop"
+TRAIT_ARM_DISARM = f"{PREFIX_TRAITS}ArmDisarm"
 TRAIT_BRIGHTNESS = f"{PREFIX_TRAITS}Brightness"
-TRAIT_COLOR_SETTING = f"{PREFIX_TRAITS}ColorSetting"
-TRAIT_SCENE = f"{PREFIX_TRAITS}Scene"
-TRAIT_TEMPERATURE_SETTING = f"{PREFIX_TRAITS}TemperatureSetting"
-TRAIT_TEMPERATURE_CONTROL = f"{PREFIX_TRAITS}TemperatureControl"
-TRAIT_LOCKUNLOCK = f"{PREFIX_TRAITS}LockUnlock"
-TRAIT_FANSPEED = f"{PREFIX_TRAITS}FanSpeed"
-TRAIT_MODES = f"{PREFIX_TRAITS}Modes"
-TRAIT_INPUTSELECTOR = f"{PREFIX_TRAITS}InputSelector"
-TRAIT_OBJECTDETECTION = f"{PREFIX_TRAITS}ObjectDetection"
-TRAIT_OPENCLOSE = f"{PREFIX_TRAITS}OpenClose"
-TRAIT_VOLUME = f"{PREFIX_TRAITS}Volume"
-TRAIT_ARMDISARM = f"{PREFIX_TRAITS}ArmDisarm"
-TRAIT_HUMIDITY_SETTING = f"{PREFIX_TRAITS}HumiditySetting"
-TRAIT_TRANSPORT_CONTROL = f"{PREFIX_TRAITS}TransportControl"
-TRAIT_MEDIA_STATE = f"{PREFIX_TRAITS}MediaState"
+TRAIT_CAMERA_STREAM = f"{PREFIX_TRAITS}CameraStream"
 TRAIT_CHANNEL = f"{PREFIX_TRAITS}Channel"
+TRAIT_COLOR_SETTING = f"{PREFIX_TRAITS}ColorSetting"
+TRAIT_DOCK = f"{PREFIX_TRAITS}Dock"
+TRAIT_ENERGY_STORAGE = f"{PREFIX_TRAITS}EnergyStorage"
+TRAIT_FAN_SPEED = f"{PREFIX_TRAITS}FanSpeed"
+TRAIT_HUMIDITY_SETTING = f"{PREFIX_TRAITS}HumiditySetting"
+TRAIT_INPUT_SELECTOR = f"{PREFIX_TRAITS}InputSelector"
 TRAIT_LOCATOR = f"{PREFIX_TRAITS}Locator"
-TRAIT_ENERGYSTORAGE = f"{PREFIX_TRAITS}EnergyStorage"
+TRAIT_LOCK_UNLOCK = f"{PREFIX_TRAITS}LockUnlock"
+TRAIT_MEDIA_STATE = f"{PREFIX_TRAITS}MediaState"
+TRAIT_MODES = f"{PREFIX_TRAITS}Modes"
+TRAIT_OBJECT_DETECTION = f"{PREFIX_TRAITS}ObjectDetection"
+TRAIT_ON_OFF = f"{PREFIX_TRAITS}OnOff"
+TRAIT_OPEN_CLOSE = f"{PREFIX_TRAITS}OpenClose"
+TRAIT_SCENE = f"{PREFIX_TRAITS}Scene"
 TRAIT_SENSOR_STATE = f"{PREFIX_TRAITS}SensorState"
+TRAIT_START_STOP = f"{PREFIX_TRAITS}StartStop"
+TRAIT_TEMPERATURE_CONTROL = f"{PREFIX_TRAITS}TemperatureControl"
+TRAIT_TEMPERATURE_SETTING = f"{PREFIX_TRAITS}TemperatureSetting"
+TRAIT_TRANSPORT_CONTROL = f"{PREFIX_TRAITS}TransportControl"
+TRAIT_VOLUME = f"{PREFIX_TRAITS}Volume"
 
 PREFIX_COMMANDS = "action.devices.commands."
-COMMAND_ONOFF = f"{PREFIX_COMMANDS}OnOff"
-COMMAND_GET_CAMERA_STREAM = f"{PREFIX_COMMANDS}GetCameraStream"
-COMMAND_DOCK = f"{PREFIX_COMMANDS}Dock"
-COMMAND_STARTSTOP = f"{PREFIX_COMMANDS}StartStop"
-COMMAND_PAUSEUNPAUSE = f"{PREFIX_COMMANDS}PauseUnpause"
-COMMAND_BRIGHTNESS_ABSOLUTE = f"{PREFIX_COMMANDS}BrightnessAbsolute"
-COMMAND_COLOR_ABSOLUTE = f"{PREFIX_COMMANDS}ColorAbsolute"
 COMMAND_ACTIVATE_SCENE = f"{PREFIX_COMMANDS}ActivateScene"
-COMMAND_SET_TEMPERATURE = f"{PREFIX_COMMANDS}SetTemperature"
-COMMAND_THERMOSTAT_TEMPERATURE_SETPOINT = (
-    f"{PREFIX_COMMANDS}ThermostatTemperatureSetpoint"
-)
-COMMAND_THERMOSTAT_TEMPERATURE_SET_RANGE = (
-    f"{PREFIX_COMMANDS}ThermostatTemperatureSetRange"
-)
-COMMAND_THERMOSTAT_SET_MODE = f"{PREFIX_COMMANDS}ThermostatSetMode"
-COMMAND_LOCKUNLOCK = f"{PREFIX_COMMANDS}LockUnlock"
-COMMAND_FANSPEED = f"{PREFIX_COMMANDS}SetFanSpeed"
-COMMAND_FANSPEEDRELATIVE = f"{PREFIX_COMMANDS}SetFanSpeedRelative"
-COMMAND_MODES = f"{PREFIX_COMMANDS}SetModes"
-COMMAND_INPUT = f"{PREFIX_COMMANDS}SetInput"
+COMMAND_ARM_DISARM = f"{PREFIX_COMMANDS}ArmDisarm"
+COMMAND_BRIGHTNESS_ABSOLUTE = f"{PREFIX_COMMANDS}BrightnessAbsolute"
+COMMAND_CHARGE = f"{PREFIX_COMMANDS}Charge"
+COMMAND_COLOR_ABSOLUTE = f"{PREFIX_COMMANDS}ColorAbsolute"
+COMMAND_DOCK = f"{PREFIX_COMMANDS}Dock"
+COMMAND_GET_CAMERA_STREAM = f"{PREFIX_COMMANDS}GetCameraStream"
+COMMAND_LOCK_UNLOCK = f"{PREFIX_COMMANDS}LockUnlock"
+COMMAND_LOCATE = f"{PREFIX_COMMANDS}Locate"
 COMMAND_NEXT_INPUT = f"{PREFIX_COMMANDS}NextInput"
-COMMAND_PREVIOUS_INPUT = f"{PREFIX_COMMANDS}PreviousInput"
-COMMAND_OPENCLOSE = f"{PREFIX_COMMANDS}OpenClose"
-COMMAND_OPENCLOSE_RELATIVE = f"{PREFIX_COMMANDS}OpenCloseRelative"
-COMMAND_SET_VOLUME = f"{PREFIX_COMMANDS}setVolume"
-COMMAND_VOLUME_RELATIVE = f"{PREFIX_COMMANDS}volumeRelative"
-COMMAND_MUTE = f"{PREFIX_COMMANDS}mute"
-COMMAND_ARMDISARM = f"{PREFIX_COMMANDS}ArmDisarm"
 COMMAND_MEDIA_NEXT = f"{PREFIX_COMMANDS}mediaNext"
 COMMAND_MEDIA_PAUSE = f"{PREFIX_COMMANDS}mediaPause"
 COMMAND_MEDIA_PREVIOUS = f"{PREFIX_COMMANDS}mediaPrevious"
@@ -172,11 +153,30 @@ COMMAND_MEDIA_SEEK_RELATIVE = f"{PREFIX_COMMANDS}mediaSeekRelative"
 COMMAND_MEDIA_SEEK_TO_POSITION = f"{PREFIX_COMMANDS}mediaSeekToPosition"
 COMMAND_MEDIA_SHUFFLE = f"{PREFIX_COMMANDS}mediaShuffle"
 COMMAND_MEDIA_STOP = f"{PREFIX_COMMANDS}mediaStop"
+COMMAND_MUTE = f"{PREFIX_COMMANDS}mute"
+COMMAND_OPEN_CLOSE = f"{PREFIX_COMMANDS}OpenClose"
+COMMAND_ON_OFF = f"{PREFIX_COMMANDS}OnOff"
+COMMAND_OPEN_CLOSE_RELATIVE = f"{PREFIX_COMMANDS}OpenCloseRelative"
+COMMAND_PAUSE_UNPAUSE = f"{PREFIX_COMMANDS}PauseUnpause"
 COMMAND_REVERSE = f"{PREFIX_COMMANDS}Reverse"
-COMMAND_SET_HUMIDITY = f"{PREFIX_COMMANDS}SetHumidity"
+COMMAND_PREVIOUS_INPUT = f"{PREFIX_COMMANDS}PreviousInput"
 COMMAND_SELECT_CHANNEL = f"{PREFIX_COMMANDS}selectChannel"
-COMMAND_LOCATE = f"{PREFIX_COMMANDS}Locate"
-COMMAND_CHARGE = f"{PREFIX_COMMANDS}Charge"
+COMMAND_SET_TEMPERATURE = f"{PREFIX_COMMANDS}SetTemperature"
+COMMAND_SET_FAN_SPEED = f"{PREFIX_COMMANDS}SetFanSpeed"
+COMMAND_SET_FAN_SPEED_RELATIVE = f"{PREFIX_COMMANDS}SetFanSpeedRelative"
+COMMAND_SET_HUMIDITY = f"{PREFIX_COMMANDS}SetHumidity"
+COMMAND_SET_INPUT = f"{PREFIX_COMMANDS}SetInput"
+COMMAND_SET_MODES = f"{PREFIX_COMMANDS}SetModes"
+COMMAND_SET_VOLUME = f"{PREFIX_COMMANDS}setVolume"
+COMMAND_START_STOP = f"{PREFIX_COMMANDS}StartStop"
+COMMAND_THERMOSTAT_SET_MODE = f"{PREFIX_COMMANDS}ThermostatSetMode"
+COMMAND_THERMOSTAT_TEMPERATURE_SETPOINT = (
+    f"{PREFIX_COMMANDS}ThermostatTemperatureSetpoint"
+)
+COMMAND_THERMOSTAT_TEMPERATURE_SET_RANGE = (
+    f"{PREFIX_COMMANDS}ThermostatTemperatureSetRange"
+)
+COMMAND_VOLUME_RELATIVE = f"{PREFIX_COMMANDS}volumeRelative"
 
 TRAITS: list[type[_Trait]] = []
 
@@ -415,7 +415,7 @@ class ObjectDetection(_Trait):
     https://developers.google.com/actions/smarthome/traits/objectdetection
     """
 
-    name = TRAIT_OBJECTDETECTION
+    name = TRAIT_OBJECT_DETECTION
     commands = []
 
     @staticmethod
@@ -473,8 +473,8 @@ class OnOffTrait(_Trait):
     https://developers.google.com/actions/smarthome/traits/onoff
     """
 
-    name = TRAIT_ONOFF
-    commands = [COMMAND_ONOFF]
+    name = TRAIT_ON_OFF
+    commands = [COMMAND_ON_OFF]
 
     @staticmethod
     def supported(domain, features, device_class, _):
@@ -793,7 +793,7 @@ class EnergyStorageTrait(_Trait):
     https://developers.google.com/actions/smarthome/traits/energystorage
     """
 
-    name = TRAIT_ENERGYSTORAGE
+    name = TRAIT_ENERGY_STORAGE
     commands = [COMMAND_CHARGE]
 
     @staticmethod
@@ -848,8 +848,8 @@ class StartStopTrait(_Trait):
     https://developers.google.com/actions/smarthome/traits/startstop
     """
 
-    name = TRAIT_STARTSTOP
-    commands = [COMMAND_STARTSTOP, COMMAND_PAUSEUNPAUSE]
+    name = TRAIT_START_STOP
+    commands = [COMMAND_START_STOP, COMMAND_PAUSE_UNPAUSE]
 
     @staticmethod
     def supported(domain, features, device_class, _):
@@ -913,7 +913,7 @@ class StartStopTrait(_Trait):
 
     async def _execute_vacuum(self, command, data, params, challenge):
         """Execute a StartStop command."""
-        if command == COMMAND_STARTSTOP:
+        if command == COMMAND_START_STOP:
             if params["start"]:
                 await self.hass.services.async_call(
                     self.state.domain,
@@ -930,7 +930,7 @@ class StartStopTrait(_Trait):
                     blocking=not self.config.should_report_state,
                     context=data.context,
                 )
-        elif command == COMMAND_PAUSEUNPAUSE:
+        elif command == COMMAND_PAUSE_UNPAUSE:
             if params["pause"]:
                 await self.hass.services.async_call(
                     self.state.domain,
@@ -951,7 +951,7 @@ class StartStopTrait(_Trait):
     async def _execute_cover_or_valve(self, command, data, params, challenge):
         """Execute a StartStop command."""
         domain = self.state.domain
-        if command == COMMAND_STARTSTOP:
+        if command == COMMAND_START_STOP:
             if params["start"] is False:
                 if self.state.state in (
                     COVER_VALVE_STATES[domain]["closing"],
@@ -1504,8 +1504,8 @@ class LockUnlockTrait(_Trait):
     https://developers.google.com/actions/smarthome/traits/lockunlock
     """
 
-    name = TRAIT_LOCKUNLOCK
-    commands = [COMMAND_LOCKUNLOCK]
+    name = TRAIT_LOCK_UNLOCK
+    commands = [COMMAND_LOCK_UNLOCK]
 
     @staticmethod
     def supported(domain, features, device_class, _):
@@ -1553,8 +1553,8 @@ class ArmDisArmTrait(_Trait):
     https://developers.google.com/actions/smarthome/traits/armdisarm
     """
 
-    name = TRAIT_ARMDISARM
-    commands = [COMMAND_ARMDISARM]
+    name = TRAIT_ARM_DISARM
+    commands = [COMMAND_ARM_DISARM]
 
     state_to_service = {
         STATE_ALARM_ARMED_HOME: SERVICE_ALARM_ARM_HOME,
@@ -1694,8 +1694,8 @@ class FanSpeedTrait(_Trait):
     https://developers.google.com/actions/smarthome/traits/fanspeed
     """
 
-    name = TRAIT_FANSPEED
-    commands = [COMMAND_FANSPEED, COMMAND_REVERSE]
+    name = TRAIT_FAN_SPEED
+    commands = [COMMAND_SET_FAN_SPEED, COMMAND_REVERSE]
 
     def __init__(self, hass, state, config):
         """Initialize a trait for a state."""
@@ -1840,7 +1840,7 @@ class FanSpeedTrait(_Trait):
 
     async def execute(self, command, data, params, challenge):
         """Execute a smart home command."""
-        if command == COMMAND_FANSPEED:
+        if command == COMMAND_SET_FAN_SPEED:
             await self.execute_fanspeed(data, params)
         elif command == COMMAND_REVERSE:
             await self.execute_reverse(data, params)
@@ -1854,7 +1854,7 @@ class ModesTrait(_Trait):
     """
 
     name = TRAIT_MODES
-    commands = [COMMAND_MODES]
+    commands = [COMMAND_SET_MODES]
 
     SYNONYMS = {
         "preset mode": ["preset mode", "mode", "preset"],
@@ -2088,8 +2088,8 @@ class InputSelectorTrait(_Trait):
     https://developers.google.com/assistant/smarthome/traits/inputselector
     """
 
-    name = TRAIT_INPUTSELECTOR
-    commands = [COMMAND_INPUT, COMMAND_NEXT_INPUT, COMMAND_PREVIOUS_INPUT]
+    name = TRAIT_INPUT_SELECTOR
+    commands = [COMMAND_SET_INPUT, COMMAND_NEXT_INPUT, COMMAND_PREVIOUS_INPUT]
 
     SYNONYMS: dict[str, list[str]] = {}
 
@@ -2124,7 +2124,7 @@ class InputSelectorTrait(_Trait):
         sources = self.state.attributes.get(media_player.ATTR_INPUT_SOURCE_LIST) or []
         source = self.state.attributes.get(media_player.ATTR_INPUT_SOURCE)
 
-        if command == COMMAND_INPUT:
+        if command == COMMAND_SET_INPUT:
             requested_source = params.get("newInput")
         elif command == COMMAND_NEXT_INPUT:
             requested_source = _next_selected(sources, source)
@@ -2162,8 +2162,8 @@ class OpenCloseTrait(_Trait):
         cover.CoverDeviceClass.GATE,
     )
 
-    name = TRAIT_OPENCLOSE
-    commands = [COMMAND_OPENCLOSE, COMMAND_OPENCLOSE_RELATIVE]
+    name = TRAIT_OPEN_CLOSE
+    commands = [COMMAND_OPEN_CLOSE, COMMAND_OPEN_CLOSE_RELATIVE]
 
     @staticmethod
     def supported(domain, features, device_class, _):
@@ -2263,7 +2263,7 @@ class OpenCloseTrait(_Trait):
         if domain in COVER_VALVE_DOMAINS:
             svc_params = {ATTR_ENTITY_ID: self.state.entity_id}
             should_verify = False
-            if command == COMMAND_OPENCLOSE_RELATIVE:
+            if command == COMMAND_OPEN_CLOSE_RELATIVE:
                 position = self.state.attributes.get(
                     COVER_VALVE_CURRENT_POSITION[domain]
                 )
diff --git a/tests/components/google_assistant/test_smart_home.py b/tests/components/google_assistant/test_smart_home.py
index 214fc4a38de..cb1169c888c 100644
--- a/tests/components/google_assistant/test_smart_home.py
+++ b/tests/components/google_assistant/test_smart_home.py
@@ -209,7 +209,7 @@ async def test_sync_message(hass: HomeAssistant, registries) -> None:
                     },
                     "traits": [
                         trait.TRAIT_BRIGHTNESS,
-                        trait.TRAIT_ONOFF,
+                        trait.TRAIT_ON_OFF,
                         trait.TRAIT_COLOR_SETTING,
                         trait.TRAIT_MODES,
                     ],
@@ -329,7 +329,7 @@ async def test_sync_in_area(area_on_device, hass: HomeAssistant, registries) ->
                     "name": {"name": "Demo Light"},
                     "traits": [
                         trait.TRAIT_BRIGHTNESS,
-                        trait.TRAIT_ONOFF,
+                        trait.TRAIT_ON_OFF,
                         trait.TRAIT_COLOR_SETTING,
                         trait.TRAIT_MODES,
                     ],
@@ -926,7 +926,7 @@ async def test_unavailable_state_does_sync(hass: HomeAssistant) -> None:
                     "name": {"name": "Demo Light"},
                     "traits": [
                         trait.TRAIT_BRIGHTNESS,
-                        trait.TRAIT_ONOFF,
+                        trait.TRAIT_ON_OFF,
                         trait.TRAIT_COLOR_SETTING,
                         trait.TRAIT_MODES,
                     ],
diff --git a/tests/components/google_assistant/test_trait.py b/tests/components/google_assistant/test_trait.py
index 77a9027e76d..d9378892fb2 100644
--- a/tests/components/google_assistant/test_trait.py
+++ b/tests/components/google_assistant/test_trait.py
@@ -187,12 +187,12 @@ async def test_onoff_group(hass: HomeAssistant) -> None:
     assert trt_off.query_attributes() == {"on": False}
 
     on_calls = async_mock_service(hass, HOMEASSISTANT_DOMAIN, SERVICE_TURN_ON)
-    await trt_on.execute(trait.COMMAND_ONOFF, BASIC_DATA, {"on": True}, {})
+    await trt_on.execute(trait.COMMAND_ON_OFF, BASIC_DATA, {"on": True}, {})
     assert len(on_calls) == 1
     assert on_calls[0].data == {ATTR_ENTITY_ID: "group.bla"}
 
     off_calls = async_mock_service(hass, HOMEASSISTANT_DOMAIN, SERVICE_TURN_OFF)
-    await trt_on.execute(trait.COMMAND_ONOFF, BASIC_DATA, {"on": False}, {})
+    await trt_on.execute(trait.COMMAND_ON_OFF, BASIC_DATA, {"on": False}, {})
     assert len(off_calls) == 1
     assert off_calls[0].data == {ATTR_ENTITY_ID: "group.bla"}
 
@@ -215,12 +215,12 @@ async def test_onoff_input_boolean(hass: HomeAssistant) -> None:
     assert trt_off.query_attributes() == {"on": False}
 
     on_calls = async_mock_service(hass, input_boolean.DOMAIN, SERVICE_TURN_ON)
-    await trt_on.execute(trait.COMMAND_ONOFF, BASIC_DATA, {"on": True}, {})
+    await trt_on.execute(trait.COMMAND_ON_OFF, BASIC_DATA, {"on": True}, {})
     assert len(on_calls) == 1
     assert on_calls[0].data == {ATTR_ENTITY_ID: "input_boolean.bla"}
 
     off_calls = async_mock_service(hass, input_boolean.DOMAIN, SERVICE_TURN_OFF)
-    await trt_on.execute(trait.COMMAND_ONOFF, BASIC_DATA, {"on": False}, {})
+    await trt_on.execute(trait.COMMAND_ON_OFF, BASIC_DATA, {"on": False}, {})
     assert len(off_calls) == 1
     assert off_calls[0].data == {ATTR_ENTITY_ID: "input_boolean.bla"}
 
@@ -282,12 +282,12 @@ async def test_onoff_switch(hass: HomeAssistant) -> None:
     assert trt_assumed.sync_attributes() == {"commandOnlyOnOff": True}
 
     on_calls = async_mock_service(hass, switch.DOMAIN, SERVICE_TURN_ON)
-    await trt_on.execute(trait.COMMAND_ONOFF, BASIC_DATA, {"on": True}, {})
+    await trt_on.execute(trait.COMMAND_ON_OFF, BASIC_DATA, {"on": True}, {})
     assert len(on_calls) == 1
     assert on_calls[0].data == {ATTR_ENTITY_ID: "switch.bla"}
 
     off_calls = async_mock_service(hass, switch.DOMAIN, SERVICE_TURN_OFF)
-    await trt_on.execute(trait.COMMAND_ONOFF, BASIC_DATA, {"on": False}, {})
+    await trt_on.execute(trait.COMMAND_ON_OFF, BASIC_DATA, {"on": False}, {})
     assert len(off_calls) == 1
     assert off_calls[0].data == {ATTR_ENTITY_ID: "switch.bla"}
 
@@ -307,12 +307,12 @@ async def test_onoff_fan(hass: HomeAssistant) -> None:
     assert trt_off.query_attributes() == {"on": False}
 
     on_calls = async_mock_service(hass, fan.DOMAIN, SERVICE_TURN_ON)
-    await trt_on.execute(trait.COMMAND_ONOFF, BASIC_DATA, {"on": True}, {})
+    await trt_on.execute(trait.COMMAND_ON_OFF, BASIC_DATA, {"on": True}, {})
     assert len(on_calls) == 1
     assert on_calls[0].data == {ATTR_ENTITY_ID: "fan.bla"}
 
     off_calls = async_mock_service(hass, fan.DOMAIN, SERVICE_TURN_OFF)
-    await trt_on.execute(trait.COMMAND_ONOFF, BASIC_DATA, {"on": False}, {})
+    await trt_on.execute(trait.COMMAND_ON_OFF, BASIC_DATA, {"on": False}, {})
     assert len(off_calls) == 1
     assert off_calls[0].data == {ATTR_ENTITY_ID: "fan.bla"}
 
@@ -333,12 +333,12 @@ async def test_onoff_light(hass: HomeAssistant) -> None:
     assert trt_off.query_attributes() == {"on": False}
 
     on_calls = async_mock_service(hass, light.DOMAIN, SERVICE_TURN_ON)
-    await trt_on.execute(trait.COMMAND_ONOFF, BASIC_DATA, {"on": True}, {})
+    await trt_on.execute(trait.COMMAND_ON_OFF, BASIC_DATA, {"on": True}, {})
     assert len(on_calls) == 1
     assert on_calls[0].data == {ATTR_ENTITY_ID: "light.bla"}
 
     off_calls = async_mock_service(hass, light.DOMAIN, SERVICE_TURN_OFF)
-    await trt_on.execute(trait.COMMAND_ONOFF, BASIC_DATA, {"on": False}, {})
+    await trt_on.execute(trait.COMMAND_ON_OFF, BASIC_DATA, {"on": False}, {})
     assert len(off_calls) == 1
     assert off_calls[0].data == {ATTR_ENTITY_ID: "light.bla"}
 
@@ -359,13 +359,13 @@ async def test_onoff_media_player(hass: HomeAssistant) -> None:
     assert trt_off.query_attributes() == {"on": False}
 
     on_calls = async_mock_service(hass, media_player.DOMAIN, SERVICE_TURN_ON)
-    await trt_on.execute(trait.COMMAND_ONOFF, BASIC_DATA, {"on": True}, {})
+    await trt_on.execute(trait.COMMAND_ON_OFF, BASIC_DATA, {"on": True}, {})
     assert len(on_calls) == 1
     assert on_calls[0].data == {ATTR_ENTITY_ID: "media_player.bla"}
 
     off_calls = async_mock_service(hass, media_player.DOMAIN, SERVICE_TURN_OFF)
 
-    await trt_on.execute(trait.COMMAND_ONOFF, BASIC_DATA, {"on": False}, {})
+    await trt_on.execute(trait.COMMAND_ON_OFF, BASIC_DATA, {"on": False}, {})
     assert len(off_calls) == 1
     assert off_calls[0].data == {ATTR_ENTITY_ID: "media_player.bla"}
 
@@ -386,13 +386,13 @@ async def test_onoff_humidifier(hass: HomeAssistant) -> None:
     assert trt_off.query_attributes() == {"on": False}
 
     on_calls = async_mock_service(hass, humidifier.DOMAIN, SERVICE_TURN_ON)
-    await trt_on.execute(trait.COMMAND_ONOFF, BASIC_DATA, {"on": True}, {})
+    await trt_on.execute(trait.COMMAND_ON_OFF, BASIC_DATA, {"on": True}, {})
     assert len(on_calls) == 1
     assert on_calls[0].data == {ATTR_ENTITY_ID: "humidifier.bla"}
 
     off_calls = async_mock_service(hass, humidifier.DOMAIN, SERVICE_TURN_OFF)
 
-    await trt_on.execute(trait.COMMAND_ONOFF, BASIC_DATA, {"on": False}, {})
+    await trt_on.execute(trait.COMMAND_ON_OFF, BASIC_DATA, {"on": False}, {})
     assert len(off_calls) == 1
     assert off_calls[0].data == {ATTR_ENTITY_ID: "humidifier.bla"}
 
@@ -415,13 +415,13 @@ async def test_onoff_water_heater(hass: HomeAssistant) -> None:
     assert trt_off.query_attributes() == {"on": False}
 
     on_calls = async_mock_service(hass, water_heater.DOMAIN, SERVICE_TURN_ON)
-    await trt_on.execute(trait.COMMAND_ONOFF, BASIC_DATA, {"on": True}, {})
+    await trt_on.execute(trait.COMMAND_ON_OFF, BASIC_DATA, {"on": True}, {})
     assert len(on_calls) == 1
     assert on_calls[0].data == {ATTR_ENTITY_ID: "water_heater.bla"}
 
     off_calls = async_mock_service(hass, water_heater.DOMAIN, SERVICE_TURN_OFF)
 
-    await trt_on.execute(trait.COMMAND_ONOFF, BASIC_DATA, {"on": False}, {})
+    await trt_on.execute(trait.COMMAND_ON_OFF, BASIC_DATA, {"on": False}, {})
     assert len(off_calls) == 1
     assert off_calls[0].data == {ATTR_ENTITY_ID: "water_heater.bla"}
 
@@ -562,22 +562,22 @@ async def test_startstop_vacuum(hass: HomeAssistant) -> None:
     assert trt.query_attributes() == {"isRunning": False, "isPaused": True}
 
     start_calls = async_mock_service(hass, vacuum.DOMAIN, vacuum.SERVICE_START)
-    await trt.execute(trait.COMMAND_STARTSTOP, BASIC_DATA, {"start": True}, {})
+    await trt.execute(trait.COMMAND_START_STOP, BASIC_DATA, {"start": True}, {})
     assert len(start_calls) == 1
     assert start_calls[0].data == {ATTR_ENTITY_ID: "vacuum.bla"}
 
     stop_calls = async_mock_service(hass, vacuum.DOMAIN, vacuum.SERVICE_STOP)
-    await trt.execute(trait.COMMAND_STARTSTOP, BASIC_DATA, {"start": False}, {})
+    await trt.execute(trait.COMMAND_START_STOP, BASIC_DATA, {"start": False}, {})
     assert len(stop_calls) == 1
     assert stop_calls[0].data == {ATTR_ENTITY_ID: "vacuum.bla"}
 
     pause_calls = async_mock_service(hass, vacuum.DOMAIN, vacuum.SERVICE_PAUSE)
-    await trt.execute(trait.COMMAND_PAUSEUNPAUSE, BASIC_DATA, {"pause": True}, {})
+    await trt.execute(trait.COMMAND_PAUSE_UNPAUSE, BASIC_DATA, {"pause": True}, {})
     assert len(pause_calls) == 1
     assert pause_calls[0].data == {ATTR_ENTITY_ID: "vacuum.bla"}
 
     unpause_calls = async_mock_service(hass, vacuum.DOMAIN, vacuum.SERVICE_START)
-    await trt.execute(trait.COMMAND_PAUSEUNPAUSE, BASIC_DATA, {"pause": False}, {})
+    await trt.execute(trait.COMMAND_PAUSE_UNPAUSE, BASIC_DATA, {"pause": False}, {})
     assert len(unpause_calls) == 1
     assert unpause_calls[0].data == {ATTR_ENTITY_ID: "vacuum.bla"}
 
@@ -665,7 +665,7 @@ async def test_startstop_cover_valve(
     open_calls = async_mock_service(hass, domain, service_open)
     close_calls = async_mock_service(hass, domain, service_close)
     toggle_calls = async_mock_service(hass, domain, service_toggle)
-    await trt.execute(trait.COMMAND_STARTSTOP, BASIC_DATA, {"start": False}, {})
+    await trt.execute(trait.COMMAND_START_STOP, BASIC_DATA, {"start": False}, {})
     assert len(stop_calls) == 1
     assert stop_calls[0].data == {ATTR_ENTITY_ID: f"{domain}.bla"}
 
@@ -681,18 +681,18 @@ async def test_startstop_cover_valve(
     with pytest.raises(
         SmartHomeError, match=f"{domain.capitalize()} is already stopped"
     ):
-        await trt.execute(trait.COMMAND_STARTSTOP, BASIC_DATA, {"start": False}, {})
+        await trt.execute(trait.COMMAND_START_STOP, BASIC_DATA, {"start": False}, {})
 
     # Start triggers toggle open
     state.state = state_closed
-    await trt.execute(trait.COMMAND_STARTSTOP, BASIC_DATA, {"start": True}, {})
+    await trt.execute(trait.COMMAND_START_STOP, BASIC_DATA, {"start": True}, {})
     assert len(open_calls) == 0
     assert len(close_calls) == 0
     assert len(toggle_calls) == 1
     assert toggle_calls[0].data == {ATTR_ENTITY_ID: f"{domain}.bla"}
     # Second start triggers toggle close
     state.state = state_open
-    await trt.execute(trait.COMMAND_STARTSTOP, BASIC_DATA, {"start": True}, {})
+    await trt.execute(trait.COMMAND_START_STOP, BASIC_DATA, {"start": True}, {})
     assert len(open_calls) == 0
     assert len(close_calls) == 0
     assert len(toggle_calls) == 2
@@ -703,7 +703,7 @@ async def test_startstop_cover_valve(
         SmartHomeError,
         match="Command action.devices.commands.PauseUnpause is not supported",
     ):
-        await trt.execute(trait.COMMAND_PAUSEUNPAUSE, BASIC_DATA, {"start": True}, {})
+        await trt.execute(trait.COMMAND_PAUSE_UNPAUSE, BASIC_DATA, {"start": True}, {})
 
 
 @pytest.mark.parametrize(
@@ -779,13 +779,13 @@ async def test_startstop_cover_valve_assumed(
 
     stop_calls = async_mock_service(hass, domain, service_stop)
     toggle_calls = async_mock_service(hass, domain, service_toggle)
-    await trt.execute(trait.COMMAND_STARTSTOP, BASIC_DATA, {"start": False}, {})
+    await trt.execute(trait.COMMAND_START_STOP, BASIC_DATA, {"start": False}, {})
     assert len(stop_calls) == 1
     assert len(toggle_calls) == 0
     assert stop_calls[0].data == {ATTR_ENTITY_ID: f"{domain}.bla"}
 
     stop_calls.clear()
-    await trt.execute(trait.COMMAND_STARTSTOP, BASIC_DATA, {"start": True}, {})
+    await trt.execute(trait.COMMAND_START_STOP, BASIC_DATA, {"start": True}, {})
     assert len(stop_calls) == 0
     assert len(toggle_calls) == 1
     assert toggle_calls[0].data == {ATTR_ENTITY_ID: f"{domain}.bla"}
@@ -984,13 +984,13 @@ async def test_light_modes(hass: HomeAssistant) -> None:
     }
 
     assert trt.can_execute(
-        trait.COMMAND_MODES,
+        trait.COMMAND_SET_MODES,
         params={"updateModeSettings": {"effect": "colorloop"}},
     )
 
     calls = async_mock_service(hass, light.DOMAIN, SERVICE_TURN_ON)
     await trt.execute(
-        trait.COMMAND_MODES,
+        trait.COMMAND_SET_MODES,
         BASIC_DATA,
         {"updateModeSettings": {"effect": "colorloop"}},
         {},
@@ -1422,7 +1422,7 @@ async def test_temperature_control(hass: HomeAssistant) -> None:
         "temperatureAmbientCelsius": 18,
     }
     with pytest.raises(helpers.SmartHomeError) as err:
-        await trt.execute(trait.COMMAND_ONOFF, BASIC_DATA, {"on": False}, {})
+        await trt.execute(trait.COMMAND_ON_OFF, BASIC_DATA, {"on": False}, {})
     assert err.value.code == const.ERR_NOT_SUPPORTED
 
 
@@ -1609,11 +1609,11 @@ async def test_lock_unlock_lock(hass: HomeAssistant) -> None:
 
     assert trt.query_attributes() == {"isLocked": True}
 
-    assert trt.can_execute(trait.COMMAND_LOCKUNLOCK, {"lock": True})
+    assert trt.can_execute(trait.COMMAND_LOCK_UNLOCK, {"lock": True})
 
     calls = async_mock_service(hass, lock.DOMAIN, lock.SERVICE_LOCK)
 
-    await trt.execute(trait.COMMAND_LOCKUNLOCK, PIN_DATA, {"lock": True}, {})
+    await trt.execute(trait.COMMAND_LOCK_UNLOCK, PIN_DATA, {"lock": True}, {})
 
     assert len(calls) == 1
     assert calls[0].data == {ATTR_ENTITY_ID: "lock.front_door"}
@@ -1652,11 +1652,11 @@ async def test_lock_unlock_lock_jammed(hass: HomeAssistant) -> None:
 
     assert trt.query_attributes() == {"isJammed": True}
 
-    assert trt.can_execute(trait.COMMAND_LOCKUNLOCK, {"lock": True})
+    assert trt.can_execute(trait.COMMAND_LOCK_UNLOCK, {"lock": True})
 
     calls = async_mock_service(hass, lock.DOMAIN, lock.SERVICE_LOCK)
 
-    await trt.execute(trait.COMMAND_LOCKUNLOCK, PIN_DATA, {"lock": True}, {})
+    await trt.execute(trait.COMMAND_LOCK_UNLOCK, PIN_DATA, {"lock": True}, {})
 
     assert len(calls) == 1
     assert calls[0].data == {ATTR_ENTITY_ID: "lock.front_door"}
@@ -1677,13 +1677,13 @@ async def test_lock_unlock_unlock(hass: HomeAssistant) -> None:
 
     assert trt.query_attributes() == {"isLocked": True}
 
-    assert trt.can_execute(trait.COMMAND_LOCKUNLOCK, {"lock": False})
+    assert trt.can_execute(trait.COMMAND_LOCK_UNLOCK, {"lock": False})
 
     calls = async_mock_service(hass, lock.DOMAIN, lock.SERVICE_UNLOCK)
 
     # No challenge data
     with pytest.raises(error.ChallengeNeeded) as err:
-        await trt.execute(trait.COMMAND_LOCKUNLOCK, PIN_DATA, {"lock": False}, {})
+        await trt.execute(trait.COMMAND_LOCK_UNLOCK, PIN_DATA, {"lock": False}, {})
     assert len(calls) == 0
     assert err.value.code == const.ERR_CHALLENGE_NEEDED
     assert err.value.challenge_type == const.CHALLENGE_PIN_NEEDED
@@ -1691,14 +1691,14 @@ async def test_lock_unlock_unlock(hass: HomeAssistant) -> None:
     # invalid pin
     with pytest.raises(error.ChallengeNeeded) as err:
         await trt.execute(
-            trait.COMMAND_LOCKUNLOCK, PIN_DATA, {"lock": False}, {"pin": 9999}
+            trait.COMMAND_LOCK_UNLOCK, PIN_DATA, {"lock": False}, {"pin": 9999}
         )
     assert len(calls) == 0
     assert err.value.code == const.ERR_CHALLENGE_NEEDED
     assert err.value.challenge_type == const.CHALLENGE_FAILED_PIN_NEEDED
 
     await trt.execute(
-        trait.COMMAND_LOCKUNLOCK, PIN_DATA, {"lock": False}, {"pin": "1234"}
+        trait.COMMAND_LOCK_UNLOCK, PIN_DATA, {"lock": False}, {"pin": "1234"}
     )
 
     assert len(calls) == 1
@@ -1710,7 +1710,7 @@ async def test_lock_unlock_unlock(hass: HomeAssistant) -> None:
     )
 
     with pytest.raises(error.SmartHomeError) as err:
-        await trt.execute(trait.COMMAND_LOCKUNLOCK, BASIC_DATA, {"lock": False}, {})
+        await trt.execute(trait.COMMAND_LOCK_UNLOCK, BASIC_DATA, {"lock": False}, {})
     assert len(calls) == 1
     assert err.value.code == const.ERR_CHALLENGE_NOT_SETUP
 
@@ -1720,7 +1720,7 @@ async def test_lock_unlock_unlock(hass: HomeAssistant) -> None:
         "should_2fa",
         return_value=False,
     ):
-        await trt.execute(trait.COMMAND_LOCKUNLOCK, BASIC_DATA, {"lock": False}, {})
+        await trt.execute(trait.COMMAND_LOCK_UNLOCK, BASIC_DATA, {"lock": False}, {})
     assert len(calls) == 2
 
 
@@ -1769,7 +1769,7 @@ async def test_arm_disarm_arm_away(hass: HomeAssistant) -> None:
     }
 
     assert trt.can_execute(
-        trait.COMMAND_ARMDISARM, {"arm": True, "armLevel": STATE_ALARM_ARMED_AWAY}
+        trait.COMMAND_ARM_DISARM, {"arm": True, "armLevel": STATE_ALARM_ARMED_AWAY}
     )
 
     calls = async_mock_service(
@@ -1789,7 +1789,7 @@ async def test_arm_disarm_arm_away(hass: HomeAssistant) -> None:
     )
     with pytest.raises(error.SmartHomeError) as err:
         await trt.execute(
-            trait.COMMAND_ARMDISARM,
+            trait.COMMAND_ARM_DISARM,
             BASIC_DATA,
             {"arm": True, "armLevel": STATE_ALARM_ARMED_AWAY},
             {},
@@ -1809,7 +1809,7 @@ async def test_arm_disarm_arm_away(hass: HomeAssistant) -> None:
     # No challenge data
     with pytest.raises(error.ChallengeNeeded) as err:
         await trt.execute(
-            trait.COMMAND_ARMDISARM,
+            trait.COMMAND_ARM_DISARM,
             PIN_DATA,
             {"arm": True, "armLevel": STATE_ALARM_ARMED_AWAY},
             {},
@@ -1821,7 +1821,7 @@ async def test_arm_disarm_arm_away(hass: HomeAssistant) -> None:
     # invalid pin
     with pytest.raises(error.ChallengeNeeded) as err:
         await trt.execute(
-            trait.COMMAND_ARMDISARM,
+            trait.COMMAND_ARM_DISARM,
             PIN_DATA,
             {"arm": True, "armLevel": STATE_ALARM_ARMED_AWAY},
             {"pin": 9999},
@@ -1832,7 +1832,7 @@ async def test_arm_disarm_arm_away(hass: HomeAssistant) -> None:
 
     # correct pin
     await trt.execute(
-        trait.COMMAND_ARMDISARM,
+        trait.COMMAND_ARM_DISARM,
         PIN_DATA,
         {"arm": True, "armLevel": STATE_ALARM_ARMED_AWAY},
         {"pin": "1234"},
@@ -1852,7 +1852,7 @@ async def test_arm_disarm_arm_away(hass: HomeAssistant) -> None:
     )
     with pytest.raises(error.SmartHomeError) as err:
         await trt.execute(
-            trait.COMMAND_ARMDISARM,
+            trait.COMMAND_ARM_DISARM,
             PIN_DATA,
             {"arm": True, "armLevel": STATE_ALARM_ARMED_AWAY},
             {},
@@ -1871,7 +1871,7 @@ async def test_arm_disarm_arm_away(hass: HomeAssistant) -> None:
         PIN_CONFIG,
     )
     await trt.execute(
-        trait.COMMAND_ARMDISARM,
+        trait.COMMAND_ARM_DISARM,
         PIN_DATA,
         {"arm": True, "armLevel": STATE_ALARM_ARMED_AWAY},
         {},
@@ -1880,7 +1880,7 @@ async def test_arm_disarm_arm_away(hass: HomeAssistant) -> None:
 
     with pytest.raises(error.SmartHomeError) as err:
         await trt.execute(
-            trait.COMMAND_ARMDISARM,
+            trait.COMMAND_ARM_DISARM,
             PIN_DATA,
             {"arm": True},
             {},
@@ -1942,7 +1942,7 @@ async def test_arm_disarm_disarm(hass: HomeAssistant) -> None:
         "isArmed": False,
     }
 
-    assert trt.can_execute(trait.COMMAND_ARMDISARM, {"arm": False})
+    assert trt.can_execute(trait.COMMAND_ARM_DISARM, {"arm": False})
 
     calls = async_mock_service(
         hass, alarm_control_panel.DOMAIN, alarm_control_panel.SERVICE_ALARM_DISARM
@@ -1959,7 +1959,7 @@ async def test_arm_disarm_disarm(hass: HomeAssistant) -> None:
         BASIC_CONFIG,
     )
     with pytest.raises(error.SmartHomeError) as err:
-        await trt.execute(trait.COMMAND_ARMDISARM, BASIC_DATA, {"arm": False}, {})
+        await trt.execute(trait.COMMAND_ARM_DISARM, BASIC_DATA, {"arm": False}, {})
 
     assert len(calls) == 0
     assert err.value.code == const.ERR_CHALLENGE_NOT_SETUP
@@ -1976,7 +1976,7 @@ async def test_arm_disarm_disarm(hass: HomeAssistant) -> None:
 
     # No challenge data
     with pytest.raises(error.ChallengeNeeded) as err:
-        await trt.execute(trait.COMMAND_ARMDISARM, PIN_DATA, {"arm": False}, {})
+        await trt.execute(trait.COMMAND_ARM_DISARM, PIN_DATA, {"arm": False}, {})
     assert len(calls) == 0
     assert err.value.code == const.ERR_CHALLENGE_NEEDED
     assert err.value.challenge_type == const.CHALLENGE_PIN_NEEDED
@@ -1984,7 +1984,7 @@ async def test_arm_disarm_disarm(hass: HomeAssistant) -> None:
     # invalid pin
     with pytest.raises(error.ChallengeNeeded) as err:
         await trt.execute(
-            trait.COMMAND_ARMDISARM, PIN_DATA, {"arm": False}, {"pin": 9999}
+            trait.COMMAND_ARM_DISARM, PIN_DATA, {"arm": False}, {"pin": 9999}
         )
     assert len(calls) == 0
     assert err.value.code == const.ERR_CHALLENGE_NEEDED
@@ -1992,7 +1992,7 @@ async def test_arm_disarm_disarm(hass: HomeAssistant) -> None:
 
     # correct pin
     await trt.execute(
-        trait.COMMAND_ARMDISARM, PIN_DATA, {"arm": False}, {"pin": "1234"}
+        trait.COMMAND_ARM_DISARM, PIN_DATA, {"arm": False}, {"pin": "1234"}
     )
 
     assert len(calls) == 1
@@ -2008,7 +2008,7 @@ async def test_arm_disarm_disarm(hass: HomeAssistant) -> None:
         PIN_CONFIG,
     )
     with pytest.raises(error.SmartHomeError) as err:
-        await trt.execute(trait.COMMAND_ARMDISARM, PIN_DATA, {"arm": False}, {})
+        await trt.execute(trait.COMMAND_ARM_DISARM, PIN_DATA, {"arm": False}, {})
     assert len(calls) == 1
     assert err.value.code == const.ERR_ALREADY_DISARMED
 
@@ -2025,7 +2025,7 @@ async def test_arm_disarm_disarm(hass: HomeAssistant) -> None:
     # Cancel arming after already armed will require pin
     with pytest.raises(error.SmartHomeError) as err:
         await trt.execute(
-            trait.COMMAND_ARMDISARM, PIN_DATA, {"arm": True, "cancel": True}, {}
+            trait.COMMAND_ARM_DISARM, PIN_DATA, {"arm": True, "cancel": True}, {}
         )
     assert len(calls) == 1
     assert err.value.code == const.ERR_CHALLENGE_NEEDED
@@ -2042,7 +2042,7 @@ async def test_arm_disarm_disarm(hass: HomeAssistant) -> None:
         PIN_CONFIG,
     )
     await trt.execute(
-        trait.COMMAND_ARMDISARM, PIN_DATA, {"arm": True, "cancel": True}, {}
+        trait.COMMAND_ARM_DISARM, PIN_DATA, {"arm": True, "cancel": True}, {}
     )
     assert len(calls) == 2
 
@@ -2078,10 +2078,12 @@ async def test_fan_speed(hass: HomeAssistant) -> None:
         "currentFanSpeedSetting": ANY,
     }
 
-    assert trt.can_execute(trait.COMMAND_FANSPEED, params={"fanSpeedPercent": 10})
+    assert trt.can_execute(trait.COMMAND_SET_FAN_SPEED, params={"fanSpeedPercent": 10})
 
     calls = async_mock_service(hass, fan.DOMAIN, fan.SERVICE_SET_PERCENTAGE)
-    await trt.execute(trait.COMMAND_FANSPEED, BASIC_DATA, {"fanSpeedPercent": 10}, {})
+    await trt.execute(
+        trait.COMMAND_SET_FAN_SPEED, BASIC_DATA, {"fanSpeedPercent": 10}, {}
+    )
 
     assert len(calls) == 1
     assert calls[0].data == {"entity_id": "fan.living_room_fan", "percentage": 10}
@@ -2216,10 +2218,10 @@ async def test_fan_speed_ordered(
         "currentFanSpeedSetting": speed,
     }
 
-    assert trt.can_execute(trait.COMMAND_FANSPEED, params={"fanSpeed": speed})
+    assert trt.can_execute(trait.COMMAND_SET_FAN_SPEED, params={"fanSpeed": speed})
 
     calls = async_mock_service(hass, fan.DOMAIN, fan.SERVICE_SET_PERCENTAGE)
-    await trt.execute(trait.COMMAND_FANSPEED, BASIC_DATA, {"fanSpeed": speed}, {})
+    await trt.execute(trait.COMMAND_SET_FAN_SPEED, BASIC_DATA, {"fanSpeed": speed}, {})
 
     assert len(calls) == 1
     assert calls[0].data == {
@@ -2328,10 +2330,12 @@ async def test_climate_fan_speed(hass: HomeAssistant) -> None:
         "currentFanSpeedSetting": "low",
     }
 
-    assert trt.can_execute(trait.COMMAND_FANSPEED, params={"fanSpeed": "medium"})
+    assert trt.can_execute(trait.COMMAND_SET_FAN_SPEED, params={"fanSpeed": "medium"})
 
     calls = async_mock_service(hass, climate.DOMAIN, climate.SERVICE_SET_FAN_MODE)
-    await trt.execute(trait.COMMAND_FANSPEED, BASIC_DATA, {"fanSpeed": "medium"}, {})
+    await trt.execute(
+        trait.COMMAND_SET_FAN_SPEED, BASIC_DATA, {"fanSpeed": "medium"}, {}
+    )
 
     assert len(calls) == 1
     assert calls[0].data == {
@@ -2387,7 +2391,7 @@ async def test_inputselector(hass: HomeAssistant) -> None:
     }
 
     assert trt.can_execute(
-        trait.COMMAND_INPUT,
+        trait.COMMAND_SET_INPUT,
         params={"newInput": "media"},
     )
 
@@ -2395,7 +2399,7 @@ async def test_inputselector(hass: HomeAssistant) -> None:
         hass, media_player.DOMAIN, media_player.SERVICE_SELECT_SOURCE
     )
     await trt.execute(
-        trait.COMMAND_INPUT,
+        trait.COMMAND_SET_INPUT,
         BASIC_DATA,
         {"newInput": "media"},
         {},
@@ -2563,7 +2567,7 @@ async def test_modes_input_select(hass: HomeAssistant) -> None:
     }
 
     assert trt.can_execute(
-        trait.COMMAND_MODES,
+        trait.COMMAND_SET_MODES,
         params={"updateModeSettings": {"option": "xyz"}},
     )
 
@@ -2571,7 +2575,7 @@ async def test_modes_input_select(hass: HomeAssistant) -> None:
         hass, input_select.DOMAIN, input_select.SERVICE_SELECT_OPTION
     )
     await trt.execute(
-        trait.COMMAND_MODES,
+        trait.COMMAND_SET_MODES,
         BASIC_DATA,
         {"updateModeSettings": {"option": "xyz"}},
         {},
@@ -2639,13 +2643,13 @@ async def test_modes_select(hass: HomeAssistant) -> None:
     }
 
     assert trt.can_execute(
-        trait.COMMAND_MODES,
+        trait.COMMAND_SET_MODES,
         params={"updateModeSettings": {"option": "xyz"}},
     )
 
     calls = async_mock_service(hass, select.DOMAIN, select.SERVICE_SELECT_OPTION)
     await trt.execute(
-        trait.COMMAND_MODES,
+        trait.COMMAND_SET_MODES,
         BASIC_DATA,
         {"updateModeSettings": {"option": "xyz"}},
         {},
@@ -2716,12 +2720,12 @@ async def test_modes_humidifier(hass: HomeAssistant) -> None:
     }
 
     assert trt.can_execute(
-        trait.COMMAND_MODES, params={"updateModeSettings": {"mode": "away"}}
+        trait.COMMAND_SET_MODES, params={"updateModeSettings": {"mode": "away"}}
     )
 
     calls = async_mock_service(hass, humidifier.DOMAIN, humidifier.SERVICE_SET_MODE)
     await trt.execute(
-        trait.COMMAND_MODES,
+        trait.COMMAND_SET_MODES,
         BASIC_DATA,
         {"updateModeSettings": {"mode": "away"}},
         {},
@@ -2792,14 +2796,15 @@ async def test_modes_water_heater(hass: HomeAssistant) -> None:
     }
 
     assert trt.can_execute(
-        trait.COMMAND_MODES, params={"updateModeSettings": {"operation mode": "gas"}}
+        trait.COMMAND_SET_MODES,
+        params={"updateModeSettings": {"operation mode": "gas"}},
     )
 
     calls = async_mock_service(
         hass, water_heater.DOMAIN, water_heater.SERVICE_SET_OPERATION_MODE
     )
     await trt.execute(
-        trait.COMMAND_MODES,
+        trait.COMMAND_SET_MODES,
         BASIC_DATA,
         {"updateModeSettings": {"operation mode": "gas"}},
         {},
@@ -2868,7 +2873,7 @@ async def test_sound_modes(hass: HomeAssistant) -> None:
     }
 
     assert trt.can_execute(
-        trait.COMMAND_MODES,
+        trait.COMMAND_SET_MODES,
         params={"updateModeSettings": {"sound mode": "stereo"}},
     )
 
@@ -2876,7 +2881,7 @@ async def test_sound_modes(hass: HomeAssistant) -> None:
         hass, media_player.DOMAIN, media_player.SERVICE_SELECT_SOUND_MODE
     )
     await trt.execute(
-        trait.COMMAND_MODES,
+        trait.COMMAND_SET_MODES,
         BASIC_DATA,
         {"updateModeSettings": {"sound mode": "stereo"}},
         {},
@@ -2941,13 +2946,13 @@ async def test_preset_modes(hass: HomeAssistant) -> None:
     }
 
     assert trt.can_execute(
-        trait.COMMAND_MODES,
+        trait.COMMAND_SET_MODES,
         params={"updateModeSettings": {"preset mode": "auto"}},
     )
 
     calls = async_mock_service(hass, fan.DOMAIN, fan.SERVICE_SET_PRESET_MODE)
     await trt.execute(
-        trait.COMMAND_MODES,
+        trait.COMMAND_SET_MODES,
         BASIC_DATA,
         {"updateModeSettings": {"preset mode": "auto"}},
         {},
@@ -2975,7 +2980,7 @@ async def test_traits_unknown_domains(
 
     assert trt.supported("not_supported_domain", False, None, None) is False
     await trt.execute(
-        trait.COMMAND_MODES,
+        trait.COMMAND_SET_MODES,
         BASIC_DATA,
         {"updateModeSettings": {}},
         {},
@@ -3049,9 +3054,9 @@ async def test_openclose_cover_valve(
     calls_open = async_mock_service(hass, domain, open_service)
     calls_close = async_mock_service(hass, domain, close_service)
 
-    await trt.execute(trait.COMMAND_OPENCLOSE, BASIC_DATA, {"openPercent": 50}, {})
+    await trt.execute(trait.COMMAND_OPEN_CLOSE, BASIC_DATA, {"openPercent": 50}, {})
     await trt.execute(
-        trait.COMMAND_OPENCLOSE_RELATIVE, BASIC_DATA, {"openRelativePercent": 50}, {}
+        trait.COMMAND_OPEN_CLOSE_RELATIVE, BASIC_DATA, {"openRelativePercent": 50}, {}
     )
     assert len(calls_set) == 1
     assert calls_set[0].data == {
@@ -3066,9 +3071,9 @@ async def test_openclose_cover_valve(
 
     assert len(calls_close) == 0
 
-    await trt.execute(trait.COMMAND_OPENCLOSE, BASIC_DATA, {"openPercent": 0}, {})
+    await trt.execute(trait.COMMAND_OPEN_CLOSE, BASIC_DATA, {"openPercent": 0}, {})
     await trt.execute(
-        trait.COMMAND_OPENCLOSE_RELATIVE, BASIC_DATA, {"openRelativePercent": 0}, {}
+        trait.COMMAND_OPEN_CLOSE_RELATIVE, BASIC_DATA, {"openRelativePercent": 0}, {}
     )
     assert len(calls_set) == 1
     assert len(calls_close) == 1
@@ -3123,7 +3128,7 @@ async def test_openclose_cover_valve_unknown_state(
         trt.query_attributes()
 
     calls = async_mock_service(hass, domain, open_service)
-    await trt.execute(trait.COMMAND_OPENCLOSE, BASIC_DATA, {"openPercent": 100}, {})
+    await trt.execute(trait.COMMAND_OPEN_CLOSE, BASIC_DATA, {"openPercent": 100}, {})
     assert len(calls) == 1
     assert calls[0].data == {ATTR_ENTITY_ID: f"{domain}.bla"}
 
@@ -3177,7 +3182,7 @@ async def test_openclose_cover_valve_assumed_state(
     assert trt.query_attributes() == {}
 
     calls = async_mock_service(hass, domain, set_position_service)
-    await trt.execute(trait.COMMAND_OPENCLOSE, BASIC_DATA, {"openPercent": 40}, {})
+    await trt.execute(trait.COMMAND_OPEN_CLOSE, BASIC_DATA, {"openPercent": 40}, {})
     assert len(calls) == 1
     assert calls[0].data == {ATTR_ENTITY_ID: f"{domain}.bla", cover.ATTR_POSITION: 40}
 
@@ -3291,12 +3296,12 @@ async def test_openclose_cover_valve_no_position(
     assert trt.query_attributes() == {"openPercent": 0}
 
     calls = async_mock_service(hass, domain, close_service)
-    await trt.execute(trait.COMMAND_OPENCLOSE, BASIC_DATA, {"openPercent": 0}, {})
+    await trt.execute(trait.COMMAND_OPEN_CLOSE, BASIC_DATA, {"openPercent": 0}, {})
     assert len(calls) == 1
     assert calls[0].data == {ATTR_ENTITY_ID: f"{domain}.bla"}
 
     calls = async_mock_service(hass, domain, open_service)
-    await trt.execute(trait.COMMAND_OPENCLOSE, BASIC_DATA, {"openPercent": 100}, {})
+    await trt.execute(trait.COMMAND_OPEN_CLOSE, BASIC_DATA, {"openPercent": 100}, {})
     assert len(calls) == 1
     assert calls[0].data == {ATTR_ENTITY_ID: f"{domain}.bla"}
 
@@ -3304,14 +3309,14 @@ async def test_openclose_cover_valve_no_position(
         SmartHomeError, match=r"Current position not know for relative command"
     ):
         await trt.execute(
-            trait.COMMAND_OPENCLOSE_RELATIVE,
+            trait.COMMAND_OPEN_CLOSE_RELATIVE,
             BASIC_DATA,
             {"openRelativePercent": 100},
             {},
         )
 
     with pytest.raises(SmartHomeError, match=r"No support for partial open close"):
-        await trt.execute(trait.COMMAND_OPENCLOSE, BASIC_DATA, {"openPercent": 50}, {})
+        await trt.execute(trait.COMMAND_OPEN_CLOSE, BASIC_DATA, {"openPercent": 50}, {})
 
 
 @pytest.mark.parametrize(
@@ -3354,7 +3359,7 @@ async def test_openclose_cover_secure(hass: HomeAssistant, device_class) -> None
 
     # No challenge data
     with pytest.raises(error.ChallengeNeeded) as err:
-        await trt.execute(trait.COMMAND_OPENCLOSE, PIN_DATA, {"openPercent": 50}, {})
+        await trt.execute(trait.COMMAND_OPEN_CLOSE, PIN_DATA, {"openPercent": 50}, {})
     assert len(calls) == 0
     assert err.value.code == const.ERR_CHALLENGE_NEEDED
     assert err.value.challenge_type == const.CHALLENGE_PIN_NEEDED
@@ -3362,20 +3367,20 @@ async def test_openclose_cover_secure(hass: HomeAssistant, device_class) -> None
     # invalid pin
     with pytest.raises(error.ChallengeNeeded) as err:
         await trt.execute(
-            trait.COMMAND_OPENCLOSE, PIN_DATA, {"openPercent": 50}, {"pin": "9999"}
+            trait.COMMAND_OPEN_CLOSE, PIN_DATA, {"openPercent": 50}, {"pin": "9999"}
         )
     assert len(calls) == 0
     assert err.value.code == const.ERR_CHALLENGE_NEEDED
     assert err.value.challenge_type == const.CHALLENGE_FAILED_PIN_NEEDED
 
     await trt.execute(
-        trait.COMMAND_OPENCLOSE, PIN_DATA, {"openPercent": 50}, {"pin": "1234"}
+        trait.COMMAND_OPEN_CLOSE, PIN_DATA, {"openPercent": 50}, {"pin": "1234"}
     )
     assert len(calls) == 1
     assert calls[0].data == {ATTR_ENTITY_ID: "cover.bla", cover.ATTR_POSITION: 50}
 
     # no challenge on close
-    await trt.execute(trait.COMMAND_OPENCLOSE, PIN_DATA, {"openPercent": 0}, {})
+    await trt.execute(trait.COMMAND_OPEN_CLOSE, PIN_DATA, {"openPercent": 0}, {})
     assert len(calls_close) == 1
     assert calls_close[0].data == {ATTR_ENTITY_ID: "cover.bla"}
 
@@ -3699,7 +3704,7 @@ async def test_humidity_setting_sensor_data(
         assert trt.query_attributes() == {}
 
     with pytest.raises(helpers.SmartHomeError) as err:
-        await trt.execute(trait.COMMAND_ONOFF, BASIC_DATA, {"on": False}, {})
+        await trt.execute(trait.COMMAND_ON_OFF, BASIC_DATA, {"on": False}, {})
     assert err.value.code == const.ERR_NOT_SUPPORTED