esphome 2025.4.1__py3-none-any.whl → 2025.5.0b2__py3-none-any.whl

esphome/components/api/api_pb2.cpp

@@ -1,6 +1,7 @@
 // This file was automatically generated with a tool.
-// See scripts/api_protobuf/api_protobuf.py
+// See script/api_protobuf/api_protobuf.py
 #include "api_pb2.h"
+#include "api_pb2_size.h"
 #include "esphome/core/log.h"
 
 #include <cinttypes>
@@ -422,6 +423,38 @@ const char *proto_enum_to_string<enums::BluetoothDeviceRequestType>(enums::Bluet
 }
 #endif
 #ifdef HAS_PROTO_MESSAGE_DUMP
+template<> const char *proto_enum_to_string<enums::BluetoothScannerState>(enums::BluetoothScannerState value) {
+  switch (value) {
+    case enums::BLUETOOTH_SCANNER_STATE_IDLE:
+      return "BLUETOOTH_SCANNER_STATE_IDLE";
+    case enums::BLUETOOTH_SCANNER_STATE_STARTING:
+      return "BLUETOOTH_SCANNER_STATE_STARTING";
+    case enums::BLUETOOTH_SCANNER_STATE_RUNNING:
+      return "BLUETOOTH_SCANNER_STATE_RUNNING";
+    case enums::BLUETOOTH_SCANNER_STATE_FAILED:
+      return "BLUETOOTH_SCANNER_STATE_FAILED";
+    case enums::BLUETOOTH_SCANNER_STATE_STOPPING:
+      return "BLUETOOTH_SCANNER_STATE_STOPPING";
+    case enums::BLUETOOTH_SCANNER_STATE_STOPPED:
+      return "BLUETOOTH_SCANNER_STATE_STOPPED";
+    default:
+      return "UNKNOWN";
+  }
+}
+#endif
+#ifdef HAS_PROTO_MESSAGE_DUMP
+template<> const char *proto_enum_to_string<enums::BluetoothScannerMode>(enums::BluetoothScannerMode value) {
+  switch (value) {
+    case enums::BLUETOOTH_SCANNER_MODE_PASSIVE:
+      return "BLUETOOTH_SCANNER_MODE_PASSIVE";
+    case enums::BLUETOOTH_SCANNER_MODE_ACTIVE:
+      return "BLUETOOTH_SCANNER_MODE_ACTIVE";
+    default:
+      return "UNKNOWN";
+  }
+}
+#endif
+#ifdef HAS_PROTO_MESSAGE_DUMP
 template<>
 const char *proto_enum_to_string<enums::VoiceAssistantSubscribeFlag>(enums::VoiceAssistantSubscribeFlag value) {
   switch (value) {
@@ -622,6 +655,11 @@ void HelloRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_uint32(2, this->api_version_major);
   buffer.encode_uint32(3, this->api_version_minor);
 }
+void HelloRequest::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_string_field(total_size, 1, this->client_info, false);
+  ProtoSize::add_uint32_field(total_size, 1, this->api_version_major, false);
+  ProtoSize::add_uint32_field(total_size, 1, this->api_version_minor, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void HelloRequest::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -676,6 +714,12 @@ void HelloResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(3, this->server_info);
   buffer.encode_string(4, this->name);
 }
+void HelloResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_uint32_field(total_size, 1, this->api_version_major, false);
+  ProtoSize::add_uint32_field(total_size, 1, this->api_version_minor, false);
+  ProtoSize::add_string_field(total_size, 1, this->server_info, false);
+  ProtoSize::add_string_field(total_size, 1, this->name, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void HelloResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -711,6 +755,9 @@ bool ConnectRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value
   }
 }
 void ConnectRequest::encode(ProtoWriteBuffer buffer) const { buffer.encode_string(1, this->password); }
+void ConnectRequest::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_string_field(total_size, 1, this->password, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ConnectRequest::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -732,6 +779,9 @@ bool ConnectResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
   }
 }
 void ConnectResponse::encode(ProtoWriteBuffer buffer) const { buffer.encode_bool(1, this->invalid_password); }
+void ConnectResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_bool_field(total_size, 1, this->invalid_password, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ConnectResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -743,22 +793,27 @@ void ConnectResponse::dump_to(std::string &out) const {
 }
 #endif
 void DisconnectRequest::encode(ProtoWriteBuffer buffer) const {}
+void DisconnectRequest::calculate_size(uint32_t &total_size) const {}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void DisconnectRequest::dump_to(std::string &out) const { out.append("DisconnectRequest {}"); }
 #endif
 void DisconnectResponse::encode(ProtoWriteBuffer buffer) const {}
+void DisconnectResponse::calculate_size(uint32_t &total_size) const {}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void DisconnectResponse::dump_to(std::string &out) const { out.append("DisconnectResponse {}"); }
 #endif
 void PingRequest::encode(ProtoWriteBuffer buffer) const {}
+void PingRequest::calculate_size(uint32_t &total_size) const {}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void PingRequest::dump_to(std::string &out) const { out.append("PingRequest {}"); }
 #endif
 void PingResponse::encode(ProtoWriteBuffer buffer) const {}
+void PingResponse::calculate_size(uint32_t &total_size) const {}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void PingResponse::dump_to(std::string &out) const { out.append("PingResponse {}"); }
 #endif
 void DeviceInfoRequest::encode(ProtoWriteBuffer buffer) const {}
+void DeviceInfoRequest::calculate_size(uint32_t &total_size) const {}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void DeviceInfoRequest::dump_to(std::string &out) const { out.append("DeviceInfoRequest {}"); }
 #endif
@@ -792,6 +847,10 @@ bool DeviceInfoResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
       this->voice_assistant_feature_flags = value.as_uint32();
       return true;
     }
+    case 19: {
+      this->api_encryption_supported = value.as_bool();
+      return true;
+    }
     default:
       return false;
   }
@@ -865,6 +924,28 @@ void DeviceInfoResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_uint32(17, this->voice_assistant_feature_flags);
   buffer.encode_string(16, this->suggested_area);
   buffer.encode_string(18, this->bluetooth_mac_address);
+  buffer.encode_bool(19, this->api_encryption_supported);
+}
+void DeviceInfoResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_bool_field(total_size, 1, this->uses_password, false);
+  ProtoSize::add_string_field(total_size, 1, this->name, false);
+  ProtoSize::add_string_field(total_size, 1, this->mac_address, false);
+  ProtoSize::add_string_field(total_size, 1, this->esphome_version, false);
+  ProtoSize::add_string_field(total_size, 1, this->compilation_time, false);
+  ProtoSize::add_string_field(total_size, 1, this->model, false);
+  ProtoSize::add_bool_field(total_size, 1, this->has_deep_sleep, false);
+  ProtoSize::add_string_field(total_size, 1, this->project_name, false);
+  ProtoSize::add_string_field(total_size, 1, this->project_version, false);
+  ProtoSize::add_uint32_field(total_size, 1, this->webserver_port, false);
+  ProtoSize::add_uint32_field(total_size, 1, this->legacy_bluetooth_proxy_version, false);
+  ProtoSize::add_uint32_field(total_size, 1, this->bluetooth_proxy_feature_flags, false);
+  ProtoSize::add_string_field(total_size, 1, this->manufacturer, false);
+  ProtoSize::add_string_field(total_size, 1, this->friendly_name, false);
+  ProtoSize::add_uint32_field(total_size, 1, this->legacy_voice_assistant_version, false);
+  ProtoSize::add_uint32_field(total_size, 2, this->voice_assistant_feature_flags, false);
+  ProtoSize::add_string_field(total_size, 2, this->suggested_area, false);
+  ProtoSize::add_string_field(total_size, 2, this->bluetooth_mac_address, false);
+  ProtoSize::add_bool_field(total_size, 2, this->api_encryption_supported, false);
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void DeviceInfoResponse::dump_to(std::string &out) const {
@@ -946,18 +1027,25 @@ void DeviceInfoResponse::dump_to(std::string &out) const {
   out.append("  bluetooth_mac_address: ");
   out.append("'").append(this->bluetooth_mac_address).append("'");
   out.append("\n");
+
+  out.append("  api_encryption_supported: ");
+  out.append(YESNO(this->api_encryption_supported));
+  out.append("\n");
   out.append("}");
 }
 #endif
 void ListEntitiesRequest::encode(ProtoWriteBuffer buffer) const {}
+void ListEntitiesRequest::calculate_size(uint32_t &total_size) const {}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ListEntitiesRequest::dump_to(std::string &out) const { out.append("ListEntitiesRequest {}"); }
 #endif
 void ListEntitiesDoneResponse::encode(ProtoWriteBuffer buffer) const {}
+void ListEntitiesDoneResponse::calculate_size(uint32_t &total_size) const {}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ListEntitiesDoneResponse::dump_to(std::string &out) const { out.append("ListEntitiesDoneResponse {}"); }
 #endif
 void SubscribeStatesRequest::encode(ProtoWriteBuffer buffer) const {}
+void SubscribeStatesRequest::calculate_size(uint32_t &total_size) const {}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void SubscribeStatesRequest::dump_to(std::string &out) const { out.append("SubscribeStatesRequest {}"); }
 #endif
@@ -1026,6 +1114,17 @@ void ListEntitiesBinarySensorResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(8, this->icon);
   buffer.encode_enum<enums::EntityCategory>(9, this->entity_category);
 }
+void ListEntitiesBinarySensorResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_string_field(total_size, 1, this->object_id, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_string_field(total_size, 1, this->name, false);
+  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
+  ProtoSize::add_string_field(total_size, 1, this->device_class, false);
+  ProtoSize::add_bool_field(total_size, 1, this->is_status_binary_sensor, false);
+  ProtoSize::add_bool_field(total_size, 1, this->disabled_by_default, false);
+  ProtoSize::add_string_field(total_size, 1, this->icon, false);
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->entity_category), false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ListEntitiesBinarySensorResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -1098,6 +1197,11 @@ void BinarySensorStateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_bool(2, this->state);
   buffer.encode_bool(3, this->missing_state);
 }
+void BinarySensorStateResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_bool_field(total_size, 1, this->state, false);
+  ProtoSize::add_bool_field(total_size, 1, this->missing_state, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void BinarySensorStateResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -1197,6 +1301,20 @@ void ListEntitiesCoverResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_enum<enums::EntityCategory>(11, this->entity_category);
   buffer.encode_bool(12, this->supports_stop);
 }
+void ListEntitiesCoverResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_string_field(total_size, 1, this->object_id, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_string_field(total_size, 1, this->name, false);
+  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
+  ProtoSize::add_bool_field(total_size, 1, this->assumed_state, false);
+  ProtoSize::add_bool_field(total_size, 1, this->supports_position, false);
+  ProtoSize::add_bool_field(total_size, 1, this->supports_tilt, false);
+  ProtoSize::add_string_field(total_size, 1, this->device_class, false);
+  ProtoSize::add_bool_field(total_size, 1, this->disabled_by_default, false);
+  ProtoSize::add_string_field(total_size, 1, this->icon, false);
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->entity_category), false);
+  ProtoSize::add_bool_field(total_size, 1, this->supports_stop, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ListEntitiesCoverResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -1291,6 +1409,13 @@ void CoverStateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_float(4, this->tilt);
   buffer.encode_enum<enums::CoverOperation>(5, this->current_operation);
 }
+void CoverStateResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->legacy_state), false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->position != 0.0f, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->tilt != 0.0f, false);
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->current_operation), false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void CoverStateResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -1374,6 +1499,16 @@ void CoverCommandRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_float(7, this->tilt);
   buffer.encode_bool(8, this->stop);
 }
+void CoverCommandRequest::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_bool_field(total_size, 1, this->has_legacy_command, false);
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->legacy_command), false);
+  ProtoSize::add_bool_field(total_size, 1, this->has_position, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->position != 0.0f, false);
+  ProtoSize::add_bool_field(total_size, 1, this->has_tilt, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->tilt != 0.0f, false);
+  ProtoSize::add_bool_field(total_size, 1, this->stop, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void CoverCommandRequest::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -1497,6 +1632,24 @@ void ListEntitiesFanResponse::encode(ProtoWriteBuffer buffer) const {
     buffer.encode_string(12, it, true);
   }
 }
+void ListEntitiesFanResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_string_field(total_size, 1, this->object_id, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_string_field(total_size, 1, this->name, false);
+  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
+  ProtoSize::add_bool_field(total_size, 1, this->supports_oscillation, false);
+  ProtoSize::add_bool_field(total_size, 1, this->supports_speed, false);
+  ProtoSize::add_bool_field(total_size, 1, this->supports_direction, false);
+  ProtoSize::add_int32_field(total_size, 1, this->supported_speed_count, false);
+  ProtoSize::add_bool_field(total_size, 1, this->disabled_by_default, false);
+  ProtoSize::add_string_field(total_size, 1, this->icon, false);
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->entity_category), false);
+  if (!this->supported_preset_modes.empty()) {
+    for (const auto &it : this->supported_preset_modes) {
+      ProtoSize::add_string_field(total_size, 1, it, true);
+    }
+  }
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ListEntitiesFanResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -1610,6 +1763,15 @@ void FanStateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_int32(6, this->speed_level);
   buffer.encode_string(7, this->preset_mode);
 }
+void FanStateResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_bool_field(total_size, 1, this->state, false);
+  ProtoSize::add_bool_field(total_size, 1, this->oscillating, false);
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->speed), false);
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->direction), false);
+  ProtoSize::add_int32_field(total_size, 1, this->speed_level, false);
+  ProtoSize::add_string_field(total_size, 1, this->preset_mode, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void FanStateResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -1731,6 +1893,21 @@ void FanCommandRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_bool(12, this->has_preset_mode);
   buffer.encode_string(13, this->preset_mode);
 }
+void FanCommandRequest::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_bool_field(total_size, 1, this->has_state, false);
+  ProtoSize::add_bool_field(total_size, 1, this->state, false);
+  ProtoSize::add_bool_field(total_size, 1, this->has_speed, false);
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->speed), false);
+  ProtoSize::add_bool_field(total_size, 1, this->has_oscillating, false);
+  ProtoSize::add_bool_field(total_size, 1, this->oscillating, false);
+  ProtoSize::add_bool_field(total_size, 1, this->has_direction, false);
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->direction), false);
+  ProtoSize::add_bool_field(total_size, 1, this->has_speed_level, false);
+  ProtoSize::add_int32_field(total_size, 1, this->speed_level, false);
+  ProtoSize::add_bool_field(total_size, 1, this->has_preset_mode, false);
+  ProtoSize::add_string_field(total_size, 1, this->preset_mode, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void FanCommandRequest::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -1890,6 +2067,31 @@ void ListEntitiesLightResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(14, this->icon);
   buffer.encode_enum<enums::EntityCategory>(15, this->entity_category);
 }
+void ListEntitiesLightResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_string_field(total_size, 1, this->object_id, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_string_field(total_size, 1, this->name, false);
+  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
+  if (!this->supported_color_modes.empty()) {
+    for (const auto &it : this->supported_color_modes) {
+      ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(it), true);
+    }
+  }
+  ProtoSize::add_bool_field(total_size, 1, this->legacy_supports_brightness, false);
+  ProtoSize::add_bool_field(total_size, 1, this->legacy_supports_rgb, false);
+  ProtoSize::add_bool_field(total_size, 1, this->legacy_supports_white_value, false);
+  ProtoSize::add_bool_field(total_size, 1, this->legacy_supports_color_temperature, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->min_mireds != 0.0f, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->max_mireds != 0.0f, false);
+  if (!this->effects.empty()) {
+    for (const auto &it : this->effects) {
+      ProtoSize::add_string_field(total_size, 1, it, true);
+    }
+  }
+  ProtoSize::add_bool_field(total_size, 1, this->disabled_by_default, false);
+  ProtoSize::add_string_field(total_size, 1, this->icon, false);
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->entity_category), false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ListEntitiesLightResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -2048,6 +2250,21 @@ void LightStateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_float(13, this->warm_white);
   buffer.encode_string(9, this->effect);
 }
+void LightStateResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_bool_field(total_size, 1, this->state, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->brightness != 0.0f, false);
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->color_mode), false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->color_brightness != 0.0f, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->red != 0.0f, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->green != 0.0f, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->blue != 0.0f, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->white != 0.0f, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->color_temperature != 0.0f, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->cold_white != 0.0f, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->warm_white != 0.0f, false);
+  ProtoSize::add_string_field(total_size, 1, this->effect, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void LightStateResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -2271,6 +2488,35 @@ void LightCommandRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_bool(18, this->has_effect);
   buffer.encode_string(19, this->effect);
 }
+void LightCommandRequest::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_bool_field(total_size, 1, this->has_state, false);
+  ProtoSize::add_bool_field(total_size, 1, this->state, false);
+  ProtoSize::add_bool_field(total_size, 1, this->has_brightness, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->brightness != 0.0f, false);
+  ProtoSize::add_bool_field(total_size, 2, this->has_color_mode, false);
+  ProtoSize::add_enum_field(total_size, 2, static_cast<uint32_t>(this->color_mode), false);
+  ProtoSize::add_bool_field(total_size, 2, this->has_color_brightness, false);
+  ProtoSize::add_fixed_field<4>(total_size, 2, this->color_brightness != 0.0f, false);
+  ProtoSize::add_bool_field(total_size, 1, this->has_rgb, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->red != 0.0f, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->green != 0.0f, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->blue != 0.0f, false);
+  ProtoSize::add_bool_field(total_size, 1, this->has_white, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->white != 0.0f, false);
+  ProtoSize::add_bool_field(total_size, 1, this->has_color_temperature, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->color_temperature != 0.0f, false);
+  ProtoSize::add_bool_field(total_size, 2, this->has_cold_white, false);
+  ProtoSize::add_fixed_field<4>(total_size, 2, this->cold_white != 0.0f, false);
+  ProtoSize::add_bool_field(total_size, 2, this->has_warm_white, false);
+  ProtoSize::add_fixed_field<4>(total_size, 2, this->warm_white != 0.0f, false);
+  ProtoSize::add_bool_field(total_size, 1, this->has_transition_length, false);
+  ProtoSize::add_uint32_field(total_size, 1, this->transition_length, false);
+  ProtoSize::add_bool_field(total_size, 2, this->has_flash_length, false);
+  ProtoSize::add_uint32_field(total_size, 2, this->flash_length, false);
+  ProtoSize::add_bool_field(total_size, 2, this->has_effect, false);
+  ProtoSize::add_string_field(total_size, 2, this->effect, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void LightCommandRequest::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -2482,6 +2728,21 @@ void ListEntitiesSensorResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_bool(12, this->disabled_by_default);
   buffer.encode_enum<enums::EntityCategory>(13, this->entity_category);
 }
+void ListEntitiesSensorResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_string_field(total_size, 1, this->object_id, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_string_field(total_size, 1, this->name, false);
+  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
+  ProtoSize::add_string_field(total_size, 1, this->icon, false);
+  ProtoSize::add_string_field(total_size, 1, this->unit_of_measurement, false);
+  ProtoSize::add_int32_field(total_size, 1, this->accuracy_decimals, false);
+  ProtoSize::add_bool_field(total_size, 1, this->force_update, false);
+  ProtoSize::add_string_field(total_size, 1, this->device_class, false);
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->state_class), false);
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->legacy_last_reset_type), false);
+  ProtoSize::add_bool_field(total_size, 1, this->disabled_by_default, false);
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->entity_category), false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ListEntitiesSensorResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -2571,6 +2832,11 @@ void SensorStateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_float(2, this->state);
   buffer.encode_bool(3, this->missing_state);
 }
+void SensorStateResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->state != 0.0f, false);
+  ProtoSize::add_bool_field(total_size, 1, this->missing_state, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void SensorStateResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -2656,6 +2922,17 @@ void ListEntitiesSwitchResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_enum<enums::EntityCategory>(8, this->entity_category);
   buffer.encode_string(9, this->device_class);
 }
+void ListEntitiesSwitchResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_string_field(total_size, 1, this->object_id, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_string_field(total_size, 1, this->name, false);
+  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
+  ProtoSize::add_string_field(total_size, 1, this->icon, false);
+  ProtoSize::add_bool_field(total_size, 1, this->assumed_state, false);
+  ProtoSize::add_bool_field(total_size, 1, this->disabled_by_default, false);
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->entity_category), false);
+  ProtoSize::add_string_field(total_size, 1, this->device_class, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ListEntitiesSwitchResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -2723,6 +3000,10 @@ void SwitchStateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_fixed32(1, this->key);
   buffer.encode_bool(2, this->state);
 }
+void SwitchStateResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_bool_field(total_size, 1, this->state, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void SwitchStateResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -2762,6 +3043,10 @@ void SwitchCommandRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_fixed32(1, this->key);
   buffer.encode_bool(2, this->state);
 }
+void SwitchCommandRequest::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_bool_field(total_size, 1, this->state, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void SwitchCommandRequest::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -2837,6 +3122,16 @@ void ListEntitiesTextSensorResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_enum<enums::EntityCategory>(7, this->entity_category);
   buffer.encode_string(8, this->device_class);
 }
+void ListEntitiesTextSensorResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_string_field(total_size, 1, this->object_id, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_string_field(total_size, 1, this->name, false);
+  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
+  ProtoSize::add_string_field(total_size, 1, this->icon, false);
+  ProtoSize::add_bool_field(total_size, 1, this->disabled_by_default, false);
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->entity_category), false);
+  ProtoSize::add_string_field(total_size, 1, this->device_class, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ListEntitiesTextSensorResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -2911,6 +3206,11 @@ void TextSensorStateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(2, this->state);
   buffer.encode_bool(3, this->missing_state);
 }
+void TextSensorStateResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_string_field(total_size, 1, this->state, false);
+  ProtoSize::add_bool_field(total_size, 1, this->missing_state, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void TextSensorStateResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -2948,6 +3248,10 @@ void SubscribeLogsRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_enum<enums::LogLevel>(1, this->level);
   buffer.encode_bool(2, this->dump_config);
 }
+void SubscribeLogsRequest::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->level), false);
+  ProtoSize::add_bool_field(total_size, 1, this->dump_config, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void SubscribeLogsRequest::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -2991,6 +3295,11 @@ void SubscribeLogsResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(3, this->message);
   buffer.encode_bool(4, this->send_failed);
 }
+void SubscribeLogsResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->level), false);
+  ProtoSize::add_string_field(total_size, 1, this->message, false);
+  ProtoSize::add_bool_field(total_size, 1, this->send_failed, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void SubscribeLogsResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -3009,7 +3318,56 @@ void SubscribeLogsResponse::dump_to(std::string &out) const {
   out.append("}");
 }
 #endif
+bool NoiseEncryptionSetKeyRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
+  switch (field_id) {
+    case 1: {
+      this->key = value.as_string();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+void NoiseEncryptionSetKeyRequest::encode(ProtoWriteBuffer buffer) const { buffer.encode_string(1, this->key); }
+void NoiseEncryptionSetKeyRequest::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_string_field(total_size, 1, this->key, false);
+}
+#ifdef HAS_PROTO_MESSAGE_DUMP
+void NoiseEncryptionSetKeyRequest::dump_to(std::string &out) const {
+  __attribute__((unused)) char buffer[64];
+  out.append("NoiseEncryptionSetKeyRequest {\n");
+  out.append("  key: ");
+  out.append("'").append(this->key).append("'");
+  out.append("\n");
+  out.append("}");
+}
+#endif
+bool NoiseEncryptionSetKeyResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
+  switch (field_id) {
+    case 1: {
+      this->success = value.as_bool();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+void NoiseEncryptionSetKeyResponse::encode(ProtoWriteBuffer buffer) const { buffer.encode_bool(1, this->success); }
+void NoiseEncryptionSetKeyResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_bool_field(total_size, 1, this->success, false);
+}
+#ifdef HAS_PROTO_MESSAGE_DUMP
+void NoiseEncryptionSetKeyResponse::dump_to(std::string &out) const {
+  __attribute__((unused)) char buffer[64];
+  out.append("NoiseEncryptionSetKeyResponse {\n");
+  out.append("  success: ");
+  out.append(YESNO(this->success));
+  out.append("\n");
+  out.append("}");
+}
+#endif
 void SubscribeHomeassistantServicesRequest::encode(ProtoWriteBuffer buffer) const {}
+void SubscribeHomeassistantServicesRequest::calculate_size(uint32_t &total_size) const {}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void SubscribeHomeassistantServicesRequest::dump_to(std::string &out) const {
   out.append("SubscribeHomeassistantServicesRequest {}");
@@ -3033,6 +3391,10 @@ void HomeassistantServiceMap::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->key);
   buffer.encode_string(2, this->value);
 }
+void HomeassistantServiceMap::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_string_field(total_size, 1, this->key, false);
+  ProtoSize::add_string_field(total_size, 1, this->value, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void HomeassistantServiceMap::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -3092,6 +3454,13 @@ void HomeassistantServiceResponse::encode(ProtoWriteBuffer buffer) const {
   }
   buffer.encode_bool(5, this->is_event);
 }
+void HomeassistantServiceResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_string_field(total_size, 1, this->service, false);
+  ProtoSize::add_repeated_message(total_size, 1, this->data);
+  ProtoSize::add_repeated_message(total_size, 1, this->data_template);
+  ProtoSize::add_repeated_message(total_size, 1, this->variables);
+  ProtoSize::add_bool_field(total_size, 1, this->is_event, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void HomeassistantServiceResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -3125,6 +3494,7 @@ void HomeassistantServiceResponse::dump_to(std::string &out) const {
 }
 #endif
 void SubscribeHomeAssistantStatesRequest::encode(ProtoWriteBuffer buffer) const {}
+void SubscribeHomeAssistantStatesRequest::calculate_size(uint32_t &total_size) const {}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void SubscribeHomeAssistantStatesRequest::dump_to(std::string &out) const {
   out.append("SubscribeHomeAssistantStatesRequest {}");
@@ -3159,6 +3529,11 @@ void SubscribeHomeAssistantStateResponse::encode(ProtoWriteBuffer buffer) const
   buffer.encode_string(2, this->attribute);
   buffer.encode_bool(3, this->once);
 }
+void SubscribeHomeAssistantStateResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_string_field(total_size, 1, this->entity_id, false);
+  ProtoSize::add_string_field(total_size, 1, this->attribute, false);
+  ProtoSize::add_bool_field(total_size, 1, this->once, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void SubscribeHomeAssistantStateResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -3200,6 +3575,11 @@ void HomeAssistantStateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(2, this->state);
   buffer.encode_string(3, this->attribute);
 }
+void HomeAssistantStateResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_string_field(total_size, 1, this->entity_id, false);
+  ProtoSize::add_string_field(total_size, 1, this->state, false);
+  ProtoSize::add_string_field(total_size, 1, this->attribute, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void HomeAssistantStateResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -3219,6 +3599,7 @@ void HomeAssistantStateResponse::dump_to(std::string &out) const {
 }
 #endif
 void GetTimeRequest::encode(ProtoWriteBuffer buffer) const {}
+void GetTimeRequest::calculate_size(uint32_t &total_size) const {}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void GetTimeRequest::dump_to(std::string &out) const { out.append("GetTimeRequest {}"); }
 #endif
@@ -3233,6 +3614,9 @@ bool GetTimeResponse::decode_32bit(uint32_t field_id, Proto32Bit value) {
   }
 }
 void GetTimeResponse::encode(ProtoWriteBuffer buffer) const { buffer.encode_fixed32(1, this->epoch_seconds); }
+void GetTimeResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->epoch_seconds != 0, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void GetTimeResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -3268,6 +3652,10 @@ void ListEntitiesServicesArgument::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->name);
   buffer.encode_enum<enums::ServiceArgType>(2, this->type);
 }
+void ListEntitiesServicesArgument::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_string_field(total_size, 1, this->name, false);
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->type), false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ListEntitiesServicesArgument::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -3313,6 +3701,11 @@ void ListEntitiesServicesResponse::encode(ProtoWriteBuffer buffer) const {
     buffer.encode_message<ListEntitiesServicesArgument>(3, it, true);
   }
 }
+void ListEntitiesServicesResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_string_field(total_size, 1, this->name, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_repeated_message(total_size, 1, this->args);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ListEntitiesServicesResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -3407,6 +3800,33 @@ void ExecuteServiceArgument::encode(ProtoWriteBuffer buffer) const {
     buffer.encode_string(9, it, true);
   }
 }
+void ExecuteServiceArgument::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_bool_field(total_size, 1, this->bool_, false);
+  ProtoSize::add_int32_field(total_size, 1, this->legacy_int, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->float_ != 0.0f, false);
+  ProtoSize::add_string_field(total_size, 1, this->string_, false);
+  ProtoSize::add_sint32_field(total_size, 1, this->int_, false);
+  if (!this->bool_array.empty()) {
+    for (const auto it : this->bool_array) {
+      ProtoSize::add_bool_field(total_size, 1, it, true);
+    }
+  }
+  if (!this->int_array.empty()) {
+    for (const auto &it : this->int_array) {
+      ProtoSize::add_sint32_field(total_size, 1, it, true);
+    }
+  }
+  if (!this->float_array.empty()) {
+    for (const auto &it : this->float_array) {
+      ProtoSize::add_fixed_field<4>(total_size, 1, it != 0.0f, true);
+    }
+  }
+  if (!this->string_array.empty()) {
+    for (const auto &it : this->string_array) {
+      ProtoSize::add_string_field(total_size, 1, it, true);
+    }
+  }
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ExecuteServiceArgument::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -3488,6 +3908,10 @@ void ExecuteServiceRequest::encode(ProtoWriteBuffer buffer) const {
     buffer.encode_message<ExecuteServiceArgument>(2, it, true);
   }
 }
+void ExecuteServiceRequest::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_repeated_message(total_size, 1, this->args);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ExecuteServiceRequest::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -3560,6 +3984,15 @@ void ListEntitiesCameraResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(6, this->icon);
   buffer.encode_enum<enums::EntityCategory>(7, this->entity_category);
 }
+void ListEntitiesCameraResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_string_field(total_size, 1, this->object_id, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_string_field(total_size, 1, this->name, false);
+  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
+  ProtoSize::add_bool_field(total_size, 1, this->disabled_by_default, false);
+  ProtoSize::add_string_field(total_size, 1, this->icon, false);
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->entity_category), false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ListEntitiesCameraResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -3630,6 +4063,11 @@ void CameraImageResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(2, this->data);
   buffer.encode_bool(3, this->done);
 }
+void CameraImageResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_string_field(total_size, 1, this->data, false);
+  ProtoSize::add_bool_field(total_size, 1, this->done, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void CameraImageResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -3667,6 +4105,10 @@ void CameraImageRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_bool(1, this->single);
   buffer.encode_bool(2, this->stream);
 }
+void CameraImageRequest::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_bool_field(total_size, 1, this->single, false);
+  ProtoSize::add_bool_field(total_size, 1, this->stream, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void CameraImageRequest::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -3838,6 +4280,57 @@ void ListEntitiesClimateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_float(24, this->visual_min_humidity);
   buffer.encode_float(25, this->visual_max_humidity);
 }
+void ListEntitiesClimateResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_string_field(total_size, 1, this->object_id, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_string_field(total_size, 1, this->name, false);
+  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
+  ProtoSize::add_bool_field(total_size, 1, this->supports_current_temperature, false);
+  ProtoSize::add_bool_field(total_size, 1, this->supports_two_point_target_temperature, false);
+  if (!this->supported_modes.empty()) {
+    for (const auto &it : this->supported_modes) {
+      ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(it), true);
+    }
+  }
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->visual_min_temperature != 0.0f, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->visual_max_temperature != 0.0f, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->visual_target_temperature_step != 0.0f, false);
+  ProtoSize::add_bool_field(total_size, 1, this->legacy_supports_away, false);
+  ProtoSize::add_bool_field(total_size, 1, this->supports_action, false);
+  if (!this->supported_fan_modes.empty()) {
+    for (const auto &it : this->supported_fan_modes) {
+      ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(it), true);
+    }
+  }
+  if (!this->supported_swing_modes.empty()) {
+    for (const auto &it : this->supported_swing_modes) {
+      ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(it), true);
+    }
+  }
+  if (!this->supported_custom_fan_modes.empty()) {
+    for (const auto &it : this->supported_custom_fan_modes) {
+      ProtoSize::add_string_field(total_size, 1, it, true);
+    }
+  }
+  if (!this->supported_presets.empty()) {
+    for (const auto &it : this->supported_presets) {
+      ProtoSize::add_enum_field(total_size, 2, static_cast<uint32_t>(it), true);
+    }
+  }
+  if (!this->supported_custom_presets.empty()) {
+    for (const auto &it : this->supported_custom_presets) {
+      ProtoSize::add_string_field(total_size, 2, it, true);
+    }
+  }
+  ProtoSize::add_bool_field(total_size, 2, this->disabled_by_default, false);
+  ProtoSize::add_string_field(total_size, 2, this->icon, false);
+  ProtoSize::add_enum_field(total_size, 2, static_cast<uint32_t>(this->entity_category), false);
+  ProtoSize::add_fixed_field<4>(total_size, 2, this->visual_current_temperature_step != 0.0f, false);
+  ProtoSize::add_bool_field(total_size, 2, this->supports_current_humidity, false);
+  ProtoSize::add_bool_field(total_size, 2, this->supports_target_humidity, false);
+  ProtoSize::add_fixed_field<4>(total_size, 2, this->visual_min_humidity != 0.0f, false);
+  ProtoSize::add_fixed_field<4>(total_size, 2, this->visual_max_humidity != 0.0f, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ListEntitiesClimateResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -4058,6 +4551,23 @@ void ClimateStateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_float(14, this->current_humidity);
   buffer.encode_float(15, this->target_humidity);
 }
+void ClimateStateResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->mode), false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->current_temperature != 0.0f, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->target_temperature != 0.0f, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->target_temperature_low != 0.0f, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->target_temperature_high != 0.0f, false);
+  ProtoSize::add_bool_field(total_size, 1, this->unused_legacy_away, false);
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->action), false);
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->fan_mode), false);
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->swing_mode), false);
+  ProtoSize::add_string_field(total_size, 1, this->custom_fan_mode, false);
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->preset), false);
+  ProtoSize::add_string_field(total_size, 1, this->custom_preset, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->current_humidity != 0.0f, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->target_humidity != 0.0f, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ClimateStateResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -4266,6 +4776,31 @@ void ClimateCommandRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_bool(22, this->has_target_humidity);
   buffer.encode_float(23, this->target_humidity);
 }
+void ClimateCommandRequest::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_bool_field(total_size, 1, this->has_mode, false);
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->mode), false);
+  ProtoSize::add_bool_field(total_size, 1, this->has_target_temperature, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->target_temperature != 0.0f, false);
+  ProtoSize::add_bool_field(total_size, 1, this->has_target_temperature_low, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->target_temperature_low != 0.0f, false);
+  ProtoSize::add_bool_field(total_size, 1, this->has_target_temperature_high, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->target_temperature_high != 0.0f, false);
+  ProtoSize::add_bool_field(total_size, 1, this->unused_has_legacy_away, false);
+  ProtoSize::add_bool_field(total_size, 1, this->unused_legacy_away, false);
+  ProtoSize::add_bool_field(total_size, 1, this->has_fan_mode, false);
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->fan_mode), false);
+  ProtoSize::add_bool_field(total_size, 1, this->has_swing_mode, false);
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->swing_mode), false);
+  ProtoSize::add_bool_field(total_size, 2, this->has_custom_fan_mode, false);
+  ProtoSize::add_string_field(total_size, 2, this->custom_fan_mode, false);
+  ProtoSize::add_bool_field(total_size, 2, this->has_preset, false);
+  ProtoSize::add_enum_field(total_size, 2, static_cast<uint32_t>(this->preset), false);
+  ProtoSize::add_bool_field(total_size, 2, this->has_custom_preset, false);
+  ProtoSize::add_string_field(total_size, 2, this->custom_preset, false);
+  ProtoSize::add_bool_field(total_size, 2, this->has_target_humidity, false);
+  ProtoSize::add_fixed_field<4>(total_size, 2, this->target_humidity != 0.0f, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ClimateCommandRequest::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -4454,6 +4989,21 @@ void ListEntitiesNumberResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_enum<enums::NumberMode>(12, this->mode);
   buffer.encode_string(13, this->device_class);
 }
+void ListEntitiesNumberResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_string_field(total_size, 1, this->object_id, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_string_field(total_size, 1, this->name, false);
+  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
+  ProtoSize::add_string_field(total_size, 1, this->icon, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->min_value != 0.0f, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->max_value != 0.0f, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->step != 0.0f, false);
+  ProtoSize::add_bool_field(total_size, 1, this->disabled_by_default, false);
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->entity_category), false);
+  ProtoSize::add_string_field(total_size, 1, this->unit_of_measurement, false);
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->mode), false);
+  ProtoSize::add_string_field(total_size, 1, this->device_class, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ListEntitiesNumberResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -4545,6 +5095,11 @@ void NumberStateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_float(2, this->state);
   buffer.encode_bool(3, this->missing_state);
 }
+void NumberStateResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->state != 0.0f, false);
+  ProtoSize::add_bool_field(total_size, 1, this->missing_state, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void NumberStateResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -4583,6 +5138,10 @@ void NumberCommandRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_fixed32(1, this->key);
   buffer.encode_float(2, this->state);
 }
+void NumberCommandRequest::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->state != 0.0f, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void NumberCommandRequest::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -4661,6 +5220,20 @@ void ListEntitiesSelectResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_bool(7, this->disabled_by_default);
   buffer.encode_enum<enums::EntityCategory>(8, this->entity_category);
 }
+void ListEntitiesSelectResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_string_field(total_size, 1, this->object_id, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_string_field(total_size, 1, this->name, false);
+  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
+  ProtoSize::add_string_field(total_size, 1, this->icon, false);
+  if (!this->options.empty()) {
+    for (const auto &it : this->options) {
+      ProtoSize::add_string_field(total_size, 1, it, true);
+    }
+  }
+  ProtoSize::add_bool_field(total_size, 1, this->disabled_by_default, false);
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->entity_category), false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ListEntitiesSelectResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -4737,6 +5310,11 @@ void SelectStateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(2, this->state);
   buffer.encode_bool(3, this->missing_state);
 }
+void SelectStateResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_string_field(total_size, 1, this->state, false);
+  ProtoSize::add_bool_field(total_size, 1, this->missing_state, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void SelectStateResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -4780,6 +5358,10 @@ void SelectCommandRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_fixed32(1, this->key);
   buffer.encode_string(2, this->state);
 }
+void SelectCommandRequest::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_string_field(total_size, 1, this->state, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void SelectCommandRequest::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -4795,6 +5377,307 @@ void SelectCommandRequest::dump_to(std::string &out) const {
   out.append("}");
 }
 #endif
+bool ListEntitiesSirenResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
+  switch (field_id) {
+    case 6: {
+      this->disabled_by_default = value.as_bool();
+      return true;
+    }
+    case 8: {
+      this->supports_duration = value.as_bool();
+      return true;
+    }
+    case 9: {
+      this->supports_volume = value.as_bool();
+      return true;
+    }
+    case 10: {
+      this->entity_category = value.as_enum<enums::EntityCategory>();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+bool ListEntitiesSirenResponse::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
+  switch (field_id) {
+    case 1: {
+      this->object_id = value.as_string();
+      return true;
+    }
+    case 3: {
+      this->name = value.as_string();
+      return true;
+    }
+    case 4: {
+      this->unique_id = value.as_string();
+      return true;
+    }
+    case 5: {
+      this->icon = value.as_string();
+      return true;
+    }
+    case 7: {
+      this->tones.push_back(value.as_string());
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+bool ListEntitiesSirenResponse::decode_32bit(uint32_t field_id, Proto32Bit value) {
+  switch (field_id) {
+    case 2: {
+      this->key = value.as_fixed32();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+void ListEntitiesSirenResponse::encode(ProtoWriteBuffer buffer) const {
+  buffer.encode_string(1, this->object_id);
+  buffer.encode_fixed32(2, this->key);
+  buffer.encode_string(3, this->name);
+  buffer.encode_string(4, this->unique_id);
+  buffer.encode_string(5, this->icon);
+  buffer.encode_bool(6, this->disabled_by_default);
+  for (auto &it : this->tones) {
+    buffer.encode_string(7, it, true);
+  }
+  buffer.encode_bool(8, this->supports_duration);
+  buffer.encode_bool(9, this->supports_volume);
+  buffer.encode_enum<enums::EntityCategory>(10, this->entity_category);
+}
+void ListEntitiesSirenResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_string_field(total_size, 1, this->object_id, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_string_field(total_size, 1, this->name, false);
+  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
+  ProtoSize::add_string_field(total_size, 1, this->icon, false);
+  ProtoSize::add_bool_field(total_size, 1, this->disabled_by_default, false);
+  if (!this->tones.empty()) {
+    for (const auto &it : this->tones) {
+      ProtoSize::add_string_field(total_size, 1, it, true);
+    }
+  }
+  ProtoSize::add_bool_field(total_size, 1, this->supports_duration, false);
+  ProtoSize::add_bool_field(total_size, 1, this->supports_volume, false);
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->entity_category), false);
+}
+#ifdef HAS_PROTO_MESSAGE_DUMP
+void ListEntitiesSirenResponse::dump_to(std::string &out) const {
+  __attribute__((unused)) char buffer[64];
+  out.append("ListEntitiesSirenResponse {\n");
+  out.append("  object_id: ");
+  out.append("'").append(this->object_id).append("'");
+  out.append("\n");
+
+  out.append("  key: ");
+  sprintf(buffer, "%" PRIu32, this->key);
+  out.append(buffer);
+  out.append("\n");
+
+  out.append("  name: ");
+  out.append("'").append(this->name).append("'");
+  out.append("\n");
+
+  out.append("  unique_id: ");
+  out.append("'").append(this->unique_id).append("'");
+  out.append("\n");
+
+  out.append("  icon: ");
+  out.append("'").append(this->icon).append("'");
+  out.append("\n");
+
+  out.append("  disabled_by_default: ");
+  out.append(YESNO(this->disabled_by_default));
+  out.append("\n");
+
+  for (const auto &it : this->tones) {
+    out.append("  tones: ");
+    out.append("'").append(it).append("'");
+    out.append("\n");
+  }
+
+  out.append("  supports_duration: ");
+  out.append(YESNO(this->supports_duration));
+  out.append("\n");
+
+  out.append("  supports_volume: ");
+  out.append(YESNO(this->supports_volume));
+  out.append("\n");
+
+  out.append("  entity_category: ");
+  out.append(proto_enum_to_string<enums::EntityCategory>(this->entity_category));
+  out.append("\n");
+  out.append("}");
+}
+#endif
+bool SirenStateResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
+  switch (field_id) {
+    case 2: {
+      this->state = value.as_bool();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+bool SirenStateResponse::decode_32bit(uint32_t field_id, Proto32Bit value) {
+  switch (field_id) {
+    case 1: {
+      this->key = value.as_fixed32();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+void SirenStateResponse::encode(ProtoWriteBuffer buffer) const {
+  buffer.encode_fixed32(1, this->key);
+  buffer.encode_bool(2, this->state);
+}
+void SirenStateResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_bool_field(total_size, 1, this->state, false);
+}
+#ifdef HAS_PROTO_MESSAGE_DUMP
+void SirenStateResponse::dump_to(std::string &out) const {
+  __attribute__((unused)) char buffer[64];
+  out.append("SirenStateResponse {\n");
+  out.append("  key: ");
+  sprintf(buffer, "%" PRIu32, this->key);
+  out.append(buffer);
+  out.append("\n");
+
+  out.append("  state: ");
+  out.append(YESNO(this->state));
+  out.append("\n");
+  out.append("}");
+}
+#endif
+bool SirenCommandRequest::decode_varint(uint32_t field_id, ProtoVarInt value) {
+  switch (field_id) {
+    case 2: {
+      this->has_state = value.as_bool();
+      return true;
+    }
+    case 3: {
+      this->state = value.as_bool();
+      return true;
+    }
+    case 4: {
+      this->has_tone = value.as_bool();
+      return true;
+    }
+    case 6: {
+      this->has_duration = value.as_bool();
+      return true;
+    }
+    case 7: {
+      this->duration = value.as_uint32();
+      return true;
+    }
+    case 8: {
+      this->has_volume = value.as_bool();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+bool SirenCommandRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
+  switch (field_id) {
+    case 5: {
+      this->tone = value.as_string();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+bool SirenCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
+  switch (field_id) {
+    case 1: {
+      this->key = value.as_fixed32();
+      return true;
+    }
+    case 9: {
+      this->volume = value.as_float();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+void SirenCommandRequest::encode(ProtoWriteBuffer buffer) const {
+  buffer.encode_fixed32(1, this->key);
+  buffer.encode_bool(2, this->has_state);
+  buffer.encode_bool(3, this->state);
+  buffer.encode_bool(4, this->has_tone);
+  buffer.encode_string(5, this->tone);
+  buffer.encode_bool(6, this->has_duration);
+  buffer.encode_uint32(7, this->duration);
+  buffer.encode_bool(8, this->has_volume);
+  buffer.encode_float(9, this->volume);
+}
+void SirenCommandRequest::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_bool_field(total_size, 1, this->has_state, false);
+  ProtoSize::add_bool_field(total_size, 1, this->state, false);
+  ProtoSize::add_bool_field(total_size, 1, this->has_tone, false);
+  ProtoSize::add_string_field(total_size, 1, this->tone, false);
+  ProtoSize::add_bool_field(total_size, 1, this->has_duration, false);
+  ProtoSize::add_uint32_field(total_size, 1, this->duration, false);
+  ProtoSize::add_bool_field(total_size, 1, this->has_volume, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->volume != 0.0f, false);
+}
+#ifdef HAS_PROTO_MESSAGE_DUMP
+void SirenCommandRequest::dump_to(std::string &out) const {
+  __attribute__((unused)) char buffer[64];
+  out.append("SirenCommandRequest {\n");
+  out.append("  key: ");
+  sprintf(buffer, "%" PRIu32, this->key);
+  out.append(buffer);
+  out.append("\n");
+
+  out.append("  has_state: ");
+  out.append(YESNO(this->has_state));
+  out.append("\n");
+
+  out.append("  state: ");
+  out.append(YESNO(this->state));
+  out.append("\n");
+
+  out.append("  has_tone: ");
+  out.append(YESNO(this->has_tone));
+  out.append("\n");
+
+  out.append("  tone: ");
+  out.append("'").append(this->tone).append("'");
+  out.append("\n");
+
+  out.append("  has_duration: ");
+  out.append(YESNO(this->has_duration));
+  out.append("\n");
+
+  out.append("  duration: ");
+  sprintf(buffer, "%" PRIu32, this->duration);
+  out.append(buffer);
+  out.append("\n");
+
+  out.append("  has_volume: ");
+  out.append(YESNO(this->has_volume));
+  out.append("\n");
+
+  out.append("  volume: ");
+  sprintf(buffer, "%g", this->volume);
+  out.append(buffer);
+  out.append("\n");
+  out.append("}");
+}
+#endif
 bool ListEntitiesLockResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
   switch (field_id) {
     case 6: {
@@ -4870,6 +5753,19 @@ void ListEntitiesLockResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_bool(10, this->requires_code);
   buffer.encode_string(11, this->code_format);
 }
+void ListEntitiesLockResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_string_field(total_size, 1, this->object_id, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_string_field(total_size, 1, this->name, false);
+  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
+  ProtoSize::add_string_field(total_size, 1, this->icon, false);
+  ProtoSize::add_bool_field(total_size, 1, this->disabled_by_default, false);
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->entity_category), false);
+  ProtoSize::add_bool_field(total_size, 1, this->assumed_state, false);
+  ProtoSize::add_bool_field(total_size, 1, this->supports_open, false);
+  ProtoSize::add_bool_field(total_size, 1, this->requires_code, false);
+  ProtoSize::add_string_field(total_size, 1, this->code_format, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ListEntitiesLockResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -4945,6 +5841,10 @@ void LockStateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_fixed32(1, this->key);
   buffer.encode_enum<enums::LockState>(2, this->state);
 }
+void LockStateResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->state), false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void LockStateResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -5000,6 +5900,12 @@ void LockCommandRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_bool(3, this->has_code);
   buffer.encode_string(4, this->code);
 }
+void LockCommandRequest::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->command), false);
+  ProtoSize::add_bool_field(total_size, 1, this->has_code, false);
+  ProtoSize::add_string_field(total_size, 1, this->code, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void LockCommandRequest::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -5083,6 +5989,16 @@ void ListEntitiesButtonResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_enum<enums::EntityCategory>(7, this->entity_category);
   buffer.encode_string(8, this->device_class);
 }
+void ListEntitiesButtonResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_string_field(total_size, 1, this->object_id, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_string_field(total_size, 1, this->name, false);
+  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
+  ProtoSize::add_string_field(total_size, 1, this->icon, false);
+  ProtoSize::add_bool_field(total_size, 1, this->disabled_by_default, false);
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->entity_category), false);
+  ProtoSize::add_string_field(total_size, 1, this->device_class, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ListEntitiesButtonResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -5133,6 +6049,9 @@ bool ButtonCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
   }
 }
 void ButtonCommandRequest::encode(ProtoWriteBuffer buffer) const { buffer.encode_fixed32(1, this->key); }
+void ButtonCommandRequest::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ButtonCommandRequest::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -5183,6 +6102,13 @@ void MediaPlayerSupportedFormat::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_enum<enums::MediaPlayerFormatPurpose>(4, this->purpose);
   buffer.encode_uint32(5, this->sample_bytes);
 }
+void MediaPlayerSupportedFormat::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_string_field(total_size, 1, this->format, false);
+  ProtoSize::add_uint32_field(total_size, 1, this->sample_rate, false);
+  ProtoSize::add_uint32_field(total_size, 1, this->num_channels, false);
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->purpose), false);
+  ProtoSize::add_uint32_field(total_size, 1, this->sample_bytes, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void MediaPlayerSupportedFormat::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -5279,6 +6205,17 @@ void ListEntitiesMediaPlayerResponse::encode(ProtoWriteBuffer buffer) const {
     buffer.encode_message<MediaPlayerSupportedFormat>(9, it, true);
   }
 }
+void ListEntitiesMediaPlayerResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_string_field(total_size, 1, this->object_id, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_string_field(total_size, 1, this->name, false);
+  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
+  ProtoSize::add_string_field(total_size, 1, this->icon, false);
+  ProtoSize::add_bool_field(total_size, 1, this->disabled_by_default, false);
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->entity_category), false);
+  ProtoSize::add_bool_field(total_size, 1, this->supports_pause, false);
+  ProtoSize::add_repeated_message(total_size, 1, this->supported_formats);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ListEntitiesMediaPlayerResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -5358,6 +6295,12 @@ void MediaPlayerStateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_float(3, this->volume);
   buffer.encode_bool(4, this->muted);
 }
+void MediaPlayerStateResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->state), false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->volume != 0.0f, false);
+  ProtoSize::add_bool_field(total_size, 1, this->muted, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void MediaPlayerStateResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -5447,6 +6390,17 @@ void MediaPlayerCommandRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_bool(8, this->has_announcement);
   buffer.encode_bool(9, this->announcement);
 }
+void MediaPlayerCommandRequest::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_bool_field(total_size, 1, this->has_command, false);
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->command), false);
+  ProtoSize::add_bool_field(total_size, 1, this->has_volume, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->volume != 0.0f, false);
+  ProtoSize::add_bool_field(total_size, 1, this->has_media_url, false);
+  ProtoSize::add_string_field(total_size, 1, this->media_url, false);
+  ProtoSize::add_bool_field(total_size, 1, this->has_announcement, false);
+  ProtoSize::add_bool_field(total_size, 1, this->announcement, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void MediaPlayerCommandRequest::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -5504,6 +6458,9 @@ bool SubscribeBluetoothLEAdvertisementsRequest::decode_varint(uint32_t field_id,
 void SubscribeBluetoothLEAdvertisementsRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_uint32(1, this->flags);
 }
+void SubscribeBluetoothLEAdvertisementsRequest::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_uint32_field(total_size, 1, this->flags, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void SubscribeBluetoothLEAdvertisementsRequest::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -5546,6 +6503,15 @@ void BluetoothServiceData::encode(ProtoWriteBuffer buffer) const {
   }
   buffer.encode_string(3, this->data);
 }
+void BluetoothServiceData::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_string_field(total_size, 1, this->uuid, false);
+  if (!this->legacy_data.empty()) {
+    for (const auto &it : this->legacy_data) {
+      ProtoSize::add_uint32_field(total_size, 1, it, true);
+    }
+  }
+  ProtoSize::add_string_field(total_size, 1, this->data, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void BluetoothServiceData::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -5622,6 +6588,19 @@ void BluetoothLEAdvertisementResponse::encode(ProtoWriteBuffer buffer) const {
   }
   buffer.encode_uint32(7, this->address_type);
 }
+void BluetoothLEAdvertisementResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_uint64_field(total_size, 1, this->address, false);
+  ProtoSize::add_string_field(total_size, 1, this->name, false);
+  ProtoSize::add_sint32_field(total_size, 1, this->rssi, false);
+  if (!this->service_uuids.empty()) {
+    for (const auto &it : this->service_uuids) {
+      ProtoSize::add_string_field(total_size, 1, it, true);
+    }
+  }
+  ProtoSize::add_repeated_message(total_size, 1, this->service_data);
+  ProtoSize::add_repeated_message(total_size, 1, this->manufacturer_data);
+  ProtoSize::add_uint32_field(total_size, 1, this->address_type, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void BluetoothLEAdvertisementResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -5699,6 +6678,12 @@ void BluetoothLERawAdvertisement::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_uint32(3, this->address_type);
   buffer.encode_string(4, this->data);
 }
+void BluetoothLERawAdvertisement::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_uint64_field(total_size, 1, this->address, false);
+  ProtoSize::add_sint32_field(total_size, 1, this->rssi, false);
+  ProtoSize::add_uint32_field(total_size, 1, this->address_type, false);
+  ProtoSize::add_string_field(total_size, 1, this->data, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void BluetoothLERawAdvertisement::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -5739,6 +6724,9 @@ void BluetoothLERawAdvertisementsResponse::encode(ProtoWriteBuffer buffer) const
     buffer.encode_message<BluetoothLERawAdvertisement>(1, it, true);
   }
 }
+void BluetoothLERawAdvertisementsResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_repeated_message(total_size, 1, this->advertisements);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void BluetoothLERawAdvertisementsResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -5779,6 +6767,12 @@ void BluetoothDeviceRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_bool(3, this->has_address_type);
   buffer.encode_uint32(4, this->address_type);
 }
+void BluetoothDeviceRequest::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_uint64_field(total_size, 1, this->address, false);
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->request_type), false);
+  ProtoSize::add_bool_field(total_size, 1, this->has_address_type, false);
+  ProtoSize::add_uint32_field(total_size, 1, this->address_type, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void BluetoothDeviceRequest::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -5831,6 +6825,12 @@ void BluetoothDeviceConnectionResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_uint32(3, this->mtu);
   buffer.encode_int32(4, this->error);
 }
+void BluetoothDeviceConnectionResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_uint64_field(total_size, 1, this->address, false);
+  ProtoSize::add_bool_field(total_size, 1, this->connected, false);
+  ProtoSize::add_uint32_field(total_size, 1, this->mtu, false);
+  ProtoSize::add_int32_field(total_size, 1, this->error, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void BluetoothDeviceConnectionResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -5867,6 +6867,9 @@ bool BluetoothGATTGetServicesRequest::decode_varint(uint32_t field_id, ProtoVarI
   }
 }
 void BluetoothGATTGetServicesRequest::encode(ProtoWriteBuffer buffer) const { buffer.encode_uint64(1, this->address); }
+void BluetoothGATTGetServicesRequest::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_uint64_field(total_size, 1, this->address, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void BluetoothGATTGetServicesRequest::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -5898,6 +6901,14 @@ void BluetoothGATTDescriptor::encode(ProtoWriteBuffer buffer) const {
   }
   buffer.encode_uint32(2, this->handle);
 }
+void BluetoothGATTDescriptor::calculate_size(uint32_t &total_size) const {
+  if (!this->uuid.empty()) {
+    for (const auto &it : this->uuid) {
+      ProtoSize::add_uint64_field(total_size, 1, it, true);
+    }
+  }
+  ProtoSize::add_uint32_field(total_size, 1, this->handle, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void BluetoothGATTDescriptor::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -5954,6 +6965,16 @@ void BluetoothGATTCharacteristic::encode(ProtoWriteBuffer buffer) const {
     buffer.encode_message<BluetoothGATTDescriptor>(4, it, true);
   }
 }
+void BluetoothGATTCharacteristic::calculate_size(uint32_t &total_size) const {
+  if (!this->uuid.empty()) {
+    for (const auto &it : this->uuid) {
+      ProtoSize::add_uint64_field(total_size, 1, it, true);
+    }
+  }
+  ProtoSize::add_uint32_field(total_size, 1, this->handle, false);
+  ProtoSize::add_uint32_field(total_size, 1, this->properties, false);
+  ProtoSize::add_repeated_message(total_size, 1, this->descriptors);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void BluetoothGATTCharacteristic::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -6016,6 +7037,15 @@ void BluetoothGATTService::encode(ProtoWriteBuffer buffer) const {
     buffer.encode_message<BluetoothGATTCharacteristic>(3, it, true);
   }
 }
+void BluetoothGATTService::calculate_size(uint32_t &total_size) const {
+  if (!this->uuid.empty()) {
+    for (const auto &it : this->uuid) {
+      ProtoSize::add_uint64_field(total_size, 1, it, true);
+    }
+  }
+  ProtoSize::add_uint32_field(total_size, 1, this->handle, false);
+  ProtoSize::add_repeated_message(total_size, 1, this->characteristics);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void BluetoothGATTService::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -6066,6 +7096,10 @@ void BluetoothGATTGetServicesResponse::encode(ProtoWriteBuffer buffer) const {
     buffer.encode_message<BluetoothGATTService>(2, it, true);
   }
 }
+void BluetoothGATTGetServicesResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_uint64_field(total_size, 1, this->address, false);
+  ProtoSize::add_repeated_message(total_size, 1, this->services);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void BluetoothGATTGetServicesResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -6096,6 +7130,9 @@ bool BluetoothGATTGetServicesDoneResponse::decode_varint(uint32_t field_id, Prot
 void BluetoothGATTGetServicesDoneResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_uint64(1, this->address);
 }
+void BluetoothGATTGetServicesDoneResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_uint64_field(total_size, 1, this->address, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void BluetoothGATTGetServicesDoneResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -6125,6 +7162,10 @@ void BluetoothGATTReadRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_uint64(1, this->address);
   buffer.encode_uint32(2, this->handle);
 }
+void BluetoothGATTReadRequest::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_uint64_field(total_size, 1, this->address, false);
+  ProtoSize::add_uint32_field(total_size, 1, this->handle, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void BluetoothGATTReadRequest::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -6170,6 +7211,11 @@ void BluetoothGATTReadResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_uint32(2, this->handle);
   buffer.encode_string(3, this->data);
 }
+void BluetoothGATTReadResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_uint64_field(total_size, 1, this->address, false);
+  ProtoSize::add_uint32_field(total_size, 1, this->handle, false);
+  ProtoSize::add_string_field(total_size, 1, this->data, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void BluetoothGATTReadResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -6224,6 +7270,12 @@ void BluetoothGATTWriteRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_bool(3, this->response);
   buffer.encode_string(4, this->data);
 }
+void BluetoothGATTWriteRequest::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_uint64_field(total_size, 1, this->address, false);
+  ProtoSize::add_uint32_field(total_size, 1, this->handle, false);
+  ProtoSize::add_bool_field(total_size, 1, this->response, false);
+  ProtoSize::add_string_field(total_size, 1, this->data, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void BluetoothGATTWriteRequest::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -6266,6 +7318,10 @@ void BluetoothGATTReadDescriptorRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_uint64(1, this->address);
   buffer.encode_uint32(2, this->handle);
 }
+void BluetoothGATTReadDescriptorRequest::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_uint64_field(total_size, 1, this->address, false);
+  ProtoSize::add_uint32_field(total_size, 1, this->handle, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void BluetoothGATTReadDescriptorRequest::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -6311,6 +7367,11 @@ void BluetoothGATTWriteDescriptorRequest::encode(ProtoWriteBuffer buffer) const
   buffer.encode_uint32(2, this->handle);
   buffer.encode_string(3, this->data);
 }
+void BluetoothGATTWriteDescriptorRequest::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_uint64_field(total_size, 1, this->address, false);
+  ProtoSize::add_uint32_field(total_size, 1, this->handle, false);
+  ProtoSize::add_string_field(total_size, 1, this->data, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void BluetoothGATTWriteDescriptorRequest::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -6354,6 +7415,11 @@ void BluetoothGATTNotifyRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_uint32(2, this->handle);
   buffer.encode_bool(3, this->enable);
 }
+void BluetoothGATTNotifyRequest::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_uint64_field(total_size, 1, this->address, false);
+  ProtoSize::add_uint32_field(total_size, 1, this->handle, false);
+  ProtoSize::add_bool_field(total_size, 1, this->enable, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void BluetoothGATTNotifyRequest::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -6403,6 +7469,11 @@ void BluetoothGATTNotifyDataResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_uint32(2, this->handle);
   buffer.encode_string(3, this->data);
 }
+void BluetoothGATTNotifyDataResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_uint64_field(total_size, 1, this->address, false);
+  ProtoSize::add_uint32_field(total_size, 1, this->handle, false);
+  ProtoSize::add_string_field(total_size, 1, this->data, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void BluetoothGATTNotifyDataResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -6424,6 +7495,7 @@ void BluetoothGATTNotifyDataResponse::dump_to(std::string &out) const {
 }
 #endif
 void SubscribeBluetoothConnectionsFreeRequest::encode(ProtoWriteBuffer buffer) const {}
+void SubscribeBluetoothConnectionsFreeRequest::calculate_size(uint32_t &total_size) const {}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void SubscribeBluetoothConnectionsFreeRequest::dump_to(std::string &out) const {
   out.append("SubscribeBluetoothConnectionsFreeRequest {}");
@@ -6454,6 +7526,15 @@ void BluetoothConnectionsFreeResponse::encode(ProtoWriteBuffer buffer) const {
     buffer.encode_uint64(3, it, true);
   }
 }
+void BluetoothConnectionsFreeResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_uint32_field(total_size, 1, this->free, false);
+  ProtoSize::add_uint32_field(total_size, 1, this->limit, false);
+  if (!this->allocated.empty()) {
+    for (const auto &it : this->allocated) {
+      ProtoSize::add_uint64_field(total_size, 1, it, true);
+    }
+  }
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void BluetoothConnectionsFreeResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -6500,6 +7581,11 @@ void BluetoothGATTErrorResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_uint32(2, this->handle);
   buffer.encode_int32(3, this->error);
 }
+void BluetoothGATTErrorResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_uint64_field(total_size, 1, this->address, false);
+  ProtoSize::add_uint32_field(total_size, 1, this->handle, false);
+  ProtoSize::add_int32_field(total_size, 1, this->error, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void BluetoothGATTErrorResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -6539,6 +7625,10 @@ void BluetoothGATTWriteResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_uint64(1, this->address);
   buffer.encode_uint32(2, this->handle);
 }
+void BluetoothGATTWriteResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_uint64_field(total_size, 1, this->address, false);
+  ProtoSize::add_uint32_field(total_size, 1, this->handle, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void BluetoothGATTWriteResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -6573,6 +7663,10 @@ void BluetoothGATTNotifyResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_uint64(1, this->address);
   buffer.encode_uint32(2, this->handle);
 }
+void BluetoothGATTNotifyResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_uint64_field(total_size, 1, this->address, false);
+  ProtoSize::add_uint32_field(total_size, 1, this->handle, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void BluetoothGATTNotifyResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -6612,6 +7706,11 @@ void BluetoothDevicePairingResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_bool(2, this->paired);
   buffer.encode_int32(3, this->error);
 }
+void BluetoothDevicePairingResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_uint64_field(total_size, 1, this->address, false);
+  ProtoSize::add_bool_field(total_size, 1, this->paired, false);
+  ProtoSize::add_int32_field(total_size, 1, this->error, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void BluetoothDevicePairingResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -6655,6 +7754,11 @@ void BluetoothDeviceUnpairingResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_bool(2, this->success);
   buffer.encode_int32(3, this->error);
 }
+void BluetoothDeviceUnpairingResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_uint64_field(total_size, 1, this->address, false);
+  ProtoSize::add_bool_field(total_size, 1, this->success, false);
+  ProtoSize::add_int32_field(total_size, 1, this->error, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void BluetoothDeviceUnpairingResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -6676,6 +7780,7 @@ void BluetoothDeviceUnpairingResponse::dump_to(std::string &out) const {
 }
 #endif
 void UnsubscribeBluetoothLEAdvertisementsRequest::encode(ProtoWriteBuffer buffer) const {}
+void UnsubscribeBluetoothLEAdvertisementsRequest::calculate_size(uint32_t &total_size) const {}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void UnsubscribeBluetoothLEAdvertisementsRequest::dump_to(std::string &out) const {
   out.append("UnsubscribeBluetoothLEAdvertisementsRequest {}");
@@ -6704,6 +7809,11 @@ void BluetoothDeviceClearCacheResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_bool(2, this->success);
   buffer.encode_int32(3, this->error);
 }
+void BluetoothDeviceClearCacheResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_uint64_field(total_size, 1, this->address, false);
+  ProtoSize::add_bool_field(total_size, 1, this->success, false);
+  ProtoSize::add_int32_field(total_size, 1, this->error, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void BluetoothDeviceClearCacheResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -6724,6 +7834,68 @@ void BluetoothDeviceClearCacheResponse::dump_to(std::string &out) const {
   out.append("}");
 }
 #endif
+bool BluetoothScannerStateResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
+  switch (field_id) {
+    case 1: {
+      this->state = value.as_enum<enums::BluetoothScannerState>();
+      return true;
+    }
+    case 2: {
+      this->mode = value.as_enum<enums::BluetoothScannerMode>();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+void BluetoothScannerStateResponse::encode(ProtoWriteBuffer buffer) const {
+  buffer.encode_enum<enums::BluetoothScannerState>(1, this->state);
+  buffer.encode_enum<enums::BluetoothScannerMode>(2, this->mode);
+}
+void BluetoothScannerStateResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->state), false);
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->mode), false);
+}
+#ifdef HAS_PROTO_MESSAGE_DUMP
+void BluetoothScannerStateResponse::dump_to(std::string &out) const {
+  __attribute__((unused)) char buffer[64];
+  out.append("BluetoothScannerStateResponse {\n");
+  out.append("  state: ");
+  out.append(proto_enum_to_string<enums::BluetoothScannerState>(this->state));
+  out.append("\n");
+
+  out.append("  mode: ");
+  out.append(proto_enum_to_string<enums::BluetoothScannerMode>(this->mode));
+  out.append("\n");
+  out.append("}");
+}
+#endif
+bool BluetoothScannerSetModeRequest::decode_varint(uint32_t field_id, ProtoVarInt value) {
+  switch (field_id) {
+    case 1: {
+      this->mode = value.as_enum<enums::BluetoothScannerMode>();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+void BluetoothScannerSetModeRequest::encode(ProtoWriteBuffer buffer) const {
+  buffer.encode_enum<enums::BluetoothScannerMode>(1, this->mode);
+}
+void BluetoothScannerSetModeRequest::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->mode), false);
+}
+#ifdef HAS_PROTO_MESSAGE_DUMP
+void BluetoothScannerSetModeRequest::dump_to(std::string &out) const {
+  __attribute__((unused)) char buffer[64];
+  out.append("BluetoothScannerSetModeRequest {\n");
+  out.append("  mode: ");
+  out.append(proto_enum_to_string<enums::BluetoothScannerMode>(this->mode));
+  out.append("\n");
+  out.append("}");
+}
+#endif
 bool SubscribeVoiceAssistantRequest::decode_varint(uint32_t field_id, ProtoVarInt value) {
   switch (field_id) {
     case 1: {
@@ -6742,6 +7914,10 @@ void SubscribeVoiceAssistantRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_bool(1, this->subscribe);
   buffer.encode_uint32(2, this->flags);
 }
+void SubscribeVoiceAssistantRequest::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_bool_field(total_size, 1, this->subscribe, false);
+  ProtoSize::add_uint32_field(total_size, 1, this->flags, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void SubscribeVoiceAssistantRequest::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -6786,6 +7962,11 @@ void VoiceAssistantAudioSettings::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_uint32(2, this->auto_gain);
   buffer.encode_float(3, this->volume_multiplier);
 }
+void VoiceAssistantAudioSettings::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_uint32_field(total_size, 1, this->noise_suppression_level, false);
+  ProtoSize::add_uint32_field(total_size, 1, this->auto_gain, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->volume_multiplier != 0.0f, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void VoiceAssistantAudioSettings::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -6846,6 +8027,13 @@ void VoiceAssistantRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_message<VoiceAssistantAudioSettings>(4, this->audio_settings);
   buffer.encode_string(5, this->wake_word_phrase);
 }
+void VoiceAssistantRequest::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_bool_field(total_size, 1, this->start, false);
+  ProtoSize::add_string_field(total_size, 1, this->conversation_id, false);
+  ProtoSize::add_uint32_field(total_size, 1, this->flags, false);
+  ProtoSize::add_message_object(total_size, 1, this->audio_settings, false);
+  ProtoSize::add_string_field(total_size, 1, this->wake_word_phrase, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void VoiceAssistantRequest::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -6891,6 +8079,10 @@ void VoiceAssistantResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_uint32(1, this->port);
   buffer.encode_bool(2, this->error);
 }
+void VoiceAssistantResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_uint32_field(total_size, 1, this->port, false);
+  ProtoSize::add_bool_field(total_size, 1, this->error, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void VoiceAssistantResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -6924,6 +8116,10 @@ void VoiceAssistantEventData::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->name);
   buffer.encode_string(2, this->value);
 }
+void VoiceAssistantEventData::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_string_field(total_size, 1, this->name, false);
+  ProtoSize::add_string_field(total_size, 1, this->value, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void VoiceAssistantEventData::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -6964,6 +8160,10 @@ void VoiceAssistantEventResponse::encode(ProtoWriteBuffer buffer) const {
     buffer.encode_message<VoiceAssistantEventData>(2, it, true);
   }
 }
+void VoiceAssistantEventResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->event_type), false);
+  ProtoSize::add_repeated_message(total_size, 1, this->data);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void VoiceAssistantEventResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -7004,6 +8204,10 @@ void VoiceAssistantAudio::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->data);
   buffer.encode_bool(2, this->end);
 }
+void VoiceAssistantAudio::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_string_field(total_size, 1, this->data, false);
+  ProtoSize::add_bool_field(total_size, 1, this->end, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void VoiceAssistantAudio::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -7062,6 +8266,14 @@ void VoiceAssistantTimerEventResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_uint32(5, this->seconds_left);
   buffer.encode_bool(6, this->is_active);
 }
+void VoiceAssistantTimerEventResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->event_type), false);
+  ProtoSize::add_string_field(total_size, 1, this->timer_id, false);
+  ProtoSize::add_string_field(total_size, 1, this->name, false);
+  ProtoSize::add_uint32_field(total_size, 1, this->total_seconds, false);
+  ProtoSize::add_uint32_field(total_size, 1, this->seconds_left, false);
+  ProtoSize::add_bool_field(total_size, 1, this->is_active, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void VoiceAssistantTimerEventResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -7128,6 +8340,12 @@ void VoiceAssistantAnnounceRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(3, this->preannounce_media_id);
   buffer.encode_bool(4, this->start_conversation);
 }
+void VoiceAssistantAnnounceRequest::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_string_field(total_size, 1, this->media_id, false);
+  ProtoSize::add_string_field(total_size, 1, this->text, false);
+  ProtoSize::add_string_field(total_size, 1, this->preannounce_media_id, false);
+  ProtoSize::add_bool_field(total_size, 1, this->start_conversation, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void VoiceAssistantAnnounceRequest::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -7161,6 +8379,9 @@ bool VoiceAssistantAnnounceFinished::decode_varint(uint32_t field_id, ProtoVarIn
   }
 }
 void VoiceAssistantAnnounceFinished::encode(ProtoWriteBuffer buffer) const { buffer.encode_bool(1, this->success); }
+void VoiceAssistantAnnounceFinished::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_bool_field(total_size, 1, this->success, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void VoiceAssistantAnnounceFinished::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -7196,6 +8417,15 @@ void VoiceAssistantWakeWord::encode(ProtoWriteBuffer buffer) const {
     buffer.encode_string(3, it, true);
   }
 }
+void VoiceAssistantWakeWord::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_string_field(total_size, 1, this->id, false);
+  ProtoSize::add_string_field(total_size, 1, this->wake_word, false);
+  if (!this->trained_languages.empty()) {
+    for (const auto &it : this->trained_languages) {
+      ProtoSize::add_string_field(total_size, 1, it, true);
+    }
+  }
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void VoiceAssistantWakeWord::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -7217,6 +8447,7 @@ void VoiceAssistantWakeWord::dump_to(std::string &out) const {
 }
 #endif
 void VoiceAssistantConfigurationRequest::encode(ProtoWriteBuffer buffer) const {}
+void VoiceAssistantConfigurationRequest::calculate_size(uint32_t &total_size) const {}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void VoiceAssistantConfigurationRequest::dump_to(std::string &out) const {
   out.append("VoiceAssistantConfigurationRequest {}");
@@ -7255,6 +8486,15 @@ void VoiceAssistantConfigurationResponse::encode(ProtoWriteBuffer buffer) const
   }
   buffer.encode_uint32(3, this->max_active_wake_words);
 }
+void VoiceAssistantConfigurationResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_repeated_message(total_size, 1, this->available_wake_words);
+  if (!this->active_wake_words.empty()) {
+    for (const auto &it : this->active_wake_words) {
+      ProtoSize::add_string_field(total_size, 1, it, true);
+    }
+  }
+  ProtoSize::add_uint32_field(total_size, 1, this->max_active_wake_words, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void VoiceAssistantConfigurationResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -7293,6 +8533,13 @@ void VoiceAssistantSetConfiguration::encode(ProtoWriteBuffer buffer) const {
     buffer.encode_string(1, it, true);
   }
 }
+void VoiceAssistantSetConfiguration::calculate_size(uint32_t &total_size) const {
+  if (!this->active_wake_words.empty()) {
+    for (const auto &it : this->active_wake_words) {
+      ProtoSize::add_string_field(total_size, 1, it, true);
+    }
+  }
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void VoiceAssistantSetConfiguration::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -7375,6 +8622,18 @@ void ListEntitiesAlarmControlPanelResponse::encode(ProtoWriteBuffer buffer) cons
   buffer.encode_bool(9, this->requires_code);
   buffer.encode_bool(10, this->requires_code_to_arm);
 }
+void ListEntitiesAlarmControlPanelResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_string_field(total_size, 1, this->object_id, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_string_field(total_size, 1, this->name, false);
+  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
+  ProtoSize::add_string_field(total_size, 1, this->icon, false);
+  ProtoSize::add_bool_field(total_size, 1, this->disabled_by_default, false);
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->entity_category), false);
+  ProtoSize::add_uint32_field(total_size, 1, this->supported_features, false);
+  ProtoSize::add_bool_field(total_size, 1, this->requires_code, false);
+  ProtoSize::add_bool_field(total_size, 1, this->requires_code_to_arm, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ListEntitiesAlarmControlPanelResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -7447,6 +8706,10 @@ void AlarmControlPanelStateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_fixed32(1, this->key);
   buffer.encode_enum<enums::AlarmControlPanelState>(2, this->state);
 }
+void AlarmControlPanelStateResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->state), false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void AlarmControlPanelStateResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -7497,6 +8760,11 @@ void AlarmControlPanelCommandRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_enum<enums::AlarmControlPanelStateCommand>(2, this->command);
   buffer.encode_string(3, this->code);
 }
+void AlarmControlPanelCommandRequest::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->command), false);
+  ProtoSize::add_string_field(total_size, 1, this->code, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void AlarmControlPanelCommandRequest::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -7591,6 +8859,19 @@ void ListEntitiesTextResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(10, this->pattern);
   buffer.encode_enum<enums::TextMode>(11, this->mode);
 }
+void ListEntitiesTextResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_string_field(total_size, 1, this->object_id, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_string_field(total_size, 1, this->name, false);
+  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
+  ProtoSize::add_string_field(total_size, 1, this->icon, false);
+  ProtoSize::add_bool_field(total_size, 1, this->disabled_by_default, false);
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->entity_category), false);
+  ProtoSize::add_uint32_field(total_size, 1, this->min_length, false);
+  ProtoSize::add_uint32_field(total_size, 1, this->max_length, false);
+  ProtoSize::add_string_field(total_size, 1, this->pattern, false);
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->mode), false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ListEntitiesTextResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -7679,6 +8960,11 @@ void TextStateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(2, this->state);
   buffer.encode_bool(3, this->missing_state);
 }
+void TextStateResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_string_field(total_size, 1, this->state, false);
+  ProtoSize::add_bool_field(total_size, 1, this->missing_state, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void TextStateResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -7722,6 +9008,10 @@ void TextCommandRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_fixed32(1, this->key);
   buffer.encode_string(2, this->state);
 }
+void TextCommandRequest::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_string_field(total_size, 1, this->state, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void TextCommandRequest::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -7792,6 +9082,15 @@ void ListEntitiesDateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_bool(6, this->disabled_by_default);
   buffer.encode_enum<enums::EntityCategory>(7, this->entity_category);
 }
+void ListEntitiesDateResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_string_field(total_size, 1, this->object_id, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_string_field(total_size, 1, this->name, false);
+  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
+  ProtoSize::add_string_field(total_size, 1, this->icon, false);
+  ProtoSize::add_bool_field(total_size, 1, this->disabled_by_default, false);
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->entity_category), false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ListEntitiesDateResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -7866,6 +9165,13 @@ void DateStateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_uint32(4, this->month);
   buffer.encode_uint32(5, this->day);
 }
+void DateStateResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_bool_field(total_size, 1, this->missing_state, false);
+  ProtoSize::add_uint32_field(total_size, 1, this->year, false);
+  ProtoSize::add_uint32_field(total_size, 1, this->month, false);
+  ProtoSize::add_uint32_field(total_size, 1, this->day, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void DateStateResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -7930,6 +9236,12 @@ void DateCommandRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_uint32(3, this->month);
   buffer.encode_uint32(4, this->day);
 }
+void DateCommandRequest::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_uint32_field(total_size, 1, this->year, false);
+  ProtoSize::add_uint32_field(total_size, 1, this->month, false);
+  ProtoSize::add_uint32_field(total_size, 1, this->day, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void DateCommandRequest::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -8011,6 +9323,15 @@ void ListEntitiesTimeResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_bool(6, this->disabled_by_default);
   buffer.encode_enum<enums::EntityCategory>(7, this->entity_category);
 }
+void ListEntitiesTimeResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_string_field(total_size, 1, this->object_id, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_string_field(total_size, 1, this->name, false);
+  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
+  ProtoSize::add_string_field(total_size, 1, this->icon, false);
+  ProtoSize::add_bool_field(total_size, 1, this->disabled_by_default, false);
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->entity_category), false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ListEntitiesTimeResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -8085,6 +9406,13 @@ void TimeStateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_uint32(4, this->minute);
   buffer.encode_uint32(5, this->second);
 }
+void TimeStateResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_bool_field(total_size, 1, this->missing_state, false);
+  ProtoSize::add_uint32_field(total_size, 1, this->hour, false);
+  ProtoSize::add_uint32_field(total_size, 1, this->minute, false);
+  ProtoSize::add_uint32_field(total_size, 1, this->second, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void TimeStateResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -8149,6 +9477,12 @@ void TimeCommandRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_uint32(3, this->minute);
   buffer.encode_uint32(4, this->second);
 }
+void TimeCommandRequest::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_uint32_field(total_size, 1, this->hour, false);
+  ProtoSize::add_uint32_field(total_size, 1, this->minute, false);
+  ProtoSize::add_uint32_field(total_size, 1, this->second, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void TimeCommandRequest::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -8242,6 +9576,21 @@ void ListEntitiesEventResponse::encode(ProtoWriteBuffer buffer) const {
     buffer.encode_string(9, it, true);
   }
 }
+void ListEntitiesEventResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_string_field(total_size, 1, this->object_id, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_string_field(total_size, 1, this->name, false);
+  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
+  ProtoSize::add_string_field(total_size, 1, this->icon, false);
+  ProtoSize::add_bool_field(total_size, 1, this->disabled_by_default, false);
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->entity_category), false);
+  ProtoSize::add_string_field(total_size, 1, this->device_class, false);
+  if (!this->event_types.empty()) {
+    for (const auto &it : this->event_types) {
+      ProtoSize::add_string_field(total_size, 1, it, true);
+    }
+  }
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ListEntitiesEventResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -8311,6 +9660,10 @@ void EventResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_fixed32(1, this->key);
   buffer.encode_string(2, this->event_type);
 }
+void EventResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_string_field(total_size, 1, this->event_type, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void EventResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -8401,6 +9754,19 @@ void ListEntitiesValveResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_bool(10, this->supports_position);
   buffer.encode_bool(11, this->supports_stop);
 }
+void ListEntitiesValveResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_string_field(total_size, 1, this->object_id, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_string_field(total_size, 1, this->name, false);
+  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
+  ProtoSize::add_string_field(total_size, 1, this->icon, false);
+  ProtoSize::add_bool_field(total_size, 1, this->disabled_by_default, false);
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->entity_category), false);
+  ProtoSize::add_string_field(total_size, 1, this->device_class, false);
+  ProtoSize::add_bool_field(total_size, 1, this->assumed_state, false);
+  ProtoSize::add_bool_field(total_size, 1, this->supports_position, false);
+  ProtoSize::add_bool_field(total_size, 1, this->supports_stop, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ListEntitiesValveResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -8481,6 +9847,11 @@ void ValveStateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_float(2, this->position);
   buffer.encode_enum<enums::ValveOperation>(3, this->current_operation);
 }
+void ValveStateResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->position != 0.0f, false);
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->current_operation), false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ValveStateResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -8535,6 +9906,12 @@ void ValveCommandRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_float(3, this->position);
   buffer.encode_bool(4, this->stop);
 }
+void ValveCommandRequest::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_bool_field(total_size, 1, this->has_position, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->position != 0.0f, false);
+  ProtoSize::add_bool_field(total_size, 1, this->stop, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ValveCommandRequest::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -8614,6 +9991,15 @@ void ListEntitiesDateTimeResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_bool(6, this->disabled_by_default);
   buffer.encode_enum<enums::EntityCategory>(7, this->entity_category);
 }
+void ListEntitiesDateTimeResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_string_field(total_size, 1, this->object_id, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_string_field(total_size, 1, this->name, false);
+  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
+  ProtoSize::add_string_field(total_size, 1, this->icon, false);
+  ProtoSize::add_bool_field(total_size, 1, this->disabled_by_default, false);
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->entity_category), false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ListEntitiesDateTimeResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -8678,6 +10064,11 @@ void DateTimeStateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_bool(2, this->missing_state);
   buffer.encode_fixed32(3, this->epoch_seconds);
 }
+void DateTimeStateResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_bool_field(total_size, 1, this->missing_state, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->epoch_seconds != 0, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void DateTimeStateResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -8716,6 +10107,10 @@ void DateTimeCommandRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_fixed32(1, this->key);
   buffer.encode_fixed32(2, this->epoch_seconds);
 }
+void DateTimeCommandRequest::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->epoch_seconds != 0, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void DateTimeCommandRequest::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -8792,6 +10187,16 @@ void ListEntitiesUpdateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_enum<enums::EntityCategory>(7, this->entity_category);
   buffer.encode_string(8, this->device_class);
 }
+void ListEntitiesUpdateResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_string_field(total_size, 1, this->object_id, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_string_field(total_size, 1, this->name, false);
+  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
+  ProtoSize::add_string_field(total_size, 1, this->icon, false);
+  ProtoSize::add_bool_field(total_size, 1, this->disabled_by_default, false);
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->entity_category), false);
+  ProtoSize::add_string_field(total_size, 1, this->device_class, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ListEntitiesUpdateResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -8901,6 +10306,18 @@ void UpdateStateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(9, this->release_summary);
   buffer.encode_string(10, this->release_url);
 }
+void UpdateStateResponse::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_bool_field(total_size, 1, this->missing_state, false);
+  ProtoSize::add_bool_field(total_size, 1, this->in_progress, false);
+  ProtoSize::add_bool_field(total_size, 1, this->has_progress, false);
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->progress != 0.0f, false);
+  ProtoSize::add_string_field(total_size, 1, this->current_version, false);
+  ProtoSize::add_string_field(total_size, 1, this->latest_version, false);
+  ProtoSize::add_string_field(total_size, 1, this->title, false);
+  ProtoSize::add_string_field(total_size, 1, this->release_summary, false);
+  ProtoSize::add_string_field(total_size, 1, this->release_url, false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void UpdateStateResponse::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -8973,6 +10390,10 @@ void UpdateCommandRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_fixed32(1, this->key);
   buffer.encode_enum<enums::UpdateCommand>(2, this->command);
 }
+void UpdateCommandRequest::calculate_size(uint32_t &total_size) const {
+  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->command), false);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void UpdateCommandRequest::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];