Adjust after rebase

CODEOWNERS

@@ -1699,6 +1699,8 @@ build.json @home-assistant/supervisor
 /tests/components/tellduslive/ @fredrike
 /homeassistant/components/teltonika/ @karlbeecken
 /tests/components/teltonika/ @karlbeecken
+/homeassistant/components/temperature/ @home-assistant/core
+/tests/components/temperature/ @home-assistant/core
 /homeassistant/components/template/ @Petro31 @home-assistant/core
 /tests/components/template/ @Petro31 @home-assistant/core
 /homeassistant/components/tesla_fleet/ @Bre77

homeassistant/bootstrap.py

@@ -247,6 +247,7 @@ DEFAULT_INTEGRATIONS = {
     "humidity",
     "motion",
     "occupancy",
+    "temperature",
     "window",
 }
 DEFAULT_INTEGRATIONS_RECOVERY_MODE = {

homeassistant/components/automation/__init__.py

@@ -161,6 +161,7 @@ _EXPERIMENTAL_TRIGGER_PLATFORMS = {
     "schedule",
     "siren",
     "switch",
+    "temperature",
     "text",
     "update",
     "vacuum",

homeassistant/components/temperature/__init__.py

@@ -0,0 +1,17 @@
+"""Integration for temperature triggers."""
+
+from __future__ import annotations
+
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.typing import ConfigType
+
+DOMAIN = "temperature"
+CONFIG_SCHEMA = cv.empty_config_schema(DOMAIN)
+
+__all__ = []
+
+
+async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
+    """Set up the component."""
+    return True

homeassistant/components/temperature/icons.json

@@ -0,0 +1,10 @@
+{
+  "triggers": {
+    "changed": {
+      "trigger": "mdi:thermometer"
+    },
+    "crossed_threshold": {
+      "trigger": "mdi:thermometer"
+    }
+  }
+}

homeassistant/components/temperature/manifest.json

@@ -0,0 +1,8 @@
+{
+  "domain": "temperature",
+  "name": "Temperature",
+  "codeowners": ["@home-assistant/core"],
+  "documentation": "https://www.home-assistant.io/integrations/temperature",
+  "integration_type": "system",
+  "quality_scale": "internal"
+}

homeassistant/components/temperature/strings.json

@@ -0,0 +1,82 @@
+{
+  "common": {
+    "trigger_behavior_description": "The behavior of the targeted entities to trigger on.",
+    "trigger_behavior_name": "Behavior"
+  },
+  "selector": {
+    "number_or_entity": {
+      "choices": {
+        "entity": "Entity",
+        "number": "Number"
+      }
+    },
+    "trigger_behavior": {
+      "options": {
+        "any": "Any",
+        "first": "First",
+        "last": "Last"
+      }
+    },
+    "trigger_temperature_unit": {
+      "options": {
+        "celsius": "Celsius (°C)",
+        "fahrenheit": "Fahrenheit (°F)"
+      }
+    },
+    "trigger_threshold_type": {
+      "options": {
+        "above": "Above",
+        "below": "Below",
+        "between": "Between",
+        "outside": "Outside"
+      }
+    }
+  },
+  "title": "Temperature",
+  "triggers": {
+    "changed": {
+      "description": "Triggers when the temperature changes.",
+      "fields": {
+        "above": {
+          "description": "Only trigger when temperature is above this value.",
+          "name": "Above"
+        },
+        "below": {
+          "description": "Only trigger when temperature is below this value.",
+          "name": "Below"
+        },
+        "unit": {
+          "description": "The unit of temperature for the trigger values. Defaults to the system unit.",
+          "name": "Unit"
+        }
+      },
+      "name": "Temperature changed"
+    },
+    "crossed_threshold": {
+      "description": "Triggers when the temperature crosses a threshold.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::temperature::common::trigger_behavior_description%]",
+          "name": "[%key:component::temperature::common::trigger_behavior_name%]"
+        },
+        "lower_limit": {
+          "description": "The lower limit of the threshold.",
+          "name": "Lower limit"
+        },
+        "threshold_type": {
+          "description": "The type of threshold to use.",
+          "name": "Threshold type"
+        },
+        "unit": {
+          "description": "[%key:component::temperature::triggers::changed::fields::unit::description%]",
+          "name": "[%key:component::temperature::triggers::changed::fields::unit::name%]"
+        },
+        "upper_limit": {
+          "description": "The upper limit of the threshold.",
+          "name": "Upper limit"
+        }
+      },
+      "name": "Temperature crossed threshold"
+    }
+  }
+}

homeassistant/components/temperature/trigger.py

@@ -0,0 +1,185 @@
+"""Provides triggers for temperature."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import voluptuous as vol
+
+from homeassistant.components.climate import (
+    ATTR_CURRENT_TEMPERATURE as CLIMATE_ATTR_CURRENT_TEMPERATURE,
+    DOMAIN as CLIMATE_DOMAIN,
+)
+from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN, SensorDeviceClass
+from homeassistant.components.water_heater import (
+    ATTR_CURRENT_TEMPERATURE as WATER_HEATER_ATTR_CURRENT_TEMPERATURE,
+    DOMAIN as WATER_HEATER_DOMAIN,
+)
+from homeassistant.components.weather import (
+    ATTR_WEATHER_TEMPERATURE,
+    ATTR_WEATHER_TEMPERATURE_UNIT,
+    DOMAIN as WEATHER_DOMAIN,
+)
+from homeassistant.const import (
+    ATTR_UNIT_OF_MEASUREMENT,
+    CONF_ABOVE,
+    CONF_BELOW,
+    CONF_OPTIONS,
+    UnitOfTemperature,
+)
+from homeassistant.core import HomeAssistant, State, split_entity_id
+from homeassistant.helpers.automation import NumericalDomainSpec
+from homeassistant.helpers.trigger import (
+    ATTR_BEHAVIOR,
+    BEHAVIOR_ANY,
+    BEHAVIOR_FIRST,
+    BEHAVIOR_LAST,
+    CONF_LOWER_LIMIT,
+    CONF_THRESHOLD_TYPE,
+    CONF_UPPER_LIMIT,
+    ENTITY_STATE_TRIGGER_SCHEMA,
+    EntityNumericalStateChangedTriggerBase,
+    EntityNumericalStateCrossedThresholdTriggerBase,
+    EntityNumericalStateTriggerBase,
+    ThresholdType,
+    Trigger,
+    TriggerConfig,
+    _number_or_entity,
+    _validate_limits_for_threshold_type,
+    _validate_range,
+)
+from homeassistant.util.unit_conversion import TemperatureConverter
+
+CONF_UNIT = "unit"
+
+_UNIT_MAP = {
+    "celsius": UnitOfTemperature.CELSIUS,
+    "fahrenheit": UnitOfTemperature.FAHRENHEIT,
+}
+
+
+def _validate_temperature_unit(value: str) -> str:
+    """Convert temperature unit option to UnitOfTemperature."""
+    if value in _UNIT_MAP:
+        return _UNIT_MAP[value]
+    raise vol.Invalid(f"Unknown temperature unit: {value}")
+
+
+_UNIT_VALIDATOR = _validate_temperature_unit
+
+TEMPERATURE_CHANGED_TRIGGER_SCHEMA = ENTITY_STATE_TRIGGER_SCHEMA.extend(
+    {
+        vol.Required(CONF_OPTIONS): vol.All(
+            {
+                vol.Optional(CONF_ABOVE): _number_or_entity,
+                vol.Optional(CONF_BELOW): _number_or_entity,
+                vol.Optional(CONF_UNIT): _UNIT_VALIDATOR,
+            },
+            _validate_range(CONF_ABOVE, CONF_BELOW),
+        )
+    }
+)
+
+TEMPERATURE_CROSSED_THRESHOLD_TRIGGER_SCHEMA = ENTITY_STATE_TRIGGER_SCHEMA.extend(
+    {
+        vol.Required(CONF_OPTIONS): vol.All(
+            {
+                vol.Required(ATTR_BEHAVIOR, default=BEHAVIOR_ANY): vol.In(
+                    [BEHAVIOR_FIRST, BEHAVIOR_LAST, BEHAVIOR_ANY]
+                ),
+                vol.Optional(CONF_LOWER_LIMIT): _number_or_entity,
+                vol.Optional(CONF_UPPER_LIMIT): _number_or_entity,
+                vol.Required(CONF_THRESHOLD_TYPE): vol.Coerce(ThresholdType),
+                vol.Optional(CONF_UNIT): _UNIT_VALIDATOR,
+            },
+            _validate_range(CONF_LOWER_LIMIT, CONF_UPPER_LIMIT),
+            _validate_limits_for_threshold_type,
+        )
+    }
+)
+
+
+TEMPERATURE_DOMAIN_SPECS = {
+    CLIMATE_DOMAIN: NumericalDomainSpec(
+        value_source=CLIMATE_ATTR_CURRENT_TEMPERATURE,
+    ),
+    SENSOR_DOMAIN: NumericalDomainSpec(
+        device_class=SensorDeviceClass.TEMPERATURE,
+    ),
+    WATER_HEATER_DOMAIN: NumericalDomainSpec(
+        value_source=WATER_HEATER_ATTR_CURRENT_TEMPERATURE
+    ),
+    WEATHER_DOMAIN: NumericalDomainSpec(
+        value_source=ATTR_WEATHER_TEMPERATURE,
+    ),
+}
+
+
+class _TemperatureTriggerMixin(EntityNumericalStateTriggerBase):
+    """Mixin for temperature triggers providing entity filtering, value extraction, and unit conversion."""
+
+    _domain_specs = TEMPERATURE_DOMAIN_SPECS
+
+    def __init__(self, hass: HomeAssistant, config: TriggerConfig) -> None:
+        """Initialize the trigger."""
+        super().__init__(hass, config)
+        self._trigger_unit: str = self._options.get(
+            CONF_UNIT, hass.config.units.temperature_unit
+        )
+
+    def _get_entity_unit(self, state: State) -> str | None:
+        """Get the temperature unit of an entity from its state."""
+        domain = split_entity_id(state.entity_id)[0]
+        if domain == SENSOR_DOMAIN:
+            return state.attributes.get(ATTR_UNIT_OF_MEASUREMENT)
+        if domain == WEATHER_DOMAIN:
+            return state.attributes.get(
+                ATTR_WEATHER_TEMPERATURE_UNIT,
+                self._hass.config.units.temperature_unit,
+            )
+        # Climate and water_heater: show_temp converts to system unit
+        return self._hass.config.units.temperature_unit
+
+    def _get_tracked_value(self, state: State) -> Any:
+        """Get the temperature value converted to the trigger's configured unit."""
+        raw_value = super()._get_tracked_value(state)
+        if raw_value is None:
+            return None
+
+        entity_unit = self._get_entity_unit(state)
+        if entity_unit is None or entity_unit == self._trigger_unit:
+            return raw_value
+
+        try:
+            return TemperatureConverter.convert(
+                float(raw_value), entity_unit, self._trigger_unit
+            )
+        except TypeError, ValueError:
+            return raw_value  # Let the base class converter handle the error
+
+
+class TemperatureChangedTrigger(
+    _TemperatureTriggerMixin, EntityNumericalStateChangedTriggerBase
+):
+    """Trigger for temperature value changes across multiple domains."""
+
+    _schema = TEMPERATURE_CHANGED_TRIGGER_SCHEMA
+
+
+class TemperatureCrossedThresholdTrigger(
+    _TemperatureTriggerMixin, EntityNumericalStateCrossedThresholdTriggerBase
+):
+    """Trigger for temperature value crossing a threshold across multiple domains."""
+
+    _schema = TEMPERATURE_CROSSED_THRESHOLD_TRIGGER_SCHEMA
+
+
+TRIGGERS: dict[str, type[Trigger]] = {
+    "changed": TemperatureChangedTrigger,
+    "crossed_threshold": TemperatureCrossedThresholdTrigger,
+}
+
+
+async def async_get_triggers(hass: HomeAssistant) -> dict[str, type[Trigger]]:
+    """Return the triggers for temperature."""
+    return TRIGGERS

homeassistant/components/temperature/triggers.yaml

@@ -0,0 +1,75 @@
+.trigger_common_fields:
+  behavior: &trigger_behavior
+    required: true
+    default: any
+    selector:
+      select:
+        translation_key: trigger_behavior
+        options:
+          - first
+          - last
+          - any
+
+.number_or_entity: &number_or_entity
+  required: false
+  selector:
+    choose:
+      choices:
+        number:
+          selector:
+            number:
+              mode: box
+        entity:
+          selector:
+            entity:
+              filter:
+                domain:
+                  - input_number
+                  - number
+                  - sensor
+      translation_key: number_or_entity
+
+.trigger_threshold_type: &trigger_threshold_type
+  required: true
+  default: above
+  selector:
+    select:
+      options:
+        - above
+        - below
+        - between
+        - outside
+      translation_key: trigger_threshold_type
+
+.trigger_unit: &trigger_unit
+  required: false
+  selector:
+    select:
+      options:
+        - celsius
+        - fahrenheit
+      translation_key: trigger_temperature_unit
+
+.trigger_target: &trigger_target
+  entity:
+    - domain: sensor
+      device_class: temperature
+    - domain: climate
+    - domain: water_heater
+    - domain: weather
+
+changed:
+  target: *trigger_target
+  fields:
+    above: *number_or_entity
+    below: *number_or_entity
+    unit: *trigger_unit
+
+crossed_threshold:
+  target: *trigger_target
+  fields:
+    behavior: *trigger_behavior
+    threshold_type: *trigger_threshold_type
+    lower_limit: *number_or_entity
+    upper_limit: *number_or_entity
+    unit: *trigger_unit

script/hassfest/manifest.py

@@ -120,6 +120,7 @@ NO_IOT_CLASS = [
     "system_health",
     "system_log",
     "tag",
+    "temperature",
     "timer",
     "trace",
     "web_rtc",

script/hassfest/quality_scale.py

@@ -2149,6 +2149,7 @@ NO_QUALITY_SCALE = [
     "system_health",
     "system_log",
     "tag",
+    "temperature",
     "timer",
     "trace",
     "usage_prediction",

tests/components/temperature/__init__.py

@@ -0,0 +1 @@
+"""Tests for the temperature integration."""

tests/components/temperature/test_trigger.py

@@ -0,0 +1,892 @@
+"""Test temperature trigger."""
+
+from typing import Any
+
+import pytest
+
+from homeassistant.components.climate import (
+    ATTR_CURRENT_TEMPERATURE as CLIMATE_ATTR_CURRENT_TEMPERATURE,
+    HVACMode,
+)
+from homeassistant.components.water_heater import (
+    ATTR_CURRENT_TEMPERATURE as WATER_HEATER_ATTR_CURRENT_TEMPERATURE,
+)
+from homeassistant.components.weather import (
+    ATTR_WEATHER_TEMPERATURE,
+    ATTR_WEATHER_TEMPERATURE_UNIT,
+)
+from homeassistant.const import (
+    ATTR_DEVICE_CLASS,
+    ATTR_UNIT_OF_MEASUREMENT,
+    CONF_ENTITY_ID,
+    UnitOfTemperature,
+)
+from homeassistant.core import HomeAssistant, ServiceCall
+
+from tests.components.common import (
+    TriggerStateDescription,
+    arm_trigger,
+    assert_trigger_behavior_any,
+    assert_trigger_behavior_first,
+    assert_trigger_behavior_last,
+    assert_trigger_gated_by_labs_flag,
+    parametrize_numerical_attribute_changed_trigger_states,
+    parametrize_numerical_attribute_crossed_threshold_trigger_states,
+    parametrize_numerical_state_value_changed_trigger_states,
+    parametrize_numerical_state_value_crossed_threshold_trigger_states,
+    parametrize_target_entities,
+    target_entities,
+)
+
+
+@pytest.fixture
+async def target_sensors(hass: HomeAssistant) -> dict[str, list[str]]:
+    """Create multiple sensor entities associated with different targets."""
+    return await target_entities(hass, "sensor")
+
+
+@pytest.fixture
+async def target_climates(hass: HomeAssistant) -> dict[str, list[str]]:
+    """Create multiple climate entities associated with different targets."""
+    return await target_entities(hass, "climate")
+
+
+@pytest.fixture
+async def target_water_heaters(hass: HomeAssistant) -> dict[str, list[str]]:
+    """Create multiple water_heater entities associated with different targets."""
+    return await target_entities(hass, "water_heater")
+
+
+@pytest.fixture
+async def target_weathers(hass: HomeAssistant) -> dict[str, list[str]]:
+    """Create multiple weather entities associated with different targets."""
+    return await target_entities(hass, "weather")
+
+
+@pytest.mark.parametrize(
+    "trigger_key",
+    [
+        "temperature.changed",
+        "temperature.crossed_threshold",
+    ],
+)
+async def test_temperature_triggers_gated_by_labs_flag(
+    hass: HomeAssistant, caplog: pytest.LogCaptureFixture, trigger_key: str
+) -> None:
+    """Test the temperature triggers are gated by the labs flag."""
+    await assert_trigger_gated_by_labs_flag(hass, caplog, trigger_key)
+
+
+# --- Sensor domain tests (value in state.state) ---
+
+
+@pytest.mark.usefixtures("enable_labs_preview_features")
+@pytest.mark.parametrize(
+    ("trigger_target_config", "entity_id", "entities_in_target"),
+    parametrize_target_entities("sensor"),
+)
+@pytest.mark.parametrize(
+    ("trigger", "trigger_options", "states"),
+    [
+        *parametrize_numerical_state_value_changed_trigger_states(
+            "temperature.changed", "temperature"
+        ),
+        *parametrize_numerical_state_value_crossed_threshold_trigger_states(
+            "temperature.crossed_threshold", "temperature"
+        ),
+    ],
+)
+async def test_temperature_trigger_sensor_behavior_any(
+    hass: HomeAssistant,
+    service_calls: list[ServiceCall],
+    target_sensors: dict[str, list[str]],
+    trigger_target_config: dict,
+    entity_id: str,
+    entities_in_target: int,
+    trigger: str,
+    trigger_options: dict[str, Any],
+    states: list[TriggerStateDescription],
+) -> None:
+    """Test temperature trigger fires for sensor entities with device_class temperature."""
+    await assert_trigger_behavior_any(
+        hass,
+        service_calls=service_calls,
+        target_entities=target_sensors,
+        trigger_target_config=trigger_target_config,
+        entity_id=entity_id,
+        entities_in_target=entities_in_target,
+        trigger=trigger,
+        trigger_options=trigger_options,
+        states=states,
+    )
+
+
+@pytest.mark.usefixtures("enable_labs_preview_features")
+@pytest.mark.parametrize(
+    ("trigger_target_config", "entity_id", "entities_in_target"),
+    parametrize_target_entities("sensor"),
+)
+@pytest.mark.parametrize(
+    ("trigger", "trigger_options", "states"),
+    [
+        *parametrize_numerical_state_value_crossed_threshold_trigger_states(
+            "temperature.crossed_threshold", "temperature"
+        ),
+    ],
+)
+async def test_temperature_trigger_sensor_crossed_threshold_behavior_first(
+    hass: HomeAssistant,
+    service_calls: list[ServiceCall],
+    target_sensors: dict[str, list[str]],
+    trigger_target_config: dict,
+    entity_id: str,
+    entities_in_target: int,
+    trigger: str,
+    trigger_options: dict[str, Any],
+    states: list[TriggerStateDescription],
+) -> None:
+    """Test temperature crossed_threshold trigger fires on the first sensor state change."""
+    await assert_trigger_behavior_first(
+        hass,
+        service_calls=service_calls,
+        target_entities=target_sensors,
+        trigger_target_config=trigger_target_config,
+        entity_id=entity_id,
+        entities_in_target=entities_in_target,
+        trigger=trigger,
+        trigger_options=trigger_options,
+        states=states,
+    )
+
+
+@pytest.mark.usefixtures("enable_labs_preview_features")
+@pytest.mark.parametrize(
+    ("trigger_target_config", "entity_id", "entities_in_target"),
+    parametrize_target_entities("sensor"),
+)
+@pytest.mark.parametrize(
+    ("trigger", "trigger_options", "states"),
+    [
+        *parametrize_numerical_state_value_crossed_threshold_trigger_states(
+            "temperature.crossed_threshold", "temperature"
+        ),
+    ],
+)
+async def test_temperature_trigger_sensor_crossed_threshold_behavior_last(
+    hass: HomeAssistant,
+    service_calls: list[ServiceCall],
+    target_sensors: dict[str, list[str]],
+    trigger_target_config: dict,
+    entity_id: str,
+    entities_in_target: int,
+    trigger: str,
+    trigger_options: dict[str, Any],
+    states: list[TriggerStateDescription],
+) -> None:
+    """Test temperature crossed_threshold trigger fires when the last sensor changes state."""
+    await assert_trigger_behavior_last(
+        hass,
+        service_calls=service_calls,
+        target_entities=target_sensors,
+        trigger_target_config=trigger_target_config,
+        entity_id=entity_id,
+        entities_in_target=entities_in_target,
+        trigger=trigger,
+        trigger_options=trigger_options,
+        states=states,
+    )
+
+
+# --- Climate domain tests (value in current_temperature attribute) ---
+
+
+@pytest.mark.usefixtures("enable_labs_preview_features")
+@pytest.mark.parametrize(
+    ("trigger_target_config", "entity_id", "entities_in_target"),
+    parametrize_target_entities("climate"),
+)
+@pytest.mark.parametrize(
+    ("trigger", "trigger_options", "states"),
+    [
+        *parametrize_numerical_attribute_changed_trigger_states(
+            "temperature.changed", HVACMode.AUTO, CLIMATE_ATTR_CURRENT_TEMPERATURE
+        ),
+        *parametrize_numerical_attribute_crossed_threshold_trigger_states(
+            "temperature.crossed_threshold",
+            HVACMode.AUTO,
+            CLIMATE_ATTR_CURRENT_TEMPERATURE,
+        ),
+    ],
+)
+async def test_temperature_trigger_climate_behavior_any(
+    hass: HomeAssistant,
+    service_calls: list[ServiceCall],
+    target_climates: dict[str, list[str]],
+    trigger_target_config: dict,
+    entity_id: str,
+    entities_in_target: int,
+    trigger: str,
+    trigger_options: dict[str, Any],
+    states: list[TriggerStateDescription],
+) -> None:
+    """Test temperature trigger fires for climate entities."""
+    await assert_trigger_behavior_any(
+        hass,
+        service_calls=service_calls,
+        target_entities=target_climates,
+        trigger_target_config=trigger_target_config,
+        entity_id=entity_id,
+        entities_in_target=entities_in_target,
+        trigger=trigger,
+        trigger_options=trigger_options,
+        states=states,
+    )
+
+
+@pytest.mark.usefixtures("enable_labs_preview_features")
+@pytest.mark.parametrize(
+    ("trigger_target_config", "entity_id", "entities_in_target"),
+    parametrize_target_entities("climate"),
+)
+@pytest.mark.parametrize(
+    ("trigger", "trigger_options", "states"),
+    [
+        *parametrize_numerical_attribute_crossed_threshold_trigger_states(
+            "temperature.crossed_threshold",
+            HVACMode.AUTO,
+            CLIMATE_ATTR_CURRENT_TEMPERATURE,
+        ),
+    ],
+)
+async def test_temperature_trigger_climate_crossed_threshold_behavior_first(
+    hass: HomeAssistant,
+    service_calls: list[ServiceCall],
+    target_climates: dict[str, list[str]],
+    trigger_target_config: dict,
+    entity_id: str,
+    entities_in_target: int,
+    trigger: str,
+    trigger_options: dict[str, Any],
+    states: list[TriggerStateDescription],
+) -> None:
+    """Test temperature crossed_threshold trigger fires on the first climate state change."""
+    await assert_trigger_behavior_first(
+        hass,
+        service_calls=service_calls,
+        target_entities=target_climates,
+        trigger_target_config=trigger_target_config,
+        entity_id=entity_id,
+        entities_in_target=entities_in_target,
+        trigger=trigger,
+        trigger_options=trigger_options,
+        states=states,
+    )
+
+
+@pytest.mark.usefixtures("enable_labs_preview_features")
+@pytest.mark.parametrize(
+    ("trigger_target_config", "entity_id", "entities_in_target"),
+    parametrize_target_entities("climate"),
+)
+@pytest.mark.parametrize(
+    ("trigger", "trigger_options", "states"),
+    [
+        *parametrize_numerical_attribute_crossed_threshold_trigger_states(
+            "temperature.crossed_threshold",
+            HVACMode.AUTO,
+            CLIMATE_ATTR_CURRENT_TEMPERATURE,
+        ),
+    ],
+)
+async def test_temperature_trigger_climate_crossed_threshold_behavior_last(
+    hass: HomeAssistant,
+    service_calls: list[ServiceCall],
+    target_climates: dict[str, list[str]],
+    trigger_target_config: dict,
+    entity_id: str,
+    entities_in_target: int,
+    trigger: str,
+    trigger_options: dict[str, Any],
+    states: list[TriggerStateDescription],
+) -> None:
+    """Test temperature crossed_threshold trigger fires when the last climate changes state."""
+    await assert_trigger_behavior_last(
+        hass,
+        service_calls=service_calls,
+        target_entities=target_climates,
+        trigger_target_config=trigger_target_config,
+        entity_id=entity_id,
+        entities_in_target=entities_in_target,
+        trigger=trigger,
+        trigger_options=trigger_options,
+        states=states,
+    )
+
+
+# --- Water heater domain tests (value in current_temperature attribute) ---
+
+
+@pytest.mark.usefixtures("enable_labs_preview_features")
+@pytest.mark.parametrize(
+    ("trigger_target_config", "entity_id", "entities_in_target"),
+    parametrize_target_entities("water_heater"),
+)
+@pytest.mark.parametrize(
+    ("trigger", "trigger_options", "states"),
+    [
+        *parametrize_numerical_attribute_changed_trigger_states(
+            "temperature.changed",
+            "eco",
+            WATER_HEATER_ATTR_CURRENT_TEMPERATURE,
+        ),
+        *parametrize_numerical_attribute_crossed_threshold_trigger_states(
+            "temperature.crossed_threshold",
+            "eco",
+            WATER_HEATER_ATTR_CURRENT_TEMPERATURE,
+        ),
+    ],
+)
+async def test_temperature_trigger_water_heater_behavior_any(
+    hass: HomeAssistant,
+    service_calls: list[ServiceCall],
+    target_water_heaters: dict[str, list[str]],
+    trigger_target_config: dict,
+    entity_id: str,
+    entities_in_target: int,
+    trigger: str,
+    trigger_options: dict[str, Any],
+    states: list[TriggerStateDescription],
+) -> None:
+    """Test temperature trigger fires for water_heater entities."""
+    await assert_trigger_behavior_any(
+        hass,
+        service_calls=service_calls,
+        target_entities=target_water_heaters,
+        trigger_target_config=trigger_target_config,
+        entity_id=entity_id,
+        entities_in_target=entities_in_target,
+        trigger=trigger,
+        trigger_options=trigger_options,
+        states=states,
+    )
+
+
+@pytest.mark.usefixtures("enable_labs_preview_features")
+@pytest.mark.parametrize(
+    ("trigger_target_config", "entity_id", "entities_in_target"),
+    parametrize_target_entities("water_heater"),
+)
+@pytest.mark.parametrize(
+    ("trigger", "trigger_options", "states"),
+    [
+        *parametrize_numerical_attribute_crossed_threshold_trigger_states(
+            "temperature.crossed_threshold",
+            "eco",
+            WATER_HEATER_ATTR_CURRENT_TEMPERATURE,
+        ),
+    ],
+)
+async def test_temperature_trigger_water_heater_crossed_threshold_behavior_first(
+    hass: HomeAssistant,
+    service_calls: list[ServiceCall],
+    target_water_heaters: dict[str, list[str]],
+    trigger_target_config: dict,
+    entity_id: str,
+    entities_in_target: int,
+    trigger: str,
+    trigger_options: dict[str, Any],
+    states: list[TriggerStateDescription],
+) -> None:
+    """Test temperature crossed_threshold trigger fires on the first water_heater state change."""
+    await assert_trigger_behavior_first(
+        hass,
+        service_calls=service_calls,
+        target_entities=target_water_heaters,
+        trigger_target_config=trigger_target_config,
+        entity_id=entity_id,
+        entities_in_target=entities_in_target,
+        trigger=trigger,
+        trigger_options=trigger_options,
+        states=states,
+    )
+
+
+@pytest.mark.usefixtures("enable_labs_preview_features")
+@pytest.mark.parametrize(
+    ("trigger_target_config", "entity_id", "entities_in_target"),
+    parametrize_target_entities("water_heater"),
+)
+@pytest.mark.parametrize(
+    ("trigger", "trigger_options", "states"),
+    [
+        *parametrize_numerical_attribute_crossed_threshold_trigger_states(
+            "temperature.crossed_threshold",
+            "eco",
+            WATER_HEATER_ATTR_CURRENT_TEMPERATURE,
+        ),
+    ],
+)
+async def test_temperature_trigger_water_heater_crossed_threshold_behavior_last(
+    hass: HomeAssistant,
+    service_calls: list[ServiceCall],
+    target_water_heaters: dict[str, list[str]],
+    trigger_target_config: dict,
+    entity_id: str,
+    entities_in_target: int,
+    trigger: str,
+    trigger_options: dict[str, Any],
+    states: list[TriggerStateDescription],
+) -> None:
+    """Test temperature crossed_threshold trigger fires when the last water_heater changes state."""
+    await assert_trigger_behavior_last(
+        hass,
+        service_calls=service_calls,
+        target_entities=target_water_heaters,
+        trigger_target_config=trigger_target_config,
+        entity_id=entity_id,
+        entities_in_target=entities_in_target,
+        trigger=trigger,
+        trigger_options=trigger_options,
+        states=states,
+    )
+
+
+# --- Weather domain tests (value in temperature attribute) ---
+
+
+@pytest.mark.usefixtures("enable_labs_preview_features")
+@pytest.mark.parametrize(
+    ("trigger_target_config", "entity_id", "entities_in_target"),
+    parametrize_target_entities("weather"),
+)
+@pytest.mark.parametrize(
+    ("trigger", "trigger_options", "states"),
+    [
+        *parametrize_numerical_attribute_changed_trigger_states(
+            "temperature.changed", "sunny", ATTR_WEATHER_TEMPERATURE
+        ),
+        *parametrize_numerical_attribute_crossed_threshold_trigger_states(
+            "temperature.crossed_threshold",
+            "sunny",
+            ATTR_WEATHER_TEMPERATURE,
+        ),
+    ],
+)
+async def test_temperature_trigger_weather_behavior_any(
+    hass: HomeAssistant,
+    service_calls: list[ServiceCall],
+    target_weathers: dict[str, list[str]],
+    trigger_target_config: dict,
+    entity_id: str,
+    entities_in_target: int,
+    trigger: str,
+    trigger_options: dict[str, Any],
+    states: list[TriggerStateDescription],
+) -> None:
+    """Test temperature trigger fires for weather entities."""
+    await assert_trigger_behavior_any(
+        hass,
+        service_calls=service_calls,
+        target_entities=target_weathers,
+        trigger_target_config=trigger_target_config,
+        entity_id=entity_id,
+        entities_in_target=entities_in_target,
+        trigger=trigger,
+        trigger_options=trigger_options,
+        states=states,
+    )
+
+
+@pytest.mark.usefixtures("enable_labs_preview_features")
+@pytest.mark.parametrize(
+    ("trigger_target_config", "entity_id", "entities_in_target"),
+    parametrize_target_entities("weather"),
+)
+@pytest.mark.parametrize(
+    ("trigger", "trigger_options", "states"),
+    [
+        *parametrize_numerical_attribute_crossed_threshold_trigger_states(
+            "temperature.crossed_threshold",
+            "sunny",
+            ATTR_WEATHER_TEMPERATURE,
+        ),
+    ],
+)
+async def test_temperature_trigger_weather_crossed_threshold_behavior_first(
+    hass: HomeAssistant,
+    service_calls: list[ServiceCall],
+    target_weathers: dict[str, list[str]],
+    trigger_target_config: dict,
+    entity_id: str,
+    entities_in_target: int,
+    trigger: str,
+    trigger_options: dict[str, Any],
+    states: list[TriggerStateDescription],
+) -> None:
+    """Test temperature crossed_threshold trigger fires on the first weather state change."""
+    await assert_trigger_behavior_first(
+        hass,
+        service_calls=service_calls,
+        target_entities=target_weathers,
+        trigger_target_config=trigger_target_config,
+        entity_id=entity_id,
+        entities_in_target=entities_in_target,
+        trigger=trigger,
+        trigger_options=trigger_options,
+        states=states,
+    )
+
+
+@pytest.mark.usefixtures("enable_labs_preview_features")
+@pytest.mark.parametrize(
+    ("trigger_target_config", "entity_id", "entities_in_target"),
+    parametrize_target_entities("weather"),
+)
+@pytest.mark.parametrize(
+    ("trigger", "trigger_options", "states"),
+    [
+        *parametrize_numerical_attribute_crossed_threshold_trigger_states(
+            "temperature.crossed_threshold",
+            "sunny",
+            ATTR_WEATHER_TEMPERATURE,
+        ),
+    ],
+)
+async def test_temperature_trigger_weather_crossed_threshold_behavior_last(
+    hass: HomeAssistant,
+    service_calls: list[ServiceCall],
+    target_weathers: dict[str, list[str]],
+    trigger_target_config: dict,
+    entity_id: str,
+    entities_in_target: int,
+    trigger: str,
+    trigger_options: dict[str, Any],
+    states: list[TriggerStateDescription],
+) -> None:
+    """Test temperature crossed_threshold trigger fires when the last weather changes state."""
+    await assert_trigger_behavior_last(
+        hass,
+        service_calls=service_calls,
+        target_entities=target_weathers,
+        trigger_target_config=trigger_target_config,
+        entity_id=entity_id,
+        entities_in_target=entities_in_target,
+        trigger=trigger,
+        trigger_options=trigger_options,
+        states=states,
+    )
+
+
+# --- Device class exclusion test ---
+
+
+@pytest.mark.usefixtures("enable_labs_preview_features")
+@pytest.mark.parametrize(
+    (
+        "trigger_key",
+        "trigger_options",
+        "sensor_initial",
+        "sensor_target",
+    ),
+    [
+        (
+            "temperature.changed",
+            {},
+            "20",
+            "25",
+        ),
+        (
+            "temperature.crossed_threshold",
+            {"threshold_type": "above", "lower_limit": 10},
+            "5",
+            "20",
+        ),
+    ],
+)
+async def test_temperature_trigger_excludes_non_temperature_sensor(
+    hass: HomeAssistant,
+    service_calls: list[ServiceCall],
+    trigger_key: str,
+    trigger_options: dict[str, Any],
+    sensor_initial: str,
+    sensor_target: str,
+) -> None:
+    """Test temperature trigger does not fire for sensor entities without device_class temperature."""
+    entity_id_temperature = "sensor.test_temperature"
+    entity_id_humidity = "sensor.test_humidity"
+
+    # Set initial states
+    hass.states.async_set(
+        entity_id_temperature, sensor_initial, {ATTR_DEVICE_CLASS: "temperature"}
+    )
+    hass.states.async_set(
+        entity_id_humidity, sensor_initial, {ATTR_DEVICE_CLASS: "humidity"}
+    )
+    await hass.async_block_till_done()
+
+    await arm_trigger(
+        hass,
+        trigger_key,
+        trigger_options,
+        {
+            CONF_ENTITY_ID: [
+                entity_id_temperature,
+                entity_id_humidity,
+            ]
+        },
+    )
+
+    # Temperature sensor changes - should trigger
+    hass.states.async_set(
+        entity_id_temperature, sensor_target, {ATTR_DEVICE_CLASS: "temperature"}
+    )
+    await hass.async_block_till_done()
+    assert len(service_calls) == 1
+    assert service_calls[0].data[CONF_ENTITY_ID] == entity_id_temperature
+    service_calls.clear()
+
+    # Humidity sensor changes - should NOT trigger (wrong device class)
+    hass.states.async_set(
+        entity_id_humidity, sensor_target, {ATTR_DEVICE_CLASS: "humidity"}
+    )
+    await hass.async_block_till_done()
+    assert len(service_calls) == 0
+
+
+# --- Unit conversion tests ---
+
+
+@pytest.mark.usefixtures("enable_labs_preview_features")
+async def test_temperature_trigger_unit_conversion_sensor_celsius_to_fahrenheit(
+    hass: HomeAssistant,
+    service_calls: list[ServiceCall],
+) -> None:
+    """Test temperature trigger converts sensor value from °C to °F for threshold comparison."""
+    entity_id = "sensor.test_temp"
+
+    # Sensor reports in °C, trigger configured in °F with threshold above 70°F
+    hass.states.async_set(
+        entity_id,
+        "20",
+        {
+            ATTR_DEVICE_CLASS: "temperature",
+            ATTR_UNIT_OF_MEASUREMENT: UnitOfTemperature.CELSIUS,
+        },
+    )
+    await hass.async_block_till_done()
+
+    await arm_trigger(
+        hass,
+        "temperature.crossed_threshold",
+        {
+            "threshold_type": "above",
+            "lower_limit": 70,
+            "unit": "fahrenheit",
+        },
+        {CONF_ENTITY_ID: [entity_id]},
+    )
+
+    # 20°C = 68°F, which is below 70°F - should NOT trigger
+    hass.states.async_set(
+        entity_id,
+        "20",
+        {
+            ATTR_DEVICE_CLASS: "temperature",
+            ATTR_UNIT_OF_MEASUREMENT: UnitOfTemperature.CELSIUS,
+        },
+    )
+    await hass.async_block_till_done()
+    assert len(service_calls) == 0
+
+    # 22°C = 71.6°F, which is above 70°F - should trigger
+    hass.states.async_set(
+        entity_id,
+        "22",
+        {
+            ATTR_DEVICE_CLASS: "temperature",
+            ATTR_UNIT_OF_MEASUREMENT: UnitOfTemperature.CELSIUS,
+        },
+    )
+    await hass.async_block_till_done()
+    assert len(service_calls) == 1
+    service_calls.clear()
+
+
+@pytest.mark.usefixtures("enable_labs_preview_features")
+async def test_temperature_trigger_unit_conversion_sensor_fahrenheit_to_celsius(
+    hass: HomeAssistant,
+    service_calls: list[ServiceCall],
+) -> None:
+    """Test temperature trigger converts sensor value from °F to °C for threshold comparison."""
+    entity_id = "sensor.test_temp"
+
+    # Sensor reports in °F, trigger configured in °C with threshold above 25°C
+    hass.states.async_set(
+        entity_id,
+        "70",
+        {
+            ATTR_DEVICE_CLASS: "temperature",
+            ATTR_UNIT_OF_MEASUREMENT: UnitOfTemperature.FAHRENHEIT,
+        },
+    )
+    await hass.async_block_till_done()
+
+    await arm_trigger(
+        hass,
+        "temperature.crossed_threshold",
+        {
+            "threshold_type": "above",
+            "lower_limit": 25,
+            "unit": "celsius",
+        },
+        {CONF_ENTITY_ID: [entity_id]},
+    )
+
+    # 70°F = 21.1°C, which is below 25°C - should NOT trigger
+    hass.states.async_set(
+        entity_id,
+        "70",
+        {
+            ATTR_DEVICE_CLASS: "temperature",
+            ATTR_UNIT_OF_MEASUREMENT: UnitOfTemperature.FAHRENHEIT,
+        },
+    )
+    await hass.async_block_till_done()
+    assert len(service_calls) == 0
+
+    # 80°F = 26.7°C, which is above 25°C - should trigger
+    hass.states.async_set(
+        entity_id,
+        "80",
+        {
+            ATTR_DEVICE_CLASS: "temperature",
+            ATTR_UNIT_OF_MEASUREMENT: UnitOfTemperature.FAHRENHEIT,
+        },
+    )
+    await hass.async_block_till_done()
+    assert len(service_calls) == 1
+    service_calls.clear()
+
+
+@pytest.mark.usefixtures("enable_labs_preview_features")
+async def test_temperature_trigger_unit_conversion_changed(
+    hass: HomeAssistant,
+    service_calls: list[ServiceCall],
+) -> None:
+    """Test temperature changed trigger with unit conversion and above/below limits."""
+    entity_id = "sensor.test_temp"
+
+    # Sensor reports in °C, trigger configured in °F: above 68°F (20°C), below 77°F (25°C)
+    hass.states.async_set(
+        entity_id,
+        "18",
+        {
+            ATTR_DEVICE_CLASS: "temperature",
+            ATTR_UNIT_OF_MEASUREMENT: UnitOfTemperature.CELSIUS,
+        },
+    )
+    await hass.async_block_till_done()
+
+    await arm_trigger(
+        hass,
+        "temperature.changed",
+        {
+            "above": 68,
+            "below": 77,
+            "unit": "fahrenheit",
+        },
+        {CONF_ENTITY_ID: [entity_id]},
+    )
+
+    # 18°C = 64.4°F, below 68°F - should NOT trigger
+    hass.states.async_set(
+        entity_id,
+        "19",
+        {
+            ATTR_DEVICE_CLASS: "temperature",
+            ATTR_UNIT_OF_MEASUREMENT: UnitOfTemperature.CELSIUS,
+        },
+    )
+    await hass.async_block_till_done()
+    assert len(service_calls) == 0
+
+    # 22°C = 71.6°F, between 68°F and 77°F - should trigger
+    hass.states.async_set(
+        entity_id,
+        "22",
+        {
+            ATTR_DEVICE_CLASS: "temperature",
+            ATTR_UNIT_OF_MEASUREMENT: UnitOfTemperature.CELSIUS,
+        },
+    )
+    await hass.async_block_till_done()
+    assert len(service_calls) == 1
+    service_calls.clear()
+
+    # 26°C = 78.8°F, above 77°F - should NOT trigger
+    hass.states.async_set(
+        entity_id,
+        "26",
+        {
+            ATTR_DEVICE_CLASS: "temperature",
+            ATTR_UNIT_OF_MEASUREMENT: UnitOfTemperature.CELSIUS,
+        },
+    )
+    await hass.async_block_till_done()
+    assert len(service_calls) == 0
+
+
+@pytest.mark.usefixtures("enable_labs_preview_features")
+async def test_temperature_trigger_unit_conversion_weather(
+    hass: HomeAssistant,
+    service_calls: list[ServiceCall],
+) -> None:
+    """Test temperature trigger with unit conversion for weather entities."""
+    entity_id = "weather.test"
+
+    # Weather reports temperature in °F, trigger configured in °C with threshold above 25°C
+    hass.states.async_set(
+        entity_id,
+        "sunny",
+        {
+            ATTR_WEATHER_TEMPERATURE: 70,
+            ATTR_WEATHER_TEMPERATURE_UNIT: UnitOfTemperature.FAHRENHEIT,
+        },
+    )
+    await hass.async_block_till_done()
+
+    await arm_trigger(
+        hass,
+        "temperature.crossed_threshold",
+        {
+            "threshold_type": "above",
+            "lower_limit": 25,
+            "unit": "celsius",
+        },
+        {CONF_ENTITY_ID: [entity_id]},
+    )
+
+    # 70°F = 21.1°C, below 25°C - should NOT trigger
+    hass.states.async_set(
+        entity_id,
+        "sunny",
+        {
+            ATTR_WEATHER_TEMPERATURE: 70,
+            ATTR_WEATHER_TEMPERATURE_UNIT: UnitOfTemperature.FAHRENHEIT,
+        },
+    )
+    await hass.async_block_till_done()
+    assert len(service_calls) == 0
+
+    # 80°F = 26.7°C, above 25°C - should trigger
+    hass.states.async_set(
+        entity_id,
+        "sunny",
+        {
+            ATTR_WEATHER_TEMPERATURE: 80,
+            ATTR_WEATHER_TEMPERATURE_UNIT: UnitOfTemperature.FAHRENHEIT,
+        },
+    )
+    await hass.async_block_till_done()
+    assert len(service_calls) == 1
+    service_calls.clear()

tests/snapshots/test_bootstrap.ambr

@@ -86,6 +86,7 @@
     'system_health',
     'system_log',
     'tag',
+    'temperature',
     'text',
     'time',
     'timer',
@@ -190,6 +191,7 @@
     'system_health',
     'system_log',
     'tag',
+    'temperature',
     'text',
     'time',
     'timer',