Add override decorator to components F to G

2026-05-27 19:25:18 +02:00 · 2026-05-25 11:35:45 +01:00
1192 changed files with 8907 additions and 51800 deletions
@@ -1,52 +0,0 @@
-name: Cache and install APT packages
-description: >-
-  Wraps awalsh128/cache-apt-pkgs-action with the workarounds Home Assistant CI
-  needs. Removes the conflicting Microsoft apt source before any apt run, and
-  points the dynamic linker at the host's multiarch lib subdirectories so
-  shared libraries that rely on update-alternatives or postinst-managed paths
-  (eg libblas, liblapack pulled in by ffmpeg) stay reachable since the upstream
-  action does not execute postinst scripts on cache restore.
-
-inputs:
-  packages:
-    description: Space-delimited list of apt packages to install.
-    required: true
-  version:
-    description: Cache version. Bump to invalidate the cache.
-    required: false
-    default: "1"
-  execute_install_scripts:
-    description: >-
-      Pass-through to awalsh128/cache-apt-pkgs-action. Postinst scripts are not
-      actually cached by the upstream action, so this is largely a no-op today.
-    required: false
-    default: "false"
-
-runs:
-  using: composite
-  steps:
-    - name: Remove conflicting Microsoft apt source
-      shell: bash
-      run: sudo rm -f /etc/apt/sources.list.d/microsoft-prod.list
-    - name: Install apt packages via cache
-      uses: awalsh128/cache-apt-pkgs-action@acb598e5ddbc6f68a970c5da0688d2f3a9f04d05 # v1.5.3
-      with:
-        packages: ${{ inputs.packages }}
-        version: ${{ inputs.version }}
-        execute_install_scripts: ${{ inputs.execute_install_scripts }}
-    - name: Refresh dynamic linker cache
-      shell: bash
-      run: |
-        # awalsh128/cache-apt-pkgs-action does not run postinst scripts on
-        # cache restore, so update-alternatives symlinks (eg the one libblas
-        # creates at /usr/lib/<multiarch>/libblas.so.3) are never produced.
-        # Add every /usr/lib/<multiarch> subdirectory that holds shared
-        # libraries to the ldconfig search path so the dynamic linker still
-        # finds them.  Use dpkg-architecture to derive the host's multiarch
-        # tuple so this works on non-x86_64 runners too.
-        multiarch="$(dpkg-architecture -qDEB_HOST_MULTIARCH)"
-        find "/usr/lib/${multiarch}" -mindepth 2 -maxdepth 2 \
-          -name '*.so.*' -printf '%h\n' \
-          | sort -u \
-          | sudo tee /etc/ld.so.conf.d/zzz-cache-apt-extras.conf > /dev/null
-        sudo ldconfig
@@ -43,7 +43,6 @@ This repository contains the core of Home Assistant, a Python 3 based home autom
 - Avoid using conditions/branching in tests. Instead, either split tests or adjust the test parametrization to cover all cases without branching.
 - If multiple tests share most of their code, use `pytest.mark.parametrize` to merge them into a single parameterized test instead of duplicating the body. Use `pytest.param` with an `id` parameter to name the test cases clearly.
 - We use Syrupy for snapshot testing. Leverage `.ambr` snapshots instead of repetitive and exhaustive generation of test data within Python code itself.
- Hardcoded `entity_id`s in tests are fine. If the same one is repeated, use a constant.

 ## Good practices

@@ -60,7 +60,9 @@ env:
  # - 15.2 is the latest (as of 9 Feb 2023)
  POSTGRESQL_VERSIONS: "['postgres:12.14','postgres:15.2']"
  UV_CACHE_DIR: /tmp/uv-cache
-  APT_CACHE_VERSION: 1
+  APT_CACHE_BASE: /home/runner/work/apt
+  APT_CACHE_DIR: /home/runner/work/apt/cache
+  APT_LIST_CACHE_DIR: /home/runner/work/apt/lists
  SQLALCHEMY_WARN_20: 1
  PYTHONASYNCIODEBUG: 1
  HASS_CI: 1
@@ -84,6 +86,7 @@ jobs:
      core: ${{ steps.core.outputs.changes }}
      integrations_glob: ${{ steps.info.outputs.integrations_glob }}
      integrations: ${{ steps.integrations.outputs.changes }}
+      apt_cache_key: ${{ steps.generate_apt_cache_key.outputs.key }}
      python_cache_key: ${{ steps.generate_python_cache_key.outputs.key }}
      requirements: ${{ steps.core.outputs.requirements }}
      mariadb_groups: ${{ steps.info.outputs.mariadb_groups }}
@@ -113,6 +116,10 @@ jobs:
          # Include HA_SHORT_VERSION to force the immediate creation
          # of a new uv cache entry after a version bump.
          echo "key=venv-${CACHE_VERSION}-${HA_SHORT_VERSION}-${HASH_REQUIREMENTS_TEST}-${HASH_REQUIREMENTS}-${HASH_REQUIREMENTS_ALL}-${HASH_PACKAGE_CONSTRAINTS}-${HASH_GEN_REQUIREMENTS}" >> $GITHUB_OUTPUT
+      - name: Generate partial apt restore key
+        id: generate_apt_cache_key
+        run: |
+          echo "key=$(lsb_release -rs)-apt-${CACHE_VERSION}-${HA_SHORT_VERSION}" >> $GITHUB_OUTPUT
      - name: Filter for core changes
        uses: dorny/paths-filter@fbd0ab8f3e69293af611ebaee6363fc25e6d187d # v4.0.1
        id: core
@@ -377,36 +384,65 @@ jobs:
          path: ${{ env.UV_CACHE_DIR }}
          key: ${{ steps.generate-uv-key.outputs.full_key }}
          restore-keys: ${{ steps.generate-uv-key.outputs.partial_key }}
+      - name: Check if apt cache exists
+        id: cache-apt-check
+        uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        with:
+          lookup-only: ${{ steps.cache-venv.outputs.cache-hit == 'true' }}
+          path: |
+            ${{ env.APT_CACHE_DIR }}
+            ${{ env.APT_LIST_CACHE_DIR }}
+          key: >-
+            ${{ runner.os }}-${{ runner.arch }}-${{ needs.info.outputs.apt_cache_key }}
      - name: Install additional OS dependencies
-        if: steps.cache-venv.outputs.cache-hit != 'true'
+        if: |
+          steps.cache-venv.outputs.cache-hit != 'true'
+          || steps.cache-apt-check.outputs.cache-hit != 'true'
+        id: install-os-deps
        timeout-minutes: 10
-        uses: ./.github/actions/cache-apt-packages
-        with:
-          packages: >-
-            bluez
-            ffmpeg
-            libturbojpeg
-            libxml2-utils
-            libavcodec-dev
-            libavdevice-dev
-            libavfilter-dev
-            libavformat-dev
-            libavutil-dev
-            libswresample-dev
-            libswscale-dev
-            libudev-dev
-          version: ${{ env.APT_CACHE_VERSION }}
-          execute_install_scripts: true
-      - name: Read uv version from requirements.txt
-        if: steps.cache-venv.outputs.cache-hit != 'true'
-        id: read-uv-version
+        env:
+          APT_CACHE_HIT: ${{ steps.cache-apt-check.outputs.cache-hit }}
        run: |
-          echo "version=$(grep '^uv==' requirements.txt | cut -d'=' -f3)" >> "$GITHUB_OUTPUT"
-      - name: Set up uv
-        if: steps.cache-venv.outputs.cache-hit != 'true'
-        uses: astral-sh/setup-uv@08807647e7069bb48b6ef5acd8ec9567f424441b # v8.1.0
+          sudo rm /etc/apt/sources.list.d/microsoft-prod.list
+          if [[ "${APT_CACHE_HIT}" != 'true' ]]; then
+            mkdir -p ${APT_CACHE_DIR}
+            mkdir -p ${APT_LIST_CACHE_DIR}
+          fi
+
+          sudo apt-get update \
+            -o Dir::Cache=${APT_CACHE_DIR} \
+            -o Dir::State::Lists=${APT_LIST_CACHE_DIR}
+          sudo apt-get -y install \
+            -o Dir::Cache=${APT_CACHE_DIR} \
+            -o Dir::State::Lists=${APT_LIST_CACHE_DIR} \
+            bluez \
+            ffmpeg \
+            libturbojpeg \
+            libxml2-utils \
+            libavcodec-dev \
+            libavdevice-dev \
+            libavfilter-dev \
+            libavformat-dev \
+            libavutil-dev \
+            libswresample-dev \
+            libswscale-dev \
+            libudev-dev
+
+          if [[ "${APT_CACHE_HIT}" != 'true' ]]; then
+            sudo chmod -R 755 ${APT_CACHE_BASE}
+          fi
+      - name: Save apt cache
+        if: |
+          always()
+          && steps.cache-apt-check.outputs.cache-hit != 'true'
+          && steps.install-os-deps.outcome == 'success'
+        uses: actions/cache/save@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
        with:
-          version: ${{ steps.read-uv-version.outputs.version }}
+          path: |
+            ${{ env.APT_CACHE_DIR }}
+            ${{ env.APT_LIST_CACHE_DIR }}
+          key: >-
+            ${{ runner.os }}-${{ runner.arch }}-${{ needs.info.outputs.apt_cache_key }}
      - name: Create Python virtual environment
        if: steps.cache-venv.outputs.cache-hit != 'true'
        id: create-venv
@@ -414,6 +450,8 @@ jobs:
          python -m venv venv
          . venv/bin/activate
          python --version
+          pip install "$(grep '^uv' < requirements.txt)"
+          uv pip install -U "pip>=25.2"
          uv pip install -r requirements.txt
          uv pip install -r requirements_all.txt -r requirements_test.txt
          uv pip install -e . --config-settings editable_mode=compat
@@ -468,16 +506,30 @@ jobs:
      && github.event.inputs.mypy-only != 'true'
      && github.event.inputs.audit-licenses-only != 'true'
    steps:
+      - name: Restore apt cache
+        uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        with:
+          path: |
+            ${{ env.APT_CACHE_DIR }}
+            ${{ env.APT_LIST_CACHE_DIR }}
+          fail-on-cache-miss: true
+          key: >-
+            ${{ runner.os }}-${{ runner.arch }}-${{ needs.info.outputs.apt_cache_key }}
+      - name: Install additional OS dependencies
+        timeout-minutes: 10
+        run: |
+          sudo rm /etc/apt/sources.list.d/microsoft-prod.list
+          sudo apt-get update \
+            -o Dir::Cache=${APT_CACHE_DIR} \
+            -o Dir::State::Lists=${APT_LIST_CACHE_DIR}
+          sudo apt-get -y install \
+            -o Dir::Cache=${APT_CACHE_DIR} \
+            -o Dir::State::Lists=${APT_LIST_CACHE_DIR} \
+            libturbojpeg
      - name: Check out code from GitHub
        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
        with:
          persist-credentials: false
-      - name: Install additional OS dependencies
-        timeout-minutes: 10
-        uses: ./.github/actions/cache-apt-packages
-        with:
-          packages: libturbojpeg
-          version: ${{ env.APT_CACHE_VERSION }}
      - name: Set up Python
        id: python
        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
@@ -824,20 +876,32 @@ jobs:
      - info
      - base
    steps:
+      - name: Restore apt cache
+        uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        with:
+          path: |
+            ${{ env.APT_CACHE_DIR }}
+            ${{ env.APT_LIST_CACHE_DIR }}
+          fail-on-cache-miss: true
+          key: >-
+            ${{ runner.os }}-${{ runner.arch }}-${{ needs.info.outputs.apt_cache_key }}
+      - name: Install additional OS dependencies
+        timeout-minutes: 10
+        run: |
+          sudo rm /etc/apt/sources.list.d/microsoft-prod.list
+          sudo apt-get update \
+            -o Dir::Cache=${APT_CACHE_DIR} \
+            -o Dir::State::Lists=${APT_LIST_CACHE_DIR}
+          sudo apt-get -y install \
+            -o Dir::Cache=${APT_CACHE_DIR} \
+            -o Dir::State::Lists=${APT_LIST_CACHE_DIR} \
+            bluez \
+            ffmpeg \
+            libturbojpeg
      - name: Check out code from GitHub
        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
        with:
          persist-credentials: false
-      - name: Install additional OS dependencies
-        timeout-minutes: 10
-        uses: ./.github/actions/cache-apt-packages
-        with:
-          packages: >-
-            bluez
-            ffmpeg
-            libturbojpeg
-          version: ${{ env.APT_CACHE_VERSION }}
-          execute_install_scripts: true
      - name: Set up Python
        id: python
        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
@@ -888,21 +952,33 @@ jobs:
        python-version: ${{ fromJson(needs.info.outputs.python_versions) }}
        group: ${{ fromJson(needs.info.outputs.test_groups) }}
    steps:
+      - name: Restore apt cache
+        uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        with:
+          path: |
+            ${{ env.APT_CACHE_DIR }}
+            ${{ env.APT_LIST_CACHE_DIR }}
+          fail-on-cache-miss: true
+          key: >-
+            ${{ runner.os }}-${{ runner.arch }}-${{ needs.info.outputs.apt_cache_key }}
+      - name: Install additional OS dependencies
+        timeout-minutes: 10
+        run: |
+          sudo rm /etc/apt/sources.list.d/microsoft-prod.list
+          sudo apt-get update \
+            -o Dir::Cache=${APT_CACHE_DIR} \
+            -o Dir::State::Lists=${APT_LIST_CACHE_DIR}
+          sudo apt-get -y install \
+            -o Dir::Cache=${APT_CACHE_DIR} \
+            -o Dir::State::Lists=${APT_LIST_CACHE_DIR} \
+            bluez \
+            ffmpeg \
+            libturbojpeg \
+            libxml2-utils
      - name: Check out code from GitHub
        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
        with:
          persist-credentials: false
-      - name: Install additional OS dependencies
-        timeout-minutes: 10
-        uses: ./.github/actions/cache-apt-packages
-        with:
-          packages: >-
-            bluez
-            ffmpeg
-            libturbojpeg
-            libxml2-utils
-          version: ${{ env.APT_CACHE_VERSION }}
-          execute_install_scripts: true
      - name: Set up Python ${{ matrix.python-version }}
        id: python
        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
@@ -1029,22 +1105,34 @@ jobs:
        python-version: ${{ fromJson(needs.info.outputs.python_versions) }}
        mariadb-group: ${{ fromJson(needs.info.outputs.mariadb_groups) }}
    steps:
+      - name: Restore apt cache
+        uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        with:
+          path: |
+            ${{ env.APT_CACHE_DIR }}
+            ${{ env.APT_LIST_CACHE_DIR }}
+          fail-on-cache-miss: true
+          key: >-
+            ${{ runner.os }}-${{ runner.arch }}-${{ needs.info.outputs.apt_cache_key }}
+      - name: Install additional OS dependencies
+        timeout-minutes: 10
+        run: |
+          sudo rm /etc/apt/sources.list.d/microsoft-prod.list
+          sudo apt-get update \
+            -o Dir::Cache=${APT_CACHE_DIR} \
+            -o Dir::State::Lists=${APT_LIST_CACHE_DIR}
+          sudo apt-get -y install \
+            -o Dir::Cache=${APT_CACHE_DIR} \
+            -o Dir::State::Lists=${APT_LIST_CACHE_DIR} \
+            bluez \
+            ffmpeg \
+            libturbojpeg \
+            libmariadb-dev-compat \
+            libxml2-utils
      - name: Check out code from GitHub
        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
        with:
          persist-credentials: false
-      - name: Install additional OS dependencies
-        timeout-minutes: 10
-        uses: ./.github/actions/cache-apt-packages
-        with:
-          packages: >-
-            bluez
-            ffmpeg
-            libturbojpeg
-            libmariadb-dev-compat
-            libxml2-utils
-          version: ${{ env.APT_CACHE_VERSION }}
-          execute_install_scripts: true
      - name: Set up Python ${{ matrix.python-version }}
        id: python
        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
@@ -1178,29 +1266,36 @@ jobs:
        python-version: ${{ fromJson(needs.info.outputs.python_versions) }}
        postgresql-group: ${{ fromJson(needs.info.outputs.postgresql_groups) }}
    steps:
+      - name: Restore apt cache
+        uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        with:
+          path: |
+            ${{ env.APT_CACHE_DIR }}
+            ${{ env.APT_LIST_CACHE_DIR }}
+          fail-on-cache-miss: true
+          key: >-
+            ${{ runner.os }}-${{ runner.arch }}-${{ needs.info.outputs.apt_cache_key }}
+      - name: Install additional OS dependencies
+        timeout-minutes: 10
+        run: |
+          sudo rm /etc/apt/sources.list.d/microsoft-prod.list
+          sudo apt-get update \
+            -o Dir::Cache=${APT_CACHE_DIR} \
+            -o Dir::State::Lists=${APT_LIST_CACHE_DIR}
+          sudo apt-get -y install \
+            -o Dir::Cache=${APT_CACHE_DIR} \
+            -o Dir::State::Lists=${APT_LIST_CACHE_DIR} \
+            bluez \
+            ffmpeg \
+            libturbojpeg \
+            libxml2-utils
+          sudo /usr/share/postgresql-common/pgdg/apt.postgresql.org.sh -y
+          sudo apt-get -y install \
+            postgresql-server-dev-14
      - name: Check out code from GitHub
        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
        with:
          persist-credentials: false
-      - name: Install additional OS dependencies
-        timeout-minutes: 10
-        uses: ./.github/actions/cache-apt-packages
-        with:
-          packages: >-
-            bluez
-            ffmpeg
-            libturbojpeg
-            libxml2-utils
-          version: ${{ env.APT_CACHE_VERSION }}
-          execute_install_scripts: true
-      - name: Set up PostgreSQL apt repository
-        run: sudo /usr/share/postgresql-common/pgdg/apt.postgresql.org.sh -y
-      - name: Cache PostgreSQL development headers
-        timeout-minutes: 10
-        uses: ./.github/actions/cache-apt-packages
-        with:
-          packages: postgresql-server-dev-14
-          version: ${{ env.APT_CACHE_VERSION }}
      - name: Set up Python ${{ matrix.python-version }}
        id: python
        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
@@ -1354,21 +1449,33 @@ jobs:
        python-version: ${{ fromJson(needs.info.outputs.python_versions) }}
        group: ${{ fromJson(needs.info.outputs.test_groups) }}
    steps:
+      - name: Restore apt cache
+        uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        with:
+          path: |
+            ${{ env.APT_CACHE_DIR }}
+            ${{ env.APT_LIST_CACHE_DIR }}
+          fail-on-cache-miss: true
+          key: >-
+            ${{ runner.os }}-${{ runner.arch }}-${{ needs.info.outputs.apt_cache_key }}
+      - name: Install additional OS dependencies
+        timeout-minutes: 10
+        run: |
+          sudo rm /etc/apt/sources.list.d/microsoft-prod.list
+          sudo apt-get update \
+            -o Dir::Cache=${APT_CACHE_DIR} \
+            -o Dir::State::Lists=${APT_LIST_CACHE_DIR}
+          sudo apt-get -y install \
+            -o Dir::Cache=${APT_CACHE_DIR} \
+            -o Dir::State::Lists=${APT_LIST_CACHE_DIR} \
+            bluez \
+            ffmpeg \
+            libturbojpeg \
+            libxml2-utils
      - name: Check out code from GitHub
        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
        with:
          persist-credentials: false
-      - name: Install additional OS dependencies
-        timeout-minutes: 10
-        uses: ./.github/actions/cache-apt-packages
-        with:
-          packages: >-
-            bluez
-            ffmpeg
-            libturbojpeg
-            libxml2-utils
-          version: ${{ env.APT_CACHE_VERSION }}
-          execute_install_scripts: true
      - name: Set up Python ${{ matrix.python-version }}
        id: python
        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
@@ -27,7 +27,7 @@ jobs:
      # - No PRs marked as no-stale
      # - No issues (-1)
      - name: 60 days stale PRs policy
-        uses: actions/stale@eb5cf3af3ac0a1aa4c9c45633dd1ae542a27a899 # v10.3.0
+        uses: actions/stale@b5d41d4e1d5dceea10e7104786b73624c18a190f # v10.2.0
        with:
          repo-token: ${{ secrets.GITHUB_TOKEN }}
          days-before-stale: 60
@@ -55,11 +55,11 @@ jobs:
      - name: Generate app token
        id: token
        # Pinned to a specific version of the action for security reasons
-        # v3.2.0
-        uses: actions/create-github-app-token@bcd2ba49218906704ab6c1aa796996da409d3eb1
+        # v1.7.0
+        uses: tibdex/github-app-token@3beb63f4bd073e61482598c45c71c1019b59b73a
        with:
-          app-id: ${{ secrets.ISSUE_TRIAGE_APP_ID }} # zizmor: ignore[secrets-outside-env]
-          private-key: ${{ secrets.ISSUE_TRIAGE_APP_PEM }} # zizmor: ignore[secrets-outside-env]
+          app_id: ${{ secrets.ISSUE_TRIAGE_APP_ID }} # zizmor: ignore[secrets-outside-env]
+          private_key: ${{ secrets.ISSUE_TRIAGE_APP_PEM }} # zizmor: ignore[secrets-outside-env]

      # The 90 day stale policy for issues
      # Used for:
@@ -67,7 +67,7 @@ jobs:
      # - No issues marked as no-stale or help-wanted
      # - No PRs (-1)
      - name: 90 days stale issues
-        uses: actions/stale@eb5cf3af3ac0a1aa4c9c45633dd1ae542a27a899 # v10.3.0
+        uses: actions/stale@b5d41d4e1d5dceea10e7104786b73624c18a190f # v10.2.0
        with:
          repo-token: ${{ steps.token.outputs.token }}
          days-before-stale: 90
@@ -97,7 +97,7 @@ jobs:
      # - No Issues marked as no-stale or help-wanted
      # - No PRs (-1)
      - name: Needs more information stale issues policy
-        uses: actions/stale@eb5cf3af3ac0a1aa4c9c45633dd1ae542a27a899 # v10.3.0
+        uses: actions/stale@b5d41d4e1d5dceea10e7104786b73624c18a190f # v10.2.0
        with:
          repo-token: ${{ steps.token.outputs.token }}
          only-labels: "needs-more-information"
@@ -1,6 +1,6 @@
 repos:
  - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.15.14
+    rev: v0.15.13
    hooks:
      - id: ruff-check
        args:
@@ -337,7 +337,6 @@ homeassistant.components.led_ble.*
 homeassistant.components.lektrico.*
 homeassistant.components.letpot.*
 homeassistant.components.lg_infrared.*
-homeassistant.components.lg_tv_rs232.*
 homeassistant.components.libre_hardware_monitor.*
 homeassistant.components.lidarr.*
 homeassistant.components.liebherr.*
@@ -429,7 +428,6 @@ homeassistant.components.otp.*
 homeassistant.components.ouman_eh_800.*
 homeassistant.components.overkiz.*
 homeassistant.components.overseerr.*
-homeassistant.components.ovhcloud_ai_endpoints.*
 homeassistant.components.p1_monitor.*
 homeassistant.components.paj_gps.*
 homeassistant.components.panel_custom.*
@@ -567,7 +565,6 @@ homeassistant.components.technove.*
 homeassistant.components.tedee.*
 homeassistant.components.telegram_bot.*
 homeassistant.components.teleinfo.*
-homeassistant.components.teltonika.*
 homeassistant.components.teslemetry.*
 homeassistant.components.text.*
 homeassistant.components.thethingsnetwork.*
@@ -33,7 +33,6 @@ This repository contains the core of Home Assistant, a Python 3 based home autom
 - Avoid using conditions/branching in tests. Instead, either split tests or adjust the test parametrization to cover all cases without branching.
 - If multiple tests share most of their code, use `pytest.mark.parametrize` to merge them into a single parameterized test instead of duplicating the body. Use `pytest.param` with an `id` parameter to name the test cases clearly.
 - We use Syrupy for snapshot testing. Leverage `.ambr` snapshots instead of repetitive and exhaustive generation of test data within Python code itself.
- Hardcoded `entity_id`s in tests are fine. If the same one is repeated, use a constant.

 ## Good practices

@@ -987,8 +987,6 @@ CLAUDE.md @home-assistant/core
 /tests/components/lg_netcast/ @Drafteed @splinter98
 /homeassistant/components/lg_thinq/ @LG-ThinQ-Integration
 /tests/components/lg_thinq/ @LG-ThinQ-Integration
-/homeassistant/components/lg_tv_rs232/ @balloob
-/tests/components/lg_tv_rs232/ @balloob
 /homeassistant/components/libre_hardware_monitor/ @Sab44
 /tests/components/libre_hardware_monitor/ @Sab44
 /homeassistant/components/lichess/ @aryanhasgithub
@@ -1292,8 +1290,6 @@ CLAUDE.md @home-assistant/core
 /tests/components/openhome/ @bazwilliams
 /homeassistant/components/openrgb/ @felipecrs
 /tests/components/openrgb/ @felipecrs
-/homeassistant/components/opensensemap/ @AlCalzone
-/tests/components/opensensemap/ @AlCalzone
 /homeassistant/components/opensky/ @joostlek
 /tests/components/opensky/ @joostlek
 /homeassistant/components/opentherm_gw/ @mvn23
@@ -1321,8 +1317,6 @@ CLAUDE.md @home-assistant/core
 /tests/components/overkiz/ @imicknl
 /homeassistant/components/overseerr/ @joostlek @AmGarera
 /tests/components/overseerr/ @joostlek @AmGarera
-/homeassistant/components/ovhcloud_ai_endpoints/ @Crocmagnon
-/tests/components/ovhcloud_ai_endpoints/ @Crocmagnon
 /homeassistant/components/ovo_energy/ @timmo001
 /tests/components/ovo_energy/ @timmo001
 /homeassistant/components/p1_monitor/ @klaasnicolaas
@@ -2054,16 +2048,14 @@ CLAUDE.md @home-assistant/core
 /tests/components/yamaha_musiccast/ @vigonotion @micha91
 /homeassistant/components/yandex_transport/ @rishatik92 @devbis
 /tests/components/yandex_transport/ @rishatik92 @devbis
-/homeassistant/components/yardian/ @aeon-matrix
-/tests/components/yardian/ @aeon-matrix
+/homeassistant/components/yardian/ @h3l1o5
+/tests/components/yardian/ @h3l1o5
 /homeassistant/components/yeelight/ @zewelor @shenxn @starkillerOG @alexyao2015
 /tests/components/yeelight/ @zewelor @shenxn @starkillerOG @alexyao2015
 /homeassistant/components/yeelightsunflower/ @lindsaymarkward
 /homeassistant/components/yi/ @bachya
 /homeassistant/components/yolink/ @matrixd2
 /tests/components/yolink/ @matrixd2
-/homeassistant/components/yoto/ @cdnninja @piitaya
-/tests/components/yoto/ @cdnninja @piitaya
 /homeassistant/components/youless/ @gjong
 /tests/components/youless/ @gjong
 /homeassistant/components/youtube/ @joostlek
@@ -7,7 +7,7 @@ from homeassistant.components.select import (
    PLATFORM_SCHEMA as SELECT_PLATFORM_SCHEMA,
    SelectEntity,
 )
-from homeassistant.const import CONF_NAME, CONF_OPTIONS
+from homeassistant.const import CONF_NAME
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
@@ -19,6 +19,9 @@ from .hub import AdsHub

 DEFAULT_NAME = "ADS select"

+# pylint: disable-next=home-assistant-duplicate-const
+CONF_OPTIONS = "options"
+
 PLATFORM_SCHEMA = SELECT_PLATFORM_SCHEMA.extend(
    {
        vol.Required(CONF_ADS_VAR): cv.string,
@@ -1,7 +1,7 @@
 .trigger_common_fields:
  behavior: &trigger_behavior
    required: true
-    default: each
+    default: any
    selector:
      automation_behavior:
        mode: trigger
@@ -5,7 +5,7 @@
  fields: &trigger_common_fields
    behavior:
      required: true
-      default: each
+      default: any
      selector:
        automation_behavior:
          mode: trigger
@@ -1,13 +1,9 @@
 """Alexa Devices integration."""

-import asyncio
-import contextlib
-
 from homeassistant.const import CONF_COUNTRY, Platform
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers import aiohttp_client, config_validation as cv, httpx_client
+from homeassistant.helpers import aiohttp_client, config_validation as cv
 from homeassistant.helpers.typing import ConfigType
-from homeassistant.util.ssl import SSL_ALPN_HTTP11_HTTP2

 from .const import _LOGGER, CONF_LOGIN_DATA, CONF_SITE, COUNTRY_DOMAINS, DOMAIN
 from .coordinator import AmazonConfigEntry, AmazonDevicesCoordinator
@@ -16,8 +12,6 @@ from .services import async_setup_services
 PLATFORMS = [
    Platform.BINARY_SENSOR,
    Platform.BUTTON,
-    Platform.EVENT,
-    Platform.MEDIA_PLAYER,
    Platform.NOTIFY,
    Platform.SENSOR,
    Platform.SWITCH,
@@ -40,28 +34,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: AmazonConfigEntry) -> bo

    await coordinator.async_config_entry_first_refresh()

-    await coordinator.sync_history_state()
-    await coordinator.sync_media_state()
-
-    async def _on_http2_reauth_required() -> None:
-        entry.async_start_reauth(hass)
-
-    async def _cancel_http2() -> None:
-        http2_task.cancel()
-        with contextlib.suppress(asyncio.CancelledError):
-            await http2_task
-
-    alexa_httpx_client = httpx_client.get_async_client(
-        hass,
-        alpn_protocols=SSL_ALPN_HTTP11_HTTP2,
-    )
-
-    http2_task = await coordinator.api.start_http2_processing(
-        alexa_httpx_client, on_reauth_required=_on_http2_reauth_required
-    )
-
-    entry.async_on_unload(_cancel_http2)
-
    entry.runtime_data = coordinator

    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
@@ -8,18 +8,13 @@ from aioamazondevices.exceptions import (
    CannotConnect,
    CannotRetrieveData,
 )
-from aioamazondevices.structures import (
-    AmazonDevice,
-    AmazonMediaState,
-    AmazonVocalRecord,
-    AmazonVolumeState,
-)
+from aioamazondevices.structures import AmazonDevice
 from aiohttp import ClientSession

 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_PASSWORD, CONF_USERNAME, Platform
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
+from homeassistant.exceptions import ConfigEntryAuthFailed
 from homeassistant.helpers import device_registry as dr, entity_registry as er
 from homeassistant.helpers.debounce import Debouncer
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
@@ -78,18 +73,6 @@ class AmazonDevicesCoordinator(DataUpdateCoordinator[dict[str, AmazonDevice]]):
            if routine.domain == Platform.BUTTON
        }

-        self._vocal_records: dict[str, AmazonVocalRecord] = {}
-        self.api.on_history_event.append(self.history_state_event_handler)
-        self.api.on_history_event.freeze()
-
-        self._volume_states: dict[str, AmazonVolumeState] = {}
-        self.api.on_volume_state_event.append(self.volume_state_event_handler)
-        self.api.on_volume_state_event.freeze()
-
-        self._media_states: dict[str, AmazonMediaState] = {}
-        self.api.on_media_state_event.append(self.media_state_event_handler)
-        self.api.on_media_state_event.freeze()
-
    async def _async_update_data(self) -> dict[str, AmazonDevice]:
        """Update device data."""
        try:
@@ -166,66 +149,3 @@ class AmazonDevicesCoordinator(DataUpdateCoordinator[dict[str, AmazonDevice]]):
            )
            if entity_id:
                entity_registry.async_remove(entity_id)
-
-    async def sync_history_state(self) -> None:
-        """Sync history state."""
-        try:
-            self._vocal_records = await self.api.sync_history_state()
-        except CannotAuthenticate as e:
-            raise ConfigEntryAuthFailed(
-                translation_domain=DOMAIN,
-                translation_key="invalid_auth",
-                translation_placeholders={"error": repr(e)},
-            ) from e
-        except CannotConnect as e:
-            raise ConfigEntryNotReady(
-                translation_domain=DOMAIN,
-                translation_key="cannot_connect_with_error",
-                translation_placeholders={"error": repr(e)},
-            ) from e
-        except BaseException as e:
-            raise ConfigEntryNotReady(
-                translation_domain=DOMAIN,
-                translation_key="cannot_retrieve_data_with_error",
-                translation_placeholders={"error": repr(e)},
-            ) from e
-
-    async def history_state_event_handler(
-        self, vocal_records: dict[str, AmazonVocalRecord]
-    ) -> None:
-        """Handle pushed vocal record events."""
-        self._vocal_records = {**self._vocal_records, **vocal_records}
-        self.async_update_listeners()
-
-    @property
-    def vocal_records(self) -> dict[str, AmazonVocalRecord]:
-        """Vocal records of devices."""
-        return self._vocal_records
-
-    async def sync_media_state(self) -> None:
-        """Sync media state."""
-        await self.api.sync_media_state()
-
-    async def media_state_event_handler(
-        self, media_state: dict[str, AmazonMediaState]
-    ) -> None:
-        """Handle pushed media state changed events."""
-        self._media_states = media_state
-        self.async_update_listeners()
-
-    @property
-    def media_states(self) -> dict[str, AmazonMediaState]:
-        """Media state of devices."""
-        return self._media_states
-
-    async def volume_state_event_handler(
-        self, volume_states: dict[str, AmazonVolumeState]
-    ) -> None:
-        """Handle pushed volume change events."""
-        self._volume_states = volume_states
-        self.async_update_listeners()
-
-    @property
-    def volume_states(self) -> dict[str, AmazonVolumeState]:
-        """Volumes of devices."""
-        return self._volume_states
@@ -1,86 +0,0 @@
-"""Support for events."""
-
-from typing import Final
-
-from homeassistant.components.event import EventEntity, EventEntityDescription
-from homeassistant.core import HomeAssistant, callback
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-
-from .const import _LOGGER
-from .coordinator import AmazonConfigEntry, AmazonDevicesCoordinator
-from .entity import AmazonEntity
-
-# Coordinator is used to centralize the data updates
-PARALLEL_UPDATES = 0
-
-EVENTS: Final = {
-    EventEntityDescription(
-        key="voice_event",
-        translation_key="voice_event",
-    ),
-}
-
-EVENT_TYPE = "triggered"
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: AmazonConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up Alexa Devices events based on a config entry."""
-    coordinator = entry.runtime_data
-
-    known_devices: set[str] = set()
-
-    def _check_device() -> None:
-        current_devices = set(coordinator.data)
-        new_devices = current_devices - known_devices
-        if new_devices:
-            known_devices.update(new_devices)
-            async_add_entities(
-                AlexaVoiceEvent(coordinator, serial_num, event_desc)
-                for event_desc in EVENTS
-                for serial_num in new_devices
-            )
-
-    _check_device()
-    entry.async_on_unload(coordinator.async_add_listener(_check_device))
-
-
-class AlexaVoiceEvent(AmazonEntity, EventEntity):
-    """Representation of an Alexa voice event."""
-
-    _attr_event_types = [EVENT_TYPE]
-    coordinator: AmazonDevicesCoordinator
-    _last_seen_timestamp: int | None = None
-
-    @callback
-    def _handle_coordinator_update(self) -> None:
-        """Handle updated data from the coordinator."""
-
-        if not (
-            vocal_record := self.coordinator.vocal_records.get(
-                self.device.serial_number
-            )
-        ):
-            _LOGGER.debug(
-                "No vocal record found for device %s [%s]",
-                self.device.account_name,
-                self.device.serial_number,
-            )
-            return
-
-        if vocal_record.timestamp == self._last_seen_timestamp:
-            return
-
-        self._last_seen_timestamp = vocal_record.timestamp
-        self._trigger_event(
-            EVENT_TYPE,
-            {
-                "intent": vocal_record.intent,
-                "voice_command": vocal_record.title,
-                "voice_reply": vocal_record.sub_title,
-            },
-        )
-        self.async_write_ha_state()
@@ -1,10 +1,5 @@
 {
  "entity": {
-    "event": {
-      "voice_event": {
-        "default": "mdi:chat-processing"
-      }
-    },
    "sensor": {
      "voc_index": {
        "default": "mdi:molecule"
@@ -8,5 +8,5 @@
  "iot_class": "cloud_polling",
  "loggers": ["aioamazondevices"],
  "quality_scale": "platinum",
-  "requirements": ["aioamazondevices==13.8.0"]
+  "requirements": ["aioamazondevices==13.7.0"]
 }
@@ -1,294 +0,0 @@
-"""Media player platform for Alexa Devices."""
-
-from dataclasses import dataclass
-from datetime import datetime
-from typing import Any, Final
-
-from aioamazondevices.structures import (
-    AmazonMediaControls,
-    AmazonMediaState,
-    AmazonVolumeState,
-)
-
-from homeassistant.components.media_player import (
-    MediaPlayerDeviceClass,
-    MediaPlayerEnqueue,
-    MediaPlayerEntity,
-    MediaPlayerEntityDescription,
-    MediaPlayerEntityFeature,
-    MediaPlayerState,
-    MediaType,
-)
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-
-from .const import _LOGGER
-from .coordinator import AmazonConfigEntry, AmazonDevicesCoordinator
-from .entity import AmazonEntity
-from .utils import alexa_api_call
-
-PARALLEL_UPDATES = 1
-
-STANDARD_SUPPORTED_FEATURES = (
-    MediaPlayerEntityFeature.VOLUME_SET
-    | MediaPlayerEntityFeature.VOLUME_STEP
-    | MediaPlayerEntityFeature.VOLUME_MUTE
-    | MediaPlayerEntityFeature.STOP
-    | MediaPlayerEntityFeature.PLAY_MEDIA
-)
-
-
-@dataclass(frozen=True, kw_only=True)
-class AmazonDevicesMediaPlayerEntityDescription(MediaPlayerEntityDescription):
-    """Describes an Alexa Devices media player entity."""
-
-
-MEDIA_PLAYERS: Final = (
-    AmazonDevicesMediaPlayerEntityDescription(
-        key="media",
-    ),
-)
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: AmazonConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up Alexa Devices media player entities from a config entry."""
-    coordinator = entry.runtime_data
-
-    known_devices: set[str] = set()
-
-    def _check_device() -> None:
-        """Add entities for newly discovered devices."""
-        new_entities: list[AlexaDevicesMediaPlayer] = []
-
-        for serial_num, device in coordinator.data.items():
-            if serial_num in known_devices or not device.media_player_supported:
-                continue
-
-            known_devices.add(serial_num)
-            new_entities.extend(
-                AlexaDevicesMediaPlayer(coordinator, serial_num, description)
-                for description in MEDIA_PLAYERS
-            )
-
-        if new_entities:
-            async_add_entities(new_entities)
-
-    remove_listener = coordinator.async_add_listener(_check_device)
-    entry.async_on_unload(remove_listener)
-    _check_device()
-
-
-class AlexaDevicesMediaPlayer(AmazonEntity, MediaPlayerEntity):
-    """Representation of an Alexa device media player."""
-
-    entity_description: AmazonDevicesMediaPlayerEntityDescription
-
-    _attr_name = None  # Uses the device name
-    _attr_device_class = MediaPlayerDeviceClass.SPEAKER
-    _attr_volume_step = 0.05
-
-    def __init__(
-        self,
-        coordinator: AmazonDevicesCoordinator,
-        serial_num: str,
-        description: AmazonDevicesMediaPlayerEntityDescription,
-    ) -> None:
-        """Initialize."""
-        self._prev_volume: int | None = None
-        super().__init__(coordinator, serial_num, description)
-
-    @property
-    def media_state(self) -> AmazonMediaState | None:
-        """Return the media state relating to device."""
-        if not self.coordinator or not self.coordinator.media_states:
-            return None
-        return self.coordinator.media_states.get(self._serial_num)
-
-    @property
-    def volume_state(self) -> AmazonVolumeState | None:
-        """Volume settings for device."""
-        if not self.coordinator or not self.coordinator.volume_states:
-            return None
-        return self.coordinator.volume_states.get(self._serial_num)
-
-    @property
-    def supported_features(self) -> MediaPlayerEntityFeature:
-        """Return dynamically supported features based on current media."""
-        features = STANDARD_SUPPORTED_FEATURES
-
-        if self.media_state is None:
-            return features
-
-        if self.media_state.pause_enabled:
-            features |= MediaPlayerEntityFeature.PLAY | MediaPlayerEntityFeature.PAUSE
-
-        if self.media_state.next_enabled:
-            features |= MediaPlayerEntityFeature.NEXT_TRACK
-
-        if self.media_state.previous_enabled:
-            features |= MediaPlayerEntityFeature.PREVIOUS_TRACK
-
-        return features
-
-    @property
-    def state(self) -> MediaPlayerState | None:
-        """Return the current state of the player."""
-        if not self.media_state:
-            return MediaPlayerState.IDLE
-        if self.media_state.player_state == "PLAYING":
-            return MediaPlayerState.PLAYING
-        if self.media_state.player_state == "PAUSED":
-            return MediaPlayerState.PAUSED
-
-        return MediaPlayerState.IDLE
-
-    @property
-    def volume_level(self) -> float | None:
-        """Return the volume level (0.0 to 1.0)."""
-        if not self.volume_state or self.volume_state.volume is None:
-            return None
-        return self.volume_state.volume / 100
-
-    @property
-    def is_volume_muted(self) -> bool | None:
-        """Return True if the volume is muted."""
-        if not self.volume_state:
-            return None
-        return self.volume_state.volume == 0
-
-    @property
-    def media_title(self) -> str | None:
-        """Track title."""
-        if not self.media_state:
-            return None
-        return self.media_state.now_playing_title
-
-    @property
-    def media_artist(self) -> str | None:
-        """Artist name."""
-        if not self.media_state:
-            return None
-        return self.media_state.now_playing_line1
-
-    @property
-    def media_album_name(self) -> str | None:
-        """Album name."""
-        if not self.media_state:
-            return None
-        return self.media_state.now_playing_line2
-
-    @property
-    def media_image_url(self) -> str | None:
-        """Album art URL."""
-        if not self.media_state:
-            return None
-        return self.media_state.now_playing_url
-
-    @property
-    def media_duration(self) -> int | None:
-        """Duration in seconds."""
-        if not self.media_state:
-            return None
-        return self.media_state.media_length
-
-    @property
-    def media_position(self) -> int | None:
-        """Current playback position in seconds."""
-        if not self.media_state:
-            return None
-        return self.media_state.media_position
-
-    @property
-    def media_position_updated_at(self) -> datetime | None:
-        """When media_position was last updated — HA uses this to interpolate the progress bar."""
-        if not self.media_state:
-            return None
-        return self.media_state.media_position_updated_at
-
-    @property
-    def media_content_type(self) -> MediaType | None:
-        """Content type — tells HA what kind of media is playing."""
-        if self.state in [MediaPlayerState.PLAYING, MediaPlayerState.PAUSED]:
-            return MediaType.MUSIC
-        return None
-
-    async def async_play_media(
-        self,
-        media_type: MediaType | str,
-        media_id: str,
-        enqueue: MediaPlayerEnqueue | None = None,
-        announce: bool | None = None,
-        **kwargs: Any,
-    ) -> None:
-        """Play a piece of media."""
-        await self.async_call_alexa_music(media_id, media_type)
-
-    @alexa_api_call
-    async def async_call_alexa_music(
-        self, search_phrase: str, provider_id: str
-    ) -> None:
-        """Call alexa music."""
-        await self.coordinator.api.call_alexa_music(
-            self.device, search_phrase, provider_id
-        )
-
-    @alexa_api_call
-    async def async_set_device_volume(self, volume: int) -> None:
-        """Set the device volume."""
-        _LOGGER.debug(
-            "Setting volume for %s to %s%%",
-            self.device.serial_number,
-            volume,
-        )
-        await self.coordinator.api.set_device_volume(self.device, volume)
-
-    async def async_set_volume_level(self, volume: float) -> None:
-        """Set the volume level (0.0 to 1.0)."""
-        device_volume = round(volume * 100)
-        await self.async_set_device_volume(device_volume)
-
-    async def async_mute_volume(self, mute: bool) -> None:
-        """Mute or un-mute the volume."""
-        # Whilst you can mute a device by asking it there appears to be
-        # no way to do this programmatically so set volume to 0
-        if not self.volume_state or self.volume_state.volume is None:
-            return
-        if mute:
-            self._prev_volume = self.volume_state.volume
-            target_volume = 0
-        else:
-            if self._prev_volume is None:
-                return
-            target_volume = self._prev_volume
-        await self.async_set_volume_level(target_volume / 100)
-
-    @alexa_api_call
-    async def _send_media_command(self, command: AmazonMediaControls) -> None:
-        _LOGGER.debug(
-            "Sending media command '%s' to %s", command, self.device.serial_number
-        )
-        await self.coordinator.api.send_media_command(self.device, command)
-
-    async def async_media_stop(self) -> None:
-        """Send stop command."""
-        await self._send_media_command(AmazonMediaControls.Stop)
-
-    async def async_media_pause(self) -> None:
-        """Send pause command."""
-        await self._send_media_command(AmazonMediaControls.Pause)
-
-    async def async_media_play(self) -> None:
-        """Send play command."""
-        await self._send_media_command(AmazonMediaControls.Play)
-
-    async def async_media_next_track(self) -> None:
-        """Send next track command."""
-        await self._send_media_command(AmazonMediaControls.Next)
-
-    async def async_media_previous_track(self) -> None:
-        """Send previous track command."""
-        await self._send_media_command(AmazonMediaControls.Previous)
@@ -58,18 +58,6 @@
    }
  },
  "entity": {
-    "event": {
-      "voice_event": {
-        "name": "Voice event",
-        "state_attributes": {
-          "event_type": {
-            "state": {
-              "triggered": "Triggered"
-            }
-          }
-        }
-      }
-    },
    "notify": {
      "announce": {
        "name": "Announce"
@@ -230,13 +230,13 @@ async def async_migrate_entry(hass: HomeAssistant, entry: AnthropicConfigEntry)

    if entry.version == 2 and entry.minor_version == 3:
        # Remove Temperature parameter
-        temperature_key = "temperature"
+        CONF_TEMPERATURE = "temperature"

        for subentry in entry.subentries.values():
            data = subentry.data.copy()
-            if temperature_key not in data:
+            if CONF_TEMPERATURE not in data:
                continue
-            data.pop(temperature_key, None)
+            data.pop(CONF_TEMPERATURE, None)
            hass.config_entries.async_update_subentry(entry, subentry, data=data)

        hass.config_entries.async_update_entry(entry, minor_version=4)
@@ -7,3 +7,27 @@ CONNECTION_TIMEOUT: int = 10

 # Field name of last self test retrieved from apcupsd.
 LAST_S_TEST: Final = "laststest"
+
+# Mapping of deprecated sensor keys (as reported by apcupsd,
+# lower-cased) to their deprecation
+# repair issue translation keys.
+DEPRECATED_SENSORS: Final = {
+    "apc": "apc_deprecated",
+    "end apc": "date_deprecated",
+    "date": "date_deprecated",
+    "apcmodel": "available_via_device_info",
+    "model": "available_via_device_info",
+    "firmware": "available_via_device_info",
+    "version": "available_via_device_info",
+    "upsname": "available_via_device_info",
+    "serialno": "available_via_device_info",
+}
+
+AVAILABLE_VIA_DEVICE_ATTR: Final = {
+    "apcmodel": "model",
+    "model": "model",
+    "firmware": "hw_version",
+    "version": "sw_version",
+    "upsname": "name",
+    "serialno": "serial_number",
+}
@@ -1,10 +1,11 @@
 """Support for APCUPSd sensors."""

 import logging
-from typing import Final

 import dateutil

+from homeassistant.components.automation import automations_with_entity
+from homeassistant.components.script import scripts_with_entity
 from homeassistant.components.sensor import (
    SensorDeviceClass,
    SensorEntity,
@@ -23,9 +24,11 @@ from homeassistant.const import (
    UnitOfTime,
 )
 from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers import entity_registry as er
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+import homeassistant.helpers.issue_registry as ir

-from .const import LAST_S_TEST
+from .const import AVAILABLE_VIA_DEVICE_ATTR, DEPRECATED_SENSORS, DOMAIN, LAST_S_TEST
 from .coordinator import APCUPSdConfigEntry, APCUPSdCoordinator
 from .entity import APCUPSdEntity

@@ -33,20 +36,6 @@ PARALLEL_UPDATES = 0

 _LOGGER = logging.getLogger(__name__)

-# List of useless sensors to ignore, since they are either provided in device
-# information, or not useful at all
-IGNORED_SENSORS: Final = {
-    "apc",
-    "end apc",
-    "date",
-    "apcmodel",
-    "model",
-    "firmware",
-    "version",
-    "upsname",
-    "serialno",
-}
-
 SENSORS: dict[str, SensorEntityDescription] = {
    "alarmdel": SensorEntityDescription(
        key="alarmdel",
@@ -60,6 +49,18 @@ SENSORS: dict[str, SensorEntityDescription] = {
        device_class=SensorDeviceClass.TEMPERATURE,
        state_class=SensorStateClass.MEASUREMENT,
    ),
+    "apc": SensorEntityDescription(
+        key="apc",
+        translation_key="apc_status",
+        entity_registry_enabled_default=False,
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
+    "apcmodel": SensorEntityDescription(
+        key="apcmodel",
+        translation_key="apc_model",
+        entity_registry_enabled_default=False,
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
    "badbatts": SensorEntityDescription(
        key="badbatts",
        translation_key="bad_batteries",
@@ -99,6 +100,12 @@ SENSORS: dict[str, SensorEntityDescription] = {
        state_class=SensorStateClass.TOTAL_INCREASING,
        device_class=SensorDeviceClass.DURATION,
    ),
+    "date": SensorEntityDescription(
+        key="date",
+        translation_key="date",
+        entity_registry_enabled_default=False,
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
    "dipsw": SensorEntityDescription(
        key="dipsw",
        translation_key="dip_switch_settings",
@@ -125,11 +132,23 @@ SENSORS: dict[str, SensorEntityDescription] = {
        translation_key="wake_delay",
        entity_category=EntityCategory.DIAGNOSTIC,
    ),
+    "end apc": SensorEntityDescription(
+        key="end apc",
+        translation_key="date_and_time",
+        entity_registry_enabled_default=False,
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
    "extbatts": SensorEntityDescription(
        key="extbatts",
        translation_key="external_batteries",
        entity_category=EntityCategory.DIAGNOSTIC,
    ),
+    "firmware": SensorEntityDescription(
+        key="firmware",
+        translation_key="firmware_version",
+        entity_registry_enabled_default=False,
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
    "hitrans": SensorEntityDescription(
        key="hitrans",
        translation_key="transfer_high",
@@ -245,6 +264,12 @@ SENSORS: dict[str, SensorEntityDescription] = {
        translation_key="min_time",
        entity_category=EntityCategory.DIAGNOSTIC,
    ),
+    "model": SensorEntityDescription(
+        key="model",
+        translation_key="model",
+        entity_registry_enabled_default=False,
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
    "nombattv": SensorEntityDescription(
        key="nombattv",
        translation_key="battery_nominal_voltage",
@@ -333,6 +358,12 @@ SENSORS: dict[str, SensorEntityDescription] = {
        entity_registry_enabled_default=False,
        entity_category=EntityCategory.DIAGNOSTIC,
    ),
+    "serialno": SensorEntityDescription(
+        key="serialno",
+        translation_key="serial_number",
+        entity_registry_enabled_default=False,
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
    "starttime": SensorEntityDescription(
        key="starttime",
        translation_key="startup_time",
@@ -373,6 +404,18 @@ SENSORS: dict[str, SensorEntityDescription] = {
        translation_key="ups_mode",
        entity_category=EntityCategory.DIAGNOSTIC,
    ),
+    "upsname": SensorEntityDescription(
+        key="upsname",
+        translation_key="ups_name",
+        entity_registry_enabled_default=False,
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
+    "version": SensorEntityDescription(
+        key="version",
+        translation_key="version",
+        entity_registry_enabled_default=False,
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
    "xoffbat": SensorEntityDescription(
        key="xoffbat",
        translation_key="transfer_from_battery",
@@ -438,10 +481,9 @@ async def async_setup_entry(
    # as unknown initially.
    #
    # We also sort the resources to ensure the order of entities
-    # created is deterministic
+    # created is deterministic since "APCMODEL" and "MODEL"
+    # resources map to the same "Model" name.
    for resource in sorted(available_resources | {LAST_S_TEST}):
-        if resource in IGNORED_SENSORS:
-            continue
        if resource not in SENSORS:
            _LOGGER.warning("Invalid resource from APCUPSd: %s", resource.upper())
            continue
@@ -519,3 +561,63 @@ class APCUPSdSensor(APCUPSdEntity, SensorEntity):
        self._attr_native_value, inferred_unit = infer_unit(data)
        if not self.native_unit_of_measurement:
            self._attr_native_unit_of_measurement = inferred_unit
+
+    async def async_added_to_hass(self) -> None:
+        """Handle when entity is added to Home Assistant.
+
+        If this is a deprecated sensor entity, create a repair issue to guide
+        the user to disable it.
+        """
+        await super().async_added_to_hass()
+
+        if not self.enabled:
+            return
+
+        reason = DEPRECATED_SENSORS.get(self.entity_description.key)
+        if not reason:
+            return
+
+        automations = automations_with_entity(self.hass, self.entity_id)
+        scripts = scripts_with_entity(self.hass, self.entity_id)
+        if not automations and not scripts:
+            return
+
+        entity_registry = er.async_get(self.hass)
+        items = [
+            f"- [{entry.name or entry.original_name or entity_id}]"
+            f"(/config/{integration}/edit/"
+            f"{entry.unique_id or entity_id.split('.', 1)[-1]})"
+            for integration, entities in (
+                ("automation", automations),
+                ("script", scripts),
+            )
+            for entity_id in entities
+            if (entry := entity_registry.async_get(entity_id))
+        ]
+        placeholders = {
+            "entity_name": str(self.name or self.entity_id),
+            "entity_id": self.entity_id,
+            "items": "\n".join(items),
+        }
+        if via_attr := AVAILABLE_VIA_DEVICE_ATTR.get(self.entity_description.key):
+            placeholders["available_via_device_attr"] = via_attr
+        if device_entry := self.device_entry:
+            placeholders["device_id"] = device_entry.id
+
+        ir.async_create_issue(
+            self.hass,
+            DOMAIN,
+            f"{reason}_{self.entity_id}",
+            breaks_in_ha_version="2026.6.0",
+            is_fixable=False,
+            severity=ir.IssueSeverity.WARNING,
+            translation_key=reason,
+            translation_placeholders=placeholders,
+        )
+
+    async def async_will_remove_from_hass(self) -> None:
+        """Handle when entity will be removed from Home Assistant."""
+        await super().async_will_remove_from_hass()
+
+        if issue_key := DEPRECATED_SENSORS.get(self.entity_description.key):
+            ir.async_delete_issue(self.hass, DOMAIN, f"{issue_key}_{self.entity_id}")
@@ -241,5 +241,19 @@
    "cannot_connect": {
      "message": "Cannot connect to APC UPS Daemon."
    }
+  },
+  "issues": {
+    "apc_deprecated": {
+      "description": "The {entity_name} sensor (`{entity_id}`) is deprecated because it exposes internal details of the APC UPS Daemon response.\n\nIt is still referenced in the following automations or scripts:\n{items}\n\nUpdate those automations or scripts to use supported APC UPS entities instead. Reload the APC UPS Daemon integration afterwards to resolve this issue.",
+      "title": "{entity_name} sensor is deprecated"
+    },
+    "available_via_device_info": {
+      "description": "The {entity_name} sensor (`{entity_id}`) is deprecated because the same value is available from the device registry via `device_attr(\"{device_id}\", \"{available_via_device_attr}\")`.\n\nIt is still referenced in the following automations or scripts:\n{items}\n\nUpdate those automations or scripts to use the `device_attr` helper instead of this sensor. Reload the APC UPS Daemon integration afterwards to resolve this issue.",
+      "title": "{entity_name} sensor is deprecated"
+    },
+    "date_deprecated": {
+      "description": "The {entity_name} sensor (`{entity_id}`) is deprecated because the timestamp is already available from other APC UPS sensors via their last updated time.\n\nIt is still referenced in the following automations or scripts:\n{items}\n\nUpdate those automations or scripts to reference any entity's `last_updated` attribute instead (for example, `states.binary_sensor.apcups_online_status.last_updated`). Reload the APC UPS Daemon integration afterwards to resolve this issue.",
+      "title": "{entity_name} sensor is deprecated"
+    }
  }
 }
@@ -193,11 +193,7 @@ async def async_setup_entry(
            Aranet4BluetoothSensorEntity, async_add_entities
        )
    )
-    entry.async_on_unload(
-        entry.runtime_data.async_register_processor(
-            processor, AranetSensorEntityDescription
-        )
-    )
+    entry.async_on_unload(entry.runtime_data.async_register_processor(processor))


 class Aranet4BluetoothSensorEntity(
@@ -5,7 +5,7 @@
  fields:
    behavior:
      required: true
-      default: each
+      default: any
      selector:
        automation_behavior:
          mode: trigger
@@ -49,20 +49,6 @@ SENSORS_TYPE_COUNT = "sensors_count"

 _LOGGER = logging.getLogger(__name__)

-_ENTITY_MIGRATION_ID = {
-    "sensor_connected_device": "Devices Connected",
-    "sensor_rx_bytes": "Download",
-    "sensor_tx_bytes": "Upload",
-    "sensor_rx_rates": "Download Speed",
-    "sensor_tx_rates": "Upload Speed",
-    "sensor_load_avg1": "Load Avg (1m)",
-    "sensor_load_avg5": "Load Avg (5m)",
-    "sensor_load_avg15": "Load Avg (15m)",
-    "2.4GHz": "2.4GHz Temperature",
-    "5.0GHz": "5GHz Temperature",
-    "CPU": "CPU Temperature",
-}
-

 class AsusWrtSensorDataHandler:
    """Data handler for AsusWrt sensor."""
@@ -201,6 +187,20 @@ class AsusWrtRouter:

    def _migrate_entities_unique_id(self) -> None:
        """Migrate router entities to new unique id format."""
+        _ENTITY_MIGRATION_ID = {
+            "sensor_connected_device": "Devices Connected",
+            "sensor_rx_bytes": "Download",
+            "sensor_tx_bytes": "Upload",
+            "sensor_rx_rates": "Download Speed",
+            "sensor_tx_rates": "Upload Speed",
+            "sensor_load_avg1": "Load Avg (1m)",
+            "sensor_load_avg5": "Load Avg (5m)",
+            "sensor_load_avg15": "Load Avg (15m)",
+            "2.4GHz": "2.4GHz Temperature",
+            "5.0GHz": "5GHz Temperature",
+            "CPU": "CPU Temperature",
+        }
+
        entity_reg = er.async_get(self.hass)
        router_entries = er.async_entries_for_config_entry(
            entity_reg, self._entry.entry_id
@@ -1,6 +1,5 @@
 """Light platform for Avea."""

-from collections.abc import Callable
 from contextlib import suppress
 import logging
 from typing import Any
@@ -20,7 +19,6 @@ from homeassistant.core import DOMAIN as HOMEASSISTANT_DOMAIN, HomeAssistant
 from homeassistant.data_entry_flow import FlowResultType
 from homeassistant.exceptions import PlatformNotReady
 from homeassistant.helpers import issue_registry as ir
-from homeassistant.helpers.device_registry import CONNECTION_BLUETOOTH, DeviceInfo
 from homeassistant.helpers.entity_platform import (
    AddConfigEntryEntitiesCallback,
    AddEntitiesCallback,
@@ -29,7 +27,7 @@ from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
 from homeassistant.util import color as color_util

 from . import AveaConfigEntry
-from .const import DOMAIN, INTEGRATION_TITLE, MODEL, UNKNOWN_NAME
+from .const import DOMAIN, INTEGRATION_TITLE, UNKNOWN_NAME

 _LOGGER = logging.getLogger(__name__)
 UPDATE_EXCEPTIONS = (BleakError, OSError, RuntimeError)
@@ -44,13 +42,6 @@ def _normalize_name(name: str | None) -> str | None:
    return name


-def _read_device_info_value(read: Callable[[], str | None]) -> str | None:
-    """Read a device information value from an Avea bulb."""
-    with suppress(*UPDATE_EXCEPTIONS):
-        return _normalize_name(read())
-    return None
-
-
 def _ha_brightness_to_avea(brightness: int) -> int:
    """Convert Home Assistant brightness to Avea brightness."""
    return round((brightness / 255) * AVEA_MAX_BRIGHTNESS)
@@ -105,8 +96,7 @@ async def async_setup_entry(
 ) -> None:
    """Set up the Avea light platform."""
    async_add_entities(
-        [AveaLight(entry.runtime_data, entry.data[CONF_ADDRESS])],
-        update_before_add=True,
+        [AveaLight(entry.runtime_data, entry.title)], update_before_add=True
    )


@@ -190,42 +180,14 @@ class AveaLight(LightEntity):
    """Representation of an Avea."""

    _attr_color_mode = ColorMode.HS
-    _attr_has_entity_name = True
-    _attr_name = None
    _attr_supported_color_modes = {ColorMode.HS}

-    def __init__(self, light: avea.Bulb, address: str) -> None:
+    def __init__(self, light: avea.Bulb, entry_title: str) -> None:
        """Initialize an AveaLight."""
        self._light = light
-        self._attr_unique_id = address
+        self._attr_name = entry_title
        self._attr_brightness = light.brightness
        self._last_brightness = 255
-        self._device_info_updated = False
-        self._attr_device_info = DeviceInfo(
-            connections={(CONNECTION_BLUETOOTH, address)},
-            model=MODEL,
-        )
-
-    def _update_device_info(self) -> None:
-        """Fetch device information from the Avea bulb."""
-        device_info = self._attr_device_info
-        assert device_info is not None
-
-        manufacturer = _read_device_info_value(self._light.get_manufacturer_name)
-        hardware_revision = _read_device_info_value(self._light.get_hardware_revision)
-        firmware_version = _read_device_info_value(self._light.get_fw_version)
-        serial_number = _read_device_info_value(self._light.get_serial_number)
-
-        if manufacturer:
-            device_info["manufacturer"] = manufacturer
-        if hardware_revision:
-            device_info["hw_version"] = hardware_revision
-        if firmware_version:
-            device_info["sw_version"] = firmware_version
-        if serial_number:
-            device_info["serial_number"] = serial_number
-
-        self._device_info_updated = True

    def turn_on(self, **kwargs: Any) -> None:
        """Instruct the light to turn on."""
@@ -252,8 +214,6 @@ class AveaLight(LightEntity):
        connected = self._light.connect()

        try:
-            if not self._device_info_updated:
-                self._update_device_info()
            brightness = self._light.get_brightness()
            rgb_color = self._light.get_rgb()
        finally:
@@ -51,6 +51,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: S3ConfigEntry) -> bool:
                translation_key="invalid_bucket_name",
            ) from err
    except ValueError as err:
+        # pylint: disable-next=home-assistant-exception-translation-key-missing
        raise ConfigEntryError(
            translation_domain=DOMAIN,
            translation_key="invalid_endpoint_url",
@@ -7,7 +7,7 @@
      "cannot_connect": "[%key:component::aws_s3::exceptions::cannot_connect::message%]",
      "invalid_bucket_name": "[%key:component::aws_s3::exceptions::invalid_bucket_name::message%]",
      "invalid_credentials": "[%key:component::aws_s3::exceptions::invalid_credentials::message%]",
-      "invalid_endpoint_url": "[%key:component::aws_s3::exceptions::invalid_endpoint_url::message%]"
+      "invalid_endpoint_url": "Invalid endpoint URL. Please make sure it's a valid AWS S3 endpoint URL."
    },
    "step": {
      "user": {
@@ -48,9 +48,6 @@
    },
    "invalid_credentials": {
      "message": "Bucket cannot be accessed using provided combination of access key ID and secret access key."
-    },
-    "invalid_endpoint_url": {
-      "message": "Invalid endpoint URL. Please make sure it's a valid AWS S3 endpoint URL."
    }
  }
 }
@@ -2,7 +2,7 @@

 from collections.abc import Mapping
 from ipaddress import ip_address
-from typing import TYPE_CHECKING, Any
+from typing import Any
 from urllib.parse import urlsplit

 import voluptuous as vol
@@ -49,9 +49,6 @@ from .const import (
 from .errors import AuthenticationRequired, CannotConnect
 from .hub import AxisHub, get_axis_api

-if TYPE_CHECKING:
-    import axis
-
 AXIS_OUI = {"00:40:8c", "ac:cc:8e", "b8:a4:4f", "e8:27:25"}
 DEFAULT_PORT = 443
 DEFAULT_PROTOCOL = "https"
@@ -96,8 +93,7 @@ class AxisFlowHandler(ConfigFlow, domain=DOMAIN):
                errors["base"] = "cannot_connect"

            else:
-                if (serial := self._get_serial_number(api)) is None:
-                    return self.async_abort(reason="no_serial_number")
+                serial = api.vapix.serial_number
                config = {
                    CONF_PROTOCOL: user_input[CONF_PROTOCOL],
                    CONF_HOST: user_input[CONF_HOST],
@@ -262,19 +258,6 @@ class AxisFlowHandler(ConfigFlow, domain=DOMAIN):

        return await self.async_step_user()

-    @staticmethod
-    def _get_serial_number(api: axis.AxisDevice) -> str | None:
-        """Retrieve the device serial number from the Axis API.
-
-        Tries basic_device_info first, then property_handler. Returns None if not found.
-        """
-        vapix = api.vapix
-        if vapix.basic_device_info.initialized:
-            return vapix.basic_device_info["0"].serial_number
-        if vapix.params.property_handler.initialized:
-            return vapix.params.property_handler["0"].system_serial_number
-        return None
-

 class AxisOptionsFlowHandler(OptionsFlow):
    """Handle Axis device options."""
@@ -3,7 +3,6 @@
    "abort": {
      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
      "link_local_address": "Link local addresses are not supported",
-      "no_serial_number": "Could not retrieve a serial number from the device. Please check device connectivity and try again.",
      "not_axis_device": "Discovered device not an Axis device",
      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]",
      "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]",
@@ -1,7 +1,7 @@
 .trigger_common_fields:
  behavior: &trigger_behavior
    required: true
-    default: each
+    default: any
    selector:
      automation_behavior:
        mode: trigger
@@ -32,7 +32,6 @@ PLATFORMS = [
    Platform.LIGHT,
    Platform.SENSOR,
    Platform.SWITCH,
-    Platform.UPDATE,
 ]

 PARALLEL_UPDATES = 0
@@ -3,7 +3,7 @@
 from typing import Any

 import blebox_uniapi.cover
-from blebox_uniapi.cover import BleboxCoverState, UnifiedCoverType
+from blebox_uniapi.cover import BleboxCoverState

 from homeassistant.components.cover import (
    ATTR_POSITION,
@@ -25,19 +25,6 @@ BLEBOX_TO_COVER_DEVICE_CLASSES = {
    "shutter": CoverDeviceClass.SHUTTER,
 }

-UNIFIED_COVER_TYPE_TO_DEVICE_CLASS = {
-    UnifiedCoverType.AWNING: CoverDeviceClass.AWNING,
-    UnifiedCoverType.BLIND: CoverDeviceClass.BLIND,
-    UnifiedCoverType.CURTAIN: CoverDeviceClass.CURTAIN,
-    UnifiedCoverType.DAMPER: CoverDeviceClass.DAMPER,
-    UnifiedCoverType.DOOR: CoverDeviceClass.DOOR,
-    UnifiedCoverType.GARAGE: CoverDeviceClass.GARAGE,
-    UnifiedCoverType.GATE: CoverDeviceClass.GATE,
-    UnifiedCoverType.SHADE: CoverDeviceClass.SHADE,
-    UnifiedCoverType.SHUTTER: CoverDeviceClass.SHUTTER,
-    UnifiedCoverType.WINDOW: CoverDeviceClass.WINDOW,
-}
-
 BLEBOX_TO_HASS_COVER_STATES = {
    None: None,
    # all blebox covers
@@ -72,6 +59,7 @@ class BleBoxCoverEntity(BleBoxEntity[blebox_uniapi.cover.Cover], CoverEntity):
    def __init__(self, feature: blebox_uniapi.cover.Cover) -> None:
        """Initialize a BleBox cover feature."""
        super().__init__(feature)
+        self._attr_device_class = BLEBOX_TO_COVER_DEVICE_CLASSES[feature.device_class]
        self._attr_supported_features = (
            CoverEntityFeature.OPEN | CoverEntityFeature.CLOSE
        )
@@ -88,21 +76,6 @@ class BleBoxCoverEntity(BleBoxEntity[blebox_uniapi.cover.Cover], CoverEntity):
                | CoverEntityFeature.CLOSE_TILT
            )

-        if feature.tilt_only:
-            self._attr_supported_features &= ~(
-                CoverEntityFeature.OPEN
-                | CoverEntityFeature.CLOSE
-                | CoverEntityFeature.SET_POSITION
-                | CoverEntityFeature.STOP
-            )
-
-    @property
-    def device_class(self) -> CoverDeviceClass | None:
-        """Return the device class based on cover type when available."""
-        if (cover_type := self._feature.cover_type) is not None:
-            return UNIFIED_COVER_TYPE_TO_DEVICE_CLASS[cover_type]
-        return BLEBOX_TO_COVER_DEVICE_CLASSES[self._feature.device_class]
-
    @property
    def current_cover_position(self) -> int | None:
        """Return the current cover position."""
@@ -145,8 +118,7 @@ class BleBoxCoverEntity(BleBoxEntity[blebox_uniapi.cover.Cover], CoverEntity):

    async def async_open_cover_tilt(self, **kwargs: Any) -> None:
        """Fully open the cover tilt."""
-        position = 50 if self._feature.is_tilt_180 else 0
-        await self._feature.async_set_tilt_position(position)
+        await self._feature.async_set_tilt_position(0)

    async def async_close_cover_tilt(self, **kwargs: Any) -> None:
        """Fully close the cover tilt."""
@@ -7,6 +7,6 @@
  "integration_type": "device",
  "iot_class": "local_polling",
  "loggers": ["blebox_uniapi"],
-  "requirements": ["blebox-uniapi==2.5.4"],
+  "requirements": ["blebox-uniapi==2.5.3"],
  "zeroconf": ["_bbxsrv._tcp.local."]
 }
@@ -1,141 +0,0 @@
-"""BleBox update entities implementation."""
-
-from datetime import timedelta
-from typing import Any, Final
-
-from blebox_uniapi.error import ConnectionError as BleBoxConnectionError, Error
-import blebox_uniapi.update
-
-from homeassistant.components.update import (
-    UpdateDeviceClass,
-    UpdateEntity,
-    UpdateEntityFeature,
-)
-from homeassistant.core import CALLBACK_TYPE, HomeAssistant
-from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers import device_registry as dr
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-from homeassistant.helpers.event import async_call_later
-
-from . import BleBoxConfigEntry
-from .entity import BleBoxEntity
-
-SCAN_INTERVAL = timedelta(hours=1)
-
-
-_POLL_INTERVAL_SECONDS: Final = 10
-_MAX_POLL_ATTEMPTS: Final = 30
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    config_entry: BleBoxConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up a BleBox update entry."""
-    entities = [
-        BleBoxUpdateEntity(feature)
-        for feature in config_entry.runtime_data.features.get("updates", [])
-    ]
-    async_add_entities(entities, True)
-
-
-class BleBoxUpdateEntity(BleBoxEntity[blebox_uniapi.update.Update], UpdateEntity):
-    """Representation of BleBox updates."""
-
-    _attr_device_class = UpdateDeviceClass.FIRMWARE
-    _attr_supported_features = (
-        UpdateEntityFeature.INSTALL | UpdateEntityFeature.PROGRESS
-    )
-
-    def __init__(self, feature: blebox_uniapi.update.Update) -> None:
-        """Initialize the update entity."""
-        super().__init__(feature)
-        self._in_progress_old_version: str | None = None
-        self._poll_cancel: CALLBACK_TYPE | None = None
-        self._poll_attempts: int = 0
-
-    @property
-    def in_progress(self) -> bool:
-        """Return True while the device hasn't yet rebooted to the new firmware."""
-        return (
-            self._in_progress_old_version is not None
-            and self._in_progress_old_version == self._feature.installed_version
-        )
-
-    def _sync_sw_version(self) -> None:
-        """Sync installed firmware version to the device registry."""
-        if self.device_entry:
-            dr.async_get(self.hass).async_update_device(
-                self.device_entry.id,
-                sw_version=self._feature.installed_version,
-            )
-
-    async def async_update(self) -> None:
-        """Update state and refresh sw_version in device registry."""
-        try:
-            await self._feature.async_update()
-        except Error as ex:
-            raise HomeAssistantError(ex) from ex
-        self._sync_sw_version()
-
-    @property
-    def installed_version(self) -> str | None:
-        """Version installed and in use."""
-        return self._feature.installed_version
-
-    @property
-    def latest_version(self) -> str | None:
-        """Latest version available for install."""
-        return self._feature.latest_version
-
-    def _cancel_poll(self) -> None:
-        if self._poll_cancel is not None:
-            self._poll_cancel()
-            self._poll_cancel = None
-
-    def _reset_progress(self) -> None:
-        self._in_progress_old_version = None
-        self._poll_attempts = 0
-        self.async_write_ha_state()
-
-    async def async_install(
-        self, version: str | None, backup: bool, **kwargs: Any
-    ) -> None:
-        """Install an update."""
-        self._cancel_poll()
-        self._in_progress_old_version = self._feature.installed_version
-        self._poll_attempts = 0
-        self.async_write_ha_state()
-        try:
-            await self._feature.async_install()
-        except Error as ex:
-            self._reset_progress()
-            raise HomeAssistantError(ex) from ex
-        self._poll_cancel = async_call_later(
-            self.hass, _POLL_INTERVAL_SECONDS, self._poll_until_updated
-        )
-
-    async def async_will_remove_from_hass(self) -> None:
-        """Cancel any pending poll timer when the entity is removed."""
-        self._cancel_poll()
-
-    async def _poll_until_updated(self, _now: Any) -> None:
-        """Poll device until the installed version changes after OTA reboot."""
-        self._poll_cancel = None
-        self._poll_attempts += 1
-        try:
-            await self._feature.async_update()
-        except BleBoxConnectionError:
-            pass
-        except Error:
-            self._reset_progress()
-            return
-        else:
-            self._sync_sw_version()
-        if self.in_progress and self._poll_attempts < _MAX_POLL_ATTEMPTS:
-            self._poll_cancel = async_call_later(
-                self.hass, _POLL_INTERVAL_SECONDS, self._poll_until_updated
-            )
-        else:
-            self._reset_progress()
@@ -124,9 +124,7 @@ async def async_setup_entry(
            BlueMaestroBluetoothSensorEntity, async_add_entities
        )
    )
-    entry.async_on_unload(
-        coordinator.async_register_processor(processor, SensorEntityDescription)
-    )
+    entry.async_on_unload(coordinator.async_register_processor(processor))


 class BlueMaestroBluetoothSensorEntity(
@@ -22,7 +22,6 @@ from homeassistant.config_entries import (
    ConfigFlowResult,
    OptionsFlow,
 )
-from homeassistant.const import CONF_SOURCE
 from homeassistant.core import callback
 from homeassistant.helpers.schema_config_entry_flow import (
    SchemaCommonFlowHandler,
@@ -41,6 +40,7 @@ from .const import (
    CONF_DETAILS,
    CONF_MODE,
    CONF_PASSIVE,
+    CONF_SOURCE,
    CONF_SOURCE_CONFIG_ENTRY_ID,
    CONF_SOURCE_DEVICE_ID,
    CONF_SOURCE_DOMAIN,
@@ -22,6 +22,9 @@ CONF_PASSIVE = "passive"

 DEFAULT_MODE = BluetoothScanningMode.AUTO.value

+
+# pylint: disable-next=home-assistant-duplicate-const
+CONF_SOURCE: Final = "source"
 CONF_SOURCE_DOMAIN: Final = "source_domain"
 CONF_SOURCE_MODEL: Final = "source_model"
 CONF_SOURCE_CONFIG_ENTRY_ID: Final = "source_config_entry_id"
@@ -21,11 +21,7 @@ from habluetooth import (
 )

 from homeassistant import config_entries
-from homeassistant.const import (
-    CONF_SOURCE,
-    EVENT_HOMEASSISTANT_STOP,
-    EVENT_LOGGING_CHANGED,
-)
+from homeassistant.const import EVENT_HOMEASSISTANT_STOP, EVENT_LOGGING_CHANGED
 from homeassistant.core import (
    CALLBACK_TYPE,
    Event,
@@ -37,6 +33,7 @@ from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.util.package import is_docker_env

 from .const import (
+    CONF_SOURCE,
    CONF_SOURCE_CONFIG_ENTRY_ID,
    CONF_SOURCE_DEVICE_ID,
    CONF_SOURCE_DOMAIN,
@@ -17,10 +17,10 @@
  "requirements": [
    "bleak==3.0.2",
    "bleak-retry-connector==4.6.1",
-    "bluetooth-adapters==2.3.0",
+    "bluetooth-adapters==2.1.0",
    "bluetooth-auto-recovery==1.6.4",
    "bluetooth-data-tools==1.29.18",
-    "dbus-fast==5.0.15",
-    "habluetooth==6.7.9"
+    "dbus-fast==5.0.9",
+    "habluetooth==6.7.3"
  ]
 }
@@ -17,7 +17,6 @@ BTHOME_BLE_EVENT: Final = "bthome_ble_event"

 EVENT_CLASS_BUTTON: Final = "button"
 EVENT_CLASS_DIMMER: Final = "dimmer"
-EVENT_CLASS_COMMAND: Final = "command"

 CONF_EVENT_CLASS: Final = "event_class"
 CONF_EVENT_PROPERTIES: Final = "event_properties"
@@ -28,7 +28,6 @@ from .const import (
    DOMAIN,
    EVENT_CLASS,
    EVENT_CLASS_BUTTON,
-    EVENT_CLASS_COMMAND,
    EVENT_CLASS_DIMMER,
    EVENT_TYPE,
 )
@@ -44,7 +43,6 @@ EVENT_TYPES_BY_EVENT_CLASS = {
        "hold_press",
    },
    EVENT_CLASS_DIMMER: {"rotate_left", "rotate_right"},
-    EVENT_CLASS_COMMAND: {"off", "on", "toggle", "step_up", "step_down"},
 }

 TRIGGER_SCHEMA = DEVICE_TRIGGER_BASE_SCHEMA.extend(
@@ -16,7 +16,6 @@ from . import format_discovered_event_class, format_event_dispatcher_name
 from .const import (
    DOMAIN,
    EVENT_CLASS_BUTTON,
-    EVENT_CLASS_COMMAND,
    EVENT_CLASS_DIMMER,
    EVENT_PROPERTIES,
    EVENT_TYPE,
@@ -44,11 +43,6 @@ DESCRIPTIONS_BY_EVENT_CLASS = {
        translation_key="dimmer",
        event_types=["rotate_left", "rotate_right"],
    ),
-    EVENT_CLASS_COMMAND: EventEntityDescription(
-        key=EVENT_CLASS_COMMAND,
-        translation_key="command",
-        event_types=["off", "on", "toggle", "step_up", "step_down"],
-    ),
 }


@@ -20,5 +20,5 @@
  "dependencies": ["bluetooth_adapters"],
  "documentation": "https://www.home-assistant.io/integrations/bthome",
  "iot_class": "local_push",
-  "requirements": ["bthome-ble==3.23.2"]
+  "requirements": ["bthome-ble==3.17.0"]
 }
@@ -192,12 +192,6 @@ SENSOR_DESCRIPTIONS = {
        native_unit_of_measurement=LIGHT_LUX,
        state_class=SensorStateClass.MEASUREMENT,
    ),
-    # Light level (-)
-    (BTHomeExtendedSensorDeviceClass.LIGHT_LEVEL, None): SensorEntityDescription(
-        key=str(BTHomeExtendedSensorDeviceClass.LIGHT_LEVEL),
-        state_class=SensorStateClass.MEASUREMENT,
-        translation_key="light_level",
-    ),
    # Mass sensor (kg)
    (BTHomeSensorDeviceClass.MASS, Units.MASS_KILOGRAMS): SensorEntityDescription(
        key=f"{BTHomeSensorDeviceClass.MASS}_{Units.MASS_KILOGRAMS}",
@@ -293,12 +287,6 @@ SENSOR_DESCRIPTIONS = {
        state_class=SensorStateClass.MEASUREMENT,
        translation_key="rotational_speed",
    ),
-    # Settings revision (-)
-    (BTHomeExtendedSensorDeviceClass.SETTINGS_REVISION, None): SensorEntityDescription(
-        key=str(BTHomeExtendedSensorDeviceClass.SETTINGS_REVISION),
-        entity_category=EntityCategory.DIAGNOSTIC,
-        translation_key="settings_revision",
-    ),
    # Signal Strength (RSSI) (dB)
    (
        BTHomeSensorDeviceClass.SIGNAL_STRENGTH,
@@ -36,19 +36,13 @@
      "long_double_press": "Long Double Press",
      "long_press": "Long Press",
      "long_triple_press": "Long Triple Press",
-      "off": "Off",
-      "on": "On",
      "press": "Press",
      "rotate_left": "Rotate Left",
      "rotate_right": "Rotate Right",
-      "step_down": "Step Down",
-      "step_up": "Step Up",
-      "toggle": "Toggle",
      "triple_press": "Triple Press"
    },
    "trigger_type": {
      "button": "Button \"{subtype}\"",
-      "command": "Command \"{subtype}\"",
      "dimmer": "Dimmer \"{subtype}\""
    }
  },
@@ -74,19 +68,6 @@
          }
        }
      },
-      "command": {
-        "state_attributes": {
-          "event_type": {
-            "state": {
-              "off": "Off",
-              "on": "On",
-              "step_down": "Step down",
-              "step_up": "Step up",
-              "toggle": "Toggle"
-            }
-          }
-        }
-      },
      "dimmer": {
        "state_attributes": {
          "event_type": {
@@ -117,9 +98,6 @@
      "gyroscope": {
        "name": "Gyroscope"
      },
-      "light_level": {
-        "name": "Light level"
-      },
      "packet_id": {
        "name": "Packet ID"
      },
@@ -132,9 +110,6 @@
      "rotational_speed": {
        "name": "Rotational speed"
      },
-      "settings_revision": {
-        "name": "Settings revision"
-      },
      "text": {
        "name": "Text"
      },
@@ -32,16 +32,8 @@ OPTIONS_SCHEMA = KNOWN_HOSTS_SCHEMA.extend(
        vol.Required(CONF_MORE_OPTIONS): section(
            vol.Schema(
                {
-                    vol.Optional(CONF_UUID): SelectSelector(
-                        SelectSelectorConfig(
-                            custom_value=True, options=[], multiple=True
-                        ),
-                    ),
-                    vol.Optional(CONF_IGNORE_CEC): SelectSelector(
-                        SelectSelectorConfig(
-                            custom_value=True, options=[], multiple=True
-                        ),
-                    ),
+                    vol.Optional(CONF_UUID): str,
+                    vol.Optional(CONF_IGNORE_CEC): str,
                }
            ),
            SectionConfig(collapsed=True),
@@ -117,11 +109,13 @@ class CastOptionsFlowHandler(OptionsFlow):
    ) -> ConfigFlowResult:
        """Manage the Google Cast options."""
        if user_input is not None:
-            ignore_cec = _trim_items(
-                user_input[CONF_MORE_OPTIONS].get(CONF_IGNORE_CEC, [])
+            ignore_cec = _string_to_list(
+                user_input[CONF_MORE_OPTIONS].get(CONF_IGNORE_CEC, "")
            )
            known_hosts = _trim_items(user_input.get(CONF_KNOWN_HOSTS, []))
-            wanted_uuid = _trim_items(user_input[CONF_MORE_OPTIONS].get(CONF_UUID, []))
+            wanted_uuid = _string_to_list(
+                user_input[CONF_MORE_OPTIONS].get(CONF_UUID, "")
+            )
            updated_config = dict(self.config_entry.data)
            updated_config[CONF_IGNORE_CEC] = ignore_cec
            updated_config[CONF_KNOWN_HOSTS] = known_hosts
@@ -138,7 +132,9 @@ class CastOptionsFlowHandler(OptionsFlow):
        for key in (CONF_UUID, CONF_IGNORE_CEC):
            if key not in self.config_entry.data:
                continue
-            suggested[CONF_MORE_OPTIONS][key] = self.config_entry.data[key]
+            suggested[CONF_MORE_OPTIONS][key] = _list_to_string(
+                self.config_entry.data[key]
+            )

        return self.async_show_form(
            step_id="init",
@@ -147,5 +143,16 @@ class CastOptionsFlowHandler(OptionsFlow):
        )


+def _list_to_string(items: list[str]) -> str:
+    comma_separated_string = ""
+    if items:
+        comma_separated_string = ",".join(items)
+    return comma_separated_string
+
+
+def _string_to_list(string: str) -> list[str]:
+    return [x.strip() for x in string.split(",") if x.strip()]
+
+
 def _trim_items(items: list[str]) -> list[str]:
    return [x.strip() for x in items if x.strip()]
@@ -1,57 +0,0 @@
-"""Diagnostics for the cert_expiry integration."""
-
-from typing import Any
-
-from homeassistant.components.diagnostics import async_redact_data
-from homeassistant.const import CONF_HOST
-from homeassistant.core import HomeAssistant
-
-from .coordinator import CertExpiryConfigEntry
-
-TO_REDACT = {CONF_HOST, "name", "title", "unique_id"}
-
-
-async def async_get_config_entry_diagnostics(
-    _hass: HomeAssistant,
-    entry: CertExpiryConfigEntry,
-) -> dict[str, Any]:
-    """Return diagnostics for a config entry."""
-    entry_diagnostics = entry.as_dict()
-
-    coordinator = getattr(entry, "runtime_data", None)
-
-    coordinator_diagnostics: dict[str, Any] = {
-        "host": None,
-        "port": None,
-        "name": None,
-        "expiry_datetime": None,
-        "is_cert_valid": None,
-        "cert_error": None,
-        "last_update_success": None,
-    }
-
-    if coordinator is not None:
-        expiry = coordinator.data.isoformat() if coordinator.data else None
-        cert_error = (
-            (
-                f"{type(coordinator.cert_error).__module__}."
-                f"{type(coordinator.cert_error).__qualname__}"
-            )
-            if coordinator.cert_error
-            else None
-        )
-
-        coordinator_diagnostics = {
-            "host": coordinator.host,
-            "port": coordinator.port,
-            "name": coordinator.name,
-            "expiry_datetime": expiry,
-            "is_cert_valid": coordinator.is_cert_valid,
-            "cert_error": cert_error,
-            "last_update_success": coordinator.last_update_success,
-        }
-
-    return {
-        "entry": async_redact_data(entry_diagnostics, TO_REDACT),
-        "coordinator": async_redact_data(coordinator_diagnostics, TO_REDACT),
-    }
@@ -1,81 +0,0 @@
-rules:
-  # Bronze
-  action-setup:
-    status: exempt
-    comment: Integration does not register custom actions.
-  appropriate-polling:
-    status: done
-    comment: Certificates are checked every 12 hours via DataUpdateCoordinator.
-  brands: done
-  common-modules: done
-  config-flow-test-coverage:
-    status: done
-    comment: test_abort_on_socket_failed can be parametrized and should end in CREATE_ENTRY to test flow recovery.
-  config-flow: done
-  dependency-transparency:
-    status: exempt
-    comment: Integration has no external library dependencies.
-  docs-actions:
-    status: exempt
-    comment: Integration does not register custom actions.
-  docs-high-level-description: done
-  docs-installation-instructions: done
-  docs-removal-instructions: done
-  entity-event-setup:
-    status: exempt
-    comment: Integration does not subscribe to events.
-  entity-unique-id: done
-  has-entity-name: done
-  runtime-data: done
-  test-before-configure: done
-  test-before-setup: todo
-  unique-config-entry: done
-  # Silver
-  action-exceptions:
-    status: exempt
-    comment: Integration does not register custom actions.
-  config-entry-unloading: done
-  docs-configuration-parameters: todo
-  docs-installation-parameters: todo
-  entity-unavailable: done
-  integration-owner: done
-  log-when-unavailable: done
-  parallel-updates: todo
-  reauthentication-flow:
-    status: exempt
-    comment: Config flow only collects host/port; the integration does not authenticate.
-  test-coverage:
-    status: todo
-    comment: Consider creating a mock_config_entry fixture and use that throughout tests.
-  # Gold
-  devices: done
-  diagnostics: todo
-  discovery: todo
-  discovery-update-info: todo
-  docs-data-update: todo
-  docs-examples: todo
-  docs-known-limitations: todo
-  docs-supported-devices: todo
-  docs-supported-functions: todo
-  docs-troubleshooting: todo
-  docs-use-cases: todo
-  dynamic-devices:
-    status: exempt
-    comment: Integration supports a single device per config entry.
-  entity-category:
-    status: todo
-    comment: Extra state attributes (is_valid, error) should be moved to separate entities in the future.
-  entity-device-class: done
-  entity-disabled-by-default: todo
-  entity-translations: done
-  exception-translations: todo
-  icon-translations: todo
-  reconfiguration-flow: done
-  repair-issues: todo
-  stale-devices:
-    status: exempt
-    comment: Integration supports a single device per config entry.
-  # Platinum
-  async-dependency: todo
-  inject-websession: todo
-  strict-typing: todo
@@ -16,10 +16,6 @@
          "host": "[%key:common::config_flow::data::host%]",
          "port": "[%key:common::config_flow::data::port%]"
        },
-        "data_description": {
-          "host": "The hostname or IP address of the server to monitor.",
-          "port": "The port to connect to on the server."
-        },
        "title": "Reconfigure the certificate to test"
      },
      "user": {
@@ -28,10 +24,6 @@
          "name": "The name of the certificate",
          "port": "[%key:common::config_flow::data::port%]"
        },
-        "data_description": {
-          "host": "The hostname or IP address of the server to monitor.",
-          "port": "The port to connect to on the server."
-        },
        "title": "Define the certificate to test"
      }
    }
@@ -7,7 +7,7 @@ from homeassistant.core import HomeAssistant, State
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.automation import DomainSpec
 from homeassistant.helpers.trigger import (
-    ENTITY_STATE_TRIGGER_SCHEMA_WITH_BEHAVIOR,
+    ENTITY_STATE_TRIGGER_SCHEMA_FIRST_LAST,
    EntityNumericalStateChangedTriggerBase,
    EntityNumericalStateChangedTriggerWithUnitBase,
    EntityNumericalStateCrossedThresholdTriggerBase,
@@ -26,7 +26,7 @@ from .const import ATTR_HUMIDITY, ATTR_HVAC_ACTION, DOMAIN, HVACAction, HVACMode

 CONF_HVAC_MODE = "hvac_mode"

-HVAC_MODE_CHANGED_TRIGGER_SCHEMA = ENTITY_STATE_TRIGGER_SCHEMA_WITH_BEHAVIOR.extend(
+HVAC_MODE_CHANGED_TRIGGER_SCHEMA = ENTITY_STATE_TRIGGER_SCHEMA_FIRST_LAST.extend(
    {
        vol.Required(CONF_OPTIONS): {
            vol.Required(CONF_HVAC_MODE): vol.All(
@@ -5,7 +5,7 @@
  fields:
    behavior: &trigger_behavior
      required: true
-      default: each
+      default: any
      selector:
        automation_behavior:
          mode: trigger
@@ -275,13 +275,9 @@ class CloudGoogleConfig(AbstractConfig):
            )
        )

-    def should_expose(self, entity_id: str) -> bool:
-        """If an entity should be exposed."""
-        entity_filter: EntityFilter = self._config[CONF_FILTER]
-        if not entity_filter.empty_filter:
-            return entity_filter(entity_id)
-
-        return async_should_expose(self.hass, CLOUD_GOOGLE, entity_id)
+    def should_expose(self, state: State) -> bool:
+        """If a state object should be exposed."""
+        return self._should_expose_entity_id(state.entity_id)

    def _should_expose_legacy(self, entity_id: str) -> bool:
        """If an entity ID should be exposed."""
@@ -312,6 +308,14 @@ class CloudGoogleConfig(AbstractConfig):
            and _supported_legacy(self.hass, entity_id)
        )

+    def _should_expose_entity_id(self, entity_id: str) -> bool:
+        """If an entity should be exposed."""
+        entity_filter: EntityFilter = self._config[CONF_FILTER]
+        if not entity_filter.empty_filter:
+            return entity_filter(entity_id)
+
+        return async_should_expose(self.hass, CLOUD_GOOGLE, entity_id)
+
    @property
    def agent_user_id(self) -> str:
        """Return Agent User Id to use for query responses."""
@@ -463,7 +467,7 @@ class CloudGoogleConfig(AbstractConfig):

        entity_id = event.data["entity_id"]

-        if not self.should_expose(entity_id):
+        if not self._should_expose_entity_id(entity_id):
            return

        self.async_schedule_google_sync_all()
@@ -486,7 +490,8 @@ class CloudGoogleConfig(AbstractConfig):

        # Check if any exposed entity uses the device area
        if not any(
-            entity_entry.area_id is None and self.should_expose(entity_entry.entity_id)
+            entity_entry.area_id is None
+            and self._should_expose_entity_id(entity_entry.entity_id)
            for entity_entry in er.async_entries_for_device(
                er.async_get(self.hass), event.data["device_id"]
            )
@@ -5,5 +5,3 @@ ATTR_URL = "color_extract_url"

 DOMAIN = "color_extractor"
 DEFAULT_NAME = "Color extractor"
-
-SERVICE_GET_COLOR = "get_color"
@@ -1,8 +1,5 @@
 {
  "services": {
-    "get_color": {
-      "service": "mdi:select-color"
-    },
    "turn_on": {
      "service": "mdi:lightbulb-on"
    }
@@ -3,7 +3,6 @@
 import asyncio
 import io
 import logging
-from typing import Any

 import aiohttp
 from colorthief import ColorThief
@@ -16,16 +15,15 @@ from homeassistant.components.light import (
    LIGHT_TURN_ON_SCHEMA,
 )
 from homeassistant.const import SERVICE_TURN_ON
-from homeassistant.core import HomeAssistant, ServiceCall, SupportsResponse, callback
-from homeassistant.exceptions import ServiceValidationError
+from homeassistant.core import HomeAssistant, ServiceCall, callback
 from homeassistant.helpers import aiohttp_client, config_validation as cv

-from .const import ATTR_PATH, ATTR_URL, DOMAIN, SERVICE_GET_COLOR
+from .const import ATTR_PATH, ATTR_URL, DOMAIN

 _LOGGER = logging.getLogger(__name__)

 # Extend the existing light.turn_on service schema
-TURN_ON_SERVICE_SCHEMA = vol.All(
+SERVICE_SCHEMA = vol.All(
    cv.has_at_least_one_key(ATTR_URL, ATTR_PATH),
    cv.make_entity_service_schema(
        {
@@ -36,14 +34,6 @@ TURN_ON_SERVICE_SCHEMA = vol.All(
    ),
 )

-GET_COLOR_SERVICE_SCHEMA = vol.All(
-    cv.has_at_least_one_key(ATTR_URL, ATTR_PATH),
-    {
-        vol.Exclusive(ATTR_PATH, "color_extractor"): cv.isfile,
-        vol.Exclusive(ATTR_URL, "color_extractor"): cv.url,
-    },
-)
-

 def _get_file(file_path: str) -> str:
    """Get a PIL acceptable input file reference.
@@ -155,50 +145,6 @@ async def async_handle_service(service_call: ServiceCall) -> None:
        )


-async def async_handle_get_color(
-    service_call: ServiceCall,
-) -> dict[str, Any]:
-    """Handle get_color service call."""
-    service_data = dict(service_call.data)
-
-    try:
-        if ATTR_URL in service_data:
-            image_type = "URL"
-            image_reference = service_data.pop(ATTR_URL)
-            color = await _async_extract_color_from_url(
-                service_call.hass, image_reference
-            )
-
-        elif ATTR_PATH in service_data:
-            image_type = "file path"
-            image_reference = service_data.pop(ATTR_PATH)
-            color = await service_call.hass.async_add_executor_job(
-                _extract_color_from_path, service_call.hass, image_reference
-            )
-
-    except UnidentifiedImageError as ex:
-        raise ServiceValidationError(
-            translation_domain=DOMAIN,
-            translation_key="invalid_image",
-            translation_placeholders={
-                "image_type": image_type,
-                "image_reference": image_reference,
-            },
-        ) from ex
-
-    if color is None:
-        raise ServiceValidationError(
-            translation_domain=DOMAIN,
-            translation_key="invalid_image",
-            translation_placeholders={
-                "image_type": image_type,
-                "image_reference": image_reference,
-            },
-        )
-
-    return {"color": color}
-
-
@callback
 def async_setup_services(hass: HomeAssistant) -> None:
    """Register the services."""
@@ -207,13 +153,5 @@ def async_setup_services(hass: HomeAssistant) -> None:
        DOMAIN,
        SERVICE_TURN_ON,
        async_handle_service,
-        schema=TURN_ON_SERVICE_SCHEMA,
-    )
-
-    hass.services.async_register(
-        DOMAIN,
-        SERVICE_GET_COLOR,
-        async_handle_get_color,
-        schema=GET_COLOR_SERVICE_SCHEMA,
-        supports_response=SupportsResponse.ONLY,
+        schema=SERVICE_SCHEMA,
    )
@@ -11,13 +11,3 @@ turn_on:
      example: /opt/images/logo.png
      selector:
        text:
-get_color:
-  fields:
-    color_extract_url:
-      example: https://www.example.com/images/logo.png
-      selector:
-        text:
-    color_extract_path:
-      example: /opt/images/logo.png
-      selector:
-        text:
@@ -6,26 +6,7 @@
      }
    }
  },
-  "exceptions": {
-    "invalid_image": {
-      "message": "Bad image {image_reference} from {image_type} provided, are you sure it's an image?"
-    }
-  },
  "services": {
-    "get_color": {
-      "description": "Gets the predominant RGB color found in the image provided by URL or file path.",
-      "fields": {
-        "color_extract_path": {
-          "description": "The full system path to the image we want to extract RGB values from. Must be allowed in allowlist_external_dirs.",
-          "name": "[%key:common::config_flow::data::path%]"
-        },
-        "color_extract_url": {
-          "description": "The URL of the image we want to extract RGB values from. Must be allowed in allowlist_external_urls.",
-          "name": "[%key:common::config_flow::data::url%]"
-        }
-      },
-      "name": "Get predominant color"
-    },
    "turn_on": {
      "description": "Sets the light RGB to the predominant color found in the image provided by URL or file path.",
      "fields": {
@@ -175,6 +175,7 @@ class ConfigManagerFlowIndexView(
        vol.Schema(
            {
                vol.Required("handler"): vol.Any(str, list),
+                vol.Optional("show_advanced_options", default=False): cv.boolean,
                vol.Optional("entry_id"): cv.string,
            },
            extra=vol.ALLOW_EXTRA,
@@ -301,6 +302,7 @@ class SubentryManagerFlowIndexView(
        vol.Schema(
            {
                vol.Required("handler"): vol.All(vol.Coerce(tuple), (str, str)),
+                vol.Optional("show_advanced_options", default=False): cv.boolean,
            },
            extra=vol.ALLOW_EXTRA,
        )
@@ -60,9 +60,7 @@ class CheckConfigView(HomeAssistantView):
        vol.Optional("location_name"): str,
        vol.Optional("longitude"): cv.longitude,
        vol.Optional("radius"): cv.positive_int,
-        # Validated by async_set_time_zone in the executor to avoid
-        # blocking I/O loading zoneinfo data on the event loop.
-        vol.Optional("time_zone"): str,
+        vol.Optional("time_zone"): cv.time_zone,
        vol.Optional("update_units"): bool,
        vol.Optional("unit_system"): unit_system.validate_unit_system,
    }
@@ -5,7 +5,7 @@
  fields:
    behavior:
      required: true
-      default: each
+      default: any
      selector:
        automation_behavior:
          mode: trigger
@@ -1,7 +1,7 @@
 .trigger_common_fields: &trigger_common_fields
  behavior:
    required: true
-    default: each
+    default: any
    selector:
      automation_behavior:
        mode: trigger
@@ -6,6 +6,6 @@
  "documentation": "https://www.home-assistant.io/integrations/data_grand_lyon",
  "integration_type": "service",
  "iot_class": "cloud_polling",
-  "quality_scale": "platinum",
+  "quality_scale": "silver",
  "requirements": ["data-grand-lyon-ha==0.7.0"]
 }
@@ -49,15 +49,13 @@ rules:
    status: exempt
    comment: This is a service integration; there are no discoverable devices.
  docs-data-update: done
-  docs-examples: done
+  docs-examples: todo
  docs-known-limitations: done
  docs-supported-devices: done
  docs-supported-functions: done
  docs-troubleshooting: done
  docs-use-cases: done
-  dynamic-devices:
-    status: exempt
-    comment: This is a service integration; devices are added and removed manually by the user.
+  dynamic-devices: done
  entity-category: done
  entity-device-class: done
  entity-disabled-by-default: done
@@ -68,9 +66,7 @@ rules:
  repair-issues:
    status: exempt
    comment: no known use cases for repair issues or flows, yet
-  stale-devices:
-    status: exempt
-    comment: This is a service integration; devices are added and removed manually by the user.
+  stale-devices: done

  # Platinum
  async-dependency: done
@@ -3,14 +3,23 @@
 import asyncio
 from typing import Any

-from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import STATE_HOME
+from homeassistant.const import ATTR_GPS_ACCURACY, STATE_HOME  # noqa: F401
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import discovery
 from homeassistant.helpers.entity_component import EntityComponent
 from homeassistant.helpers.typing import ConfigType
-from homeassistant.util.hass_dict import HassKey

+from .config_entry import (  # noqa: F401
+    DATA_COMPONENT,
+    BaseScannerEntity,
+    BaseTrackerEntity,
+    ScannerEntity,
+    ScannerEntityDescription,
+    TrackerEntity,
+    TrackerEntityDescription,
+    async_setup_entry,
+    async_unload_entry,
+)
 from .const import (  # noqa: F401
    ATTR_ATTRIBUTES,
    ATTR_BATTERY,
@@ -22,7 +31,6 @@ from .const import (  # noqa: F401
    ATTR_LOCATION_NAME,
    ATTR_MAC,
    ATTR_SOURCE_TYPE,
-    CONF_ASSOCIATED_ZONE,
    CONF_CONSIDER_HOME,
    CONF_NEW_DEVICE_DEFAULTS,
    CONF_SCAN_INTERVAL,
@@ -37,14 +45,6 @@ from .const import (  # noqa: F401
    SCAN_INTERVAL,
    SourceType,
 )
-from .entity import (  # noqa: F401
-    BaseScannerEntity,
-    BaseTrackerEntity,
-    ScannerEntity,
-    ScannerEntityDescription,
-    TrackerEntity,
-    TrackerEntityDescription,
-)
 from .legacy import (  # noqa: F401
    PLATFORM_SCHEMA,
    PLATFORM_SCHEMA_BASE,
@@ -60,8 +60,6 @@ from .legacy import (  # noqa: F401
    see,
 )

-DATA_COMPONENT: HassKey[EntityComponent[BaseTrackerEntity]] = HassKey(DOMAIN)
-

 def is_on(hass: HomeAssistant, entity_id: str) -> bool:
    """Return the state if any or a specified device is home."""
@@ -110,23 +108,3 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
        eager_start=True,
    )
    return True
-
-
-async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
-    """Set up an entry."""
-    component: EntityComponent[BaseTrackerEntity] | None = hass.data.get(DOMAIN)
-
-    if component is not None:
-        return await component.async_setup_entry(entry)
-
-    component = hass.data[DATA_COMPONENT] = EntityComponent[BaseTrackerEntity](
-        LOGGER, DOMAIN, hass
-    )
-    component.register_shutdown()
-
-    return await component.async_setup_entry(entry)
-
-
-async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
-    """Unload an entry."""
-    return await hass.data[DATA_COMPONENT].async_unload_entry(entry)
@@ -1,45 +1,500 @@
 """Code to set up a device tracker platform using a config entry."""

-from functools import partial
+import asyncio
+from typing import Any, final

-from homeassistant.helpers.deprecation import (
-    DeprecatedAlias,
-    all_with_deprecated_constants,
-    check_if_deprecated_constant,
-    dir_with_deprecated_constants,
+from propcache.api import cached_property
+
+from homeassistant.components import zone
+from homeassistant.components.zone import ATTR_PASSIVE, ATTR_RADIUS
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import (
+    ATTR_BATTERY_LEVEL,
+    ATTR_GPS_ACCURACY,
+    ATTR_LATITUDE,
+    ATTR_LONGITUDE,
+    STATE_HOME,
+    STATE_NOT_HOME,
+    EntityCategory,
+)
+from homeassistant.core import Event, HomeAssistant, State, callback
+from homeassistant.helpers import device_registry as dr, entity_registry as er
+from homeassistant.helpers.device_registry import (
+    DeviceInfo,
+    EventDeviceRegistryUpdatedData,
+)
+from homeassistant.helpers.dispatcher import async_dispatcher_send
+from homeassistant.helpers.entity import Entity, EntityDescription
+from homeassistant.helpers.entity_component import EntityComponent
+from homeassistant.helpers.entity_platform import EntityPlatform
+from homeassistant.helpers.typing import StateType
+from homeassistant.util.hass_dict import HassKey
+
+from .const import (
+    ATTR_HOST_NAME,
+    ATTR_IN_ZONES,
+    ATTR_IP,
+    ATTR_MAC,
+    ATTR_SOURCE_TYPE,
+    CONNECTED_DEVICE_REGISTERED,
+    DOMAIN,
+    LOGGER,
+    SourceType,
 )

-from . import (
-    BaseTrackerEntity as _BaseTrackerEntity,
-    ScannerEntity as _ScannerEntity,
-    SourceType as _SourceType,
-    TrackerEntity as _TrackerEntity,
-    TrackerEntityDescription as _TrackerEntityDescription,
-)
+DATA_COMPONENT: HassKey[EntityComponent[BaseTrackerEntity]] = HassKey(DOMAIN)
+DATA_KEY: HassKey[dict[str, tuple[str, str]]] = HassKey(f"{DOMAIN}_mac")

-_DEPRECATED_TrackerEntity = DeprecatedAlias(
-    _TrackerEntity, "homeassistant.components.device_tracker.TrackerEntity", "2027.6"
-)
-_DEPRECATED_ScannerEntity = DeprecatedAlias(
-    _ScannerEntity, "homeassistant.components.device_tracker.ScannerEntity", "2027.6"
-)
-_DEPRECATED_BaseTrackerEntity = DeprecatedAlias(
-    _BaseTrackerEntity,
-    "homeassistant.components.device_tracker.BaseTrackerEntity",
-    "2027.6",
-)
-_DEPRECATED_TrackerEntityDescription = DeprecatedAlias(
-    _TrackerEntityDescription,
-    "homeassistant.components.device_tracker.TrackerEntityDescription",
-    "2027.6",
-)
-_DEPRECATED_SourceType = DeprecatedAlias(
-    _SourceType, "homeassistant.components.device_tracker.SourceType", "2027.6"
-)
+# mypy: disallow-any-generics

-# These can be removed if no deprecated aliases are in this module anymore
-__getattr__ = partial(check_if_deprecated_constant, module_globals=globals())
-__dir__ = partial(
-    dir_with_deprecated_constants, module_globals_keys=[*globals().keys()]
-)
-__all__ = all_with_deprecated_constants(globals())
+
+async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+    """Set up an entry."""
+    component: EntityComponent[BaseTrackerEntity] | None = hass.data.get(DOMAIN)
+
+    if component is not None:
+        return await component.async_setup_entry(entry)
+
+    component = hass.data[DATA_COMPONENT] = EntityComponent[BaseTrackerEntity](
+        LOGGER, DOMAIN, hass
+    )
+    component.register_shutdown()
+
+    return await component.async_setup_entry(entry)
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+    """Unload an entry."""
+    return await hass.data[DATA_COMPONENT].async_unload_entry(entry)
+
+
+@callback
+def _async_connected_device_registered(
+    hass: HomeAssistant, mac: str, ip_address: str | None, hostname: str | None
+) -> None:
+    """Register a newly seen connected device.
+
+    This is currently used by the dhcp integration
+    to listen for newly registered connected devices
+    for discovery.
+    """
+    async_dispatcher_send(
+        hass,
+        CONNECTED_DEVICE_REGISTERED,
+        {
+            ATTR_IP: ip_address,
+            ATTR_MAC: mac,
+            ATTR_HOST_NAME: hostname,
+        },
+    )
+
+
+@callback
+def _async_register_mac(
+    hass: HomeAssistant,
+    domain: str,
+    mac: str,
+    unique_id: str,
+) -> None:
+    """Register a mac address with a unique ID."""
+    mac = dr.format_mac(mac)
+    if DATA_KEY in hass.data:
+        hass.data[DATA_KEY][mac] = (domain, unique_id)
+        return
+
+    # Setup listening.
+
+    # dict mapping mac -> partial unique ID
+    data = hass.data[DATA_KEY] = {mac: (domain, unique_id)}
+
+    @callback
+    def handle_device_event(ev: Event[EventDeviceRegistryUpdatedData]) -> None:
+        """Enable the online status entity for the mac of a newly created device."""
+        # Only for new devices
+        if ev.data["action"] != "create":
+            return
+
+        dev_reg = dr.async_get(hass)
+        device_entry = dev_reg.async_get(ev.data["device_id"])
+
+        if device_entry is None:
+            # This should not happen, since the device was just created.
+            return
+
+        # Check if device has a mac
+        mac = None
+        for conn in device_entry.connections:
+            if conn[0] == dr.CONNECTION_NETWORK_MAC:
+                mac = conn[1]
+                break
+
+        if mac is None:
+            return
+
+        # Check if we have an entity for this mac
+        if (unique_id := data.get(mac)) is None:
+            return
+
+        ent_reg = er.async_get(hass)
+
+        if (entity_id := ent_reg.async_get_entity_id(DOMAIN, *unique_id)) is None:
+            return
+
+        entity_entry = ent_reg.entities[entity_id]
+
+        # Make sure entity has a config entry and was disabled by the
+        # default disable logic in the integration and new entities
+        # are allowed to be added.
+        if (
+            entity_entry.config_entry_id is None
+            or (
+                (
+                    config_entry := hass.config_entries.async_get_entry(
+                        entity_entry.config_entry_id
+                    )
+                )
+                is not None
+                and config_entry.pref_disable_new_entities
+            )
+            or entity_entry.disabled_by != er.RegistryEntryDisabler.INTEGRATION
+        ):
+            return
+
+        # Enable entity
+        ent_reg.async_update_entity(entity_id, disabled_by=None)
+
+    hass.bus.async_listen(dr.EVENT_DEVICE_REGISTRY_UPDATED, handle_device_event)
+
+
+class BaseTrackerEntity(Entity):
+    """Represent a tracked device.
+
+    Not intended to be directly inherited by integrations. Integrations should
+    inherit TrackerEntity, BaseScannerEntity or ScannerEntity instead.
+    """
+
+    _attr_device_info: None = None
+    _attr_entity_category = EntityCategory.DIAGNOSTIC
+    _attr_source_type: SourceType
+
+    @cached_property
+    def battery_level(self) -> int | None:
+        """Return the battery level of the device.
+
+        Percentage from 0-100.
+        """
+        return None
+
+    @property
+    def source_type(self) -> SourceType:
+        """Return the source type, eg gps or router, of the device."""
+        if hasattr(self, "_attr_source_type"):
+            return self._attr_source_type
+        raise NotImplementedError
+
+    @property
+    def state_attributes(self) -> dict[str, StateType]:
+        """Return the device state attributes."""
+        attr: dict[str, StateType] = {ATTR_SOURCE_TYPE: self.source_type}
+
+        if self.battery_level is not None:
+            attr[ATTR_BATTERY_LEVEL] = self.battery_level
+
+        return attr
+
+
+class TrackerEntityDescription(EntityDescription, frozen_or_thawed=True):
+    """A class that describes tracker entities."""
+
+
+CACHED_TRACKER_PROPERTIES_WITH_ATTR_ = {
+    "in_zones",
+    "latitude",
+    "location_accuracy",
+    "location_name",
+    "longitude",
+}
+
+
+class TrackerEntity(
+    BaseTrackerEntity, cached_properties=CACHED_TRACKER_PROPERTIES_WITH_ATTR_
+):
+    """Base class for a tracked device."""
+
+    entity_description: TrackerEntityDescription
+    _attr_in_zones: list[str] | None = None
+    _attr_latitude: float | None = None
+    _attr_location_accuracy: float = 0
+    _attr_location_name: str | None = None
+    _attr_longitude: float | None = None
+    _attr_source_type: SourceType = SourceType.GPS
+
+    __active_zone: State | None = None
+    __in_zones: list[str] | None = None
+
+    @cached_property
+    def should_poll(self) -> bool:
+        """No polling for entities that have location pushed."""
+        return False
+
+    @property
+    def force_update(self) -> bool:
+        """All updates need to be written to the state machine if we're not polling."""
+        return not self.should_poll
+
+    @cached_property
+    def in_zones(self) -> list[str] | None:
+        """Return the entity_id of zones the device is currently in.
+
+        The list may be in any order; the base class sorts it by zone radius
+        and discards zones which do not exist. Ignored if latitude and
+        longitude are both set.
+        """
+        return self._attr_in_zones
+
+    @cached_property
+    def location_accuracy(self) -> float:
+        """Return the location accuracy of the device.
+
+        Value in meters.
+        """
+        return self._attr_location_accuracy
+
+    @cached_property
+    def location_name(self) -> str | None:
+        """Return a location name for the current location of the device."""
+        return self._attr_location_name
+
+    @cached_property
+    def latitude(self) -> float | None:
+        """Return latitude value of the device."""
+        return self._attr_latitude
+
+    @cached_property
+    def longitude(self) -> float | None:
+        """Return longitude value of the device."""
+        return self._attr_longitude
+
+    @callback
+    def _async_write_ha_state(self) -> None:
+        """Calculate active zones."""
+        if self.available and self.latitude is not None and self.longitude is not None:
+            self.__active_zone, self.__in_zones = zone.async_in_zones(
+                self.hass, self.latitude, self.longitude, self.location_accuracy
+            )
+        elif (zones := self.in_zones) is not None:
+            zone_states = sorted(
+                (
+                    zone_state
+                    for entity_id in zones
+                    if (zone_state := self.hass.states.get(entity_id)) is not None
+                ),
+                key=lambda z: z.attributes[ATTR_RADIUS],
+            )
+            self.__active_zone = next(
+                (z for z in zone_states if not z.attributes.get(ATTR_PASSIVE)),
+                None,
+            )
+            self.__in_zones = [z.entity_id for z in zone_states]
+        else:
+            self.__active_zone = None
+            self.__in_zones = None
+        super()._async_write_ha_state()
+
+    @property
+    def state(self) -> str | None:
+        """Return the state of the device."""
+        if self.location_name is not None:
+            return self.location_name
+
+        if (
+            self.latitude is not None and self.longitude is not None
+        ) or self.__in_zones is not None:
+            zone_state = self.__active_zone
+            if zone_state is None:
+                state = STATE_NOT_HOME
+            elif zone_state.entity_id == zone.ENTITY_ID_HOME:
+                state = STATE_HOME
+            else:
+                state = zone_state.name
+            return state
+
+        return None
+
+    @final
+    @property
+    def state_attributes(self) -> dict[str, Any]:
+        """Return the device state attributes."""
+        attr: dict[str, Any] = {ATTR_IN_ZONES: self.__in_zones or []}
+        attr.update(super().state_attributes)
+
+        if self.latitude is not None and self.longitude is not None:
+            attr[ATTR_LATITUDE] = self.latitude
+            attr[ATTR_LONGITUDE] = self.longitude
+            attr[ATTR_GPS_ACCURACY] = self.location_accuracy
+
+        return attr
+
+
+class BaseScannerEntity(BaseTrackerEntity):
+    """Base class for a tracked device that can be connected or disconnected.
+
+    Unlike ScannerEntity, this entity does not make assumptions about MAC
+    addresses being used to identify the device.
+    """
+
+    @property
+    def state(self) -> str | None:
+        """Return the state of the device."""
+        if self.is_connected is None:
+            return None
+        if self.is_connected:
+            return STATE_HOME
+        return STATE_NOT_HOME
+
+    @property
+    def is_connected(self) -> bool | None:
+        """Return true if the device is connected."""
+        raise NotImplementedError
+
+
+class ScannerEntityDescription(EntityDescription, frozen_or_thawed=True):
+    """A class that describes tracker entities."""
+
+
+CACHED_SCANNER_PROPERTIES_WITH_ATTR_ = {
+    "ip_address",
+    "mac_address",
+    "hostname",
+}
+
+
+class ScannerEntity(
+    BaseScannerEntity, cached_properties=CACHED_SCANNER_PROPERTIES_WITH_ATTR_
+):
+    """Base class for a tracked device that is on a scanned network."""
+
+    entity_description: ScannerEntityDescription
+    _attr_hostname: str | None = None
+    _attr_ip_address: str | None = None
+    _attr_mac_address: str | None = None
+    _attr_source_type: SourceType = SourceType.ROUTER
+
+    @cached_property
+    def ip_address(self) -> str | None:
+        """Return the primary ip address of the device."""
+        return self._attr_ip_address
+
+    @cached_property
+    def mac_address(self) -> str | None:
+        """Return the mac address of the device."""
+        return self._attr_mac_address
+
+    @cached_property
+    def hostname(self) -> str | None:
+        """Return hostname of the device."""
+        return self._attr_hostname
+
+    @property
+    def unique_id(self) -> str | None:
+        """Return unique ID of the entity."""
+        return self.mac_address
+
+    @final
+    @property
+    def device_info(self) -> DeviceInfo | None:
+        """Device tracker entities should not create device registry entries."""
+        return None
+
+    @property
+    def entity_registry_enabled_default(self) -> bool:
+        """Return if entity is enabled by default."""
+        # If mac_address is None, we can never find a device entry.
+        return (
+            # Do not disable if we won't activate our attach to device logic
+            self.mac_address is None
+            or self.device_info is not None
+            # Disable if we automatically attach but there is no device
+            or self.find_device_entry() is not None
+        )
+
+    @callback
+    def add_to_platform_start(
+        self,
+        hass: HomeAssistant,
+        platform: EntityPlatform,
+        parallel_updates: asyncio.Semaphore | None,
+    ) -> None:
+        """Start adding an entity to a platform."""
+        super().add_to_platform_start(hass, platform, parallel_updates)
+        if self.mac_address and self.unique_id:
+            _async_register_mac(
+                hass,
+                platform.platform_name,
+                self.mac_address,
+                self.unique_id,
+            )
+            if self.is_connected and self.ip_address:
+                _async_connected_device_registered(
+                    hass,
+                    self.mac_address,
+                    self.ip_address,
+                    self.hostname,
+                )
+
+    @callback
+    def find_device_entry(self) -> dr.DeviceEntry | None:
+        """Return device entry."""
+        assert self.mac_address is not None
+
+        return dr.async_get(self.hass).async_get_device(
+            connections={(dr.CONNECTION_NETWORK_MAC, self.mac_address)}
+        )
+
+    async def async_internal_added_to_hass(self) -> None:
+        """Handle added to Home Assistant."""
+        # Entities without a unique ID don't have a device
+        if (
+            not self.registry_entry
+            or not self.platform.config_entry
+            or not self.mac_address
+            or (device_entry := self.find_device_entry()) is None
+            # Entities should not have a device info. We opt them out
+            # of this logic if they do.
+            or self.device_info
+        ):
+            if self.device_info:
+                LOGGER.debug("Entity %s unexpectedly has a device info", self.entity_id)
+            await super().async_internal_added_to_hass()
+            return
+
+        # Attach entry to device
+        if self.registry_entry.device_id != device_entry.id:
+            self.registry_entry = er.async_get(self.hass).async_update_entity(
+                self.entity_id, device_id=device_entry.id
+            )
+
+        # Attach device to config entry
+        if self.platform.config_entry.entry_id not in device_entry.config_entries:
+            dr.async_get(self.hass).async_update_device(
+                device_entry.id,
+                add_config_entry_id=self.platform.config_entry.entry_id,
+            )
+
+        # Do this last or else the entity registry update listener has been installed
+        await super().async_internal_added_to_hass()
+
+    @final
+    @property
+    def state_attributes(self) -> dict[str, StateType]:
+        """Return the device state attributes."""
+        attr = super().state_attributes
+
+        if ip_address := self.ip_address:
+            attr[ATTR_IP] = ip_address
+        if (mac_address := self.mac_address) is not None:
+            attr[ATTR_MAC] = mac_address
+        if (hostname := self.hostname) is not None:
+            attr[ATTR_HOST_NAME] = hostname
+
+        return attr
@@ -36,8 +36,6 @@ DEFAULT_CONSIDER_HOME: Final = timedelta(seconds=180)

 CONF_NEW_DEVICE_DEFAULTS: Final = "new_device_defaults"

-CONF_ASSOCIATED_ZONE: Final = "associated_zone"
-
 ATTR_ATTRIBUTES: Final = "attributes"
 ATTR_BATTERY: Final = "battery"
 ATTR_DEV_ID: Final = "dev_id"
@@ -1,624 +0,0 @@
-"""Provide functionality to keep track of devices."""
-
-import asyncio
-from typing import TYPE_CHECKING, Any, final
-
-from propcache.api import cached_property
-
-from homeassistant.components import zone
-from homeassistant.components.zone import ATTR_PASSIVE, ATTR_RADIUS
-from homeassistant.const import (
-    ATTR_BATTERY_LEVEL,
-    ATTR_GPS_ACCURACY,
-    ATTR_LATITUDE,
-    ATTR_LONGITUDE,
-    STATE_HOME,
-    STATE_NOT_HOME,
-    EntityCategory,
-)
-from homeassistant.core import (
-    CALLBACK_TYPE,
-    Event,
-    EventStateChangedData,
-    HomeAssistant,
-    State,
-    callback,
-)
-from homeassistant.helpers import (
-    device_registry as dr,
-    entity_registry as er,
-    issue_registry as ir,
-)
-from homeassistant.helpers.device_registry import (
-    DeviceInfo,
-    EventDeviceRegistryUpdatedData,
-)
-from homeassistant.helpers.dispatcher import async_dispatcher_send
-from homeassistant.helpers.entity import Entity, EntityDescription
-from homeassistant.helpers.entity_platform import EntityPlatform
-from homeassistant.helpers.event import async_track_state_change_event
-from homeassistant.util.hass_dict import HassKey
-
-from .const import (
-    ATTR_HOST_NAME,
-    ATTR_IN_ZONES,
-    ATTR_IP,
-    ATTR_MAC,
-    ATTR_SOURCE_TYPE,
-    CONF_ASSOCIATED_ZONE,
-    CONNECTED_DEVICE_REGISTERED,
-    DOMAIN,
-    LOGGER,
-    SourceType,
-)
-
-DATA_KEY: HassKey[dict[str, tuple[str, str]]] = HassKey(f"{DOMAIN}_mac")
-
-
-@callback
-def _async_connected_device_registered(
-    hass: HomeAssistant, mac: str, ip_address: str | None, hostname: str | None
-) -> None:
-    """Register a newly seen connected device.
-
-    This is currently used by the dhcp integration
-    to listen for newly registered connected devices
-    for discovery.
-    """
-    async_dispatcher_send(
-        hass,
-        CONNECTED_DEVICE_REGISTERED,
-        {
-            ATTR_IP: ip_address,
-            ATTR_MAC: mac,
-            ATTR_HOST_NAME: hostname,
-        },
-    )
-
-
-@callback
-def _async_register_mac(
-    hass: HomeAssistant,
-    domain: str,
-    mac: str,
-    unique_id: str,
-) -> None:
-    """Register a mac address with a unique ID."""
-    mac = dr.format_mac(mac)
-    if DATA_KEY in hass.data:
-        hass.data[DATA_KEY][mac] = (domain, unique_id)
-        return
-
-    # Setup listening.
-
-    # dict mapping mac -> partial unique ID
-    data = hass.data[DATA_KEY] = {mac: (domain, unique_id)}
-
-    @callback
-    def handle_device_event(ev: Event[EventDeviceRegistryUpdatedData]) -> None:
-        """Enable the online status entity for the mac of a newly created device."""
-        # Only for new devices
-        if ev.data["action"] != "create":
-            return
-
-        dev_reg = dr.async_get(hass)
-        device_entry = dev_reg.async_get(ev.data["device_id"])
-
-        if device_entry is None:
-            # This should not happen, since the device was just created.
-            return
-
-        # Check if device has a mac
-        mac = None
-        for conn in device_entry.connections:
-            if conn[0] == dr.CONNECTION_NETWORK_MAC:
-                mac = conn[1]
-                break
-
-        if mac is None:
-            return
-
-        # Check if we have an entity for this mac
-        if (unique_id := data.get(mac)) is None:
-            return
-
-        ent_reg = er.async_get(hass)
-
-        if (entity_id := ent_reg.async_get_entity_id(DOMAIN, *unique_id)) is None:
-            return
-
-        entity_entry = ent_reg.entities[entity_id]
-
-        # Make sure entity has a config entry and was disabled by the
-        # default disable logic in the integration and new entities
-        # are allowed to be added.
-        if (
-            entity_entry.config_entry_id is None
-            or (
-                (
-                    config_entry := hass.config_entries.async_get_entry(
-                        entity_entry.config_entry_id
-                    )
-                )
-                is not None
-                and config_entry.pref_disable_new_entities
-            )
-            or entity_entry.disabled_by != er.RegistryEntryDisabler.INTEGRATION
-        ):
-            return
-
-        # Enable entity
-        ent_reg.async_update_entity(entity_id, disabled_by=None)
-
-    hass.bus.async_listen(dr.EVENT_DEVICE_REGISTRY_UPDATED, handle_device_event)
-
-
-class BaseTrackerEntity(Entity):
-    """Represent a tracked device.
-
-    Not intended to be directly inherited by integrations. Integrations should
-    inherit TrackerEntity, BaseScannerEntity or ScannerEntity instead.
-    """
-
-    _attr_device_info: None = None
-    _attr_entity_category = EntityCategory.DIAGNOSTIC
-    _attr_source_type: SourceType
-
-    @cached_property
-    def battery_level(self) -> int | None:
-        """Return the battery level of the device.
-
-        Percentage from 0-100.
-        """
-        return None
-
-    @property
-    def source_type(self) -> SourceType:
-        """Return the source type, eg gps or router, of the device."""
-        if hasattr(self, "_attr_source_type"):
-            return self._attr_source_type
-        raise NotImplementedError
-
-    @property
-    def state_attributes(self) -> dict[str, Any]:
-        """Return the device state attributes."""
-        attr: dict[str, Any] = {ATTR_SOURCE_TYPE: self.source_type}
-
-        if self.battery_level is not None:
-            attr[ATTR_BATTERY_LEVEL] = self.battery_level
-
-        return attr
-
-
-class TrackerEntityDescription(EntityDescription, frozen_or_thawed=True):
-    """A class that describes tracker entities."""
-
-
-CACHED_TRACKER_PROPERTIES_WITH_ATTR_ = {
-    "in_zones",
-    "latitude",
-    "location_accuracy",
-    "location_name",
-    "longitude",
-}
-
-
-class TrackerEntity(
-    BaseTrackerEntity, cached_properties=CACHED_TRACKER_PROPERTIES_WITH_ATTR_
-):
-    """Base class for a tracked device."""
-
-    entity_description: TrackerEntityDescription
-    _attr_in_zones: list[str] | None = None
-    _attr_latitude: float | None = None
-    _attr_location_accuracy: float = 0
-    _attr_location_name: str | None = None
-    _attr_longitude: float | None = None
-    _attr_source_type: SourceType = SourceType.GPS
-
-    __active_zone: State | None = None
-    __in_zones: list[str] | None = None
-
-    @cached_property
-    def should_poll(self) -> bool:
-        """No polling for entities that have location pushed."""
-        return False
-
-    @property
-    def force_update(self) -> bool:
-        """All updates need to be written to the state machine if we're not polling."""
-        return not self.should_poll
-
-    @cached_property
-    def in_zones(self) -> list[str] | None:
-        """Return the entity_id of zones the device is currently in.
-
-        The list may be in any order; the base class sorts it by zone radius
-        and discards zones which do not exist. Takes precedence over latitude
-        and longitude when set (including when set to an empty list).
-        """
-        return self._attr_in_zones
-
-    @cached_property
-    def location_accuracy(self) -> float:
-        """Return the location accuracy of the device.
-
-        Value in meters.
-        """
-        return self._attr_location_accuracy
-
-    @cached_property
-    def location_name(self) -> str | None:
-        """Return a location name for the current location of the device."""
-        return self._attr_location_name
-
-    @cached_property
-    def latitude(self) -> float | None:
-        """Return latitude value of the device."""
-        return self._attr_latitude
-
-    @cached_property
-    def longitude(self) -> float | None:
-        """Return longitude value of the device."""
-        return self._attr_longitude
-
-    @callback
-    def _async_write_ha_state(self) -> None:
-        """Calculate active zones."""
-        if (zones := self.in_zones) is not None:
-            zone_states = sorted(
-                (
-                    zone_state
-                    for entity_id in zones
-                    if (zone_state := self.hass.states.get(entity_id)) is not None
-                ),
-                key=lambda z: z.attributes[ATTR_RADIUS],
-            )
-            self.__active_zone = next(
-                (z for z in zone_states if not z.attributes.get(ATTR_PASSIVE)),
-                None,
-            )
-            self.__in_zones = [z.entity_id for z in zone_states]
-        elif (
-            self.available and self.latitude is not None and self.longitude is not None
-        ):
-            self.__active_zone, self.__in_zones = zone.async_in_zones(
-                self.hass, self.latitude, self.longitude, self.location_accuracy
-            )
-        else:
-            self.__active_zone = None
-            self.__in_zones = None
-        super()._async_write_ha_state()
-
-    @property
-    def state(self) -> str | None:
-        """Return the state of the device."""
-        if self.location_name is not None:
-            return self.location_name
-
-        if (
-            self.latitude is not None and self.longitude is not None
-        ) or self.__in_zones is not None:
-            zone_state = self.__active_zone
-            if zone_state is None:
-                state = STATE_NOT_HOME
-            elif zone_state.entity_id == zone.ENTITY_ID_HOME:
-                state = STATE_HOME
-            else:
-                state = zone_state.name
-            return state
-
-        return None
-
-    @final
-    @property
-    def state_attributes(self) -> dict[str, Any]:
-        """Return the device state attributes."""
-        attr: dict[str, Any] = {ATTR_IN_ZONES: self.__in_zones or []}
-        attr.update(super().state_attributes)
-
-        if self.latitude is not None and self.longitude is not None:
-            attr[ATTR_LATITUDE] = self.latitude
-            attr[ATTR_LONGITUDE] = self.longitude
-            attr[ATTR_GPS_ACCURACY] = self.location_accuracy
-
-        return attr
-
-
-class BaseScannerEntity(BaseTrackerEntity):
-    """Base class for a tracked device that can be connected or disconnected.
-
-    Unlike ScannerEntity, this entity does not make assumptions about MAC
-    addresses being used to identify the device.
-    """
-
-    _scanner_option_associated_zone: str = zone.ENTITY_ID_HOME
-    _scanner_option_associated_zone_unsub: CALLBACK_TYPE | None = None
-
-    async def async_internal_added_to_hass(self) -> None:
-        """Call when the scanner entity is added to hass."""
-        await super().async_internal_added_to_hass()
-        if not self.registry_entry:
-            return
-        self._async_read_entity_options()
-
-    async def async_internal_will_remove_from_hass(self) -> None:
-        """Call when the scanner entity is about to be removed from hass."""
-        await super().async_internal_will_remove_from_hass()
-        if not self.registry_entry:
-            return
-        if self._scanner_option_associated_zone_unsub is not None:
-            self._scanner_option_associated_zone_unsub()
-            self._scanner_option_associated_zone_unsub = None
-        self._async_clear_associated_zone_issue()
-
-    @callback
-    def async_registry_entry_updated(self) -> None:
-        """Run when the entity registry entry has been updated."""
-        self._async_read_entity_options()
-
-    @callback
-    def _async_read_entity_options(self) -> None:
-        """Read entity options from the entity registry.
-
-        Called when the entity registry entry has been updated and before the
-        scanner entity is added to the state machine.
-        """
-        assert self.registry_entry
-        if (scanner_options := self.registry_entry.options.get(DOMAIN)) and (
-            associated_zone := scanner_options.get(CONF_ASSOCIATED_ZONE)
-        ):
-            new_zone = associated_zone
-        else:
-            new_zone = zone.ENTITY_ID_HOME
-
-        if new_zone == self._scanner_option_associated_zone:
-            return
-
-        # Tear down tracking for the previous zone.
-        if self._scanner_option_associated_zone_unsub is not None:
-            self._scanner_option_associated_zone_unsub()
-            self._scanner_option_associated_zone_unsub = None
-        self._async_clear_associated_zone_issue()
-
-        self._scanner_option_associated_zone = new_zone
-
-        # zone.home is always present so no tracking or issue handling needed.
-        if new_zone == zone.ENTITY_ID_HOME:
-            return
-
-        self._scanner_option_associated_zone_unsub = async_track_state_change_event(
-            self.hass, new_zone, self._async_associated_zone_state_changed
-        )
-        if self.hass.states.get(new_zone) is None:
-            self._async_create_associated_zone_issue()
-
-    @callback
-    def _async_associated_zone_state_changed(
-        self, event: Event[EventStateChangedData]
-    ) -> None:
-        """Open or clear the repair issue when the associated zone appears or disappears."""
-        if event.data["new_state"] is None:
-            self._async_create_associated_zone_issue()
-        else:
-            self._async_clear_associated_zone_issue()
-        self.async_write_ha_state()
-
-    @callback
-    def _async_create_associated_zone_issue(self) -> None:
-        """Create a repair issue prompting the user to reconfigure the scanner."""
-        ir.async_create_issue(
-            self.hass,
-            DOMAIN,
-            self._associated_zone_issue_id,
-            is_fixable=False,
-            severity=ir.IssueSeverity.WARNING,
-            translation_key="associated_zone_missing",
-            translation_placeholders={
-                "entity_id": self.entity_id,
-                "zone": self._scanner_option_associated_zone,
-            },
-        )
-
-    @callback
-    def _async_clear_associated_zone_issue(self) -> None:
-        """Clear the associated-zone-missing repair issue if it exists."""
-        ir.async_delete_issue(self.hass, DOMAIN, self._associated_zone_issue_id)
-
-    @property
-    def _associated_zone_issue_id(self) -> str:
-        """Return the issue id for the associated-zone-missing repair."""
-        if TYPE_CHECKING:
-            assert self.registry_entry
-        return f"associated_zone_missing_{self.registry_entry.id}"
-
-    @property
-    def state(self) -> str | None:
-        """Return the state of the device."""
-        if self.is_connected is None:
-            return None
-        if not self.is_connected:
-            return STATE_NOT_HOME
-        associated_zone = self._scanner_option_associated_zone
-        if associated_zone == zone.ENTITY_ID_HOME:
-            return STATE_HOME
-        if zone_state := self.hass.states.get(associated_zone):
-            return zone_state.name
-        # Configured zone has been removed; state is unknown.
-        return None
-
-    @property
-    def is_connected(self) -> bool | None:
-        """Return true if the device is connected."""
-        raise NotImplementedError
-
-    @final
-    @property
-    def state_attributes(self) -> dict[str, Any]:
-        """Return the device state attributes."""
-        attr: dict[str, Any] = {ATTR_IN_ZONES: []}
-        attr.update(super().state_attributes)
-
-        if not self.is_connected:
-            return attr
-
-        associated_zone = self._scanner_option_associated_zone
-        # If the configured zone has been removed, in_zones stays empty so the
-        # attribute does not claim membership in a zone that no longer exists.
-        if (
-            associated_zone != zone.ENTITY_ID_HOME
-            and self.hass.states.get(associated_zone) is None
-        ):
-            return attr
-
-        attr[ATTR_IN_ZONES] = [
-            associated_zone,
-            *zone.async_get_enclosing_zones(self.hass, associated_zone),
-        ]
-
-        return attr
-
-
-class ScannerEntityDescription(EntityDescription, frozen_or_thawed=True):
-    """A class that describes tracker entities."""
-
-
-CACHED_SCANNER_PROPERTIES_WITH_ATTR_ = {
-    "ip_address",
-    "mac_address",
-    "hostname",
-}
-
-
-class ScannerEntity(
-    BaseScannerEntity, cached_properties=CACHED_SCANNER_PROPERTIES_WITH_ATTR_
-):
-    """Base class for a tracked device that is on a scanned network."""
-
-    entity_description: ScannerEntityDescription
-    _attr_hostname: str | None = None
-    _attr_ip_address: str | None = None
-    _attr_mac_address: str | None = None
-    _attr_source_type: SourceType = SourceType.ROUTER
-
-    @cached_property
-    def ip_address(self) -> str | None:
-        """Return the primary ip address of the device."""
-        return self._attr_ip_address
-
-    @cached_property
-    def mac_address(self) -> str | None:
-        """Return the mac address of the device."""
-        return self._attr_mac_address
-
-    @cached_property
-    def hostname(self) -> str | None:
-        """Return hostname of the device."""
-        return self._attr_hostname
-
-    @property
-    def unique_id(self) -> str | None:
-        """Return unique ID of the entity."""
-        return self.mac_address
-
-    @final
-    @property
-    def device_info(self) -> DeviceInfo | None:
-        """Device tracker entities should not create device registry entries."""
-        return None
-
-    @property
-    def entity_registry_enabled_default(self) -> bool:
-        """Return if entity is enabled by default."""
-        # If mac_address is None, we can never find a device entry.
-        return (
-            # Do not disable if we won't activate our attach to device logic
-            self.mac_address is None
-            or self.device_info is not None
-            # Disable if we automatically attach but there is no device
-            or self.find_device_entry() is not None
-        )
-
-    @callback
-    def add_to_platform_start(
-        self,
-        hass: HomeAssistant,
-        platform: EntityPlatform,
-        parallel_updates: asyncio.Semaphore | None,
-    ) -> None:
-        """Start adding an entity to a platform."""
-        super().add_to_platform_start(hass, platform, parallel_updates)
-        if self.mac_address and self.unique_id:
-            _async_register_mac(
-                hass,
-                platform.platform_name,
-                self.mac_address,
-                self.unique_id,
-            )
-            if self.is_connected and self.ip_address:
-                _async_connected_device_registered(
-                    hass,
-                    self.mac_address,
-                    self.ip_address,
-                    self.hostname,
-                )
-
-    @callback
-    def find_device_entry(self) -> dr.DeviceEntry | None:
-        """Return device entry."""
-        assert self.mac_address is not None
-
-        return dr.async_get(self.hass).async_get_device(
-            connections={(dr.CONNECTION_NETWORK_MAC, self.mac_address)}
-        )
-
-    async def async_internal_added_to_hass(self) -> None:
-        """Handle added to Home Assistant."""
-        # Entities without a unique ID don't have a device
-        if (
-            not self.registry_entry
-            or not self.platform.config_entry
-            or not self.mac_address
-            or (device_entry := self.find_device_entry()) is None
-            # Entities should not have a device info. We opt them out
-            # of this logic if they do.
-            or self.device_info
-        ):
-            if self.device_info:
-                LOGGER.debug("Entity %s unexpectedly has a device info", self.entity_id)
-            await super().async_internal_added_to_hass()
-            return
-
-        # Attach entry to device
-        if self.registry_entry.device_id != device_entry.id:
-            self.registry_entry = er.async_get(self.hass).async_update_entity(
-                self.entity_id, device_id=device_entry.id
-            )
-
-        # Attach device to config entry
-        if self.platform.config_entry.entry_id not in device_entry.config_entries:
-            dr.async_get(self.hass).async_update_device(
-                device_entry.id,
-                add_config_entry_id=self.platform.config_entry.entry_id,
-            )
-
-        # Do this last or else the entity registry update listener has been installed
-        await super().async_internal_added_to_hass()
-
-    # BaseScannerEntity.state_attributes is @final to keep external subclasses
-    # from tampering with it; ScannerEntity is an in-tree subclass that
-    # intentionally extends it with ip/mac/hostname.
-    @final  # type: ignore[misc]
-    @property
-    def state_attributes(self) -> dict[str, Any]:
-        """Return the device state attributes."""
-        attr = super().state_attributes
-
-        if ip_address := self.ip_address:
-            attr[ATTR_IP] = ip_address
-        if (mac_address := self.mac_address) is not None:
-            attr[ATTR_MAC] = mac_address
-        if (hostname := self.hostname) is not None:
-            attr[ATTR_HOST_NAME] = hostname
-
-        return attr
@@ -38,9 +38,6 @@ from homeassistant.const import (
 from homeassistant.core import Event, HomeAssistant, ServiceCall, callback
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import config_validation as cv, entity_registry as er
-from homeassistant.helpers.entity_platform import (
-    async_create_platform_config_not_supported_issue,
-)
 from homeassistant.helpers.event import (
    async_track_time_interval,
    async_track_utc_time_change,
@@ -382,8 +379,8 @@ async def async_extract_config(
        if platform.type == PLATFORM_TYPE_LEGACY:
            legacy.append(platform)
        else:
-            async_create_platform_config_not_supported_issue(
-                hass, platform.name, DOMAIN
+            raise ValueError(
+                f"Unable to determine type for {platform.name}: {platform.type}"
            )

    return legacy
@@ -44,12 +44,6 @@
      }
    }
  },
-  "issues": {
-    "associated_zone_missing": {
-      "description": "The scanner entity `{entity_id}` is associated with the zone `{zone}`, but that zone has been removed.\n\nTo fix this, reconfigure the scanner to use a different zone or recreate the missing zone.",
-      "title": "Scanner is associated with a removed zone"
-    }
-  },
  "services": {
    "see": {
      "description": "Manually update the records of a seen legacy device tracker in the known_devices.yaml file.",
@@ -15,8 +15,8 @@
  ],
  "quality_scale": "internal",
  "requirements": [
-    "aiodhcpwatcher==1.2.7",
-    "aiodiscover==3.2.4",
+    "aiodhcpwatcher==1.2.6",
+    "aiodiscover==3.2.3",
    "cached-ipaddress==1.1.1"
  ]
 }
@@ -1,7 +1,7 @@
 .trigger_common_fields: &trigger_common_fields
  behavior:
    required: true
-    default: each
+    default: any
    selector:
      automation_behavior:
        mode: trigger
@@ -15,7 +15,6 @@ from homeassistant.helpers.service_info.dhcp import DhcpServiceInfo
 from homeassistant.helpers.service_info.zeroconf import ZeroconfServiceInfo

 from .const import DOMAIN
-from .validation import UnsupportedBoardError, async_get_supported_board_info

 _LOGGER = logging.getLogger(__name__)

@@ -44,11 +43,6 @@ class DucoConfigFlow(ConfigFlow, domain=DOMAIN):

        try:
            box_name, _ = await self._validate_input(discovery_info.ip)
-        except UnsupportedBoardError:
-            _LOGGER.debug(
-                "Unsupported Duco board discovered via DHCP at %s", discovery_info.ip
-            )
-            return self.async_abort(reason="unsupported_board")
        except DucoConnectionError:
            return self.async_abort(reason="cannot_connect")
        except DucoError:
@@ -67,12 +61,6 @@ class DucoConfigFlow(ConfigFlow, domain=DOMAIN):
        """Handle zeroconf discovery."""
        try:
            box_name, mac = await self._validate_input(discovery_info.host)
-        except UnsupportedBoardError:
-            _LOGGER.debug(
-                "Unsupported Duco board discovered via zeroconf at %s",
-                discovery_info.host,
-            )
-            return self.async_abort(reason="unsupported_board")
        except DucoConnectionError:
            return self.async_abort(reason="cannot_connect")
        except DucoError:
@@ -114,8 +102,6 @@ class DucoConfigFlow(ConfigFlow, domain=DOMAIN):
        if user_input is not None:
            try:
                box_name, mac = await self._validate_input(user_input[CONF_HOST])
-            except UnsupportedBoardError:
-                errors["base"] = "unsupported_board"
            except DucoConnectionError:
                errors["base"] = "cannot_connect"
            except DucoError:
@@ -147,8 +133,6 @@ class DucoConfigFlow(ConfigFlow, domain=DOMAIN):
        if user_input is not None:
            try:
                box_name, mac = await self._validate_input(user_input[CONF_HOST])
-            except UnsupportedBoardError:
-                errors["base"] = "unsupported_board"
            except DucoConnectionError:
                errors["base"] = "cannot_connect"
            except DucoError:
@@ -178,6 +162,6 @@ class DucoConfigFlow(ConfigFlow, domain=DOMAIN):
            session=async_get_clientsession(self.hass),
            host=host,
        )
-        board_info = await async_get_supported_board_info(client)
+        board_info = await client.async_get_board_info()
        lan_info = await client.async_get_lan_info()
        return board_info.box_name, lan_info.mac
@@ -4,11 +4,7 @@ from dataclasses import dataclass
 import logging

 from duco_connectivity import DucoClient
-from duco_connectivity.exceptions import (
-    DucoConnectionError,
-    DucoError,
-    DucoResponseError,
-)
+from duco_connectivity.exceptions import DucoConnectionError, DucoError
 from duco_connectivity.models import BoardInfo, Node

 from homeassistant.config_entries import ConfigEntry
@@ -17,7 +13,6 @@ from homeassistant.exceptions import ConfigEntryError
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed

 from .const import DOMAIN, SCAN_INTERVAL
-from .validation import UnsupportedBoardError, async_get_supported_board_info

 _LOGGER = logging.getLogger(__name__)

@@ -57,18 +52,7 @@ class DucoCoordinator(DataUpdateCoordinator[DucoData]):
    async def _async_setup(self) -> None:
        """Fetch board info once during initial setup."""
        try:
-            self.board_info = await async_get_supported_board_info(self.client)
-        except UnsupportedBoardError as err:
-            raise ConfigEntryError(
-                translation_domain=DOMAIN,
-                translation_key="unsupported_board",
-            ) from err
-        except DucoResponseError as err:
-            raise ConfigEntryError(
-                translation_domain=DOMAIN,
-                translation_key="api_error",
-                translation_placeholders={"error": repr(err)},
-            ) from err
+            self.board_info = await self.client.async_get_board_info()
        except DucoConnectionError as err:
            raise UpdateFailed(
                translation_domain=DOMAIN,
@@ -86,6 +70,20 @@ class DucoCoordinator(DataUpdateCoordinator[DucoData]):
        """Fetch node data from the Duco box."""
        try:
            nodes = await self.client.async_get_nodes()
+        except DucoConnectionError as err:
+            raise UpdateFailed(
+                translation_domain=DOMAIN,
+                translation_key="cannot_connect",
+                translation_placeholders={"error": repr(err)},
+            ) from err
+        except DucoError as err:
+            raise UpdateFailed(
+                translation_domain=DOMAIN,
+                translation_key="api_error",
+                translation_placeholders={"error": repr(err)},
+            ) from err
+
+        try:
            lan_info = await self.client.async_get_lan_info()
        except DucoConnectionError as err:
            raise UpdateFailed(
@@ -6,13 +6,11 @@
      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
      "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]",
      "unique_id_mismatch": "The device you entered belongs to a different Duco box.",
-      "unknown": "[%key:common::config_flow::error::unknown%]",
-      "unsupported_board": "This Duco system is not supported by this integration. The integration requires a Duco Connectivity Board running public API 2.1 or newer."
+      "unknown": "[%key:common::config_flow::error::unknown%]"
    },
    "error": {
      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
-      "unknown": "[%key:common::config_flow::error::unknown%]",
-      "unsupported_board": "[%key:component::duco::config::abort::unsupported_board%]"
+      "unknown": "[%key:common::config_flow::error::unknown%]"
    },
    "step": {
      "discovery_confirm": {
@@ -64,23 +62,23 @@
      "ventilation_state": {
        "name": "Ventilation state",
        "state": {
-          "aut1": "AUT1",
-          "aut2": "AUT2",
-          "aut3": "AUT3",
-          "auto": "AUTO",
-          "cnt1": "CNT1",
-          "cnt2": "CNT2",
-          "cnt3": "CNT3",
-          "empt": "EMPT",
-          "man1": "MAN1",
-          "man1x2": "MAN1x2",
-          "man1x3": "MAN1x3",
-          "man2": "MAN2",
-          "man2x2": "MAN2x2",
-          "man2x3": "MAN2x3",
-          "man3": "MAN3",
-          "man3x2": "MAN3x2",
-          "man3x3": "MAN3x3"
+          "aut1": "Automatic boost (15 min)",
+          "aut2": "Automatic boost (30 min)",
+          "aut3": "Automatic boost (45 min)",
+          "auto": "Automatic",
+          "cnt1": "Continuous low speed",
+          "cnt2": "Continuous medium speed",
+          "cnt3": "Continuous high speed",
+          "empt": "Empty house",
+          "man1": "Manual low speed (15 min)",
+          "man1x2": "Manual low speed (30 min)",
+          "man1x3": "Manual low speed (45 min)",
+          "man2": "Manual medium speed (15 min)",
+          "man2x2": "Manual medium speed (30 min)",
+          "man2x3": "Manual medium speed (45 min)",
+          "man3": "Manual high speed (15 min)",
+          "man3x2": "Manual high speed (30 min)",
+          "man3x3": "Manual high speed (45 min)"
        }
      }
    }
@@ -100,9 +98,6 @@
    },
    "rate_limit_exceeded": {
      "message": "The Duco device has reached its daily write limit. Try again tomorrow."
-    },
-    "unsupported_board": {
-      "message": "[%key:component::duco::config::abort::unsupported_board%]"
    }
  },
  "system_health": {
@@ -1,58 +0,0 @@
-"""Validation helpers for supported Duco systems."""
-
-from awesomeversion import (
-    AwesomeVersion,
-    AwesomeVersionStrategy,
-    AwesomeVersionStrategyException,
-)
-from duco_connectivity import DucoClient
-from duco_connectivity.exceptions import DucoResponseError
-from duco_connectivity.models import BoardInfo
-
-# Newer Connectivity boards expose /info with PublicApiVersion. We use that
-# endpoint to distinguish supported Connectivity hardware from older
-# Communication board V1 hardware.
-_MIN_PUBLIC_API_VERSION = AwesomeVersion(
-    "2.1", ensure_strategy=AwesomeVersionStrategy.SIMPLEVER
-)
-
-
-class UnsupportedBoardError(Exception):
-    """Raised when the Duco system is not supported by this integration."""
-
-
-def validate_board_support(board_info: BoardInfo) -> None:
-    """Raise UnsupportedBoardError if the board does not meet support requirements."""
-    version = board_info.public_api_version
-    if version is None:
-        raise UnsupportedBoardError("Board did not report a public API version")
-    try:
-        parsed_version = AwesomeVersion(
-            version, ensure_strategy=AwesomeVersionStrategy.SIMPLEVER
-        )
-    except AwesomeVersionStrategyException as err:
-        raise UnsupportedBoardError(
-            f"Board reported malformed public API version: {version}"
-        ) from err
-    if parsed_version < _MIN_PUBLIC_API_VERSION:
-        raise UnsupportedBoardError(
-            "Board public API version "
-            f"{version} is below the supported minimum {_MIN_PUBLIC_API_VERSION}"
-        )
-
-
-async def async_get_supported_board_info(client: DucoClient) -> BoardInfo:
-    """Fetch and validate board info for a supported Duco system."""
-    try:
-        board_info = await client.async_get_board_info()
-    except DucoResponseError as err:
-        if err.status == 404:
-            # Duco indicated that Communication board V1 does not implement
-            # /info, so a 404 is enough to treat the device as unsupported.
-            raise UnsupportedBoardError(
-                "Board does not expose the /info endpoint"
-            ) from err
-        raise
-
-    validate_board_support(board_info)
-    return board_info
@@ -41,7 +41,7 @@ class UKFloodsFlowHandler(ConfigFlow, domain=DOMAIN):
        self.stations = {}
        for station in stations:
            label = station["label"]
-            rlo_id = station["RLOIid"]
+            rloId = station["RLOIid"]

            # API annoyingly sometimes returns a list and some times returns a string
            # E.g. L3121 has a label of ['Scurf Dyke', 'Scurf Dyke Dyke Level']
@@ -50,11 +50,11 @@ class UKFloodsFlowHandler(ConfigFlow, domain=DOMAIN):

            # Similar for RLOIid
            # E.g. 0018 has an RLOIid of ['10427', '9154']
-            if isinstance(rlo_id, list):
-                rlo_id = rlo_id[-1]
+            if isinstance(rloId, list):
+                rloId = rloId[-1]

-            full_name = label + " - " + rlo_id
-            self.stations[full_name] = station["stationReference"]
+            fullName = label + " - " + rloId
+            self.stations[fullName] = station["stationReference"]

        if not self.stations:
            return self.async_abort(reason="no_stations")
@@ -8,16 +8,12 @@ from pyecobee import (
    ECOBEE_REFRESH_TOKEN,
    ECOBEE_USERNAME,
    Ecobee,
-    EcobeeAuthFailedError,
-    EcobeeAuthMfaRequiredError,
-    EcobeeAuthUnknownError,
    ExpiredTokenError,
 )

 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_API_KEY, CONF_PASSWORD, CONF_USERNAME
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryAuthFailed
 from homeassistant.util import Throttle

 from .const import _LOGGER, CONF_REFRESH_TOKEN, PLATFORMS
@@ -106,26 +102,7 @@ class EcobeeData:
    async def refresh(self) -> bool:
        """Refresh ecobee tokens and update config entry."""
        _LOGGER.debug("Refreshing ecobee tokens and updating config entry")
-        try:
-            success = await self._hass.async_add_executor_job(
-                self.ecobee.refresh_tokens
-            )
-        except EcobeeAuthMfaRequiredError as err:
-            raise ConfigEntryAuthFailed(
-                "ecobee account requires MFA; reauthentication needed"
-            ) from err
-        except EcobeeAuthFailedError as err:
-            if self.ecobee.config.get(ECOBEE_USERNAME):
-                raise ConfigEntryAuthFailed(
-                    "ecobee rejected stored credentials"
-                ) from err
-            _LOGGER.error("Ecobee rejected stored credentials: %s", err)
-            return False
-        except EcobeeAuthUnknownError:
-            _LOGGER.exception("Unexpected error refreshing ecobee tokens")
-            return False
-
-        if success:
+        if await self._hass.async_add_executor_job(self.ecobee.refresh_tokens):
            data = {}
            if self.ecobee.config.get(ECOBEE_API_KEY):
                data = {
@@ -1,22 +1,12 @@
 """Config flow to configure ecobee."""

-from collections.abc import Mapping
 from typing import Any

-from pyecobee import (
-    ECOBEE_API_KEY,
-    ECOBEE_PASSWORD,
-    ECOBEE_USERNAME,
-    Ecobee,
-    EcobeeAuthFailedError,
-    EcobeeAuthMfaRequiredError,
-    EcobeeAuthUnknownError,
-    MfaChallenge,
-)
+from pyecobee import ECOBEE_API_KEY, ECOBEE_PASSWORD, ECOBEE_USERNAME, Ecobee
 import voluptuous as vol

-from homeassistant.config_entries import SOURCE_REAUTH, ConfigFlow, ConfigFlowResult
-from homeassistant.const import CONF_API_KEY, CONF_CODE, CONF_PASSWORD, CONF_USERNAME
+from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+from homeassistant.const import CONF_API_KEY, CONF_PASSWORD, CONF_USERNAME

 from .const import CONF_REFRESH_TOKEN, DOMAIN

@@ -28,9 +18,6 @@ _USER_SCHEMA = vol.Schema(
    }
 )

-_MFA_SCHEMA = vol.Schema({vol.Required(CONF_CODE): str})
-_REAUTH_SCHEMA = vol.Schema({vol.Required(CONF_PASSWORD): str})
-

 class EcobeeFlowHandler(ConfigFlow, domain=DOMAIN):
    """Handle an ecobee config flow."""
@@ -38,15 +25,12 @@ class EcobeeFlowHandler(ConfigFlow, domain=DOMAIN):
    VERSION = 1

    _ecobee: Ecobee
-    _mfa_challenge: MfaChallenge | None = None
-    _pending_username: str | None = None
-    _pending_password: str | None = None

    async def async_step_user(
        self, user_input: dict[str, Any] | None = None
    ) -> ConfigFlowResult:
        """Handle a flow initiated by the user."""
-        errors: dict[str, str] = {}
+        errors = {}

        if user_input is not None:
            api_key = user_input.get(CONF_API_KEY)
@@ -54,34 +38,27 @@ class EcobeeFlowHandler(ConfigFlow, domain=DOMAIN):
            password = user_input.get(CONF_PASSWORD)

            if api_key and not (username or password):
+                # Use the user-supplied API key to attempt to obtain a PIN from ecobee.
                self._ecobee = Ecobee(config={ECOBEE_API_KEY: api_key})
                if await self.hass.async_add_executor_job(self._ecobee.request_pin):
+                    # We have a PIN; move to the next step of the flow.
                    return await self.async_step_authorize()
                errors["base"] = "pin_request_failed"
            elif username and password and not api_key:
-                self._pending_username = username
-                self._pending_password = password
                self._ecobee = Ecobee(
                    config={
                        ECOBEE_USERNAME: username,
                        ECOBEE_PASSWORD: password,
                    }
                )
-                try:
-                    success = await self.hass.async_add_executor_job(
-                        self._ecobee.refresh_tokens
-                    )
-                except EcobeeAuthMfaRequiredError as err:
-                    self._mfa_challenge = err.args[0]
-                    return await self.async_step_mfa()
-                except EcobeeAuthFailedError:
-                    errors["base"] = "invalid_auth"
-                except EcobeeAuthUnknownError:
-                    errors["base"] = "unknown"
-                else:
-                    if success:
-                        return self._async_create_or_update_entry()
-                    errors["base"] = "login_failed"
+                if await self.hass.async_add_executor_job(self._ecobee.refresh_tokens):
+                    config = {
+                        CONF_USERNAME: username,
+                        CONF_PASSWORD: password,
+                        CONF_REFRESH_TOKEN: self._ecobee.refresh_token,
+                    }
+                    return self.async_create_entry(title=DOMAIN, data=config)
+                errors["base"] = "login_failed"
            else:
                errors["base"] = "invalid_auth"

@@ -91,46 +68,16 @@ class EcobeeFlowHandler(ConfigFlow, domain=DOMAIN):
            errors=errors,
        )

-    async def async_step_mfa(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Collect an MFA OTP code and complete the login."""
-        assert self._mfa_challenge is not None
-        errors: dict[str, str] = {}
-
-        if user_input is not None:
-            code = user_input[CONF_CODE].strip()
-            if not code:
-                errors["base"] = "invalid_mfa_code"
-            else:
-                try:
-                    success = await self.hass.async_add_executor_job(
-                        self._ecobee.submit_mfa_code, self._mfa_challenge, code
-                    )
-                except EcobeeAuthFailedError:
-                    errors["base"] = "invalid_mfa_code"
-                except EcobeeAuthUnknownError:
-                    errors["base"] = "unknown"
-                else:
-                    if success:
-                        return self._async_create_or_update_entry()
-                    errors["base"] = "invalid_mfa_code"
-
-        return self.async_show_form(
-            step_id="mfa",
-            data_schema=_MFA_SCHEMA,
-            errors=errors,
-            description_placeholders={"mfa_type": self._mfa_challenge.mfa_type},
-        )
-
    async def async_step_authorize(
        self, user_input: dict[str, Any] | None = None
    ) -> ConfigFlowResult:
-        """Present the user with the PIN so that the app can be authorized on ecobee.com."""
-        errors: dict[str, str] = {}
+        """Present the user with the PIN to authorize on ecobee.com."""
+        errors = {}

        if user_input is not None:
+            # Attempt to obtain tokens from ecobee and finish the flow.
            if await self.hass.async_add_executor_job(self._ecobee.request_tokens):
+                # Refresh token obtained; create the config entry.
                config = {
                    CONF_API_KEY: self._ecobee.api_key,
                    CONF_REFRESH_TOKEN: self._ecobee.refresh_token,
@@ -146,61 +93,3 @@ class EcobeeFlowHandler(ConfigFlow, domain=DOMAIN):
                "auth_url": "https://www.ecobee.com/consumerportal/index.html",
            },
        )
-
-    async def async_step_reauth(
-        self, entry_data: Mapping[str, Any]
-    ) -> ConfigFlowResult:
-        """Perform reauth upon an ecobee authentication error."""
-        self._pending_username = entry_data.get(CONF_USERNAME)
-        self._pending_password = entry_data.get(CONF_PASSWORD)
-        return await self.async_step_reauth_confirm()
-
-    async def async_step_reauth_confirm(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Re-run the web login. May surface a fresh MFA challenge."""
-        errors: dict[str, str] = {}
-
-        if user_input is not None:
-            self._pending_password = user_input[CONF_PASSWORD]
-            self._ecobee = Ecobee(
-                config={
-                    ECOBEE_USERNAME: self._pending_username,
-                    ECOBEE_PASSWORD: self._pending_password,
-                }
-            )
-            try:
-                success = await self.hass.async_add_executor_job(
-                    self._ecobee.refresh_tokens
-                )
-            except EcobeeAuthMfaRequiredError as err:
-                self._mfa_challenge = err.args[0]
-                return await self.async_step_mfa()
-            except EcobeeAuthFailedError:
-                errors["base"] = "invalid_auth"
-            except EcobeeAuthUnknownError:
-                errors["base"] = "unknown"
-            else:
-                if success:
-                    return self._async_create_or_update_entry()
-                errors["base"] = "login_failed"
-
-        return self.async_show_form(
-            step_id="reauth_confirm",
-            data_schema=_REAUTH_SCHEMA,
-            errors=errors,
-            description_placeholders={"username": self._pending_username or ""},
-        )
-
-    def _async_create_or_update_entry(self) -> ConfigFlowResult:
-        """Create a new entry or update the existing one on reauth."""
-        data = {
-            CONF_USERNAME: self._pending_username,
-            CONF_PASSWORD: self._pending_password,
-            CONF_REFRESH_TOKEN: self._ecobee.refresh_token,
-        }
-        if self.source == SOURCE_REAUTH:
-            return self.async_update_reload_and_abort(
-                self._get_reauth_entry(), data=data
-            )
-        return self.async_create_entry(title=DOMAIN, data=data)
@@ -1,33 +1,18 @@
 {
  "config": {
    "abort": {
-      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]",
      "single_instance_allowed": "[%key:common::config_flow::abort::single_instance_allowed%]"
    },
    "error": {
      "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
-      "invalid_mfa_code": "The MFA code was not accepted by ecobee; please try again.",
      "login_failed": "Error authenticating with ecobee; please verify your credentials are correct.",
      "pin_request_failed": "Error requesting PIN from ecobee; please verify API key is correct.",
-      "token_request_failed": "Error requesting tokens from ecobee; please try again.",
-      "unknown": "[%key:common::config_flow::error::unknown%]"
+      "token_request_failed": "Error requesting tokens from ecobee; please try again."
    },
    "step": {
      "authorize": {
        "description": "Please authorize this app at {auth_url} with PIN code:\n\n{pin}\n\nThen, select **Submit**."
      },
-      "mfa": {
-        "data": {
-          "code": "MFA code"
-        },
-        "description": "ecobee requires multi-factor authentication. Enter the {mfa_type} code from your authenticator app."
-      },
-      "reauth_confirm": {
-        "data": {
-          "password": "[%key:common::config_flow::data::password%]"
-        },
-        "description": "Reauthenticate the ecobee account for **{username}**."
-      },
      "user": {
        "data": {
          "api_key": "[%key:common::config_flow::data::api_key%]"
@@ -3,13 +3,12 @@
 import voluptuous as vol

 from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
-from homeassistant.helpers.selector import SerialPortSelector

 from .const import CONF_SERIAL_PORT, DEFAULT_TITLE, DOMAIN

 DATA_SCHEMA = vol.Schema(
    {
-        vol.Required(CONF_SERIAL_PORT): SerialPortSelector(),
+        vol.Required(CONF_SERIAL_PORT): str,
    }
 )

@@ -4,8 +4,8 @@
  "codeowners": [],
  "config_flow": true,
  "documentation": "https://www.home-assistant.io/integrations/edl21",
-  "integration_type": "device",
+  "integration_type": "hub",
  "iot_class": "local_push",
  "loggers": ["sml"],
-  "requirements": ["pysml==0.1.7"]
+  "requirements": ["pysml==0.1.5"]
 }
@@ -1,6 +1,7 @@
 """Support for EDL21 Smart Meters."""

 from collections.abc import Mapping
+from datetime import timedelta
 from typing import Any

 from sml import SmlGetListResponse
@@ -28,6 +29,7 @@ from homeassistant.helpers.dispatcher import (
    async_dispatcher_send,
 )
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from homeassistant.util.dt import utcnow

 from .const import (
    CONF_SERIAL_PORT,
@@ -37,6 +39,8 @@ from .const import (
    SIGNAL_EDL21_TELEGRAM,
 )

+MIN_TIME_BETWEEN_UPDATES = timedelta(seconds=60)
+
 # OBIS format: A-B:C.D.E*F
 SENSOR_TYPES: tuple[SensorEntityDescription, ...] = (
    # A=1: Electricity
@@ -387,6 +391,8 @@ class EDL21Entity(SensorEntity):
        self._electricity_id = electricity_id
        self._obis = obis
        self._telegram = telegram
+        self._min_time = MIN_TIME_BETWEEN_UPDATES
+        self._last_update = utcnow()
        self._async_remove_dispatcher = None
        self.entity_description = entity_description
        self._attr_unique_id = f"{electricity_id}_{obis}"
@@ -408,7 +414,12 @@ class EDL21Entity(SensorEntity):
            if self._telegram == telegram:
                return

+            now = utcnow()
+            if now - self._last_update < self._min_time:
+                return
+
            self._telegram = telegram
+            self._last_update = now
            self.async_write_ha_state()

        self._async_remove_dispatcher = async_dispatcher_connect(
@@ -6,10 +6,7 @@
    "step": {
      "user": {
        "data": {
-          "serial_port": "[%key:common::config_flow::data::port%]"
-        },
-        "data_description": {
-          "serial_port": "Serial port path to connect to"
+          "serial_port": "[%key:common::config_flow::data::usb_path%]"
        },
        "title": "Add your EDL21 smart meter"
      }
@@ -40,7 +40,6 @@ ELK_ELEMENTS = {
 EVENT_ELKM1_KEYPAD_KEY_PRESSED = "elkm1.keypad_key_pressed"


-ATTR_DURATION = "duration"
 ATTR_KEYPAD_ID = "keypad_id"
 ATTR_KEY = "key"
 ATTR_KEY_NAME = "key_name"
@@ -48,9 +48,6 @@
    },
    "speak_word": {
      "service": "mdi:message-minus"
-    },
-    "switch_output_turn_on_for": {
-      "service": "mdi:timer"
    }
  }
 }
@@ -161,15 +161,3 @@ sensor_zone_trigger:
    entity:
      integration: elkm1
      domain: sensor
-
-switch_output_turn_on_for:
-  target:
-    entity:
-      integration: elkm1
-      domain: switch
-  fields:
-    duration:
-      example: 42
-      required: true
-      selector:
-        duration:
@@ -210,16 +210,6 @@
        }
      },
      "name": "Speak word"
-    },
-    "switch_output_turn_on_for": {
-      "description": "Turns on an output for a specified length of time.",
-      "fields": {
-        "duration": {
-          "description": "Length of time to turn the output on for.",
-          "name": "Duration"
-        }
-      },
-      "name": "Switch output turn on for"
    }
  }
 }
@@ -1,7 +1,5 @@
 """Support for control of ElkM1 outputs (relays)."""

-from datetime import timedelta
-from math import ceil
 from typing import Any

 from elkm1_lib.const import ThermostatMode, ThermostatSetting
@@ -9,29 +7,15 @@ from elkm1_lib.elements import Element
 from elkm1_lib.elk import Elk
 from elkm1_lib.outputs import Output
 from elkm1_lib.thermostats import Thermostat
-import voluptuous as vol

-from homeassistant.components.switch import DOMAIN as SWITCH_DOMAIN, SwitchEntity
+from homeassistant.components.switch import SwitchEntity
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers import config_validation as cv, service
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-from homeassistant.helpers.typing import VolDictType

 from . import ElkM1ConfigEntry
-from .const import ATTR_DURATION, DOMAIN
 from .entity import ElkAttachedEntity, ElkEntity, create_elk_entities
 from .models import ELKM1Data

-SERVICE_SWITCH_OUTPUT_TURN_ON_FOR = "switch_output_turn_on_for"
-
-ELK_OUTPUT_TURN_ON_FOR_SERVICE_SCHEMA: VolDictType = {
-    vol.Required(ATTR_DURATION): vol.All(
-        cv.time_period,
-        vol.Range(min=timedelta(seconds=1), max=timedelta(seconds=65535)),
-    ),
-}
-

 async def async_setup_entry(
    hass: HomeAssistant,
@@ -48,15 +32,6 @@ async def async_setup_entry(
    )
    async_add_entities(entities)

-    service.async_register_platform_entity_service(
-        hass,
-        DOMAIN,
-        SERVICE_SWITCH_OUTPUT_TURN_ON_FOR,
-        entity_domain=SWITCH_DOMAIN,
-        schema=ELK_OUTPUT_TURN_ON_FOR_SERVICE_SCHEMA,
-        func="async_switch_output_turn_on_for",
-    )
-

 class ElkOutput(ElkAttachedEntity, SwitchEntity):
    """Elk output as switch."""
@@ -76,10 +51,6 @@ class ElkOutput(ElkAttachedEntity, SwitchEntity):
        """Turn off the output."""
        self._element.turn_off()

-    async def async_switch_output_turn_on_for(self, duration: timedelta) -> None:
-        """Turn on an output for specified length of time."""
-        self._element.turn_on(ceil(duration.total_seconds()))
-

 class ElkThermostatEMHeat(ElkEntity, SwitchEntity):
    """Elk Thermostat emergency heat as switch."""
@@ -108,7 +79,3 @@ class ElkThermostatEMHeat(ElkEntity, SwitchEntity):
    async def async_turn_off(self, **kwargs: Any) -> None:
        """Turn off the output."""
        self._elk_set(ThermostatMode.EMERGENCY_HEAT)
-
-    async def async_switch_output_turn_on_for(self, duration: timedelta) -> None:
-        """Turn on an output for specified length of time: not supported for thermostat."""
-        raise HomeAssistantError("supported only on ElkM1 output switch entities")
@@ -27,7 +27,7 @@ DEFAULT_BLUETOOTH_SCANNING_MODE = BluetoothScanningMode.AUTO.value

 DEFAULT_PORT: Final = 6053

-STABLE_BLE_VERSION_STR = "2026.5.1"
+STABLE_BLE_VERSION_STR = "2025.11.0"
 STABLE_BLE_VERSION = AwesomeVersion(STABLE_BLE_VERSION_STR)
 PROJECT_URLS = {
    "esphome.bluetooth-proxy": "https://esphome.github.io/bluetooth-proxies/",
@@ -53,7 +53,7 @@ def async_static_info_updated(
    platform: entity_platform.EntityPlatform,
    async_add_entities: AddEntitiesCallback,
    info_type: type[_InfoT],
-    entity_type: Callable[[RuntimeEntryData, EntityInfo, type[_StateT]], _EntityT],
+    entity_type: type[_EntityT],
    state_type: type[_StateT],
    infos: list[EntityInfo],
 ) -> None:
@@ -188,7 +188,7 @@ async def platform_async_setup_entry(
    async_add_entities: AddEntitiesCallback,
    *,
    info_type: type[_InfoT],
-    entity_type: Callable[[RuntimeEntryData, EntityInfo, type[_StateT]], _EntityT],
+    entity_type: type[_EntityT],
    state_type: type[_StateT],
    info_filter: Callable[[_InfoT], bool] | None = None,
 ) -> None:
@@ -196,11 +196,6 @@ async def platform_async_setup_entry(

    This method is in charge of receiving, distributing and storing
    info and state updates.
-
-    `entity_type` is any callable that builds an entity from
-    `(entry_data, info, state_type)`. A regular entity class satisfies this,
-    and platforms with multiple entity classes can pass a factory function
-    that picks the class per static info.
    """
    entry_data = entry.runtime_data
    entry_data.info[info_type] = {}
@@ -1,34 +1,28 @@
 """Infrared platform for ESPHome."""

-import functools
+from functools import partial
 import logging
-from typing import TYPE_CHECKING

-from aioesphomeapi import EntityInfo, EntityState, InfraredCapability, InfraredInfo
-from aioesphomeapi.client import InfraredRFReceiveEventModel
+from aioesphomeapi import EntityState, InfraredCapability, InfraredInfo

-from homeassistant.components.infrared import (
-    InfraredCommand,
-    InfraredEmitterEntity,
-    InfraredReceivedSignal,
-    InfraredReceiverEntity,
-)
-from homeassistant.core import CALLBACK_TYPE, callback
+from homeassistant.components.infrared import InfraredCommand, InfraredEmitterEntity
+from homeassistant.core import callback

 from .entity import (
    EsphomeEntity,
    convert_api_error_ha_error,
    platform_async_setup_entry,
 )
-from .entry_data import RuntimeEntryData

 _LOGGER = logging.getLogger(__name__)

 PARALLEL_UPDATES = 0


-class _EsphomeInfraredEntity(EsphomeEntity[InfraredInfo, EntityState]):
-    """Common base for ESPHome infrared entities."""
+class EsphomeInfraredEntity(
+    EsphomeEntity[InfraredInfo, EntityState], InfraredEmitterEntity
+):
+    """ESPHome infrared emitter entity using native API."""

    @callback
    def _on_device_update(self) -> None:
@@ -38,10 +32,6 @@ class _EsphomeInfraredEntity(EsphomeEntity[InfraredInfo, EntityState]):
            # Infrared entities should go available as soon as the device comes online
            self.async_write_ha_state()

-
-class EsphomeInfraredEmitterEntity(_EsphomeInfraredEntity, InfraredEmitterEntity):
-    """ESPHome infrared emitter entity using native API."""
-
    @convert_api_error_ha_error
    async def async_send_command(self, command: InfraredCommand) -> None:
        """Send an IR command."""
@@ -56,77 +46,10 @@ class EsphomeInfraredEmitterEntity(_EsphomeInfraredEntity, InfraredEmitterEntity
        )


-class EsphomeInfraredReceiverEntity(_EsphomeInfraredEntity, InfraredReceiverEntity):
-    """ESPHome infrared receiver entity using native API."""
-
-    _unsub_receive: CALLBACK_TYPE | None = None
-
-    async def async_added_to_hass(self) -> None:
-        """Register callbacks including IR receive subscription."""
-        await super().async_added_to_hass()
-        self._async_subscribe_receive()
-
-    async def async_will_remove_from_hass(self) -> None:
-        """Unsubscribe from the device on entity removal."""
-        await super().async_will_remove_from_hass()
-        if self._unsub_receive is not None:
-            self._unsub_receive()
-            self._unsub_receive = None
-
-    @callback
-    def _async_subscribe_receive(self) -> None:
-        """Subscribe to IR receive events if the device is connected."""
-        # Subscribing requires an active API connection; defer to
-        # _on_device_update when the device is not (yet) available.
-        if self._unsub_receive is not None or not self._entry_data.available:
-            return
-        self._unsub_receive = self._client.subscribe_infrared_rf_receive(
-            self._on_infrared_rf_receive
-        )
-
-    @callback
-    def _on_device_update(self) -> None:
-        """Call when device updates or entry data changes."""
-        super()._on_device_update()
-        if self._entry_data.available:
-            self._async_subscribe_receive()
-        elif self._unsub_receive is not None:
-            self._unsub_receive = None
-
-    @callback
-    def _on_infrared_rf_receive(self, event: InfraredRFReceiveEventModel) -> None:
-        """Handle a received IR signal from the device."""
-        if (
-            event.key != self._static_info.key
-            or event.device_id != self._static_info.device_id
-        ):
-            return
-        self._handle_received_signal(InfraredReceivedSignal(timings=event.timings))
-
-
-def _make_infrared_entity(
-    entry_data: RuntimeEntryData,
-    info: EntityInfo,
-    state_type: type[EntityState],
-) -> _EsphomeInfraredEntity:
-    """Build the right infrared entity based on the InfraredInfo capabilities."""
-    if TYPE_CHECKING:
-        assert isinstance(info, InfraredInfo)
-    cls = (
-        EsphomeInfraredReceiverEntity
-        if info.capabilities & InfraredCapability.RECEIVER
-        else EsphomeInfraredEmitterEntity
-    )
-    return cls(entry_data, info, state_type)
-
-
-async_setup_entry = functools.partial(
+async_setup_entry = partial(
    platform_async_setup_entry,
    info_type=InfraredInfo,
-    entity_type=_make_infrared_entity,
+    entity_type=EsphomeInfraredEntity,
    state_type=EntityState,
-    info_filter=lambda info: bool(
-        info.capabilities
-        & (InfraredCapability.TRANSMITTER | InfraredCapability.RECEIVER)
-    ),
+    info_filter=lambda info: bool(info.capabilities & InfraredCapability.TRANSMITTER),
 )
@@ -17,7 +17,7 @@
  "mqtt": ["esphome/discover/#"],
  "quality_scale": "platinum",
  "requirements": [
-    "aioesphomeapi==45.3.1",
+    "aioesphomeapi==45.2.2",
    "esphome-dashboard-api==1.3.0",
    "bleak-esphome==3.9.1"
  ],
@@ -124,11 +124,11 @@ async def async_setup_entry(

    for camera in coordinator.data:
        device_category = coordinator.data[camera].get("device_category")
-        support_ext = coordinator.data[camera].get("supportExt")
+        supportExt = coordinator.data[camera].get("supportExt")
        if (
            device_category == DeviceCatagories.BATTERY_CAMERA_DEVICE_CATEGORY.value
-            and support_ext
-            and str(SupportExt.SupportBatteryManage.value) in support_ext
+            and supportExt
+            and str(SupportExt.SupportBatteryManage.value) in supportExt
        ):
            entities.append(
                EzvizSelect(coordinator, camera, BATTERY_WORK_MODE_SELECT_TYPE)
@@ -2,7 +2,7 @@

 from collections.abc import Callable, Mapping
 from dataclasses import dataclass
-from typing import Any
+from typing import Any, override

 from faadelays import Airport

@@ -121,11 +121,13 @@ class FAABinarySensor(CoordinatorEntity[FAADataUpdateCoordinator], BinarySensorE
            entry_type=DeviceEntryType.SERVICE,
        )

+    @override
    @property
    def is_on(self) -> bool | None:
        """Return the status of the sensor."""
        return self.entity_description.is_on_fn(self.coordinator.data)

+    @override
    @property
    def extra_state_attributes(self) -> Mapping[str, Any]:
        """Return attributes for sensor."""
@@ -1,7 +1,7 @@
 """Config flow for FAA Delays integration."""

 import logging
-from typing import Any
+from typing import Any, override

 from aiohttp import ClientConnectionError
 import faadelays
@@ -23,6 +23,7 @@ class FAADelaysConfigFlow(ConfigFlow, domain=DOMAIN):

    VERSION = 1

+    @override
    async def async_step_user(
        self, user_input: dict[str, Any] | None = None
    ) -> ConfigFlowResult:
@@ -3,6 +3,7 @@
 import asyncio
 from datetime import timedelta
 import logging
+from typing import override

 from aiohttp import ClientConnectionError
 from faadelays import Airport
@@ -34,6 +35,7 @@ class FAADataUpdateCoordinator(DataUpdateCoordinator[Airport]):
        self.session = aiohttp_client.async_get_clientsession(hass)
        self.data = Airport(code, self.session)

+    @override
    async def _async_update_data(self) -> Airport:
        try:
            async with asyncio.timeout(10):
@@ -3,7 +3,7 @@
 from http import HTTPStatus
 import json
 import logging
-from typing import Any
+from typing import Any, override

 import requests
 import voluptuous as vol
@@ -45,6 +45,7 @@ class FacebookNotificationService(BaseNotificationService):
        """Initialize the service."""
        self.page_access_token = access_token

+    @override
    def send_message(self, message: str = "", **kwargs: Any) -> None:
        """Send some message."""
        payload = {"access_token": self.page_access_token}
@@ -4,7 +4,7 @@ from datetime import timedelta
 import logging
 import os
 import re
-from typing import Any
+from typing import Any, override

 import voluptuous as vol

@@ -69,16 +69,19 @@ class BanSensor(SensorEntity):
        )
        _LOGGER.debug("Setting up jail %s", self.jail)

+    @override
    @property
    def name(self):
        """Return the name of the sensor."""
        return self._name

+    @override
    @property
    def extra_state_attributes(self) -> dict[str, Any]:
        """Return the state attributes of the fail2ban sensor."""
        return self.ban_dict

+    @override
    @property
    def native_value(self):
        """Return the most recently banned IP Address."""
@@ -1,5 +1,7 @@
 """Family Hub camera for Samsung Refrigerators."""

+from typing import override
+
 from pyfamilyhublocal import FamilyHubCam
 import voluptuous as vol

@@ -50,12 +52,14 @@ class FamilyHubCamera(Camera):
        self._name = name
        self.family_hub_cam = family_hub_cam

+    @override
    async def async_camera_image(
        self, width: int | None = None, height: int | None = None
    ) -> bytes | None:
        """Return a still image response."""
        return await self.family_hub_cam.async_get_cam_image()

+    @override
    @property
    def name(self):
        """Return the name of this camera."""
--- a/Show More
+++ b/Show More