Revert "Return target in trigger description command (#156766 )"

This reverts commit 343ea1b82d.
2025-11-26 19:18:05 +00:00 · 2025-11-19 07:58:17 +01:00
814 changed files with 9465 additions and 70926 deletions
--- a/.github/workflows/builder.yml
+++ b/.github/workflows/builder.yml
@@ -14,7 +14,6 @@ env:
  PIP_TIMEOUT: 60
  UV_HTTP_TIMEOUT: 60
  UV_SYSTEM_PYTHON: "true"
-  BASE_IMAGE_VERSION: "2025.11.0"

 jobs:
  init:
@@ -22,15 +21,18 @@ jobs:
    if: github.repository_owner == 'home-assistant'
    runs-on: ubuntu-latest
    outputs:
+      architectures: ${{ steps.info.outputs.architectures }}
      version: ${{ steps.version.outputs.version }}
      channel: ${{ steps.version.outputs.channel }}
      publish: ${{ steps.version.outputs.publish }}
    steps:
      - name: Checkout the repository
-        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
+        with:
+          fetch-depth: 0

      - name: Set up Python ${{ env.DEFAULT_PYTHON }}
-        uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
+        uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6.0.0
        with:
          python-version: ${{ env.DEFAULT_PYTHON }}

@@ -77,7 +79,7 @@ jobs:
    name: Build ${{ matrix.arch }} base core image
    if: github.repository_owner == 'home-assistant'
    needs: init
-    runs-on: ${{ matrix.os }}
+    runs-on: ubuntu-latest
    permissions:
      contents: read
      packages: write
@@ -85,15 +87,14 @@ jobs:
    strategy:
      fail-fast: false
      matrix:
-        arch: ["amd64", "aarch64"]
-        include:
-          - arch: amd64
-            os: ubuntu-latest
-          - arch: aarch64
-            os: ubuntu-24.04-arm
+        arch: ${{ fromJson(needs.init.outputs.architectures) }}
+        exclude:
+          - arch: armv7
+          - arch: armhf
+          - arch: i386
    steps:
      - name: Checkout the repository
-        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1

      - name: Download nightly wheels of frontend
        if: needs.init.outputs.channel == 'dev'
@@ -119,7 +120,7 @@ jobs:

      - name: Set up Python ${{ env.DEFAULT_PYTHON }}
        if: needs.init.outputs.channel == 'dev'
-        uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
+        uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6.0.0
        with:
          python-version: ${{ env.DEFAULT_PYTHON }}

@@ -187,59 +188,16 @@ jobs:
          username: ${{ github.repository_owner }}
          password: ${{ secrets.GITHUB_TOKEN }}

-      - name: Install Cosign
-        uses: sigstore/cosign-installer@faadad0cce49287aee09b3a48701e75088a2c6ad # v4.0.0
-        with:
-          cosign-release: "v2.5.3"
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@e468171a9de216ec08956ac3ada2f0791b6bd435 # v3.11.1
-
-      - name: Build variables
-        id: vars
-        shell: bash
-        run: |
-          echo "base_image=ghcr.io/home-assistant/${{ matrix.arch }}-homeassistant-base:${{ env.BASE_IMAGE_VERSION }}" >> "$GITHUB_OUTPUT"
-          echo "cache_image=ghcr.io/home-assistant/${{ matrix.arch }}-homeassistant:latest" >> "$GITHUB_OUTPUT"
-          echo "created=$(date --rfc-3339=seconds --utc)" >> "$GITHUB_OUTPUT"
-
-      - name: Verify base image signature
-        run: |
-          cosign verify \
-            --certificate-oidc-issuer https://token.actions.githubusercontent.com \
-            --certificate-identity-regexp "https://github.com/home-assistant/docker/.*" \
-            "${{ steps.vars.outputs.base_image }}"
-
-      - name: Verify cache image signature
-        id: cache
-        continue-on-error: true
-        run: |
-          cosign verify \
-            --certificate-oidc-issuer https://token.actions.githubusercontent.com \
-            --certificate-identity-regexp "https://github.com/home-assistant/core/.*" \
-            "${{ steps.vars.outputs.cache_image }}"
-
+      # home-assistant/builder doesn't support sha pinning
      - name: Build base image
-        id: build
-        uses: docker/build-push-action@263435318d21b8e681c14492fe198d362a7d2c83 # v6.18.0
+        uses: home-assistant/builder@2025.09.0
        with:
-          context: .
-          file: ./Dockerfile
-          platforms: ${{ steps.vars.outputs.platform }}
-          push: true
-          cache-from: ${{ steps.cache.outcome == 'success' && steps.vars.outputs.cache_image || '' }}
-          build-args: |
-            BUILD_FROM=${{ steps.vars.outputs.base_image }}
-          tags: ghcr.io/home-assistant/${{ matrix.arch }}-homeassistant:${{ needs.init.outputs.version }}
-          labels: |
-            io.hass.arch=${{ matrix.arch }}
-            io.hass.version=${{ needs.init.outputs.version }}
-            org.opencontainers.image.created=${{ steps.vars.outputs.created }}
-            org.opencontainers.image.version=${{ needs.init.outputs.version }}
-
-      - name: Sign image
-        run: |
-          cosign sign --yes "ghcr.io/home-assistant/${{ matrix.arch }}-homeassistant:${{ needs.init.outputs.version }}@${{ steps.build.outputs.digest }}"
+          args: |
+            $BUILD_ARGS \
+            --${{ matrix.arch }} \
+            --cosign \
+            --target /data \
+            --generic ${{ needs.init.outputs.version }}

  build_machine:
    name: Build ${{ matrix.machine }} machine core image
@@ -269,7 +227,7 @@ jobs:
          - green
    steps:
      - name: Checkout the repository
-        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1

      - name: Set build additional args
        run: |
@@ -307,7 +265,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout the repository
-        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1

      - name: Initialize git
        uses: home-assistant/actions/helpers/git-init@master
@@ -351,7 +309,7 @@ jobs:
        registry: ["ghcr.io/home-assistant", "docker.io/homeassistant"]
    steps:
      - name: Checkout the repository
-        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1

      - name: Install Cosign
        uses: sigstore/cosign-installer@faadad0cce49287aee09b3a48701e75088a2c6ad # v4.0.0
@@ -460,10 +418,10 @@ jobs:
    if: github.repository_owner == 'home-assistant' && needs.init.outputs.publish == 'true'
    steps:
      - name: Checkout the repository
-        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1

      - name: Set up Python ${{ env.DEFAULT_PYTHON }}
-        uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
+        uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6.0.0
        with:
          python-version: ${{ env.DEFAULT_PYTHON }}

@@ -505,7 +463,7 @@ jobs:
      HASSFEST_IMAGE_TAG: ghcr.io/home-assistant/hassfest:${{ needs.init.outputs.version }}
    steps:
      - name: Checkout repository
-        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1

      - name: Login to GitHub Container Registry
        uses: docker/login-action@5e57cd118135c172c3672efd75eb46360885c0ef # v3.6.0
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -99,7 +99,7 @@ jobs:
    steps:
      - &checkout
        name: Check out code from GitHub
-        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
      - name: Generate partial Python venv restore key
        id: generate_python_cache_key
        run: |
@@ -257,7 +257,7 @@ jobs:
      - &setup-python-default
        name: Set up Python ${{ env.DEFAULT_PYTHON }}
        id: python
-        uses: &actions-setup-python actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
+        uses: &actions-setup-python actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6.0.0
        with:
          python-version: ${{ env.DEFAULT_PYTHON }}
          check-latest: true
--- a/.github/workflows/codeql.yml
+++ b/.github/workflows/codeql.yml
@@ -21,14 +21,14 @@ jobs:

    steps:
      - name: Check out code from GitHub
-        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1

      - name: Initialize CodeQL
-        uses: github/codeql-action/init@fdbfb4d2750291e159f0156def62b853c2798ca2 # v4.31.5
+        uses: github/codeql-action/init@014f16e7ab1402f30e7c3329d33797e7948572db # v4.31.3
        with:
          languages: python

      - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@fdbfb4d2750291e159f0156def62b853c2798ca2 # v4.31.5
+        uses: github/codeql-action/analyze@014f16e7ab1402f30e7c3329d33797e7948572db # v4.31.3
        with:
          category: "/language:python"
--- a/.github/workflows/detect-duplicate-issues.yml
+++ b/.github/workflows/detect-duplicate-issues.yml
@@ -231,7 +231,7 @@ jobs:
      - name: Detect duplicates using AI
        id: ai_detection
        if: steps.extract.outputs.should_continue == 'true' && steps.fetch_similar.outputs.has_similar == 'true'
-        uses: actions/ai-inference@5022b33bc1431add9b2831934daf8147a2ad9331 # v2.0.2
+        uses: actions/ai-inference@a1c11829223a786afe3b5663db904a3aa1eac3a2 # v2.0.1
        with:
          model: openai/gpt-4o
          system-prompt: |
--- a/.github/workflows/detect-non-english-issues.yml
+++ b/.github/workflows/detect-non-english-issues.yml
@@ -57,7 +57,7 @@ jobs:
      - name: Detect language using AI
        id: ai_language_detection
        if: steps.detect_language.outputs.should_continue == 'true'
-        uses: actions/ai-inference@5022b33bc1431add9b2831934daf8147a2ad9331 # v2.0.2
+        uses: actions/ai-inference@a1c11829223a786afe3b5663db904a3aa1eac3a2 # v2.0.1
        with:
          model: openai/gpt-4o-mini
          system-prompt: |
--- a/.github/workflows/translations.yml
+++ b/.github/workflows/translations.yml
@@ -19,10 +19,10 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout the repository
-        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1

      - name: Set up Python ${{ env.DEFAULT_PYTHON }}
-        uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
+        uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6.0.0
        with:
          python-version: ${{ env.DEFAULT_PYTHON }}

--- a/.github/workflows/wheels.yml
+++ b/.github/workflows/wheels.yml
@@ -28,14 +28,16 @@ jobs:
    name: Initialize wheels builder
    if: github.repository_owner == 'home-assistant'
    runs-on: ubuntu-latest
+    outputs:
+      architectures: ${{ steps.info.outputs.architectures }}
    steps:
      - &checkout
        name: Checkout the repository
-        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1

      - name: Set up Python ${{ env.DEFAULT_PYTHON }}
        id: python
-        uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
+        uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6.0.0
        with:
          python-version: ${{ env.DEFAULT_PYTHON }}
          check-latest: true
@@ -48,6 +50,10 @@ jobs:
          pip install "$(grep '^uv' < requirements.txt)"
          uv pip install -r requirements.txt

+      - name: Get information
+        id: info
+        uses: home-assistant/actions/helpers/info@master
+
      - name: Create requirements_diff file
        run: |
          if [[ ${{ github.event_name }} =~ (schedule|workflow_dispatch) ]]; then
@@ -71,8 +77,20 @@ jobs:

            # Use C-Extension for SQLAlchemy
            echo "REQUIRE_SQLALCHEMY_CEXT=1"
+
+            # Add additional pip wheel build constraints
+            echo "PIP_CONSTRAINT=build_constraints.txt"
          ) > .env_file

+      - name: Write pip wheel build constraints
+        run: |
+          (
+            # ninja 1.11.1.2 + 1.11.1.3 seem to be broken on at least armhf
+            # this caused the numpy builds to fail
+            # https://github.com/scikit-build/ninja-python-distributions/issues/274
+            echo "ninja==1.11.1.1"
+          ) > build_constraints.txt
+
      - name: Upload env_file
        uses: &actions-upload-artifact actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
        with:
@@ -81,6 +99,13 @@ jobs:
          include-hidden-files: true
          overwrite: true

+      - name: Upload build_constraints
+        uses: *actions-upload-artifact
+        with:
+          name: build_constraints
+          path: ./build_constraints.txt
+          overwrite: true
+
      - name: Upload requirements_diff
        uses: *actions-upload-artifact
        with:
@@ -108,12 +133,18 @@ jobs:
      fail-fast: false
      matrix: &matrix-build
        abi: ["cp313", "cp314"]
-        arch: ["amd64", "aarch64"]
+        arch: ${{ fromJson(needs.init.outputs.architectures) }}
        include:
-          - arch: amd64
-            os: ubuntu-latest
+          - os: ubuntu-latest
          - arch: aarch64
            os: ubuntu-24.04-arm
+        exclude:
+          - abi: cp314
+            arch: armv7
+          - abi: cp314
+            arch: armhf
+          - abi: cp314
+            arch: i386
    steps:
      - *checkout

@@ -123,6 +154,12 @@ jobs:
        with:
          name: env_file

+      - &download-build-constraints
+        name: Download build_constraints
+        uses: *actions-download-artifact
+        with:
+          name: build_constraints
+
      - &download-requirements-diff
        name: Download requirements_diff
        uses: *actions-download-artifact
@@ -135,8 +172,9 @@ jobs:
          sed -i "/uv/d" requirements.txt
          sed -i "/uv/d" requirements_diff.txt

+      # home-assistant/wheels doesn't support sha pinning
      - name: Build wheels
-        uses: &home-assistant-wheels home-assistant/wheels@6066c17a2a4aafcf7bdfeae01717f63adfcdba98 # 2025.11.0
+        uses: &home-assistant-wheels home-assistant/wheels@2025.10.0
        with:
          abi: ${{ matrix.abi }}
          tag: musllinux_1_2
@@ -161,7 +199,7 @@ jobs:
      - *checkout

      - *download-env-file
-
+      - *download-build-constraints
      - *download-requirements-diff

      - name: Download requirements_all_wheels
@@ -171,12 +209,17 @@ jobs:

      - name: Adjust build env
        run: |
+          if [ "${{ matrix.arch }}" = "i386" ]; then
+            echo "NPY_DISABLE_SVML=1" >> .env_file
+          fi
+
          # Do not pin numpy in wheels building
          sed -i "/numpy/d" homeassistant/package_constraints.txt
          # Don't build wheels for uv as uv requires a greater version of rust as currently available on alpine
          sed -i "/uv/d" requirements.txt
          sed -i "/uv/d" requirements_diff.txt

+      # home-assistant/wheels doesn't support sha pinning
      - name: Build wheels
        uses: *home-assistant-wheels
        with:
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -94,7 +94,7 @@ repos:
        pass_filenames: false
        language: script
        types: [text]
-        files: ^(script/hassfest/(metadata|docker)\.py|homeassistant/const\.py$|pyproject\.toml)$
+        files: ^(script/hassfest/metadata\.py|homeassistant/const\.py$|pyproject\.toml|homeassistant/components/go2rtc/const\.py)$
      - id: hassfest-mypy-config
        name: hassfest-mypy-config
        entry: script/run-in-env.sh python3 -m script.hassfest -p mypy_config
--- a/.strict-typing
+++ b/.strict-typing
@@ -120,6 +120,7 @@ homeassistant.components.blueprint.*
 homeassistant.components.bluesound.*
 homeassistant.components.bluetooth.*
 homeassistant.components.bluetooth_adapters.*
+homeassistant.components.bluetooth_tracker.*
 homeassistant.components.bmw_connected_drive.*
 homeassistant.components.bond.*
 homeassistant.components.bosch_alarm.*
--- a/20
+++ b/20
@@ -69,8 +69,6 @@ build.json @home-assistant/supervisor
 /tests/components/airly/ @bieniu
 /homeassistant/components/airnow/ @asymworks
 /tests/components/airnow/ @asymworks
-/homeassistant/components/airobot/ @mettolen
-/tests/components/airobot/ @mettolen
 /homeassistant/components/airos/ @CoMPaTech
 /tests/components/airos/ @CoMPaTech
 /homeassistant/components/airq/ @Sibgatulin @dl2080
@@ -121,8 +119,6 @@ build.json @home-assistant/supervisor
 /tests/components/androidtv/ @JeffLIrion @ollo69
 /homeassistant/components/androidtv_remote/ @tronikos @Drafteed
 /tests/components/androidtv_remote/ @tronikos @Drafteed
-/homeassistant/components/anglian_water/ @pantherale0
-/tests/components/anglian_water/ @pantherale0
 /homeassistant/components/anova/ @Lash-L
 /tests/components/anova/ @Lash-L
 /homeassistant/components/anthemav/ @hyralex
@@ -185,8 +181,8 @@ build.json @home-assistant/supervisor
 /homeassistant/components/automation/ @home-assistant/core
 /tests/components/automation/ @home-assistant/core
 /homeassistant/components/avea/ @pattyland
-/homeassistant/components/awair/ @ahayworth @ricohageman
-/tests/components/awair/ @ahayworth @ricohageman
+/homeassistant/components/awair/ @ahayworth @danielsjf
+/tests/components/awair/ @ahayworth @danielsjf
 /homeassistant/components/aws_s3/ @tomasbedrich
 /tests/components/aws_s3/ @tomasbedrich
 /homeassistant/components/axis/ @Kane610
@@ -393,8 +389,6 @@ build.json @home-assistant/supervisor
 /tests/components/dsmr/ @Robbie1221
 /homeassistant/components/dsmr_reader/ @sorted-bits @glodenox @erwindouna
 /tests/components/dsmr_reader/ @sorted-bits @glodenox @erwindouna
-/homeassistant/components/duckdns/ @tr4nt0r
-/tests/components/duckdns/ @tr4nt0r
 /homeassistant/components/duke_energy/ @hunterjm
 /tests/components/duke_energy/ @hunterjm
 /homeassistant/components/duotecno/ @cereal2nd
@@ -474,8 +468,6 @@ build.json @home-assistant/supervisor
 /tests/components/escea/ @lazdavila
 /homeassistant/components/esphome/ @jesserockz @kbx81 @bdraco
 /tests/components/esphome/ @jesserockz @kbx81 @bdraco
-/homeassistant/components/essent/ @jaapp
-/tests/components/essent/ @jaapp
 /homeassistant/components/eufylife_ble/ @bdr99
 /tests/components/eufylife_ble/ @bdr99
 /homeassistant/components/event/ @home-assistant/core
@@ -595,8 +587,6 @@ build.json @home-assistant/supervisor
 /tests/components/goodwe/ @mletenay @starkillerOG
 /homeassistant/components/google/ @allenporter
 /tests/components/google/ @allenporter
-/homeassistant/components/google_air_quality/ @Thomas55555
-/tests/components/google_air_quality/ @Thomas55555
 /homeassistant/components/google_assistant/ @home-assistant/cloud
 /tests/components/google_assistant/ @home-assistant/cloud
 /homeassistant/components/google_assistant_sdk/ @tronikos
@@ -637,8 +627,6 @@ build.json @home-assistant/supervisor
 /tests/components/guardian/ @bachya
 /homeassistant/components/habitica/ @tr4nt0r
 /tests/components/habitica/ @tr4nt0r
-/homeassistant/components/hanna/ @bestycame
-/tests/components/hanna/ @bestycame
 /homeassistant/components/hardkernel/ @home-assistant/core
 /tests/components/hardkernel/ @home-assistant/core
 /homeassistant/components/hardware/ @home-assistant/core
@@ -706,8 +694,6 @@ build.json @home-assistant/supervisor
 /tests/components/huawei_lte/ @scop @fphammerle
 /homeassistant/components/hue/ @marcelveldt
 /tests/components/hue/ @marcelveldt
-/homeassistant/components/hue_ble/ @flip-dots
-/tests/components/hue_ble/ @flip-dots
 /homeassistant/components/huisbaasje/ @dennisschroer
 /tests/components/huisbaasje/ @dennisschroer
 /homeassistant/components/humidifier/ @home-assistant/core @Shulyaka
@@ -860,8 +846,6 @@ build.json @home-assistant/supervisor
 /tests/components/kraken/ @eifinger
 /homeassistant/components/kulersky/ @emlove
 /tests/components/kulersky/ @emlove
-/homeassistant/components/labs/ @home-assistant/core
-/tests/components/labs/ @home-assistant/core
 /homeassistant/components/lacrosse_view/ @IceBotYT
 /tests/components/lacrosse_view/ @IceBotYT
 /homeassistant/components/lamarzocco/ @zweckj
--- a/33
+++ b/33
@@ -4,33 +4,34 @@
 ARG BUILD_FROM
 FROM ${BUILD_FROM}

-LABEL \
-    io.hass.type="core" \
-    org.opencontainers.image.authors="The Home Assistant Authors" \
-    org.opencontainers.image.description="Open-source home automation platform running on Python 3" \
-    org.opencontainers.image.documentation="https://www.home-assistant.io/docs/" \
-    org.opencontainers.image.licenses="Apache-2.0" \
-    org.opencontainers.image.source="https://github.com/home-assistant/core" \
-    org.opencontainers.image.title="Home Assistant" \
-    org.opencontainers.image.url="https://www.home-assistant.io/"
-
 # Synchronize with homeassistant/core.py:async_stop
 ENV \
    S6_SERVICES_GRACETIME=240000 \
    UV_SYSTEM_PYTHON=true \
    UV_NO_CACHE=true

+ARG QEMU_CPU
+
 # Home Assistant S6-Overlay
 COPY rootfs /

-# Add go2rtc binary
-COPY --from=ghcr.io/alexxit/go2rtc@sha256:baef0aa19d759fcfd31607b34ce8eaf039d496282bba57731e6ae326896d7640 /usr/local/bin/go2rtc /bin/go2rtc
-
+# Needs to be redefined inside the FROM statement to be set for RUN commands
+ARG BUILD_ARCH
+# Get go2rtc binary
 RUN \
+    case "${BUILD_ARCH}" in \
+        "aarch64") go2rtc_suffix='arm64' ;; \
+        "armhf") go2rtc_suffix='armv6' ;; \
+        "armv7") go2rtc_suffix='arm' ;; \
+        *) go2rtc_suffix=${BUILD_ARCH} ;; \
+    esac \
+    && curl -L https://github.com/AlexxIT/go2rtc/releases/download/v1.9.11/go2rtc_linux_${go2rtc_suffix} --output /bin/go2rtc \
+    && chmod +x /bin/go2rtc \
    # Verify go2rtc can be executed
-    go2rtc --version \
-    # Install uv
-    && pip3 install uv==0.9.6
+    && go2rtc --version
+
+# Install uv
+RUN pip3 install uv==0.9.6

 WORKDIR /usr/src

--- a/build.yaml
+++ b/build.yaml
@@ -0,0 +1,19 @@
+image: ghcr.io/home-assistant/{arch}-homeassistant
+build_from:
+  aarch64: ghcr.io/home-assistant/aarch64-homeassistant-base:2025.11.0
+  armhf: ghcr.io/home-assistant/armhf-homeassistant-base:2025.11.0
+  armv7: ghcr.io/home-assistant/armv7-homeassistant-base:2025.11.0
+  amd64: ghcr.io/home-assistant/amd64-homeassistant-base:2025.11.0
+  i386: ghcr.io/home-assistant/i386-homeassistant-base:2025.11.0
+cosign:
+  base_identity: https://github.com/home-assistant/docker/.*
+  identity: https://github.com/home-assistant/core/.*
+labels:
+  io.hass.type: core
+  org.opencontainers.image.title: Home Assistant
+  org.opencontainers.image.description: Open-source home automation platform running on Python 3
+  org.opencontainers.image.source: https://github.com/home-assistant/core
+  org.opencontainers.image.authors: The Home Assistant Authors
+  org.opencontainers.image.url: https://www.home-assistant.io/
+  org.opencontainers.image.documentation: https://www.home-assistant.io/docs/
+  org.opencontainers.image.licenses: Apache-2.0
--- a/homeassistant/bootstrap.py
+++ b/homeassistant/bootstrap.py
@@ -176,8 +176,6 @@ FRONTEND_INTEGRATIONS = {
 STAGE_0_INTEGRATIONS = (
    # Load logging and http deps as soon as possible
    ("logging, http deps", LOGGING_AND_HTTP_DEPS_INTEGRATIONS, None),
-    # Setup labs for preview features
-    ("labs", {"labs"}, STAGE_0_SUBSTAGE_TIMEOUT),
    # Setup frontend
    ("frontend", FRONTEND_INTEGRATIONS, None),
    # Setup recorder
@@ -214,7 +212,6 @@ DEFAULT_INTEGRATIONS = {
    "backup",
    "frontend",
    "hardware",
-    "labs",
    "logger",
    "network",
    "system_health",
--- a/homeassistant/brands/google.json
+++ b/homeassistant/brands/google.json
@@ -2,7 +2,6 @@
  "domain": "google",
  "name": "Google",
  "integrations": [
-    "google_air_quality",
    "google_assistant",
    "google_assistant_sdk",
    "google_cloud",
--- a/homeassistant/brands/philips.json
+++ b/homeassistant/brands/philips.json
@@ -1,5 +1,5 @@
 {
  "domain": "philips",
  "name": "Philips",
-  "integrations": ["dynalite", "hue", "hue_ble", "philips_js"]
+  "integrations": ["dynalite", "hue", "philips_js"]
 }
--- a/homeassistant/brands/raspberry_pi.json
+++ b/homeassistant/brands/raspberry_pi.json
@@ -1,5 +1,5 @@
 {
  "domain": "raspberry_pi",
  "name": "Raspberry Pi",
-  "integrations": ["raspberry_pi", "rpi_power", "remote_rpi_gpio"]
+  "integrations": ["raspberry_pi", "rpi_camera", "rpi_power", "remote_rpi_gpio"]
 }
--- a/homeassistant/components/actron_air/init.py
+++ b/homeassistant/components/actron_air/init.py
@@ -1,10 +1,10 @@
 """The Actron Air integration."""

 from actron_neo_api import (
-    ActronAirACSystem,
-    ActronAirAPI,
-    ActronAirAPIError,
-    ActronAirAuthError,
+    ActronAirNeoACSystem,
+    ActronNeoAPI,
+    ActronNeoAPIError,
+    ActronNeoAuthError,
 )

 from homeassistant.const import CONF_API_TOKEN, Platform
@@ -23,16 +23,16 @@ PLATFORM = [Platform.CLIMATE]
 async def async_setup_entry(hass: HomeAssistant, entry: ActronAirConfigEntry) -> bool:
    """Set up Actron Air integration from a config entry."""

-    api = ActronAirAPI(refresh_token=entry.data[CONF_API_TOKEN])
-    systems: list[ActronAirACSystem] = []
+    api = ActronNeoAPI(refresh_token=entry.data[CONF_API_TOKEN])
+    systems: list[ActronAirNeoACSystem] = []

    try:
        systems = await api.get_ac_systems()
        await api.update_status()
-    except ActronAirAuthError:
+    except ActronNeoAuthError:
        _LOGGER.error("Authentication error while setting up Actron Air integration")
        raise
-    except ActronAirAPIError as err:
+    except ActronNeoAPIError as err:
        _LOGGER.error("API error while setting up Actron Air integration: %s", err)
        raise

--- a/homeassistant/components/actron_air/climate.py
+++ b/homeassistant/components/actron_air/climate.py
@@ -2,7 +2,7 @@

 from typing import Any

-from actron_neo_api import ActronAirStatus, ActronAirZone
+from actron_neo_api import ActronAirNeoStatus, ActronAirNeoZone

 from homeassistant.components.climate import (
    FAN_AUTO,
@@ -132,7 +132,7 @@ class ActronSystemClimate(BaseClimateEntity):
        return self._status.max_temp

    @property
-    def _status(self) -> ActronAirStatus:
+    def _status(self) -> ActronAirNeoStatus:
        """Get the current status from the coordinator."""
        return self.coordinator.data

@@ -194,7 +194,7 @@ class ActronZoneClimate(BaseClimateEntity):
    def __init__(
        self,
        coordinator: ActronAirSystemCoordinator,
-        zone: ActronAirZone,
+        zone: ActronAirNeoZone,
    ) -> None:
        """Initialize an Actron Air unit."""
        super().__init__(coordinator, zone.title)
@@ -221,7 +221,7 @@ class ActronZoneClimate(BaseClimateEntity):
        return self._zone.max_temp

    @property
-    def _zone(self) -> ActronAirZone:
+    def _zone(self) -> ActronAirNeoZone:
        """Get the current zone data from the coordinator."""
        status = self.coordinator.data
        return status.zones[self._zone_id]
--- a/homeassistant/components/actron_air/config_flow.py
+++ b/homeassistant/components/actron_air/config_flow.py
@@ -3,7 +3,7 @@
 import asyncio
 from typing import Any

-from actron_neo_api import ActronAirAPI, ActronAirAuthError
+from actron_neo_api import ActronNeoAPI, ActronNeoAuthError

 from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
 from homeassistant.const import CONF_API_TOKEN
@@ -17,7 +17,7 @@ class ActronAirConfigFlow(ConfigFlow, domain=DOMAIN):

    def __init__(self) -> None:
        """Initialize the config flow."""
-        self._api: ActronAirAPI | None = None
+        self._api: ActronNeoAPI | None = None
        self._device_code: str | None = None
        self._user_code: str = ""
        self._verification_uri: str = ""
@@ -30,10 +30,10 @@ class ActronAirConfigFlow(ConfigFlow, domain=DOMAIN):
        """Handle the initial step."""
        if self._api is None:
            _LOGGER.debug("Initiating device authorization")
-            self._api = ActronAirAPI()
+            self._api = ActronNeoAPI()
            try:
                device_code_response = await self._api.request_device_code()
-            except ActronAirAuthError as err:
+            except ActronNeoAuthError as err:
                _LOGGER.error("OAuth2 flow failed: %s", err)
                return self.async_abort(reason="oauth2_error")

@@ -50,7 +50,7 @@ class ActronAirConfigFlow(ConfigFlow, domain=DOMAIN):
            try:
                await self._api.poll_for_token(self._device_code)
                _LOGGER.debug("Authorization successful")
-            except ActronAirAuthError as ex:
+            except ActronNeoAuthError as ex:
                _LOGGER.exception("Error while waiting for device authorization")
                raise CannotConnect from ex

@@ -89,7 +89,7 @@ class ActronAirConfigFlow(ConfigFlow, domain=DOMAIN):

        try:
            user_data = await self._api.get_user_info()
-        except ActronAirAuthError as err:
+        except ActronNeoAuthError as err:
            _LOGGER.error("Error getting user info: %s", err)
            return self.async_abort(reason="oauth2_error")

--- a/homeassistant/components/actron_air/coordinator.py
+++ b/homeassistant/components/actron_air/coordinator.py
@@ -5,7 +5,7 @@ from __future__ import annotations
 from dataclasses import dataclass
 from datetime import timedelta

-from actron_neo_api import ActronAirACSystem, ActronAirAPI, ActronAirStatus
+from actron_neo_api import ActronAirNeoACSystem, ActronAirNeoStatus, ActronNeoAPI

 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
@@ -23,7 +23,7 @@ ERROR_UNKNOWN = "unknown_error"
 class ActronAirRuntimeData:
    """Runtime data for the Actron Air integration."""

-    api: ActronAirAPI
+    api: ActronNeoAPI
    system_coordinators: dict[str, ActronAirSystemCoordinator]


@@ -33,15 +33,15 @@ AUTH_ERROR_THRESHOLD = 3
 SCAN_INTERVAL = timedelta(seconds=30)


-class ActronAirSystemCoordinator(DataUpdateCoordinator[ActronAirACSystem]):
+class ActronAirSystemCoordinator(DataUpdateCoordinator[ActronAirNeoACSystem]):
    """System coordinator for Actron Air integration."""

    def __init__(
        self,
        hass: HomeAssistant,
        entry: ActronAirConfigEntry,
-        api: ActronAirAPI,
-        system: ActronAirACSystem,
+        api: ActronNeoAPI,
+        system: ActronAirNeoACSystem,
    ) -> None:
        """Initialize the coordinator."""
        super().__init__(
@@ -57,7 +57,7 @@ class ActronAirSystemCoordinator(DataUpdateCoordinator[ActronAirACSystem]):
        self.status = self.api.state_manager.get_status(self.serial_number)
        self.last_seen = dt_util.utcnow()

-    async def _async_update_data(self) -> ActronAirStatus:
+    async def _async_update_data(self) -> ActronAirNeoStatus:
        """Fetch updates and merge incremental changes into the full state."""
        await self.api.update_status()
        self.status = self.api.state_manager.get_status(self.serial_number)
--- a/homeassistant/components/actron_air/manifest.json
+++ b/homeassistant/components/actron_air/manifest.json
@@ -12,5 +12,5 @@
  "documentation": "https://www.home-assistant.io/integrations/actron_air",
  "iot_class": "cloud_polling",
  "quality_scale": "bronze",
-  "requirements": ["actron-neo-api==0.1.87"]
+  "requirements": ["actron-neo-api==0.1.84"]
 }
--- a/homeassistant/components/airobot/init.py
+++ b/homeassistant/components/airobot/init.py
@@ -1,29 +0,0 @@
-"""The Airobot integration."""
-
-from __future__ import annotations
-
-from homeassistant.const import Platform
-from homeassistant.core import HomeAssistant
-
-from .coordinator import AirobotConfigEntry, AirobotDataUpdateCoordinator
-
-PLATFORMS: list[Platform] = [Platform.CLIMATE]
-
-
-async def async_setup_entry(hass: HomeAssistant, entry: AirobotConfigEntry) -> bool:
-    """Set up Airobot from a config entry."""
-    coordinator = AirobotDataUpdateCoordinator(hass, entry)
-
-    # Fetch initial data so we have data when entities subscribe
-    await coordinator.async_config_entry_first_refresh()
-
-    entry.runtime_data = coordinator
-
-    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
-
-    return True
-
-
-async def async_unload_entry(hass: HomeAssistant, entry: AirobotConfigEntry) -> bool:
-    """Unload a config entry."""
-    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
--- a/homeassistant/components/airobot/climate.py
+++ b/homeassistant/components/airobot/climate.py
@@ -1,168 +0,0 @@
-"""Climate platform for Airobot thermostat."""
-
-from __future__ import annotations
-
-from typing import Any
-
-from pyairobotrest.const import (
-    MODE_AWAY,
-    MODE_HOME,
-    SETPOINT_TEMP_MAX,
-    SETPOINT_TEMP_MIN,
-)
-from pyairobotrest.exceptions import AirobotError
-from pyairobotrest.models import ThermostatSettings, ThermostatStatus
-
-from homeassistant.components.climate import (
-    PRESET_AWAY,
-    PRESET_BOOST,
-    PRESET_HOME,
-    ClimateEntity,
-    ClimateEntityFeature,
-    HVACAction,
-    HVACMode,
-)
-from homeassistant.const import ATTR_TEMPERATURE, UnitOfTemperature
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ServiceValidationError
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-
-from . import AirobotConfigEntry
-from .const import DOMAIN
-from .entity import AirobotEntity
-
-PARALLEL_UPDATES = 1
-
-_PRESET_MODE_2_MODE = {
-    PRESET_AWAY: MODE_AWAY,
-    PRESET_HOME: MODE_HOME,
-}
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: AirobotConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up Airobot climate platform."""
-    coordinator = entry.runtime_data
-    async_add_entities([AirobotClimate(coordinator)])
-
-
-class AirobotClimate(AirobotEntity, ClimateEntity):
-    """Representation of an Airobot thermostat."""
-
-    _attr_name = None
-    _attr_translation_key = "thermostat"
-    _attr_temperature_unit = UnitOfTemperature.CELSIUS
-    _attr_hvac_modes = [HVACMode.HEAT]
-    _attr_preset_modes = [PRESET_HOME, PRESET_AWAY, PRESET_BOOST]
-    _attr_supported_features = (
-        ClimateEntityFeature.TARGET_TEMPERATURE | ClimateEntityFeature.PRESET_MODE
-    )
-    _attr_min_temp = SETPOINT_TEMP_MIN
-    _attr_max_temp = SETPOINT_TEMP_MAX
-
-    @property
-    def _status(self) -> ThermostatStatus:
-        """Get status from coordinator data."""
-        return self.coordinator.data.status
-
-    @property
-    def _settings(self) -> ThermostatSettings:
-        """Get settings from coordinator data."""
-        return self.coordinator.data.settings
-
-    @property
-    def current_temperature(self) -> float | None:
-        """Return the current temperature.
-
-        If floor temperature is available, thermostat is set up for floor heating.
-        """
-        if self._status.temp_floor is not None:
-            return self._status.temp_floor
-        return self._status.temp_air
-
-    @property
-    def current_humidity(self) -> float | None:
-        """Return the current humidity."""
-        return self._status.hum_air
-
-    @property
-    def target_temperature(self) -> float | None:
-        """Return the target temperature."""
-        if self._settings.is_home_mode:
-            return self._settings.setpoint_temp
-        return self._settings.setpoint_temp_away
-
-    @property
-    def hvac_mode(self) -> HVACMode:
-        """Return current HVAC mode."""
-        if self._status.is_heating:
-            return HVACMode.HEAT
-        return HVACMode.OFF
-
-    @property
-    def hvac_action(self) -> HVACAction:
-        """Return current HVAC action."""
-        if self._status.is_heating:
-            return HVACAction.HEATING
-        return HVACAction.IDLE
-
-    @property
-    def preset_mode(self) -> str | None:
-        """Return current preset mode."""
-        if self._settings.setting_flags.boost_enabled:
-            return PRESET_BOOST
-        if self._settings.is_home_mode:
-            return PRESET_HOME
-        return PRESET_AWAY
-
-    async def async_set_temperature(self, **kwargs: Any) -> None:
-        """Set new target temperature."""
-        temperature = kwargs[ATTR_TEMPERATURE]
-
-        try:
-            if self._settings.is_home_mode:
-                await self.coordinator.client.set_home_temperature(float(temperature))
-            else:
-                await self.coordinator.client.set_away_temperature(float(temperature))
-        except AirobotError as err:
-            raise ServiceValidationError(
-                translation_domain=DOMAIN,
-                translation_key="set_temperature_failed",
-                translation_placeholders={"temperature": str(temperature)},
-            ) from err
-
-        await self.coordinator.async_request_refresh()
-
-    async def async_set_hvac_mode(self, hvac_mode: HVACMode) -> None:
-        """Set HVAC mode.
-
-        This thermostat only supports HEAT mode. The climate platform validates
-        that only supported modes are passed, so this method is a no-op.
-        """
-
-    async def async_set_preset_mode(self, preset_mode: str) -> None:
-        """Set new preset mode."""
-        try:
-            if preset_mode == PRESET_BOOST:
-                # Enable boost mode
-                if not self._settings.setting_flags.boost_enabled:
-                    await self.coordinator.client.set_boost_mode(True)
-            else:
-                # Disable boost mode if it's enabled
-                if self._settings.setting_flags.boost_enabled:
-                    await self.coordinator.client.set_boost_mode(False)
-
-                # Set the mode (HOME or AWAY)
-                await self.coordinator.client.set_mode(_PRESET_MODE_2_MODE[preset_mode])
-
-        except AirobotError as err:
-            raise ServiceValidationError(
-                translation_domain=DOMAIN,
-                translation_key="set_preset_mode_failed",
-                translation_placeholders={"preset_mode": preset_mode},
-            ) from err
-
-        await self.coordinator.async_request_refresh()
--- a/homeassistant/components/airobot/config_flow.py
+++ b/homeassistant/components/airobot/config_flow.py
@@ -1,183 +0,0 @@
-"""Config flow for the Airobot integration."""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-import logging
-from typing import Any
-
-from pyairobotrest import AirobotClient
-from pyairobotrest.exceptions import (
-    AirobotAuthError,
-    AirobotConnectionError,
-    AirobotError,
-    AirobotTimeoutError,
-)
-import voluptuous as vol
-
-from homeassistant.config_entries import ConfigFlow as BaseConfigFlow, ConfigFlowResult
-from homeassistant.const import CONF_HOST, CONF_MAC, CONF_PASSWORD, CONF_USERNAME
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
-from homeassistant.helpers.service_info.dhcp import DhcpServiceInfo
-
-from .const import DOMAIN
-
-_LOGGER = logging.getLogger(__name__)
-
-STEP_USER_DATA_SCHEMA = vol.Schema(
-    {
-        vol.Required(CONF_HOST): str,
-        vol.Required(CONF_USERNAME): str,
-        vol.Required(CONF_PASSWORD): str,
-    }
-)
-
-
-@dataclass
-class DeviceInfo:
-    """Device information."""
-
-    title: str
-    device_id: str
-
-
-async def validate_input(hass: HomeAssistant, data: dict[str, Any]) -> DeviceInfo:
-    """Validate the user input allows us to connect.
-
-    Data has the keys from STEP_USER_DATA_SCHEMA with values provided by the user.
-    """
-    session = async_get_clientsession(hass)
-
-    client = AirobotClient(
-        host=data[CONF_HOST],
-        username=data[CONF_USERNAME],
-        password=data[CONF_PASSWORD],
-        session=session,
-    )
-
-    try:
-        # Try to fetch data to validate connection and authentication
-        status = await client.get_statuses()
-        settings = await client.get_settings()
-    except AirobotAuthError as err:
-        raise InvalidAuth from err
-    except (AirobotConnectionError, AirobotTimeoutError, AirobotError) as err:
-        raise CannotConnect from err
-
-    # Use device name or device ID as title
-    title = settings.device_name or status.device_id
-
-    return DeviceInfo(title=title, device_id=status.device_id)
-
-
-class AirobotConfigFlow(BaseConfigFlow, domain=DOMAIN):
-    """Handle a config flow for Airobot."""
-
-    VERSION = 1
-    MINOR_VERSION = 1
-
-    def __init__(self) -> None:
-        """Initialize the config flow."""
-        self._discovered_host: str | None = None
-        self._discovered_mac: str | None = None
-        self._discovered_device_id: str | None = None
-
-    async def async_step_dhcp(
-        self, discovery_info: DhcpServiceInfo
-    ) -> ConfigFlowResult:
-        """Handle DHCP discovery."""
-        # Store the discovered IP address and MAC
-        self._discovered_host = discovery_info.ip
-        self._discovered_mac = discovery_info.macaddress
-
-        # Extract device_id from hostname (format: airobot-thermostat-t01xxxxxx)
-        hostname = discovery_info.hostname.lower()
-        device_id = hostname.replace("airobot-thermostat-", "").upper()
-        self._discovered_device_id = device_id
-        # Set unique_id to device_id for duplicate detection
-        await self.async_set_unique_id(device_id)
-        self._abort_if_unique_id_configured(updates={CONF_HOST: discovery_info.ip})
-
-        # Show the confirmation form
-        return await self.async_step_dhcp_confirm()
-
-    async def async_step_dhcp_confirm(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle DHCP discovery confirmation - ask for credentials only."""
-        errors: dict[str, str] = {}
-
-        if user_input is not None:
-            # Combine discovered host and device_id with user-provided password
-            data = {
-                CONF_HOST: self._discovered_host,
-                CONF_USERNAME: self._discovered_device_id,
-                CONF_PASSWORD: user_input[CONF_PASSWORD],
-            }
-
-            try:
-                info = await validate_input(self.hass, data)
-            except CannotConnect:
-                errors["base"] = "cannot_connect"
-            except InvalidAuth:
-                errors["base"] = "invalid_auth"
-            except Exception:
-                _LOGGER.exception("Unexpected exception")
-                errors["base"] = "unknown"
-            else:
-                # Store MAC address in config entry data
-                if self._discovered_mac:
-                    data[CONF_MAC] = self._discovered_mac
-
-                return self.async_create_entry(title=info.title, data=data)
-
-        # Only ask for password since we already have the device_id from discovery
-        return self.async_show_form(
-            step_id="dhcp_confirm",
-            data_schema=vol.Schema(
-                {
-                    vol.Required(CONF_PASSWORD): str,
-                }
-            ),
-            description_placeholders={
-                "host": self._discovered_host or "",
-                "device_id": self._discovered_device_id or "",
-            },
-            errors=errors,
-        )
-
-    async def async_step_user(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle the initial step."""
-        errors: dict[str, str] = {}
-
-        if user_input is not None:
-            try:
-                info = await validate_input(self.hass, user_input)
-            except CannotConnect:
-                errors["base"] = "cannot_connect"
-            except InvalidAuth:
-                errors["base"] = "invalid_auth"
-            except Exception:
-                _LOGGER.exception("Unexpected exception")
-                errors["base"] = "unknown"
-            else:
-                # Use device ID as unique ID to prevent duplicates
-                await self.async_set_unique_id(info.device_id)
-                self._abort_if_unique_id_configured()
-                return self.async_create_entry(title=info.title, data=user_input)
-
-        return self.async_show_form(
-            step_id="user", data_schema=STEP_USER_DATA_SCHEMA, errors=errors
-        )
-
-
-class CannotConnect(HomeAssistantError):
-    """Error to indicate we cannot connect."""
-
-
-class InvalidAuth(HomeAssistantError):
-    """Error to indicate there is invalid auth."""
--- a/homeassistant/components/airobot/const.py
+++ b/homeassistant/components/airobot/const.py
@@ -1,5 +0,0 @@
-"""Constants for the Airobot integration."""
-
-from typing import Final
-
-DOMAIN: Final = "airobot"
--- a/homeassistant/components/airobot/coordinator.py
+++ b/homeassistant/components/airobot/coordinator.py
@@ -1,59 +0,0 @@
-"""Coordinator for the Airobot integration."""
-
-from __future__ import annotations
-
-from datetime import timedelta
-import logging
-
-from pyairobotrest import AirobotClient
-from pyairobotrest.exceptions import AirobotAuthError, AirobotConnectionError
-
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
-from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
-
-from .const import DOMAIN
-from .models import AirobotData
-
-_LOGGER = logging.getLogger(__name__)
-
-# Update interval - thermostat measures air every 30 seconds
-UPDATE_INTERVAL = timedelta(seconds=30)
-
-type AirobotConfigEntry = ConfigEntry[AirobotDataUpdateCoordinator]
-
-
-class AirobotDataUpdateCoordinator(DataUpdateCoordinator[AirobotData]):
-    """Class to manage fetching Airobot data."""
-
-    config_entry: AirobotConfigEntry
-
-    def __init__(self, hass: HomeAssistant, entry: AirobotConfigEntry) -> None:
-        """Initialize the coordinator."""
-        super().__init__(
-            hass,
-            _LOGGER,
-            name=DOMAIN,
-            update_interval=UPDATE_INTERVAL,
-            config_entry=entry,
-        )
-        session = async_get_clientsession(hass)
-
-        self.client = AirobotClient(
-            host=entry.data[CONF_HOST],
-            username=entry.data[CONF_USERNAME],
-            password=entry.data[CONF_PASSWORD],
-            session=session,
-        )
-
-    async def _async_update_data(self) -> AirobotData:
-        """Fetch data from API endpoint."""
-        try:
-            status = await self.client.get_statuses()
-            settings = await self.client.get_settings()
-        except (AirobotAuthError, AirobotConnectionError) as err:
-            raise UpdateFailed(f"Failed to communicate with device: {err}") from err
-
-        return AirobotData(status=status, settings=settings)
--- a/homeassistant/components/airobot/entity.py
+++ b/homeassistant/components/airobot/entity.py
@@ -1,42 +0,0 @@
-"""Base entity for Airobot integration."""
-
-from __future__ import annotations
-
-from homeassistant.const import CONF_MAC
-from homeassistant.helpers.device_registry import CONNECTION_NETWORK_MAC, DeviceInfo
-from homeassistant.helpers.update_coordinator import CoordinatorEntity
-
-from .const import DOMAIN
-from .coordinator import AirobotDataUpdateCoordinator
-
-
-class AirobotEntity(CoordinatorEntity[AirobotDataUpdateCoordinator]):
-    """Base class for Airobot entities."""
-
-    _attr_has_entity_name = True
-
-    def __init__(
-        self,
-        coordinator: AirobotDataUpdateCoordinator,
-    ) -> None:
-        """Initialize the entity."""
-        super().__init__(coordinator)
-        status = coordinator.data.status
-        settings = coordinator.data.settings
-
-        self._attr_unique_id = status.device_id
-
-        connections = set()
-        if (mac := coordinator.config_entry.data.get(CONF_MAC)) is not None:
-            connections.add((CONNECTION_NETWORK_MAC, mac))
-
-        self._attr_device_info = DeviceInfo(
-            identifiers={(DOMAIN, status.device_id)},
-            connections=connections,
-            name=settings.device_name or status.device_id,
-            manufacturer="Airobot",
-            model="Thermostat",
-            model_id="TE1",
-            sw_version=str(status.fw_version),
-            hw_version=str(status.hw_version),
-        )
--- a/homeassistant/components/airobot/manifest.json
+++ b/homeassistant/components/airobot/manifest.json
@@ -1,17 +0,0 @@
-{
-  "domain": "airobot",
-  "name": "Airobot",
-  "codeowners": ["@mettolen"],
-  "config_flow": true,
-  "dhcp": [
-    {
-      "hostname": "airobot-thermostat-*"
-    }
-  ],
-  "documentation": "https://www.home-assistant.io/integrations/airobot",
-  "integration_type": "device",
-  "iot_class": "local_polling",
-  "loggers": ["pyairobotrest"],
-  "quality_scale": "bronze",
-  "requirements": ["pyairobotrest==0.1.0"]
-}
--- a/homeassistant/components/airobot/models.py
+++ b/homeassistant/components/airobot/models.py
@@ -1,15 +0,0 @@
-"""Models for the Airobot integration."""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-
-from pyairobotrest.models import ThermostatSettings, ThermostatStatus
-
-
-@dataclass
-class AirobotData:
-    """Data from the Airobot coordinator."""
-
-    status: ThermostatStatus
-    settings: ThermostatSettings
--- a/homeassistant/components/airobot/quality_scale.yaml
+++ b/homeassistant/components/airobot/quality_scale.yaml
@@ -1,72 +0,0 @@
-rules:
-  # Bronze
-  action-setup:
-    status: exempt
-    comment: Integration does not register custom actions.
-  appropriate-polling: done
-  brands: done
-  common-modules: done
-  config-flow-test-coverage: done
-  config-flow: done
-  dependency-transparency: done
-  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 use event subscriptions.
-  entity-unique-id: done
-  has-entity-name: done
-  runtime-data: done
-  test-before-configure: done
-  test-before-setup: done
-  unique-config-entry: done
-
-  # Silver
-  action-exceptions: done
-  config-entry-unloading: done
-  docs-configuration-parameters: done
-  docs-installation-parameters: done
-  entity-unavailable: done
-  integration-owner: done
-  log-when-unavailable: done
-  parallel-updates: done
-  reauthentication-flow: todo
-  test-coverage: done
-
-  # Gold
-  devices: done
-  diagnostics: todo
-  discovery-update-info: done
-  discovery: done
-  docs-data-update: done
-  docs-examples: todo
-  docs-known-limitations: todo
-  docs-supported-devices: done
-  docs-supported-functions: done
-  docs-troubleshooting: done
-  docs-use-cases: todo
-  dynamic-devices:
-    status: exempt
-    comment: Single device integration, no dynamic device discovery needed.
-  entity-category: done
-  entity-device-class: done
-  entity-disabled-by-default: todo
-  entity-translations: todo
-  exception-translations: done
-  icon-translations: todo
-  reconfiguration-flow: todo
-  repair-issues:
-    status: exempt
-    comment: This integration doesn't have any cases where raising an issue is needed.
-  stale-devices:
-    status: exempt
-    comment: Single device integration, no stale device handling needed.
-
-  # Platinum
-  async-dependency: done
-  inject-websession: done
-  strict-typing: todo
--- a/homeassistant/components/airobot/strings.json
+++ b/homeassistant/components/airobot/strings.json
@@ -1,44 +0,0 @@
-{
-  "config": {
-    "abort": {
-      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]"
-    },
-    "error": {
-      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
-      "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
-      "unknown": "[%key:common::config_flow::error::unknown%]"
-    },
-    "step": {
-      "dhcp_confirm": {
-        "data": {
-          "password": "[%key:common::config_flow::data::password%]"
-        },
-        "data_description": {
-          "password": "The thermostat password."
-        },
-        "description": "Airobot thermostat {device_id} discovered at {host}. Enter the password to complete setup. Find the password in the thermostat settings menu under Connectivity → Mobile app."
-      },
-      "user": {
-        "data": {
-          "host": "[%key:common::config_flow::data::host%]",
-          "password": "[%key:common::config_flow::data::password%]",
-          "username": "[%key:common::config_flow::data::username%]"
-        },
-        "data_description": {
-          "host": "The hostname or IP address of your Airobot thermostat.",
-          "password": "The thermostat password.",
-          "username": "The thermostat Device ID (e.g., T01XXXXXX)."
-        },
-        "description": "Enter your Airobot thermostat connection details. Find the Device ID and password in the thermostat settings menu under Connectivity → Mobile app."
-      }
-    }
-  },
-  "exceptions": {
-    "set_preset_mode_failed": {
-      "message": "Failed to set preset mode to {preset_mode}."
-    },
-    "set_temperature_failed": {
-      "message": "Failed to set temperature to {temperature}."
-    }
-  }
-}
--- a/homeassistant/components/alarm_control_panel/icons.json
+++ b/homeassistant/components/alarm_control_panel/icons.json
@@ -36,28 +36,5 @@
    "alarm_trigger": {
      "service": "mdi:bell-ring"
    }
-  },
-  "triggers": {
-    "armed": {
-      "trigger": "mdi:shield"
-    },
-    "armed_away": {
-      "trigger": "mdi:shield-lock"
-    },
-    "armed_home": {
-      "trigger": "mdi:shield-home"
-    },
-    "armed_night": {
-      "trigger": "mdi:shield-moon"
-    },
-    "armed_vacation": {
-      "trigger": "mdi:shield-airplane"
-    },
-    "disarmed": {
-      "trigger": "mdi:shield-off"
-    },
-    "triggered": {
-      "trigger": "mdi:bell-ring"
-    }
  }
 }
--- a/homeassistant/components/alarm_control_panel/strings.json
+++ b/homeassistant/components/alarm_control_panel/strings.json
@@ -1,8 +1,4 @@
 {
-  "common": {
-    "trigger_behavior_description": "The behavior of the targeted alarms to trigger on.",
-    "trigger_behavior_name": "Behavior"
-  },
  "device_automation": {
    "action_type": {
      "arm_away": "Arm {entity_name} away",
@@ -75,15 +71,6 @@
      "message": "Arming requires a code but none was given for {entity_id}."
    }
  },
-  "selector": {
-    "trigger_behavior": {
-      "options": {
-        "any": "Any",
-        "first": "First",
-        "last": "Last"
-      }
-    }
-  },
  "services": {
    "alarm_arm_away": {
      "description": "Arms the alarm in the away mode.",
@@ -156,84 +143,5 @@
      "name": "Trigger"
    }
  },
-  "title": "Alarm control panel",
-  "triggers": {
-    "armed": {
-      "description": "Triggers when an alarm is armed.",
-      "description_configured": "[%key:component::alarm_control_panel::triggers::armed::description%]",
-      "fields": {
-        "behavior": {
-          "description": "[%key:component::alarm_control_panel::common::trigger_behavior_description%]",
-          "name": "[%key:component::alarm_control_panel::common::trigger_behavior_name%]"
-        }
-      },
-      "name": "When an alarm is armed"
-    },
-    "armed_away": {
-      "description": "Triggers when an alarm is armed away.",
-      "description_configured": "[%key:component::alarm_control_panel::triggers::armed_away::description%]",
-      "fields": {
-        "behavior": {
-          "description": "[%key:component::alarm_control_panel::common::trigger_behavior_description%]",
-          "name": "[%key:component::alarm_control_panel::common::trigger_behavior_name%]"
-        }
-      },
-      "name": "When an alarm is armed away"
-    },
-    "armed_home": {
-      "description": "Triggers when an alarm is armed home.",
-      "description_configured": "[%key:component::alarm_control_panel::triggers::armed_home::description%]",
-      "fields": {
-        "behavior": {
-          "description": "[%key:component::alarm_control_panel::common::trigger_behavior_description%]",
-          "name": "[%key:component::alarm_control_panel::common::trigger_behavior_name%]"
-        }
-      },
-      "name": "When an alarm is armed home"
-    },
-    "armed_night": {
-      "description": "Triggers when an alarm is armed night.",
-      "description_configured": "[%key:component::alarm_control_panel::triggers::armed_night::description%]",
-      "fields": {
-        "behavior": {
-          "description": "[%key:component::alarm_control_panel::common::trigger_behavior_description%]",
-          "name": "[%key:component::alarm_control_panel::common::trigger_behavior_name%]"
-        }
-      },
-      "name": "When an alarm is armed night"
-    },
-    "armed_vacation": {
-      "description": "Triggers when an alarm is armed vacation.",
-      "description_configured": "[%key:component::alarm_control_panel::triggers::armed_vacation::description%]",
-      "fields": {
-        "behavior": {
-          "description": "[%key:component::alarm_control_panel::common::trigger_behavior_description%]",
-          "name": "[%key:component::alarm_control_panel::common::trigger_behavior_name%]"
-        }
-      },
-      "name": "When an alarm is armed vacation"
-    },
-    "disarmed": {
-      "description": "Triggers when an alarm is disarmed.",
-      "description_configured": "[%key:component::alarm_control_panel::triggers::disarmed::description%]",
-      "fields": {
-        "behavior": {
-          "description": "[%key:component::alarm_control_panel::common::trigger_behavior_description%]",
-          "name": "[%key:component::alarm_control_panel::common::trigger_behavior_name%]"
-        }
-      },
-      "name": "When an alarm is disarmed"
-    },
-    "triggered": {
-      "description": "Triggers when an alarm is triggered.",
-      "description_configured": "[%key:component::alarm_control_panel::triggers::triggered::description%]",
-      "fields": {
-        "behavior": {
-          "description": "[%key:component::alarm_control_panel::common::trigger_behavior_description%]",
-          "name": "[%key:component::alarm_control_panel::common::trigger_behavior_name%]"
-        }
-      },
-      "name": "When an alarm is triggered"
-    }
-  }
+  "title": "Alarm control panel"
 }
--- a/homeassistant/components/alarm_control_panel/trigger.py
+++ b/homeassistant/components/alarm_control_panel/trigger.py
@@ -1,99 +0,0 @@
-"""Provides triggers for alarm control panels."""
-
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers.entity import get_supported_features
-from homeassistant.helpers.trigger import (
-    EntityStateTriggerBase,
-    Trigger,
-    make_conditional_entity_state_trigger,
-    make_entity_state_trigger,
-)
-
-from .const import DOMAIN, AlarmControlPanelEntityFeature, AlarmControlPanelState
-
-
-def supports_feature(hass: HomeAssistant, entity_id: str, features: int) -> bool:
-    """Get the device class of an entity or UNDEFINED if not found."""
-    try:
-        return bool(get_supported_features(hass, entity_id) & features)
-    except HomeAssistantError:
-        return False
-
-
-class EntityStateTriggerRequiredFeatures(EntityStateTriggerBase):
-    """Trigger for entity state changes."""
-
-    _required_features: int
-
-    def entity_filter(self, entities: set[str]) -> set[str]:
-        """Filter entities of this domain."""
-        entities = super().entity_filter(entities)
-        return {
-            entity_id
-            for entity_id in entities
-            if supports_feature(self._hass, entity_id, self._required_features)
-        }
-
-
-def make_entity_state_trigger_required_features(
-    domain: str, to_state: str, required_features: int
-) -> type[EntityStateTriggerBase]:
-    """Create an entity state trigger class."""
-
-    class CustomTrigger(EntityStateTriggerRequiredFeatures):
-        """Trigger for entity state changes."""
-
-        _domain = domain
-        _to_state = to_state
-        _required_features = required_features
-
-    return CustomTrigger
-
-
-TRIGGERS: dict[str, type[Trigger]] = {
-    "armed": make_conditional_entity_state_trigger(
-        DOMAIN,
-        from_states={
-            AlarmControlPanelState.ARMING,
-            AlarmControlPanelState.DISARMED,
-            AlarmControlPanelState.DISARMING,
-            AlarmControlPanelState.PENDING,
-            AlarmControlPanelState.TRIGGERED,
-        },
-        to_states={
-            AlarmControlPanelState.ARMED_AWAY,
-            AlarmControlPanelState.ARMED_CUSTOM_BYPASS,
-            AlarmControlPanelState.ARMED_HOME,
-            AlarmControlPanelState.ARMED_NIGHT,
-            AlarmControlPanelState.ARMED_VACATION,
-        },
-    ),
-    "armed_away": make_entity_state_trigger_required_features(
-        DOMAIN,
-        AlarmControlPanelState.ARMED_AWAY,
-        AlarmControlPanelEntityFeature.ARM_AWAY,
-    ),
-    "armed_home": make_entity_state_trigger_required_features(
-        DOMAIN,
-        AlarmControlPanelState.ARMED_HOME,
-        AlarmControlPanelEntityFeature.ARM_HOME,
-    ),
-    "armed_night": make_entity_state_trigger_required_features(
-        DOMAIN,
-        AlarmControlPanelState.ARMED_NIGHT,
-        AlarmControlPanelEntityFeature.ARM_NIGHT,
-    ),
-    "armed_vacation": make_entity_state_trigger_required_features(
-        DOMAIN,
-        AlarmControlPanelState.ARMED_VACATION,
-        AlarmControlPanelEntityFeature.ARM_VACATION,
-    ),
-    "disarmed": make_entity_state_trigger(DOMAIN, AlarmControlPanelState.DISARMED),
-    "triggered": make_entity_state_trigger(DOMAIN, AlarmControlPanelState.TRIGGERED),
-}
-
-
-async def async_get_triggers(hass: HomeAssistant) -> dict[str, type[Trigger]]:
-    """Return the triggers for alarm control panels."""
-    return TRIGGERS
--- a/homeassistant/components/alarm_control_panel/triggers.yaml
+++ b/homeassistant/components/alarm_control_panel/triggers.yaml
@@ -1,53 +0,0 @@
-.trigger_common: &trigger_common
-  target:
-    entity:
-      domain: alarm_control_panel
-  fields: &trigger_common_fields
-    behavior:
-      required: true
-      default: any
-      selector:
-        select:
-          options:
-            - first
-            - last
-            - any
-          translation_key: trigger_behavior
-
-armed: *trigger_common
-
-armed_away:
-  fields: *trigger_common_fields
-  target:
-    entity:
-      domain: alarm_control_panel
-      supported_features:
-        - alarm_control_panel.AlarmControlPanelEntityFeature.ARM_AWAY
-
-armed_home:
-  fields: *trigger_common_fields
-  target:
-    entity:
-      domain: alarm_control_panel
-      supported_features:
-        - alarm_control_panel.AlarmControlPanelEntityFeature.ARM_HOME
-
-armed_night:
-  fields: *trigger_common_fields
-  target:
-    entity:
-      domain: alarm_control_panel
-      supported_features:
-        - alarm_control_panel.AlarmControlPanelEntityFeature.ARM_NIGHT
-
-armed_vacation:
-  fields: *trigger_common_fields
-  target:
-    entity:
-      domain: alarm_control_panel
-      supported_features:
-        - alarm_control_panel.AlarmControlPanelEntityFeature.ARM_VACATION
-
-disarmed: *trigger_common
-
-triggered: *trigger_common
--- a/homeassistant/components/alexa_devices/config_flow.py
+++ b/homeassistant/components/alexa_devices/config_flow.py
@@ -45,7 +45,7 @@ async def validate_input(hass: HomeAssistant, data: dict[str, Any]) -> dict[str,
        data[CONF_PASSWORD],
    )

-    return await api.login.login_mode_interactive(data[CONF_CODE])
+    return await api.login_mode_interactive(data[CONF_CODE])


 class AmazonDevicesConfigFlow(ConfigFlow, domain=DOMAIN):
--- a/homeassistant/components/alexa_devices/coordinator.py
+++ b/homeassistant/components/alexa_devices/coordinator.py
@@ -59,7 +59,7 @@ class AmazonDevicesCoordinator(DataUpdateCoordinator[dict[str, AmazonDevice]]):
    async def _async_update_data(self) -> dict[str, AmazonDevice]:
        """Update device data."""
        try:
-            await self.api.login.login_mode_stored_data()
+            await self.api.login_mode_stored_data()
            data = await self.api.get_devices_data()
        except CannotConnect as err:
            raise UpdateFailed(
--- a/homeassistant/components/alexa_devices/manifest.json
+++ b/homeassistant/components/alexa_devices/manifest.json
@@ -8,5 +8,5 @@
  "iot_class": "cloud_polling",
  "loggers": ["aioamazondevices"],
  "quality_scale": "platinum",
-  "requirements": ["aioamazondevices==9.0.3"]
+  "requirements": ["aioamazondevices==8.0.1"]
 }
--- a/homeassistant/components/analytics/init.py
+++ b/homeassistant/components/analytics/init.py
@@ -7,6 +7,7 @@ import voluptuous as vol
 from homeassistant.components import websocket_api
 from homeassistant.const import EVENT_HOMEASSISTANT_STARTED
 from homeassistant.core import Event, HomeAssistant, callback
+from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.typing import ConfigType
 from homeassistant.util.hass_dict import HassKey

@@ -29,36 +30,14 @@ __all__ = [
    "async_devices_payload",
 ]

-CONF_SNAPSHOTS_URL = "snapshots_url"
-
-CONFIG_SCHEMA = vol.Schema(
-    {
-        DOMAIN: vol.Schema(
-            {
-                vol.Optional(CONF_SNAPSHOTS_URL): vol.Any(str, None),
-            }
-        )
-    },
-    extra=vol.ALLOW_EXTRA,
-)
+CONFIG_SCHEMA = cv.empty_config_schema(DOMAIN)

 DATA_COMPONENT: HassKey[Analytics] = HassKey(DOMAIN)


-async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
+async def async_setup(hass: HomeAssistant, _: ConfigType) -> bool:
    """Set up the analytics integration."""
-    analytics_config = config.get(DOMAIN, {})
-
-    # For now we want to enable device analytics only if the url option
-    # is explicitly listed in YAML.
-    if CONF_SNAPSHOTS_URL in analytics_config:
-        disable_snapshots = False
-        snapshots_url = analytics_config[CONF_SNAPSHOTS_URL]
-    else:
-        disable_snapshots = True
-        snapshots_url = None
-
-    analytics = Analytics(hass, snapshots_url, disable_snapshots)
+    analytics = Analytics(hass)

    # Load stored data
    await analytics.load()
--- a/homeassistant/components/analytics/analytics.py
+++ b/homeassistant/components/analytics/analytics.py
@@ -59,6 +59,9 @@ from homeassistant.loader import (
 from homeassistant.setup import async_get_loaded_integrations

 from .const import (
+    ANALYTICS_ENDPOINT_URL,
+    ANALYTICS_ENDPOINT_URL_DEV,
+    ANALYTICS_SNAPSHOT_ENDPOINT_URL,
    ATTR_ADDON_COUNT,
    ATTR_ADDONS,
    ATTR_ARCH,
@@ -88,14 +91,10 @@ from .const import (
    ATTR_USER_COUNT,
    ATTR_UUID,
    ATTR_VERSION,
-    BASIC_ENDPOINT_URL,
-    BASIC_ENDPOINT_URL_DEV,
    DOMAIN,
    INTERVAL,
    LOGGER,
    PREFERENCE_SCHEMA,
-    SNAPSHOT_DEFAULT_URL,
-    SNAPSHOT_URL_PATH,
    SNAPSHOT_VERSION,
    STORAGE_KEY,
    STORAGE_VERSION,
@@ -237,18 +236,10 @@ class AnalyticsData:
 class Analytics:
    """Analytics helper class for the analytics integration."""

-    def __init__(
-        self,
-        hass: HomeAssistant,
-        snapshots_url: str | None = None,
-        disable_snapshots: bool = False,
-    ) -> None:
+    def __init__(self, hass: HomeAssistant) -> None:
        """Initialize the Analytics class."""
-        self._hass: HomeAssistant = hass
-        self._snapshots_url = snapshots_url
-        self._disable_snapshots = disable_snapshots
-
-        self._session = async_get_clientsession(hass)
+        self.hass: HomeAssistant = hass
+        self.session = async_get_clientsession(hass)
        self._data = AnalyticsData(False, {})
        self._store = Store[dict[str, Any]](hass, STORAGE_VERSION, STORAGE_KEY)
        self._basic_scheduled: CALLBACK_TYPE | None = None
@@ -258,15 +249,13 @@ class Analytics:
    def preferences(self) -> dict:
        """Return the current active preferences."""
        preferences = self._data.preferences
-        result = {
+        return {
            ATTR_BASE: preferences.get(ATTR_BASE, False),
+            ATTR_SNAPSHOTS: preferences.get(ATTR_SNAPSHOTS, False),
            ATTR_DIAGNOSTICS: preferences.get(ATTR_DIAGNOSTICS, False),
            ATTR_USAGE: preferences.get(ATTR_USAGE, False),
            ATTR_STATISTICS: preferences.get(ATTR_STATISTICS, False),
        }
-        if not self._disable_snapshots:
-            result[ATTR_SNAPSHOTS] = preferences.get(ATTR_SNAPSHOTS, False)
-        return result

    @property
    def onboarded(self) -> bool:
@@ -283,13 +272,13 @@ class Analytics:
        """Return the endpoint that will receive the payload."""
        if RELEASE_CHANNEL is ReleaseChannel.DEV:
            # dev installations will contact the dev analytics environment
-            return BASIC_ENDPOINT_URL_DEV
-        return BASIC_ENDPOINT_URL
+            return ANALYTICS_ENDPOINT_URL_DEV
+        return ANALYTICS_ENDPOINT_URL

    @property
    def supervisor(self) -> bool:
        """Return bool if a supervisor is present."""
-        return is_hassio(self._hass)
+        return is_hassio(self.hass)

    async def load(self) -> None:
        """Load preferences."""
@@ -299,7 +288,7 @@ class Analytics:

        if (
            self.supervisor
-            and (supervisor_info := hassio.get_supervisor_info(self._hass)) is not None
+            and (supervisor_info := hassio.get_supervisor_info(self.hass)) is not None
        ):
            if not self.onboarded:
                # User have not configured analytics, get this setting from the supervisor
@@ -326,7 +315,7 @@ class Analytics:

        if self.supervisor:
            await hassio.async_update_diagnostics(
-                self._hass, self.preferences.get(ATTR_DIAGNOSTICS, False)
+                self.hass, self.preferences.get(ATTR_DIAGNOSTICS, False)
            )

    async def send_analytics(self, _: datetime | None = None) -> None:
@@ -334,7 +323,7 @@ class Analytics:
        if not self.onboarded or not self.preferences.get(ATTR_BASE, False):
            return

-        hass = self._hass
+        hass = self.hass
        supervisor_info = None
        operating_system_info: dict[str, Any] = {}

@@ -474,7 +463,7 @@ class Analytics:

        try:
            async with timeout(30):
-                response = await self._session.post(self.endpoint_basic, json=payload)
+                response = await self.session.post(self.endpoint_basic, json=payload)
                if response.status == 200:
                    LOGGER.info(
                        (
@@ -490,9 +479,11 @@ class Analytics:
                        self.endpoint_basic,
                    )
        except TimeoutError:
-            LOGGER.error("Timeout sending analytics to %s", BASIC_ENDPOINT_URL)
+            LOGGER.error("Timeout sending analytics to %s", ANALYTICS_ENDPOINT_URL)
        except aiohttp.ClientError as err:
-            LOGGER.error("Error sending analytics to %s: %r", BASIC_ENDPOINT_URL, err)
+            LOGGER.error(
+                "Error sending analytics to %s: %r", ANALYTICS_ENDPOINT_URL, err
+            )

    @callback
    def _async_should_report_integration(
@@ -516,7 +507,7 @@ class Analytics:
        if not integration.config_flow:
            return False

-        entries = self._hass.config_entries.async_entries(integration.domain)
+        entries = self.hass.config_entries.async_entries(integration.domain)

        # Filter out ignored and disabled entries
        return any(
@@ -530,7 +521,7 @@ class Analytics:
        if not self.onboarded or not self.preferences.get(ATTR_SNAPSHOTS, False):
            return

-        payload = await _async_snapshot_payload(self._hass)
+        payload = await _async_snapshot_payload(self.hass)

        headers = {
            "Content-Type": "application/json",
@@ -541,16 +532,11 @@ class Analytics:
                self._data.submission_identifier
            )

-        url = (
-            self._snapshots_url
-            if self._snapshots_url is not None
-            else SNAPSHOT_DEFAULT_URL
-        )
-        url += SNAPSHOT_URL_PATH
-
        try:
            async with timeout(30):
-                response = await self._session.post(url, json=payload, headers=headers)
+                response = await self.session.post(
+                    ANALYTICS_SNAPSHOT_ENDPOINT_URL, json=payload, headers=headers
+                )

                if response.status == 200:  # OK
                    response_data = await response.json()
@@ -576,7 +562,7 @@ class Analytics:
                        # Clear the invalid identifier and retry on next cycle
                        LOGGER.warning(
                            "Invalid submission identifier to %s, clearing: %s",
-                            url,
+                            ANALYTICS_SNAPSHOT_ENDPOINT_URL,
                            error_message,
                        )
                        self._data.submission_identifier = None
@@ -585,7 +571,7 @@ class Analytics:
                        LOGGER.warning(
                            "Malformed snapshot analytics submission (%s) to %s: %s",
                            error_kind,
-                            url,
+                            ANALYTICS_SNAPSHOT_ENDPOINT_URL,
                            error_message,
                        )

@@ -593,7 +579,7 @@ class Analytics:
                    response_text = await response.text()
                    LOGGER.warning(
                        "Snapshot analytics service %s unavailable: %s",
-                        url,
+                        ANALYTICS_SNAPSHOT_ENDPOINT_URL,
                        response_text,
                    )

@@ -601,18 +587,18 @@ class Analytics:
                    LOGGER.warning(
                        "Unexpected status code %s when submitting snapshot analytics to %s",
                        response.status,
-                        url,
+                        ANALYTICS_SNAPSHOT_ENDPOINT_URL,
                    )

        except TimeoutError:
            LOGGER.error(
                "Timeout sending snapshot analytics to %s",
-                url,
+                ANALYTICS_SNAPSHOT_ENDPOINT_URL,
            )
        except aiohttp.ClientError as err:
            LOGGER.error(
                "Error sending snapshot analytics to %s: %r",
-                url,
+                ANALYTICS_SNAPSHOT_ENDPOINT_URL,
                err,
            )

@@ -636,7 +622,7 @@ class Analytics:
        elif self._basic_scheduled is None:
            # Wait 15 min after started for basic analytics
            self._basic_scheduled = async_call_later(
-                self._hass,
+                self.hass,
                900,
                HassJob(
                    self._async_schedule_basic,
@@ -645,7 +631,10 @@ class Analytics:
                ),
            )

-        if not self.preferences.get(ATTR_SNAPSHOTS, False) or self._disable_snapshots:
+        if not self.preferences.get(ATTR_SNAPSHOTS, False) or RELEASE_CHANNEL not in (
+            ReleaseChannel.DEV,
+            ReleaseChannel.NIGHTLY,
+        ):
            LOGGER.debug("Snapshot analytics not scheduled")
            if self._snapshot_scheduled:
                self._snapshot_scheduled()
@@ -653,11 +642,9 @@ class Analytics:
        elif self._snapshot_scheduled is None:
            snapshot_submission_time = self._data.snapshot_submission_time

-            interval_seconds = INTERVAL.total_seconds()
-
            if snapshot_submission_time is None:
                # Randomize the submission time within the 24 hours
-                snapshot_submission_time = random.uniform(0, interval_seconds)
+                snapshot_submission_time = random.uniform(0, 86400)
                self._data.snapshot_submission_time = snapshot_submission_time
                await self._save()
                LOGGER.debug(
@@ -667,10 +654,10 @@ class Analytics:

            # Calculate delay until next submission
            current_time = time.time()
-            delay = (snapshot_submission_time - current_time) % interval_seconds
+            delay = (snapshot_submission_time - current_time) % 86400

            self._snapshot_scheduled = async_call_later(
-                self._hass,
+                self.hass,
                delay,
                HassJob(
                    self._async_schedule_snapshots,
@@ -685,7 +672,7 @@ class Analytics:

        # Send basic analytics every day
        self._basic_scheduled = async_track_time_interval(
-            self._hass,
+            self.hass,
            self.send_analytics,
            INTERVAL,
            name="basic analytics daily",
@@ -698,7 +685,7 @@ class Analytics:

        # Send snapshot analytics every day
        self._snapshot_scheduled = async_track_time_interval(
-            self._hass,
+            self.hass,
            self.send_snapshot,
            INTERVAL,
            name="snapshot analytics daily",
--- a/homeassistant/components/analytics/const.py
+++ b/homeassistant/components/analytics/const.py
@@ -5,17 +5,15 @@ import logging

 import voluptuous as vol

+ANALYTICS_ENDPOINT_URL = "https://analytics-api.home-assistant.io/v1"
+ANALYTICS_ENDPOINT_URL_DEV = "https://analytics-api-dev.home-assistant.io/v1"
+SNAPSHOT_VERSION = "1"
+ANALYTICS_SNAPSHOT_ENDPOINT_URL = f"https://device-database.eco-dev-aws.openhomefoundation.com/api/v1/snapshot/{SNAPSHOT_VERSION}"
 DOMAIN = "analytics"
 INTERVAL = timedelta(days=1)
 STORAGE_KEY = "core.analytics"
 STORAGE_VERSION = 1

-BASIC_ENDPOINT_URL = "https://analytics-api.home-assistant.io/v1"
-BASIC_ENDPOINT_URL_DEV = "https://analytics-api-dev.home-assistant.io/v1"
-
-SNAPSHOT_VERSION = 1
-SNAPSHOT_DEFAULT_URL = "https://device-database.eco-dev-aws.openhomefoundation.com"
-SNAPSHOT_URL_PATH = f"/api/v1/snapshot/{SNAPSHOT_VERSION}"

 LOGGER: logging.Logger = logging.getLogger(__package__)

--- a/homeassistant/components/anglian_water/init.py
+++ b/homeassistant/components/anglian_water/init.py
@@ -1,70 +0,0 @@
-"""The Anglian Water integration."""
-
-from __future__ import annotations
-
-from pyanglianwater import AnglianWater
-from pyanglianwater.auth import MSOB2CAuth
-from pyanglianwater.exceptions import (
-    ExpiredAccessTokenError,
-    SelfAssertedError,
-    SmartMeterUnavailableError,
-)
-
-from homeassistant.const import (
-    CONF_ACCESS_TOKEN,
-    CONF_PASSWORD,
-    CONF_USERNAME,
-    Platform,
-)
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryError
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
-
-from .const import CONF_ACCOUNT_NUMBER, DOMAIN
-from .coordinator import AnglianWaterConfigEntry, AnglianWaterUpdateCoordinator
-
-_PLATFORMS: list[Platform] = [Platform.SENSOR]
-
-
-async def async_setup_entry(
-    hass: HomeAssistant, entry: AnglianWaterConfigEntry
-) -> bool:
-    """Set up Anglian Water from a config entry."""
-    auth = MSOB2CAuth(
-        username=entry.data[CONF_USERNAME],
-        password=entry.data[CONF_PASSWORD],
-        session=async_get_clientsession(hass),
-        refresh_token=entry.data[CONF_ACCESS_TOKEN],
-        account_number=entry.data[CONF_ACCOUNT_NUMBER],
-    )
-    try:
-        await auth.send_refresh_request()
-    except (ExpiredAccessTokenError, SelfAssertedError) as err:
-        raise ConfigEntryAuthFailed from err
-
-    _aw = AnglianWater(authenticator=auth)
-
-    try:
-        await _aw.validate_smart_meter()
-    except SmartMeterUnavailableError as err:
-        raise ConfigEntryError(
-            translation_domain=DOMAIN, translation_key="smart_meter_unavailable"
-        ) from err
-
-    hass.config_entries.async_update_entry(
-        entry, data={**entry.data, CONF_ACCESS_TOKEN: auth.refresh_token}
-    )
-    entry.runtime_data = coordinator = AnglianWaterUpdateCoordinator(
-        hass=hass, api=_aw, config_entry=entry
-    )
-
-    await coordinator.async_config_entry_first_refresh()
-    await hass.config_entries.async_forward_entry_setups(entry, _PLATFORMS)
-    return True
-
-
-async def async_unload_entry(
-    hass: HomeAssistant, entry: AnglianWaterConfigEntry
-) -> bool:
-    """Unload a config entry."""
-    return await hass.config_entries.async_unload_platforms(entry, _PLATFORMS)
--- a/homeassistant/components/anglian_water/config_flow.py
+++ b/homeassistant/components/anglian_water/config_flow.py
@@ -1,103 +0,0 @@
-"""Config flow for the Anglian Water integration."""
-
-from __future__ import annotations
-
-import logging
-from typing import Any
-
-from aiohttp import CookieJar
-from pyanglianwater import AnglianWater
-from pyanglianwater.auth import BaseAuth, MSOB2CAuth
-from pyanglianwater.exceptions import (
-    InvalidAccountIdError,
-    SelfAssertedError,
-    SmartMeterUnavailableError,
-)
-import voluptuous as vol
-
-from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
-from homeassistant.const import CONF_ACCESS_TOKEN, CONF_PASSWORD, CONF_USERNAME
-from homeassistant.helpers import selector
-from homeassistant.helpers.aiohttp_client import async_create_clientsession
-
-from .const import CONF_ACCOUNT_NUMBER, DOMAIN
-
-_LOGGER = logging.getLogger(__name__)
-
-STEP_USER_DATA_SCHEMA = vol.Schema(
-    {
-        vol.Required(CONF_USERNAME): selector.TextSelector(),
-        vol.Required(CONF_PASSWORD): selector.TextSelector(
-            selector.TextSelectorConfig(type=selector.TextSelectorType.PASSWORD)
-        ),
-    }
-)
-
-
-async def validate_credentials(auth: MSOB2CAuth) -> str | MSOB2CAuth:
-    """Validate the provided credentials."""
-    try:
-        await auth.send_login_request()
-    except SelfAssertedError:
-        return "invalid_auth"
-    except Exception:
-        _LOGGER.exception("Unexpected exception")
-        return "unknown"
-    _aw = AnglianWater(authenticator=auth)
-    try:
-        await _aw.validate_smart_meter()
-    except (InvalidAccountIdError, SmartMeterUnavailableError):
-        return "smart_meter_unavailable"
-    return auth
-
-
-class AnglianWaterConfigFlow(ConfigFlow, domain=DOMAIN):
-    """Handle a config flow for Anglian Water."""
-
-    async def async_step_user(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle the initial step."""
-        errors: dict[str, str] = {}
-        if user_input is not None:
-            validation_response = await validate_credentials(
-                MSOB2CAuth(
-                    username=user_input[CONF_USERNAME],
-                    password=user_input[CONF_PASSWORD],
-                    session=async_create_clientsession(
-                        self.hass,
-                        cookie_jar=CookieJar(quote_cookie=False),
-                    ),
-                    account_number=user_input.get(CONF_ACCOUNT_NUMBER),
-                )
-            )
-            if isinstance(validation_response, BaseAuth):
-                account_number = (
-                    user_input.get(CONF_ACCOUNT_NUMBER)
-                    or validation_response.account_number
-                )
-                await self.async_set_unique_id(account_number)
-                self._abort_if_unique_id_configured()
-                return self.async_create_entry(
-                    title=account_number,
-                    data={
-                        **user_input,
-                        CONF_ACCESS_TOKEN: validation_response.refresh_token,
-                        CONF_ACCOUNT_NUMBER: account_number,
-                    },
-                )
-            if validation_response == "smart_meter_unavailable":
-                return self.async_show_form(
-                    step_id="user",
-                    data_schema=STEP_USER_DATA_SCHEMA.extend(
-                        {
-                            vol.Required(CONF_ACCOUNT_NUMBER): selector.TextSelector(),
-                        }
-                    ),
-                    errors={"base": validation_response},
-                )
-            errors["base"] = validation_response
-
-        return self.async_show_form(
-            step_id="user", data_schema=STEP_USER_DATA_SCHEMA, errors=errors
-        )
--- a/homeassistant/components/anglian_water/const.py
+++ b/homeassistant/components/anglian_water/const.py
@@ -1,4 +0,0 @@
-"""Constants for the Anglian Water integration."""
-
-DOMAIN = "anglian_water"
-CONF_ACCOUNT_NUMBER = "account_number"
--- a/homeassistant/components/anglian_water/coordinator.py
+++ b/homeassistant/components/anglian_water/coordinator.py
@@ -1,49 +0,0 @@
-"""Anglian Water data coordinator."""
-
-from __future__ import annotations
-
-from datetime import timedelta
-import logging
-
-from pyanglianwater import AnglianWater
-from pyanglianwater.exceptions import ExpiredAccessTokenError, UnknownEndpointError
-
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
-
-from .const import DOMAIN
-
-type AnglianWaterConfigEntry = ConfigEntry[AnglianWaterUpdateCoordinator]
-
-_LOGGER = logging.getLogger(__name__)
-UPDATE_INTERVAL = timedelta(minutes=60)
-
-
-class AnglianWaterUpdateCoordinator(DataUpdateCoordinator[None]):
-    """Anglian Water data update coordinator."""
-
-    config_entry: AnglianWaterConfigEntry
-
-    def __init__(
-        self,
-        hass: HomeAssistant,
-        api: AnglianWater,
-        config_entry: AnglianWaterConfigEntry,
-    ) -> None:
-        """Initialize update coordinator."""
-        super().__init__(
-            hass=hass,
-            logger=_LOGGER,
-            name=DOMAIN,
-            update_interval=UPDATE_INTERVAL,
-            config_entry=config_entry,
-        )
-        self.api = api
-
-    async def _async_update_data(self) -> None:
-        """Update data from Anglian Water's API."""
-        try:
-            return await self.api.update()
-        except (ExpiredAccessTokenError, UnknownEndpointError) as err:
-            raise UpdateFailed from err
--- a/homeassistant/components/anglian_water/entity.py
+++ b/homeassistant/components/anglian_water/entity.py
@@ -1,44 +0,0 @@
-"""Anglian Water entity."""
-
-from __future__ import annotations
-
-import logging
-
-from pyanglianwater.meter import SmartMeter
-
-from homeassistant.helpers.device_registry import DeviceInfo
-from homeassistant.helpers.update_coordinator import CoordinatorEntity
-
-from .const import DOMAIN
-from .coordinator import AnglianWaterUpdateCoordinator
-
-_LOGGER = logging.getLogger(__name__)
-
-
-class AnglianWaterEntity(CoordinatorEntity[AnglianWaterUpdateCoordinator]):
-    """Defines a Anglian Water entity."""
-
-    def __init__(
-        self,
-        coordinator: AnglianWaterUpdateCoordinator,
-        smart_meter: SmartMeter,
-    ) -> None:
-        """Initialize Anglian Water entity."""
-        super().__init__(coordinator)
-        self.smart_meter = smart_meter
-        self._attr_device_info = DeviceInfo(
-            identifiers={(DOMAIN, smart_meter.serial_number)},
-            name="Smart Water Meter",
-            manufacturer="Anglian Water",
-            serial_number=smart_meter.serial_number,
-        )
-
-    async def async_added_to_hass(self) -> None:
-        """When entity is loaded."""
-        self.coordinator.api.updated_data_callbacks.append(self.async_write_ha_state)
-        await super().async_added_to_hass()
-
-    async def async_will_remove_from_hass(self) -> None:
-        """When will be removed from HASS."""
-        self.coordinator.api.updated_data_callbacks.remove(self.async_write_ha_state)
-        await super().async_will_remove_from_hass()
--- a/homeassistant/components/anglian_water/manifest.json
+++ b/homeassistant/components/anglian_water/manifest.json
@@ -1,10 +0,0 @@
-{
-  "domain": "anglian_water",
-  "name": "Anglian Water",
-  "codeowners": ["@pantherale0"],
-  "config_flow": true,
-  "documentation": "https://www.home-assistant.io/integrations/anglian_water",
-  "iot_class": "cloud_polling",
-  "quality_scale": "bronze",
-  "requirements": ["pyanglianwater==2.1.0"]
-}
--- a/homeassistant/components/anglian_water/quality_scale.yaml
+++ b/homeassistant/components/anglian_water/quality_scale.yaml
@@ -1,83 +0,0 @@
-rules:
-  # Bronze
-  action-setup:
-    status: exempt
-    comment: |
-      No custom actions are defined.
-  appropriate-polling: done
-  brands: done
-  common-modules: done
-  config-flow-test-coverage: done
-  config-flow: done
-  dependency-transparency: done
-  docs-actions:
-    status: exempt
-    comment: |
-      No custom actions are defined.
-  docs-high-level-description: done
-  docs-installation-instructions: done
-  docs-removal-instructions: done
-  entity-event-setup: done
-  entity-unique-id: done
-  has-entity-name: done
-  runtime-data: done
-  test-before-configure: done
-  test-before-setup: done
-  unique-config-entry: done
-
-  # Silver
-  action-exceptions:
-    status: exempt
-    comment: |
-      No custom actions are defined.
-  config-entry-unloading: done
-  docs-configuration-parameters: done
-  docs-installation-parameters: done
-  entity-unavailable: done
-  integration-owner: done
-  log-when-unavailable: done
-  parallel-updates: done
-  reauthentication-flow: todo
-  test-coverage: todo
-
-  # Gold
-  devices: done
-  diagnostics: todo
-  discovery-update-info:
-    status: exempt
-    comment: |
-      Unable to discover meters.
-  discovery:
-    status: exempt
-    comment: |
-      Unable to discover meters.
-  docs-data-update: done
-  docs-examples: todo
-  docs-known-limitations: done
-  docs-supported-devices: done
-  docs-supported-functions: done
-  docs-troubleshooting: done
-  docs-use-cases: todo
-  dynamic-devices: todo
-  entity-category: done
-  entity-device-class: done
-  entity-disabled-by-default:
-    status: exempt
-    comment: |
-      No entities are disabled by default.
-  entity-translations: done
-  exception-translations: done
-  icon-translations:
-    status: exempt
-    comment: |
-      Entities do not require different icons.
-  reconfiguration-flow: todo
-  repair-issues:
-    status: exempt
-    comment: |
-      Read-only integration and no repairs are possible.
-  stale-devices: todo
-  # Platinum
-  async-dependency: done
-  inject-websession: done
-  strict-typing: todo
--- a/homeassistant/components/anglian_water/sensor.py
+++ b/homeassistant/components/anglian_water/sensor.py
@@ -1,118 +0,0 @@
-"""Anglian Water sensor platform."""
-
-from __future__ import annotations
-
-from collections.abc import Callable
-from dataclasses import dataclass
-from enum import StrEnum
-
-from pyanglianwater.meter import SmartMeter
-
-from homeassistant.components.sensor import (
-    EntityCategory,
-    SensorDeviceClass,
-    SensorEntity,
-    SensorEntityDescription,
-    SensorStateClass,
-)
-from homeassistant.const import UnitOfVolume
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-
-from .coordinator import AnglianWaterConfigEntry, AnglianWaterUpdateCoordinator
-from .entity import AnglianWaterEntity
-
-PARALLEL_UPDATES = 0
-
-
-class AnglianWaterSensor(StrEnum):
-    """Store keys for Anglian Water sensors."""
-
-    YESTERDAY_CONSUMPTION = "yesterday_consumption"
-    YESTERDAY_WATER_COST = "yesterday_water_cost"
-    YESTERDAY_SEWERAGE_COST = "yesterday_sewerage_cost"
-    LATEST_READING = "latest_reading"
-
-
-@dataclass(frozen=True, kw_only=True)
-class AnglianWaterSensorEntityDescription(SensorEntityDescription):
-    """Describes AnglianWater sensor entity."""
-
-    value_fn: Callable[[SmartMeter], float]
-
-
-ENTITY_DESCRIPTIONS: tuple[AnglianWaterSensorEntityDescription, ...] = (
-    AnglianWaterSensorEntityDescription(
-        key=AnglianWaterSensor.YESTERDAY_CONSUMPTION,
-        native_unit_of_measurement=UnitOfVolume.LITERS,
-        device_class=SensorDeviceClass.WATER,
-        value_fn=lambda entity: entity.get_yesterday_consumption,
-        state_class=SensorStateClass.TOTAL,
-        translation_key=AnglianWaterSensor.YESTERDAY_CONSUMPTION,
-        entity_category=EntityCategory.DIAGNOSTIC,
-    ),
-    AnglianWaterSensorEntityDescription(
-        key=AnglianWaterSensor.LATEST_READING,
-        native_unit_of_measurement=UnitOfVolume.CUBIC_METERS,
-        device_class=SensorDeviceClass.WATER,
-        value_fn=lambda entity: entity.latest_read,
-        state_class=SensorStateClass.TOTAL_INCREASING,
-        translation_key=AnglianWaterSensor.LATEST_READING,
-        entity_category=EntityCategory.DIAGNOSTIC,
-    ),
-    AnglianWaterSensorEntityDescription(
-        key=AnglianWaterSensor.YESTERDAY_WATER_COST,
-        native_unit_of_measurement="GBP",
-        device_class=SensorDeviceClass.MONETARY,
-        value_fn=lambda entity: entity.yesterday_water_cost,
-        translation_key=AnglianWaterSensor.YESTERDAY_WATER_COST,
-        entity_category=EntityCategory.DIAGNOSTIC,
-    ),
-    AnglianWaterSensorEntityDescription(
-        key=AnglianWaterSensor.YESTERDAY_SEWERAGE_COST,
-        native_unit_of_measurement="GBP",
-        device_class=SensorDeviceClass.MONETARY,
-        value_fn=lambda entity: entity.yesterday_sewerage_cost,
-        translation_key=AnglianWaterSensor.YESTERDAY_SEWERAGE_COST,
-        entity_category=EntityCategory.DIAGNOSTIC,
-    ),
-)
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: AnglianWaterConfigEntry,
-    async_add_devices: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up the sensor platform."""
-    async_add_devices(
-        AnglianWaterSensorEntity(
-            coordinator=entry.runtime_data,
-            description=entity_description,
-            smart_meter=smart_meter,
-        )
-        for entity_description in ENTITY_DESCRIPTIONS
-        for smart_meter in entry.runtime_data.api.meters.values()
-    )
-
-
-class AnglianWaterSensorEntity(AnglianWaterEntity, SensorEntity):
-    """Defines a Anglian Water sensor."""
-
-    entity_description: AnglianWaterSensorEntityDescription
-
-    def __init__(
-        self,
-        coordinator: AnglianWaterUpdateCoordinator,
-        smart_meter: SmartMeter,
-        description: AnglianWaterSensorEntityDescription,
-    ) -> None:
-        """Initialize Anglian Water sensor."""
-        super().__init__(coordinator, smart_meter)
-        self.entity_description = description
-        self._attr_unique_id = f"{smart_meter.serial_number}_{description.key}"
-
-    @property
-    def native_value(self) -> float | None:
-        """Return the state of the sensor."""
-        return self.entity_description.value_fn(self.smart_meter)
--- a/homeassistant/components/anglian_water/strings.json
+++ b/homeassistant/components/anglian_water/strings.json
@@ -1,55 +0,0 @@
-{
-  "config": {
-    "abort": {
-      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]"
-    },
-    "error": {
-      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
-      "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
-      "smart_meter_unavailable": "This account does not have any smart meters associated with it. If this is unexpected, enter your Billing Account Number found at the top of your latest bill.",
-      "unknown": "[%key:common::config_flow::error::unknown%]"
-    },
-    "step": {
-      "user": {
-        "data": {
-          "account_number": "Billing Account Number",
-          "password": "[%key:common::config_flow::data::password%]",
-          "username": "[%key:common::config_flow::data::username%]"
-        },
-        "data_description": {
-          "account_number": "Your account number found on your latest bill.",
-          "password": "Your password",
-          "username": "Username or email used to login to the Anglian Water website."
-        },
-        "description": "Enter your Anglian Water account credentials to connect to Home Assistant."
-      }
-    }
-  },
-  "entity": {
-    "sensor": {
-      "latest_reading": {
-        "name": "Latest reading"
-      },
-      "yesterday_consumption": {
-        "name": "Yesterday's usage"
-      },
-      "yesterday_sewerage_cost": {
-        "name": "Yesterday's sewerage cost"
-      },
-      "yesterday_water_cost": {
-        "name": "Yesterday's water cost"
-      }
-    }
-  },
-  "exceptions": {
-    "auth_expired": {
-      "message": "Authentication token expired"
-    },
-    "service_unavailable": {
-      "message": "Anglian Water services are currently unavailable for maintenance."
-    },
-    "smart_meter_unavailable": {
-      "message": "This account no longer has a smart meter associated with it."
-    }
-  }
-}
--- a/homeassistant/components/anthropic/init.py
+++ b/homeassistant/components/anthropic/init.py
@@ -17,7 +17,13 @@ from homeassistant.helpers import (
 )
 from homeassistant.helpers.typing import ConfigType

-from .const import CONF_CHAT_MODEL, DEFAULT, DEFAULT_CONVERSATION_NAME, DOMAIN, LOGGER
+from .const import (
+    CONF_CHAT_MODEL,
+    DEFAULT_CONVERSATION_NAME,
+    DOMAIN,
+    LOGGER,
+    RECOMMENDED_CHAT_MODEL,
+)

 PLATFORMS = (Platform.AI_TASK, Platform.CONVERSATION)
 CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
@@ -40,9 +46,9 @@ async def async_setup_entry(hass: HomeAssistant, entry: AnthropicConfigEntry) ->
        # Use model from first conversation subentry for validation
        subentries = list(entry.subentries.values())
        if subentries:
-            model_id = subentries[0].data.get(CONF_CHAT_MODEL, DEFAULT[CONF_CHAT_MODEL])
+            model_id = subentries[0].data.get(CONF_CHAT_MODEL, RECOMMENDED_CHAT_MODEL)
        else:
-            model_id = DEFAULT[CONF_CHAT_MODEL]
+            model_id = RECOMMENDED_CHAT_MODEL
        model = await client.models.retrieve(model_id=model_id, timeout=10.0)
        LOGGER.debug("Anthropic model: %s", model.display_name)
    except anthropic.AuthenticationError as err:
--- a/homeassistant/components/anthropic/config_flow.py
+++ b/homeassistant/components/anthropic/config_flow.py
@@ -6,7 +6,7 @@ from functools import partial
 import json
 import logging
 import re
-from typing import Any, cast
+from typing import Any

 import anthropic
 import voluptuous as vol
@@ -54,11 +54,17 @@ from .const import (
    CONF_WEB_SEARCH_REGION,
    CONF_WEB_SEARCH_TIMEZONE,
    CONF_WEB_SEARCH_USER_LOCATION,
-    DEFAULT,
    DEFAULT_AI_TASK_NAME,
    DEFAULT_CONVERSATION_NAME,
    DOMAIN,
    NON_THINKING_MODELS,
+    RECOMMENDED_CHAT_MODEL,
+    RECOMMENDED_MAX_TOKENS,
+    RECOMMENDED_TEMPERATURE,
+    RECOMMENDED_THINKING_BUDGET,
+    RECOMMENDED_WEB_SEARCH,
+    RECOMMENDED_WEB_SEARCH_MAX_USES,
+    RECOMMENDED_WEB_SEARCH_USER_LOCATION,
    WEB_SEARCH_UNSUPPORTED_MODELS,
 )

@@ -70,13 +76,13 @@ STEP_USER_DATA_SCHEMA = vol.Schema(
    }
 )

-DEFAULT_CONVERSATION_OPTIONS = {
+RECOMMENDED_CONVERSATION_OPTIONS = {
    CONF_RECOMMENDED: True,
    CONF_LLM_HASS_API: [llm.LLM_API_ASSIST],
    CONF_PROMPT: llm.DEFAULT_INSTRUCTIONS_PROMPT,
 }

-DEFAULT_AI_TASK_OPTIONS = {
+RECOMMENDED_AI_TASK_OPTIONS = {
    CONF_RECOMMENDED: True,
 }

@@ -130,13 +136,13 @@ class AnthropicConfigFlow(ConfigFlow, domain=DOMAIN):
                    subentries=[
                        {
                            "subentry_type": "conversation",
-                            "data": DEFAULT_CONVERSATION_OPTIONS,
+                            "data": RECOMMENDED_CONVERSATION_OPTIONS,
                            "title": DEFAULT_CONVERSATION_NAME,
                            "unique_id": None,
                        },
                        {
                            "subentry_type": "ai_task_data",
-                            "data": DEFAULT_AI_TASK_OPTIONS,
+                            "data": RECOMMENDED_AI_TASK_OPTIONS,
                            "title": DEFAULT_AI_TASK_NAME,
                            "unique_id": None,
                        },
@@ -174,9 +180,9 @@ class ConversationSubentryFlowHandler(ConfigSubentryFlow):
    ) -> SubentryFlowResult:
        """Add a subentry."""
        if self._subentry_type == "ai_task_data":
-            self.options = DEFAULT_AI_TASK_OPTIONS.copy()
+            self.options = RECOMMENDED_AI_TASK_OPTIONS.copy()
        else:
-            self.options = DEFAULT_CONVERSATION_OPTIONS.copy()
+            self.options = RECOMMENDED_CONVERSATION_OPTIONS.copy()
        return await self.async_step_init()

    async def async_step_reconfigure(
@@ -277,7 +283,7 @@ class ConversationSubentryFlowHandler(ConfigSubentryFlow):
        step_schema: VolDictType = {
            vol.Optional(
                CONF_CHAT_MODEL,
-                default=DEFAULT[CONF_CHAT_MODEL],
+                default=RECOMMENDED_CHAT_MODEL,
            ): SelectSelector(
                SelectSelectorConfig(
                    options=await self._get_model_list(), custom_value=True
@@ -285,11 +291,11 @@ class ConversationSubentryFlowHandler(ConfigSubentryFlow):
            ),
            vol.Optional(
                CONF_MAX_TOKENS,
-                default=DEFAULT[CONF_MAX_TOKENS],
+                default=RECOMMENDED_MAX_TOKENS,
            ): int,
            vol.Optional(
                CONF_TEMPERATURE,
-                default=DEFAULT[CONF_TEMPERATURE],
+                default=RECOMMENDED_TEMPERATURE,
            ): NumberSelector(NumberSelectorConfig(min=0, max=1, step=0.05)),
        }

@@ -319,14 +325,12 @@ class ConversationSubentryFlowHandler(ConfigSubentryFlow):

        if not model.startswith(tuple(NON_THINKING_MODELS)):
            step_schema[
-                vol.Optional(
-                    CONF_THINKING_BUDGET, default=DEFAULT[CONF_THINKING_BUDGET]
-                )
+                vol.Optional(CONF_THINKING_BUDGET, default=RECOMMENDED_THINKING_BUDGET)
            ] = vol.All(
                NumberSelector(
                    NumberSelectorConfig(
                        min=0,
-                        max=self.options.get(CONF_MAX_TOKENS, DEFAULT[CONF_MAX_TOKENS]),
+                        max=self.options.get(CONF_MAX_TOKENS, RECOMMENDED_MAX_TOKENS),
                    )
                ),
                vol.Coerce(int),
@@ -339,15 +343,15 @@ class ConversationSubentryFlowHandler(ConfigSubentryFlow):
                {
                    vol.Optional(
                        CONF_WEB_SEARCH,
-                        default=DEFAULT[CONF_WEB_SEARCH],
+                        default=RECOMMENDED_WEB_SEARCH,
                    ): bool,
                    vol.Optional(
                        CONF_WEB_SEARCH_MAX_USES,
-                        default=DEFAULT[CONF_WEB_SEARCH_MAX_USES],
+                        default=RECOMMENDED_WEB_SEARCH_MAX_USES,
                    ): int,
                    vol.Optional(
                        CONF_WEB_SEARCH_USER_LOCATION,
-                        default=DEFAULT[CONF_WEB_SEARCH_USER_LOCATION],
+                        default=RECOMMENDED_WEB_SEARCH_USER_LOCATION,
                    ): bool,
                }
            )
@@ -365,10 +369,9 @@ class ConversationSubentryFlowHandler(ConfigSubentryFlow):
            user_input = {}

        if user_input is not None:
-            if user_input.get(CONF_WEB_SEARCH, DEFAULT[CONF_WEB_SEARCH]) and not errors:
+            if user_input.get(CONF_WEB_SEARCH, RECOMMENDED_WEB_SEARCH) and not errors:
                if user_input.get(
-                    CONF_WEB_SEARCH_USER_LOCATION,
-                    DEFAULT[CONF_WEB_SEARCH_USER_LOCATION],
+                    CONF_WEB_SEARCH_USER_LOCATION, RECOMMENDED_WEB_SEARCH_USER_LOCATION
                ):
                    user_input.update(await self._get_location_data())

@@ -453,7 +456,7 @@ class ConversationSubentryFlowHandler(ConfigSubentryFlow):
                }
            )
            response = await client.messages.create(
-                model=cast(str, DEFAULT[CONF_CHAT_MODEL]),
+                model=RECOMMENDED_CHAT_MODEL,
                messages=[
                    {
                        "role": "user",
@@ -468,7 +471,7 @@ class ConversationSubentryFlowHandler(ConfigSubentryFlow):
                        "content": "{",  # hints the model to skip any preamble
                    },
                ],
-                max_tokens=cast(int, DEFAULT[CONF_MAX_TOKENS]),
+                max_tokens=RECOMMENDED_MAX_TOKENS,
            )
            _LOGGER.debug("Model response: %s", response.content)
            location_data = location_schema(
--- a/homeassistant/components/anthropic/const.py
+++ b/homeassistant/components/anthropic/const.py
@@ -11,29 +11,25 @@ DEFAULT_AI_TASK_NAME = "Claude AI Task"
 CONF_RECOMMENDED = "recommended"
 CONF_PROMPT = "prompt"
 CONF_CHAT_MODEL = "chat_model"
+RECOMMENDED_CHAT_MODEL = "claude-3-5-haiku-latest"
 CONF_MAX_TOKENS = "max_tokens"
+RECOMMENDED_MAX_TOKENS = 3000
 CONF_TEMPERATURE = "temperature"
+RECOMMENDED_TEMPERATURE = 1.0
 CONF_THINKING_BUDGET = "thinking_budget"
+RECOMMENDED_THINKING_BUDGET = 0
+MIN_THINKING_BUDGET = 1024
 CONF_WEB_SEARCH = "web_search"
+RECOMMENDED_WEB_SEARCH = False
 CONF_WEB_SEARCH_USER_LOCATION = "user_location"
+RECOMMENDED_WEB_SEARCH_USER_LOCATION = False
 CONF_WEB_SEARCH_MAX_USES = "web_search_max_uses"
+RECOMMENDED_WEB_SEARCH_MAX_USES = 5
 CONF_WEB_SEARCH_CITY = "city"
 CONF_WEB_SEARCH_REGION = "region"
 CONF_WEB_SEARCH_COUNTRY = "country"
 CONF_WEB_SEARCH_TIMEZONE = "timezone"

-DEFAULT = {
-    CONF_CHAT_MODEL: "claude-3-5-haiku-latest",
-    CONF_MAX_TOKENS: 3000,
-    CONF_TEMPERATURE: 1.0,
-    CONF_THINKING_BUDGET: 0,
-    CONF_WEB_SEARCH: False,
-    CONF_WEB_SEARCH_USER_LOCATION: False,
-    CONF_WEB_SEARCH_MAX_USES: 5,
-}
-
-MIN_THINKING_BUDGET = 1024
-
 NON_THINKING_MODELS = [
    "claude-3-5",  # Both sonnet and haiku
    "claude-3-opus",
--- a/homeassistant/components/anthropic/entity.py
+++ b/homeassistant/components/anthropic/entity.py
@@ -84,11 +84,14 @@ from .const import (
    CONF_WEB_SEARCH_REGION,
    CONF_WEB_SEARCH_TIMEZONE,
    CONF_WEB_SEARCH_USER_LOCATION,
-    DEFAULT,
    DOMAIN,
    LOGGER,
    MIN_THINKING_BUDGET,
    NON_THINKING_MODELS,
+    RECOMMENDED_CHAT_MODEL,
+    RECOMMENDED_MAX_TOKENS,
+    RECOMMENDED_TEMPERATURE,
+    RECOMMENDED_THINKING_BUDGET,
 )

 # Max number of back and forth with the LLM to generate a response
@@ -601,19 +604,17 @@ class AnthropicBaseLLMEntity(Entity):
            raise TypeError("First message must be a system message")
        messages = _convert_content(chat_log.content[1:])

-        model = options.get(CONF_CHAT_MODEL, DEFAULT[CONF_CHAT_MODEL])
+        model = options.get(CONF_CHAT_MODEL, RECOMMENDED_CHAT_MODEL)

        model_args = MessageCreateParamsStreaming(
            model=model,
            messages=messages,
-            max_tokens=options.get(CONF_MAX_TOKENS, DEFAULT[CONF_MAX_TOKENS]),
+            max_tokens=options.get(CONF_MAX_TOKENS, RECOMMENDED_MAX_TOKENS),
            system=system.content,
            stream=True,
        )

-        thinking_budget = options.get(
-            CONF_THINKING_BUDGET, DEFAULT[CONF_THINKING_BUDGET]
-        )
+        thinking_budget = options.get(CONF_THINKING_BUDGET, RECOMMENDED_THINKING_BUDGET)
        if (
            not model.startswith(tuple(NON_THINKING_MODELS))
            and thinking_budget >= MIN_THINKING_BUDGET
@@ -624,7 +625,7 @@ class AnthropicBaseLLMEntity(Entity):
        else:
            model_args["thinking"] = ThinkingConfigDisabledParam(type="disabled")
            model_args["temperature"] = options.get(
-                CONF_TEMPERATURE, DEFAULT[CONF_TEMPERATURE]
+                CONF_TEMPERATURE, RECOMMENDED_TEMPERATURE
            )

        tools: list[ToolUnionParam] = []
--- a/homeassistant/components/assist_satellite/icons.json
+++ b/homeassistant/components/assist_satellite/icons.json
@@ -14,19 +14,5 @@
    "start_conversation": {
      "service": "mdi:forum"
    }
-  },
-  "triggers": {
-    "idle": {
-      "trigger": "mdi:chat-sleep"
-    },
-    "listening": {
-      "trigger": "mdi:chat-question"
-    },
-    "processing": {
-      "trigger": "mdi:chat-processing"
-    },
-    "responding": {
-      "trigger": "mdi:chat-alert"
-    }
  }
 }
--- a/homeassistant/components/assist_satellite/strings.json
+++ b/homeassistant/components/assist_satellite/strings.json
@@ -1,8 +1,4 @@
 {
-  "common": {
-    "trigger_behavior_description": "The behavior of the targeted Assist satellites to trigger on.",
-    "trigger_behavior_name": "Behavior"
-  },
  "entity_component": {
    "_": {
      "name": "Assist satellite",
@@ -20,13 +16,6 @@
        "id": "Answer ID",
        "sentences": "Sentences"
      }
-    },
-    "trigger_behavior": {
-      "options": {
-        "any": "Any",
-        "first": "First",
-        "last": "Last"
-      }
    }
  },
  "services": {
@@ -109,51 +98,5 @@
      "name": "Start conversation"
    }
  },
-  "title": "Assist satellite",
-  "triggers": {
-    "idle": {
-      "description": "Triggers when an Assist satellite becomes idle.",
-      "description_configured": "[%key:component::assist_satellite::triggers::idle::description%]",
-      "fields": {
-        "behavior": {
-          "description": "[%key:component::assist_satellite::common::trigger_behavior_description%]",
-          "name": "[%key:component::assist_satellite::common::trigger_behavior_name%]"
-        }
-      },
-      "name": "When an Assist satellite becomes idle"
-    },
-    "listening": {
-      "description": "Triggers when an Assist satellite starts listening.",
-      "description_configured": "[%key:component::assist_satellite::triggers::listening::description%]",
-      "fields": {
-        "behavior": {
-          "description": "[%key:component::assist_satellite::common::trigger_behavior_description%]",
-          "name": "[%key:component::assist_satellite::common::trigger_behavior_name%]"
-        }
-      },
-      "name": "When an Assist satellite starts listening"
-    },
-    "processing": {
-      "description": "Triggers when an Assist satellite is processing.",
-      "description_configured": "[%key:component::assist_satellite::triggers::processing::description%]",
-      "fields": {
-        "behavior": {
-          "description": "[%key:component::assist_satellite::common::trigger_behavior_description%]",
-          "name": "[%key:component::assist_satellite::common::trigger_behavior_name%]"
-        }
-      },
-      "name": "When an Assist satellite is processing"
-    },
-    "responding": {
-      "description": "Triggers when an Assist satellite is responding.",
-      "description_configured": "[%key:component::assist_satellite::triggers::responding::description%]",
-      "fields": {
-        "behavior": {
-          "description": "[%key:component::assist_satellite::common::trigger_behavior_description%]",
-          "name": "[%key:component::assist_satellite::common::trigger_behavior_name%]"
-        }
-      },
-      "name": "When an Assist satellite is responding"
-    }
-  }
+  "title": "Assist satellite"
 }
--- a/homeassistant/components/assist_satellite/trigger.py
+++ b/homeassistant/components/assist_satellite/trigger.py
@@ -1,19 +0,0 @@
-"""Provides triggers for assist satellites."""
-
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.trigger import Trigger, make_entity_state_trigger
-
-from .const import DOMAIN
-from .entity import AssistSatelliteState
-
-TRIGGERS: dict[str, type[Trigger]] = {
-    "idle": make_entity_state_trigger(DOMAIN, AssistSatelliteState.IDLE),
-    "listening": make_entity_state_trigger(DOMAIN, AssistSatelliteState.LISTENING),
-    "processing": make_entity_state_trigger(DOMAIN, AssistSatelliteState.PROCESSING),
-    "responding": make_entity_state_trigger(DOMAIN, AssistSatelliteState.RESPONDING),
-}
-
-
-async def async_get_triggers(hass: HomeAssistant) -> dict[str, type[Trigger]]:
-    """Return the triggers for assist satellites."""
-    return TRIGGERS
--- a/homeassistant/components/assist_satellite/triggers.yaml
+++ b/homeassistant/components/assist_satellite/triggers.yaml
@@ -1,20 +0,0 @@
-.trigger_common: &trigger_common
-  target:
-    entity:
-      domain: assist_satellite
-  fields:
-    behavior:
-      required: true
-      default: any
-      selector:
-        select:
-          options:
-            - first
-            - last
-            - any
-          translation_key: trigger_behavior
-
-idle: *trigger_common
-listening: *trigger_common
-processing: *trigger_common
-responding: *trigger_common
--- a/homeassistant/components/august/manifest.json
+++ b/homeassistant/components/august/manifest.json
@@ -29,5 +29,5 @@
  "documentation": "https://www.home-assistant.io/integrations/august",
  "iot_class": "cloud_push",
  "loggers": ["pubnub", "yalexs"],
-  "requirements": ["yalexs==9.2.0", "yalexs-ble==3.2.1"]
+  "requirements": ["yalexs==9.2.0", "yalexs-ble==3.1.2"]
 }
--- a/homeassistant/components/automation/manifest.json
+++ b/homeassistant/components/automation/manifest.json
@@ -6,10 +6,5 @@
  "dependencies": ["blueprint", "trace"],
  "documentation": "https://www.home-assistant.io/integrations/automation",
  "integration_type": "system",
-  "preview_features": {
-    "new_triggers_conditions": {
-      "report_issue_url": "https://github.com/home-assistant/core/issues/new?template=bug_report.yml&integration_link=https://www.home-assistant.io/integrations/automation&integration_name=Automation"
-    }
-  },
  "quality_scale": "internal"
 }
--- a/homeassistant/components/automation/strings.json
+++ b/homeassistant/components/automation/strings.json
@@ -67,14 +67,6 @@
      "title": "[%key:component::automation::common::validation_failed_title%]"
    }
  },
-  "preview_features": {
-    "new_triggers_conditions": {
-      "description": "Enables new intuitive triggers and conditions that are more user-friendly than technical state-based options.\n\nThese new automation features support targets across your entire home, letting you trigger automations for any entity, device, area, floor, or label (for example, when any light in your living room turned on). Integrations can now also provide their own intuitive triggers and conditions, just like actions.\n\nThis preview also includes a new tree view to help you navigate your home when adding triggers, conditions, and actions.",
-      "disable_confirmation": "Disabling this preview will cause automations and scripts that use the new intuitive triggers and conditions to fail.\n\nBefore disabling, ensure that your automations or scripts do not rely on this feature.",
-      "enable_confirmation": "This feature is still in development and may change. These new intuitive triggers and conditions are being refined based on user feedback and are not yet complete.\n\nBy enabling this preview, you'll have early access to these new capabilities, but be aware that they may be modified or updated in future releases.",
-      "name": "Intuitive triggers and conditions"
-    }
-  },
  "services": {
    "reload": {
      "description": "Reloads the automation configuration.",
--- a/homeassistant/components/awair/manifest.json
+++ b/homeassistant/components/awair/manifest.json
@@ -1,12 +1,12 @@
 {
  "domain": "awair",
  "name": "Awair",
-  "codeowners": ["@ahayworth", "@ricohageman"],
+  "codeowners": ["@ahayworth", "@danielsjf"],
  "config_flow": true,
  "documentation": "https://www.home-assistant.io/integrations/awair",
  "iot_class": "local_polling",
  "loggers": ["python_awair"],
-  "requirements": ["python-awair==0.2.5"],
+  "requirements": ["python-awair==0.2.4"],
  "zeroconf": [
    {
      "name": "awair*",
--- a/homeassistant/components/awair/quality_scale.yaml
+++ b/homeassistant/components/awair/quality_scale.yaml
@@ -1,98 +0,0 @@
-rules:
-  # Bronze
-  action-setup:
-    status: exempt
-    comment: No actions defined
-  appropriate-polling:
-    status: done
-    comment: |
-      We fetch both user and devices, could probably slow one down
-  brands: done
-  common-modules: done
-  config-flow:
-    status: todo
-    comment: |
-      data_description fields are missing
-      Should not abort in cloud step when anything else than invalid access token
-      Find out why access token is optional
-      Discovered devices step is redundant
-  config-flow-test-coverage:
-    status: todo
-    comment: |
-      Move happy flow to the top and merge with `test_show_form`
-      Reuse `result`
-      Cloud tests should initialize with data directly
-      Tests should finish in CREATE_ENTRY
-  dependency-transparency:
-    status: todo
-    comment: |
-      Dependency is not built in the CI
-  docs-actions: todo
-  docs-high-level-description: done
-  docs-installation-instructions: done
-  docs-removal-instructions: done
-  entity-event-setup:
-    status: exempt
-    comment: No explicit event subscription
-  entity-unique-id: done
-  has-entity-name: done
-  runtime-data: done
-  test-before-configure: done
-  test-before-setup: done
-  unique-config-entry: done
-
-  # Silver
-  action-exceptions:
-    status: exempt
-    comment: No actions defined
-  config-entry-unloading: done
-  docs-configuration-parameters: todo
-  docs-installation-parameters: todo
-  entity-unavailable: todo
-  integration-owner: done
-  log-when-unavailable: done
-  parallel-updates: todo
-  reauthentication-flow: done
-  test-coverage:
-    status: todo
-    comment: |
-      Patch objects where we use them
-      Use test helpers to load JSON
-      typo `no_devicess_fixture`
-      Make common config entries for cloud and local
-      Test setup of the integration
-
-  # Gold
-  devices:
-    status: done
-    comment: |
-      Can move to shorthand attribute
-      Can remove typecast
-  diagnostics: todo
-  discovery: done
-  discovery-update-info: done
-  docs-data-update: done
-  docs-examples: todo
-  docs-known-limitations: todo
-  docs-supported-devices: todo
-  docs-supported-functions: todo
-  docs-troubleshooting: todo
-  docs-use-cases: todo
-  dynamic-devices: todo
-  entity-category: todo
-  entity-device-class:
-    status: done
-    comment: |
-      Can remove rounding
-  entity-disabled-by-default: done
-  entity-translations: done
-  exception-translations: todo
-  icon-translations: done
-  reconfiguration-flow: todo
-  repair-issues: todo
-  stale-devices: todo
-
-  # Platinum
-  async-dependency: todo
-  inject-websession: done
-  strict-typing: todo
--- a/homeassistant/components/bang_olufsen/config_flow.py
+++ b/homeassistant/components/bang_olufsen/config_flow.py
@@ -21,10 +21,10 @@ from .const import (
    ATTR_ITEM_NUMBER,
    ATTR_SERIAL_NUMBER,
    ATTR_TYPE_NUMBER,
+    COMPATIBLE_MODELS,
    CONF_SERIAL_NUMBER,
    DEFAULT_MODEL,
    DOMAIN,
-    SELECTABLE_MODELS,
 )
 from .util import get_serial_number_from_jid

@@ -70,7 +70,7 @@ class BangOlufsenConfigFlowHandler(ConfigFlow, domain=DOMAIN):
            {
                vol.Required(CONF_HOST): str,
                vol.Required(CONF_MODEL, default=DEFAULT_MODEL): SelectSelector(
-                    SelectSelectorConfig(options=SELECTABLE_MODELS)
+                    SelectSelectorConfig(options=COMPATIBLE_MODELS)
                ),
            }
        )
--- a/homeassistant/components/bang_olufsen/const.py
+++ b/homeassistant/components/bang_olufsen/const.py
@@ -62,7 +62,6 @@ class BangOlufsenMediaType(StrEnum):
 class BangOlufsenModel(StrEnum):
    """Enum for compatible model names."""

-    # Mozart devices
    BEOCONNECT_CORE = "Beoconnect Core"
    BEOLAB_8 = "BeoLab 8"
    BEOLAB_28 = "BeoLab 28"
@@ -72,26 +71,7 @@ class BangOlufsenModel(StrEnum):
    BEOSOUND_BALANCE = "Beosound Balance"
    BEOSOUND_EMERGE = "Beosound Emerge"
    BEOSOUND_LEVEL = "Beosound Level"
-    BEOSOUND_PREMIERE = "Beosound Premiere"
    BEOSOUND_THEATRE = "Beosound Theatre"
-    # Remote devices
-    BEOREMOTE_ONE = "Beoremote One"
-
-
-# Physical "buttons" on devices
-class BangOlufsenButtons(StrEnum):
-    """Enum for device buttons."""
-
-    BLUETOOTH = "Bluetooth"
-    MICROPHONE = "Microphone"
-    NEXT = "Next"
-    PLAY_PAUSE = "PlayPause"
-    PRESET_1 = "Preset1"
-    PRESET_2 = "Preset2"
-    PRESET_3 = "Preset3"
-    PRESET_4 = "Preset4"
-    PREVIOUS = "Previous"
-    VOLUME = "Volume"


 # Dispatcher events
@@ -99,7 +79,6 @@ class WebsocketNotification(StrEnum):
    """Enum for WebSocket notification types."""

    ACTIVE_LISTENING_MODE = "active_listening_mode"
-    BEO_REMOTE_BUTTON = "beo_remote_button"
    BUTTON = "button"
    PLAYBACK_ERROR = "playback_error"
    PLAYBACK_METADATA = "playback_metadata"
@@ -117,7 +96,6 @@ class WebsocketNotification(StrEnum):
    BEOLINK_AVAILABLE_LISTENERS = "beolinkAvailableListeners"
    CONFIGURATION = "configuration"
    NOTIFICATION = "notification"
-    REMOTE_CONTROL_DEVICES = "remoteControlDevices"
    REMOTE_MENU_CHANGED = "remoteMenuChanged"

    ALL = "all"
@@ -133,11 +111,7 @@ CONF_SERIAL_NUMBER: Final = "serial_number"
 CONF_BEOLINK_JID: Final = "jid"

 # Models to choose from in manual configuration.
-SELECTABLE_MODELS: list[str] = [
-    model.value for model in BangOlufsenModel if model != BangOlufsenModel.BEOREMOTE_ONE
-]
-
-MANUFACTURER: Final[str] = "Bang & Olufsen"
+COMPATIBLE_MODELS: list[str] = [x.value for x in BangOlufsenModel]

 # Attribute names for zeroconf discovery.
 ATTR_TYPE_NUMBER: Final[str] = "tn"
@@ -230,16 +204,29 @@ FALLBACK_SOURCES: Final[SourceArray] = SourceArray(
        ),
    ]
 )
+# Map for storing compatibility of devices.
+
+MODEL_SUPPORT_DEVICE_BUTTONS: Final[str] = "device_buttons"
+
+MODEL_SUPPORT_MAP = {
+    MODEL_SUPPORT_DEVICE_BUTTONS: (
+        BangOlufsenModel.BEOLAB_8,
+        BangOlufsenModel.BEOLAB_28,
+        BangOlufsenModel.BEOSOUND_2,
+        BangOlufsenModel.BEOSOUND_A5,
+        BangOlufsenModel.BEOSOUND_A9,
+        BangOlufsenModel.BEOSOUND_BALANCE,
+        BangOlufsenModel.BEOSOUND_EMERGE,
+        BangOlufsenModel.BEOSOUND_LEVEL,
+        BangOlufsenModel.BEOSOUND_THEATRE,
+    )
+}

 # Device events
 BANG_OLUFSEN_WEBSOCKET_EVENT: Final[str] = f"{DOMAIN}_websocket_event"

 # Dict used to translate native Bang & Olufsen event names to string.json compatible ones
 EVENT_TRANSLATION_MAP: dict[str, str] = {
-    # Beoremote One
-    "KeyPress": "key_press",
-    "KeyRelease": "key_release",
-    # Physical "buttons"
    "shortPress (Release)": "short_press_release",
    "longPress (Timeout)": "long_press_timeout",
    "longPress (Release)": "long_press_release",
@@ -249,7 +236,18 @@ EVENT_TRANSLATION_MAP: dict[str, str] = {

 CONNECTION_STATUS: Final[str] = "CONNECTION_STATUS"

-DEVICE_BUTTONS: Final[list[str]] = [x.value for x in BangOlufsenButtons]
+DEVICE_BUTTONS: Final[list[str]] = [
+    "Bluetooth",
+    "Microphone",
+    "Next",
+    "PlayPause",
+    "Preset1",
+    "Preset2",
+    "Preset3",
+    "Preset4",
+    "Previous",
+    "Volume",
+]


 DEVICE_BUTTON_EVENTS: Final[list[str]] = [
@@ -260,70 +258,6 @@ DEVICE_BUTTON_EVENTS: Final[list[str]] = [
    "very_long_press_release",
 ]

-BEO_REMOTE_SUBMENU_CONTROL: Final[str] = "Control"
-BEO_REMOTE_SUBMENU_LIGHT: Final[str] = "Light"
-
-# Common for both submenus
-BEO_REMOTE_KEYS: Final[tuple[str, ...]] = (
-    "Blue",
-    "Digit0",
-    "Digit1",
-    "Digit2",
-    "Digit3",
-    "Digit4",
-    "Digit5",
-    "Digit6",
-    "Digit7",
-    "Digit8",
-    "Digit9",
-    "Down",
-    "Green",
-    "Left",
-    "Play",
-    "Red",
-    "Rewind",
-    "Right",
-    "Select",
-    "Stop",
-    "Up",
-    "Wind",
-    "Yellow",
-    "Func1",
-    "Func2",
-    "Func3",
-    "Func4",
-    "Func5",
-    "Func6",
-    "Func7",
-    "Func8",
-    "Func9",
-    "Func10",
-    "Func11",
-    "Func12",
-    "Func13",
-    "Func14",
-    "Func15",
-    "Func16",
-    "Func17",
-)
-
-# "keys" that are unique to the Control submenu
-BEO_REMOTE_CONTROL_KEYS: Final[tuple[str, ...]] = (
-    "Func18",
-    "Func19",
-    "Func20",
-    "Func21",
-    "Func22",
-    "Func23",
-    "Func24",
-    "Func25",
-    "Func26",
-    "Func27",
-)
-
-BEO_REMOTE_KEY_EVENTS: Final[list[str]] = ["key_press", "key_release"]
-
-
 # Beolink Converter NL/ML sources need to be transformed to upper case
 BEOLINK_JOIN_SOURCES_TO_UPPER = (
    "aux_a",
--- a/homeassistant/components/bang_olufsen/diagnostics.py
+++ b/homeassistant/components/bang_olufsen/diagnostics.py
@@ -6,13 +6,11 @@ from typing import TYPE_CHECKING, Any

 from homeassistant.components.event import DOMAIN as EVENT_DOMAIN
 from homeassistant.components.media_player import DOMAIN as MEDIA_PLAYER_DOMAIN
-from homeassistant.const import CONF_MODEL
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import entity_registry as er

 from . import BangOlufsenConfigEntry
-from .const import DOMAIN
-from .util import get_device_buttons
+from .const import DEVICE_BUTTONS, DOMAIN


 async def async_get_config_entry_diagnostics(
@@ -42,7 +40,7 @@ async def async_get_config_entry_diagnostics(
            data["media_player"] = state_dict

    # Add button Event entity states (if enabled)
-    for device_button in get_device_buttons(config_entry.data[CONF_MODEL]):
+    for device_button in DEVICE_BUTTONS:
        if entity_id := entity_registry.async_get_entity_id(
            EVENT_DOMAIN, DOMAIN, f"{config_entry.unique_id}_{device_button}"
        ):
--- a/homeassistant/components/bang_olufsen/event.py
+++ b/homeassistant/components/bang_olufsen/event.py
@@ -2,34 +2,22 @@

 from __future__ import annotations

-from typing import TYPE_CHECKING
-
-from mozart_api.models import PairedRemote
-
 from homeassistant.components.event import EventDeviceClass, EventEntity
 from homeassistant.const import CONF_MODEL
 from homeassistant.core import HomeAssistant, callback
-from homeassistant.helpers import device_registry as dr
-from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback

 from . import BangOlufsenConfigEntry
 from .const import (
-    BEO_REMOTE_CONTROL_KEYS,
-    BEO_REMOTE_KEY_EVENTS,
-    BEO_REMOTE_KEYS,
-    BEO_REMOTE_SUBMENU_CONTROL,
-    BEO_REMOTE_SUBMENU_LIGHT,
    CONNECTION_STATUS,
    DEVICE_BUTTON_EVENTS,
-    DOMAIN,
-    MANUFACTURER,
-    BangOlufsenModel,
+    DEVICE_BUTTONS,
+    MODEL_SUPPORT_DEVICE_BUTTONS,
+    MODEL_SUPPORT_MAP,
    WebsocketNotification,
 )
 from .entity import BangOlufsenEntity
-from .util import get_device_buttons, get_remotes

 PARALLEL_UPDATES = 0

@@ -39,87 +27,25 @@ async def async_setup_entry(
    config_entry: BangOlufsenConfigEntry,
    async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
-    """Set up Event entities from config entry."""
-    entities: list[BangOlufsenEvent] = []
+    """Set up Sensor entities from config entry."""

-    async_add_entities(
-        BangOlufsenButtonEvent(config_entry, button_type)
-        for button_type in get_device_buttons(config_entry.data[CONF_MODEL])
-    )
-
-    # Check for connected Beoremote One
-    remotes = await get_remotes(config_entry.runtime_data.client)
-
-    for remote in remotes:
-        # Add Light keys
-        entities.extend(
-            [
-                BangOlufsenRemoteKeyEvent(
-                    config_entry,
-                    remote,
-                    f"{BEO_REMOTE_SUBMENU_LIGHT}/{key_type}",
-                )
-                for key_type in BEO_REMOTE_KEYS
-            ]
+    if config_entry.data[CONF_MODEL] in MODEL_SUPPORT_MAP[MODEL_SUPPORT_DEVICE_BUTTONS]:
+        async_add_entities(
+            BangOlufsenButtonEvent(config_entry, button_type)
+            for button_type in DEVICE_BUTTONS
        )

-        # Add Control keys
-        entities.extend(
-            [
-                BangOlufsenRemoteKeyEvent(
-                    config_entry,
-                    remote,
-                    f"{BEO_REMOTE_SUBMENU_CONTROL}/{key_type}",
-                )
-                for key_type in (*BEO_REMOTE_KEYS, *BEO_REMOTE_CONTROL_KEYS)
-            ]
-        )

-    # If the remote is no longer available, then delete the device.
-    # The remote may appear as being available to the device after it has been unpaired on the remote
-    # As it has to be removed from the device on the app.
-
-    device_registry = dr.async_get(hass)
-    devices = device_registry.devices.get_devices_for_config_entry_id(
-        config_entry.entry_id
-    )
-    for device in devices:
-        if (
-            device.model == BangOlufsenModel.BEOREMOTE_ONE
-            and device.serial_number not in {remote.serial_number for remote in remotes}
-        ):
-            device_registry.async_update_device(
-                device.id, remove_config_entry_id=config_entry.entry_id
-            )
-
-    async_add_entities(new_entities=entities)
-
-
-class BangOlufsenEvent(BangOlufsenEntity, EventEntity):
-    """Base Event class."""
+class BangOlufsenButtonEvent(BangOlufsenEntity, EventEntity):
+    """Event class for Button events."""

    _attr_device_class = EventDeviceClass.BUTTON
    _attr_entity_registry_enabled_default = False
-
-    def __init__(self, config_entry: BangOlufsenConfigEntry) -> None:
-        """Initialize Event."""
-        super().__init__(config_entry, config_entry.runtime_data.client)
-
-    @callback
-    def _async_handle_event(self, event: str) -> None:
-        """Handle event."""
-        self._trigger_event(event)
-        self.async_write_ha_state()
-
-
-class BangOlufsenButtonEvent(BangOlufsenEvent):
-    """Event class for Button events."""
-
    _attr_event_types = DEVICE_BUTTON_EVENTS

    def __init__(self, config_entry: BangOlufsenConfigEntry, button_type: str) -> None:
        """Initialize Button."""
-        super().__init__(config_entry)
+        super().__init__(config_entry, config_entry.runtime_data.client)

        self._attr_unique_id = f"{self._unique_id}_{button_type}"

@@ -133,65 +59,20 @@ class BangOlufsenButtonEvent(BangOlufsenEvent):
        self.async_on_remove(
            async_dispatcher_connect(
                self.hass,
-                f"{DOMAIN}_{self._unique_id}_{CONNECTION_STATUS}",
+                f"{self._unique_id}_{CONNECTION_STATUS}",
                self._async_update_connection_state,
            )
        )
        self.async_on_remove(
            async_dispatcher_connect(
                self.hass,
-                f"{DOMAIN}_{self._unique_id}_{WebsocketNotification.BUTTON}_{self._button_type}",
+                f"{self._unique_id}_{WebsocketNotification.BUTTON}_{self._button_type}",
                self._async_handle_event,
            )
        )

-
-class BangOlufsenRemoteKeyEvent(BangOlufsenEvent):
-    """Event class for Beoremote One key events."""
-
-    _attr_event_types = BEO_REMOTE_KEY_EVENTS
-
-    def __init__(
-        self,
-        config_entry: BangOlufsenConfigEntry,
-        remote: PairedRemote,
-        key_type: str,
-    ) -> None:
-        """Initialize Beoremote One key."""
-        super().__init__(config_entry)
-
-        if TYPE_CHECKING:
-            assert remote.serial_number
-
-        self._attr_unique_id = f"{remote.serial_number}_{self._unique_id}_{key_type}"
-        self._attr_device_info = DeviceInfo(
-            identifiers={(DOMAIN, f"{remote.serial_number}_{self._unique_id}")},
-            name=f"{BangOlufsenModel.BEOREMOTE_ONE}-{remote.serial_number}-{self._unique_id}",
-            model=BangOlufsenModel.BEOREMOTE_ONE,
-            serial_number=remote.serial_number,
-            sw_version=remote.app_version,
-            manufacturer=MANUFACTURER,
-            via_device=(DOMAIN, self._unique_id),
-        )
-
-        # Make the native key name Home Assistant compatible
-        self._attr_translation_key = key_type.lower().replace("/", "_")
-
-        self._key_type = key_type
-
-    async def async_added_to_hass(self) -> None:
-        """Listen to WebSocket Beoremote One key events."""
-        self.async_on_remove(
-            async_dispatcher_connect(
-                self.hass,
-                f"{DOMAIN}_{self._unique_id}_{CONNECTION_STATUS}",
-                self._async_update_connection_state,
-            )
-        )
-        self.async_on_remove(
-            async_dispatcher_connect(
-                self.hass,
-                f"{DOMAIN}_{self._unique_id}_{WebsocketNotification.BEO_REMOTE_BUTTON}_{self._key_type}",
-                self._async_handle_event,
-            )
-        )
+    @callback
+    def _async_handle_event(self, event: str) -> None:
+        """Handle event."""
+        self._trigger_event(event)
+        self.async_write_ha_state()
--- a/homeassistant/components/bang_olufsen/icons.json
+++ b/homeassistant/components/bang_olufsen/icons.json
@@ -1,278 +1,4 @@
 {
-  "entity": {
-    "event": {
-      "control_blue": {
-        "default": "mdi:remote"
-      },
-      "control_digit0": {
-        "default": "mdi:remote"
-      },
-      "control_digit1": {
-        "default": "mdi:remote"
-      },
-      "control_digit2": {
-        "default": "mdi:remote"
-      },
-      "control_digit3": {
-        "default": "mdi:remote"
-      },
-      "control_digit4": {
-        "default": "mdi:remote"
-      },
-      "control_digit5": {
-        "default": "mdi:remote"
-      },
-      "control_digit6": {
-        "default": "mdi:remote"
-      },
-      "control_digit7": {
-        "default": "mdi:remote"
-      },
-      "control_digit8": {
-        "default": "mdi:remote"
-      },
-      "control_digit9": {
-        "default": "mdi:remote"
-      },
-      "control_down": {
-        "default": "mdi:remote"
-      },
-      "control_func1": {
-        "default": "mdi:remote"
-      },
-      "control_func10": {
-        "default": "mdi:remote"
-      },
-      "control_func11": {
-        "default": "mdi:remote"
-      },
-      "control_func12": {
-        "default": "mdi:remote"
-      },
-      "control_func13": {
-        "default": "mdi:remote"
-      },
-      "control_func14": {
-        "default": "mdi:remote"
-      },
-      "control_func15": {
-        "default": "mdi:remote"
-      },
-      "control_func16": {
-        "default": "mdi:remote"
-      },
-      "control_func17": {
-        "default": "mdi:remote"
-      },
-      "control_func18": {
-        "default": "mdi:remote"
-      },
-      "control_func19": {
-        "default": "mdi:remote"
-      },
-      "control_func2": {
-        "default": "mdi:remote"
-      },
-      "control_func20": {
-        "default": "mdi:remote"
-      },
-      "control_func21": {
-        "default": "mdi:remote"
-      },
-      "control_func22": {
-        "default": "mdi:remote"
-      },
-      "control_func23": {
-        "default": "mdi:remote"
-      },
-      "control_func24": {
-        "default": "mdi:remote"
-      },
-      "control_func25": {
-        "default": "mdi:remote"
-      },
-      "control_func26": {
-        "default": "mdi:remote"
-      },
-      "control_func27": {
-        "default": "mdi:remote"
-      },
-      "control_func3": {
-        "default": "mdi:remote"
-      },
-      "control_func4": {
-        "default": "mdi:remote"
-      },
-      "control_func5": {
-        "default": "mdi:remote"
-      },
-      "control_func6": {
-        "default": "mdi:remote"
-      },
-      "control_func7": {
-        "default": "mdi:remote"
-      },
-      "control_func8": {
-        "default": "mdi:remote"
-      },
-      "control_func9": {
-        "default": "mdi:remote"
-      },
-      "control_green": {
-        "default": "mdi:remote"
-      },
-      "control_left": {
-        "default": "mdi:remote"
-      },
-      "control_play": {
-        "default": "mdi:remote"
-      },
-      "control_red": {
-        "default": "mdi:remote"
-      },
-      "control_rewind": {
-        "default": "mdi:remote"
-      },
-      "control_right": {
-        "default": "mdi:remote"
-      },
-      "control_select": {
-        "default": "mdi:remote"
-      },
-      "control_stop": {
-        "default": "mdi:remote"
-      },
-      "control_up": {
-        "default": "mdi:remote"
-      },
-      "control_wind": {
-        "default": "mdi:remote"
-      },
-      "control_yellow": {
-        "default": "mdi:remote"
-      },
-      "light_blue": {
-        "default": "mdi:remote"
-      },
-      "light_digit0": {
-        "default": "mdi:remote"
-      },
-      "light_digit1": {
-        "default": "mdi:remote"
-      },
-      "light_digit2": {
-        "default": "mdi:remote"
-      },
-      "light_digit3": {
-        "default": "mdi:remote"
-      },
-      "light_digit4": {
-        "default": "mdi:remote"
-      },
-      "light_digit5": {
-        "default": "mdi:remote"
-      },
-      "light_digit6": {
-        "default": "mdi:remote"
-      },
-      "light_digit7": {
-        "default": "mdi:remote"
-      },
-      "light_digit8": {
-        "default": "mdi:remote"
-      },
-      "light_digit9": {
-        "default": "mdi:remote"
-      },
-      "light_down": {
-        "default": "mdi:remote"
-      },
-      "light_func1": {
-        "default": "mdi:remote"
-      },
-      "light_func10": {
-        "default": "mdi:remote"
-      },
-      "light_func11": {
-        "default": "mdi:remote"
-      },
-      "light_func12": {
-        "default": "mdi:remote"
-      },
-      "light_func13": {
-        "default": "mdi:remote"
-      },
-      "light_func14": {
-        "default": "mdi:remote"
-      },
-      "light_func15": {
-        "default": "mdi:remote"
-      },
-      "light_func16": {
-        "default": "mdi:remote"
-      },
-      "light_func17": {
-        "default": "mdi:remote"
-      },
-      "light_func2": {
-        "default": "mdi:remote"
-      },
-      "light_func3": {
-        "default": "mdi:remote"
-      },
-      "light_func4": {
-        "default": "mdi:remote"
-      },
-      "light_func5": {
-        "default": "mdi:remote"
-      },
-      "light_func6": {
-        "default": "mdi:remote"
-      },
-      "light_func7": {
-        "default": "mdi:remote"
-      },
-      "light_func8": {
-        "default": "mdi:remote"
-      },
-      "light_func9": {
-        "default": "mdi:remote"
-      },
-      "light_green": {
-        "default": "mdi:remote"
-      },
-      "light_left": {
-        "default": "mdi:remote"
-      },
-      "light_play": {
-        "default": "mdi:remote"
-      },
-      "light_red": {
-        "default": "mdi:remote"
-      },
-      "light_rewind": {
-        "default": "mdi:remote"
-      },
-      "light_right": {
-        "default": "mdi:remote"
-      },
-      "light_select": {
-        "default": "mdi:remote"
-      },
-      "light_stop": {
-        "default": "mdi:remote"
-      },
-      "light_up": {
-        "default": "mdi:remote"
-      },
-      "light_wind": {
-        "default": "mdi:remote"
-      },
-      "light_yellow": {
-        "default": "mdi:remote"
-      }
-    }
-  },
  "services": {
    "beolink_allstandby": { "service": "mdi:close-circle-multiple-outline" },
    "beolink_expand": { "service": "mdi:location-enter" },
--- a/homeassistant/components/bang_olufsen/media_player.py
+++ b/homeassistant/components/bang_olufsen/media_player.py
@@ -80,7 +80,6 @@ from .const import (
    CONNECTION_STATUS,
    DOMAIN,
    FALLBACK_SOURCES,
-    MANUFACTURER,
    VALID_MEDIA_TYPES,
    BangOlufsenMediaType,
    BangOlufsenSource,
@@ -202,7 +201,7 @@ class BangOlufsenMediaPlayer(BangOlufsenEntity, MediaPlayerEntity):
        self._attr_device_info = DeviceInfo(
            configuration_url=f"http://{self._host}/#/",
            identifiers={(DOMAIN, self._unique_id)},
-            manufacturer=MANUFACTURER,
+            manufacturer="Bang & Olufsen",
            model=self._model,
            serial_number=self._unique_id,
        )
@@ -250,7 +249,7 @@ class BangOlufsenMediaPlayer(BangOlufsenEntity, MediaPlayerEntity):
            self.async_on_remove(
                async_dispatcher_connect(
                    self.hass,
-                    f"{DOMAIN}_{self._unique_id}_{signal}",
+                    f"{self._unique_id}_{signal}",
                    signal_handler,
                )
            )
--- a/homeassistant/components/bang_olufsen/strings.json
+++ b/homeassistant/components/bang_olufsen/strings.json
--- a/homeassistant/components/bang_olufsen/util.py
+++ b/homeassistant/components/bang_olufsen/util.py
@@ -2,16 +2,11 @@

 from __future__ import annotations

-from typing import cast
-
-from mozart_api.models import PairedRemote
-from mozart_api.mozart_client import MozartClient
-
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import device_registry as dr
 from homeassistant.helpers.device_registry import DeviceEntry

-from .const import DEVICE_BUTTONS, DOMAIN, BangOlufsenButtons, BangOlufsenModel
+from .const import DOMAIN


 def get_device(hass: HomeAssistant, unique_id: str) -> DeviceEntry:
@@ -26,30 +21,3 @@ def get_device(hass: HomeAssistant, unique_id: str) -> DeviceEntry:
 def get_serial_number_from_jid(jid: str) -> str:
    """Get serial number from Beolink JID."""
    return jid.split(".")[2].split("@")[0]
-
-
-async def get_remotes(client: MozartClient) -> list[PairedRemote]:
-    """Get paired remotes."""
-
-    bluetooth_remote_list = await client.get_bluetooth_remotes()
-
-    return [
-        remote
-        for remote in cast(list[PairedRemote], bluetooth_remote_list.items)
-        if remote.serial_number is not None
-    ]
-
-
-def get_device_buttons(model: BangOlufsenModel) -> list[str]:
-    """Get supported buttons for a given model."""
-    buttons = DEVICE_BUTTONS.copy()
-
-    # Beosound Premiere does not have a bluetooth button
-    if model == BangOlufsenModel.BEOSOUND_PREMIERE:
-        buttons.remove(BangOlufsenButtons.BLUETOOTH)
-
-    # Beoconnect Core does not have any buttons
-    elif model == BangOlufsenModel.BEOCONNECT_CORE:
-        buttons = []
-
-    return buttons
--- a/homeassistant/components/bang_olufsen/websocket.py
+++ b/homeassistant/components/bang_olufsen/websocket.py
@@ -6,7 +6,6 @@ import logging
 from typing import TYPE_CHECKING

 from mozart_api.models import (
-    BeoRemoteButton,
    ButtonEvent,
    ListeningModeProps,
    PlaybackContentMetadata,
@@ -29,13 +28,11 @@ from homeassistant.util.enum import try_parse_enum
 from .const import (
    BANG_OLUFSEN_WEBSOCKET_EVENT,
    CONNECTION_STATUS,
-    DOMAIN,
    EVENT_TRANSLATION_MAP,
-    BangOlufsenModel,
    WebsocketNotification,
 )
 from .entity import BangOlufsenBase
-from .util import get_device, get_remotes
+from .util import get_device

 _LOGGER = logging.getLogger(__name__)

@@ -60,9 +57,6 @@ class BangOlufsenWebsocket(BangOlufsenBase):
        self._client.get_active_listening_mode_notifications(
            self.on_active_listening_mode
        )
-        self._client.get_beo_remote_button_notifications(
-            self.on_beo_remote_button_notification
-        )
        self._client.get_button_notifications(self.on_button_notification)

        self._client.get_playback_error_notifications(
@@ -93,7 +87,7 @@ class BangOlufsenWebsocket(BangOlufsenBase):
        """Update all entities of the connection status."""
        async_dispatcher_send(
            self.hass,
-            f"{DOMAIN}_{self._unique_id}_{CONNECTION_STATUS}",
+            f"{self._unique_id}_{CONNECTION_STATUS}",
            self._client.websocket_connected,
        )

@@ -111,22 +105,10 @@ class BangOlufsenWebsocket(BangOlufsenBase):
        """Send active_listening_mode dispatch."""
        async_dispatcher_send(
            self.hass,
-            f"{DOMAIN}_{self._unique_id}_{WebsocketNotification.ACTIVE_LISTENING_MODE}",
+            f"{self._unique_id}_{WebsocketNotification.ACTIVE_LISTENING_MODE}",
            notification,
        )

-    def on_beo_remote_button_notification(self, notification: BeoRemoteButton) -> None:
-        """Send beo_remote_button dispatch."""
-        if TYPE_CHECKING:
-            assert notification.type
-
-        # Send to event entity
-        async_dispatcher_send(
-            self.hass,
-            f"{DOMAIN}_{self._unique_id}_{WebsocketNotification.BEO_REMOTE_BUTTON}_{notification.key}",
-            EVENT_TRANSLATION_MAP[notification.type],
-        )
-
    def on_button_notification(self, notification: ButtonEvent) -> None:
        """Send button dispatch."""
        # State is expected to always be available.
@@ -136,11 +118,11 @@ class BangOlufsenWebsocket(BangOlufsenBase):
        # Send to event entity
        async_dispatcher_send(
            self.hass,
-            f"{DOMAIN}_{self._unique_id}_{WebsocketNotification.BUTTON}_{notification.button}",
+            f"{self._unique_id}_{WebsocketNotification.BUTTON}_{notification.button}",
            EVENT_TRANSLATION_MAP[notification.state],
        )

-    async def on_notification_notification(
+    def on_notification_notification(
        self, notification: WebsocketNotificationTag
    ) -> None:
        """Send notification dispatch."""
@@ -154,51 +136,24 @@ class BangOlufsenWebsocket(BangOlufsenBase):
        ):
            async_dispatcher_send(
                self.hass,
-                f"{DOMAIN}_{self._unique_id}_{WebsocketNotification.BEOLINK}",
+                f"{self._unique_id}_{WebsocketNotification.BEOLINK}",
            )
        elif notification_type is WebsocketNotification.CONFIGURATION:
            async_dispatcher_send(
                self.hass,
-                f"{DOMAIN}_{self._unique_id}_{WebsocketNotification.CONFIGURATION}",
+                f"{self._unique_id}_{WebsocketNotification.CONFIGURATION}",
            )
        elif notification_type is WebsocketNotification.REMOTE_MENU_CHANGED:
            async_dispatcher_send(
                self.hass,
-                f"{DOMAIN}_{self._unique_id}_{WebsocketNotification.REMOTE_MENU_CHANGED}",
+                f"{self._unique_id}_{WebsocketNotification.REMOTE_MENU_CHANGED}",
            )

-        # This notification is triggered by a remote pairing, unpairing and connecting to a device
-        # So the current remote devices have to be compared to available remotes to determine action
-        elif notification_type is WebsocketNotification.REMOTE_CONTROL_DEVICES:
-            device_registry = dr.async_get(self.hass)
-            # Get remote devices connected to the device from Home Assistant
-            device_serial_numbers = [
-                device.serial_number
-                for device in device_registry.devices.get_devices_for_config_entry_id(
-                    self.entry.entry_id
-                )
-                if device.serial_number is not None
-                and device.model == BangOlufsenModel.BEOREMOTE_ONE
-            ]
-            # Get paired remotes from device
-            remote_serial_numbers = [
-                remote.serial_number
-                for remote in await get_remotes(self._client)
-                if remote.serial_number is not None
-            ]
-            # Check if number of remote devices correspond to number of paired remotes
-            if len(remote_serial_numbers) != len(device_serial_numbers):
-                _LOGGER.info(
-                    "A Beoremote One has been paired or unpaired to %s. Reloading config entry to add device and entities",
-                    self.entry.title,
-                )
-                self.hass.config_entries.async_schedule_reload(self.entry.entry_id)
-
    def on_playback_error_notification(self, notification: PlaybackError) -> None:
        """Send playback_error dispatch."""
        async_dispatcher_send(
            self.hass,
-            f"{DOMAIN}_{self._unique_id}_{WebsocketNotification.PLAYBACK_ERROR}",
+            f"{self._unique_id}_{WebsocketNotification.PLAYBACK_ERROR}",
            notification,
        )

@@ -208,7 +163,7 @@ class BangOlufsenWebsocket(BangOlufsenBase):
        """Send playback_metadata dispatch."""
        async_dispatcher_send(
            self.hass,
-            f"{DOMAIN}_{self._unique_id}_{WebsocketNotification.PLAYBACK_METADATA}",
+            f"{self._unique_id}_{WebsocketNotification.PLAYBACK_METADATA}",
            notification,
        )

@@ -216,7 +171,7 @@ class BangOlufsenWebsocket(BangOlufsenBase):
        """Send playback_progress dispatch."""
        async_dispatcher_send(
            self.hass,
-            f"{DOMAIN}_{self._unique_id}_{WebsocketNotification.PLAYBACK_PROGRESS}",
+            f"{self._unique_id}_{WebsocketNotification.PLAYBACK_PROGRESS}",
            notification,
        )

@@ -224,7 +179,7 @@ class BangOlufsenWebsocket(BangOlufsenBase):
        """Send playback_state dispatch."""
        async_dispatcher_send(
            self.hass,
-            f"{DOMAIN}_{self._unique_id}_{WebsocketNotification.PLAYBACK_STATE}",
+            f"{self._unique_id}_{WebsocketNotification.PLAYBACK_STATE}",
            notification,
        )

@@ -232,7 +187,7 @@ class BangOlufsenWebsocket(BangOlufsenBase):
        """Send playback_source dispatch."""
        async_dispatcher_send(
            self.hass,
-            f"{DOMAIN}_{self._unique_id}_{WebsocketNotification.PLAYBACK_SOURCE}",
+            f"{self._unique_id}_{WebsocketNotification.PLAYBACK_SOURCE}",
            notification,
        )

@@ -240,7 +195,7 @@ class BangOlufsenWebsocket(BangOlufsenBase):
        """Send source_change dispatch."""
        async_dispatcher_send(
            self.hass,
-            f"{DOMAIN}_{self._unique_id}_{WebsocketNotification.SOURCE_CHANGE}",
+            f"{self._unique_id}_{WebsocketNotification.SOURCE_CHANGE}",
            notification,
        )

@@ -248,7 +203,7 @@ class BangOlufsenWebsocket(BangOlufsenBase):
        """Send volume dispatch."""
        async_dispatcher_send(
            self.hass,
-            f"{DOMAIN}_{self._unique_id}_{WebsocketNotification.VOLUME}",
+            f"{self._unique_id}_{WebsocketNotification.VOLUME}",
            notification,
        )

--- a/homeassistant/components/bluetooth/manifest.json
+++ b/homeassistant/components/bluetooth/manifest.json
@@ -20,7 +20,7 @@
    "bluetooth-adapters==2.1.0",
    "bluetooth-auto-recovery==1.5.3",
    "bluetooth-data-tools==1.28.4",
-    "dbus-fast==3.1.2",
+    "dbus-fast==3.0.0",
    "habluetooth==5.7.0"
  ]
 }
--- a/homeassistant/components/bluetooth_tracker/init.py
+++ b/homeassistant/components/bluetooth_tracker/init.py
@@ -0,0 +1 @@
+"""The bluetooth_tracker component."""
--- a/homeassistant/components/bluetooth_tracker/const.py
+++ b/homeassistant/components/bluetooth_tracker/const.py
@@ -0,0 +1,10 @@
+"""Constants for the Bluetooth Tracker component."""
+
+from typing import Final
+
+DOMAIN: Final = "bluetooth_tracker"
+SERVICE_UPDATE: Final = "update"
+
+BT_PREFIX: Final = "BT_"
+CONF_REQUEST_RSSI: Final = "request_rssi"
+DEFAULT_DEVICE_ID: Final = -1
--- a/homeassistant/components/bluetooth_tracker/device_tracker.py
+++ b/homeassistant/components/bluetooth_tracker/device_tracker.py
@@ -0,0 +1,213 @@
+"""Tracking for bluetooth devices."""
+
+from __future__ import annotations
+
+import asyncio
+from datetime import datetime, timedelta
+import logging
+from typing import Final
+
+import bluetooth
+from bt_proximity import BluetoothRSSI
+import voluptuous as vol
+
+from homeassistant.components.device_tracker import (
+    CONF_SCAN_INTERVAL,
+    CONF_TRACK_NEW,
+    DEFAULT_TRACK_NEW,
+    PLATFORM_SCHEMA as DEVICE_TRACKER_PLATFORM_SCHEMA,
+    SCAN_INTERVAL,
+    SourceType,
+)
+from homeassistant.components.device_tracker.legacy import (
+    YAML_DEVICES,
+    AsyncSeeCallback,
+    Device,
+    async_load_config,
+)
+from homeassistant.const import CONF_DEVICE_ID
+from homeassistant.core import HomeAssistant, ServiceCall
+from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.event import async_track_time_interval
+from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
+
+from .const import (
+    BT_PREFIX,
+    CONF_REQUEST_RSSI,
+    DEFAULT_DEVICE_ID,
+    DOMAIN,
+    SERVICE_UPDATE,
+)
+
+_LOGGER: Final = logging.getLogger(__name__)
+
+PLATFORM_SCHEMA: Final = DEVICE_TRACKER_PLATFORM_SCHEMA.extend(
+    {
+        vol.Optional(CONF_TRACK_NEW): cv.boolean,
+        vol.Optional(CONF_REQUEST_RSSI): cv.boolean,
+        vol.Optional(CONF_DEVICE_ID, default=DEFAULT_DEVICE_ID): vol.All(
+            vol.Coerce(int), vol.Range(min=-1)
+        ),
+    }
+)
+
+
+def is_bluetooth_device(device: Device) -> bool:
+    """Check whether a device is a bluetooth device by its mac."""
+    return device.mac is not None and device.mac[:3].upper() == BT_PREFIX
+
+
+def discover_devices(device_id: int) -> list[tuple[str, str]]:
+    """Discover Bluetooth devices."""
+    try:
+        result = bluetooth.discover_devices(
+            duration=8,
+            lookup_names=True,
+            flush_cache=True,
+            lookup_class=False,
+            device_id=device_id,
+        )
+    except OSError as ex:
+        # OSError is generally thrown if a bluetooth device isn't found
+        _LOGGER.error("Couldn't discover bluetooth devices: %s", ex)
+        return []
+    _LOGGER.debug("Bluetooth devices discovered = %d", len(result))
+    return result  # type: ignore[no-any-return]
+
+
+async def see_device(
+    hass: HomeAssistant,
+    async_see: AsyncSeeCallback,
+    mac: str,
+    device_name: str,
+    rssi: tuple[int] | None = None,
+) -> None:
+    """Mark a device as seen."""
+    attributes = {}
+    if rssi is not None:
+        attributes["rssi"] = rssi
+
+    await async_see(
+        mac=f"{BT_PREFIX}{mac}",
+        host_name=device_name,
+        attributes=attributes,
+        source_type=SourceType.BLUETOOTH,
+    )
+
+
+async def get_tracking_devices(hass: HomeAssistant) -> tuple[set[str], set[str]]:
+    """Load all known devices.
+
+    We just need the devices so set consider_home and home range to 0
+    """
+    yaml_path: str = hass.config.path(YAML_DEVICES)
+
+    devices = await async_load_config(yaml_path, hass, timedelta(0))
+    bluetooth_devices = [device for device in devices if is_bluetooth_device(device)]
+
+    devices_to_track: set[str] = {
+        device.mac[3:]
+        for device in bluetooth_devices
+        if device.track and device.mac is not None
+    }
+    devices_to_not_track: set[str] = {
+        device.mac[3:]
+        for device in bluetooth_devices
+        if not device.track and device.mac is not None
+    }
+
+    return devices_to_track, devices_to_not_track
+
+
+def lookup_name(mac: str) -> str | None:
+    """Lookup a Bluetooth device name."""
+    _LOGGER.debug("Scanning %s", mac)
+    return bluetooth.lookup_name(mac, timeout=5)  # type: ignore[no-any-return]
+
+
+async def async_setup_scanner(
+    hass: HomeAssistant,
+    config: ConfigType,
+    async_see: AsyncSeeCallback,
+    discovery_info: DiscoveryInfoType | None = None,
+) -> bool:
+    """Set up the Bluetooth Scanner."""
+    device_id: int = config[CONF_DEVICE_ID]
+    interval: timedelta = config.get(CONF_SCAN_INTERVAL, SCAN_INTERVAL)
+    request_rssi: bool = config.get(CONF_REQUEST_RSSI, False)
+    update_bluetooth_lock = asyncio.Lock()
+
+    # If track new devices is true discover new devices on startup.
+    track_new: bool = config.get(CONF_TRACK_NEW, DEFAULT_TRACK_NEW)
+    _LOGGER.debug("Tracking new devices is set to %s", track_new)
+
+    devices_to_track, devices_to_not_track = await get_tracking_devices(hass)
+
+    if not devices_to_track and not track_new:
+        _LOGGER.debug("No Bluetooth devices to track and not tracking new devices")
+
+    if request_rssi:
+        _LOGGER.debug("Detecting RSSI for devices")
+
+    async def perform_bluetooth_update() -> None:
+        """Discover Bluetooth devices and update status."""
+        _LOGGER.debug("Performing Bluetooth devices discovery and update")
+        tasks: list[asyncio.Task[None]] = []
+
+        try:
+            if track_new:
+                devices = await hass.async_add_executor_job(discover_devices, device_id)
+                for mac, _device_name in devices:
+                    if mac not in devices_to_track and mac not in devices_to_not_track:
+                        devices_to_track.add(mac)
+
+            for mac in devices_to_track:
+                friendly_name = await hass.async_add_executor_job(lookup_name, mac)
+                if friendly_name is None:
+                    # Could not lookup device name
+                    continue
+
+                rssi = None
+                if request_rssi:
+                    client = BluetoothRSSI(mac)
+                    rssi = await hass.async_add_executor_job(client.request_rssi)
+                    client.close()
+
+                tasks.append(
+                    asyncio.create_task(
+                        see_device(hass, async_see, mac, friendly_name, rssi)
+                    )
+                )
+
+            if tasks:
+                await asyncio.wait(tasks)
+
+        except bluetooth.BluetoothError:
+            _LOGGER.exception("Error looking up Bluetooth device")
+
+    async def update_bluetooth(now: datetime | None = None) -> None:
+        """Lookup Bluetooth devices and update status."""
+        # If an update is in progress, we don't do anything
+        if update_bluetooth_lock.locked():
+            _LOGGER.debug(
+                (
+                    "Previous execution of update_bluetooth is taking longer than the"
+                    " scheduled update of interval %s"
+                ),
+                interval,
+            )
+            return
+
+        async with update_bluetooth_lock:
+            await perform_bluetooth_update()
+
+    async def handle_manual_update_bluetooth(call: ServiceCall) -> None:
+        """Update bluetooth devices on demand."""
+        await update_bluetooth()
+
+    hass.async_create_task(update_bluetooth())
+    async_track_time_interval(hass, update_bluetooth, interval)
+
+    hass.services.async_register(DOMAIN, SERVICE_UPDATE, handle_manual_update_bluetooth)
+
+    return True
--- a/homeassistant/components/bluetooth_tracker/icons.json
+++ b/homeassistant/components/bluetooth_tracker/icons.json
@@ -0,0 +1,7 @@
+{
+  "services": {
+    "update": {
+      "service": "mdi:update"
+    }
+  }
+}
--- a/homeassistant/components/bluetooth_tracker/manifest.json
+++ b/homeassistant/components/bluetooth_tracker/manifest.json
@@ -0,0 +1,10 @@
+{
+  "domain": "bluetooth_tracker",
+  "name": "Bluetooth Tracker",
+  "codeowners": [],
+  "documentation": "https://www.home-assistant.io/integrations/bluetooth_tracker",
+  "iot_class": "local_polling",
+  "loggers": ["bluetooth", "bt_proximity"],
+  "quality_scale": "legacy",
+  "requirements": ["bt-proximity==0.2.1", "PyBluez==0.22"]
+}
--- a/homeassistant/components/bluetooth_tracker/services.yaml
+++ b/homeassistant/components/bluetooth_tracker/services.yaml
@@ -0,0 +1 @@
+update:
--- a/homeassistant/components/bluetooth_tracker/strings.json
+++ b/homeassistant/components/bluetooth_tracker/strings.json
@@ -0,0 +1,8 @@
+{
+  "services": {
+    "update": {
+      "description": "Triggers manual tracker update.",
+      "name": "Update"
+    }
+  }
+}
--- a/homeassistant/components/brother/entity.py
+++ b/homeassistant/components/brother/entity.py
@@ -24,7 +24,7 @@ class BrotherPrinterEntity(CoordinatorEntity[BrotherDataUpdateCoordinator]):
            connections={(CONNECTION_NETWORK_MAC, coordinator.brother.mac)},
            serial_number=coordinator.brother.serial,
            manufacturer="Brother",
-            model_id=coordinator.brother.model,
+            model=coordinator.brother.model,
            name=coordinator.brother.model,
            sw_version=coordinator.brother.firmware,
        )
--- a/homeassistant/components/brother/manifest.json
+++ b/homeassistant/components/brother/manifest.json
@@ -8,8 +8,7 @@
  "integration_type": "device",
  "iot_class": "local_polling",
  "loggers": ["brother", "pyasn1", "pysmi", "pysnmp"],
-  "quality_scale": "platinum",
-  "requirements": ["brother==6.0.0"],
+  "requirements": ["brother==5.1.1"],
  "zeroconf": [
    {
      "name": "brother*",
--- a/homeassistant/components/brother/quality_scale.yaml
+++ b/homeassistant/components/brother/quality_scale.yaml
@@ -1,78 +0,0 @@
-rules:
-  # Bronze
-  action-setup:
-    status: exempt
-    comment: The integration does not register services.
-  appropriate-polling: done
-  brands: done
-  common-modules: done
-  config-flow-test-coverage: done
-  config-flow: done
-  dependency-transparency: done
-  docs-actions:
-    status: exempt
-    comment: The integration does not register services.
-  docs-high-level-description: done
-  docs-installation-instructions: done
-  docs-removal-instructions: done
-  entity-event-setup: done
-  entity-unique-id: done
-  has-entity-name: done
-  runtime-data: done
-  test-before-configure: done
-  test-before-setup: done
-  unique-config-entry: done
-
-  # Silver
-  action-exceptions:
-    status: exempt
-    comment: The integration does not register services.
-  config-entry-unloading: done
-  docs-configuration-parameters:
-    status: exempt
-    comment: No options to configure.
-  docs-installation-parameters: done
-  entity-unavailable: done
-  integration-owner: done
-  log-when-unavailable: done
-  parallel-updates: done
-  reauthentication-flow:
-    status: exempt
-    comment: SNMP doesn't return error identifying an authentication problem, to change the SNMP community (simple password) the user should use reconfigure flow.
-  test-coverage: done
-
-  # Gold
-  devices: done
-  diagnostics: done
-  discovery-update-info: done
-  discovery: done
-  docs-data-update: done
-  docs-examples: done
-  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 integration has a fixed single device.
-  entity-category: done
-  entity-device-class: done
-  entity-disabled-by-default: done
-  entity-translations: done
-  exception-translations: done
-  icon-translations: done
-  reconfiguration-flow: done
-  repair-issues:
-    status: exempt
-    comment: This integration doesn't have any cases where raising an issue is needed.
-  stale-devices:
-    status: exempt
-    comment: This integration has a fixed single device.
-
-  # Platinum
-  async-dependency: done
-  inject-websession:
-    status: exempt
-    comment: The integration does not connect via HTTP instead it uses a shared SNMP engine.
-  strict-typing: done
--- a/homeassistant/components/brother/sensor.py
+++ b/homeassistant/components/brother/sensor.py
@@ -17,7 +17,7 @@ from homeassistant.components.sensor import (
    SensorStateClass,
 )
 from homeassistant.const import PERCENTAGE, EntityCategory
-from homeassistant.core import HomeAssistant
+from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers import entity_registry as er
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.typing import StateType
@@ -345,10 +345,12 @@ class BrotherPrinterSensor(BrotherPrinterEntity, SensorEntity):
        """Initialize."""
        super().__init__(coordinator)

+        self._attr_native_value = description.value(coordinator.data)
        self._attr_unique_id = f"{coordinator.brother.serial.lower()}_{description.key}"
        self.entity_description = description

-    @property
-    def native_value(self) -> StateType | datetime:
-        """Return the native value of the sensor."""
-        return self.entity_description.value(self.coordinator.data)
+    @callback
+    def _handle_coordinator_update(self) -> None:
+        """Handle updated data from the coordinator."""
+        self._attr_native_value = self.entity_description.value(self.coordinator.data)
+        self.async_write_ha_state()
--- a/homeassistant/components/climate/icons.json
+++ b/homeassistant/components/climate/icons.json
@@ -96,16 +96,5 @@
    "turn_on": {
      "service": "mdi:power-on"
    }
-  },
-  "triggers": {
-    "started_heating": {
-      "trigger": "mdi:fire"
-    },
-    "turned_off": {
-      "trigger": "mdi:power-off"
-    },
-    "turned_on": {
-      "trigger": "mdi:power-on"
-    }
  }
 }
--- a/homeassistant/components/climate/strings.json
+++ b/homeassistant/components/climate/strings.json
@@ -1,8 +1,4 @@
 {
-  "common": {
-    "trigger_behavior_description": "The behavior of the targeted climates to trigger on.",
-    "trigger_behavior_name": "Behavior"
-  },
  "device_automation": {
    "action_type": {
      "set_hvac_mode": "Change HVAC mode on {entity_name}",
@@ -191,13 +187,6 @@
        "heat_cool": "Heat/cool",
        "off": "[%key:common::state::off%]"
      }
-    },
-    "trigger_behavior": {
-      "options": {
-        "any": "Any",
-        "first": "First",
-        "last": "Last"
-      }
    }
  },
  "services": {
@@ -296,40 +285,5 @@
      "name": "[%key:common::action::turn_on%]"
    }
  },
-  "title": "Climate",
-  "triggers": {
-    "started_heating": {
-      "description": "Triggers when a climate starts to heat.",
-      "description_configured": "[%key:component::climate::triggers::started_heating::description%]",
-      "fields": {
-        "behavior": {
-          "description": "[%key:component::climate::common::trigger_behavior_description%]",
-          "name": "[%key:component::climate::common::trigger_behavior_name%]"
-        }
-      },
-      "name": "When a climate starts to heat"
-    },
-    "turned_off": {
-      "description": "Triggers when a climate is turned off.",
-      "description_configured": "[%key:component::climate::triggers::turned_off::description%]",
-      "fields": {
-        "behavior": {
-          "description": "[%key:component::climate::common::trigger_behavior_description%]",
-          "name": "[%key:component::climate::common::trigger_behavior_name%]"
-        }
-      },
-      "name": "When a climate is turned off"
-    },
-    "turned_on": {
-      "description": "Triggers when a climate is turned on.",
-      "description_configured": "[%key:component::climate::triggers::turned_on::description%]",
-      "fields": {
-        "behavior": {
-          "description": "[%key:component::climate::common::trigger_behavior_description%]",
-          "name": "[%key:component::climate::common::trigger_behavior_name%]"
-        }
-      },
-      "name": "When a climate is turned on"
-    }
-  }
+  "title": "Climate"
 }
--- a/homeassistant/components/climate/trigger.py
+++ b/homeassistant/components/climate/trigger.py
@@ -1,37 +0,0 @@
-"""Provides triggers for climates."""
-
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.trigger import (
-    Trigger,
-    make_conditional_entity_state_trigger,
-    make_entity_state_attribute_trigger,
-    make_entity_state_trigger,
-)
-
-from .const import ATTR_HVAC_ACTION, DOMAIN, HVACAction, HVACMode
-
-TRIGGERS: dict[str, type[Trigger]] = {
-    "turned_off": make_entity_state_trigger(DOMAIN, HVACMode.OFF),
-    "turned_on": make_conditional_entity_state_trigger(
-        DOMAIN,
-        from_states={
-            HVACMode.OFF,
-        },
-        to_states={
-            HVACMode.AUTO,
-            HVACMode.COOL,
-            HVACMode.DRY,
-            HVACMode.FAN_ONLY,
-            HVACMode.HEAT,
-            HVACMode.HEAT_COOL,
-        },
-    ),
-    "started_heating": make_entity_state_attribute_trigger(
-        DOMAIN, ATTR_HVAC_ACTION, HVACAction.HEATING
-    ),
-}
-
-
-async def async_get_triggers(hass: HomeAssistant) -> dict[str, type[Trigger]]:
-    """Return the triggers for climates."""
-    return TRIGGERS
--- a/homeassistant/components/climate/triggers.yaml
+++ b/homeassistant/components/climate/triggers.yaml
@@ -1,19 +0,0 @@
-.trigger_common: &trigger_common
-  target:
-    entity:
-      domain: climate
-  fields:
-    behavior:
-      required: true
-      default: any
-      selector:
-        select:
-          translation_key: trigger_behavior
-          options:
-            - first
-            - last
-            - any
-
-started_heating: *trigger_common
-turned_off: *trigger_common
-turned_on: *trigger_common
--- a/homeassistant/components/cloud/init.py
+++ b/homeassistant/components/cloud/init.py
@@ -7,7 +7,7 @@ from collections.abc import Awaitable, Callable
 from datetime import datetime, timedelta
 from enum import Enum
 import logging
-from typing import Any, cast
+from typing import cast

 from hass_nabucasa import Cloud
 import voluptuous as vol
@@ -77,13 +77,7 @@ from .subscription import async_subscription_info

 DEFAULT_MODE = MODE_PROD

-PLATFORMS = [
-    Platform.AI_TASK,
-    Platform.BINARY_SENSOR,
-    Platform.CONVERSATION,
-    Platform.STT,
-    Platform.TTS,
-]
+PLATFORMS = [Platform.BINARY_SENSOR, Platform.STT, Platform.TTS]

 SERVICE_REMOTE_CONNECT = "remote_connect"
 SERVICE_REMOTE_DISCONNECT = "remote_disconnect"
@@ -92,10 +86,6 @@ SIGNAL_CLOUD_CONNECTION_STATE: SignalType[CloudConnectionState] = SignalType(
    "CLOUD_CONNECTION_STATE"
 )

-_SIGNAL_CLOUDHOOKS_UPDATED: SignalType[dict[str, Any]] = SignalType(
-    "CLOUDHOOKS_UPDATED"
-)
-
 STARTUP_REPAIR_DELAY = 1  # 1 hour

 ALEXA_ENTITY_SCHEMA = vol.Schema(
@@ -252,24 +242,6 @@ async def async_delete_cloudhook(hass: HomeAssistant, webhook_id: str) -> None:
    await hass.data[DATA_CLOUD].cloudhooks.async_delete(webhook_id)


-@callback
-def async_listen_cloudhook_change(
-    hass: HomeAssistant,
-    webhook_id: str,
-    on_change: Callable[[dict[str, Any] | None], None],
-) -> Callable[[], None]:
-    """Listen for cloudhook changes for the given webhook and notify when modified or deleted."""
-
-    @callback
-    def _handle_cloudhooks_updated(cloudhooks: dict[str, Any]) -> None:
-        """Handle cloudhooks updated signal."""
-        on_change(cloudhooks.get(webhook_id))
-
-    return async_dispatcher_connect(
-        hass, _SIGNAL_CLOUDHOOKS_UPDATED, _handle_cloudhooks_updated
-    )
-
-
@bind_hass
@callback
 def async_remote_ui_url(hass: HomeAssistant) -> str:
@@ -317,7 +289,7 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:

    hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, _shutdown)

-    _handle_prefs_updated(hass, cloud)
+    _remote_handle_prefs_updated(cloud)
    _setup_services(hass, prefs)

    async def async_startup_repairs(_: datetime) -> None:
@@ -401,32 +373,26 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:


@callback
-def _handle_prefs_updated(hass: HomeAssistant, cloud: Cloud[CloudClient]) -> None:
-    """Register handler for cloud preferences updates."""
-    cur_remote_enabled = cloud.client.prefs.remote_enabled
-    cur_cloudhooks = cloud.client.prefs.cloudhooks
+def _remote_handle_prefs_updated(cloud: Cloud[CloudClient]) -> None:
+    """Handle remote preferences updated."""
+    cur_pref = cloud.client.prefs.remote_enabled
    lock = asyncio.Lock()

-    async def on_prefs_updated(prefs: CloudPreferences) -> None:
-        """Handle cloud preferences updates."""
-        nonlocal cur_remote_enabled
-        nonlocal cur_cloudhooks
+    # Sync remote connection with prefs
+    async def remote_prefs_updated(prefs: CloudPreferences) -> None:
+        """Update remote status."""
+        nonlocal cur_pref

-        # Lock protects cur_ state variables from concurrent updates
        async with lock:
-            if cur_cloudhooks != prefs.cloudhooks:
-                cur_cloudhooks = prefs.cloudhooks
-                async_dispatcher_send(hass, _SIGNAL_CLOUDHOOKS_UPDATED, cur_cloudhooks)
-
-            if prefs.remote_enabled == cur_remote_enabled:
+            if prefs.remote_enabled == cur_pref:
                return

-            if cur_remote_enabled := prefs.remote_enabled:
+            if cur_pref := prefs.remote_enabled:
                await cloud.remote.connect()
            else:
                await cloud.remote.disconnect()

-    cloud.client.prefs.async_listen_updates(on_prefs_updated)
+    cloud.client.prefs.async_listen_updates(remote_prefs_updated)


 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
--- a/homeassistant/components/cloud/ai_task.py
+++ b/homeassistant/components/cloud/ai_task.py
@@ -1,200 +0,0 @@
-"""AI Task integration for Home Assistant Cloud."""
-
-from __future__ import annotations
-
-import io
-from json import JSONDecodeError
-import logging
-
-from hass_nabucasa.llm import (
-    LLMAuthenticationError,
-    LLMError,
-    LLMImageAttachment,
-    LLMRateLimitError,
-    LLMResponseError,
-    LLMServiceError,
-)
-from PIL import Image
-
-from homeassistant.components import ai_task, conversation
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryAuthFailed, HomeAssistantError
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-from homeassistant.util.json import json_loads
-
-from .const import AI_TASK_ENTITY_UNIQUE_ID, DATA_CLOUD
-from .entity import BaseCloudLLMEntity
-
-_LOGGER = logging.getLogger(__name__)
-
-
-def _convert_image_for_editing(data: bytes) -> tuple[bytes, str]:
-    """Ensure the image data is in a format accepted by OpenAI image edits."""
-    stream = io.BytesIO(data)
-    with Image.open(stream) as img:
-        mode = img.mode
-        if mode not in ("RGBA", "LA", "L"):
-            img = img.convert("RGBA")
-
-        output = io.BytesIO()
-        if img.mode in ("RGBA", "LA", "L"):
-            img.save(output, format="PNG")
-            return output.getvalue(), "image/png"
-
-        img.save(output, format=img.format or "PNG")
-        return output.getvalue(), f"image/{(img.format or 'png').lower()}"
-
-
-async def async_prepare_image_generation_attachments(
-    hass: HomeAssistant, attachments: list[conversation.Attachment]
-) -> list[LLMImageAttachment]:
-    """Load attachment data for image generation."""
-
-    def prepare() -> list[LLMImageAttachment]:
-        items: list[LLMImageAttachment] = []
-        for attachment in attachments:
-            if not attachment.mime_type or not attachment.mime_type.startswith(
-                "image/"
-            ):
-                raise HomeAssistantError(
-                    "Only image attachments are supported for image generation"
-                )
-            path = attachment.path
-            if not path.exists():
-                raise HomeAssistantError(f"`{path}` does not exist")
-
-            data = path.read_bytes()
-            mime_type = attachment.mime_type
-
-            try:
-                data, mime_type = _convert_image_for_editing(data)
-            except HomeAssistantError:
-                raise
-            except Exception as err:
-                raise HomeAssistantError("Failed to process image attachment") from err
-
-            items.append(
-                LLMImageAttachment(
-                    filename=path.name,
-                    mime_type=mime_type,
-                    data=data,
-                )
-            )
-
-        return items
-
-    return await hass.async_add_executor_job(prepare)
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    config_entry: ConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up Home Assistant Cloud AI Task entity."""
-    cloud = hass.data[DATA_CLOUD]
-    try:
-        await cloud.llm.async_ensure_token()
-    except LLMError:
-        return
-
-    async_add_entities([CloudLLMTaskEntity(cloud, config_entry)])
-
-
-class CloudLLMTaskEntity(ai_task.AITaskEntity, BaseCloudLLMEntity):
-    """Home Assistant Cloud AI Task entity."""
-
-    _attr_has_entity_name = True
-    _attr_supported_features = (
-        ai_task.AITaskEntityFeature.GENERATE_DATA
-        | ai_task.AITaskEntityFeature.GENERATE_IMAGE
-        | ai_task.AITaskEntityFeature.SUPPORT_ATTACHMENTS
-    )
-    _attr_translation_key = "cloud_ai"
-    _attr_unique_id = AI_TASK_ENTITY_UNIQUE_ID
-
-    @property
-    def available(self) -> bool:
-        """Return if the entity is available."""
-        return self._cloud.is_logged_in and self._cloud.valid_subscription
-
-    async def _async_generate_data(
-        self,
-        task: ai_task.GenDataTask,
-        chat_log: conversation.ChatLog,
-    ) -> ai_task.GenDataTaskResult:
-        """Handle a generate data task."""
-        await self._async_handle_chat_log(
-            "ai_task", chat_log, task.name, task.structure
-        )
-
-        if not isinstance(chat_log.content[-1], conversation.AssistantContent):
-            raise HomeAssistantError(
-                "Last content in chat log is not an AssistantContent"
-            )
-
-        text = chat_log.content[-1].content or ""
-
-        if not task.structure:
-            return ai_task.GenDataTaskResult(
-                conversation_id=chat_log.conversation_id,
-                data=text,
-            )
-        try:
-            data = json_loads(text)
-        except JSONDecodeError as err:
-            _LOGGER.error(
-                "Failed to parse JSON response: %s. Response: %s",
-                err,
-                text,
-            )
-            raise HomeAssistantError("Error with OpenAI structured response") from err
-
-        return ai_task.GenDataTaskResult(
-            conversation_id=chat_log.conversation_id,
-            data=data,
-        )
-
-    async def _async_generate_image(
-        self,
-        task: ai_task.GenImageTask,
-        chat_log: conversation.ChatLog,
-    ) -> ai_task.GenImageTaskResult:
-        """Handle a generate image task."""
-        attachments: list[LLMImageAttachment] | None = None
-        if task.attachments:
-            attachments = await async_prepare_image_generation_attachments(
-                self.hass, task.attachments
-            )
-
-        try:
-            if attachments is None:
-                image = await self._cloud.llm.async_generate_image(
-                    prompt=task.instructions,
-                )
-            else:
-                image = await self._cloud.llm.async_edit_image(
-                    prompt=task.instructions,
-                    attachments=attachments,
-                )
-        except LLMAuthenticationError as err:
-            raise ConfigEntryAuthFailed("Cloud LLM authentication failed") from err
-        except LLMRateLimitError as err:
-            raise HomeAssistantError("Cloud LLM is rate limited") from err
-        except LLMResponseError as err:
-            raise HomeAssistantError(str(err)) from err
-        except LLMServiceError as err:
-            raise HomeAssistantError("Error talking to Cloud LLM") from err
-        except LLMError as err:
-            raise HomeAssistantError(str(err)) from err
-
-        return ai_task.GenImageTaskResult(
-            conversation_id=chat_log.conversation_id,
-            mime_type=image["mime_type"],
-            image_data=image["image_data"],
-            model=image.get("model"),
-            width=image.get("width"),
-            height=image.get("height"),
-            revised_prompt=image.get("revised_prompt"),
-        )
--- a/homeassistant/components/cloud/const.py
+++ b/homeassistant/components/cloud/const.py
@@ -91,8 +91,6 @@ DISPATCHER_REMOTE_UPDATE: SignalType[Any] = SignalType("cloud_remote_update")

 STT_ENTITY_UNIQUE_ID = "cloud-speech-to-text"
 TTS_ENTITY_UNIQUE_ID = "cloud-text-to-speech"
-AI_TASK_ENTITY_UNIQUE_ID = "cloud-ai-task"
-CONVERSATION_ENTITY_UNIQUE_ID = "cloud-conversation-agent"

 LOGIN_MFA_TIMEOUT = 60

--- a/homeassistant/components/cloud/conversation.py
+++ b/homeassistant/components/cloud/conversation.py
@@ -1,75 +0,0 @@
-"""Conversation support for Home Assistant Cloud."""
-
-from __future__ import annotations
-
-from typing import Literal
-
-from hass_nabucasa.llm import LLMError
-
-from homeassistant.components import conversation
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import MATCH_ALL
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers import llm
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-
-from .const import CONVERSATION_ENTITY_UNIQUE_ID, DATA_CLOUD, DOMAIN
-from .entity import BaseCloudLLMEntity
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    config_entry: ConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up the Home Assistant Cloud conversation entity."""
-    cloud = hass.data[DATA_CLOUD]
-    try:
-        await cloud.llm.async_ensure_token()
-    except LLMError:
-        return
-
-    async_add_entities([CloudConversationEntity(cloud, config_entry)])
-
-
-class CloudConversationEntity(
-    conversation.ConversationEntity,
-    BaseCloudLLMEntity,
-):
-    """Home Assistant Cloud conversation agent."""
-
-    _attr_has_entity_name = True
-    _attr_name = "Home Assistant Cloud"
-    _attr_translation_key = "cloud_conversation"
-    _attr_unique_id = CONVERSATION_ENTITY_UNIQUE_ID
-    _attr_supported_features = conversation.ConversationEntityFeature.CONTROL
-
-    @property
-    def available(self) -> bool:
-        """Return if the entity is available."""
-        return self._cloud.is_logged_in and self._cloud.valid_subscription
-
-    @property
-    def supported_languages(self) -> list[str] | Literal["*"]:
-        """Return a list of supported languages."""
-        return MATCH_ALL
-
-    async def _async_handle_message(
-        self,
-        user_input: conversation.ConversationInput,
-        chat_log: conversation.ChatLog,
-    ) -> conversation.ConversationResult:
-        """Process a user input."""
-        try:
-            await chat_log.async_provide_llm_data(
-                user_input.as_llm_context(DOMAIN),
-                llm.LLM_API_ASSIST,
-                None,
-                user_input.extra_system_prompt,
-            )
-        except conversation.ConverseError as err:
-            return err.as_conversation_result()
-
-        await self._async_handle_chat_log("conversation", chat_log)
-
-        return conversation.async_get_result_from_chat_log(user_input, chat_log)
--- a/homeassistant/components/cloud/entity.py
+++ b/homeassistant/components/cloud/entity.py
@@ -1,615 +0,0 @@
-"""Helpers for cloud LLM chat handling."""
-
-import base64
-from collections.abc import AsyncGenerator, Callable, Iterable
-from enum import Enum
-import json
-import logging
-import re
-from typing import Any, Literal, cast
-
-from hass_nabucasa import Cloud
-from hass_nabucasa.llm import (
-    LLMAuthenticationError,
-    LLMError,
-    LLMRateLimitError,
-    LLMResponseError,
-    LLMServiceError,
-)
-from litellm import (
-    ResponseFunctionToolCall,
-    ResponseInputParam,
-    ResponsesAPIStreamEvents,
-)
-from openai.types.responses import (
-    FunctionToolParam,
-    ResponseInputItemParam,
-    ResponseReasoningItem,
-    ToolParam,
-    WebSearchToolParam,
-)
-from openai.types.responses.response_input_param import (
-    ImageGenerationCall as ImageGenerationCallParam,
-)
-from openai.types.responses.response_output_item import ImageGenerationCall
-import voluptuous as vol
-from voluptuous_openapi import convert
-
-from homeassistant.components import conversation
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.exceptions import ConfigEntryAuthFailed, HomeAssistantError
-from homeassistant.helpers import llm
-from homeassistant.helpers.entity import Entity
-from homeassistant.util import slugify
-
-from .client import CloudClient
-
-_LOGGER = logging.getLogger(__name__)
-
-_MAX_TOOL_ITERATIONS = 10
-
-
-class ResponseItemType(str, Enum):
-    """Response item types."""
-
-    FUNCTION_CALL = "function_call"
-    MESSAGE = "message"
-    REASONING = "reasoning"
-    WEB_SEARCH_CALL = "web_search_call"
-    IMAGE = "image"
-
-
-def _convert_content_to_param(
-    chat_content: Iterable[conversation.Content],
-) -> ResponseInputParam:
-    """Convert any native chat message for this agent to the native format."""
-    messages: ResponseInputParam = []
-    reasoning_summary: list[str] = []
-    web_search_calls: dict[str, dict[str, Any]] = {}
-
-    for content in chat_content:
-        if isinstance(content, conversation.ToolResultContent):
-            if (
-                content.tool_name == "web_search_call"
-                and content.tool_call_id in web_search_calls
-            ):
-                web_search_call = web_search_calls.pop(content.tool_call_id)
-                web_search_call["status"] = content.tool_result.get(
-                    "status", "completed"
-                )
-                messages.append(cast("ResponseInputItemParam", web_search_call))
-            else:
-                messages.append(
-                    {
-                        "type": "function_call_output",
-                        "call_id": content.tool_call_id,
-                        "output": json.dumps(content.tool_result),
-                    }
-                )
-            continue
-
-        if content.content:
-            role: Literal["user", "assistant", "system", "developer"] = content.role
-            if role == "system":
-                role = "developer"
-            messages.append(
-                {"type": "message", "role": role, "content": content.content}
-            )
-
-        if isinstance(content, conversation.AssistantContent):
-            if content.tool_calls:
-                for tool_call in content.tool_calls:
-                    if (
-                        tool_call.external
-                        and tool_call.tool_name == "web_search_call"
-                        and "action" in tool_call.tool_args
-                    ):
-                        web_search_calls[tool_call.id] = {
-                            "type": "web_search_call",
-                            "id": tool_call.id,
-                            "action": tool_call.tool_args["action"],
-                            "status": "completed",
-                        }
-                    else:
-                        messages.append(
-                            {
-                                "type": "function_call",
-                                "name": tool_call.tool_name,
-                                "arguments": json.dumps(tool_call.tool_args),
-                                "call_id": tool_call.id,
-                            }
-                        )
-
-            if content.thinking_content:
-                reasoning_summary.append(content.thinking_content)
-
-            if isinstance(content.native, ResponseReasoningItem):
-                messages.append(
-                    {
-                        "type": "reasoning",
-                        "id": content.native.id,
-                        "summary": (
-                            [
-                                {
-                                    "type": "summary_text",
-                                    "text": summary,
-                                }
-                                for summary in reasoning_summary
-                            ]
-                            if content.thinking_content
-                            else []
-                        ),
-                        "encrypted_content": content.native.encrypted_content,
-                    }
-                )
-                reasoning_summary = []
-
-            elif isinstance(content.native, ImageGenerationCall):
-                messages.append(
-                    cast(ImageGenerationCallParam, content.native.to_dict())
-                )
-
-    return messages
-
-
-def _format_tool(
-    tool: llm.Tool,
-    custom_serializer: Callable[[Any], Any] | None,
-) -> ToolParam:
-    """Format a Home Assistant tool for the OpenAI Responses API."""
-    parameters = convert(tool.parameters, custom_serializer=custom_serializer)
-
-    spec: FunctionToolParam = {
-        "type": "function",
-        "name": tool.name,
-        "strict": False,
-        "description": tool.description,
-        "parameters": parameters,
-    }
-
-    return spec
-
-
-def _adjust_schema(schema: dict[str, Any]) -> None:
-    """Adjust the schema to be compatible with OpenAI API."""
-    if schema["type"] == "object":
-        schema.setdefault("strict", True)
-        schema.setdefault("additionalProperties", False)
-        if "properties" not in schema:
-            return
-
-        if "required" not in schema:
-            schema["required"] = []
-
-        # Ensure all properties are required
-        for prop, prop_info in schema["properties"].items():
-            _adjust_schema(prop_info)
-            if prop not in schema["required"]:
-                prop_info["type"] = [prop_info["type"], "null"]
-                schema["required"].append(prop)
-
-    elif schema["type"] == "array":
-        if "items" not in schema:
-            return
-
-        _adjust_schema(schema["items"])
-
-
-def _format_structured_output(
-    schema: vol.Schema, llm_api: llm.APIInstance | None
-) -> dict[str, Any]:
-    """Format the schema to be compatible with OpenAI API."""
-    result: dict[str, Any] = convert(
-        schema,
-        custom_serializer=(
-            llm_api.custom_serializer if llm_api else llm.selector_serializer
-        ),
-    )
-
-    _ensure_schema_constraints(result)
-
-    return result
-
-
-def _ensure_schema_constraints(schema: dict[str, Any]) -> None:
-    """Ensure generated schemas match the Responses API expectations."""
-    schema_type = schema.get("type")
-
-    if schema_type == "object":
-        schema.setdefault("additionalProperties", False)
-        properties = schema.get("properties")
-        if isinstance(properties, dict):
-            for property_schema in properties.values():
-                if isinstance(property_schema, dict):
-                    _ensure_schema_constraints(property_schema)
-    elif schema_type == "array":
-        items = schema.get("items")
-        if isinstance(items, dict):
-            _ensure_schema_constraints(items)
-
-
-# Borrowed and adapted from openai_conversation component
-async def _transform_stream(  # noqa: C901 - This is complex, but better to have it in one place
-    chat_log: conversation.ChatLog,
-    stream: Any,
-    remove_citations: bool = False,
-) -> AsyncGenerator[
-    conversation.AssistantContentDeltaDict | conversation.ToolResultContentDeltaDict
-]:
-    """Transform stream result into HA format."""
-    last_summary_index = None
-    last_role: Literal["assistant", "tool_result"] | None = None
-    current_tool_call: ResponseFunctionToolCall | None = None
-
-    # Non-reasoning models don't follow our request to remove citations, so we remove
-    # them manually here. They always follow the same pattern: the citation is always
-    # in parentheses in Markdown format, the citation is always in a single delta event,
-    # and sometimes the closing parenthesis is split into a separate delta event.
-    remove_parentheses: bool = False
-    citation_regexp = re.compile(r"\(\[([^\]]+)\]\((https?:\/\/[^\)]+)\)")
-
-    async for event in stream:
-        event_type = getattr(event, "type", None)
-        event_item = getattr(event, "item", None)
-        event_item_type = getattr(event_item, "type", None) if event_item else None
-
-        _LOGGER.debug(
-            "Event[%s] | item: %s",
-            event_type,
-            event_item_type,
-        )
-
-        if event_type == ResponsesAPIStreamEvents.OUTPUT_ITEM_ADDED:
-            # Detect function_call even when it's a BaseLiteLLMOpenAIResponseObject
-            if event_item_type == ResponseItemType.FUNCTION_CALL:
-                # OpenAI has tool calls as individual events
-                # while HA puts tool calls inside the assistant message.
-                # We turn them into individual assistant content for HA
-                # to ensure that tools are called as soon as possible.
-                yield {"role": "assistant"}
-                last_role = "assistant"
-                last_summary_index = None
-                current_tool_call = cast(ResponseFunctionToolCall, event.item)
-            elif (
-                event_item_type == ResponseItemType.MESSAGE
-                or (
-                    event_item_type == ResponseItemType.REASONING
-                    and last_summary_index is not None
-                )  # Subsequent ResponseReasoningItem
-                or last_role != "assistant"
-            ):
-                yield {"role": "assistant"}
-                last_role = "assistant"
-                last_summary_index = None
-
-        elif event_type == ResponsesAPIStreamEvents.OUTPUT_ITEM_DONE:
-            if event_item_type == ResponseItemType.REASONING:
-                encrypted_content = getattr(event.item, "encrypted_content", None)
-                summary = getattr(event.item, "summary", []) or []
-
-                yield {
-                    "native": ResponseReasoningItem(
-                        type="reasoning",
-                        id=event.item.id,
-                        summary=[],
-                        encrypted_content=encrypted_content,
-                    )
-                }
-
-                last_summary_index = len(summary) - 1 if summary else None
-            elif event_item_type == ResponseItemType.WEB_SEARCH_CALL:
-                action = getattr(event.item, "action", None)
-                if isinstance(action, dict):
-                    action_dict = action
-                elif action is not None:
-                    action_dict = action.to_dict()
-                else:
-                    action_dict = {}
-                yield {
-                    "tool_calls": [
-                        llm.ToolInput(
-                            id=event.item.id,
-                            tool_name="web_search_call",
-                            tool_args={"action": action_dict},
-                            external=True,
-                        )
-                    ]
-                }
-                yield {
-                    "role": "tool_result",
-                    "tool_call_id": event.item.id,
-                    "tool_name": "web_search_call",
-                    "tool_result": {"status": event.item.status},
-                }
-                last_role = "tool_result"
-            elif event_item_type == ResponseItemType.IMAGE:
-                yield {"native": event.item}
-                last_summary_index = -1  # Trigger new assistant message on next turn
-
-        elif event_type == ResponsesAPIStreamEvents.OUTPUT_TEXT_DELTA:
-            data = event.delta
-            if remove_parentheses:
-                data = data.removeprefix(")")
-                remove_parentheses = False
-            elif remove_citations and (match := citation_regexp.search(data)):
-                match_start, match_end = match.span()
-                # remove leading space if any
-                if data[match_start - 1 : match_start] == " ":
-                    match_start -= 1
-                # remove closing parenthesis:
-                if data[match_end : match_end + 1] == ")":
-                    match_end += 1
-                else:
-                    remove_parentheses = True
-                data = data[:match_start] + data[match_end:]
-            if data:
-                yield {"content": data}
-
-        elif event_type == ResponsesAPIStreamEvents.REASONING_SUMMARY_TEXT_DELTA:
-            # OpenAI can output several reasoning summaries
-            # in a single ResponseReasoningItem. We split them as separate
-            # AssistantContent messages. Only last of them will have
-            # the reasoning `native` field set.
-            if (
-                last_summary_index is not None
-                and event.summary_index != last_summary_index
-            ):
-                yield {"role": "assistant"}
-                last_role = "assistant"
-            last_summary_index = event.summary_index
-            yield {"thinking_content": event.delta}
-
-        elif event_type == ResponsesAPIStreamEvents.FUNCTION_CALL_ARGUMENTS_DELTA:
-            if current_tool_call is not None:
-                current_tool_call.arguments += event.delta
-
-        elif event_type == ResponsesAPIStreamEvents.WEB_SEARCH_CALL_SEARCHING:
-            yield {"role": "assistant"}
-
-        elif event_type == ResponsesAPIStreamEvents.FUNCTION_CALL_ARGUMENTS_DONE:
-            if current_tool_call is not None:
-                current_tool_call.status = "completed"
-
-                raw_args = json.loads(current_tool_call.arguments)
-                for key in ("area", "floor"):
-                    if key in raw_args and not raw_args[key]:
-                        # Remove keys that are "" or None
-                        raw_args.pop(key, None)
-
-                yield {
-                    "tool_calls": [
-                        llm.ToolInput(
-                            id=current_tool_call.call_id,
-                            tool_name=current_tool_call.name,
-                            tool_args=raw_args,
-                        )
-                    ]
-                }
-
-        elif event_type == ResponsesAPIStreamEvents.RESPONSE_COMPLETED:
-            if event.response.usage is not None:
-                chat_log.async_trace(
-                    {
-                        "stats": {
-                            "input_tokens": event.response.usage.input_tokens,
-                            "output_tokens": event.response.usage.output_tokens,
-                        }
-                    }
-                )
-
-        elif event_type == ResponsesAPIStreamEvents.RESPONSE_INCOMPLETE:
-            if event.response.usage is not None:
-                chat_log.async_trace(
-                    {
-                        "stats": {
-                            "input_tokens": event.response.usage.input_tokens,
-                            "output_tokens": event.response.usage.output_tokens,
-                        }
-                    }
-                )
-
-            if (
-                event.response.incomplete_details
-                and event.response.incomplete_details.reason
-            ):
-                reason: str = event.response.incomplete_details.reason
-            else:
-                reason = "unknown reason"
-
-            if reason == "max_output_tokens":
-                reason = "max output tokens reached"
-            elif reason == "content_filter":
-                reason = "content filter triggered"
-
-            raise HomeAssistantError(f"OpenAI response incomplete: {reason}")
-
-        elif event_type == ResponsesAPIStreamEvents.RESPONSE_FAILED:
-            if event.response.usage is not None:
-                chat_log.async_trace(
-                    {
-                        "stats": {
-                            "input_tokens": event.response.usage.input_tokens,
-                            "output_tokens": event.response.usage.output_tokens,
-                        }
-                    }
-                )
-            reason = "unknown reason"
-            if event.response.error is not None:
-                reason = event.response.error.message
-            raise HomeAssistantError(f"OpenAI response failed: {reason}")
-
-        elif event_type == ResponsesAPIStreamEvents.ERROR:
-            raise HomeAssistantError(f"OpenAI response error: {event.message}")
-
-
-class BaseCloudLLMEntity(Entity):
-    """Cloud LLM conversation agent."""
-
-    def __init__(self, cloud: Cloud[CloudClient], config_entry: ConfigEntry) -> None:
-        """Initialize the entity."""
-        self._cloud = cloud
-        self._entry = config_entry
-
-    async def _prepare_chat_for_generation(
-        self,
-        chat_log: conversation.ChatLog,
-        messages: ResponseInputParam,
-        response_format: dict[str, Any] | None = None,
-    ) -> dict[str, Any]:
-        """Prepare kwargs for Cloud LLM from the chat log."""
-
-        last_content: Any = chat_log.content[-1]
-        if last_content.role == "user" and last_content.attachments:
-            files = await self._async_prepare_files_for_prompt(last_content.attachments)
-            current_content = last_content.content
-            last_content = [*(current_content or []), *files]
-
-        tools: list[ToolParam] = []
-        tool_choice: str | None = None
-
-        if chat_log.llm_api:
-            ha_tools: list[ToolParam] = [
-                _format_tool(tool, chat_log.llm_api.custom_serializer)
-                for tool in chat_log.llm_api.tools
-            ]
-
-            if ha_tools:
-                if not chat_log.unresponded_tool_results:
-                    tools = ha_tools
-                    tool_choice = "auto"
-                else:
-                    tools = []
-                    tool_choice = "none"
-
-        web_search = WebSearchToolParam(
-            type="web_search",
-            search_context_size="medium",
-        )
-        tools.append(web_search)
-
-        response_kwargs: dict[str, Any] = {
-            "messages": messages,
-            "conversation_id": chat_log.conversation_id,
-        }
-
-        if response_format is not None:
-            response_kwargs["response_format"] = response_format
-        if tools is not None:
-            response_kwargs["tools"] = tools
-        if tool_choice is not None:
-            response_kwargs["tool_choice"] = tool_choice
-
-        response_kwargs["stream"] = True
-
-        return response_kwargs
-
-    async def _async_prepare_files_for_prompt(
-        self,
-        attachments: list[conversation.Attachment],
-    ) -> list[dict[str, Any]]:
-        """Prepare files for multimodal prompts."""
-
-        def prepare() -> list[dict[str, Any]]:
-            content: list[dict[str, Any]] = []
-            for attachment in attachments:
-                mime_type = attachment.mime_type
-                path = attachment.path
-                if not path.exists():
-                    raise HomeAssistantError(f"`{path}` does not exist")
-
-                data = base64.b64encode(path.read_bytes()).decode("utf-8")
-                if mime_type and mime_type.startswith("image/"):
-                    content.append(
-                        {
-                            "type": "input_image",
-                            "image_url": f"data:{mime_type};base64,{data}",
-                            "detail": "auto",
-                        }
-                    )
-                elif mime_type and mime_type.startswith("application/pdf"):
-                    content.append(
-                        {
-                            "type": "input_file",
-                            "filename": str(path.name),
-                            "file_data": f"data:{mime_type};base64,{data}",
-                        }
-                    )
-                else:
-                    raise HomeAssistantError(
-                        "Only images and PDF are currently supported as attachments"
-                    )
-
-            return content
-
-        return await self.hass.async_add_executor_job(prepare)
-
-    async def _async_handle_chat_log(
-        self,
-        type: Literal["ai_task", "conversation"],
-        chat_log: conversation.ChatLog,
-        structure_name: str | None = None,
-        structure: vol.Schema | None = None,
-    ) -> None:
-        """Generate a response for the chat log."""
-
-        for _ in range(_MAX_TOOL_ITERATIONS):
-            response_format: dict[str, Any] | None = None
-            if structure and structure_name:
-                response_format = {
-                    "type": "json_schema",
-                    "json_schema": {
-                        "name": slugify(structure_name),
-                        "schema": _format_structured_output(
-                            structure, chat_log.llm_api
-                        ),
-                        "strict": True,
-                    },
-                }
-
-            messages = _convert_content_to_param(chat_log.content)
-
-            response_kwargs = await self._prepare_chat_for_generation(
-                chat_log,
-                messages,
-                response_format,
-            )
-
-            try:
-                if type == "conversation":
-                    raw_stream = await self._cloud.llm.async_process_conversation(
-                        **response_kwargs,
-                    )
-                else:
-                    raw_stream = await self._cloud.llm.async_generate_data(
-                        **response_kwargs,
-                    )
-
-                messages.extend(
-                    _convert_content_to_param(
-                        [
-                            content
-                            async for content in chat_log.async_add_delta_content_stream(
-                                self.entity_id,
-                                _transform_stream(
-                                    chat_log,
-                                    raw_stream,
-                                    True,
-                                ),
-                            )
-                        ]
-                    )
-                )
-
-            except LLMAuthenticationError as err:
-                raise ConfigEntryAuthFailed("Cloud LLM authentication failed") from err
-            except LLMRateLimitError as err:
-                raise HomeAssistantError("Cloud LLM is rate limited") from err
-            except LLMResponseError as err:
-                raise HomeAssistantError(str(err)) from err
-            except LLMServiceError as err:
-                raise HomeAssistantError("Error talking to Cloud LLM") from err
-            except LLMError as err:
-                raise HomeAssistantError(str(err)) from err
-
-            if not chat_log.unresponded_tool_results:
-                break
--- a/homeassistant/components/cloud/helpers.py
+++ b/homeassistant/components/cloud/helpers.py
@@ -1,7 +1,5 @@
 """Helpers for the cloud component."""

-from __future__ import annotations
-
 from collections import deque
 import logging

--- a/homeassistant/components/cloud/manifest.json
+++ b/homeassistant/components/cloud/manifest.json
@@ -13,6 +13,6 @@
  "integration_type": "system",
  "iot_class": "cloud_push",
  "loggers": ["acme", "hass_nabucasa", "snitun"],
-  "requirements": ["hass-nabucasa==1.6.1"],
+  "requirements": ["hass-nabucasa==1.5.1"],
  "single_config_entry": true
 }
--- a/homeassistant/components/cloud/strings.json
+++ b/homeassistant/components/cloud/strings.json
@@ -1,11 +1,4 @@
 {
-  "entity": {
-    "ai_task": {
-      "cloud_ai": {
-        "name": "Home Assistant Cloud AI"
-      }
-    }
-  },
  "exceptions": {
    "backup_size_too_large": {
      "message": "The backup size of {size}GB is too large to be uploaded to Home Assistant Cloud."
--- a/homeassistant/components/config/area_registry.py
+++ b/homeassistant/components/config/area_registry.py
@@ -18,7 +18,6 @@ def async_setup(hass: HomeAssistant) -> bool:
    websocket_api.async_register_command(hass, websocket_create_area)
    websocket_api.async_register_command(hass, websocket_delete_area)
    websocket_api.async_register_command(hass, websocket_update_area)
-    websocket_api.async_register_command(hass, websocket_reorder_areas)
    return True


@@ -146,27 +145,3 @@ def websocket_update_area(
        connection.send_error(msg["id"], "invalid_info", str(err))
    else:
        connection.send_result(msg["id"], entry.json_fragment)
-
-
-@websocket_api.websocket_command(
-    {
-        vol.Required("type"): "config/area_registry/reorder",
-        vol.Required("area_ids"): [str],
-    }
-)
-@websocket_api.require_admin
-@callback
-def websocket_reorder_areas(
-    hass: HomeAssistant,
-    connection: websocket_api.ActiveConnection,
-    msg: dict[str, Any],
-) -> None:
-    """Handle reorder areas websocket command."""
-    registry = ar.async_get(hass)
-
-    try:
-        registry.async_reorder(msg["area_ids"])
-    except ValueError as err:
-        connection.send_error(msg["id"], websocket_api.ERR_INVALID_FORMAT, str(err))
-    else:
-        connection.send_result(msg["id"])
--- a/homeassistant/components/config/floor_registry.py
+++ b/homeassistant/components/config/floor_registry.py
@@ -18,7 +18,6 @@ def async_setup(hass: HomeAssistant) -> bool:
    websocket_api.async_register_command(hass, websocket_create_floor)
    websocket_api.async_register_command(hass, websocket_delete_floor)
    websocket_api.async_register_command(hass, websocket_update_floor)
-    websocket_api.async_register_command(hass, websocket_reorder_floors)
    return True


@@ -128,28 +127,6 @@ def websocket_update_floor(
        connection.send_result(msg["id"], _entry_dict(entry))


-@websocket_api.websocket_command(
-    {
-        vol.Required("type"): "config/floor_registry/reorder",
-        vol.Required("floor_ids"): [str],
-    }
-)
-@websocket_api.require_admin
-@callback
-def websocket_reorder_floors(
-    hass: HomeAssistant, connection: ActiveConnection, msg: dict[str, Any]
-) -> None:
-    """Handle reorder floors websocket command."""
-    registry = fr.async_get(hass)
-
-    try:
-        registry.async_reorder(msg["floor_ids"])
-    except ValueError as err:
-        connection.send_error(msg["id"], websocket_api.ERR_INVALID_FORMAT, str(err))
-    else:
-        connection.send_result(msg["id"])
-
-
@callback
 def _entry_dict(entry: FloorEntry) -> dict[str, Any]:
    """Convert entry to API format."""
--- a/homeassistant/components/conversation/chat_log.py
+++ b/homeassistant/components/conversation/chat_log.py
@@ -7,7 +7,6 @@ from collections.abc import AsyncGenerator, AsyncIterable, Callable, Generator
 from contextlib import contextmanager
 from contextvars import ContextVar
 from dataclasses import asdict, dataclass, field, replace
-from datetime import datetime
 import logging
 from pathlib import Path
 from typing import Any, Literal, TypedDict, cast
@@ -17,18 +16,14 @@ import voluptuous as vol
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError, TemplateError
 from homeassistant.helpers import chat_session, frame, intent, llm, template
-from homeassistant.util.dt import utcnow
 from homeassistant.util.hass_dict import HassKey
 from homeassistant.util.json import JsonObjectType

 from . import trace
-from .const import ChatLogEventType
 from .models import ConversationInput, ConversationResult

 DATA_CHAT_LOGS: HassKey[dict[str, ChatLog]] = HassKey("conversation_chat_logs")
-DATA_SUBSCRIPTIONS: HassKey[
-    list[Callable[[str, ChatLogEventType, dict[str, Any]], None]]
-] = HassKey("conversation_chat_log_subscriptions")
+
 LOGGER = logging.getLogger(__name__)

 current_chat_log: ContextVar[ChatLog | None] = ContextVar(
@@ -36,40 +31,6 @@ current_chat_log: ContextVar[ChatLog | None] = ContextVar(
 )


-@callback
-def async_subscribe_chat_logs(
-    hass: HomeAssistant,
-    callback_func: Callable[[str, ChatLogEventType, dict[str, Any]], None],
-) -> Callable[[], None]:
-    """Subscribe to all chat logs."""
-    subscriptions = hass.data.get(DATA_SUBSCRIPTIONS)
-    if subscriptions is None:
-        subscriptions = []
-        hass.data[DATA_SUBSCRIPTIONS] = subscriptions
-
-    subscriptions.append(callback_func)
-
-    @callback
-    def unsubscribe() -> None:
-        """Unsubscribe from chat logs."""
-        subscriptions.remove(callback_func)
-
-    return unsubscribe
-
-
-@callback
-def _async_notify_subscribers(
-    hass: HomeAssistant,
-    conversation_id: str,
-    event_type: ChatLogEventType,
-    data: dict[str, Any],
-) -> None:
-    """Notify subscribers of a chat log event."""
-    if subscriptions := hass.data.get(DATA_SUBSCRIPTIONS):
-        for callback_func in subscriptions:
-            callback_func(conversation_id, event_type, data)
-
-
@contextmanager
 def async_get_chat_log(
    hass: HomeAssistant,
@@ -102,8 +63,6 @@ def async_get_chat_log(
        all_chat_logs = {}
        hass.data[DATA_CHAT_LOGS] = all_chat_logs

-    is_new_log = session.conversation_id not in all_chat_logs
-
    if chat_log := all_chat_logs.get(session.conversation_id):
        chat_log = replace(chat_log, content=chat_log.content.copy())
    else:
@@ -112,15 +71,6 @@ def async_get_chat_log(
    if chat_log_delta_listener:
        chat_log.delta_listener = chat_log_delta_listener

-    # Fire CREATED event for new chat logs before any content is added
-    if is_new_log:
-        _async_notify_subscribers(
-            hass,
-            session.conversation_id,
-            ChatLogEventType.CREATED,
-            {"chat_log": chat_log.as_dict()},
-        )
-
    if user_input is not None:
        chat_log.async_add_user_content(UserContent(content=user_input.text))

@@ -134,28 +84,14 @@ def async_get_chat_log(
        LOGGER.debug(
            "Chat Log opened but no assistant message was added, ignoring update"
        )
-        # If this was a new log but nothing was added, fire DELETED to clean up
-        if is_new_log:
-            _async_notify_subscribers(
-                hass,
-                session.conversation_id,
-                ChatLogEventType.DELETED,
-                {},
-            )
        return

-    if is_new_log:
+    if session.conversation_id not in all_chat_logs:

        @callback
        def do_cleanup() -> None:
            """Handle cleanup."""
            all_chat_logs.pop(session.conversation_id)
-            _async_notify_subscribers(
-                hass,
-                session.conversation_id,
-                ChatLogEventType.DELETED,
-                {},
-            )

        session.async_on_cleanup(do_cleanup)

@@ -164,16 +100,6 @@ def async_get_chat_log(

    all_chat_logs[session.conversation_id] = chat_log

-    # For new logs, CREATED was already fired before content was added
-    # For existing logs, fire UPDATED
-    if not is_new_log:
-        _async_notify_subscribers(
-            hass,
-            session.conversation_id,
-            ChatLogEventType.UPDATED,
-            {"chat_log": chat_log.as_dict()},
-        )
-

 class ConverseError(HomeAssistantError):
    """Error during initialization of conversation.
@@ -203,15 +129,6 @@ class SystemContent:

    role: Literal["system"] = field(init=False, default="system")
    content: str
-    created: datetime = field(init=False, default_factory=utcnow)
-
-    def as_dict(self) -> dict[str, Any]:
-        """Return a dictionary representation of the content."""
-        return {
-            "role": self.role,
-            "content": self.content,
-            "created": self.created,
-        }


@dataclass(frozen=True)
@@ -221,20 +138,6 @@ class UserContent:
    role: Literal["user"] = field(init=False, default="user")
    content: str
    attachments: list[Attachment] | None = field(default=None)
-    created: datetime = field(init=False, default_factory=utcnow)
-
-    def as_dict(self) -> dict[str, Any]:
-        """Return a dictionary representation of the content."""
-        result: dict[str, Any] = {
-            "role": self.role,
-            "content": self.content,
-            "created": self.created,
-        }
-        if self.attachments:
-            result["attachments"] = [
-                attachment.as_dict() for attachment in self.attachments
-            ]
-        return result


@dataclass(frozen=True)
@@ -250,14 +153,6 @@ class Attachment:
    path: Path
    """Path to the attachment on disk."""

-    def as_dict(self) -> dict[str, Any]:
-        """Return a dictionary representation of the attachment."""
-        return {
-            "media_content_id": self.media_content_id,
-            "mime_type": self.mime_type,
-            "path": str(self.path),
-        }
-

@dataclass(frozen=True)
 class AssistantContent:
@@ -269,22 +164,6 @@ class AssistantContent:
    thinking_content: str | None = None
    tool_calls: list[llm.ToolInput] | None = None
    native: Any = None
-    created: datetime = field(init=False, default_factory=utcnow)
-
-    def as_dict(self) -> dict[str, Any]:
-        """Return a dictionary representation of the content."""
-        result: dict[str, Any] = {
-            "role": self.role,
-            "agent_id": self.agent_id,
-            "created": self.created,
-        }
-        if self.content:
-            result["content"] = self.content
-        if self.thinking_content:
-            result["thinking_content"] = self.thinking_content
-        if self.tool_calls:
-            result["tool_calls"] = self.tool_calls
-        return result


@dataclass(frozen=True)
@@ -296,18 +175,6 @@ class ToolResultContent:
    tool_call_id: str
    tool_name: str
    tool_result: JsonObjectType
-    created: datetime = field(init=False, default_factory=utcnow)
-
-    def as_dict(self) -> dict[str, Any]:
-        """Return a dictionary representation of the content."""
-        return {
-            "role": self.role,
-            "agent_id": self.agent_id,
-            "tool_call_id": self.tool_call_id,
-            "tool_name": self.tool_name,
-            "tool_result": self.tool_result,
-            "created": self.created,
-        }


 type Content = SystemContent | UserContent | AssistantContent | ToolResultContent
@@ -343,16 +210,6 @@ class ChatLog:
    llm_api: llm.APIInstance | None = None
    delta_listener: Callable[[ChatLog, dict], None] | None = None
    llm_input_provided_index = 0
-    created: datetime = field(init=False, default_factory=utcnow)
-
-    def as_dict(self) -> dict[str, Any]:
-        """Return a dictionary representation of the chat log."""
-        return {
-            "conversation_id": self.conversation_id,
-            "continue_conversation": self.continue_conversation,
-            "content": [c.as_dict() for c in self.content],
-            "created": self.created,
-        }

    @property
    def continue_conversation(self) -> bool:
@@ -384,12 +241,6 @@ class ChatLog:
        """Add user content to the log."""
        LOGGER.debug("Adding user content: %s", content)
        self.content.append(content)
-        _async_notify_subscribers(
-            self.hass,
-            self.conversation_id,
-            ChatLogEventType.CONTENT_ADDED,
-            {"content": content.as_dict()},
-        )

    @callback
    def async_add_assistant_content_without_tools(
@@ -408,12 +259,6 @@ class ChatLog:
        ):
            raise ValueError("Non-external tool calls not allowed")
        self.content.append(content)
-        _async_notify_subscribers(
-            self.hass,
-            self.conversation_id,
-            ChatLogEventType.CONTENT_ADDED,
-            {"content": content.as_dict()},
-        )

    async def async_add_assistant_content(
        self,
@@ -472,14 +317,6 @@ class ChatLog:
                tool_result=tool_result,
            )
            self.content.append(response_content)
-            _async_notify_subscribers(
-                self.hass,
-                self.conversation_id,
-                ChatLogEventType.CONTENT_ADDED,
-                {
-                    "content": response_content.as_dict(),
-                },
-            )
            yield response_content

    async def async_add_delta_content_stream(
@@ -756,12 +593,6 @@ class ChatLog:
        self.llm_api = llm_api
        self.extra_system_prompt = extra_system_prompt
        self.content[0] = SystemContent(content=prompt)
-        _async_notify_subscribers(
-            self.hass,
-            self.conversation_id,
-            ChatLogEventType.UPDATED,
-            {"chat_log": self.as_dict()},
-        )

        LOGGER.debug("Prompt: %s", self.content)
        LOGGER.debug("Tools: %s", self.llm_api.tools if self.llm_api else None)
--- a/homeassistant/components/conversation/const.py
+++ b/homeassistant/components/conversation/const.py
@@ -2,7 +2,7 @@

 from __future__ import annotations

-from enum import IntFlag, StrEnum
+from enum import IntFlag
 from typing import TYPE_CHECKING

 from homeassistant.util.hass_dict import HassKey
@@ -34,13 +34,3 @@ class ConversationEntityFeature(IntFlag):

 METADATA_CUSTOM_SENTENCE = "hass_custom_sentence"
 METADATA_CUSTOM_FILE = "hass_custom_file"
-
-
-class ChatLogEventType(StrEnum):
-    """Chat log event type."""
-
-    INITIAL_STATE = "initial_state"
-    CREATED = "created"
-    UPDATED = "updated"
-    DELETED = "deleted"
-    CONTENT_ADDED = "content_added"
--- a/Show More
+++ b/Show More