From 2a0e39901ea407c9f097aa450fef2bfa95adde70 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci-lite[bot]"
 <117423508+pre-commit-ci-lite[bot]@users.noreply.github.com>
Date: Mon, 13 Apr 2026 07:22:54 +0000
Subject: [PATCH 1/4] [pre-commit.ci lite] apply automatic fixes

---
 esphome/components/api/api_pb2.cpp | 1504 +++++++++++++++++++---------
 1 file changed, 1028 insertions(+), 476 deletions(-)

diff --git a/esphome/components/api/api_pb2.cpp b/esphome/components/api/api_pb2.cpp
index 5e6dab8877..9943c06cb1 100644
--- a/esphome/components/api/api_pb2.cpp
+++ b/esphome/components/api/api_pb2.cpp
@@ -1,29 +1,33 @@
 // This file was automatically generated with a tool.
 // See script/api_protobuf/api_protobuf.py
-    #include "api_pb2.h"
-    #include "esphome/core/log.h"
-    #include "esphome/core/helpers.h"
-    #include <cstring>
+#include "api_pb2.h"
+#include "esphome/core/log.h"
+#include "esphome/core/helpers.h"
+#include <cstring>
 
 namespace esphome::api {
 
-
-
 bool HelloRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
   switch (field_id) {
-    case 2: this->api_version_major = value; break;
-    case 3: this->api_version_minor = value; break;
-    default: return false;
+    case 2:
+      this->api_version_major = value;
+      break;
+    case 3:
+      this->api_version_minor = value;
+      break;
+    default:
+      return false;
   }
   return true;
 }
 bool HelloRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 1: {
-          this->client_info = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
-          break;
-        }
-    default: return false;
+      this->client_info = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
+      break;
+    }
+    default:
+      return false;
   }
   return true;
 }
@@ -332,22 +336,38 @@ uint32_t CoverStateResponse::calculate_size() const {
 }
 bool CoverCommandRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
   switch (field_id) {
-    case 4: this->has_position = value != 0; break;
-    case 6: this->has_tilt = value != 0; break;
-    case 8: this->stop = value != 0; break;
+    case 4:
+      this->has_position = value != 0;
+      break;
+    case 6:
+      this->has_tilt = value != 0;
+      break;
+    case 8:
+      this->stop = value != 0;
+      break;
 #ifdef USE_DEVICES
-    case 9: this->device_id = value; break;
+    case 9:
+      this->device_id = value;
+      break;
 #endif
-    default: return false;
+    default:
+      return false;
   }
   return true;
 }
 bool CoverCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
   switch (field_id) {
-    case 1: this->key = value.as_fixed32(); break;
-    case 5: this->position = value.as_float(); break;
-    case 7: this->tilt = value.as_float(); break;
-    default: return false;
+    case 1:
+      this->key = value.as_fixed32();
+      break;
+    case 5:
+      this->position = value.as_float();
+      break;
+    case 7:
+      this->tilt = value.as_float();
+      break;
+    default:
+      return false;
   }
   return true;
 }
@@ -427,36 +447,61 @@ uint32_t FanStateResponse::calculate_size() const {
 }
 bool FanCommandRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
   switch (field_id) {
-    case 2: this->has_state = value != 0; break;
-    case 3: this->state = value != 0; break;
-    case 6: this->has_oscillating = value != 0; break;
-    case 7: this->oscillating = value != 0; break;
-    case 8: this->has_direction = value != 0; break;
-    case 9: this->direction = static_cast<enums::FanDirection>(value); break;
-    case 10: this->has_speed_level = value != 0; break;
-    case 11: this->speed_level = static_cast<int32_t>(value); break;
-    case 12: this->has_preset_mode = value != 0; break;
+    case 2:
+      this->has_state = value != 0;
+      break;
+    case 3:
+      this->state = value != 0;
+      break;
+    case 6:
+      this->has_oscillating = value != 0;
+      break;
+    case 7:
+      this->oscillating = value != 0;
+      break;
+    case 8:
+      this->has_direction = value != 0;
+      break;
+    case 9:
+      this->direction = static_cast<enums::FanDirection>(value);
+      break;
+    case 10:
+      this->has_speed_level = value != 0;
+      break;
+    case 11:
+      this->speed_level = static_cast<int32_t>(value);
+      break;
+    case 12:
+      this->has_preset_mode = value != 0;
+      break;
 #ifdef USE_DEVICES
-    case 14: this->device_id = value; break;
+    case 14:
+      this->device_id = value;
+      break;
 #endif
-    default: return false;
+    default:
+      return false;
   }
   return true;
 }
 bool FanCommandRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 13: {
-          this->preset_mode = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
-          break;
-        }
-    default: return false;
+      this->preset_mode = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
+      break;
+    }
+    default:
+      return false;
   }
   return true;
 }
 bool FanCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
   switch (field_id) {
-    case 1: this->key = value.as_fixed32(); break;
-    default: return false;
+    case 1:
+      this->key = value.as_fixed32();
+      break;
+    default:
+      return false;
   }
   return true;
 }
@@ -552,52 +597,109 @@ uint32_t LightStateResponse::calculate_size() const {
 }
 bool LightCommandRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
   switch (field_id) {
-    case 2: this->has_state = value != 0; break;
-    case 3: this->state = value != 0; break;
-    case 4: this->has_brightness = value != 0; break;
-    case 22: this->has_color_mode = value != 0; break;
-    case 23: this->color_mode = static_cast<enums::ColorMode>(value); break;
-    case 20: this->has_color_brightness = value != 0; break;
-    case 6: this->has_rgb = value != 0; break;
-    case 10: this->has_white = value != 0; break;
-    case 12: this->has_color_temperature = value != 0; break;
-    case 24: this->has_cold_white = value != 0; break;
-    case 26: this->has_warm_white = value != 0; break;
-    case 14: this->has_transition_length = value != 0; break;
-    case 15: this->transition_length = value; break;
-    case 16: this->has_flash_length = value != 0; break;
-    case 17: this->flash_length = value; break;
-    case 18: this->has_effect = value != 0; break;
+    case 2:
+      this->has_state = value != 0;
+      break;
+    case 3:
+      this->state = value != 0;
+      break;
+    case 4:
+      this->has_brightness = value != 0;
+      break;
+    case 22:
+      this->has_color_mode = value != 0;
+      break;
+    case 23:
+      this->color_mode = static_cast<enums::ColorMode>(value);
+      break;
+    case 20:
+      this->has_color_brightness = value != 0;
+      break;
+    case 6:
+      this->has_rgb = value != 0;
+      break;
+    case 10:
+      this->has_white = value != 0;
+      break;
+    case 12:
+      this->has_color_temperature = value != 0;
+      break;
+    case 24:
+      this->has_cold_white = value != 0;
+      break;
+    case 26:
+      this->has_warm_white = value != 0;
+      break;
+    case 14:
+      this->has_transition_length = value != 0;
+      break;
+    case 15:
+      this->transition_length = value;
+      break;
+    case 16:
+      this->has_flash_length = value != 0;
+      break;
+    case 17:
+      this->flash_length = value;
+      break;
+    case 18:
+      this->has_effect = value != 0;
+      break;
 #ifdef USE_DEVICES
-    case 28: this->device_id = value; break;
+    case 28:
+      this->device_id = value;
+      break;
 #endif
-    default: return false;
+    default:
+      return false;
   }
   return true;
 }
 bool LightCommandRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 19: {
-          this->effect = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
-          break;
-        }
-    default: return false;
+      this->effect = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
+      break;
+    }
+    default:
+      return false;
   }
   return true;
 }
 bool LightCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
   switch (field_id) {
-    case 1: this->key = value.as_fixed32(); break;
-    case 5: this->brightness = value.as_float(); break;
-    case 21: this->color_brightness = value.as_float(); break;
-    case 7: this->red = value.as_float(); break;
-    case 8: this->green = value.as_float(); break;
-    case 9: this->blue = value.as_float(); break;
-    case 11: this->white = value.as_float(); break;
-    case 13: this->color_temperature = value.as_float(); break;
-    case 25: this->cold_white = value.as_float(); break;
-    case 27: this->warm_white = value.as_float(); break;
-    default: return false;
+    case 1:
+      this->key = value.as_fixed32();
+      break;
+    case 5:
+      this->brightness = value.as_float();
+      break;
+    case 21:
+      this->color_brightness = value.as_float();
+      break;
+    case 7:
+      this->red = value.as_float();
+      break;
+    case 8:
+      this->green = value.as_float();
+      break;
+    case 9:
+      this->blue = value.as_float();
+      break;
+    case 11:
+      this->white = value.as_float();
+      break;
+    case 13:
+      this->color_temperature = value.as_float();
+      break;
+    case 25:
+      this->cold_white = value.as_float();
+      break;
+    case 27:
+      this->warm_white = value.as_float();
+      break;
+    default:
+      return false;
   }
   return true;
 }
@@ -644,7 +746,8 @@ uint32_t ListEntitiesSensorResponse::calculate_size() const {
   return size;
 }
 __attribute__((optimize("O2")))  // NOLINT(clang-diagnostic-unknown-attributes)
-uint8_t *SensorStateResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *
+SensorStateResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
   uint8_t *__restrict__ pos = buffer.get_pos();
   ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 13, this->key);
   ProtoEncode::encode_float(pos PROTO_ENCODE_DEBUG_ARG, 2, this->state);
@@ -655,7 +758,8 @@ uint8_t *SensorStateResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG
   return pos;
 }
 __attribute__((optimize("O2")))  // NOLINT(clang-diagnostic-unknown-attributes)
-uint32_t SensorStateResponse::calculate_size() const {
+uint32_t
+SensorStateResponse::calculate_size() const {
   uint32_t size = 0;
   size += 5;
   size += ProtoSize::calc_float(1, this->state);
@@ -721,18 +825,26 @@ uint32_t SwitchStateResponse::calculate_size() const {
 }
 bool SwitchCommandRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
   switch (field_id) {
-    case 2: this->state = value != 0; break;
+    case 2:
+      this->state = value != 0;
+      break;
 #ifdef USE_DEVICES
-    case 3: this->device_id = value; break;
+    case 3:
+      this->device_id = value;
+      break;
 #endif
-    default: return false;
+    default:
+      return false;
   }
   return true;
 }
 bool SwitchCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
   switch (field_id) {
-    case 1: this->key = value.as_fixed32(); break;
-    default: return false;
+    case 1:
+      this->key = value.as_fixed32();
+      break;
+    default:
+      return false;
   }
   return true;
 }
@@ -793,14 +905,20 @@ uint32_t TextSensorStateResponse::calculate_size() const {
 #endif
 bool SubscribeLogsRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
   switch (field_id) {
-    case 1: this->level = static_cast<enums::LogLevel>(value); break;
-    case 2: this->dump_config = value != 0; break;
-    default: return false;
+    case 1:
+      this->level = static_cast<enums::LogLevel>(value);
+      break;
+    case 2:
+      this->dump_config = value != 0;
+      break;
+    default:
+      return false;
   }
   return true;
 }
 __attribute__((optimize("O2")))  // NOLINT(clang-diagnostic-unknown-attributes)
-uint8_t *SubscribeLogsResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *
+SubscribeLogsResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
   uint8_t *__restrict__ pos = buffer.get_pos();
   ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 1, static_cast<uint32_t>(this->level), true);
   ProtoEncode::write_raw_byte(pos PROTO_ENCODE_DEBUG_ARG, 26);
@@ -809,7 +927,8 @@ uint8_t *SubscribeLogsResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEB
   return pos;
 }
 __attribute__((optimize("O2")))  // NOLINT(clang-diagnostic-unknown-attributes)
-uint32_t SubscribeLogsResponse::calculate_size() const {
+uint32_t
+SubscribeLogsResponse::calculate_size() const {
   uint32_t size = 0;
   size += 2;
   size += ProtoSize::calc_length(1, this->message_len_);
@@ -819,11 +938,12 @@ uint32_t SubscribeLogsResponse::calculate_size() const {
 bool NoiseEncryptionSetKeyRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 1: {
-          this->key = value.data();
-          this->key_len = value.size();
-          break;
-        }
-    default: return false;
+      this->key = value.data();
+      this->key_len = value.size();
+      break;
+    }
+    default:
+      return false;
   }
   return true;
 }
@@ -909,26 +1029,32 @@ uint32_t HomeassistantActionRequest::calculate_size() const {
 #ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES
 bool HomeassistantActionResponse::decode_varint(uint32_t field_id, proto_varint_value_t value) {
   switch (field_id) {
-    case 1: this->call_id = value; break;
-    case 2: this->success = value != 0; break;
-    default: return false;
+    case 1:
+      this->call_id = value;
+      break;
+    case 2:
+      this->success = value != 0;
+      break;
+    default:
+      return false;
   }
   return true;
 }
 bool HomeassistantActionResponse::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 3: {
-          this->error_message = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
-          break;
-        }
+      this->error_message = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
+      break;
+    }
 #ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
     case 4: {
-          this->response_data = value.data();
-          this->response_data_len = value.size();
-          break;
-        }
+      this->response_data = value.data();
+      this->response_data_len = value.size();
+      break;
+    }
 #endif
-    default: return false;
+    default:
+      return false;
   }
   return true;
 }
@@ -951,65 +1077,95 @@ uint32_t SubscribeHomeAssistantStateResponse::calculate_size() const {
 bool HomeAssistantStateResponse::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 1: {
-          this->entity_id = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
-          break;
-        }
+      this->entity_id = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
+      break;
+    }
     case 2: {
-          this->state = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
-          break;
-        }
+      this->state = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
+      break;
+    }
     case 3: {
-          this->attribute = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
-          break;
-        }
-    default: return false;
+      this->attribute = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
+      break;
+    }
+    default:
+      return false;
   }
   return true;
 }
 #endif
 bool DSTRule::decode_varint(uint32_t field_id, proto_varint_value_t value) {
   switch (field_id) {
-    case 1: this->time_seconds = decode_zigzag32(static_cast<uint32_t>(value)); break;
-    case 2: this->day = value; break;
-    case 3: this->type = static_cast<enums::DSTRuleType>(value); break;
-    case 4: this->month = value; break;
-    case 5: this->week = value; break;
-    case 6: this->day_of_week = value; break;
-    default: return false;
+    case 1:
+      this->time_seconds = decode_zigzag32(static_cast<uint32_t>(value));
+      break;
+    case 2:
+      this->day = value;
+      break;
+    case 3:
+      this->type = static_cast<enums::DSTRuleType>(value);
+      break;
+    case 4:
+      this->month = value;
+      break;
+    case 5:
+      this->week = value;
+      break;
+    case 6:
+      this->day_of_week = value;
+      break;
+    default:
+      return false;
   }
   return true;
 }
 bool ParsedTimezone::decode_varint(uint32_t field_id, proto_varint_value_t value) {
   switch (field_id) {
-    case 1: this->std_offset_seconds = decode_zigzag32(static_cast<uint32_t>(value)); break;
-    case 2: this->dst_offset_seconds = decode_zigzag32(static_cast<uint32_t>(value)); break;
-    default: return false;
+    case 1:
+      this->std_offset_seconds = decode_zigzag32(static_cast<uint32_t>(value));
+      break;
+    case 2:
+      this->dst_offset_seconds = decode_zigzag32(static_cast<uint32_t>(value));
+      break;
+    default:
+      return false;
   }
   return true;
 }
 bool ParsedTimezone::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
-    case 3: value.decode_to_message(this->dst_start); break;
-    case 4: value.decode_to_message(this->dst_end); break;
-    default: return false;
+    case 3:
+      value.decode_to_message(this->dst_start);
+      break;
+    case 4:
+      value.decode_to_message(this->dst_end);
+      break;
+    default:
+      return false;
   }
   return true;
 }
 bool GetTimeResponse::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 2: {
-          this->timezone = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
-          break;
-        }
-    case 3: value.decode_to_message(this->parsed_timezone); break;
-    default: return false;
+      this->timezone = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
+      break;
+    }
+    case 3:
+      value.decode_to_message(this->parsed_timezone);
+      break;
+    default:
+      return false;
   }
   return true;
 }
 bool GetTimeResponse::decode_32bit(uint32_t field_id, Proto32Bit value) {
   switch (field_id) {
-    case 1: this->epoch_seconds = value.as_fixed32(); break;
-    default: return false;
+    case 1:
+      this->epoch_seconds = value.as_fixed32();
+      break;
+    default:
+      return false;
   }
   return true;
 }
@@ -1050,31 +1206,50 @@ uint32_t ListEntitiesServicesResponse::calculate_size() const {
 }
 bool ExecuteServiceArgument::decode_varint(uint32_t field_id, proto_varint_value_t value) {
   switch (field_id) {
-    case 1: this->bool_ = value != 0; break;
-    case 2: this->legacy_int = static_cast<int32_t>(value); break;
-    case 5: this->int_ = decode_zigzag32(static_cast<uint32_t>(value)); break;
-    case 6: this->bool_array.push_back(value != 0); break;
-    case 7: this->int_array.push_back(decode_zigzag32(static_cast<uint32_t>(value))); break;
-    default: return false;
+    case 1:
+      this->bool_ = value != 0;
+      break;
+    case 2:
+      this->legacy_int = static_cast<int32_t>(value);
+      break;
+    case 5:
+      this->int_ = decode_zigzag32(static_cast<uint32_t>(value));
+      break;
+    case 6:
+      this->bool_array.push_back(value != 0);
+      break;
+    case 7:
+      this->int_array.push_back(decode_zigzag32(static_cast<uint32_t>(value)));
+      break;
+    default:
+      return false;
   }
   return true;
 }
 bool ExecuteServiceArgument::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 4: {
-          this->string_ = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
-          break;
-        }
-    case 9: this->string_array.push_back(value.as_string()); break;
-    default: return false;
+      this->string_ = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
+      break;
+    }
+    case 9:
+      this->string_array.push_back(value.as_string());
+      break;
+    default:
+      return false;
   }
   return true;
 }
 bool ExecuteServiceArgument::decode_32bit(uint32_t field_id, Proto32Bit value) {
   switch (field_id) {
-    case 3: this->float_ = value.as_float(); break;
-    case 8: this->float_array.push_back(value.as_float()); break;
-    default: return false;
+    case 3:
+      this->float_ = value.as_float();
+      break;
+    case 8:
+      this->float_array.push_back(value.as_float());
+      break;
+    default:
+      return false;
   }
   return true;
 }
@@ -1092,26 +1267,38 @@ void ExecuteServiceArgument::decode(const uint8_t *buffer, size_t length) {
 bool ExecuteServiceRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
   switch (field_id) {
 #ifdef USE_API_USER_DEFINED_ACTION_RESPONSES
-    case 3: this->call_id = value; break;
+    case 3:
+      this->call_id = value;
+      break;
 #endif
 #ifdef USE_API_USER_DEFINED_ACTION_RESPONSES
-    case 4: this->return_response = value != 0; break;
+    case 4:
+      this->return_response = value != 0;
+      break;
 #endif
-    default: return false;
+    default:
+      return false;
   }
   return true;
 }
 bool ExecuteServiceRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
-    case 2: this->args.emplace_back(); value.decode_to_message(this->args.back()); break;
-    default: return false;
+    case 2:
+      this->args.emplace_back();
+      value.decode_to_message(this->args.back());
+      break;
+    default:
+      return false;
   }
   return true;
 }
 bool ExecuteServiceRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
   switch (field_id) {
-    case 1: this->key = value.as_fixed32(); break;
-    default: return false;
+    case 1:
+      this->key = value.as_fixed32();
+      break;
+    default:
+      return false;
   }
   return true;
 }
@@ -1196,9 +1383,14 @@ uint32_t CameraImageResponse::calculate_size() const {
 }
 bool CameraImageRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
   switch (field_id) {
-    case 1: this->single = value != 0; break;
-    case 2: this->stream = value != 0; break;
-    default: return false;
+    case 1:
+      this->single = value != 0;
+      break;
+    case 2:
+      this->stream = value != 0;
+      break;
+    default:
+      return false;
   }
   return true;
 }
@@ -1342,49 +1534,92 @@ uint32_t ClimateStateResponse::calculate_size() const {
 }
 bool ClimateCommandRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
   switch (field_id) {
-    case 2: this->has_mode = value != 0; break;
-    case 3: this->mode = static_cast<enums::ClimateMode>(value); break;
-    case 4: this->has_target_temperature = value != 0; break;
-    case 6: this->has_target_temperature_low = value != 0; break;
-    case 8: this->has_target_temperature_high = value != 0; break;
-    case 12: this->has_fan_mode = value != 0; break;
-    case 13: this->fan_mode = static_cast<enums::ClimateFanMode>(value); break;
-    case 14: this->has_swing_mode = value != 0; break;
-    case 15: this->swing_mode = static_cast<enums::ClimateSwingMode>(value); break;
-    case 16: this->has_custom_fan_mode = value != 0; break;
-    case 18: this->has_preset = value != 0; break;
-    case 19: this->preset = static_cast<enums::ClimatePreset>(value); break;
-    case 20: this->has_custom_preset = value != 0; break;
-    case 22: this->has_target_humidity = value != 0; break;
+    case 2:
+      this->has_mode = value != 0;
+      break;
+    case 3:
+      this->mode = static_cast<enums::ClimateMode>(value);
+      break;
+    case 4:
+      this->has_target_temperature = value != 0;
+      break;
+    case 6:
+      this->has_target_temperature_low = value != 0;
+      break;
+    case 8:
+      this->has_target_temperature_high = value != 0;
+      break;
+    case 12:
+      this->has_fan_mode = value != 0;
+      break;
+    case 13:
+      this->fan_mode = static_cast<enums::ClimateFanMode>(value);
+      break;
+    case 14:
+      this->has_swing_mode = value != 0;
+      break;
+    case 15:
+      this->swing_mode = static_cast<enums::ClimateSwingMode>(value);
+      break;
+    case 16:
+      this->has_custom_fan_mode = value != 0;
+      break;
+    case 18:
+      this->has_preset = value != 0;
+      break;
+    case 19:
+      this->preset = static_cast<enums::ClimatePreset>(value);
+      break;
+    case 20:
+      this->has_custom_preset = value != 0;
+      break;
+    case 22:
+      this->has_target_humidity = value != 0;
+      break;
 #ifdef USE_DEVICES
-    case 24: this->device_id = value; break;
+    case 24:
+      this->device_id = value;
+      break;
 #endif
-    default: return false;
+    default:
+      return false;
   }
   return true;
 }
 bool ClimateCommandRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 17: {
-          this->custom_fan_mode = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
-          break;
-        }
+      this->custom_fan_mode = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
+      break;
+    }
     case 21: {
-          this->custom_preset = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
-          break;
-        }
-    default: return false;
+      this->custom_preset = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
+      break;
+    }
+    default:
+      return false;
   }
   return true;
 }
 bool ClimateCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
   switch (field_id) {
-    case 1: this->key = value.as_fixed32(); break;
-    case 5: this->target_temperature = value.as_float(); break;
-    case 7: this->target_temperature_low = value.as_float(); break;
-    case 9: this->target_temperature_high = value.as_float(); break;
-    case 23: this->target_humidity = value.as_float(); break;
-    default: return false;
+    case 1:
+      this->key = value.as_fixed32();
+      break;
+    case 5:
+      this->target_temperature = value.as_float();
+      break;
+    case 7:
+      this->target_temperature_low = value.as_float();
+      break;
+    case 9:
+      this->target_temperature_high = value.as_float();
+      break;
+    case 23:
+      this->target_humidity = value.as_float();
+      break;
+    default:
+      return false;
   }
   return true;
 }
@@ -1464,23 +1699,41 @@ uint32_t WaterHeaterStateResponse::calculate_size() const {
 }
 bool WaterHeaterCommandRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
   switch (field_id) {
-    case 2: this->has_fields = value; break;
-    case 3: this->mode = static_cast<enums::WaterHeaterMode>(value); break;
+    case 2:
+      this->has_fields = value;
+      break;
+    case 3:
+      this->mode = static_cast<enums::WaterHeaterMode>(value);
+      break;
 #ifdef USE_DEVICES
-    case 5: this->device_id = value; break;
+    case 5:
+      this->device_id = value;
+      break;
 #endif
-    case 6: this->state = value; break;
-    default: return false;
+    case 6:
+      this->state = value;
+      break;
+    default:
+      return false;
   }
   return true;
 }
 bool WaterHeaterCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
   switch (field_id) {
-    case 1: this->key = value.as_fixed32(); break;
-    case 4: this->target_temperature = value.as_float(); break;
-    case 7: this->target_temperature_low = value.as_float(); break;
-    case 8: this->target_temperature_high = value.as_float(); break;
-    default: return false;
+    case 1:
+      this->key = value.as_fixed32();
+      break;
+    case 4:
+      this->target_temperature = value.as_float();
+      break;
+    case 7:
+      this->target_temperature_low = value.as_float();
+      break;
+    case 8:
+      this->target_temperature_high = value.as_float();
+      break;
+    default:
+      return false;
   }
   return true;
 }
@@ -1551,17 +1804,25 @@ uint32_t NumberStateResponse::calculate_size() const {
 bool NumberCommandRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
   switch (field_id) {
 #ifdef USE_DEVICES
-    case 3: this->device_id = value; break;
+    case 3:
+      this->device_id = value;
+      break;
 #endif
-    default: return false;
+    default:
+      return false;
   }
   return true;
 }
 bool NumberCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
   switch (field_id) {
-    case 1: this->key = value.as_fixed32(); break;
-    case 2: this->state = value.as_float(); break;
-    default: return false;
+    case 1:
+      this->key = value.as_fixed32();
+      break;
+    case 2:
+      this->state = value.as_float();
+      break;
+    default:
+      return false;
   }
   return true;
 }
@@ -1628,26 +1889,33 @@ uint32_t SelectStateResponse::calculate_size() const {
 bool SelectCommandRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
   switch (field_id) {
 #ifdef USE_DEVICES
-    case 3: this->device_id = value; break;
+    case 3:
+      this->device_id = value;
+      break;
 #endif
-    default: return false;
+    default:
+      return false;
   }
   return true;
 }
 bool SelectCommandRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 2: {
-          this->state = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
-          break;
-        }
-    default: return false;
+      this->state = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
+      break;
+    }
+    default:
+      return false;
   }
   return true;
 }
 bool SelectCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
   switch (field_id) {
-    case 1: this->key = value.as_fixed32(); break;
-    default: return false;
+    case 1:
+      this->key = value.as_fixed32();
+      break;
+    default:
+      return false;
   }
   return true;
 }
@@ -1715,34 +1983,55 @@ uint32_t SirenStateResponse::calculate_size() const {
 }
 bool SirenCommandRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
   switch (field_id) {
-    case 2: this->has_state = value != 0; break;
-    case 3: this->state = value != 0; break;
-    case 4: this->has_tone = value != 0; break;
-    case 6: this->has_duration = value != 0; break;
-    case 7: this->duration = value; break;
-    case 8: this->has_volume = value != 0; break;
+    case 2:
+      this->has_state = value != 0;
+      break;
+    case 3:
+      this->state = value != 0;
+      break;
+    case 4:
+      this->has_tone = value != 0;
+      break;
+    case 6:
+      this->has_duration = value != 0;
+      break;
+    case 7:
+      this->duration = value;
+      break;
+    case 8:
+      this->has_volume = value != 0;
+      break;
 #ifdef USE_DEVICES
-    case 10: this->device_id = value; break;
+    case 10:
+      this->device_id = value;
+      break;
 #endif
-    default: return false;
+    default:
+      return false;
   }
   return true;
 }
 bool SirenCommandRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 5: {
-          this->tone = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
-          break;
-        }
-    default: return false;
+      this->tone = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
+      break;
+    }
+    default:
+      return false;
   }
   return true;
 }
 bool SirenCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
   switch (field_id) {
-    case 1: this->key = value.as_fixed32(); break;
-    case 9: this->volume = value.as_float(); break;
-    default: return false;
+    case 1:
+      this->key = value.as_fixed32();
+      break;
+    case 9:
+      this->volume = value.as_float();
+      break;
+    default:
+      return false;
   }
   return true;
 }
@@ -1806,29 +2095,40 @@ uint32_t LockStateResponse::calculate_size() const {
 }
 bool LockCommandRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
   switch (field_id) {
-    case 2: this->command = static_cast<enums::LockCommand>(value); break;
-    case 3: this->has_code = value != 0; break;
+    case 2:
+      this->command = static_cast<enums::LockCommand>(value);
+      break;
+    case 3:
+      this->has_code = value != 0;
+      break;
 #ifdef USE_DEVICES
-    case 5: this->device_id = value; break;
+    case 5:
+      this->device_id = value;
+      break;
 #endif
-    default: return false;
+    default:
+      return false;
   }
   return true;
 }
 bool LockCommandRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 4: {
-          this->code = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
-          break;
-        }
-    default: return false;
+      this->code = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
+      break;
+    }
+    default:
+      return false;
   }
   return true;
 }
 bool LockCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
   switch (field_id) {
-    case 1: this->key = value.as_fixed32(); break;
-    default: return false;
+    case 1:
+      this->key = value.as_fixed32();
+      break;
+    default:
+      return false;
   }
   return true;
 }
@@ -1869,16 +2169,22 @@ uint32_t ListEntitiesButtonResponse::calculate_size() const {
 bool ButtonCommandRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
   switch (field_id) {
 #ifdef USE_DEVICES
-    case 2: this->device_id = value; break;
+    case 2:
+      this->device_id = value;
+      break;
 #endif
-    default: return false;
+    default:
+      return false;
   }
   return true;
 }
 bool ButtonCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
   switch (field_id) {
-    case 1: this->key = value.as_fixed32(); break;
-    default: return false;
+    case 1:
+      this->key = value.as_fixed32();
+      break;
+    default:
+      return false;
   }
   return true;
 }
@@ -1968,34 +2274,55 @@ uint32_t MediaPlayerStateResponse::calculate_size() const {
 }
 bool MediaPlayerCommandRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
   switch (field_id) {
-    case 2: this->has_command = value != 0; break;
-    case 3: this->command = static_cast<enums::MediaPlayerCommand>(value); break;
-    case 4: this->has_volume = value != 0; break;
-    case 6: this->has_media_url = value != 0; break;
-    case 8: this->has_announcement = value != 0; break;
-    case 9: this->announcement = value != 0; break;
+    case 2:
+      this->has_command = value != 0;
+      break;
+    case 3:
+      this->command = static_cast<enums::MediaPlayerCommand>(value);
+      break;
+    case 4:
+      this->has_volume = value != 0;
+      break;
+    case 6:
+      this->has_media_url = value != 0;
+      break;
+    case 8:
+      this->has_announcement = value != 0;
+      break;
+    case 9:
+      this->announcement = value != 0;
+      break;
 #ifdef USE_DEVICES
-    case 10: this->device_id = value; break;
+    case 10:
+      this->device_id = value;
+      break;
 #endif
-    default: return false;
+    default:
+      return false;
   }
   return true;
 }
 bool MediaPlayerCommandRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 7: {
-          this->media_url = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
-          break;
-        }
-    default: return false;
+      this->media_url = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
+      break;
+    }
+    default:
+      return false;
   }
   return true;
 }
 bool MediaPlayerCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
   switch (field_id) {
-    case 1: this->key = value.as_fixed32(); break;
-    case 5: this->volume = value.as_float(); break;
-    default: return false;
+    case 1:
+      this->key = value.as_fixed32();
+      break;
+    case 5:
+      this->volume = value.as_float();
+      break;
+    default:
+      return false;
   }
   return true;
 }
@@ -2003,36 +2330,41 @@ bool MediaPlayerCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value
 #ifdef USE_BLUETOOTH_PROXY
 bool SubscribeBluetoothLEAdvertisementsRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
   switch (field_id) {
-    case 1: this->flags = value; break;
-    default: return false;
+    case 1:
+      this->flags = value;
+      break;
+    default:
+      return false;
   }
   return true;
 }
 __attribute__((optimize("O2")))  // NOLINT(clang-diagnostic-unknown-attributes)
-uint8_t *BluetoothLERawAdvertisementsResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *
+BluetoothLERawAdvertisementsResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
   uint8_t *__restrict__ pos = buffer.get_pos();
   for (uint16_t i = 0; i < this->advertisements_len; i++) {
     auto &sub_msg = this->advertisements[i];
-  ProtoEncode::write_raw_byte(pos PROTO_ENCODE_DEBUG_ARG, 10);
-  uint8_t *len_pos = pos;
-  ProtoEncode::reserve_byte(pos PROTO_ENCODE_DEBUG_ARG);
-  ProtoEncode::write_raw_byte(pos PROTO_ENCODE_DEBUG_ARG, 8);
-  ProtoEncode::encode_varint_raw_64(pos PROTO_ENCODE_DEBUG_ARG, sub_msg.address);
-  ProtoEncode::write_raw_byte(pos PROTO_ENCODE_DEBUG_ARG, 16);
-  ProtoEncode::encode_varint_raw_short(pos PROTO_ENCODE_DEBUG_ARG, encode_zigzag32(sub_msg.rssi));
-  if (sub_msg.address_type) {
-    ProtoEncode::write_raw_byte(pos PROTO_ENCODE_DEBUG_ARG, 24);
-  ProtoEncode::encode_varint_raw(pos PROTO_ENCODE_DEBUG_ARG, sub_msg.address_type);
-  }
-  ProtoEncode::write_raw_byte(pos PROTO_ENCODE_DEBUG_ARG, 34);
-  ProtoEncode::write_raw_byte(pos PROTO_ENCODE_DEBUG_ARG, static_cast<uint8_t>(sub_msg.data_len));
-  ProtoEncode::encode_raw(pos PROTO_ENCODE_DEBUG_ARG, sub_msg.data, sub_msg.data_len);
-  *len_pos = static_cast<uint8_t>(pos - len_pos - 1);
+    ProtoEncode::write_raw_byte(pos PROTO_ENCODE_DEBUG_ARG, 10);
+    uint8_t *len_pos = pos;
+    ProtoEncode::reserve_byte(pos PROTO_ENCODE_DEBUG_ARG);
+    ProtoEncode::write_raw_byte(pos PROTO_ENCODE_DEBUG_ARG, 8);
+    ProtoEncode::encode_varint_raw_64(pos PROTO_ENCODE_DEBUG_ARG, sub_msg.address);
+    ProtoEncode::write_raw_byte(pos PROTO_ENCODE_DEBUG_ARG, 16);
+    ProtoEncode::encode_varint_raw_short(pos PROTO_ENCODE_DEBUG_ARG, encode_zigzag32(sub_msg.rssi));
+    if (sub_msg.address_type) {
+      ProtoEncode::write_raw_byte(pos PROTO_ENCODE_DEBUG_ARG, 24);
+      ProtoEncode::encode_varint_raw(pos PROTO_ENCODE_DEBUG_ARG, sub_msg.address_type);
+    }
+    ProtoEncode::write_raw_byte(pos PROTO_ENCODE_DEBUG_ARG, 34);
+    ProtoEncode::write_raw_byte(pos PROTO_ENCODE_DEBUG_ARG, static_cast<uint8_t>(sub_msg.data_len));
+    ProtoEncode::encode_raw(pos PROTO_ENCODE_DEBUG_ARG, sub_msg.data, sub_msg.data_len);
+    *len_pos = static_cast<uint8_t>(pos - len_pos - 1);
   }
   return pos;
 }
 __attribute__((optimize("O2")))  // NOLINT(clang-diagnostic-unknown-attributes)
-uint32_t BluetoothLERawAdvertisementsResponse::calculate_size() const {
+uint32_t
+BluetoothLERawAdvertisementsResponse::calculate_size() const {
   uint32_t size = 0;
   for (uint16_t i = 0; i < this->advertisements_len; i++) {
     auto &sub_msg = this->advertisements[i];
@@ -2046,11 +2378,20 @@ uint32_t BluetoothLERawAdvertisementsResponse::calculate_size() const {
 }
 bool BluetoothDeviceRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
   switch (field_id) {
-    case 1: this->address = value; break;
-    case 2: this->request_type = static_cast<enums::BluetoothDeviceRequestType>(value); break;
-    case 3: this->has_address_type = value != 0; break;
-    case 4: this->address_type = value; break;
-    default: return false;
+    case 1:
+      this->address = value;
+      break;
+    case 2:
+      this->request_type = static_cast<enums::BluetoothDeviceRequestType>(value);
+      break;
+    case 3:
+      this->has_address_type = value != 0;
+      break;
+    case 4:
+      this->address_type = value;
+      break;
+    default:
+      return false;
   }
   return true;
 }
@@ -2072,8 +2413,11 @@ uint32_t BluetoothDeviceConnectionResponse::calculate_size() const {
 }
 bool BluetoothGATTGetServicesRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
   switch (field_id) {
-    case 1: this->address = value; break;
-    default: return false;
+    case 1:
+      this->address = value;
+      break;
+    default:
+      return false;
   }
   return true;
 }
@@ -2185,9 +2529,14 @@ uint32_t BluetoothGATTGetServicesDoneResponse::calculate_size() const {
 }
 bool BluetoothGATTReadRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
   switch (field_id) {
-    case 1: this->address = value; break;
-    case 2: this->handle = value; break;
-    default: return false;
+    case 1:
+      this->address = value;
+      break;
+    case 2:
+      this->handle = value;
+      break;
+    default:
+      return false;
   }
   return true;
 }
@@ -2207,57 +2556,83 @@ uint32_t BluetoothGATTReadResponse::calculate_size() const {
 }
 bool BluetoothGATTWriteRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
   switch (field_id) {
-    case 1: this->address = value; break;
-    case 2: this->handle = value; break;
-    case 3: this->response = value != 0; break;
-    default: return false;
+    case 1:
+      this->address = value;
+      break;
+    case 2:
+      this->handle = value;
+      break;
+    case 3:
+      this->response = value != 0;
+      break;
+    default:
+      return false;
   }
   return true;
 }
 bool BluetoothGATTWriteRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 4: {
-          this->data = value.data();
-          this->data_len = value.size();
-          break;
-        }
-    default: return false;
+      this->data = value.data();
+      this->data_len = value.size();
+      break;
+    }
+    default:
+      return false;
   }
   return true;
 }
 bool BluetoothGATTReadDescriptorRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
   switch (field_id) {
-    case 1: this->address = value; break;
-    case 2: this->handle = value; break;
-    default: return false;
+    case 1:
+      this->address = value;
+      break;
+    case 2:
+      this->handle = value;
+      break;
+    default:
+      return false;
   }
   return true;
 }
 bool BluetoothGATTWriteDescriptorRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
   switch (field_id) {
-    case 1: this->address = value; break;
-    case 2: this->handle = value; break;
-    default: return false;
+    case 1:
+      this->address = value;
+      break;
+    case 2:
+      this->handle = value;
+      break;
+    default:
+      return false;
   }
   return true;
 }
 bool BluetoothGATTWriteDescriptorRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 3: {
-          this->data = value.data();
-          this->data_len = value.size();
-          break;
-        }
-    default: return false;
+      this->data = value.data();
+      this->data_len = value.size();
+      break;
+    }
+    default:
+      return false;
   }
   return true;
 }
 bool BluetoothGATTNotifyRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
   switch (field_id) {
-    case 1: this->address = value; break;
-    case 2: this->handle = value; break;
-    case 3: this->enable = value != 0; break;
-    default: return false;
+    case 1:
+      this->address = value;
+      break;
+    case 2:
+      this->handle = value;
+      break;
+    case 3:
+      this->enable = value != 0;
+      break;
+    default:
+      return false;
   }
   return true;
 }
@@ -2393,8 +2768,11 @@ uint32_t BluetoothScannerStateResponse::calculate_size() const {
 }
 bool BluetoothScannerSetModeRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
   switch (field_id) {
-    case 1: this->mode = static_cast<enums::BluetoothScannerMode>(value); break;
-    default: return false;
+    case 1:
+      this->mode = static_cast<enums::BluetoothScannerMode>(value);
+      break;
+    default:
+      return false;
   }
   return true;
 }
@@ -2402,9 +2780,14 @@ bool BluetoothScannerSetModeRequest::decode_varint(uint32_t field_id, proto_vari
 #ifdef USE_VOICE_ASSISTANT
 bool SubscribeVoiceAssistantRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
   switch (field_id) {
-    case 1: this->subscribe = value != 0; break;
-    case 2: this->flags = value; break;
-    default: return false;
+    case 1:
+      this->subscribe = value != 0;
+      break;
+    case 2:
+      this->flags = value;
+      break;
+    default:
+      return false;
   }
   return true;
 }
@@ -2442,55 +2825,72 @@ uint32_t VoiceAssistantRequest::calculate_size() const {
 }
 bool VoiceAssistantResponse::decode_varint(uint32_t field_id, proto_varint_value_t value) {
   switch (field_id) {
-    case 1: this->port = value; break;
-    case 2: this->error = value != 0; break;
-    default: return false;
+    case 1:
+      this->port = value;
+      break;
+    case 2:
+      this->error = value != 0;
+      break;
+    default:
+      return false;
   }
   return true;
 }
 bool VoiceAssistantEventData::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 1: {
-          this->name = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
-          break;
-        }
+      this->name = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
+      break;
+    }
     case 2: {
-          this->value = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
-          break;
-        }
-    default: return false;
+      this->value = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
+      break;
+    }
+    default:
+      return false;
   }
   return true;
 }
 bool VoiceAssistantEventResponse::decode_varint(uint32_t field_id, proto_varint_value_t value) {
   switch (field_id) {
-    case 1: this->event_type = static_cast<enums::VoiceAssistantEvent>(value); break;
-    default: return false;
+    case 1:
+      this->event_type = static_cast<enums::VoiceAssistantEvent>(value);
+      break;
+    default:
+      return false;
   }
   return true;
 }
 bool VoiceAssistantEventResponse::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
-    case 2: this->data.emplace_back(); value.decode_to_message(this->data.back()); break;
-    default: return false;
+    case 2:
+      this->data.emplace_back();
+      value.decode_to_message(this->data.back());
+      break;
+    default:
+      return false;
   }
   return true;
 }
 bool VoiceAssistantAudio::decode_varint(uint32_t field_id, proto_varint_value_t value) {
   switch (field_id) {
-    case 2: this->end = value != 0; break;
-    default: return false;
+    case 2:
+      this->end = value != 0;
+      break;
+    default:
+      return false;
   }
   return true;
 }
 bool VoiceAssistantAudio::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 1: {
-          this->data = value.data();
-          this->data_len = value.size();
-          break;
-        }
-    default: return false;
+      this->data = value.data();
+      this->data_len = value.size();
+      break;
+    }
+    default:
+      return false;
   }
   return true;
 }
@@ -2508,50 +2908,64 @@ uint32_t VoiceAssistantAudio::calculate_size() const {
 }
 bool VoiceAssistantTimerEventResponse::decode_varint(uint32_t field_id, proto_varint_value_t value) {
   switch (field_id) {
-    case 1: this->event_type = static_cast<enums::VoiceAssistantTimerEvent>(value); break;
-    case 4: this->total_seconds = value; break;
-    case 5: this->seconds_left = value; break;
-    case 6: this->is_active = value != 0; break;
-    default: return false;
+    case 1:
+      this->event_type = static_cast<enums::VoiceAssistantTimerEvent>(value);
+      break;
+    case 4:
+      this->total_seconds = value;
+      break;
+    case 5:
+      this->seconds_left = value;
+      break;
+    case 6:
+      this->is_active = value != 0;
+      break;
+    default:
+      return false;
   }
   return true;
 }
 bool VoiceAssistantTimerEventResponse::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 2: {
-          this->timer_id = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
-          break;
-        }
+      this->timer_id = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
+      break;
+    }
     case 3: {
-          this->name = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
-          break;
-        }
-    default: return false;
+      this->name = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
+      break;
+    }
+    default:
+      return false;
   }
   return true;
 }
 bool VoiceAssistantAnnounceRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
   switch (field_id) {
-    case 4: this->start_conversation = value != 0; break;
-    default: return false;
+    case 4:
+      this->start_conversation = value != 0;
+      break;
+    default:
+      return false;
   }
   return true;
 }
 bool VoiceAssistantAnnounceRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 1: {
-          this->media_id = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
-          break;
-        }
+      this->media_id = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
+      break;
+    }
     case 2: {
-          this->text = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
-          break;
-        }
+      this->text = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
+      break;
+    }
     case 3: {
-          this->preannounce_media_id = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
-          break;
-        }
-    default: return false;
+      this->preannounce_media_id = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
+      break;
+    }
+    default:
+      return false;
   }
   return true;
 }
@@ -2587,42 +3001,52 @@ uint32_t VoiceAssistantWakeWord::calculate_size() const {
 }
 bool VoiceAssistantExternalWakeWord::decode_varint(uint32_t field_id, proto_varint_value_t value) {
   switch (field_id) {
-    case 5: this->model_size = value; break;
-    default: return false;
+    case 5:
+      this->model_size = value;
+      break;
+    default:
+      return false;
   }
   return true;
 }
 bool VoiceAssistantExternalWakeWord::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 1: {
-          this->id = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
-          break;
-        }
+      this->id = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
+      break;
+    }
     case 2: {
-          this->wake_word = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
-          break;
-        }
-    case 3: this->trained_languages.push_back(value.as_string()); break;
+      this->wake_word = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
+      break;
+    }
+    case 3:
+      this->trained_languages.push_back(value.as_string());
+      break;
     case 4: {
-          this->model_type = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
-          break;
-        }
+      this->model_type = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
+      break;
+    }
     case 6: {
-          this->model_hash = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
-          break;
-        }
+      this->model_hash = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
+      break;
+    }
     case 7: {
-          this->url = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
-          break;
-        }
-    default: return false;
+      this->url = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
+      break;
+    }
+    default:
+      return false;
   }
   return true;
 }
 bool VoiceAssistantConfigurationRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
-    case 1: this->external_wake_words.emplace_back(); value.decode_to_message(this->external_wake_words.back()); break;
-    default: return false;
+    case 1:
+      this->external_wake_words.emplace_back();
+      value.decode_to_message(this->external_wake_words.back());
+      break;
+    default:
+      return false;
   }
   return true;
 }
@@ -2654,8 +3078,11 @@ uint32_t VoiceAssistantConfigurationResponse::calculate_size() const {
 }
 bool VoiceAssistantSetConfiguration::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
-    case 1: this->active_wake_words.push_back(value.as_string()); break;
-    default: return false;
+    case 1:
+      this->active_wake_words.push_back(value.as_string());
+      break;
+    default:
+      return false;
   }
   return true;
 }
@@ -2717,28 +3144,37 @@ uint32_t AlarmControlPanelStateResponse::calculate_size() const {
 }
 bool AlarmControlPanelCommandRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
   switch (field_id) {
-    case 2: this->command = static_cast<enums::AlarmControlPanelStateCommand>(value); break;
+    case 2:
+      this->command = static_cast<enums::AlarmControlPanelStateCommand>(value);
+      break;
 #ifdef USE_DEVICES
-    case 4: this->device_id = value; break;
+    case 4:
+      this->device_id = value;
+      break;
 #endif
-    default: return false;
+    default:
+      return false;
   }
   return true;
 }
 bool AlarmControlPanelCommandRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 3: {
-          this->code = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
-          break;
-        }
-    default: return false;
+      this->code = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
+      break;
+    }
+    default:
+      return false;
   }
   return true;
 }
 bool AlarmControlPanelCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
   switch (field_id) {
-    case 1: this->key = value.as_fixed32(); break;
-    default: return false;
+    case 1:
+      this->key = value.as_fixed32();
+      break;
+    default:
+      return false;
   }
   return true;
 }
@@ -2805,26 +3241,33 @@ uint32_t TextStateResponse::calculate_size() const {
 bool TextCommandRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
   switch (field_id) {
 #ifdef USE_DEVICES
-    case 3: this->device_id = value; break;
+    case 3:
+      this->device_id = value;
+      break;
 #endif
-    default: return false;
+    default:
+      return false;
   }
   return true;
 }
 bool TextCommandRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 2: {
-          this->state = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
-          break;
-        }
-    default: return false;
+      this->state = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
+      break;
+    }
+    default:
+      return false;
   }
   return true;
 }
 bool TextCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
   switch (field_id) {
-    case 1: this->key = value.as_fixed32(); break;
-    default: return false;
+    case 1:
+      this->key = value.as_fixed32();
+      break;
+    default:
+      return false;
   }
   return true;
 }
@@ -2886,20 +3329,32 @@ uint32_t DateStateResponse::calculate_size() const {
 }
 bool DateCommandRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
   switch (field_id) {
-    case 2: this->year = value; break;
-    case 3: this->month = value; break;
-    case 4: this->day = value; break;
+    case 2:
+      this->year = value;
+      break;
+    case 3:
+      this->month = value;
+      break;
+    case 4:
+      this->day = value;
+      break;
 #ifdef USE_DEVICES
-    case 5: this->device_id = value; break;
+    case 5:
+      this->device_id = value;
+      break;
 #endif
-    default: return false;
+    default:
+      return false;
   }
   return true;
 }
 bool DateCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
   switch (field_id) {
-    case 1: this->key = value.as_fixed32(); break;
-    default: return false;
+    case 1:
+      this->key = value.as_fixed32();
+      break;
+    default:
+      return false;
   }
   return true;
 }
@@ -2961,20 +3416,32 @@ uint32_t TimeStateResponse::calculate_size() const {
 }
 bool TimeCommandRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
   switch (field_id) {
-    case 2: this->hour = value; break;
-    case 3: this->minute = value; break;
-    case 4: this->second = value; break;
+    case 2:
+      this->hour = value;
+      break;
+    case 3:
+      this->minute = value;
+      break;
+    case 4:
+      this->second = value;
+      break;
 #ifdef USE_DEVICES
-    case 5: this->device_id = value; break;
+    case 5:
+      this->device_id = value;
+      break;
 #endif
-    default: return false;
+    default:
+      return false;
   }
   return true;
 }
 bool TimeCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
   switch (field_id) {
-    case 1: this->key = value.as_fixed32(); break;
-    default: return false;
+    case 1:
+      this->key = value.as_fixed32();
+      break;
+    default:
+      return false;
   }
   return true;
 }
@@ -3100,20 +3567,32 @@ uint32_t ValveStateResponse::calculate_size() const {
 }
 bool ValveCommandRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
   switch (field_id) {
-    case 2: this->has_position = value != 0; break;
-    case 4: this->stop = value != 0; break;
+    case 2:
+      this->has_position = value != 0;
+      break;
+    case 4:
+      this->stop = value != 0;
+      break;
 #ifdef USE_DEVICES
-    case 5: this->device_id = value; break;
+    case 5:
+      this->device_id = value;
+      break;
 #endif
-    default: return false;
+    default:
+      return false;
   }
   return true;
 }
 bool ValveCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
   switch (field_id) {
-    case 1: this->key = value.as_fixed32(); break;
-    case 3: this->position = value.as_float(); break;
-    default: return false;
+    case 1:
+      this->key = value.as_fixed32();
+      break;
+    case 3:
+      this->position = value.as_float();
+      break;
+    default:
+      return false;
   }
   return true;
 }
@@ -3172,17 +3651,25 @@ uint32_t DateTimeStateResponse::calculate_size() const {
 bool DateTimeCommandRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
   switch (field_id) {
 #ifdef USE_DEVICES
-    case 3: this->device_id = value; break;
+    case 3:
+      this->device_id = value;
+      break;
 #endif
-    default: return false;
+    default:
+      return false;
   }
   return true;
 }
 bool DateTimeCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
   switch (field_id) {
-    case 1: this->key = value.as_fixed32(); break;
-    case 2: this->epoch_seconds = value.as_fixed32(); break;
-    default: return false;
+    case 1:
+      this->key = value.as_fixed32();
+      break;
+    case 2:
+      this->epoch_seconds = value.as_fixed32();
+      break;
+    default:
+      return false;
   }
   return true;
 }
@@ -3256,18 +3743,26 @@ uint32_t UpdateStateResponse::calculate_size() const {
 }
 bool UpdateCommandRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
   switch (field_id) {
-    case 2: this->command = static_cast<enums::UpdateCommand>(value); break;
+    case 2:
+      this->command = static_cast<enums::UpdateCommand>(value);
+      break;
 #ifdef USE_DEVICES
-    case 3: this->device_id = value; break;
+    case 3:
+      this->device_id = value;
+      break;
 #endif
-    default: return false;
+    default:
+      return false;
   }
   return true;
 }
 bool UpdateCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
   switch (field_id) {
-    case 1: this->key = value.as_fixed32(); break;
-    default: return false;
+    case 1:
+      this->key = value.as_fixed32();
+      break;
+    default:
+      return false;
   }
   return true;
 }
@@ -3276,11 +3771,12 @@ bool UpdateCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
 bool ZWaveProxyFrame::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 1: {
-          this->data = value.data();
-          this->data_len = value.size();
-          break;
-        }
-    default: return false;
+      this->data = value.data();
+      this->data_len = value.size();
+      break;
+    }
+    default:
+      return false;
   }
   return true;
 }
@@ -3296,19 +3792,23 @@ uint32_t ZWaveProxyFrame::calculate_size() const {
 }
 bool ZWaveProxyRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
   switch (field_id) {
-    case 1: this->type = static_cast<enums::ZWaveProxyRequestType>(value); break;
-    default: return false;
+    case 1:
+      this->type = static_cast<enums::ZWaveProxyRequestType>(value);
+      break;
+    default:
+      return false;
   }
   return true;
 }
 bool ZWaveProxyRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 2: {
-          this->data = value.data();
-          this->data_len = value.size();
-          break;
-        }
-    default: return false;
+      this->data = value.data();
+      this->data_len = value.size();
+      break;
+    }
+    default:
+      return false;
   }
   return true;
 }
@@ -3365,30 +3865,41 @@ uint32_t ListEntitiesInfraredResponse::calculate_size() const {
 bool InfraredRFTransmitRawTimingsRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
   switch (field_id) {
 #ifdef USE_DEVICES
-    case 1: this->device_id = value; break;
+    case 1:
+      this->device_id = value;
+      break;
 #endif
-    case 3: this->carrier_frequency = value; break;
-    case 4: this->repeat_count = value; break;
-    default: return false;
+    case 3:
+      this->carrier_frequency = value;
+      break;
+    case 4:
+      this->repeat_count = value;
+      break;
+    default:
+      return false;
   }
   return true;
 }
 bool InfraredRFTransmitRawTimingsRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 5: {
-          this->timings_data_ = value.data();
-          this->timings_length_ = value.size();
-          this->timings_count_ = count_packed_varints(value.data(), value.size());
-          break;
-        }
-    default: return false;
+      this->timings_data_ = value.data();
+      this->timings_length_ = value.size();
+      this->timings_count_ = count_packed_varints(value.data(), value.size());
+      break;
+    }
+    default:
+      return false;
   }
   return true;
 }
 bool InfraredRFTransmitRawTimingsRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
   switch (field_id) {
-    case 2: this->key = value.as_fixed32(); break;
-    default: return false;
+    case 2:
+      this->key = value.as_fixed32();
+      break;
+    default:
+      return false;
   }
   return true;
 }
@@ -3420,13 +3931,26 @@ uint32_t InfraredRFReceiveEvent::calculate_size() const {
 #ifdef USE_SERIAL_PROXY
 bool SerialProxyConfigureRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
   switch (field_id) {
-    case 1: this->instance = value; break;
-    case 2: this->baudrate = value; break;
-    case 3: this->flow_control = value != 0; break;
-    case 4: this->parity = static_cast<enums::SerialProxyParity>(value); break;
-    case 5: this->stop_bits = value; break;
-    case 6: this->data_size = value; break;
-    default: return false;
+    case 1:
+      this->instance = value;
+      break;
+    case 2:
+      this->baudrate = value;
+      break;
+    case 3:
+      this->flow_control = value != 0;
+      break;
+    case 4:
+      this->parity = static_cast<enums::SerialProxyParity>(value);
+      break;
+    case 5:
+      this->stop_bits = value;
+      break;
+    case 6:
+      this->data_size = value;
+      break;
+    default:
+      return false;
   }
   return true;
 }
@@ -3444,34 +3968,46 @@ uint32_t SerialProxyDataReceived::calculate_size() const {
 }
 bool SerialProxyWriteRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
   switch (field_id) {
-    case 1: this->instance = value; break;
-    default: return false;
+    case 1:
+      this->instance = value;
+      break;
+    default:
+      return false;
   }
   return true;
 }
 bool SerialProxyWriteRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 2: {
-          this->data = value.data();
-          this->data_len = value.size();
-          break;
-        }
-    default: return false;
+      this->data = value.data();
+      this->data_len = value.size();
+      break;
+    }
+    default:
+      return false;
   }
   return true;
 }
 bool SerialProxySetModemPinsRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
   switch (field_id) {
-    case 1: this->instance = value; break;
-    case 2: this->line_states = value; break;
-    default: return false;
+    case 1:
+      this->instance = value;
+      break;
+    case 2:
+      this->line_states = value;
+      break;
+    default:
+      return false;
   }
   return true;
 }
 bool SerialProxyGetModemPinsRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
   switch (field_id) {
-    case 1: this->instance = value; break;
-    default: return false;
+    case 1:
+      this->instance = value;
+      break;
+    default:
+      return false;
   }
   return true;
 }
@@ -3489,9 +4025,14 @@ uint32_t SerialProxyGetModemPinsResponse::calculate_size() const {
 }
 bool SerialProxyRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
   switch (field_id) {
-    case 1: this->instance = value; break;
-    case 2: this->type = static_cast<enums::SerialProxyRequestType>(value); break;
-    default: return false;
+    case 1:
+      this->instance = value;
+      break;
+    case 2:
+      this->type = static_cast<enums::SerialProxyRequestType>(value);
+      break;
+    default:
+      return false;
   }
   return true;
 }
@@ -3515,12 +4056,23 @@ uint32_t SerialProxyRequestResponse::calculate_size() const {
 #ifdef USE_BLUETOOTH_PROXY
 bool BluetoothSetConnectionParamsRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
   switch (field_id) {
-    case 1: this->address = value; break;
-    case 2: this->min_interval = value; break;
-    case 3: this->max_interval = value; break;
-    case 4: this->latency = value; break;
-    case 5: this->timeout = value; break;
-    default: return false;
+    case 1:
+      this->address = value;
+      break;
+    case 2:
+      this->min_interval = value;
+      break;
+    case 3:
+      this->max_interval = value;
+      break;
+    case 4:
+      this->latency = value;
+      break;
+    case 5:
+      this->timeout = value;
+      break;
+    default:
+      return false;
   }
   return true;
 }

From 5b4385a08497b5f2eda32dea77e206d99e5d3f78 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Sun, 12 Apr 2026 21:42:31 -1000
Subject: [PATCH 2/4] [api] Add speed_optimized proto option for hot encode
 paths (#15691)

Co-authored-by: pre-commit-ci-lite[bot] <117423508+pre-commit-ci-lite[bot]@users.noreply.github.com>
---
 esphome/components/api/api.proto         |  2 ++
 esphome/components/api/api_options.proto |  1 +
 esphome/components/api/api_pb2.cpp       | 16 ++++++++++++----
 script/api_protobuf/api_protobuf.py      | 14 ++++++++++++--
 4 files changed, 27 insertions(+), 6 deletions(-)

diff --git a/esphome/components/api/api.proto b/esphome/components/api/api.proto
index e4d0c2d16d..4a9a6f9051 100644
--- a/esphome/components/api/api.proto
+++ b/esphome/components/api/api.proto
@@ -671,6 +671,7 @@ message SensorStateResponse {
   option (source) = SOURCE_SERVER;
   option (ifdef) = "USE_SENSOR";
   option (no_delay) = true;
+  option (speed_optimized) = true;
 
   fixed32 key = 1 [(force) = true];
   float state = 2;
@@ -1638,6 +1639,7 @@ message BluetoothLERawAdvertisementsResponse {
   option (source) = SOURCE_SERVER;
   option (ifdef) = "USE_BLUETOOTH_PROXY";
   option (no_delay) = true;
+  option (speed_optimized) = true;
 
   repeated BluetoothLERawAdvertisement advertisements = 1 [(fixed_array_with_length_define) = "BLUETOOTH_PROXY_ADVERTISEMENT_BATCH_SIZE"];
 }
diff --git a/esphome/components/api/api_options.proto b/esphome/components/api/api_options.proto
index dacc290e31..d5d0b37e8d 100644
--- a/esphome/components/api/api_options.proto
+++ b/esphome/components/api/api_options.proto
@@ -23,6 +23,7 @@ extend google.protobuf.MessageOptions {
     optional bool no_delay = 1040 [default=false];
     optional string base_class = 1041;
     optional bool inline_encode = 1042 [default=false];
+    optional bool speed_optimized = 1043 [default=false];
 }
 
 extend google.protobuf.FieldOptions {
diff --git a/esphome/components/api/api_pb2.cpp b/esphome/components/api/api_pb2.cpp
index c2d513f0d3..481510e407 100644
--- a/esphome/components/api/api_pb2.cpp
+++ b/esphome/components/api/api_pb2.cpp
@@ -745,7 +745,9 @@ uint32_t ListEntitiesSensorResponse::calculate_size() const {
 #endif
   return size;
 }
-uint8_t *SensorStateResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+__attribute__((optimize("O2")))  // NOLINT(clang-diagnostic-unknown-attributes)
+uint8_t *
+SensorStateResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
   uint8_t *__restrict__ pos = buffer.get_pos();
   ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 13, this->key);
   ProtoEncode::encode_float(pos PROTO_ENCODE_DEBUG_ARG, 2, this->state);
@@ -755,7 +757,9 @@ uint8_t *SensorStateResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG
 #endif
   return pos;
 }
-uint32_t SensorStateResponse::calculate_size() const {
+__attribute__((optimize("O2")))  // NOLINT(clang-diagnostic-unknown-attributes)
+uint32_t
+SensorStateResponse::calculate_size() const {
   uint32_t size = 0;
   size += 5;
   size += ProtoSize::calc_float(1, this->state);
@@ -2328,7 +2332,9 @@ bool SubscribeBluetoothLEAdvertisementsRequest::decode_varint(uint32_t field_id,
   }
   return true;
 }
-uint8_t *BluetoothLERawAdvertisementsResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+__attribute__((optimize("O2")))  // NOLINT(clang-diagnostic-unknown-attributes)
+uint8_t *
+BluetoothLERawAdvertisementsResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
   uint8_t *__restrict__ pos = buffer.get_pos();
   for (uint16_t i = 0; i < this->advertisements_len; i++) {
     auto &sub_msg = this->advertisements[i];
@@ -2350,7 +2356,9 @@ uint8_t *BluetoothLERawAdvertisementsResponse::encode(ProtoWriteBuffer &buffer P
   }
   return pos;
 }
-uint32_t BluetoothLERawAdvertisementsResponse::calculate_size() const {
+__attribute__((optimize("O2")))  // NOLINT(clang-diagnostic-unknown-attributes)
+uint32_t
+BluetoothLERawAdvertisementsResponse::calculate_size() const {
   uint32_t size = 0;
   for (uint16_t i = 0; i < this->advertisements_len; i++) {
     auto &sub_msg = this->advertisements[i];
diff --git a/script/api_protobuf/api_protobuf.py b/script/api_protobuf/api_protobuf.py
index 39bfc865d0..1743d2bb34 100755
--- a/script/api_protobuf/api_protobuf.py
+++ b/script/api_protobuf/api_protobuf.py
@@ -2679,6 +2679,16 @@ def build_message_type(
         and get_opt(desc, inline_opt, False)
     )
 
+    # Check if this message wants speed-optimized encode/calculate_size.
+    # When set, __attribute__((optimize("O2"))) is added to the definitions
+    # so GCC inlines the small ProtoEncode helpers even under -Os.
+    is_speed_optimized = get_opt(desc, pb.speed_optimized, False)
+    speed_attr = (
+        '__attribute__((optimize("O2")))  // NOLINT(clang-diagnostic-unknown-attributes)\n'
+        if is_speed_optimized
+        else ""
+    )
+
     # Only generate encode method if this message needs encoding and has fields
     if needs_encode and encode and not is_inline_only:
         # Add PROTO_ENCODE_DEBUG_ARG after pos in all proto_* calls
@@ -2688,7 +2698,7 @@ def build_message_type(
             )
             for line in encode
         ]
-        o = f"uint8_t *{desc.name}::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {{\n"
+        o = f"{speed_attr}uint8_t *{desc.name}::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {{\n"
         o += "  uint8_t *__restrict__ pos = buffer.get_pos();\n"
         o += indent("\n".join(encode_debug)) + "\n"
         o += "  return pos;\n"
@@ -2702,7 +2712,7 @@ def build_message_type(
 
     # Add calculate_size method only if this message needs encoding and has fields
     if needs_encode and size_calc and not is_inline_only:
-        o = f"uint32_t {desc.name}::calculate_size() const {{\n"
+        o = f"{speed_attr}uint32_t {desc.name}::calculate_size() const {{\n"
         o += "  uint32_t size = 0;\n"
         o += indent("\n".join(size_calc)) + "\n"
         o += "  return size;\n"

From 6db787d5e4cf637182b7b82e1e23b82971a1a46a Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 13 Apr 2026 08:12:57 +0000
Subject: [PATCH 3/4] Bump aioesphomeapi from 44.14.0 to 44.15.0 (#15699)

Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 requirements.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/requirements.txt b/requirements.txt
index fa642b579b..cd3aa5bd86 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -12,7 +12,7 @@ platformio==6.1.19
 esptool==5.2.0
 click==8.3.2
 esphome-dashboard==20260408.1
-aioesphomeapi==44.14.0
+aioesphomeapi==44.15.0
 zeroconf==0.148.0
 puremagic==1.30
 ruamel.yaml==0.19.1 # dashboard_import

From 4bcf3b9661d47b3a957cfc235ad9d30d1419d070 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@home-assistant.io>
Date: Sun, 12 Apr 2026 22:44:02 -1000
Subject: [PATCH 4/4] fix existing bug

---
 esphome/components/api/api_pb2.cpp  | 2 +-
 script/api_protobuf/api_protobuf.py | 6 ++++--
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/esphome/components/api/api_pb2.cpp b/esphome/components/api/api_pb2.cpp
index 9943c06cb1..f304c85282 100644
--- a/esphome/components/api/api_pb2.cpp
+++ b/esphome/components/api/api_pb2.cpp
@@ -931,7 +931,7 @@ uint32_t
 SubscribeLogsResponse::calculate_size() const {
   uint32_t size = 0;
   size += 2;
-  size += ProtoSize::calc_length(1, this->message_len_);
+  size += ProtoSize::calc_length_force(1, this->message_len_);
   return size;
 }
 #ifdef USE_API_NOISE
diff --git a/script/api_protobuf/api_protobuf.py b/script/api_protobuf/api_protobuf.py
index 1743d2bb34..73e0859d5e 100755
--- a/script/api_protobuf/api_protobuf.py
+++ b/script/api_protobuf/api_protobuf.py
@@ -1028,7 +1028,8 @@ class BytesType(TypeInfo):
         )
 
     def get_size_calculation(self, name: str, force: bool = False) -> str:
-        return f"size += ProtoSize::calc_length({self.calculate_field_id_size()}, this->{self.field_name}_len_);"
+        calc_fn = "calc_length_force" if force else "calc_length"
+        return f"size += ProtoSize::{calc_fn}({self.calculate_field_id_size()}, this->{self.field_name}_len_);"
 
     def get_estimated_size(self) -> int:
         return self.calculate_field_id_size() + 8  # field ID + 8 bytes typical bytes
@@ -1109,7 +1110,8 @@ class PointerToBytesBufferType(PointerToBufferTypeBase):
         )
 
     def get_size_calculation(self, name: str, force: bool = False) -> str:
-        return f"size += ProtoSize::calc_length({self.calculate_field_id_size()}, this->{self.field_name}_len);"
+        calc_fn = "calc_length_force" if force else "calc_length"
+        return f"size += ProtoSize::{calc_fn}({self.calculate_field_id_size()}, this->{self.field_name}_len);"
 
 
 class PointerToStringBufferType(PointerToBufferTypeBase):