Add continue statements for both error cases in IP ban loading

Co-authored-by: frenck <195327+frenck@users.noreply.github.com>
Initial plan
2025-11-27 11:38:01 +00:00 · 2025-11-25 10:33:17 +00:00 · 2025-11-25 10:30:05 +00:00 · 2025-11-25 09:44:17 +00:00 · 2025-11-25 09:34:11 +01:00 · 2025-11-25 09:18:02 +01:00
1208 changed files with 104306 additions and 25807 deletions
--- a/.github/workflows/builder.yml
+++ b/.github/workflows/builder.yml
@@ -27,12 +27,12 @@ jobs:
      publish: ${{ steps.version.outputs.publish }}
    steps:
      - name: Checkout the repository
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
        with:
          fetch-depth: 0

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

@@ -88,13 +88,9 @@ jobs:
      fail-fast: false
      matrix:
        arch: ${{ fromJson(needs.init.outputs.architectures) }}
-        exclude:
-          - arch: armv7
-          - arch: armhf
-          - arch: i386
    steps:
      - name: Checkout the repository
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0

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

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

@@ -227,7 +223,7 @@ jobs:
          - green
    steps:
      - name: Checkout the repository
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0

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

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

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

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

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

      - name: Login to GitHub Container Registry
        uses: docker/login-action@5e57cd118135c172c3672efd75eb46360885c0ef # v3.6.0
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -37,7 +37,7 @@ on:
        type: boolean

 env:
-  CACHE_VERSION: 1
+  CACHE_VERSION: 2
  UV_CACHE_VERSION: 1
  MYPY_CACHE_VERSION: 1
  HA_SHORT_VERSION: "2025.12"
@@ -99,7 +99,7 @@ jobs:
    steps:
      - &checkout
        name: Check out code from GitHub
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
      - 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@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6.0.0
+        uses: &actions-setup-python actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
        with:
          python-version: ${{ env.DEFAULT_PYTHON }}
          check-latest: true
@@ -622,7 +622,7 @@ jobs:
    steps:
      - *checkout
      - name: Dependency review
-        uses: actions/dependency-review-action@40c09b7dc99638e5ddb0bfd91c1673effc064d8a # v4.8.1
+        uses: actions/dependency-review-action@3c4e3dcb1aa7874d2c16be7d79418e9b7efd6261 # v4.8.2
        with:
          license-check: false # We use our own license audit checks

--- 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@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0

      - name: Initialize CodeQL
-        uses: github/codeql-action/init@0499de31b99561a6d14a36a5f662c2a54f91beee # v4.31.2
+        uses: github/codeql-action/init@fdbfb4d2750291e159f0156def62b853c2798ca2 # v4.31.5
        with:
          languages: python

      - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@0499de31b99561a6d14a36a5f662c2a54f91beee # v4.31.2
+        uses: github/codeql-action/analyze@fdbfb4d2750291e159f0156def62b853c2798ca2 # v4.31.5
        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@a1c11829223a786afe3b5663db904a3aa1eac3a2 # v2.0.1
+        uses: actions/ai-inference@5022b33bc1431add9b2831934daf8147a2ad9331 # v2.0.2
        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@a1c11829223a786afe3b5663db904a3aa1eac3a2 # v2.0.1
+        uses: actions/ai-inference@5022b33bc1431add9b2831934daf8147a2ad9331 # v2.0.2
        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@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0

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

--- a/.github/workflows/wheels.yml
+++ b/.github/workflows/wheels.yml
@@ -33,11 +33,11 @@ jobs:
    steps:
      - &checkout
        name: Checkout the repository
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0

      - name: Set up Python ${{ env.DEFAULT_PYTHON }}
        id: python
-        uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6.0.0
+        uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
        with:
          python-version: ${{ env.DEFAULT_PYTHON }}
          check-latest: true
@@ -77,20 +77,8 @@ 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:
@@ -99,13 +87,6 @@ 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:
@@ -138,13 +119,6 @@ jobs:
          - 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

@@ -154,12 +128,6 @@ 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
@@ -199,7 +167,7 @@ jobs:
      - *checkout

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

      - name: Download requirements_all_wheels
@@ -209,10 +177,6 @@ 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
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -87,14 +87,14 @@ repos:
        pass_filenames: false
        language: script
        types: [text]
-        files: ^(homeassistant/.+/(icons|manifest|strings)\.json|homeassistant/.+/(quality_scale)\.yaml|homeassistant/brands/.*\.json|homeassistant/.+/services\.yaml|script/hassfest/(?!metadata|mypy_config).+\.py|requirements.+\.txt)$
+        files: ^(homeassistant/.+/(icons|manifest|strings)\.json|homeassistant/.+/(conditions|quality_scale|services|triggers)\.yaml|homeassistant/brands/.*\.json|script/hassfest/(?!metadata|mypy_config).+\.py|requirements.+\.txt)$
      - id: hassfest-metadata
        name: hassfest-metadata
        entry: script/run-in-env.sh python3 -m script.hassfest -p metadata,docker
        pass_filenames: false
        language: script
        types: [text]
-        files: ^(script/hassfest/metadata\.py|homeassistant/const\.py$|pyproject\.toml|homeassistant/components/go2rtc/const\.py)$
+        files: ^(script/hassfest/(metadata|docker)\.py|homeassistant/const\.py$|pyproject\.toml)$
      - 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
@@ -231,6 +231,7 @@ homeassistant.components.google_cloud.*
 homeassistant.components.google_drive.*
 homeassistant.components.google_photos.*
 homeassistant.components.google_sheets.*
+homeassistant.components.google_weather.*
 homeassistant.components.govee_ble.*
 homeassistant.components.gpsd.*
 homeassistant.components.greeneye_monitor.*
@@ -578,6 +579,7 @@ homeassistant.components.wiz.*
 homeassistant.components.wled.*
 homeassistant.components.workday.*
 homeassistant.components.worldclock.*
+homeassistant.components.xbox.*
 homeassistant.components.xiaomi_ble.*
 homeassistant.components.yale_smart_alarm.*
 homeassistant.components.yalexs_ble.*
--- a/18
+++ b/18
@@ -69,6 +69,8 @@ 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
@@ -389,6 +391,8 @@ 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
@@ -607,6 +611,8 @@ build.json @home-assistant/supervisor
 /tests/components/google_tasks/ @allenporter
 /homeassistant/components/google_travel_time/ @eifinger
 /tests/components/google_travel_time/ @eifinger
+/homeassistant/components/google_weather/ @tronikos
+/tests/components/google_weather/ @tronikos
 /homeassistant/components/govee_ble/ @bdraco
 /tests/components/govee_ble/ @bdraco
 /homeassistant/components/govee_light_local/ @Galorhallen
@@ -625,6 +631,8 @@ 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
@@ -844,6 +852,8 @@ 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
@@ -1017,8 +1027,8 @@ build.json @home-assistant/supervisor
 /homeassistant/components/msteams/ @peroyvind
 /homeassistant/components/mullvad/ @meichthys
 /tests/components/mullvad/ @meichthys
-/homeassistant/components/music_assistant/ @music-assistant
-/tests/components/music_assistant/ @music-assistant
+/homeassistant/components/music_assistant/ @music-assistant @arturpragacz
+/tests/components/music_assistant/ @music-assistant @arturpragacz
 /homeassistant/components/mutesync/ @currentoor
 /tests/components/mutesync/ @currentoor
 /homeassistant/components/my/ @home-assistant/core
@@ -1374,6 +1384,8 @@ build.json @home-assistant/supervisor
 /tests/components/sanix/ @tomaszsluszniak
 /homeassistant/components/satel_integra/ @Tommatheussen
 /tests/components/satel_integra/ @Tommatheussen
+/homeassistant/components/saunum/ @mettolen
+/tests/components/saunum/ @mettolen
 /homeassistant/components/scene/ @home-assistant/core
 /tests/components/scene/ @home-assistant/core
 /homeassistant/components/schedule/ @home-assistant/core
@@ -1732,6 +1744,8 @@ build.json @home-assistant/supervisor
 /tests/components/vesync/ @markperdue @webdjoe @thegardenmonkey @cdnninja @iprak @sapuseven
 /homeassistant/components/vicare/ @CFenner
 /tests/components/vicare/ @CFenner
+/homeassistant/components/victron_ble/ @rajlaud
+/tests/components/victron_ble/ @rajlaud
 /homeassistant/components/victron_remote_monitoring/ @AndyTempel
 /tests/components/victron_remote_monitoring/ @AndyTempel
 /homeassistant/components/vilfo/ @ManneW
--- a/23
+++ b/23
@@ -15,23 +15,14 @@ ARG QEMU_CPU
 # Home Assistant S6-Overlay
 COPY rootfs /

-# 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
+# Add go2rtc binary
+COPY --from=ghcr.io/alexxit/go2rtc@sha256:baef0aa19d759fcfd31607b34ce8eaf039d496282bba57731e6ae326896d7640 /usr/local/bin/go2rtc /bin/go2rtc

-# Install uv
-RUN pip3 install uv==0.9.6
+RUN \
+    # Verify go2rtc can be executed
+    go2rtc --version \
+    # Install uv
+    && pip3 install uv==0.9.6

 WORKDIR /usr/src

--- a/build.yaml
+++ b/build.yaml
@@ -1,10 +1,7 @@
 image: ghcr.io/home-assistant/{arch}-homeassistant
 build_from:
-  aarch64: ghcr.io/home-assistant/aarch64-homeassistant-base:2025.10.1
-  armhf: ghcr.io/home-assistant/armhf-homeassistant-base:2025.10.1
-  armv7: ghcr.io/home-assistant/armv7-homeassistant-base:2025.10.1
-  amd64: ghcr.io/home-assistant/amd64-homeassistant-base:2025.10.1
-  i386: ghcr.io/home-assistant/i386-homeassistant-base:2025.10.1
+  aarch64: ghcr.io/home-assistant/aarch64-homeassistant-base:2025.11.0
+  amd64: ghcr.io/home-assistant/amd64-homeassistant-base:2025.11.0
 cosign:
  base_identity: https://github.com/home-assistant/docker/.*
  identity: https://github.com/home-assistant/core/.*
--- a/homeassistant/bootstrap.py
+++ b/homeassistant/bootstrap.py
@@ -176,6 +176,8 @@ 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
@@ -212,6 +214,7 @@ DEFAULT_INTEGRATIONS = {
    "backup",
    "frontend",
    "hardware",
+    "labs",
    "logger",
    "network",
    "system_health",
--- a/homeassistant/brands/google.json
+++ b/homeassistant/brands/google.json
@@ -15,6 +15,7 @@
    "google_tasks",
    "google_translate",
    "google_travel_time",
+    "google_weather",
    "google_wifi",
    "google",
    "nest",
--- a/homeassistant/brands/victron.json
+++ b/homeassistant/brands/victron.json
@@ -0,0 +1,5 @@
+{
+  "domain": "victron",
+  "name": "Victron",
+  "integrations": ["victron_ble", "victron_remote_monitoring"]
+}
--- 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 (
-    ActronAirNeoACSystem,
-    ActronNeoAPI,
-    ActronNeoAPIError,
-    ActronNeoAuthError,
+    ActronAirACSystem,
+    ActronAirAPI,
+    ActronAirAPIError,
+    ActronAirAuthError,
 )

 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 = ActronNeoAPI(refresh_token=entry.data[CONF_API_TOKEN])
-    systems: list[ActronAirNeoACSystem] = []
+    api = ActronAirAPI(refresh_token=entry.data[CONF_API_TOKEN])
+    systems: list[ActronAirACSystem] = []

    try:
        systems = await api.get_ac_systems()
        await api.update_status()
-    except ActronNeoAuthError:
+    except ActronAirAuthError:
        _LOGGER.error("Authentication error while setting up Actron Air integration")
        raise
-    except ActronNeoAPIError as err:
+    except ActronAirAPIError 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 ActronAirNeoStatus, ActronAirNeoZone
+from actron_neo_api import ActronAirStatus, ActronAirZone

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

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

@@ -194,7 +194,7 @@ class ActronZoneClimate(BaseClimateEntity):
    def __init__(
        self,
        coordinator: ActronAirSystemCoordinator,
-        zone: ActronAirNeoZone,
+        zone: ActronAirZone,
    ) -> 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) -> ActronAirNeoZone:
+    def _zone(self) -> ActronAirZone:
        """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 ActronNeoAPI, ActronNeoAuthError
+from actron_neo_api import ActronAirAPI, ActronAirAuthError

 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: ActronNeoAPI | None = None
+        self._api: ActronAirAPI | 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 = ActronNeoAPI()
+            self._api = ActronAirAPI()
            try:
                device_code_response = await self._api.request_device_code()
-            except ActronNeoAuthError as err:
+            except ActronAirAuthError 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 ActronNeoAuthError as ex:
+            except ActronAirAuthError 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 ActronNeoAuthError as err:
+        except ActronAirAuthError 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 ActronAirNeoACSystem, ActronAirNeoStatus, ActronNeoAPI
+from actron_neo_api import ActronAirACSystem, ActronAirAPI, ActronAirStatus

 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: ActronNeoAPI
+    api: ActronAirAPI
    system_coordinators: dict[str, ActronAirSystemCoordinator]


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


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

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

-    async def _async_update_data(self) -> ActronAirNeoStatus:
+    async def _async_update_data(self) -> ActronAirStatus:
        """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.84"]
+  "requirements": ["actron-neo-api==0.1.87"]
 }
--- a/homeassistant/components/adguard/init.py
+++ b/homeassistant/components/adguard/init.py
@@ -45,7 +45,7 @@ SERVICE_REFRESH_SCHEMA = vol.Schema(
    {vol.Optional(CONF_FORCE, default=False): cv.boolean}
 )

-PLATFORMS = [Platform.SENSOR, Platform.SWITCH]
+PLATFORMS = [Platform.SENSOR, Platform.SWITCH, Platform.UPDATE]
 type AdGuardConfigEntry = ConfigEntry[AdGuardData]


--- a/homeassistant/components/adguard/manifest.json
+++ b/homeassistant/components/adguard/manifest.json
@@ -7,5 +7,5 @@
  "integration_type": "service",
  "iot_class": "local_polling",
  "loggers": ["adguardhome"],
-  "requirements": ["adguardhome==0.7.0"]
+  "requirements": ["adguardhome==0.8.1"]
 }
--- a/homeassistant/components/adguard/update.py
+++ b/homeassistant/components/adguard/update.py
@@ -0,0 +1,71 @@
+"""AdGuard Home Update platform."""
+
+from __future__ import annotations
+
+from datetime import timedelta
+from typing import Any
+
+from adguardhome import AdGuardHomeError
+
+from homeassistant.components.update import UpdateEntity, UpdateEntityFeature
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from . import AdGuardConfigEntry, AdGuardData
+from .const import DOMAIN
+from .entity import AdGuardHomeEntity
+
+SCAN_INTERVAL = timedelta(seconds=300)
+PARALLEL_UPDATES = 1
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: AdGuardConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up AdGuard Home update entity based on a config entry."""
+    data = entry.runtime_data
+
+    if (await data.client.update.update_available()).disabled:
+        return
+
+    async_add_entities([AdGuardHomeUpdate(data, entry)], True)
+
+
+class AdGuardHomeUpdate(AdGuardHomeEntity, UpdateEntity):
+    """Defines an AdGuard Home update."""
+
+    _attr_supported_features = UpdateEntityFeature.INSTALL
+    _attr_name = None
+
+    def __init__(
+        self,
+        data: AdGuardData,
+        entry: AdGuardConfigEntry,
+    ) -> None:
+        """Initialize AdGuard Home update."""
+        super().__init__(data, entry)
+
+        self._attr_unique_id = "_".join(
+            [DOMAIN, self.adguard.host, str(self.adguard.port), "update"]
+        )
+
+    async def _adguard_update(self) -> None:
+        """Update AdGuard Home entity."""
+        value = await self.adguard.update.update_available()
+        self._attr_installed_version = self.data.version
+        self._attr_latest_version = value.new_version
+        self._attr_release_summary = value.announcement
+        self._attr_release_url = value.announcement_url
+
+    async def async_install(
+        self, version: str | None, backup: bool, **kwargs: Any
+    ) -> None:
+        """Install latest update."""
+        try:
+            await self.adguard.update.begin_update()
+        except AdGuardHomeError as err:
+            raise HomeAssistantError(f"Failed to install update: {err}") from err
+        self.hass.config_entries.async_schedule_reload(self._entry.entry_id)
--- a/homeassistant/components/airobot/init.py
+++ b/homeassistant/components/airobot/init.py
@@ -0,0 +1,29 @@
+"""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
@@ -0,0 +1,151 @@
+"""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."""
+        return self._status.temp_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_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
@@ -0,0 +1,183 @@
+"""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
@@ -0,0 +1,5 @@
+"""Constants for the Airobot integration."""
+
+from typing import Final
+
+DOMAIN: Final = "airobot"
--- a/homeassistant/components/airobot/coordinator.py
+++ b/homeassistant/components/airobot/coordinator.py
@@ -0,0 +1,59 @@
+"""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
@@ -0,0 +1,42 @@
+"""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
@@ -0,0 +1,17 @@
+{
+  "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
@@ -0,0 +1,15 @@
+"""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
@@ -0,0 +1,70 @@
+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: todo
+  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
@@ -0,0 +1,44 @@
+{
+  "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/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_mode_interactive(data[CONF_CODE])
+    return await api.login.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
@@ -16,6 +16,7 @@ from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryAuthFailed
 from homeassistant.helpers import device_registry as dr
+from homeassistant.helpers.debounce import Debouncer
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed

 from .const import _LOGGER, CONF_LOGIN_DATA, DOMAIN
@@ -43,6 +44,9 @@ class AmazonDevicesCoordinator(DataUpdateCoordinator[dict[str, AmazonDevice]]):
            name=entry.title,
            config_entry=entry,
            update_interval=timedelta(seconds=SCAN_INTERVAL),
+            request_refresh_debouncer=Debouncer(
+                hass, _LOGGER, cooldown=30, immediate=False
+            ),
        )
        self.api = AmazonEchoApi(
            session,
@@ -55,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_mode_stored_data()
+            await self.api.login.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==8.0.1"]
+  "requirements": ["aioamazondevices==9.0.3"]
 }
--- a/homeassistant/components/analytics/init.py
+++ b/homeassistant/components/analytics/init.py
@@ -6,9 +6,7 @@ import voluptuous as vol

 from homeassistant.components import websocket_api
 from homeassistant.const import EVENT_HOMEASSISTANT_STARTED
-from homeassistant.core import Event, HassJob, HomeAssistant, callback
-from homeassistant.helpers import config_validation as cv
-from homeassistant.helpers.event import async_call_later, async_track_time_interval
+from homeassistant.core import Event, HomeAssistant, callback
 from homeassistant.helpers.typing import ConfigType
 from homeassistant.util.hass_dict import HassKey

@@ -20,7 +18,7 @@ from .analytics import (
    EntityAnalyticsModifications,
    async_devices_payload,
 )
-from .const import ATTR_ONBOARDED, ATTR_PREFERENCES, DOMAIN, INTERVAL, PREFERENCE_SCHEMA
+from .const import ATTR_ONBOARDED, ATTR_PREFERENCES, DOMAIN, PREFERENCE_SCHEMA
 from .http import AnalyticsDevicesView

 __all__ = [
@@ -31,40 +29,43 @@ __all__ = [
    "async_devices_payload",
 ]

-CONFIG_SCHEMA = cv.empty_config_schema(DOMAIN)
+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,
+)

 DATA_COMPONENT: HassKey[Analytics] = HassKey(DOMAIN)


-async def async_setup(hass: HomeAssistant, _: ConfigType) -> bool:
+async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
    """Set up the analytics integration."""
-    analytics = Analytics(hass)
+    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)

    # Load stored data
    await analytics.load()

-    @callback
-    def start_schedule(_event: Event) -> None:
+    async def start_schedule(_event: Event) -> None:
        """Start the send schedule after the started event."""
-        # Wait 15 min after started
-        async_call_later(
-            hass,
-            900,
-            HassJob(
-                analytics.send_analytics,
-                name="analytics schedule",
-                cancel_on_shutdown=True,
-            ),
-        )
-
-        # Send every day
-        async_track_time_interval(
-            hass,
-            analytics.send_analytics,
-            INTERVAL,
-            name="analytics daily",
-            cancel_on_shutdown=True,
-        )
+        await analytics.async_schedule()

    hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STARTED, start_schedule)

@@ -111,7 +112,7 @@ async def websocket_analytics_preferences(
    analytics = hass.data[DATA_COMPONENT]

    await analytics.save_preferences(preferences)
-    await analytics.send_analytics()
+    await analytics.async_schedule()

    connection.send_result(
        msg["id"],
--- a/homeassistant/components/analytics/analytics.py
+++ b/homeassistant/components/analytics/analytics.py
@@ -7,6 +7,8 @@ from asyncio import timeout
 from collections.abc import Awaitable, Callable, Iterable, Mapping
 from dataclasses import asdict as dataclass_asdict, dataclass, field
 from datetime import datetime
+import random
+import time
 from typing import Any, Protocol
 import uuid

@@ -31,10 +33,18 @@ from homeassistant.const import (
    BASE_PLATFORMS,
    __version__ as HA_VERSION,
 )
-from homeassistant.core import HomeAssistant, callback
+from homeassistant.core import (
+    CALLBACK_TYPE,
+    HassJob,
+    HomeAssistant,
+    ReleaseChannel,
+    callback,
+    get_release_channel,
+)
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import device_registry as dr, entity_registry as er
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers.event import async_call_later, async_track_time_interval
 from homeassistant.helpers.hassio import is_hassio
 from homeassistant.helpers.singleton import singleton
 from homeassistant.helpers.storage import Store
@@ -49,8 +59,6 @@ from homeassistant.loader import (
 from homeassistant.setup import async_get_loaded_integrations

 from .const import (
-    ANALYTICS_ENDPOINT_URL,
-    ANALYTICS_ENDPOINT_URL_DEV,
    ATTR_ADDON_COUNT,
    ATTR_ADDONS,
    ATTR_ARCH,
@@ -71,6 +79,7 @@ from .const import (
    ATTR_PROTECTED,
    ATTR_RECORDER,
    ATTR_SLUG,
+    ATTR_SNAPSHOTS,
    ATTR_STATE_COUNT,
    ATTR_STATISTICS,
    ATTR_SUPERVISOR,
@@ -79,9 +88,15 @@ 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,
 )
@@ -194,13 +209,18 @@ def gen_uuid() -> str:
    return uuid.uuid4().hex


+RELEASE_CHANNEL = get_release_channel()
+
+
@dataclass
 class AnalyticsData:
    """Analytics data."""

    onboarded: bool
    preferences: dict[str, bool]
-    uuid: str | None
+    uuid: str | None = None
+    submission_identifier: str | None = None
+    snapshot_submission_time: float | None = None

    @classmethod
    def from_dict(cls, data: dict[str, Any]) -> AnalyticsData:
@@ -209,29 +229,44 @@ class AnalyticsData:
            data["onboarded"],
            data["preferences"],
            data["uuid"],
+            data.get("submission_identifier"),
+            data.get("snapshot_submission_time"),
        )


 class Analytics:
    """Analytics helper class for the analytics integration."""

-    def __init__(self, hass: HomeAssistant) -> None:
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        snapshots_url: str | None = None,
+        disable_snapshots: bool = False,
+    ) -> None:
        """Initialize the Analytics class."""
-        self.hass: HomeAssistant = hass
-        self.session = async_get_clientsession(hass)
-        self._data = AnalyticsData(False, {}, None)
+        self._hass: HomeAssistant = hass
+        self._snapshots_url = snapshots_url
+        self._disable_snapshots = disable_snapshots
+
+        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
+        self._snapshot_scheduled: CALLBACK_TYPE | None = None

    @property
    def preferences(self) -> dict:
        """Return the current active preferences."""
        preferences = self._data.preferences
-        return {
+        result = {
            ATTR_BASE: preferences.get(ATTR_BASE, 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:
@@ -244,17 +279,17 @@ class Analytics:
        return self._data.uuid

    @property
-    def endpoint(self) -> str:
+    def endpoint_basic(self) -> str:
        """Return the endpoint that will receive the payload."""
-        if HA_VERSION.endswith("0.dev0"):
+        if RELEASE_CHANNEL is ReleaseChannel.DEV:
            # dev installations will contact the dev analytics environment
-            return ANALYTICS_ENDPOINT_URL_DEV
-        return ANALYTICS_ENDPOINT_URL
+            return BASIC_ENDPOINT_URL_DEV
+        return BASIC_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."""
@@ -264,7 +299,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
@@ -277,32 +312,35 @@ class Analytics:
                ):
                    self._data.preferences[ATTR_DIAGNOSTICS] = False

+    async def _save(self) -> None:
+        """Save data."""
+        await self._store.async_save(dataclass_asdict(self._data))
+
    async def save_preferences(self, preferences: dict) -> None:
        """Save preferences."""
        preferences = PREFERENCE_SCHEMA(preferences)
        self._data.preferences.update(preferences)
        self._data.onboarded = True

-        await self._store.async_save(dataclass_asdict(self._data))
+        await self._save()

        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:
        """Send analytics."""
-        hass = self.hass
+        if not self.onboarded or not self.preferences.get(ATTR_BASE, False):
+            return
+
+        hass = self._hass
        supervisor_info = None
        operating_system_info: dict[str, Any] = {}

-        if not self.onboarded or not self.preferences.get(ATTR_BASE, False):
-            LOGGER.debug("Nothing to submit")
-            return
-
        if self._data.uuid is None:
            self._data.uuid = gen_uuid()
-            await self._store.async_save(dataclass_asdict(self._data))
+            await self._save()

        if self.supervisor:
            supervisor_info = hassio.get_supervisor_info(hass)
@@ -436,7 +474,7 @@ class Analytics:

        try:
            async with timeout(30):
-                response = await self.session.post(self.endpoint, json=payload)
+                response = await self._session.post(self.endpoint_basic, json=payload)
                if response.status == 200:
                    LOGGER.info(
                        (
@@ -449,14 +487,12 @@ class Analytics:
                    LOGGER.warning(
                        "Sending analytics failed with statuscode %s from %s",
                        response.status,
-                        self.endpoint,
+                        self.endpoint_basic,
                    )
        except TimeoutError:
-            LOGGER.error("Timeout sending analytics to %s", ANALYTICS_ENDPOINT_URL)
+            LOGGER.error("Timeout sending analytics to %s", BASIC_ENDPOINT_URL)
        except aiohttp.ClientError as err:
-            LOGGER.error(
-                "Error sending analytics to %s: %r", ANALYTICS_ENDPOINT_URL, err
-            )
+            LOGGER.error("Error sending analytics to %s: %r", BASIC_ENDPOINT_URL, err)

    @callback
    def _async_should_report_integration(
@@ -480,7 +516,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(
@@ -489,6 +525,186 @@ class Analytics:
            if entry.source != SOURCE_IGNORE and entry.disabled_by is None
        )

+    async def send_snapshot(self, _: datetime | None = None) -> None:
+        """Send a snapshot."""
+        if not self.onboarded or not self.preferences.get(ATTR_SNAPSHOTS, False):
+            return
+
+        payload = await _async_snapshot_payload(self._hass)
+
+        headers = {
+            "Content-Type": "application/json",
+            "User-Agent": f"home-assistant/{HA_VERSION}",
+        }
+        if self._data.submission_identifier is not None:
+            headers["X-Device-Database-Submission-Identifier"] = (
+                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)
+
+                if response.status == 200:  # OK
+                    response_data = await response.json()
+                    new_identifier = response_data.get("submission_identifier")
+
+                    if (
+                        new_identifier is not None
+                        and new_identifier != self._data.submission_identifier
+                    ):
+                        self._data.submission_identifier = new_identifier
+                        await self._save()
+
+                    LOGGER.info(
+                        "Submitted snapshot analytics to Home Assistant servers"
+                    )
+
+                elif response.status == 400:  # Bad Request
+                    response_data = await response.json()
+                    error_kind = response_data.get("kind", "unknown")
+                    error_message = response_data.get("message", "Unknown error")
+
+                    if error_kind == "invalid-submission-identifier":
+                        # Clear the invalid identifier and retry on next cycle
+                        LOGGER.warning(
+                            "Invalid submission identifier to %s, clearing: %s",
+                            url,
+                            error_message,
+                        )
+                        self._data.submission_identifier = None
+                        await self._save()
+                    else:
+                        LOGGER.warning(
+                            "Malformed snapshot analytics submission (%s) to %s: %s",
+                            error_kind,
+                            url,
+                            error_message,
+                        )
+
+                elif response.status == 503:  # Service Unavailable
+                    response_text = await response.text()
+                    LOGGER.warning(
+                        "Snapshot analytics service %s unavailable: %s",
+                        url,
+                        response_text,
+                    )
+
+                else:
+                    LOGGER.warning(
+                        "Unexpected status code %s when submitting snapshot analytics to %s",
+                        response.status,
+                        url,
+                    )
+
+        except TimeoutError:
+            LOGGER.error(
+                "Timeout sending snapshot analytics to %s",
+                url,
+            )
+        except aiohttp.ClientError as err:
+            LOGGER.error(
+                "Error sending snapshot analytics to %s: %r",
+                url,
+                err,
+            )
+
+    async def async_schedule(self) -> None:
+        """Schedule analytics."""
+        if not self.onboarded:
+            LOGGER.debug("Analytics not scheduled")
+            if self._basic_scheduled is not None:
+                self._basic_scheduled()
+                self._basic_scheduled = None
+            if self._snapshot_scheduled:
+                self._snapshot_scheduled()
+                self._snapshot_scheduled = None
+            return
+
+        if not self.preferences.get(ATTR_BASE, False):
+            LOGGER.debug("Basic analytics not scheduled")
+            if self._basic_scheduled is not None:
+                self._basic_scheduled()
+                self._basic_scheduled = None
+        elif self._basic_scheduled is None:
+            # Wait 15 min after started for basic analytics
+            self._basic_scheduled = async_call_later(
+                self._hass,
+                900,
+                HassJob(
+                    self._async_schedule_basic,
+                    name="basic analytics schedule",
+                    cancel_on_shutdown=True,
+                ),
+            )
+
+        if not self.preferences.get(ATTR_SNAPSHOTS, False) or self._disable_snapshots:
+            LOGGER.debug("Snapshot analytics not scheduled")
+            if self._snapshot_scheduled:
+                self._snapshot_scheduled()
+                self._snapshot_scheduled = None
+        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)
+                self._data.snapshot_submission_time = snapshot_submission_time
+                await self._save()
+                LOGGER.debug(
+                    "Initialized snapshot submission time to %s",
+                    snapshot_submission_time,
+                )
+
+            # Calculate delay until next submission
+            current_time = time.time()
+            delay = (snapshot_submission_time - current_time) % interval_seconds
+
+            self._snapshot_scheduled = async_call_later(
+                self._hass,
+                delay,
+                HassJob(
+                    self._async_schedule_snapshots,
+                    name="snapshot analytics schedule",
+                    cancel_on_shutdown=True,
+                ),
+            )
+
+    async def _async_schedule_basic(self, _: datetime | None = None) -> None:
+        """Schedule basic analytics."""
+        await self.send_analytics()
+
+        # Send basic analytics every day
+        self._basic_scheduled = async_track_time_interval(
+            self._hass,
+            self.send_analytics,
+            INTERVAL,
+            name="basic analytics daily",
+            cancel_on_shutdown=True,
+        )
+
+    async def _async_schedule_snapshots(self, _: datetime | None = None) -> None:
+        """Schedule snapshot analytics."""
+        await self.send_snapshot()
+
+        # Send snapshot analytics every day
+        self._snapshot_scheduled = async_track_time_interval(
+            self._hass,
+            self.send_snapshot,
+            INTERVAL,
+            name="snapshot analytics daily",
+            cancel_on_shutdown=True,
+        )
+

 def _domains_from_yaml_config(yaml_configuration: dict[str, Any]) -> set[str]:
    """Extract domains from the YAML configuration."""
@@ -505,8 +721,8 @@ DEFAULT_DEVICE_ANALYTICS_CONFIG = DeviceAnalyticsModifications()
 DEFAULT_ENTITY_ANALYTICS_CONFIG = EntityAnalyticsModifications()


-async def async_devices_payload(hass: HomeAssistant) -> dict:  # noqa: C901
-    """Return detailed information about entities and devices."""
+async def _async_snapshot_payload(hass: HomeAssistant) -> dict:  # noqa: C901
+    """Return detailed information about entities and devices for a snapshot."""
    dev_reg = dr.async_get(hass)
    ent_reg = er.async_get(hass)

@@ -711,8 +927,13 @@ async def async_devices_payload(hass: HomeAssistant) -> dict:  # noqa: C901

            entities_info.append(entity_info)

+    return integrations_info
+
+
+async def async_devices_payload(hass: HomeAssistant) -> dict:
+    """Return detailed information about entities and devices for a direct download."""
    return {
-        "version": "home-assistant:1",
+        "version": f"home-assistant:{SNAPSHOT_VERSION}",
        "home_assistant": HA_VERSION,
-        "integrations": integrations_info,
+        "integrations": await _async_snapshot_payload(hass),
    }
--- a/homeassistant/components/analytics/const.py
+++ b/homeassistant/components/analytics/const.py
@@ -5,13 +5,17 @@ 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"
 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__)

@@ -38,6 +42,7 @@ ATTR_PREFERENCES = "preferences"
 ATTR_PROTECTED = "protected"
 ATTR_RECORDER = "recorder"
 ATTR_SLUG = "slug"
+ATTR_SNAPSHOTS = "snapshots"
 ATTR_STATE_COUNT = "state_count"
 ATTR_STATISTICS = "statistics"
 ATTR_SUPERVISOR = "supervisor"
@@ -51,6 +56,7 @@ ATTR_VERSION = "version"
 PREFERENCE_SCHEMA = vol.Schema(
    {
        vol.Optional(ATTR_BASE): bool,
+        vol.Optional(ATTR_SNAPSHOTS): bool,
        vol.Optional(ATTR_DIAGNOSTICS): bool,
        vol.Optional(ATTR_STATISTICS): bool,
        vol.Optional(ATTR_USAGE): bool,
--- a/homeassistant/components/anthropic/init.py
+++ b/homeassistant/components/anthropic/init.py
@@ -25,7 +25,7 @@ from .const import (
    RECOMMENDED_CHAT_MODEL,
 )

-PLATFORMS = (Platform.CONVERSATION,)
+PLATFORMS = (Platform.AI_TASK, Platform.CONVERSATION)
 CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)

 type AnthropicConfigEntry = ConfigEntry[anthropic.AsyncClient]
--- a/homeassistant/components/anthropic/ai_task.py
+++ b/homeassistant/components/anthropic/ai_task.py
@@ -0,0 +1,80 @@
+"""AI Task integration for Anthropic."""
+
+from __future__ import annotations
+
+from json import JSONDecodeError
+import logging
+
+from homeassistant.components import ai_task, conversation
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from homeassistant.util.json import json_loads
+
+from .entity import AnthropicBaseLLMEntity
+
+_LOGGER = logging.getLogger(__name__)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config_entry: ConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up AI Task entities."""
+    for subentry in config_entry.subentries.values():
+        if subentry.subentry_type != "ai_task_data":
+            continue
+
+        async_add_entities(
+            [AnthropicTaskEntity(config_entry, subentry)],
+            config_subentry_id=subentry.subentry_id,
+        )
+
+
+class AnthropicTaskEntity(
+    ai_task.AITaskEntity,
+    AnthropicBaseLLMEntity,
+):
+    """Anthropic AI Task entity."""
+
+    _attr_supported_features = (
+        ai_task.AITaskEntityFeature.GENERATE_DATA
+        | ai_task.AITaskEntityFeature.SUPPORT_ATTACHMENTS
+    )
+
+    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(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 Claude structured response") from err
+
+        return ai_task.GenDataTaskResult(
+            conversation_id=chat_log.conversation_id,
+            data=data,
+        )
--- a/homeassistant/components/anthropic/config_flow.py
+++ b/homeassistant/components/anthropic/config_flow.py
@@ -5,6 +5,7 @@ from __future__ import annotations
 from functools import partial
 import json
 import logging
+import re
 from typing import Any

 import anthropic
@@ -53,6 +54,7 @@ from .const import (
    CONF_WEB_SEARCH_REGION,
    CONF_WEB_SEARCH_TIMEZONE,
    CONF_WEB_SEARCH_USER_LOCATION,
+    DEFAULT_AI_TASK_NAME,
    DEFAULT_CONVERSATION_NAME,
    DOMAIN,
    NON_THINKING_MODELS,
@@ -74,12 +76,16 @@ STEP_USER_DATA_SCHEMA = vol.Schema(
    }
 )

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

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

 async def validate_input(hass: HomeAssistant, data: dict[str, Any]) -> None:
    """Validate the user input allows us to connect.
@@ -102,7 +108,7 @@ class AnthropicConfigFlow(ConfigFlow, domain=DOMAIN):
        self, user_input: dict[str, Any] | None = None
    ) -> ConfigFlowResult:
        """Handle the initial step."""
-        errors = {}
+        errors: dict[str, str] = {}

        if user_input is not None:
            self._async_abort_entries_match(user_input)
@@ -130,10 +136,16 @@ class AnthropicConfigFlow(ConfigFlow, domain=DOMAIN):
                    subentries=[
                        {
                            "subentry_type": "conversation",
-                            "data": RECOMMENDED_OPTIONS,
+                            "data": RECOMMENDED_CONVERSATION_OPTIONS,
                            "title": DEFAULT_CONVERSATION_NAME,
                            "unique_id": None,
-                        }
+                        },
+                        {
+                            "subentry_type": "ai_task_data",
+                            "data": RECOMMENDED_AI_TASK_OPTIONS,
+                            "title": DEFAULT_AI_TASK_NAME,
+                            "unique_id": None,
+                        },
                    ],
                )

@@ -147,7 +159,10 @@ class AnthropicConfigFlow(ConfigFlow, domain=DOMAIN):
        cls, config_entry: ConfigEntry
    ) -> dict[str, type[ConfigSubentryFlow]]:
        """Return subentries supported by this integration."""
-        return {"conversation": ConversationSubentryFlowHandler}
+        return {
+            "conversation": ConversationSubentryFlowHandler,
+            "ai_task_data": ConversationSubentryFlowHandler,
+        }


 class ConversationSubentryFlowHandler(ConfigSubentryFlow):
@@ -164,7 +179,10 @@ class ConversationSubentryFlowHandler(ConfigSubentryFlow):
        self, user_input: dict[str, Any] | None = None
    ) -> SubentryFlowResult:
        """Add a subentry."""
-        self.options = RECOMMENDED_OPTIONS.copy()
+        if self._subentry_type == "ai_task_data":
+            self.options = RECOMMENDED_AI_TASK_OPTIONS.copy()
+        else:
+            self.options = RECOMMENDED_CONVERSATION_OPTIONS.copy()
        return await self.async_step_init()

    async def async_step_reconfigure(
@@ -198,23 +216,29 @@ class ConversationSubentryFlowHandler(ConfigSubentryFlow):
        errors: dict[str, str] = {}

        if self._is_new:
-            step_schema[vol.Required(CONF_NAME, default=DEFAULT_CONVERSATION_NAME)] = (
-                str
+            if self._subentry_type == "ai_task_data":
+                default_name = DEFAULT_AI_TASK_NAME
+            else:
+                default_name = DEFAULT_CONVERSATION_NAME
+            step_schema[vol.Required(CONF_NAME, default=default_name)] = str
+
+        if self._subentry_type == "conversation":
+            step_schema.update(
+                {
+                    vol.Optional(CONF_PROMPT): TemplateSelector(),
+                    vol.Optional(
+                        CONF_LLM_HASS_API,
+                    ): SelectSelector(
+                        SelectSelectorConfig(options=hass_apis, multiple=True)
+                    ),
+                }
            )

-        step_schema.update(
-            {
-                vol.Optional(CONF_PROMPT): TemplateSelector(),
-                vol.Optional(
-                    CONF_LLM_HASS_API,
-                ): SelectSelector(
-                    SelectSelectorConfig(options=hass_apis, multiple=True)
-                ),
-                vol.Required(
-                    CONF_RECOMMENDED, default=self.options.get(CONF_RECOMMENDED, False)
-                ): bool,
-            }
-        )
+        step_schema[
+            vol.Required(
+                CONF_RECOMMENDED, default=self.options.get(CONF_RECOMMENDED, False)
+            )
+        ] = bool

        if user_input is not None:
            if not user_input.get(CONF_LLM_HASS_API):
@@ -260,7 +284,11 @@ class ConversationSubentryFlowHandler(ConfigSubentryFlow):
            vol.Optional(
                CONF_CHAT_MODEL,
                default=RECOMMENDED_CHAT_MODEL,
-            ): str,
+            ): SelectSelector(
+                SelectSelectorConfig(
+                    options=await self._get_model_list(), custom_value=True
+                )
+            ),
            vol.Optional(
                CONF_MAX_TOKENS,
                default=RECOMMENDED_MAX_TOKENS,
@@ -298,10 +326,14 @@ class ConversationSubentryFlowHandler(ConfigSubentryFlow):
        if not model.startswith(tuple(NON_THINKING_MODELS)):
            step_schema[
                vol.Optional(CONF_THINKING_BUDGET, default=RECOMMENDED_THINKING_BUDGET)
-            ] = NumberSelector(
-                NumberSelectorConfig(
-                    min=0, max=self.options.get(CONF_MAX_TOKENS, RECOMMENDED_MAX_TOKENS)
-                )
+            ] = vol.All(
+                NumberSelector(
+                    NumberSelectorConfig(
+                        min=0,
+                        max=self.options.get(CONF_MAX_TOKENS, RECOMMENDED_MAX_TOKENS),
+                    )
+                ),
+                vol.Coerce(int),
            )
        else:
            self.options.pop(CONF_THINKING_BUDGET, None)
@@ -367,6 +399,39 @@ class ConversationSubentryFlowHandler(ConfigSubentryFlow):
            last_step=True,
        )

+    async def _get_model_list(self) -> list[SelectOptionDict]:
+        """Get list of available models."""
+        try:
+            client = await self.hass.async_add_executor_job(
+                partial(
+                    anthropic.AsyncAnthropic,
+                    api_key=self._get_entry().data[CONF_API_KEY],
+                )
+            )
+            models = (await client.models.list()).data
+        except anthropic.AnthropicError:
+            models = []
+        _LOGGER.debug("Available models: %s", models)
+        model_options: list[SelectOptionDict] = []
+        short_form = re.compile(r"[^\d]-\d$")
+        for model_info in models:
+            # Resolve alias from versioned model name:
+            model_alias = (
+                model_info.id[:-9]
+                if model_info.id
+                not in ("claude-3-haiku-20240307", "claude-3-opus-20240229")
+                else model_info.id
+            )
+            if short_form.search(model_alias):
+                model_alias += "-0"
+            model_options.append(
+                SelectOptionDict(
+                    label=model_info.display_name,
+                    value=model_alias,
+                )
+            )
+        return model_options
+
    async def _get_location_data(self) -> dict[str, str]:
        """Get approximate location data of the user."""
        location_data: dict[str, str] = {}
--- a/homeassistant/components/anthropic/const.py
+++ b/homeassistant/components/anthropic/const.py
@@ -6,6 +6,7 @@ DOMAIN = "anthropic"
 LOGGER = logging.getLogger(__package__)

 DEFAULT_CONVERSATION_NAME = "Claude conversation"
+DEFAULT_AI_TASK_NAME = "Claude AI Task"

 CONF_RECOMMENDED = "recommended"
 CONF_PROMPT = "prompt"
--- a/homeassistant/components/anthropic/entity.py
+++ b/homeassistant/components/anthropic/entity.py
@@ -1,17 +1,24 @@
 """Base entity for Anthropic."""

+import base64
 from collections.abc import AsyncGenerator, Callable, Iterable
 from dataclasses import dataclass, field
 import json
+from mimetypes import guess_file_type
+from pathlib import Path
 from typing import Any

 import anthropic
 from anthropic import AsyncStream
 from anthropic.types import (
+    Base64ImageSourceParam,
+    Base64PDFSourceParam,
    CitationsDelta,
    CitationsWebSearchResultLocation,
    CitationWebSearchResultLocationParam,
    ContentBlockParam,
+    DocumentBlockParam,
+    ImageBlockParam,
    InputJSONDelta,
    MessageDeltaUsage,
    MessageParam,
@@ -37,6 +44,9 @@ from anthropic.types import (
    ThinkingConfigDisabledParam,
    ThinkingConfigEnabledParam,
    ThinkingDelta,
+    ToolChoiceAnyParam,
+    ToolChoiceAutoParam,
+    ToolChoiceToolParam,
    ToolParam,
    ToolResultBlockParam,
    ToolUnionParam,
@@ -50,13 +60,16 @@ from anthropic.types import (
    WebSearchToolResultError,
 )
 from anthropic.types.message_create_params import MessageCreateParamsStreaming
+import voluptuous as vol
 from voluptuous_openapi import convert

 from homeassistant.components import conversation
 from homeassistant.config_entries import ConfigSubentry
+from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import device_registry as dr, llm
 from homeassistant.helpers.entity import Entity
+from homeassistant.util import slugify

 from . import AnthropicConfigEntry
 from .const import (
@@ -321,6 +334,7 @@ def _convert_content(
 async def _transform_stream(  # noqa: C901 - This is complex, but better to have it in one place
    chat_log: conversation.ChatLog,
    stream: AsyncStream[MessageStreamEvent],
+    output_tool: str | None = None,
 ) -> AsyncGenerator[
    conversation.AssistantContentDeltaDict | conversation.ToolResultContentDeltaDict
 ]:
@@ -378,9 +392,19 @@ async def _transform_stream(  # noqa: C901 - This is complex, but better to have
                    type="tool_use",
                    id=response.content_block.id,
                    name=response.content_block.name,
-                    input="",
+                    input={},
                )
                current_tool_args = ""
+                if response.content_block.name == output_tool:
+                    if first_block or content_details.has_content():
+                        if content_details.has_citations():
+                            content_details.delete_empty()
+                            yield {"native": content_details}
+                        content_details = ContentDetails()
+                        content_details.add_citation_detail()
+                        yield {"role": "assistant"}
+                        has_native = False
+                        first_block = False
            elif isinstance(response.content_block, TextBlock):
                if (  # Do not start a new assistant content just for citations, concatenate consecutive blocks with citations instead.
                    first_block
@@ -435,7 +459,7 @@ async def _transform_stream(  # noqa: C901 - This is complex, but better to have
                    type="server_tool_use",
                    id=response.content_block.id,
                    name=response.content_block.name,
-                    input="",
+                    input={},
                )
                current_tool_args = ""
            elif isinstance(response.content_block, WebSearchToolResultBlock):
@@ -471,7 +495,16 @@ async def _transform_stream(  # noqa: C901 - This is complex, but better to have
                first_block = True
        elif isinstance(response, RawContentBlockDeltaEvent):
            if isinstance(response.delta, InputJSONDelta):
-                current_tool_args += response.delta.partial_json
+                if (
+                    current_tool_block is not None
+                    and current_tool_block["name"] == output_tool
+                ):
+                    content_details.citation_details[-1].length += len(
+                        response.delta.partial_json
+                    )
+                    yield {"content": response.delta.partial_json}
+                else:
+                    current_tool_args += response.delta.partial_json
            elif isinstance(response.delta, TextDelta):
                content_details.citation_details[-1].length += len(response.delta.text)
                yield {"content": response.delta.text}
@@ -490,6 +523,9 @@ async def _transform_stream(  # noqa: C901 - This is complex, but better to have
                content_details.add_citation(response.delta.citation)
        elif isinstance(response, RawContentBlockStopEvent):
            if current_tool_block is not None:
+                if current_tool_block["name"] == output_tool:
+                    current_tool_block = None
+                    continue
                tool_args = json.loads(current_tool_args) if current_tool_args else {}
                current_tool_block["input"] = tool_args
                yield {
@@ -557,6 +593,8 @@ class AnthropicBaseLLMEntity(Entity):
    async def _async_handle_chat_log(
        self,
        chat_log: conversation.ChatLog,
+        structure_name: str | None = None,
+        structure: vol.Schema | None = None,
    ) -> None:
        """Generate an answer for the chat log."""
        options = self.subentry.data
@@ -613,6 +651,74 @@ class AnthropicBaseLLMEntity(Entity):
                }
            tools.append(web_search)

+        # Handle attachments by adding them to the last user message
+        last_content = chat_log.content[-1]
+        if last_content.role == "user" and last_content.attachments:
+            last_message = messages[-1]
+            if last_message["role"] != "user":
+                raise HomeAssistantError(
+                    "Last message must be a user message to add attachments"
+                )
+            if isinstance(last_message["content"], str):
+                last_message["content"] = [
+                    TextBlockParam(type="text", text=last_message["content"])
+                ]
+            last_message["content"].extend(  # type: ignore[union-attr]
+                await async_prepare_files_for_prompt(
+                    self.hass, [(a.path, a.mime_type) for a in last_content.attachments]
+                )
+            )
+
+        if structure and structure_name:
+            structure_name = slugify(structure_name)
+            if model_args["thinking"]["type"] == "disabled":
+                if not tools:
+                    # Simplest case: no tools and no extended thinking
+                    # Add a tool and force its use
+                    model_args["tool_choice"] = ToolChoiceToolParam(
+                        type="tool",
+                        name=structure_name,
+                    )
+                else:
+                    # Second case: tools present but no extended thinking
+                    # Allow the model to use any tool but not text response
+                    # The model should know to use the right tool by its description
+                    model_args["tool_choice"] = ToolChoiceAnyParam(
+                        type="any",
+                    )
+            else:
+                # Extended thinking is enabled. With extended thinking, we cannot
+                # force tool use or disable text responses, so we add a hint to the
+                # system prompt instead. With extended thinking, the model should be
+                # smart enough to use the tool.
+                model_args["tool_choice"] = ToolChoiceAutoParam(
+                    type="auto",
+                )
+
+                if isinstance(model_args["system"], str):
+                    model_args["system"] = [
+                        TextBlockParam(type="text", text=model_args["system"])
+                    ]
+                model_args["system"].append(  # type: ignore[union-attr]
+                    TextBlockParam(
+                        type="text",
+                        text=f"Claude MUST use the '{structure_name}' tool to provide the final answer instead of plain text.",
+                    )
+                )
+
+            tools.append(
+                ToolParam(
+                    name=structure_name,
+                    description="Use this tool to reply to the user",
+                    input_schema=convert(
+                        structure,
+                        custom_serializer=chat_log.llm_api.custom_serializer
+                        if chat_log.llm_api
+                        else llm.selector_serializer,
+                    ),
+                )
+            )
+
        if tools:
            model_args["tools"] = tools

@@ -629,7 +735,11 @@ class AnthropicBaseLLMEntity(Entity):
                            content
                            async for content in chat_log.async_add_delta_content_stream(
                                self.entity_id,
-                                _transform_stream(chat_log, stream),
+                                _transform_stream(
+                                    chat_log,
+                                    stream,
+                                    output_tool=structure_name if structure else None,
+                                ),
                            )
                        ]
                    )
@@ -641,3 +751,59 @@ class AnthropicBaseLLMEntity(Entity):

            if not chat_log.unresponded_tool_results:
                break
+
+
+async def async_prepare_files_for_prompt(
+    hass: HomeAssistant, files: list[tuple[Path, str | None]]
+) -> Iterable[ImageBlockParam | DocumentBlockParam]:
+    """Append files to a prompt.
+
+    Caller needs to ensure that the files are allowed.
+    """
+
+    def append_files_to_content() -> Iterable[ImageBlockParam | DocumentBlockParam]:
+        content: list[ImageBlockParam | DocumentBlockParam] = []
+
+        for file_path, mime_type in files:
+            if not file_path.exists():
+                raise HomeAssistantError(f"`{file_path}` does not exist")
+
+            if mime_type is None:
+                mime_type = guess_file_type(file_path)[0]
+
+            if not mime_type or not mime_type.startswith(("image/", "application/pdf")):
+                raise HomeAssistantError(
+                    "Only images and PDF are supported by the Anthropic API,"
+                    f"`{file_path}` is not an image file or PDF"
+                )
+            if mime_type == "image/jpg":
+                mime_type = "image/jpeg"
+
+            base64_file = base64.b64encode(file_path.read_bytes()).decode("utf-8")
+
+            if mime_type.startswith("image/"):
+                content.append(
+                    ImageBlockParam(
+                        type="image",
+                        source=Base64ImageSourceParam(
+                            type="base64",
+                            media_type=mime_type,  # type: ignore[typeddict-item]
+                            data=base64_file,
+                        ),
+                    )
+                )
+            elif mime_type.startswith("application/pdf"):
+                content.append(
+                    DocumentBlockParam(
+                        type="document",
+                        source=Base64PDFSourceParam(
+                            type="base64",
+                            media_type=mime_type,  # type: ignore[typeddict-item]
+                            data=base64_file,
+                        ),
+                    )
+                )
+
+        return content
+
+    return await hass.async_add_executor_job(append_files_to_content)
--- a/homeassistant/components/anthropic/manifest.json
+++ b/homeassistant/components/anthropic/manifest.json
@@ -8,5 +8,5 @@
  "documentation": "https://www.home-assistant.io/integrations/anthropic",
  "integration_type": "service",
  "iot_class": "cloud_polling",
-  "requirements": ["anthropic==0.69.0"]
+  "requirements": ["anthropic==0.73.0"]
 }
--- a/homeassistant/components/anthropic/strings.json
+++ b/homeassistant/components/anthropic/strings.json
@@ -18,6 +18,49 @@
    }
  },
  "config_subentries": {
+    "ai_task_data": {
+      "abort": {
+        "entry_not_loaded": "[%key:component::anthropic::config_subentries::conversation::abort::entry_not_loaded%]",
+        "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]"
+      },
+      "entry_type": "AI task",
+      "initiate_flow": {
+        "reconfigure": "Reconfigure AI task",
+        "user": "Add AI task"
+      },
+      "step": {
+        "advanced": {
+          "data": {
+            "chat_model": "[%key:common::generic::model%]",
+            "max_tokens": "[%key:component::anthropic::config_subentries::conversation::step::advanced::data::max_tokens%]",
+            "temperature": "[%key:component::anthropic::config_subentries::conversation::step::advanced::data::temperature%]"
+          },
+          "title": "[%key:component::anthropic::config_subentries::conversation::step::advanced::title%]"
+        },
+        "init": {
+          "data": {
+            "name": "[%key:common::config_flow::data::name%]",
+            "recommended": "[%key:component::anthropic::config_subentries::conversation::step::init::data::recommended%]"
+          },
+          "title": "[%key:component::anthropic::config_subentries::conversation::step::init::title%]"
+        },
+        "model": {
+          "data": {
+            "thinking_budget": "[%key:component::anthropic::config_subentries::conversation::step::model::data::thinking_budget%]",
+            "user_location": "[%key:component::anthropic::config_subentries::conversation::step::model::data::user_location%]",
+            "web_search": "[%key:component::anthropic::config_subentries::conversation::step::model::data::web_search%]",
+            "web_search_max_uses": "[%key:component::anthropic::config_subentries::conversation::step::model::data::web_search_max_uses%]"
+          },
+          "data_description": {
+            "thinking_budget": "[%key:component::anthropic::config_subentries::conversation::step::model::data_description::thinking_budget%]",
+            "user_location": "[%key:component::anthropic::config_subentries::conversation::step::model::data_description::user_location%]",
+            "web_search": "[%key:component::anthropic::config_subentries::conversation::step::model::data_description::web_search%]",
+            "web_search_max_uses": "[%key:component::anthropic::config_subentries::conversation::step::model::data_description::web_search_max_uses%]"
+          },
+          "title": "[%key:component::anthropic::config_subentries::conversation::step::model::title%]"
+        }
+      }
+    },
    "conversation": {
      "abort": {
        "entry_not_loaded": "Cannot add things while the configuration is disabled.",
@@ -46,7 +89,8 @@
          },
          "data_description": {
            "prompt": "Instruct how the LLM should respond. This can be a template."
-          }
+          },
+          "title": "Basic settings"
        },
        "model": {
          "data": {
--- a/homeassistant/components/apcupsd/const.py
+++ b/homeassistant/components/apcupsd/const.py
@@ -7,3 +7,26 @@ CONNECTION_TIMEOUT: int = 10

 # Field name of last self test retrieved from apcupsd.
 LAST_S_TEST: Final = "laststest"
+
+# Mapping of deprecated sensor keys (as reported by apcupsd, lower-cased) to their deprecation
+# repair issue translation keys.
+DEPRECATED_SENSORS: Final = {
+    "apc": "apc_deprecated",
+    "end apc": "date_deprecated",
+    "date": "date_deprecated",
+    "apcmodel": "available_via_device_info",
+    "model": "available_via_device_info",
+    "firmware": "available_via_device_info",
+    "version": "available_via_device_info",
+    "upsname": "available_via_device_info",
+    "serialno": "available_via_device_info",
+}
+
+AVAILABLE_VIA_DEVICE_ATTR: Final = {
+    "apcmodel": "model",
+    "model": "model",
+    "firmware": "hw_version",
+    "version": "sw_version",
+    "upsname": "name",
+    "serialno": "serial_number",
+}
--- a/homeassistant/components/apcupsd/sensor.py
+++ b/homeassistant/components/apcupsd/sensor.py
@@ -4,6 +4,8 @@ from __future__ import annotations

 import logging

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

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

@@ -528,3 +532,62 @@ class APCUPSdSensor(APCUPSdEntity, SensorEntity):
        self._attr_native_value, inferred_unit = infer_unit(self.coordinator.data[key])
        if not self.native_unit_of_measurement:
            self._attr_native_unit_of_measurement = inferred_unit
+
+    async def async_added_to_hass(self) -> None:
+        """Handle when entity is added to Home Assistant.
+
+        If this is a deprecated sensor entity, create a repair issue to guide
+        the user to disable it.
+        """
+        await super().async_added_to_hass()
+
+        if not self.enabled:
+            return
+
+        reason = DEPRECATED_SENSORS.get(self.entity_description.key)
+        if not reason:
+            return
+
+        automations = automations_with_entity(self.hass, self.entity_id)
+        scripts = scripts_with_entity(self.hass, self.entity_id)
+        if not automations and not scripts:
+            return
+
+        entity_registry = er.async_get(self.hass)
+        items = [
+            f"- [{entry.name or entry.original_name or entity_id}]"
+            f"(/config/{integration}/edit/{entry.unique_id or entity_id.split('.', 1)[-1]})"
+            for integration, entities in (
+                ("automation", automations),
+                ("script", scripts),
+            )
+            for entity_id in entities
+            if (entry := entity_registry.async_get(entity_id))
+        ]
+        placeholders = {
+            "entity_name": str(self.name or self.entity_id),
+            "entity_id": self.entity_id,
+            "items": "\n".join(items),
+        }
+        if via_attr := AVAILABLE_VIA_DEVICE_ATTR.get(self.entity_description.key):
+            placeholders["available_via_device_attr"] = via_attr
+        if device_entry := self.device_entry:
+            placeholders["device_id"] = device_entry.id
+
+        ir.async_create_issue(
+            self.hass,
+            DOMAIN,
+            f"{reason}_{self.entity_id}",
+            breaks_in_ha_version="2026.6.0",
+            is_fixable=False,
+            severity=ir.IssueSeverity.WARNING,
+            translation_key=reason,
+            translation_placeholders=placeholders,
+        )
+
+    async def async_will_remove_from_hass(self) -> None:
+        """Handle when entity will be removed from Home Assistant."""
+        await super().async_will_remove_from_hass()
+
+        if issue_key := DEPRECATED_SENSORS.get(self.entity_description.key):
+            ir.async_delete_issue(self.hass, DOMAIN, f"{issue_key}_{self.entity_id}")
--- a/homeassistant/components/apcupsd/strings.json
+++ b/homeassistant/components/apcupsd/strings.json
@@ -241,5 +241,19 @@
    "cannot_connect": {
      "message": "Cannot connect to APC UPS Daemon."
    }
+  },
+  "issues": {
+    "apc_deprecated": {
+      "description": "The {entity_name} sensor (`{entity_id}`) is deprecated because it exposes internal details of the APC UPS Daemon response.\n\nIt is still referenced in the following automations or scripts:\n{items}\n\nUpdate those automations or scripts to use supported APC UPS entities instead. Reload the APC UPS Daemon integration afterwards to resolve this issue.",
+      "title": "{entity_name} sensor is deprecated"
+    },
+    "available_via_device_info": {
+      "description": "The {entity_name} sensor (`{entity_id}`) is deprecated because the same value is available from the device registry via `device_attr(\"{device_id}\", \"{available_via_device_attr}\")`.\n\nIt is still referenced in the following automations or scripts:\n{items}\n\nUpdate those automations or scripts to use the `device_attr` helper instead of this sensor. Reload the APC UPS Daemon integration afterwards to resolve this issue.",
+      "title": "{entity_name} sensor is deprecated"
+    },
+    "date_deprecated": {
+      "description": "The {entity_name} sensor (`{entity_id}`) is deprecated because the timestamp is already available from other APC UPS sensors via their last updated time.\n\nIt is still referenced in the following automations or scripts:\n{items}\n\nUpdate those automations or scripts to reference any entity's `last_updated` attribute instead (for example, `states.binary_sensor.apcups_online_status.last_updated`). Reload the APC UPS Daemon integration afterwards to resolve this issue.",
+      "title": "{entity_name} sensor is deprecated"
+    }
  }
 }
--- a/homeassistant/components/asuswrt/bridge.py
+++ b/homeassistant/components/asuswrt/bridge.py
@@ -111,8 +111,6 @@ def handle_errors_and_zip[_AsusWrtBridgeT: AsusWrtBridge](

            if isinstance(data, dict):
                return dict(zip(keys, list(data.values()), strict=False))
-            if not isinstance(data, (list, tuple)):
-                raise UpdateFailed("Received invalid data type")
            return dict(zip(keys, data, strict=False))

        return _wrapper
--- a/homeassistant/components/awair/manifest.json
+++ b/homeassistant/components/awair/manifest.json
@@ -6,7 +6,7 @@
  "documentation": "https://www.home-assistant.io/integrations/awair",
  "iot_class": "local_polling",
  "loggers": ["python_awair"],
-  "requirements": ["python-awair==0.2.4"],
+  "requirements": ["python-awair==0.2.5"],
  "zeroconf": [
    {
      "name": "awair*",
--- 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=COMPATIBLE_MODELS)
+                    SelectSelectorConfig(options=SELECTABLE_MODELS)
                ),
            }
        )
--- a/homeassistant/components/bang_olufsen/const.py
+++ b/homeassistant/components/bang_olufsen/const.py
@@ -62,6 +62,7 @@ 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"
@@ -71,7 +72,26 @@ 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
@@ -79,6 +99,7 @@ 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"
@@ -96,6 +117,7 @@ class WebsocketNotification(StrEnum):
    BEOLINK_AVAILABLE_LISTENERS = "beolinkAvailableListeners"
    CONFIGURATION = "configuration"
    NOTIFICATION = "notification"
+    REMOTE_CONTROL_DEVICES = "remoteControlDevices"
    REMOTE_MENU_CHANGED = "remoteMenuChanged"

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

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

 # Attribute names for zeroconf discovery.
 ATTR_TYPE_NUMBER: Final[str] = "tn"
@@ -204,29 +230,16 @@ 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",
@@ -236,18 +249,7 @@ EVENT_TRANSLATION_MAP: dict[str, str] = {

 CONNECTION_STATUS: Final[str] = "CONNECTION_STATUS"

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


 DEVICE_BUTTON_EVENTS: Final[list[str]] = [
@@ -258,6 +260,70 @@ 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,11 +6,13 @@ 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 DEVICE_BUTTONS, DOMAIN
+from .const import DOMAIN
+from .util import get_device_buttons


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

    # Add button Event entity states (if enabled)
-    for device_button in DEVICE_BUTTONS:
+    for device_button in get_device_buttons(config_entry.data[CONF_MODEL]):
        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,22 +2,34 @@

 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,
-    DEVICE_BUTTONS,
-    MODEL_SUPPORT_DEVICE_BUTTONS,
-    MODEL_SUPPORT_MAP,
+    DOMAIN,
+    MANUFACTURER,
+    BangOlufsenModel,
    WebsocketNotification,
 )
 from .entity import BangOlufsenEntity
+from .util import get_device_buttons, get_remotes

 PARALLEL_UPDATES = 0

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

-    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
+    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
+            ]
        )

+        # 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)
+            ]
+        )

-class BangOlufsenButtonEvent(BangOlufsenEntity, EventEntity):
-    """Event class for Button events."""
+    # 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."""

    _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, config_entry.runtime_data.client)
+        super().__init__(config_entry)

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

@@ -59,20 +133,65 @@ class BangOlufsenButtonEvent(BangOlufsenEntity, EventEntity):
        self.async_on_remove(
            async_dispatcher_connect(
                self.hass,
-                f"{self._unique_id}_{CONNECTION_STATUS}",
+                f"{DOMAIN}_{self._unique_id}_{CONNECTION_STATUS}",
                self._async_update_connection_state,
            )
        )
        self.async_on_remove(
            async_dispatcher_connect(
                self.hass,
-                f"{self._unique_id}_{WebsocketNotification.BUTTON}_{self._button_type}",
+                f"{DOMAIN}_{self._unique_id}_{WebsocketNotification.BUTTON}_{self._button_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()
+
+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,
+            )
+        )
--- a/homeassistant/components/bang_olufsen/icons.json
+++ b/homeassistant/components/bang_olufsen/icons.json
@@ -1,4 +1,278 @@
 {
+  "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,6 +80,7 @@ from .const import (
    CONNECTION_STATUS,
    DOMAIN,
    FALLBACK_SOURCES,
+    MANUFACTURER,
    VALID_MEDIA_TYPES,
    BangOlufsenMediaType,
    BangOlufsenSource,
@@ -201,7 +202,7 @@ class BangOlufsenMediaPlayer(BangOlufsenEntity, MediaPlayerEntity):
        self._attr_device_info = DeviceInfo(
            configuration_url=f"http://{self._host}/#/",
            identifiers={(DOMAIN, self._unique_id)},
-            manufacturer="Bang & Olufsen",
+            manufacturer=MANUFACTURER,
            model=self._model,
            serial_number=self._unique_id,
        )
@@ -249,7 +250,7 @@ class BangOlufsenMediaPlayer(BangOlufsenEntity, MediaPlayerEntity):
            self.async_on_remove(
                async_dispatcher_connect(
                    self.hass,
-                    f"{self._unique_id}_{signal}",
+                    f"{DOMAIN}_{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,11 +2,16 @@

 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 DOMAIN
+from .const import DEVICE_BUTTONS, DOMAIN, BangOlufsenButtons, BangOlufsenModel


 def get_device(hass: HomeAssistant, unique_id: str) -> DeviceEntry:
@@ -21,3 +26,30 @@ 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,6 +6,7 @@ import logging
 from typing import TYPE_CHECKING

 from mozart_api.models import (
+    BeoRemoteButton,
    ButtonEvent,
    ListeningModeProps,
    PlaybackContentMetadata,
@@ -28,11 +29,13 @@ 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
+from .util import get_device, get_remotes

 _LOGGER = logging.getLogger(__name__)

@@ -57,6 +60,9 @@ 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(
@@ -87,7 +93,7 @@ class BangOlufsenWebsocket(BangOlufsenBase):
        """Update all entities of the connection status."""
        async_dispatcher_send(
            self.hass,
-            f"{self._unique_id}_{CONNECTION_STATUS}",
+            f"{DOMAIN}_{self._unique_id}_{CONNECTION_STATUS}",
            self._client.websocket_connected,
        )

@@ -105,10 +111,22 @@ class BangOlufsenWebsocket(BangOlufsenBase):
        """Send active_listening_mode dispatch."""
        async_dispatcher_send(
            self.hass,
-            f"{self._unique_id}_{WebsocketNotification.ACTIVE_LISTENING_MODE}",
+            f"{DOMAIN}_{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.
@@ -118,11 +136,11 @@ class BangOlufsenWebsocket(BangOlufsenBase):
        # Send to event entity
        async_dispatcher_send(
            self.hass,
-            f"{self._unique_id}_{WebsocketNotification.BUTTON}_{notification.button}",
+            f"{DOMAIN}_{self._unique_id}_{WebsocketNotification.BUTTON}_{notification.button}",
            EVENT_TRANSLATION_MAP[notification.state],
        )

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

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

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

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

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

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

@@ -203,7 +248,7 @@ class BangOlufsenWebsocket(BangOlufsenBase):
        """Send volume dispatch."""
        async_dispatcher_send(
            self.hass,
-            f"{self._unique_id}_{WebsocketNotification.VOLUME}",
+            f"{DOMAIN}_{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==2.45.0",
+    "dbus-fast==3.1.2",
    "habluetooth==5.7.0"
  ]
 }
--- 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=coordinator.brother.model,
+            model_id=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,7 +8,8 @@
  "integration_type": "device",
  "iot_class": "local_polling",
  "loggers": ["brother", "pyasn1", "pysmi", "pysnmp"],
-  "requirements": ["brother==5.1.1"],
+  "quality_scale": "platinum",
+  "requirements": ["brother==6.0.0"],
  "zeroconf": [
    {
      "name": "brother*",
--- a/homeassistant/components/brother/quality_scale.yaml
+++ b/homeassistant/components/brother/quality_scale.yaml
@@ -0,0 +1,78 @@
+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, callback
+from homeassistant.core import HomeAssistant
 from homeassistant.helpers import entity_registry as er
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.typing import StateType
@@ -345,12 +345,10 @@ 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

-    @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()
+    @property
+    def native_value(self) -> StateType | datetime:
+        """Return the native value of the sensor."""
+        return self.entity_description.value(self.coordinator.data)
--- a/homeassistant/components/bsblan/climate.py
+++ b/homeassistant/components/bsblan/climate.py
@@ -74,8 +74,11 @@ class BSBLANClimate(BSBLanEntity, ClimateEntity):
        super().__init__(data.fast_coordinator, data)
        self._attr_unique_id = f"{format_mac(data.device.MAC)}-climate"

-        self._attr_min_temp = data.static.min_temp.value
-        self._attr_max_temp = data.static.max_temp.value
+        # Set temperature range if available, otherwise use Home Assistant defaults
+        if data.static.min_temp is not None and data.static.min_temp.value is not None:
+            self._attr_min_temp = data.static.min_temp.value
+        if data.static.max_temp is not None and data.static.max_temp.value is not None:
+            self._attr_max_temp = data.static.max_temp.value
        self._attr_temperature_unit = data.fast_coordinator.client.get_temperature_unit

    @property
--- a/homeassistant/components/bsblan/manifest.json
+++ b/homeassistant/components/bsblan/manifest.json
@@ -7,7 +7,7 @@
  "integration_type": "device",
  "iot_class": "local_polling",
  "loggers": ["bsblan"],
-  "requirements": ["python-bsblan==3.1.0"],
+  "requirements": ["python-bsblan==3.1.1"],
  "zeroconf": [
    {
      "name": "bsb-lan*",
--- 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 cast
+from typing import Any, cast

 from hass_nabucasa import Cloud
 import voluptuous as vol
@@ -55,6 +55,7 @@ from .const import (
    CONF_ALIASES,
    CONF_API_SERVER,
    CONF_COGNITO_CLIENT_ID,
+    CONF_DISCOVERY_SERVICE_ACTIONS,
    CONF_ENTITY_CONFIG,
    CONF_FILTER,
    CONF_GOOGLE_ACTIONS,
@@ -85,6 +86,10 @@ 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(
@@ -139,6 +144,7 @@ CONFIG_SCHEMA = vol.Schema(
                {
                    vol.Required(CONF_MODE): vol.In([MODE_DEV]),
                    vol.Required(CONF_API_SERVER): str,
+                    vol.Optional(CONF_DISCOVERY_SERVICE_ACTIONS): {str: cv.url},
                }
            ),
            _BASE_CONFIG_SCHEMA.extend(
@@ -240,6 +246,24 @@ 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:
@@ -287,7 +311,7 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:

    hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, _shutdown)

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

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


@callback
-def _remote_handle_prefs_updated(cloud: Cloud[CloudClient]) -> None:
-    """Handle remote preferences updated."""
-    cur_pref = cloud.client.prefs.remote_enabled
+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
    lock = asyncio.Lock()

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

+        # Lock protects cur_ state variables from concurrent updates
        async with lock:
-            if prefs.remote_enabled == cur_pref:
+            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:
                return

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

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


 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
--- a/homeassistant/components/cloud/const.py
+++ b/homeassistant/components/cloud/const.py
@@ -79,6 +79,7 @@ CONF_ACCOUNT_LINK_SERVER = "account_link_server"
 CONF_ACCOUNTS_SERVER = "accounts_server"
 CONF_ACME_SERVER = "acme_server"
 CONF_API_SERVER = "api_server"
+CONF_DISCOVERY_SERVICE_ACTIONS = "discovery_service_actions"
 CONF_RELAYER_SERVER = "relayer_server"
 CONF_REMOTESTATE_SERVER = "remotestate_server"
 CONF_SERVICEHANDLERS_SERVER = "servicehandlers_server"
--- 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.5.1"],
+  "requirements": ["hass-nabucasa==1.6.0"],
  "single_config_entry": true
 }
--- a/homeassistant/components/comelit/config_flow.py
+++ b/homeassistant/components/comelit/config_flow.py
@@ -37,13 +37,6 @@ USER_SCHEMA = vol.Schema(
    }
 )
 STEP_REAUTH_DATA_SCHEMA = vol.Schema({vol.Required(CONF_PIN): cv.string})
-STEP_RECONFIGURE = vol.Schema(
-    {
-        vol.Required(CONF_HOST): cv.string,
-        vol.Required(CONF_PORT): cv.port,
-        vol.Optional(CONF_PIN, default=DEFAULT_PIN): cv.string,
-    }
-)


 async def validate_input(hass: HomeAssistant, data: dict[str, Any]) -> dict[str, str]:
@@ -175,36 +168,55 @@ class ComelitConfigFlow(ConfigFlow, domain=DOMAIN):
    ) -> ConfigFlowResult:
        """Handle reconfiguration of the device."""
        reconfigure_entry = self._get_reconfigure_entry()
-        if not user_input:
-            return self.async_show_form(
-                step_id="reconfigure", data_schema=STEP_RECONFIGURE
-            )
-
-        updated_host = user_input[CONF_HOST]
-
-        self._async_abort_entries_match({CONF_HOST: updated_host})
-
        errors: dict[str, str] = {}

-        try:
-            await validate_input(self.hass, user_input)
-        except CannotConnect:
-            errors["base"] = "cannot_connect"
-        except InvalidAuth:
-            errors["base"] = "invalid_auth"
-        except InvalidPin:
-            errors["base"] = "invalid_pin"
-        except Exception:  # noqa: BLE001
-            _LOGGER.exception("Unexpected exception")
-            errors["base"] = "unknown"
-        else:
-            return self.async_update_reload_and_abort(
-                reconfigure_entry, data_updates={CONF_HOST: updated_host}
-            )
+        if user_input is not None:
+            updated_host = user_input[CONF_HOST]
+
+            self._async_abort_entries_match({CONF_HOST: updated_host})
+
+            try:
+                data_to_validate = {
+                    CONF_HOST: updated_host,
+                    CONF_PORT: user_input[CONF_PORT],
+                    CONF_PIN: user_input[CONF_PIN],
+                    CONF_TYPE: reconfigure_entry.data.get(CONF_TYPE, BRIDGE),
+                }
+                await validate_input(self.hass, data_to_validate)
+            except CannotConnect:
+                errors["base"] = "cannot_connect"
+            except InvalidAuth:
+                errors["base"] = "invalid_auth"
+            except InvalidPin:
+                errors["base"] = "invalid_pin"
+            except Exception:  # noqa: BLE001
+                _LOGGER.exception("Unexpected exception")
+                errors["base"] = "unknown"
+            else:
+                data_updates = {
+                    CONF_HOST: updated_host,
+                    CONF_PORT: user_input[CONF_PORT],
+                    CONF_PIN: user_input[CONF_PIN],
+                }
+                return self.async_update_reload_and_abort(
+                    reconfigure_entry, data_updates=data_updates
+                )
+
+        schema = vol.Schema(
+            {
+                vol.Required(
+                    CONF_HOST, default=reconfigure_entry.data[CONF_HOST]
+                ): cv.string,
+                vol.Required(
+                    CONF_PORT, default=reconfigure_entry.data[CONF_PORT]
+                ): cv.port,
+                vol.Optional(CONF_PIN): cv.string,
+            }
+        )

        return self.async_show_form(
            step_id="reconfigure",
-            data_schema=STEP_RECONFIGURE,
+            data_schema=schema,
            errors=errors,
        )

--- a/homeassistant/components/config/area_registry.py
+++ b/homeassistant/components/config/area_registry.py
@@ -18,6 +18,7 @@ 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


@@ -145,3 +146,27 @@ 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,6 +18,7 @@ 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


@@ -127,6 +128,28 @@ 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/init.py
+++ b/homeassistant/components/conversation/init.py
@@ -4,7 +4,7 @@ from __future__ import annotations

 from collections.abc import Callable
 import logging
-from typing import Literal
+from typing import Any, Literal

 from hassil.recognize import RecognizeResult
 import voluptuous as vol
@@ -21,6 +21,7 @@ from homeassistant.core import (
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import config_validation as cv, intent
 from homeassistant.helpers.entity_component import EntityComponent
+from homeassistant.helpers.reload import async_integration_yaml_config
 from homeassistant.helpers.typing import ConfigType
 from homeassistant.loader import bind_hass

@@ -52,6 +53,8 @@ from .const import (
    DATA_COMPONENT,
    DOMAIN,
    HOME_ASSISTANT_AGENT,
+    METADATA_CUSTOM_FILE,
+    METADATA_CUSTOM_SENTENCE,
    SERVICE_PROCESS,
    SERVICE_RELOAD,
    ConversationEntityFeature,
@@ -266,10 +269,13 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
    entity_component = EntityComponent[ConversationEntity](_LOGGER, DOMAIN, hass)
    hass.data[DATA_COMPONENT] = entity_component

-    agent_config = config.get(DOMAIN, {})
-    await async_setup_default_agent(
-        hass, entity_component, config_intents=agent_config.get("intents", {})
-    )
+    manager = get_agent_manager(hass)
+
+    hass_config_path = hass.config.path()
+    config_intents = _get_config_intents(config, hass_config_path)
+    manager.update_config_intents(config_intents)
+
+    await async_setup_default_agent(hass, entity_component)

    async def handle_process(service: ServiceCall) -> ServiceResponse:
        """Parse text into commands."""
@@ -294,9 +300,16 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:

    async def handle_reload(service: ServiceCall) -> None:
        """Reload intents."""
-        agent = get_agent_manager(hass).default_agent
+        language = service.data.get(ATTR_LANGUAGE)
+        if language is None:
+            conf = await async_integration_yaml_config(hass, DOMAIN)
+            if conf is not None:
+                config_intents = _get_config_intents(conf, hass_config_path)
+                manager.update_config_intents(config_intents)
+
+        agent = manager.default_agent
        if agent is not None:
-            await agent.async_reload(language=service.data.get(ATTR_LANGUAGE))
+            await agent.async_reload(language=language)

    hass.services.async_register(
        DOMAIN,
@@ -313,6 +326,27 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
    return True


+def _get_config_intents(config: ConfigType, hass_config_path: str) -> dict[str, Any]:
+    """Return config intents."""
+    intents = config.get(DOMAIN, {}).get("intents", {})
+    return {
+        "intents": {
+            intent_name: {
+                "data": [
+                    {
+                        "sentences": sentences,
+                        "metadata": {
+                            METADATA_CUSTOM_SENTENCE: True,
+                            METADATA_CUSTOM_FILE: hass_config_path,
+                        },
+                    }
+                ]
+            }
+            for intent_name, sentences in intents.items()
+        }
+    }
+
+
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
    """Set up a config entry."""
    return await hass.data[DATA_COMPONENT].async_setup_entry(entry)
--- a/homeassistant/components/conversation/agent_manager.py
+++ b/homeassistant/components/conversation/agent_manager.py
@@ -147,6 +147,7 @@ class AgentManager:
        self.hass = hass
        self._agents: dict[str, AbstractConversationAgent] = {}
        self.default_agent: DefaultAgent | None = None
+        self.config_intents: dict[str, Any] = {}
        self.triggers_details: list[TriggerDetails] = []

    @callback
@@ -199,9 +200,16 @@ class AgentManager:

    async def async_setup_default_agent(self, agent: DefaultAgent) -> None:
        """Set up the default agent."""
+        agent.update_config_intents(self.config_intents)
        agent.update_triggers(self.triggers_details)
        self.default_agent = agent

+    def update_config_intents(self, intents: dict[str, Any]) -> None:
+        """Update config intents."""
+        self.config_intents = intents
+        if self.default_agent is not None:
+            self.default_agent.update_config_intents(intents)
+
    def register_trigger(self, trigger_details: TriggerDetails) -> CALLBACK_TYPE:
        """Register a trigger."""
        self.triggers_details.append(trigger_details)
--- a/homeassistant/components/conversation/chat_log.py
+++ b/homeassistant/components/conversation/chat_log.py
@@ -7,6 +7,7 @@ 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
@@ -16,14 +17,18 @@ 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(
@@ -31,6 +36,40 @@ 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,
@@ -63,6 +102,8 @@ 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:
@@ -71,6 +112,15 @@ 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))

@@ -84,14 +134,28 @@ 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 session.conversation_id not in all_chat_logs:
+    if is_new_log:

        @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)

@@ -100,6 +164,16 @@ 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.
@@ -129,6 +203,15 @@ 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)
@@ -138,6 +221,20 @@ 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)
@@ -153,6 +250,14 @@ 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:
@@ -164,6 +269,22 @@ 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)
@@ -175,6 +296,18 @@ 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
@@ -210,6 +343,16 @@ 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:
@@ -241,6 +384,12 @@ 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(
@@ -259,6 +408,12 @@ 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,
@@ -317,6 +472,14 @@ 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(
@@ -593,6 +756,12 @@ 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
+from enum import IntFlag, StrEnum
 from typing import TYPE_CHECKING

 from homeassistant.util.hass_dict import HassKey
@@ -30,3 +30,17 @@ class ConversationEntityFeature(IntFlag):
    """Supported features of the conversation entity."""

    CONTROL = 1
+
+
+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/homeassistant/components/conversation/default_agent.py
+++ b/homeassistant/components/conversation/default_agent.py
@@ -77,7 +77,12 @@ from homeassistant.util.json import JsonObjectType, json_loads_object

 from .agent_manager import get_agent_manager
 from .chat_log import AssistantContent, ChatLog
-from .const import DOMAIN, ConversationEntityFeature
+from .const import (
+    DOMAIN,
+    METADATA_CUSTOM_FILE,
+    METADATA_CUSTOM_SENTENCE,
+    ConversationEntityFeature,
+)
 from .entity import ConversationEntity
 from .models import ConversationInput, ConversationResult
 from .trace import ConversationTraceEventType, async_conversation_trace_append
@@ -91,8 +96,6 @@ _ENTITY_REGISTRY_UPDATE_FIELDS = ["aliases", "name", "original_name"]

 _DEFAULT_EXPOSED_ATTRIBUTES = {"device_class"}

-METADATA_CUSTOM_SENTENCE = "hass_custom_sentence"
-METADATA_CUSTOM_FILE = "hass_custom_file"
 METADATA_FUZZY_MATCH = "hass_fuzzy_match"

 ERROR_SENTINEL = object()
@@ -202,10 +205,9 @@ class IntentCache:
 async def async_setup_default_agent(
    hass: HomeAssistant,
    entity_component: EntityComponent[ConversationEntity],
-    config_intents: dict[str, Any],
 ) -> None:
    """Set up entity registry listener for the default agent."""
-    agent = DefaultAgent(hass, config_intents)
+    agent = DefaultAgent(hass)
    await entity_component.async_add_entities([agent])
    await get_agent_manager(hass).async_setup_default_agent(agent)

@@ -230,14 +232,14 @@ class DefaultAgent(ConversationEntity):
    _attr_name = "Home Assistant"
    _attr_supported_features = ConversationEntityFeature.CONTROL

-    def __init__(self, hass: HomeAssistant, config_intents: dict[str, Any]) -> None:
+    def __init__(self, hass: HomeAssistant) -> None:
        """Initialize the default agent."""
        self.hass = hass
        self._lang_intents: dict[str, LanguageIntents | object] = {}
        self._load_intents_lock = asyncio.Lock()

-        # intent -> [sentences]
-        self._config_intents: dict[str, Any] = config_intents
+        # Intents from common conversation config
+        self._config_intents: dict[str, Any] = {}

        # Sentences that will trigger a callback (skipping intent recognition)
        self._triggers_details: list[TriggerDetails] = []
@@ -1035,6 +1037,14 @@ class DefaultAgent(ConversationEntity):
        # Intents have changed, so we must clear the cache
        self._intent_cache.clear()

+    @callback
+    def update_config_intents(self, intents: dict[str, Any]) -> None:
+        """Update config intents."""
+        self._config_intents = intents
+
+        # Intents have changed, so we must clear the cache
+        self._intent_cache.clear()
+
    async def async_prepare(self, language: str | None = None) -> None:
        """Load intents for a language."""
        if language is None:
@@ -1159,33 +1169,10 @@ class DefaultAgent(ConversationEntity):
                    custom_sentences_path,
                )

-        # Load sentences from HA config for default language only
-        if self._config_intents and (
-            self.hass.config.language in (language, language_variant)
-        ):
-            hass_config_path = self.hass.config.path()
-            merge_dict(
-                intents_dict,
-                {
-                    "intents": {
-                        intent_name: {
-                            "data": [
-                                {
-                                    "sentences": sentences,
-                                    "metadata": {
-                                        METADATA_CUSTOM_SENTENCE: True,
-                                        METADATA_CUSTOM_FILE: hass_config_path,
-                                    },
-                                }
-                            ]
-                        }
-                        for intent_name, sentences in self._config_intents.items()
-                    }
-                },
-            )
-            _LOGGER.debug(
-                "Loaded intents from configuration.yaml",
-            )
+        merge_dict(
+            intents_dict,
+            self._config_intents,
+        )

        if not intents_dict:
            return None
--- a/homeassistant/components/conversation/http.py
+++ b/homeassistant/components/conversation/http.py
@@ -12,6 +12,7 @@ from homeassistant.components import http, websocket_api
 from homeassistant.components.http.data_validator import RequestDataValidator
 from homeassistant.const import MATCH_ALL
 from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers.chat_session import async_get_chat_session
 from homeassistant.util import language as language_util

 from .agent_manager import (
@@ -20,7 +21,8 @@ from .agent_manager import (
    async_get_agent,
    get_agent_manager,
 )
-from .const import DATA_COMPONENT
+from .chat_log import DATA_CHAT_LOGS, async_get_chat_log, async_subscribe_chat_logs
+from .const import DATA_COMPONENT, ChatLogEventType
 from .entity import ConversationEntity
 from .models import ConversationInput

@@ -35,6 +37,8 @@ def async_setup(hass: HomeAssistant) -> None:
    websocket_api.async_register_command(hass, websocket_list_sentences)
    websocket_api.async_register_command(hass, websocket_hass_agent_debug)
    websocket_api.async_register_command(hass, websocket_hass_agent_language_scores)
+    websocket_api.async_register_command(hass, websocket_subscribe_chat_log)
+    websocket_api.async_register_command(hass, websocket_subscribe_chat_log_index)


@websocket_api.websocket_command(
@@ -265,3 +269,114 @@ class ConversationProcessView(http.HomeAssistantView):
        )

        return self.json(result.as_dict())
+
+
+@websocket_api.websocket_command(
+    {
+        vol.Required("type"): "conversation/chat_log/subscribe",
+        vol.Required("conversation_id"): str,
+    }
+)
+@websocket_api.require_admin
+def websocket_subscribe_chat_log(
+    hass: HomeAssistant,
+    connection: websocket_api.ActiveConnection,
+    msg: dict[str, Any],
+) -> None:
+    """Subscribe to a chat log."""
+    msg_id = msg["id"]
+    subscribed_conversation = msg["conversation_id"]
+
+    chat_logs = hass.data.get(DATA_CHAT_LOGS)
+
+    if not chat_logs or subscribed_conversation not in chat_logs:
+        connection.send_error(
+            msg_id,
+            websocket_api.ERR_NOT_FOUND,
+            "Conversation chat log not found",
+        )
+        return
+
+    @callback
+    def forward_events(conversation_id: str, event_type: str, data: dict) -> None:
+        """Forward chat log events to websocket connection."""
+        if conversation_id != subscribed_conversation:
+            return
+
+        connection.send_event(
+            msg_id,
+            {
+                "conversation_id": conversation_id,
+                "event_type": event_type,
+                "data": data,
+            },
+        )
+
+        if event_type == ChatLogEventType.DELETED:
+            unsubscribe()
+            del connection.subscriptions[msg_id]
+
+    unsubscribe = async_subscribe_chat_logs(hass, forward_events)
+    connection.subscriptions[msg_id] = unsubscribe
+    connection.send_result(msg_id)
+
+    with (
+        async_get_chat_session(hass, subscribed_conversation) as session,
+        async_get_chat_log(hass, session) as chat_log,
+    ):
+        connection.send_event(
+            msg_id,
+            {
+                "event_type": ChatLogEventType.INITIAL_STATE,
+                "data": chat_log.as_dict(),
+            },
+        )
+
+
+@websocket_api.websocket_command(
+    {
+        vol.Required("type"): "conversation/chat_log/subscribe_index",
+    }
+)
+@websocket_api.require_admin
+def websocket_subscribe_chat_log_index(
+    hass: HomeAssistant,
+    connection: websocket_api.ActiveConnection,
+    msg: dict[str, Any],
+) -> None:
+    """Subscribe to a chat log."""
+    msg_id = msg["id"]
+
+    @callback
+    def forward_events(
+        conversation_id: str, event_type: ChatLogEventType, data: dict
+    ) -> None:
+        """Forward chat log events to websocket connection."""
+        if event_type not in (ChatLogEventType.CREATED, ChatLogEventType.DELETED):
+            return
+
+        connection.send_event(
+            msg_id,
+            {
+                "conversation_id": conversation_id,
+                "event_type": event_type,
+                "data": data,
+            },
+        )
+
+    unsubscribe = async_subscribe_chat_logs(hass, forward_events)
+    connection.subscriptions[msg["id"]] = unsubscribe
+    connection.send_result(msg["id"])
+
+    chat_logs = hass.data.get(DATA_CHAT_LOGS)
+
+    if not chat_logs:
+        return
+
+    connection.send_event(
+        msg_id,
+        {
+            "event_type": ChatLogEventType.INITIAL_STATE,
+            "data": [c.as_dict() for c in chat_logs.values()],
+        },
+    )
--- a/homeassistant/components/conversation/manifest.json
+++ b/homeassistant/components/conversation/manifest.json
@@ -6,5 +6,5 @@
  "documentation": "https://www.home-assistant.io/integrations/conversation",
  "integration_type": "entity",
  "quality_scale": "internal",
-  "requirements": ["hassil==3.4.0", "home-assistant-intents==2025.11.7"]
+  "requirements": ["hassil==3.4.0", "home-assistant-intents==2025.11.24"]
 }
--- a/homeassistant/components/cosori/init.py
+++ b/homeassistant/components/cosori/init.py
@@ -0,0 +1 @@
+"""Virtual integration: Cosori."""
--- a/homeassistant/components/cosori/manifest.json
+++ b/homeassistant/components/cosori/manifest.json
@@ -0,0 +1,6 @@
+{
+  "domain": "cosori",
+  "name": "Cosori",
+  "integration_type": "virtual",
+  "supported_by": "vesync"
+}
--- a/homeassistant/components/cync/init.py
+++ b/homeassistant/components/cync/init.py
@@ -9,6 +9,7 @@ from homeassistant.const import CONF_ACCESS_TOKEN, Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.util.ssl import get_default_context

 from .const import (
    CONF_AUTHORIZE_STRING,
@@ -31,9 +32,13 @@ async def async_setup_entry(hass: HomeAssistant, entry: CyncConfigEntry) -> bool
        expires_at=entry.data[CONF_EXPIRES_AT],
    )
    cync_auth = Auth(async_get_clientsession(hass), user=user_info)
+    ssl_context = get_default_context()

    try:
-        cync = await Cync.create(cync_auth)
+        cync = await Cync.create(
+            auth=cync_auth,
+            ssl_context=ssl_context,
+        )
    except AuthFailedError as ex:
        raise ConfigEntryAuthFailed("User token invalid") from ex
    except CyncError as ex:
--- a/homeassistant/components/decora_wifi/light.py
+++ b/homeassistant/components/decora_wifi/light.py
@@ -2,6 +2,7 @@

 from __future__ import annotations

+from datetime import timedelta
 import logging
 from typing import Any

@@ -25,6 +26,7 @@ from homeassistant.core import HomeAssistant
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
+from homeassistant.util import Throttle

 _LOGGER = logging.getLogger(__name__)

@@ -167,6 +169,7 @@ class DecoraWifiLight(LightEntity):
        except ValueError:
            _LOGGER.error("Failed to turn off myLeviton switch")

+    @Throttle(timedelta(seconds=30))
    def update(self) -> None:
        """Fetch new state data for this switch."""
        try:
--- a/homeassistant/components/derivative/icons.json
+++ b/homeassistant/components/derivative/icons.json
@@ -5,5 +5,10 @@
        "default": "mdi:chart-line"
      }
    }
+  },
+  "services": {
+    "reload": {
+      "service": "mdi:reload"
+    }
  }
 }
--- a/homeassistant/components/derivative/sensor.py
+++ b/homeassistant/components/derivative/sensor.py
@@ -20,8 +20,10 @@ from homeassistant.const import (
    ATTR_UNIT_OF_MEASUREMENT,
    CONF_NAME,
    CONF_SOURCE,
+    CONF_UNIQUE_ID,
    STATE_UNAVAILABLE,
    STATE_UNKNOWN,
+    Platform,
    UnitOfTime,
 )
 from homeassistant.core import (
@@ -44,6 +46,7 @@ from homeassistant.helpers.event import (
    async_track_state_change_event,
    async_track_state_report_event,
 )
+from homeassistant.helpers.reload import async_setup_reload_service
 from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType

 from .const import (
@@ -53,6 +56,7 @@ from .const import (
    CONF_UNIT,
    CONF_UNIT_PREFIX,
    CONF_UNIT_TIME,
+    DOMAIN,
 )

 _LOGGER = logging.getLogger(__name__)
@@ -85,6 +89,7 @@ DEFAULT_TIME_WINDOW = 0
 PLATFORM_SCHEMA = SENSOR_PLATFORM_SCHEMA.extend(
    {
        vol.Optional(CONF_NAME): cv.string,
+        vol.Optional(CONF_UNIQUE_ID): cv.string,
        vol.Required(CONF_SOURCE): cv.entity_id,
        vol.Optional(CONF_ROUND_DIGITS, default=DEFAULT_ROUND): vol.Coerce(int),
        vol.Optional(CONF_UNIT_PREFIX, default=None): vol.In(UNIT_PREFIXES),
@@ -145,6 +150,8 @@ async def async_setup_platform(
    discovery_info: DiscoveryInfoType | None = None,
 ) -> None:
    """Set up the derivative sensor."""
+    await async_setup_reload_service(hass, DOMAIN, [Platform.SENSOR])
+
    derivative = DerivativeSensor(
        hass,
        name=config.get(CONF_NAME),
@@ -154,7 +161,7 @@ async def async_setup_platform(
        unit_of_measurement=config.get(CONF_UNIT),
        unit_prefix=config[CONF_UNIT_PREFIX],
        unit_time=config[CONF_UNIT_TIME],
-        unique_id=None,
+        unique_id=config.get(CONF_UNIQUE_ID),
        max_sub_interval=config.get(CONF_MAX_SUB_INTERVAL),
    )

@@ -286,14 +293,14 @@ class DerivativeSensor(RestoreSensor, SensorEntity):
        )
        self.async_write_ha_state()

-    async def async_added_to_hass(self) -> None:
-        """Handle entity which will be added."""
-        await super().async_added_to_hass()
+    async def _handle_restore(self) -> None:
        restored_data = await self.async_get_last_sensor_data()
        if restored_data:
-            self._attr_native_unit_of_measurement = (
-                restored_data.native_unit_of_measurement
-            )
+            if self._attr_native_unit_of_measurement is None:
+                # Only restore the unit if it's not assigned from YAML
+                self._attr_native_unit_of_measurement = (
+                    restored_data.native_unit_of_measurement
+                )
            try:
                self._attr_native_value = round(
                    Decimal(restored_data.native_value),  # type: ignore[arg-type]
@@ -302,6 +309,11 @@ class DerivativeSensor(RestoreSensor, SensorEntity):
            except (InvalidOperation, TypeError):
                self._attr_native_value = None

+    async def async_added_to_hass(self) -> None:
+        """Handle entity which will be added."""
+        await super().async_added_to_hass()
+        await self._handle_restore()
+
        source_state = self.hass.states.get(self._sensor_source_id)
        self._derive_and_set_attributes_from_state(source_state)

--- a/homeassistant/components/derivative/services.yaml
+++ b/homeassistant/components/derivative/services.yaml
@@ -0,0 +1 @@
+reload:
--- a/homeassistant/components/derivative/strings.json
+++ b/homeassistant/components/derivative/strings.json
@@ -58,5 +58,11 @@
      }
    }
  },
+  "services": {
+    "reload": {
+      "description": "Reloads derivative sensors from the YAML-configuration.",
+      "name": "[%key:common::action::reload%]"
+    }
+  },
  "title": "Derivative sensor"
 }
--- a/homeassistant/components/dlna_dmr/manifest.json
+++ b/homeassistant/components/dlna_dmr/manifest.json
@@ -8,7 +8,7 @@
  "documentation": "https://www.home-assistant.io/integrations/dlna_dmr",
  "iot_class": "local_push",
  "loggers": ["async_upnp_client"],
-  "requirements": ["async-upnp-client==0.45.0", "getmac==0.9.5"],
+  "requirements": ["async-upnp-client==0.46.0", "getmac==0.9.5"],
  "ssdp": [
    {
      "deviceType": "urn:schemas-upnp-org:device:MediaRenderer:1",
--- a/homeassistant/components/dlna_dms/manifest.json
+++ b/homeassistant/components/dlna_dms/manifest.json
@@ -7,7 +7,7 @@
  "dependencies": ["ssdp"],
  "documentation": "https://www.home-assistant.io/integrations/dlna_dms",
  "iot_class": "local_polling",
-  "requirements": ["async-upnp-client==0.45.0"],
+  "requirements": ["async-upnp-client==0.46.0"],
  "ssdp": [
    {
      "deviceType": "urn:schemas-upnp-org:device:MediaServer:1",
--- a/homeassistant/components/dominos/init.py
+++ b/homeassistant/components/dominos/init.py
@@ -1,259 +0,0 @@
-"""Support for Dominos Pizza ordering."""
-
-from datetime import timedelta
-import logging
-
-from pizzapi import Address, Customer, Order
-import voluptuous as vol
-
-from homeassistant.components import http
-from homeassistant.core import HomeAssistant, ServiceCall, callback
-from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers import config_validation as cv
-from homeassistant.helpers.entity import Entity
-from homeassistant.helpers.entity_component import EntityComponent
-from homeassistant.helpers.typing import ConfigType
-from homeassistant.util import Throttle
-
-_LOGGER = logging.getLogger(__name__)
-
-# The domain of your component. Should be equal to the name of your component.
-DOMAIN = "dominos"
-ENTITY_ID_FORMAT = DOMAIN + ".{}"
-
-ATTR_COUNTRY = "country_code"
-ATTR_FIRST_NAME = "first_name"
-ATTR_LAST_NAME = "last_name"
-ATTR_EMAIL = "email"
-ATTR_PHONE = "phone"
-ATTR_ADDRESS = "address"
-ATTR_ORDERS = "orders"
-ATTR_SHOW_MENU = "show_menu"
-ATTR_ORDER_ENTITY = "order_entity_id"
-ATTR_ORDER_NAME = "name"
-ATTR_ORDER_CODES = "codes"
-
-MIN_TIME_BETWEEN_UPDATES = timedelta(minutes=10)
-MIN_TIME_BETWEEN_STORE_UPDATES = timedelta(minutes=3330)
-
-_ORDERS_SCHEMA = vol.Schema(
-    {
-        vol.Required(ATTR_ORDER_NAME): cv.string,
-        vol.Required(ATTR_ORDER_CODES): vol.All(cv.ensure_list, [cv.string]),
-    }
-)
-
-CONFIG_SCHEMA = vol.Schema(
-    {
-        DOMAIN: vol.Schema(
-            {
-                vol.Required(ATTR_COUNTRY): cv.string,
-                vol.Required(ATTR_FIRST_NAME): cv.string,
-                vol.Required(ATTR_LAST_NAME): cv.string,
-                vol.Required(ATTR_EMAIL): cv.string,
-                vol.Required(ATTR_PHONE): cv.string,
-                vol.Required(ATTR_ADDRESS): cv.string,
-                vol.Optional(ATTR_SHOW_MENU): cv.boolean,
-                vol.Optional(ATTR_ORDERS, default=[]): vol.All(
-                    cv.ensure_list, [_ORDERS_SCHEMA]
-                ),
-            }
-        )
-    },
-    extra=vol.ALLOW_EXTRA,
-)
-
-
-def setup(hass: HomeAssistant, config: ConfigType) -> bool:
-    """Set up is called when Home Assistant is loading our component."""
-    dominos = Dominos(hass, config)
-
-    component = EntityComponent[DominosOrder](_LOGGER, DOMAIN, hass)
-    hass.data[DOMAIN] = {}
-    entities: list[DominosOrder] = []
-    conf = config[DOMAIN]
-
-    hass.services.register(
-        DOMAIN,
-        "order",
-        dominos.handle_order,
-        vol.Schema(
-            {
-                vol.Required(ATTR_ORDER_ENTITY): cv.entity_ids,
-            }
-        ),
-    )
-
-    if conf.get(ATTR_SHOW_MENU):
-        hass.http.register_view(DominosProductListView(dominos))
-
-    for order_info in conf.get(ATTR_ORDERS):
-        order = DominosOrder(order_info, dominos)
-        entities.append(order)
-
-    component.add_entities(entities)
-
-    # Return boolean to indicate that initialization was successfully.
-    return True
-
-
-class Dominos:
-    """Main Dominos service."""
-
-    def __init__(self, hass, config):
-        """Set up main service."""
-        conf = config[DOMAIN]
-
-        self.hass = hass
-        self.customer = Customer(
-            conf.get(ATTR_FIRST_NAME),
-            conf.get(ATTR_LAST_NAME),
-            conf.get(ATTR_EMAIL),
-            conf.get(ATTR_PHONE),
-            conf.get(ATTR_ADDRESS),
-        )
-        self.address = Address(
-            *self.customer.address.split(","), country=conf.get(ATTR_COUNTRY)
-        )
-        self.country = conf.get(ATTR_COUNTRY)
-        try:
-            self.closest_store = self.address.closest_store()
-        except Exception:  # noqa: BLE001
-            self.closest_store = None
-
-    def handle_order(self, call: ServiceCall) -> None:
-        """Handle ordering pizza."""
-        entity_ids = call.data[ATTR_ORDER_ENTITY]
-
-        target_orders = [
-            order
-            for order in self.hass.data[DOMAIN]["entities"]
-            if order.entity_id in entity_ids
-        ]
-
-        for order in target_orders:
-            order.place()
-
-    @Throttle(MIN_TIME_BETWEEN_STORE_UPDATES)
-    def update_closest_store(self):
-        """Update the shared closest store (if open)."""
-        try:
-            self.closest_store = self.address.closest_store()
-        except Exception:  # noqa: BLE001
-            self.closest_store = None
-            return False
-        return True
-
-    def get_menu(self):
-        """Return the products from the closest stores menu."""
-        self.update_closest_store()
-        if self.closest_store is None:
-            _LOGGER.warning("Cannot get menu. Store may be closed")
-            return []
-        menu = self.closest_store.get_menu()
-        product_entries = []
-
-        for product in menu.products:
-            item = {}
-            if isinstance(product.menu_data["Variants"], list):
-                variants = ", ".join(product.menu_data["Variants"])
-            else:
-                variants = product.menu_data["Variants"]
-            item["name"] = product.name
-            item["variants"] = variants
-            product_entries.append(item)
-
-        return product_entries
-
-
-class DominosProductListView(http.HomeAssistantView):
-    """View to retrieve product list content."""
-
-    url = "/api/dominos"
-    name = "api:dominos"
-
-    def __init__(self, dominos):
-        """Initialize suite view."""
-        self.dominos = dominos
-
-    @callback
-    def get(self, request):
-        """Retrieve if API is running."""
-        return self.json(self.dominos.get_menu())
-
-
-class DominosOrder(Entity):
-    """Represents a Dominos order entity."""
-
-    def __init__(self, order_info, dominos):
-        """Set up the entity."""
-        self._name = order_info["name"]
-        self._product_codes = order_info["codes"]
-        self._orderable = False
-        self.dominos = dominos
-
-    @property
-    def name(self):
-        """Return the orders name."""
-        return self._name
-
-    @property
-    def product_codes(self):
-        """Return the orders product codes."""
-        return self._product_codes
-
-    @property
-    def orderable(self):
-        """Return the true if orderable."""
-        return self._orderable
-
-    @property
-    def state(self):
-        """Return the state either closed, orderable or unorderable."""
-        if self.dominos.closest_store is None:
-            return "closed"
-        return "orderable" if self._orderable else "unorderable"
-
-    @Throttle(MIN_TIME_BETWEEN_UPDATES)
-    def update(self):
-        """Update the order state and refreshes the store."""
-        try:
-            self.dominos.update_closest_store()
-        except Exception:  # noqa: BLE001
-            self._orderable = False
-            return
-
-        try:
-            order = self.order()
-            order.pay_with()
-            self._orderable = True
-        except Exception:  # noqa: BLE001
-            self._orderable = False
-
-    def order(self):
-        """Create the order object."""
-        if self.dominos.closest_store is None:
-            raise HomeAssistantError("No store available")
-
-        order = Order(
-            self.dominos.closest_store,
-            self.dominos.customer,
-            self.dominos.address,
-            self.dominos.country,
-        )
-
-        for code in self._product_codes:
-            order.add_item(code)
-
-        return order
-
-    def place(self):
-        """Place the order."""
-        try:
-            order = self.order()
-            order.place()
-        except Exception:  # noqa: BLE001
-            self._orderable = False
-            _LOGGER.warning(
-                "Attempted to order Dominos - Order invalid or store closed"
-            )
--- a/homeassistant/components/dominos/icons.json
+++ b/homeassistant/components/dominos/icons.json
@@ -1,7 +0,0 @@
-{
-  "services": {
-    "order": {
-      "service": "mdi:pizza"
-    }
-  }
-}
--- a/homeassistant/components/dominos/manifest.json
+++ b/homeassistant/components/dominos/manifest.json
@@ -1,11 +0,0 @@
-{
-  "domain": "dominos",
-  "name": "Dominos Pizza",
-  "codeowners": [],
-  "dependencies": ["http"],
-  "documentation": "https://www.home-assistant.io/integrations/dominos",
-  "iot_class": "cloud_polling",
-  "loggers": ["pizzapi"],
-  "quality_scale": "legacy",
-  "requirements": ["pizzapi==0.0.6"]
-}
--- a/homeassistant/components/dominos/services.yaml
+++ b/homeassistant/components/dominos/services.yaml
@@ -1,6 +0,0 @@
-order:
-  fields:
-    order_entity_id:
-      example: dominos.medium_pan
-      selector:
-        text:
--- a/homeassistant/components/dominos/strings.json
+++ b/homeassistant/components/dominos/strings.json
@@ -1,14 +0,0 @@
-{
-  "services": {
-    "order": {
-      "description": "Places a set of orders with Domino's Pizza.",
-      "fields": {
-        "order_entity_id": {
-          "description": "The ID (as specified in the configuration) of an order to place. If provided as an array, all the identified orders will be placed.",
-          "name": "Order entity"
-        }
-      },
-      "name": "Order"
-    }
-  }
-}
--- a/homeassistant/components/duckdns/init.py
+++ b/homeassistant/components/duckdns/init.py
@@ -10,6 +10,7 @@ from typing import Any, cast
 from aiohttp import ClientSession
 import voluptuous as vol

+from homeassistant.config_entries import SOURCE_IMPORT, ConfigEntry
 from homeassistant.const import CONF_ACCESS_TOKEN, CONF_DOMAIN
 from homeassistant.core import (
    CALLBACK_TYPE,
@@ -18,13 +19,17 @@ from homeassistant.core import (
    ServiceCall,
    callback,
 )
+from homeassistant.exceptions import ServiceValidationError
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.event import async_call_later
+from homeassistant.helpers.selector import ConfigEntrySelector
 from homeassistant.helpers.typing import ConfigType
 from homeassistant.loader import bind_hass
 from homeassistant.util import dt as dt_util

+from .const import ATTR_CONFIG_ENTRY
+
 _LOGGER = logging.getLogger(__name__)

 ATTR_TXT = "txt"
@@ -32,7 +37,13 @@ ATTR_TXT = "txt"
 DOMAIN = "duckdns"

 INTERVAL = timedelta(minutes=5)
-
+BACKOFF_INTERVALS = (
+    INTERVAL,
+    timedelta(minutes=1),
+    timedelta(minutes=5),
+    timedelta(minutes=15),
+    timedelta(minutes=30),
+)
 SERVICE_SET_TXT = "set_txt"

 UPDATE_URL = "https://www.duckdns.org/update"
@@ -49,39 +60,112 @@ CONFIG_SCHEMA = vol.Schema(
    extra=vol.ALLOW_EXTRA,
 )

-SERVICE_TXT_SCHEMA = vol.Schema({vol.Required(ATTR_TXT): vol.Any(None, cv.string)})
+SERVICE_TXT_SCHEMA = vol.Schema(
+    {
+        vol.Optional(ATTR_CONFIG_ENTRY): ConfigEntrySelector(
+            {
+                "integration": DOMAIN,
+            }
+        ),
+        vol.Optional(ATTR_TXT): vol.Any(None, cv.string),
+    }
+)
+
+type DuckDnsConfigEntry = ConfigEntry


 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
    """Initialize the DuckDNS component."""
-    domain: str = config[DOMAIN][CONF_DOMAIN]
-    token: str = config[DOMAIN][CONF_ACCESS_TOKEN]
+
+    hass.services.async_register(
+        DOMAIN,
+        SERVICE_SET_TXT,
+        update_domain_service,
+        schema=SERVICE_TXT_SCHEMA,
+    )
+
+    if DOMAIN not in config:
+        return True
+
+    hass.async_create_task(
+        hass.config_entries.flow.async_init(
+            DOMAIN, context={"source": SOURCE_IMPORT}, data=config[DOMAIN]
+        )
+    )
+
+    return True
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: DuckDnsConfigEntry) -> bool:
+    """Set up Duck DNS from a config entry."""
+
    session = async_get_clientsession(hass)

    async def update_domain_interval(_now: datetime) -> bool:
        """Update the DuckDNS entry."""
-        return await _update_duckdns(session, domain, token)
+        return await _update_duckdns(
+            session,
+            entry.data[CONF_DOMAIN],
+            entry.data[CONF_ACCESS_TOKEN],
+        )

-    intervals = (
-        INTERVAL,
-        timedelta(minutes=1),
-        timedelta(minutes=5),
-        timedelta(minutes=15),
-        timedelta(minutes=30),
-    )
-    async_track_time_interval_backoff(hass, update_domain_interval, intervals)
-
-    async def update_domain_service(call: ServiceCall) -> None:
-        """Update the DuckDNS entry."""
-        await _update_duckdns(session, domain, token, txt=call.data[ATTR_TXT])
-
-    hass.services.async_register(
-        DOMAIN, SERVICE_SET_TXT, update_domain_service, schema=SERVICE_TXT_SCHEMA
+    entry.async_on_unload(
+        async_track_time_interval_backoff(
+            hass, update_domain_interval, BACKOFF_INTERVALS
+        )
    )

    return True


+def get_config_entry(
+    hass: HomeAssistant, entry_id: str | None = None
+) -> DuckDnsConfigEntry:
+    """Return config entry or raise if not found or not loaded."""
+
+    if entry_id is None:
+        if not (config_entries := hass.config_entries.async_entries(DOMAIN)):
+            raise ServiceValidationError(
+                translation_domain=DOMAIN,
+                translation_key="entry_not_found",
+            )
+
+        if len(config_entries) != 1:
+            raise ServiceValidationError(
+                translation_domain=DOMAIN,
+                translation_key="entry_not_selected",
+            )
+        return config_entries[0]
+
+    if not (entry := hass.config_entries.async_get_entry(entry_id)):
+        raise ServiceValidationError(
+            translation_domain=DOMAIN,
+            translation_key="entry_not_found",
+        )
+
+    return entry
+
+
+async def update_domain_service(call: ServiceCall) -> None:
+    """Update the DuckDNS entry."""
+
+    entry = get_config_entry(call.hass, call.data.get(ATTR_CONFIG_ENTRY))
+
+    session = async_get_clientsession(call.hass)
+
+    await _update_duckdns(
+        session,
+        entry.data[CONF_DOMAIN],
+        entry.data[CONF_ACCESS_TOKEN],
+        txt=call.data.get(ATTR_TXT),
+    )
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: DuckDnsConfigEntry) -> bool:
+    """Unload a config entry."""
+    return True
+
+
 _SENTINEL = object()


--- a/homeassistant/components/duckdns/config_flow.py
+++ b/homeassistant/components/duckdns/config_flow.py
@@ -0,0 +1,81 @@
+"""Config flow for the Duck DNS integration."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+import voluptuous as vol
+
+from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+from homeassistant.const import CONF_ACCESS_TOKEN, CONF_DOMAIN
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers.selector import (
+    TextSelector,
+    TextSelectorConfig,
+    TextSelectorType,
+)
+
+from . import _update_duckdns
+from .const import DOMAIN
+from .issue import deprecate_yaml_issue
+
+_LOGGER = logging.getLogger(__name__)
+
+STEP_USER_DATA_SCHEMA = vol.Schema(
+    {
+        vol.Required(CONF_DOMAIN): TextSelector(
+            TextSelectorConfig(type=TextSelectorType.TEXT, suffix=".duckdns.org")
+        ),
+        vol.Required(CONF_ACCESS_TOKEN): str,
+    }
+)
+
+
+class DuckDnsConfigFlow(ConfigFlow, domain=DOMAIN):
+    """Handle a config flow for Duck DNS."""
+
+    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:
+            self._async_abort_entries_match({CONF_DOMAIN: user_input[CONF_DOMAIN]})
+            session = async_get_clientsession(self.hass)
+            try:
+                if not await _update_duckdns(
+                    session,
+                    user_input[CONF_DOMAIN],
+                    user_input[CONF_ACCESS_TOKEN],
+                ):
+                    errors["base"] = "update_failed"
+            except Exception:
+                _LOGGER.exception("Unexpected exception")
+                errors["base"] = "unknown"
+
+            if not errors:
+                return self.async_create_entry(
+                    title=f"{user_input[CONF_DOMAIN]}.duckdns.org", data=user_input
+                )
+
+        return self.async_show_form(
+            step_id="user",
+            data_schema=self.add_suggested_values_to_schema(
+                data_schema=STEP_USER_DATA_SCHEMA, suggested_values=user_input
+            ),
+            errors=errors,
+            description_placeholders={"url": "https://www.duckdns.org/"},
+        )
+
+    async def async_step_import(self, import_info: dict[str, Any]) -> ConfigFlowResult:
+        """Import config from yaml."""
+
+        self._async_abort_entries_match({CONF_DOMAIN: import_info[CONF_DOMAIN]})
+        result = await self.async_step_user(import_info)
+        if errors := result.get("errors"):
+            deprecate_yaml_issue(self.hass, import_success=False)
+            return self.async_abort(reason=errors["base"])
+
+        deprecate_yaml_issue(self.hass, import_success=True)
+        return result
--- a/homeassistant/components/duckdns/const.py
+++ b/homeassistant/components/duckdns/const.py
@@ -0,0 +1,7 @@
+"""Constants for the Duck DNS integration."""
+
+from typing import Final
+
+DOMAIN = "duckdns"
+
+ATTR_CONFIG_ENTRY: Final = "config_entry_id"
--- a/homeassistant/components/duckdns/issue.py
+++ b/homeassistant/components/duckdns/issue.py
@@ -0,0 +1,40 @@
+"""Issues for Duck DNS integration."""
+
+from homeassistant.core import DOMAIN as HOMEASSISTANT_DOMAIN, HomeAssistant, callback
+from homeassistant.helpers.issue_registry import IssueSeverity, async_create_issue
+
+from .const import DOMAIN
+
+
+@callback
+def deprecate_yaml_issue(hass: HomeAssistant, *, import_success: bool) -> None:
+    """Deprecate yaml issue."""
+    if import_success:
+        async_create_issue(
+            hass,
+            HOMEASSISTANT_DOMAIN,
+            f"deprecated_yaml_{DOMAIN}",
+            is_fixable=False,
+            issue_domain=DOMAIN,
+            breaks_in_ha_version="2026.6.0",
+            severity=IssueSeverity.WARNING,
+            translation_key="deprecated_yaml",
+            translation_placeholders={
+                "domain": DOMAIN,
+                "integration_title": "Duck DNS",
+            },
+        )
+    else:
+        async_create_issue(
+            hass,
+            DOMAIN,
+            "deprecated_yaml_import_issue_error",
+            breaks_in_ha_version="2026.6.0",
+            is_fixable=False,
+            issue_domain=DOMAIN,
+            severity=IssueSeverity.WARNING,
+            translation_key="deprecated_yaml_import_issue_error",
+            translation_placeholders={
+                "url": "/config/integrations/dashboard/add?domain=duckdns"
+            },
+        )
--- a/homeassistant/components/duckdns/manifest.json
+++ b/homeassistant/components/duckdns/manifest.json
@@ -1,8 +1,8 @@
 {
  "domain": "duckdns",
  "name": "Duck DNS",
-  "codeowners": [],
+  "codeowners": ["@tr4nt0r"],
+  "config_flow": true,
  "documentation": "https://www.home-assistant.io/integrations/duckdns",
-  "iot_class": "cloud_polling",
-  "quality_scale": "legacy"
+  "iot_class": "cloud_polling"
 }
--- a/Show More
+++ b/Show More