diff --git a/esphome/components/api/api_connection.h b/esphome/components/api/api_connection.h
index a4c49dccf4..f5165f7836 100644
--- a/esphome/components/api/api_connection.h
+++ b/esphome/components/api/api_connection.h
@@ -345,11 +345,7 @@ class APIConnection final : public APIServerConnectionBase {
   /// Returns false as soon as the TCP buffer is full. Marked nodiscard so we
   /// have no silent failures: every caller must handle (or log) a refusal.
   template<typename T> [[nodiscard]] bool send_message(const T &msg) {
-    if constexpr (T::ESTIMATED_SIZE == 0) {
-      return this->send_message_(0, T::MESSAGE_TYPE, &encode_msg_noop, &msg);
-    } else {
-      return this->send_message_(msg.calculate_size(), T::MESSAGE_TYPE, &proto_encode_msg<T>, &msg);
-    }
+    return this->send_message_(T::calc_size_msg(&msg), T::MESSAGE_TYPE, &T::encode_msg, &msg);
   }
 
   /// Clear the shared write buffer and reserve space for the first message.
@@ -405,16 +401,6 @@ class APIConnection final : public APIServerConnectionBase {
   void process_state_subscriptions_();
 #endif
 
-  // Size thunk — converts void* back to concrete type for direct calculate_size() call
-  template<typename T> static uint32_t calc_size(const void *msg) {
-    return static_cast<const T *>(msg)->calculate_size();
-  }
-
-  // Shared no-op encode thunk for empty messages (ESTIMATED_SIZE == 0)
-  static uint8_t *encode_msg_noop(const void *, ProtoWriteBuffer &buf PROTO_ENCODE_DEBUG_PARAM) {
-    return buf.get_pos();
-  }
-
   // Non-template buffer management for send_message
   bool send_message_(uint32_t payload_size, uint16_t message_type, MessageEncodeFn encode_fn, const void *msg);
 
@@ -433,11 +419,7 @@ class APIConnection final : public APIServerConnectionBase {
   // Hot paths (state/info) go through fill_and_encode_entity_state/info instead.
   // batch_message_type_ is already set by dispatch_message_ before reaching here.
   template<typename T> static uint16_t encode_message_to_buffer(T &msg, APIConnection *conn, uint32_t remaining_size) {
-    if constexpr (T::ESTIMATED_SIZE == 0) {
-      return encode_to_buffer_slow(0, &encode_msg_noop, &msg, conn, remaining_size);
-    } else {
-      return encode_to_buffer_slow(msg.calculate_size(), &proto_encode_msg<T>, &msg, conn, remaining_size);
-    }
+    return encode_to_buffer_slow(T::calc_size_msg(&msg), &T::encode_msg, &msg, conn, remaining_size);
   }
 
   // Non-template core — fills state fields and encodes
@@ -449,7 +431,7 @@ class APIConnection final : public APIServerConnectionBase {
   template<typename T>
   static uint16_t fill_and_encode_entity_state(EntityBase *entity, T &msg, APIConnection *conn,
                                                uint32_t remaining_size) {
-    return fill_and_encode_entity_state(entity, msg, &calc_size<T>, &proto_encode_msg<T>, conn, remaining_size);
+    return fill_and_encode_entity_state(entity, msg, &T::calc_size_msg, &T::encode_msg, conn, remaining_size);
   }
 
   // Non-template core — fills info fields, allocates buffers, and encodes
@@ -461,7 +443,7 @@ class APIConnection final : public APIServerConnectionBase {
   template<typename T>
   static uint16_t fill_and_encode_entity_info(EntityBase *entity, T &msg, APIConnection *conn,
                                               uint32_t remaining_size) {
-    return fill_and_encode_entity_info(entity, msg, &calc_size<T>, &proto_encode_msg<T>, conn, remaining_size);
+    return fill_and_encode_entity_info(entity, msg, &T::calc_size_msg, &T::encode_msg, conn, remaining_size);
   }
 
   // Non-template core — fills device_class, then delegates to fill_and_encode_entity_info
@@ -475,8 +457,8 @@ class APIConnection final : public APIServerConnectionBase {
   static uint16_t fill_and_encode_entity_info_with_device_class(EntityBase *entity, T &msg,
                                                                 StringRef &device_class_field, APIConnection *conn,
                                                                 uint32_t remaining_size) {
-    return fill_and_encode_entity_info_with_device_class(entity, msg, device_class_field, &calc_size<T>,
-                                                         &proto_encode_msg<T>, conn, remaining_size);
+    return fill_and_encode_entity_info_with_device_class(entity, msg, device_class_field, &T::calc_size_msg,
+                                                         &T::encode_msg, conn, remaining_size);
   }
 
 #ifdef USE_VOICE_ASSISTANT
diff --git a/esphome/components/api/api_pb2.cpp b/esphome/components/api/api_pb2.cpp
index 27845b559d..8fd24dc502 100644
--- a/esphome/components/api/api_pb2.cpp
+++ b/esphome/components/api/api_pb2.cpp
@@ -31,20 +31,22 @@ bool HelloRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value)
   }
   return true;
 }
-uint8_t *HelloResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *HelloResponse::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const HelloResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 1, this->api_version_major);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, this->api_version_minor);
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, this->server_info);
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 34, this->name);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.api_version_major);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, msg.api_version_minor);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, msg.server_info);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 34, msg.name);
   return pos;
 }
-uint32_t HelloResponse::calculate_size() const {
+uint32_t HelloResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const HelloResponse *>(self);
   uint32_t size = 0;
-  size += ProtoSize::calc_uint32(1, this->api_version_major);
-  size += ProtoSize::calc_uint32(1, this->api_version_minor);
-  size += 2 + this->server_info.size();
-  size += 2 + this->name.size();
+  size += ProtoSize::calc_uint32(1, msg.api_version_major);
+  size += ProtoSize::calc_uint32(1, msg.api_version_minor);
+  size += 2 + msg.server_info.size();
+  size += 2 + msg.name.size();
   return size;
 }
 bool DisconnectRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
@@ -57,388 +59,415 @@ bool DisconnectRequest::decode_varint(uint32_t field_id, proto_varint_value_t va
   }
   return true;
 }
-uint8_t *DisconnectRequest::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *DisconnectRequest::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const DisconnectRequest *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 1, static_cast<uint32_t>(this->reason));
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 1, static_cast<uint32_t>(msg.reason));
   return pos;
 }
-uint32_t DisconnectRequest::calculate_size() const {
+uint32_t DisconnectRequest::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const DisconnectRequest *>(self);
   uint32_t size = 0;
-  size += this->reason ? 2 : 0;
+  size += msg.reason ? 2 : 0;
   return size;
 }
 #ifdef USE_AREAS
-uint8_t *AreaInfo::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *AreaInfo::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const AreaInfo *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 1, this->area_id);
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 18, this->name);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.area_id);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 18, msg.name);
   return pos;
 }
-uint32_t AreaInfo::calculate_size() const {
+uint32_t AreaInfo::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const AreaInfo *>(self);
   uint32_t size = 0;
-  size += ProtoSize::calc_uint32(1, this->area_id);
-  size += 2 + this->name.size();
+  size += ProtoSize::calc_uint32(1, msg.area_id);
+  size += 2 + msg.name.size();
   return size;
 }
 #endif
 #ifdef USE_DEVICES
-uint8_t *DeviceInfo::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *DeviceInfo::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const DeviceInfo *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 1, this->device_id);
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 18, this->name);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 3, this->area_id);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.device_id);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 18, msg.name);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 3, msg.area_id);
   return pos;
 }
-uint32_t DeviceInfo::calculate_size() const {
+uint32_t DeviceInfo::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const DeviceInfo *>(self);
   uint32_t size = 0;
-  size += ProtoSize::calc_uint32(1, this->device_id);
-  size += 2 + this->name.size();
-  size += ProtoSize::calc_uint32(1, this->area_id);
+  size += ProtoSize::calc_uint32(1, msg.device_id);
+  size += 2 + msg.name.size();
+  size += ProtoSize::calc_uint32(1, msg.area_id);
   return size;
 }
 #endif
 #ifdef USE_SERIAL_PROXY
-uint8_t *SerialProxyInfo::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *SerialProxyInfo::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const SerialProxyInfo *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 1, this->name);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, static_cast<uint32_t>(this->port_type));
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 3, this->configured_line_states);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.name);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, static_cast<uint32_t>(msg.port_type));
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 3, msg.configured_line_states);
   return pos;
 }
-uint32_t SerialProxyInfo::calculate_size() const {
+uint32_t SerialProxyInfo::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const SerialProxyInfo *>(self);
   uint32_t size = 0;
-  size += ProtoSize::calc_length(1, this->name.size());
-  size += this->port_type ? 2 : 0;
-  size += ProtoSize::calc_uint32(1, this->configured_line_states);
+  size += ProtoSize::calc_length(1, msg.name.size());
+  size += msg.port_type ? 2 : 0;
+  size += ProtoSize::calc_uint32(1, msg.configured_line_states);
   return size;
 }
 #endif
-uint8_t *DeviceInfoResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *DeviceInfoResponse::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const DeviceInfoResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 18, this->name);
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, this->mac_address);
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 34, this->esphome_version);
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 42, this->compilation_time);
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 50, this->model);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 18, msg.name);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, msg.mac_address);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 34, msg.esphome_version);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 42, msg.compilation_time);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 50, msg.model);
 #ifdef USE_DEEP_SLEEP
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 7, this->has_deep_sleep);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 7, msg.has_deep_sleep);
 #endif
 #ifdef ESPHOME_PROJECT_NAME
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 66, this->project_name);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 66, msg.project_name);
 #endif
 #ifdef ESPHOME_PROJECT_NAME
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 74, this->project_version);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 74, msg.project_version);
 #endif
 #ifdef USE_WEBSERVER
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 10, this->webserver_port);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 10, msg.webserver_port);
 #endif
 #ifdef USE_BLUETOOTH_PROXY
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 15, this->bluetooth_proxy_feature_flags);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 15, msg.bluetooth_proxy_feature_flags);
 #endif
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 98, this->manufacturer);
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 106, this->friendly_name);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 98, msg.manufacturer);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 106, msg.friendly_name);
 #ifdef USE_VOICE_ASSISTANT
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 17, this->voice_assistant_feature_flags);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 17, msg.voice_assistant_feature_flags);
 #endif
 #ifdef USE_AREAS
-  pos = ProtoEncode::encode_string_force(pos PROTO_ENCODE_DEBUG_ARG, 16, this->suggested_area);
+  pos = ProtoEncode::encode_string_force(pos PROTO_ENCODE_DEBUG_ARG, 16, msg.suggested_area);
 #endif
 #ifdef USE_BLUETOOTH_PROXY
-  pos = ProtoEncode::encode_string_force(pos PROTO_ENCODE_DEBUG_ARG, 18, this->bluetooth_mac_address);
+  pos = ProtoEncode::encode_string_force(pos PROTO_ENCODE_DEBUG_ARG, 18, msg.bluetooth_mac_address);
 #endif
 #ifdef USE_API_NOISE
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 19, this->api_encryption_supported);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 19, msg.api_encryption_supported);
 #endif
 #ifdef USE_DEVICES
-  for (const auto &it : this->devices) {
+  for (const auto &it : msg.devices) {
     pos = ProtoEncode::encode_sub_message(pos PROTO_ENCODE_DEBUG_ARG, buffer, 20, it);
   }
 #endif
 #ifdef USE_AREAS
-  for (const auto &it : this->areas) {
+  for (const auto &it : msg.areas) {
     pos = ProtoEncode::encode_sub_message(pos PROTO_ENCODE_DEBUG_ARG, buffer, 21, it);
   }
 #endif
 #ifdef USE_AREAS
-  pos = ProtoEncode::encode_optional_sub_message(pos PROTO_ENCODE_DEBUG_ARG, buffer, 22, this->area);
+  pos = ProtoEncode::encode_optional_sub_message(pos PROTO_ENCODE_DEBUG_ARG, buffer, 22, msg.area);
 #endif
 #ifdef USE_ZWAVE_PROXY
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 23, this->zwave_proxy_feature_flags);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 23, msg.zwave_proxy_feature_flags);
 #endif
 #ifdef USE_ZWAVE_PROXY
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 24, this->zwave_home_id);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 24, msg.zwave_home_id);
 #endif
 #ifdef USE_SERIAL_PROXY
-  for (const auto &it : this->serial_proxies) {
+  for (const auto &it : msg.serial_proxies) {
     pos = ProtoEncode::encode_sub_message(pos PROTO_ENCODE_DEBUG_ARG, buffer, 25, it);
   }
 #endif
 #ifdef USE_API_NOISE
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 26, this->api_encryption_provisionable);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 26, msg.api_encryption_provisionable);
 #endif
   return pos;
 }
-uint32_t DeviceInfoResponse::calculate_size() const {
+uint32_t DeviceInfoResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const DeviceInfoResponse *>(self);
   uint32_t size = 0;
-  size += 2 + this->name.size();
-  size += 2 + this->mac_address.size();
-  size += 2 + this->esphome_version.size();
-  size += 2 + this->compilation_time.size();
-  size += 2 + this->model.size();
+  size += 2 + msg.name.size();
+  size += 2 + msg.mac_address.size();
+  size += 2 + msg.esphome_version.size();
+  size += 2 + msg.compilation_time.size();
+  size += 2 + msg.model.size();
 #ifdef USE_DEEP_SLEEP
-  size += ProtoSize::calc_bool(1, this->has_deep_sleep);
+  size += ProtoSize::calc_bool(1, msg.has_deep_sleep);
 #endif
 #ifdef ESPHOME_PROJECT_NAME
-  size += 2 + this->project_name.size();
+  size += 2 + msg.project_name.size();
 #endif
 #ifdef ESPHOME_PROJECT_NAME
-  size += 2 + this->project_version.size();
+  size += 2 + msg.project_version.size();
 #endif
 #ifdef USE_WEBSERVER
-  size += ProtoSize::calc_uint32(1, this->webserver_port);
+  size += ProtoSize::calc_uint32(1, msg.webserver_port);
 #endif
 #ifdef USE_BLUETOOTH_PROXY
-  size += ProtoSize::calc_uint32(1, this->bluetooth_proxy_feature_flags);
+  size += ProtoSize::calc_uint32(1, msg.bluetooth_proxy_feature_flags);
 #endif
-  size += 2 + this->manufacturer.size();
-  size += 2 + this->friendly_name.size();
+  size += 2 + msg.manufacturer.size();
+  size += 2 + msg.friendly_name.size();
 #ifdef USE_VOICE_ASSISTANT
-  size += ProtoSize::calc_uint32(2, this->voice_assistant_feature_flags);
+  size += ProtoSize::calc_uint32(2, msg.voice_assistant_feature_flags);
 #endif
 #ifdef USE_AREAS
-  size += 3 + this->suggested_area.size();
+  size += 3 + msg.suggested_area.size();
 #endif
 #ifdef USE_BLUETOOTH_PROXY
-  size += 3 + this->bluetooth_mac_address.size();
+  size += 3 + msg.bluetooth_mac_address.size();
 #endif
 #ifdef USE_API_NOISE
-  size += ProtoSize::calc_bool(2, this->api_encryption_supported);
+  size += ProtoSize::calc_bool(2, msg.api_encryption_supported);
 #endif
 #ifdef USE_DEVICES
-  for (const auto &it : this->devices) {
+  for (const auto &it : msg.devices) {
     size += ProtoSize::calc_message_force(2, it.calculate_size());
   }
 #endif
 #ifdef USE_AREAS
-  for (const auto &it : this->areas) {
+  for (const auto &it : msg.areas) {
     size += ProtoSize::calc_message_force(2, it.calculate_size());
   }
 #endif
 #ifdef USE_AREAS
-  size += ProtoSize::calc_message(2, this->area.calculate_size());
+  size += ProtoSize::calc_message(2, msg.area.calculate_size());
 #endif
 #ifdef USE_ZWAVE_PROXY
-  size += ProtoSize::calc_uint32(2, this->zwave_proxy_feature_flags);
+  size += ProtoSize::calc_uint32(2, msg.zwave_proxy_feature_flags);
 #endif
 #ifdef USE_ZWAVE_PROXY
-  size += ProtoSize::calc_uint32(2, this->zwave_home_id);
+  size += ProtoSize::calc_uint32(2, msg.zwave_home_id);
 #endif
 #ifdef USE_SERIAL_PROXY
-  for (const auto &it : this->serial_proxies) {
+  for (const auto &it : msg.serial_proxies) {
     size += ProtoSize::calc_message_force(2, it.calculate_size());
   }
 #endif
 #ifdef USE_API_NOISE
-  size += ProtoSize::calc_bool(2, this->api_encryption_provisionable);
+  size += ProtoSize::calc_bool(2, msg.api_encryption_provisionable);
 #endif
   return size;
 }
 #ifdef USE_BLUETOOTH_PROXY
-uint8_t *BluetoothProxyCapabilities::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *BluetoothProxyCapabilities::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const BluetoothProxyCapabilities *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 1, this->feature_flags);
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 18, this->mac_address);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.feature_flags);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 18, msg.mac_address);
   return pos;
 }
-uint32_t BluetoothProxyCapabilities::calculate_size() const {
+uint32_t BluetoothProxyCapabilities::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const BluetoothProxyCapabilities *>(self);
   uint32_t size = 0;
-  size += ProtoSize::calc_uint32(1, this->feature_flags);
-  size += 2 + this->mac_address.size();
+  size += ProtoSize::calc_uint32(1, msg.feature_flags);
+  size += 2 + msg.mac_address.size();
   return size;
 }
 #endif
 #ifdef USE_VOICE_ASSISTANT
-uint8_t *VoiceAssistantCapabilities::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *VoiceAssistantCapabilities::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const VoiceAssistantCapabilities *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 1, this->feature_flags);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.feature_flags);
   return pos;
 }
-uint32_t VoiceAssistantCapabilities::calculate_size() const {
+uint32_t VoiceAssistantCapabilities::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const VoiceAssistantCapabilities *>(self);
   uint32_t size = 0;
-  size += ProtoSize::calc_uint32(1, this->feature_flags);
+  size += ProtoSize::calc_uint32(1, msg.feature_flags);
   return size;
 }
 #endif
 #ifdef USE_ZWAVE_PROXY
-uint8_t *ZWaveProxyCapabilities::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *ZWaveProxyCapabilities::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const ZWaveProxyCapabilities *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 1, this->feature_flags);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, this->home_id);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.feature_flags);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, msg.home_id);
   return pos;
 }
-uint32_t ZWaveProxyCapabilities::calculate_size() const {
+uint32_t ZWaveProxyCapabilities::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const ZWaveProxyCapabilities *>(self);
   uint32_t size = 0;
-  size += ProtoSize::calc_uint32(1, this->feature_flags);
-  size += ProtoSize::calc_uint32(1, this->home_id);
+  size += ProtoSize::calc_uint32(1, msg.feature_flags);
+  size += ProtoSize::calc_uint32(1, msg.home_id);
   return size;
 }
 #endif
-uint8_t *DeviceCapabilitiesResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *DeviceCapabilitiesResponse::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const DeviceCapabilitiesResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
 #ifdef USE_BLUETOOTH_PROXY
-  pos = ProtoEncode::encode_optional_sub_message(pos PROTO_ENCODE_DEBUG_ARG, buffer, 1, this->bluetooth_proxy);
+  pos = ProtoEncode::encode_optional_sub_message(pos PROTO_ENCODE_DEBUG_ARG, buffer, 1, msg.bluetooth_proxy);
 #endif
 #ifdef USE_VOICE_ASSISTANT
-  pos = ProtoEncode::encode_optional_sub_message(pos PROTO_ENCODE_DEBUG_ARG, buffer, 2, this->voice_assistant);
+  pos = ProtoEncode::encode_optional_sub_message(pos PROTO_ENCODE_DEBUG_ARG, buffer, 2, msg.voice_assistant);
 #endif
 #ifdef USE_ZWAVE_PROXY
-  pos = ProtoEncode::encode_optional_sub_message(pos PROTO_ENCODE_DEBUG_ARG, buffer, 3, this->zwave_proxy);
+  pos = ProtoEncode::encode_optional_sub_message(pos PROTO_ENCODE_DEBUG_ARG, buffer, 3, msg.zwave_proxy);
 #endif
 #ifdef USE_SERIAL_PROXY
-  for (const auto &it : this->serial_proxies) {
+  for (const auto &it : msg.serial_proxies) {
     pos = ProtoEncode::encode_sub_message(pos PROTO_ENCODE_DEBUG_ARG, buffer, 4, it);
   }
 #endif
   return pos;
 }
-uint32_t DeviceCapabilitiesResponse::calculate_size() const {
+uint32_t DeviceCapabilitiesResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const DeviceCapabilitiesResponse *>(self);
   uint32_t size = 0;
 #ifdef USE_BLUETOOTH_PROXY
-  size += ProtoSize::calc_message(1, this->bluetooth_proxy.calculate_size());
+  size += ProtoSize::calc_message(1, msg.bluetooth_proxy.calculate_size());
 #endif
 #ifdef USE_VOICE_ASSISTANT
-  size += ProtoSize::calc_message(1, this->voice_assistant.calculate_size());
+  size += ProtoSize::calc_message(1, msg.voice_assistant.calculate_size());
 #endif
 #ifdef USE_ZWAVE_PROXY
-  size += ProtoSize::calc_message(1, this->zwave_proxy.calculate_size());
+  size += ProtoSize::calc_message(1, msg.zwave_proxy.calculate_size());
 #endif
 #ifdef USE_SERIAL_PROXY
-  for (const auto &it : this->serial_proxies) {
+  for (const auto &it : msg.serial_proxies) {
     size += ProtoSize::calc_message_force(1, it.calculate_size());
   }
 #endif
   return size;
 }
 #ifdef USE_BINARY_SENSOR
-uint8_t *ListEntitiesBinarySensorResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *ListEntitiesBinarySensorResponse::encode_msg(const void *self,
+                                                      ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const ListEntitiesBinarySensorResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 10, this->object_id);
-  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, this->key);
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, this->name);
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 5, this->device_class);
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 6, this->is_status_binary_sensor);
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 7, this->disabled_by_default);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 10, msg.object_id);
+  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, msg.key);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, msg.name);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 5, msg.device_class);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 6, msg.is_status_binary_sensor);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 7, msg.disabled_by_default);
 #ifdef USE_ENTITY_ICON
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 8, this->icon);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 8, msg.icon);
 #endif
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 9, static_cast<uint32_t>(this->entity_category));
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 9, static_cast<uint32_t>(msg.entity_category));
 #ifdef USE_DEVICES
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 10, this->device_id);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 10, msg.device_id);
 #endif
   return pos;
 }
-uint32_t ListEntitiesBinarySensorResponse::calculate_size() const {
+uint32_t ListEntitiesBinarySensorResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const ListEntitiesBinarySensorResponse *>(self);
   uint32_t size = 0;
-  size += 2 + this->object_id.size();
+  size += 2 + msg.object_id.size();
   size += 5;
-  size += 2 + this->name.size();
-  size += !this->device_class.empty() ? 2 + this->device_class.size() : 0;
-  size += ProtoSize::calc_bool(1, this->is_status_binary_sensor);
-  size += ProtoSize::calc_bool(1, this->disabled_by_default);
+  size += 2 + msg.name.size();
+  size += !msg.device_class.empty() ? 2 + msg.device_class.size() : 0;
+  size += ProtoSize::calc_bool(1, msg.is_status_binary_sensor);
+  size += ProtoSize::calc_bool(1, msg.disabled_by_default);
 #ifdef USE_ENTITY_ICON
-  size += !this->icon.empty() ? 2 + this->icon.size() : 0;
+  size += !msg.icon.empty() ? 2 + msg.icon.size() : 0;
 #endif
-  size += this->entity_category ? 2 : 0;
+  size += msg.entity_category ? 2 : 0;
 #ifdef USE_DEVICES
-  size += ProtoSize::calc_uint32(1, this->device_id);
+  size += ProtoSize::calc_uint32(1, msg.device_id);
 #endif
   return size;
 }
-uint8_t *BinarySensorStateResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *BinarySensorStateResponse::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const BinarySensorStateResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 13, this->key);
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 2, this->state);
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 3, this->missing_state);
+  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 13, msg.key);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 2, msg.state);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 3, msg.missing_state);
 #ifdef USE_DEVICES
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 4, this->device_id);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 4, msg.device_id);
 #endif
   return pos;
 }
-uint32_t BinarySensorStateResponse::calculate_size() const {
+uint32_t BinarySensorStateResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const BinarySensorStateResponse *>(self);
   uint32_t size = 0;
   size += 5;
-  size += ProtoSize::calc_bool(1, this->state);
-  size += ProtoSize::calc_bool(1, this->missing_state);
+  size += ProtoSize::calc_bool(1, msg.state);
+  size += ProtoSize::calc_bool(1, msg.missing_state);
 #ifdef USE_DEVICES
-  size += ProtoSize::calc_uint32(1, this->device_id);
+  size += ProtoSize::calc_uint32(1, msg.device_id);
 #endif
   return size;
 }
 #endif
 #ifdef USE_COVER
-uint8_t *ListEntitiesCoverResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *ListEntitiesCoverResponse::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const ListEntitiesCoverResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 10, this->object_id);
-  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, this->key);
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, this->name);
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 5, this->assumed_state);
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 6, this->supports_position);
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 7, this->supports_tilt);
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 8, this->device_class);
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 9, this->disabled_by_default);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 10, msg.object_id);
+  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, msg.key);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, msg.name);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 5, msg.assumed_state);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 6, msg.supports_position);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 7, msg.supports_tilt);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 8, msg.device_class);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 9, msg.disabled_by_default);
 #ifdef USE_ENTITY_ICON
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 10, this->icon);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 10, msg.icon);
 #endif
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 11, static_cast<uint32_t>(this->entity_category));
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 12, this->supports_stop);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 11, static_cast<uint32_t>(msg.entity_category));
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 12, msg.supports_stop);
 #ifdef USE_DEVICES
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 13, this->device_id);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 13, msg.device_id);
 #endif
   return pos;
 }
-uint32_t ListEntitiesCoverResponse::calculate_size() const {
+uint32_t ListEntitiesCoverResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const ListEntitiesCoverResponse *>(self);
   uint32_t size = 0;
-  size += 2 + this->object_id.size();
+  size += 2 + msg.object_id.size();
   size += 5;
-  size += 2 + this->name.size();
-  size += ProtoSize::calc_bool(1, this->assumed_state);
-  size += ProtoSize::calc_bool(1, this->supports_position);
-  size += ProtoSize::calc_bool(1, this->supports_tilt);
-  size += !this->device_class.empty() ? 2 + this->device_class.size() : 0;
-  size += ProtoSize::calc_bool(1, this->disabled_by_default);
+  size += 2 + msg.name.size();
+  size += ProtoSize::calc_bool(1, msg.assumed_state);
+  size += ProtoSize::calc_bool(1, msg.supports_position);
+  size += ProtoSize::calc_bool(1, msg.supports_tilt);
+  size += !msg.device_class.empty() ? 2 + msg.device_class.size() : 0;
+  size += ProtoSize::calc_bool(1, msg.disabled_by_default);
 #ifdef USE_ENTITY_ICON
-  size += !this->icon.empty() ? 2 + this->icon.size() : 0;
+  size += !msg.icon.empty() ? 2 + msg.icon.size() : 0;
 #endif
-  size += this->entity_category ? 2 : 0;
-  size += ProtoSize::calc_bool(1, this->supports_stop);
+  size += msg.entity_category ? 2 : 0;
+  size += ProtoSize::calc_bool(1, msg.supports_stop);
 #ifdef USE_DEVICES
-  size += ProtoSize::calc_uint32(1, this->device_id);
+  size += ProtoSize::calc_uint32(1, msg.device_id);
 #endif
   return size;
 }
-uint8_t *CoverStateResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *CoverStateResponse::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const CoverStateResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 13, this->key);
-  if (uint32_t raw = float_to_raw(this->position); raw != 0) [[likely]] {
+  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 13, msg.key);
+  if (uint32_t raw = float_to_raw(msg.position); raw != 0) [[likely]] {
     pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 29, raw);
   }
-  if (uint32_t raw = float_to_raw(this->tilt); raw != 0) [[likely]] {
+  if (uint32_t raw = float_to_raw(msg.tilt); raw != 0) [[likely]] {
     pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 37, raw);
   }
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 5, static_cast<uint32_t>(this->current_operation));
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 5, static_cast<uint32_t>(msg.current_operation));
 #ifdef USE_DEVICES
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 6, this->device_id);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 6, msg.device_id);
 #endif
   return pos;
 }
-uint32_t CoverStateResponse::calculate_size() const {
+uint32_t CoverStateResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const CoverStateResponse *>(self);
   uint32_t size = 0;
   size += 5;
-  size += ProtoSize::calc_float(1, this->position);
-  size += ProtoSize::calc_float(1, this->tilt);
-  size += this->current_operation ? 2 : 0;
+  size += ProtoSize::calc_float(1, msg.position);
+  size += ProtoSize::calc_float(1, msg.tilt);
+  size += msg.current_operation ? 2 : 0;
 #ifdef USE_DEVICES
-  size += ProtoSize::calc_uint32(1, this->device_id);
+  size += ProtoSize::calc_uint32(1, msg.device_id);
 #endif
   return size;
 }
@@ -481,75 +510,79 @@ bool CoverCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
 }
 #endif
 #ifdef USE_FAN
-uint8_t *ListEntitiesFanResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *ListEntitiesFanResponse::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const ListEntitiesFanResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 10, this->object_id);
-  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, this->key);
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, this->name);
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 5, this->supports_oscillation);
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 6, this->supports_speed);
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 7, this->supports_direction);
-  pos = ProtoEncode::encode_int32(pos PROTO_ENCODE_DEBUG_ARG, 8, this->supported_speed_count);
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 9, this->disabled_by_default);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 10, msg.object_id);
+  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, msg.key);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, msg.name);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 5, msg.supports_oscillation);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 6, msg.supports_speed);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 7, msg.supports_direction);
+  pos = ProtoEncode::encode_int32(pos PROTO_ENCODE_DEBUG_ARG, 8, msg.supported_speed_count);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 9, msg.disabled_by_default);
 #ifdef USE_ENTITY_ICON
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 10, this->icon);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 10, msg.icon);
 #endif
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 11, static_cast<uint32_t>(this->entity_category));
-  for (const char *it : *this->supported_preset_modes) {
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 11, static_cast<uint32_t>(msg.entity_category));
+  for (const char *it : *msg.supported_preset_modes) {
     pos = ProtoEncode::encode_string_force(pos PROTO_ENCODE_DEBUG_ARG, 12, it, strlen(it));
   }
 #ifdef USE_DEVICES
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 13, this->device_id);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 13, msg.device_id);
 #endif
   return pos;
 }
-uint32_t ListEntitiesFanResponse::calculate_size() const {
+uint32_t ListEntitiesFanResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const ListEntitiesFanResponse *>(self);
   uint32_t size = 0;
-  size += 2 + this->object_id.size();
+  size += 2 + msg.object_id.size();
   size += 5;
-  size += 2 + this->name.size();
-  size += ProtoSize::calc_bool(1, this->supports_oscillation);
-  size += ProtoSize::calc_bool(1, this->supports_speed);
-  size += ProtoSize::calc_bool(1, this->supports_direction);
-  size += ProtoSize::calc_int32(1, this->supported_speed_count);
-  size += ProtoSize::calc_bool(1, this->disabled_by_default);
+  size += 2 + msg.name.size();
+  size += ProtoSize::calc_bool(1, msg.supports_oscillation);
+  size += ProtoSize::calc_bool(1, msg.supports_speed);
+  size += ProtoSize::calc_bool(1, msg.supports_direction);
+  size += ProtoSize::calc_int32(1, msg.supported_speed_count);
+  size += ProtoSize::calc_bool(1, msg.disabled_by_default);
 #ifdef USE_ENTITY_ICON
-  size += !this->icon.empty() ? 2 + this->icon.size() : 0;
+  size += !msg.icon.empty() ? 2 + msg.icon.size() : 0;
 #endif
-  size += this->entity_category ? 2 : 0;
-  if (!this->supported_preset_modes->empty()) {
-    for (const char *it : *this->supported_preset_modes) {
+  size += msg.entity_category ? 2 : 0;
+  if (!msg.supported_preset_modes->empty()) {
+    for (const char *it : *msg.supported_preset_modes) {
       size += ProtoSize::calc_length_force(1, strlen(it));
     }
   }
 #ifdef USE_DEVICES
-  size += ProtoSize::calc_uint32(1, this->device_id);
+  size += ProtoSize::calc_uint32(1, msg.device_id);
 #endif
   return size;
 }
-uint8_t *FanStateResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *FanStateResponse::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const FanStateResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 13, this->key);
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 2, this->state);
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 3, this->oscillating);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 5, static_cast<uint32_t>(this->direction));
-  pos = ProtoEncode::encode_int32(pos PROTO_ENCODE_DEBUG_ARG, 6, this->speed_level);
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 7, this->preset_mode);
+  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 13, msg.key);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 2, msg.state);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 3, msg.oscillating);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 5, static_cast<uint32_t>(msg.direction));
+  pos = ProtoEncode::encode_int32(pos PROTO_ENCODE_DEBUG_ARG, 6, msg.speed_level);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 7, msg.preset_mode);
 #ifdef USE_DEVICES
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 8, this->device_id);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 8, msg.device_id);
 #endif
   return pos;
 }
-uint32_t FanStateResponse::calculate_size() const {
+uint32_t FanStateResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const FanStateResponse *>(self);
   uint32_t size = 0;
   size += 5;
-  size += ProtoSize::calc_bool(1, this->state);
-  size += ProtoSize::calc_bool(1, this->oscillating);
-  size += this->direction ? 2 : 0;
-  size += ProtoSize::calc_int32(1, this->speed_level);
-  size += ProtoSize::calc_length(1, this->preset_mode.size());
+  size += ProtoSize::calc_bool(1, msg.state);
+  size += ProtoSize::calc_bool(1, msg.oscillating);
+  size += msg.direction ? 2 : 0;
+  size += ProtoSize::calc_int32(1, msg.speed_level);
+  size += ProtoSize::calc_length(1, msg.preset_mode.size());
 #ifdef USE_DEVICES
-  size += ProtoSize::calc_uint32(1, this->device_id);
+  size += ProtoSize::calc_uint32(1, msg.device_id);
 #endif
   return size;
 }
@@ -615,113 +648,117 @@ bool FanCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
 }
 #endif
 #ifdef USE_LIGHT
-uint8_t *ListEntitiesLightResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *ListEntitiesLightResponse::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const ListEntitiesLightResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 10, this->object_id);
-  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, this->key);
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, this->name);
-  for (const auto &it : *this->supported_color_modes) {
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 10, msg.object_id);
+  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, msg.key);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, msg.name);
+  for (const auto &it : *msg.supported_color_modes) {
     pos = ProtoEncode::encode_uint32_force(pos PROTO_ENCODE_DEBUG_ARG, 12, static_cast<uint32_t>(it));
   }
-  if (uint32_t raw = float_to_raw(this->min_mireds); raw != 0) [[likely]] {
+  if (uint32_t raw = float_to_raw(msg.min_mireds); raw != 0) [[likely]] {
     pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 77, raw);
   }
-  if (uint32_t raw = float_to_raw(this->max_mireds); raw != 0) [[likely]] {
+  if (uint32_t raw = float_to_raw(msg.max_mireds); raw != 0) [[likely]] {
     pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 85, raw);
   }
-  for (const char *it : *this->effects) {
+  for (const char *it : *msg.effects) {
     pos = ProtoEncode::encode_string_force(pos PROTO_ENCODE_DEBUG_ARG, 11, it, strlen(it));
   }
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 13, this->disabled_by_default);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 13, msg.disabled_by_default);
 #ifdef USE_ENTITY_ICON
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 14, this->icon);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 14, msg.icon);
 #endif
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 15, static_cast<uint32_t>(this->entity_category));
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 15, static_cast<uint32_t>(msg.entity_category));
 #ifdef USE_DEVICES
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 16, this->device_id);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 16, msg.device_id);
 #endif
   return pos;
 }
-uint32_t ListEntitiesLightResponse::calculate_size() const {
+uint32_t ListEntitiesLightResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const ListEntitiesLightResponse *>(self);
   uint32_t size = 0;
-  size += 2 + this->object_id.size();
+  size += 2 + msg.object_id.size();
   size += 5;
-  size += 2 + this->name.size();
-  if (!this->supported_color_modes->empty()) {
-    size += this->supported_color_modes->size() * 2;
+  size += 2 + msg.name.size();
+  if (!msg.supported_color_modes->empty()) {
+    size += msg.supported_color_modes->size() * 2;
   }
-  size += ProtoSize::calc_float(1, this->min_mireds);
-  size += ProtoSize::calc_float(1, this->max_mireds);
-  if (!this->effects->empty()) {
-    for (const char *it : *this->effects) {
+  size += ProtoSize::calc_float(1, msg.min_mireds);
+  size += ProtoSize::calc_float(1, msg.max_mireds);
+  if (!msg.effects->empty()) {
+    for (const char *it : *msg.effects) {
       size += ProtoSize::calc_length_force(1, strlen(it));
     }
   }
-  size += ProtoSize::calc_bool(1, this->disabled_by_default);
+  size += ProtoSize::calc_bool(1, msg.disabled_by_default);
 #ifdef USE_ENTITY_ICON
-  size += !this->icon.empty() ? 2 + this->icon.size() : 0;
+  size += !msg.icon.empty() ? 2 + msg.icon.size() : 0;
 #endif
-  size += this->entity_category ? 2 : 0;
+  size += msg.entity_category ? 2 : 0;
 #ifdef USE_DEVICES
-  size += ProtoSize::calc_uint32(2, this->device_id);
+  size += ProtoSize::calc_uint32(2, msg.device_id);
 #endif
   return size;
 }
-uint8_t *LightStateResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *LightStateResponse::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const LightStateResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 13, this->key);
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 2, this->state);
-  if (uint32_t raw = float_to_raw(this->brightness); raw != 0) [[likely]] {
+  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 13, msg.key);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 2, msg.state);
+  if (uint32_t raw = float_to_raw(msg.brightness); raw != 0) [[likely]] {
     pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 29, raw);
   }
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 11, static_cast<uint32_t>(this->color_mode));
-  if (uint32_t raw = float_to_raw(this->color_brightness); raw != 0) [[likely]] {
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 11, static_cast<uint32_t>(msg.color_mode));
+  if (uint32_t raw = float_to_raw(msg.color_brightness); raw != 0) [[likely]] {
     pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 85, raw);
   }
-  if (uint32_t raw = float_to_raw(this->red); raw != 0) [[likely]] {
+  if (uint32_t raw = float_to_raw(msg.red); raw != 0) [[likely]] {
     pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 37, raw);
   }
-  if (uint32_t raw = float_to_raw(this->green); raw != 0) [[likely]] {
+  if (uint32_t raw = float_to_raw(msg.green); raw != 0) [[likely]] {
     pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 45, raw);
   }
-  if (uint32_t raw = float_to_raw(this->blue); raw != 0) [[likely]] {
+  if (uint32_t raw = float_to_raw(msg.blue); raw != 0) [[likely]] {
     pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 53, raw);
   }
-  if (uint32_t raw = float_to_raw(this->white); raw != 0) [[likely]] {
+  if (uint32_t raw = float_to_raw(msg.white); raw != 0) [[likely]] {
     pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 61, raw);
   }
-  if (uint32_t raw = float_to_raw(this->color_temperature); raw != 0) [[likely]] {
+  if (uint32_t raw = float_to_raw(msg.color_temperature); raw != 0) [[likely]] {
     pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 69, raw);
   }
-  if (uint32_t raw = float_to_raw(this->cold_white); raw != 0) [[likely]] {
+  if (uint32_t raw = float_to_raw(msg.cold_white); raw != 0) [[likely]] {
     pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 101, raw);
   }
-  if (uint32_t raw = float_to_raw(this->warm_white); raw != 0) [[likely]] {
+  if (uint32_t raw = float_to_raw(msg.warm_white); raw != 0) [[likely]] {
     pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 109, raw);
   }
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 9, this->effect);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 9, msg.effect);
 #ifdef USE_DEVICES
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 14, this->device_id);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 14, msg.device_id);
 #endif
   return pos;
 }
-uint32_t LightStateResponse::calculate_size() const {
+uint32_t LightStateResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const LightStateResponse *>(self);
   uint32_t size = 0;
   size += 5;
-  size += ProtoSize::calc_bool(1, this->state);
-  size += ProtoSize::calc_float(1, this->brightness);
-  size += this->color_mode ? 2 : 0;
-  size += ProtoSize::calc_float(1, this->color_brightness);
-  size += ProtoSize::calc_float(1, this->red);
-  size += ProtoSize::calc_float(1, this->green);
-  size += ProtoSize::calc_float(1, this->blue);
-  size += ProtoSize::calc_float(1, this->white);
-  size += ProtoSize::calc_float(1, this->color_temperature);
-  size += ProtoSize::calc_float(1, this->cold_white);
-  size += ProtoSize::calc_float(1, this->warm_white);
-  size += ProtoSize::calc_length(1, this->effect.size());
+  size += ProtoSize::calc_bool(1, msg.state);
+  size += ProtoSize::calc_float(1, msg.brightness);
+  size += msg.color_mode ? 2 : 0;
+  size += ProtoSize::calc_float(1, msg.color_brightness);
+  size += ProtoSize::calc_float(1, msg.red);
+  size += ProtoSize::calc_float(1, msg.green);
+  size += ProtoSize::calc_float(1, msg.blue);
+  size += ProtoSize::calc_float(1, msg.white);
+  size += ProtoSize::calc_float(1, msg.color_temperature);
+  size += ProtoSize::calc_float(1, msg.cold_white);
+  size += ProtoSize::calc_float(1, msg.warm_white);
+  size += ProtoSize::calc_length(1, msg.effect.size());
 #ifdef USE_DEVICES
-  size += ProtoSize::calc_uint32(1, this->device_id);
+  size += ProtoSize::calc_uint32(1, msg.device_id);
 #endif
   return size;
 }
@@ -835,123 +872,131 @@ bool LightCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
 }
 #endif
 #ifdef USE_SENSOR
-uint8_t *ListEntitiesSensorResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *ListEntitiesSensorResponse::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const ListEntitiesSensorResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 10, this->object_id);
-  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, this->key);
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, this->name);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 10, msg.object_id);
+  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, msg.key);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, msg.name);
 #ifdef USE_ENTITY_ICON
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 5, this->icon);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 5, msg.icon);
 #endif
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 6, this->unit_of_measurement);
-  pos = ProtoEncode::encode_int32(pos PROTO_ENCODE_DEBUG_ARG, 7, this->accuracy_decimals);
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 8, this->force_update);
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 9, this->device_class);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 10, static_cast<uint32_t>(this->state_class));
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 12, this->disabled_by_default);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 13, static_cast<uint32_t>(this->entity_category));
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 6, msg.unit_of_measurement);
+  pos = ProtoEncode::encode_int32(pos PROTO_ENCODE_DEBUG_ARG, 7, msg.accuracy_decimals);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 8, msg.force_update);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 9, msg.device_class);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 10, static_cast<uint32_t>(msg.state_class));
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 12, msg.disabled_by_default);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 13, static_cast<uint32_t>(msg.entity_category));
 #ifdef USE_DEVICES
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 14, this->device_id);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 14, msg.device_id);
 #endif
   return pos;
 }
-uint32_t ListEntitiesSensorResponse::calculate_size() const {
+uint32_t ListEntitiesSensorResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const ListEntitiesSensorResponse *>(self);
   uint32_t size = 0;
-  size += 2 + this->object_id.size();
+  size += 2 + msg.object_id.size();
   size += 5;
-  size += 2 + this->name.size();
+  size += 2 + msg.name.size();
 #ifdef USE_ENTITY_ICON
-  size += !this->icon.empty() ? 2 + this->icon.size() : 0;
+  size += !msg.icon.empty() ? 2 + msg.icon.size() : 0;
 #endif
-  size += !this->unit_of_measurement.empty() ? 2 + this->unit_of_measurement.size() : 0;
-  size += ProtoSize::calc_int32(1, this->accuracy_decimals);
-  size += ProtoSize::calc_bool(1, this->force_update);
-  size += !this->device_class.empty() ? 2 + this->device_class.size() : 0;
-  size += this->state_class ? 2 : 0;
-  size += ProtoSize::calc_bool(1, this->disabled_by_default);
-  size += this->entity_category ? 2 : 0;
+  size += !msg.unit_of_measurement.empty() ? 2 + msg.unit_of_measurement.size() : 0;
+  size += ProtoSize::calc_int32(1, msg.accuracy_decimals);
+  size += ProtoSize::calc_bool(1, msg.force_update);
+  size += !msg.device_class.empty() ? 2 + msg.device_class.size() : 0;
+  size += msg.state_class ? 2 : 0;
+  size += ProtoSize::calc_bool(1, msg.disabled_by_default);
+  size += msg.entity_category ? 2 : 0;
 #ifdef USE_DEVICES
-  size += ProtoSize::calc_uint32(1, this->device_id);
+  size += ProtoSize::calc_uint32(1, msg.device_id);
 #endif
   return size;
 }
 __attribute__((optimize("O2")))  // NOLINT(clang-diagnostic-unknown-attributes)
 uint8_t *
-SensorStateResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+SensorStateResponse::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const SensorStateResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 13, this->key);
-  if (uint32_t raw = float_to_raw(this->state); raw != 0) [[likely]] {
+  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 13, msg.key);
+  if (uint32_t raw = float_to_raw(msg.state); raw != 0) [[likely]] {
     pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, raw);
   }
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 3, this->missing_state);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 3, msg.missing_state);
 #ifdef USE_DEVICES
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 4, this->device_id);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 4, msg.device_id);
 #endif
   return pos;
 }
 __attribute__((optimize("O2")))  // NOLINT(clang-diagnostic-unknown-attributes)
 uint32_t
-SensorStateResponse::calculate_size() const {
+SensorStateResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const SensorStateResponse *>(self);
   uint32_t size = 0;
   size += 5;
-  size += ProtoSize::calc_float(1, this->state);
-  size += ProtoSize::calc_bool(1, this->missing_state);
+  size += ProtoSize::calc_float(1, msg.state);
+  size += ProtoSize::calc_bool(1, msg.missing_state);
 #ifdef USE_DEVICES
-  size += ProtoSize::calc_uint32(1, this->device_id);
+  size += ProtoSize::calc_uint32(1, msg.device_id);
 #endif
   return size;
 }
 #endif
 #ifdef USE_SWITCH
-uint8_t *ListEntitiesSwitchResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *ListEntitiesSwitchResponse::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const ListEntitiesSwitchResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 10, this->object_id);
-  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, this->key);
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, this->name);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 10, msg.object_id);
+  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, msg.key);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, msg.name);
 #ifdef USE_ENTITY_ICON
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 5, this->icon);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 5, msg.icon);
 #endif
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 6, this->assumed_state);
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 7, this->disabled_by_default);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 8, static_cast<uint32_t>(this->entity_category));
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 9, this->device_class);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 6, msg.assumed_state);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 7, msg.disabled_by_default);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 8, static_cast<uint32_t>(msg.entity_category));
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 9, msg.device_class);
 #ifdef USE_DEVICES
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 10, this->device_id);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 10, msg.device_id);
 #endif
   return pos;
 }
-uint32_t ListEntitiesSwitchResponse::calculate_size() const {
+uint32_t ListEntitiesSwitchResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const ListEntitiesSwitchResponse *>(self);
   uint32_t size = 0;
-  size += 2 + this->object_id.size();
+  size += 2 + msg.object_id.size();
   size += 5;
-  size += 2 + this->name.size();
+  size += 2 + msg.name.size();
 #ifdef USE_ENTITY_ICON
-  size += !this->icon.empty() ? 2 + this->icon.size() : 0;
+  size += !msg.icon.empty() ? 2 + msg.icon.size() : 0;
 #endif
-  size += ProtoSize::calc_bool(1, this->assumed_state);
-  size += ProtoSize::calc_bool(1, this->disabled_by_default);
-  size += this->entity_category ? 2 : 0;
-  size += !this->device_class.empty() ? 2 + this->device_class.size() : 0;
+  size += ProtoSize::calc_bool(1, msg.assumed_state);
+  size += ProtoSize::calc_bool(1, msg.disabled_by_default);
+  size += msg.entity_category ? 2 : 0;
+  size += !msg.device_class.empty() ? 2 + msg.device_class.size() : 0;
 #ifdef USE_DEVICES
-  size += ProtoSize::calc_uint32(1, this->device_id);
+  size += ProtoSize::calc_uint32(1, msg.device_id);
 #endif
   return size;
 }
-uint8_t *SwitchStateResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *SwitchStateResponse::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const SwitchStateResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 13, this->key);
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 2, this->state);
+  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 13, msg.key);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 2, msg.state);
 #ifdef USE_DEVICES
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 3, this->device_id);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 3, msg.device_id);
 #endif
   return pos;
 }
-uint32_t SwitchStateResponse::calculate_size() const {
+uint32_t SwitchStateResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const SwitchStateResponse *>(self);
   uint32_t size = 0;
   size += 5;
-  size += ProtoSize::calc_bool(1, this->state);
+  size += ProtoSize::calc_bool(1, msg.state);
 #ifdef USE_DEVICES
-  size += ProtoSize::calc_uint32(1, this->device_id);
+  size += ProtoSize::calc_uint32(1, msg.device_id);
 #endif
   return size;
 }
@@ -982,55 +1027,60 @@ bool SwitchCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
 }
 #endif
 #ifdef USE_TEXT_SENSOR
-uint8_t *ListEntitiesTextSensorResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *ListEntitiesTextSensorResponse::encode_msg(const void *self,
+                                                    ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const ListEntitiesTextSensorResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 10, this->object_id);
-  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, this->key);
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, this->name);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 10, msg.object_id);
+  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, msg.key);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, msg.name);
 #ifdef USE_ENTITY_ICON
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 5, this->icon);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 5, msg.icon);
 #endif
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 6, this->disabled_by_default);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 7, static_cast<uint32_t>(this->entity_category));
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 8, this->device_class);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 6, msg.disabled_by_default);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 7, static_cast<uint32_t>(msg.entity_category));
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 8, msg.device_class);
 #ifdef USE_DEVICES
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 9, this->device_id);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 9, msg.device_id);
 #endif
   return pos;
 }
-uint32_t ListEntitiesTextSensorResponse::calculate_size() const {
+uint32_t ListEntitiesTextSensorResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const ListEntitiesTextSensorResponse *>(self);
   uint32_t size = 0;
-  size += 2 + this->object_id.size();
+  size += 2 + msg.object_id.size();
   size += 5;
-  size += 2 + this->name.size();
+  size += 2 + msg.name.size();
 #ifdef USE_ENTITY_ICON
-  size += !this->icon.empty() ? 2 + this->icon.size() : 0;
+  size += !msg.icon.empty() ? 2 + msg.icon.size() : 0;
 #endif
-  size += ProtoSize::calc_bool(1, this->disabled_by_default);
-  size += this->entity_category ? 2 : 0;
-  size += !this->device_class.empty() ? 2 + this->device_class.size() : 0;
+  size += ProtoSize::calc_bool(1, msg.disabled_by_default);
+  size += msg.entity_category ? 2 : 0;
+  size += !msg.device_class.empty() ? 2 + msg.device_class.size() : 0;
 #ifdef USE_DEVICES
-  size += ProtoSize::calc_uint32(1, this->device_id);
+  size += ProtoSize::calc_uint32(1, msg.device_id);
 #endif
   return size;
 }
-uint8_t *TextSensorStateResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *TextSensorStateResponse::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const TextSensorStateResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 13, this->key);
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 2, this->state);
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 3, this->missing_state);
+  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 13, msg.key);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 2, msg.state);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 3, msg.missing_state);
 #ifdef USE_DEVICES
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 4, this->device_id);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 4, msg.device_id);
 #endif
   return pos;
 }
-uint32_t TextSensorStateResponse::calculate_size() const {
+uint32_t TextSensorStateResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const TextSensorStateResponse *>(self);
   uint32_t size = 0;
   size += 5;
-  size += ProtoSize::calc_length(1, this->state.size());
-  size += ProtoSize::calc_bool(1, this->missing_state);
+  size += ProtoSize::calc_length(1, msg.state.size());
+  size += ProtoSize::calc_bool(1, msg.missing_state);
 #ifdef USE_DEVICES
-  size += ProtoSize::calc_uint32(1, this->device_id);
+  size += ProtoSize::calc_uint32(1, msg.device_id);
 #endif
   return size;
 }
@@ -1050,20 +1100,22 @@ bool SubscribeLogsRequest::decode_varint(uint32_t field_id, proto_varint_value_t
 }
 __attribute__((optimize("O2")))  // NOLINT(clang-diagnostic-unknown-attributes)
 uint8_t *
-SubscribeLogsResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+SubscribeLogsResponse::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const SubscribeLogsResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_uint32_force(pos PROTO_ENCODE_DEBUG_ARG, 1, static_cast<uint32_t>(this->level));
+  pos = ProtoEncode::encode_uint32_force(pos PROTO_ENCODE_DEBUG_ARG, 1, static_cast<uint32_t>(msg.level));
   pos = ProtoEncode::write_raw_byte(pos PROTO_ENCODE_DEBUG_ARG, 26);
-  pos = ProtoEncode::encode_varint_raw(pos PROTO_ENCODE_DEBUG_ARG, this->message_len_);
-  pos = ProtoEncode::encode_raw(pos PROTO_ENCODE_DEBUG_ARG, this->message_ptr_, this->message_len_);
+  pos = ProtoEncode::encode_varint_raw(pos PROTO_ENCODE_DEBUG_ARG, msg.message_len_);
+  pos = ProtoEncode::encode_raw(pos PROTO_ENCODE_DEBUG_ARG, msg.message_ptr_, msg.message_len_);
   return pos;
 }
 __attribute__((optimize("O2")))  // NOLINT(clang-diagnostic-unknown-attributes)
 uint32_t
-SubscribeLogsResponse::calculate_size() const {
+SubscribeLogsResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const SubscribeLogsResponse *>(self);
   uint32_t size = 0;
   size += 2;
-  size += ProtoSize::calc_length_force(1, this->message_len_);
+  size += ProtoSize::calc_length_force(1, msg.message_len_);
   return size;
 }
 #ifdef USE_API_NOISE
@@ -1079,81 +1131,88 @@ bool NoiseEncryptionSetKeyRequest::decode_length(uint32_t field_id, ProtoLengthD
   }
   return true;
 }
-uint8_t *NoiseEncryptionSetKeyResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *NoiseEncryptionSetKeyResponse::encode_msg(const void *self,
+                                                   ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const NoiseEncryptionSetKeyResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 1, this->success);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.success);
   return pos;
 }
-uint32_t NoiseEncryptionSetKeyResponse::calculate_size() const {
+uint32_t NoiseEncryptionSetKeyResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const NoiseEncryptionSetKeyResponse *>(self);
   uint32_t size = 0;
-  size += ProtoSize::calc_bool(1, this->success);
+  size += ProtoSize::calc_bool(1, msg.success);
   return size;
 }
 #endif
 #ifdef USE_API_HOMEASSISTANT_SERVICES
-uint8_t *HomeassistantServiceMap::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *HomeassistantServiceMap::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const HomeassistantServiceMap *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 1, this->key);
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 2, this->value);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.key);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 2, msg.value);
   return pos;
 }
-uint32_t HomeassistantServiceMap::calculate_size() const {
+uint32_t HomeassistantServiceMap::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const HomeassistantServiceMap *>(self);
   uint32_t size = 0;
-  size += ProtoSize::calc_length(1, this->key.size());
-  size += ProtoSize::calc_length(1, this->value.size());
+  size += ProtoSize::calc_length(1, msg.key.size());
+  size += ProtoSize::calc_length(1, msg.value.size());
   return size;
 }
-uint8_t *HomeassistantActionRequest::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *HomeassistantActionRequest::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const HomeassistantActionRequest *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 1, this->service);
-  for (auto &it : this->data) {
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.service);
+  for (auto &it : msg.data) {
     pos = ProtoEncode::encode_sub_message(pos PROTO_ENCODE_DEBUG_ARG, buffer, 2, it);
   }
-  for (auto &it : this->data_template) {
+  for (auto &it : msg.data_template) {
     pos = ProtoEncode::encode_sub_message(pos PROTO_ENCODE_DEBUG_ARG, buffer, 3, it);
   }
-  for (auto &it : this->variables) {
+  for (auto &it : msg.variables) {
     pos = ProtoEncode::encode_sub_message(pos PROTO_ENCODE_DEBUG_ARG, buffer, 4, it);
   }
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 5, this->is_event);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 5, msg.is_event);
 #ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 6, this->call_id);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 6, msg.call_id);
 #endif
 #ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 7, this->wants_response);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 7, msg.wants_response);
 #endif
 #ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 8, this->response_template);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 8, msg.response_template);
 #endif
   return pos;
 }
-uint32_t HomeassistantActionRequest::calculate_size() const {
+uint32_t HomeassistantActionRequest::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const HomeassistantActionRequest *>(self);
   uint32_t size = 0;
-  size += ProtoSize::calc_length(1, this->service.size());
-  if (!this->data.empty()) {
-    for (const auto &it : this->data) {
+  size += ProtoSize::calc_length(1, msg.service.size());
+  if (!msg.data.empty()) {
+    for (const auto &it : msg.data) {
       size += ProtoSize::calc_message_force(1, it.calculate_size());
     }
   }
-  if (!this->data_template.empty()) {
-    for (const auto &it : this->data_template) {
+  if (!msg.data_template.empty()) {
+    for (const auto &it : msg.data_template) {
       size += ProtoSize::calc_message_force(1, it.calculate_size());
     }
   }
-  if (!this->variables.empty()) {
-    for (const auto &it : this->variables) {
+  if (!msg.variables.empty()) {
+    for (const auto &it : msg.variables) {
       size += ProtoSize::calc_message_force(1, it.calculate_size());
     }
   }
-  size += ProtoSize::calc_bool(1, this->is_event);
+  size += ProtoSize::calc_bool(1, msg.is_event);
 #ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES
-  size += ProtoSize::calc_uint32(1, this->call_id);
+  size += ProtoSize::calc_uint32(1, msg.call_id);
 #endif
 #ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
-  size += ProtoSize::calc_bool(1, this->wants_response);
+  size += ProtoSize::calc_bool(1, msg.wants_response);
 #endif
 #ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
-  size += ProtoSize::calc_length(1, this->response_template.size());
+  size += ProtoSize::calc_length(1, msg.response_template.size());
 #endif
   return size;
 }
@@ -1192,18 +1251,21 @@ bool HomeassistantActionResponse::decode_length(uint32_t field_id, ProtoLengthDe
 }
 #endif
 #ifdef USE_API_HOMEASSISTANT_STATES
-uint8_t *SubscribeHomeAssistantStateResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *SubscribeHomeAssistantStateResponse::encode_msg(const void *self,
+                                                         ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const SubscribeHomeAssistantStateResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 1, this->entity_id);
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 2, this->attribute);
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 3, this->once);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.entity_id);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 2, msg.attribute);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 3, msg.once);
   return pos;
 }
-uint32_t SubscribeHomeAssistantStateResponse::calculate_size() const {
+uint32_t SubscribeHomeAssistantStateResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const SubscribeHomeAssistantStateResponse *>(self);
   uint32_t size = 0;
-  size += ProtoSize::calc_length(1, this->entity_id.size());
-  size += ProtoSize::calc_length(1, this->attribute.size());
-  size += ProtoSize::calc_bool(1, this->once);
+  size += ProtoSize::calc_length(1, msg.entity_id.size());
+  size += ProtoSize::calc_length(1, msg.attribute.size());
+  size += ProtoSize::calc_bool(1, msg.once);
   return size;
 }
 bool HomeAssistantStateResponse::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
@@ -1299,55 +1361,59 @@ bool GetTimeResponse::decode_32bit(uint32_t field_id, Proto32Bit value) {
   return true;
 }
 #ifdef USE_API_USER_DEFINED_ACTIONS
-uint8_t *ListEntitiesServicesArgument::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *ListEntitiesServicesArgument::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const ListEntitiesServicesArgument *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 1, this->name);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, static_cast<uint32_t>(this->type));
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.name);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, static_cast<uint32_t>(msg.type));
 #ifdef USE_API_USER_DEFINED_ACTION_METADATA
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 3, this->description);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 3, msg.description);
 #endif
 #ifdef USE_API_USER_DEFINED_ACTION_METADATA
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 4, this->example);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 4, msg.example);
 #endif
   return pos;
 }
-uint32_t ListEntitiesServicesArgument::calculate_size() const {
+uint32_t ListEntitiesServicesArgument::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const ListEntitiesServicesArgument *>(self);
   uint32_t size = 0;
-  size += ProtoSize::calc_length(1, this->name.size());
-  size += this->type ? 2 : 0;
+  size += ProtoSize::calc_length(1, msg.name.size());
+  size += msg.type ? 2 : 0;
 #ifdef USE_API_USER_DEFINED_ACTION_METADATA
-  size += ProtoSize::calc_length(1, this->description.size());
+  size += ProtoSize::calc_length(1, msg.description.size());
 #endif
 #ifdef USE_API_USER_DEFINED_ACTION_METADATA
-  size += ProtoSize::calc_length(1, this->example.size());
+  size += ProtoSize::calc_length(1, msg.example.size());
 #endif
   return size;
 }
-uint8_t *ListEntitiesServicesResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *ListEntitiesServicesResponse::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const ListEntitiesServicesResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 1, this->name);
-  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, this->key);
-  for (auto &it : this->args) {
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.name);
+  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, msg.key);
+  for (auto &it : msg.args) {
     pos = ProtoEncode::encode_sub_message(pos PROTO_ENCODE_DEBUG_ARG, buffer, 3, it);
   }
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 4, static_cast<uint32_t>(this->supports_response));
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 4, static_cast<uint32_t>(msg.supports_response));
 #ifdef USE_API_USER_DEFINED_ACTION_METADATA
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 5, this->description);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 5, msg.description);
 #endif
   return pos;
 }
-uint32_t ListEntitiesServicesResponse::calculate_size() const {
+uint32_t ListEntitiesServicesResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const ListEntitiesServicesResponse *>(self);
   uint32_t size = 0;
-  size += ProtoSize::calc_length(1, this->name.size());
+  size += ProtoSize::calc_length(1, msg.name.size());
   size += 5;
-  if (!this->args.empty()) {
-    for (const auto &it : this->args) {
+  if (!msg.args.empty()) {
+    for (const auto &it : msg.args) {
       size += ProtoSize::calc_message_force(1, it.calculate_size());
     }
   }
-  size += this->supports_response ? 2 : 0;
+  size += msg.supports_response ? 2 : 0;
 #ifdef USE_API_USER_DEFINED_ACTION_METADATA
-  size += ProtoSize::calc_length(1, this->description.size());
+  size += ProtoSize::calc_length(1, msg.description.size());
 #endif
   return size;
 }
@@ -1456,75 +1522,81 @@ void ExecuteServiceRequest::decode(const uint8_t *buffer, size_t length) {
 }
 #endif
 #ifdef USE_API_USER_DEFINED_ACTION_RESPONSES
-uint8_t *ExecuteServiceResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *ExecuteServiceResponse::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const ExecuteServiceResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 1, this->call_id);
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 2, this->success);
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 3, this->error_message);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.call_id);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 2, msg.success);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 3, msg.error_message);
 #ifdef USE_API_USER_DEFINED_ACTION_RESPONSES_JSON
-  pos = ProtoEncode::encode_bytes(pos PROTO_ENCODE_DEBUG_ARG, 4, this->response_data, this->response_data_len);
+  pos = ProtoEncode::encode_bytes(pos PROTO_ENCODE_DEBUG_ARG, 4, msg.response_data, msg.response_data_len);
 #endif
   return pos;
 }
-uint32_t ExecuteServiceResponse::calculate_size() const {
+uint32_t ExecuteServiceResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const ExecuteServiceResponse *>(self);
   uint32_t size = 0;
-  size += ProtoSize::calc_uint32(1, this->call_id);
-  size += ProtoSize::calc_bool(1, this->success);
-  size += ProtoSize::calc_length(1, this->error_message.size());
+  size += ProtoSize::calc_uint32(1, msg.call_id);
+  size += ProtoSize::calc_bool(1, msg.success);
+  size += ProtoSize::calc_length(1, msg.error_message.size());
 #ifdef USE_API_USER_DEFINED_ACTION_RESPONSES_JSON
-  size += ProtoSize::calc_length(1, this->response_data_len);
+  size += ProtoSize::calc_length(1, msg.response_data_len);
 #endif
   return size;
 }
 #endif
 #ifdef USE_CAMERA
-uint8_t *ListEntitiesCameraResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *ListEntitiesCameraResponse::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const ListEntitiesCameraResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 10, this->object_id);
-  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, this->key);
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, this->name);
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 5, this->disabled_by_default);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 10, msg.object_id);
+  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, msg.key);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, msg.name);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 5, msg.disabled_by_default);
 #ifdef USE_ENTITY_ICON
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 6, this->icon);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 6, msg.icon);
 #endif
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 7, static_cast<uint32_t>(this->entity_category));
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 7, static_cast<uint32_t>(msg.entity_category));
 #ifdef USE_DEVICES
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 8, this->device_id);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 8, msg.device_id);
 #endif
   return pos;
 }
-uint32_t ListEntitiesCameraResponse::calculate_size() const {
+uint32_t ListEntitiesCameraResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const ListEntitiesCameraResponse *>(self);
   uint32_t size = 0;
-  size += 2 + this->object_id.size();
+  size += 2 + msg.object_id.size();
   size += 5;
-  size += 2 + this->name.size();
-  size += ProtoSize::calc_bool(1, this->disabled_by_default);
+  size += 2 + msg.name.size();
+  size += ProtoSize::calc_bool(1, msg.disabled_by_default);
 #ifdef USE_ENTITY_ICON
-  size += !this->icon.empty() ? 2 + this->icon.size() : 0;
+  size += !msg.icon.empty() ? 2 + msg.icon.size() : 0;
 #endif
-  size += this->entity_category ? 2 : 0;
+  size += msg.entity_category ? 2 : 0;
 #ifdef USE_DEVICES
-  size += ProtoSize::calc_uint32(1, this->device_id);
+  size += ProtoSize::calc_uint32(1, msg.device_id);
 #endif
   return size;
 }
-uint8_t *CameraImageResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *CameraImageResponse::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const CameraImageResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 13, this->key);
-  pos = ProtoEncode::encode_bytes(pos PROTO_ENCODE_DEBUG_ARG, 2, this->data_ptr_, this->data_len_);
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 3, this->done);
+  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 13, msg.key);
+  pos = ProtoEncode::encode_bytes(pos PROTO_ENCODE_DEBUG_ARG, 2, msg.data_ptr_, msg.data_len_);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 3, msg.done);
 #ifdef USE_DEVICES
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 4, this->device_id);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 4, msg.device_id);
 #endif
   return pos;
 }
-uint32_t CameraImageResponse::calculate_size() const {
+uint32_t CameraImageResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const CameraImageResponse *>(self);
   uint32_t size = 0;
   size += 5;
-  size += ProtoSize::calc_length(1, this->data_len_);
-  size += ProtoSize::calc_bool(1, this->done);
+  size += ProtoSize::calc_length(1, msg.data_len_);
+  size += ProtoSize::calc_bool(1, msg.done);
 #ifdef USE_DEVICES
-  size += ProtoSize::calc_uint32(1, this->device_id);
+  size += ProtoSize::calc_uint32(1, msg.device_id);
 #endif
   return size;
 }
@@ -1543,159 +1615,163 @@ bool CameraImageRequest::decode_varint(uint32_t field_id, proto_varint_value_t v
 }
 #endif
 #ifdef USE_CLIMATE
-uint8_t *ListEntitiesClimateResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *ListEntitiesClimateResponse::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const ListEntitiesClimateResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 10, this->object_id);
-  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, this->key);
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, this->name);
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 5, this->supports_current_temperature);
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 6, this->supports_two_point_target_temperature);
-  for (const auto &it : *this->supported_modes) {
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 10, msg.object_id);
+  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, msg.key);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, msg.name);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 5, msg.supports_current_temperature);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 6, msg.supports_two_point_target_temperature);
+  for (const auto &it : *msg.supported_modes) {
     pos = ProtoEncode::encode_uint32_force(pos PROTO_ENCODE_DEBUG_ARG, 7, static_cast<uint32_t>(it));
   }
-  if (uint32_t raw = float_to_raw(this->visual_min_temperature); raw != 0) [[likely]] {
+  if (uint32_t raw = float_to_raw(msg.visual_min_temperature); raw != 0) [[likely]] {
     pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 69, raw);
   }
-  if (uint32_t raw = float_to_raw(this->visual_max_temperature); raw != 0) [[likely]] {
+  if (uint32_t raw = float_to_raw(msg.visual_max_temperature); raw != 0) [[likely]] {
     pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 77, raw);
   }
-  if (uint32_t raw = float_to_raw(this->visual_target_temperature_step); raw != 0) [[likely]] {
+  if (uint32_t raw = float_to_raw(msg.visual_target_temperature_step); raw != 0) [[likely]] {
     pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 85, raw);
   }
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 12, this->supports_action);
-  for (const auto &it : *this->supported_fan_modes) {
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 12, msg.supports_action);
+  for (const auto &it : *msg.supported_fan_modes) {
     pos = ProtoEncode::encode_uint32_force(pos PROTO_ENCODE_DEBUG_ARG, 13, static_cast<uint32_t>(it));
   }
-  for (const auto &it : *this->supported_swing_modes) {
+  for (const auto &it : *msg.supported_swing_modes) {
     pos = ProtoEncode::encode_uint32_force(pos PROTO_ENCODE_DEBUG_ARG, 14, static_cast<uint32_t>(it));
   }
-  for (const char *it : *this->supported_custom_fan_modes) {
+  for (const char *it : *msg.supported_custom_fan_modes) {
     pos = ProtoEncode::encode_string_force(pos PROTO_ENCODE_DEBUG_ARG, 15, it, strlen(it));
   }
-  for (const auto &it : *this->supported_presets) {
+  for (const auto &it : *msg.supported_presets) {
     pos = ProtoEncode::encode_uint32_force(pos PROTO_ENCODE_DEBUG_ARG, 16, static_cast<uint32_t>(it));
   }
-  for (const char *it : *this->supported_custom_presets) {
+  for (const char *it : *msg.supported_custom_presets) {
     pos = ProtoEncode::encode_string_force(pos PROTO_ENCODE_DEBUG_ARG, 17, it, strlen(it));
   }
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 18, this->disabled_by_default);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 18, msg.disabled_by_default);
 #ifdef USE_ENTITY_ICON
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 19, this->icon);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 19, msg.icon);
 #endif
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 20, static_cast<uint32_t>(this->entity_category));
-  pos = ProtoEncode::encode_float(pos PROTO_ENCODE_DEBUG_ARG, 21, this->visual_current_temperature_step);
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 22, this->supports_current_humidity);
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 23, this->supports_target_humidity);
-  pos = ProtoEncode::encode_float(pos PROTO_ENCODE_DEBUG_ARG, 24, this->visual_min_humidity);
-  pos = ProtoEncode::encode_float(pos PROTO_ENCODE_DEBUG_ARG, 25, this->visual_max_humidity);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 20, static_cast<uint32_t>(msg.entity_category));
+  pos = ProtoEncode::encode_float(pos PROTO_ENCODE_DEBUG_ARG, 21, msg.visual_current_temperature_step);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 22, msg.supports_current_humidity);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 23, msg.supports_target_humidity);
+  pos = ProtoEncode::encode_float(pos PROTO_ENCODE_DEBUG_ARG, 24, msg.visual_min_humidity);
+  pos = ProtoEncode::encode_float(pos PROTO_ENCODE_DEBUG_ARG, 25, msg.visual_max_humidity);
 #ifdef USE_DEVICES
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 26, this->device_id);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 26, msg.device_id);
 #endif
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 27, this->feature_flags);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 28, static_cast<uint32_t>(this->temperature_unit));
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 27, msg.feature_flags);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 28, static_cast<uint32_t>(msg.temperature_unit));
   return pos;
 }
-uint32_t ListEntitiesClimateResponse::calculate_size() const {
+uint32_t ListEntitiesClimateResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const ListEntitiesClimateResponse *>(self);
   uint32_t size = 0;
-  size += 2 + this->object_id.size();
+  size += 2 + msg.object_id.size();
   size += 5;
-  size += 2 + this->name.size();
-  size += ProtoSize::calc_bool(1, this->supports_current_temperature);
-  size += ProtoSize::calc_bool(1, this->supports_two_point_target_temperature);
-  if (!this->supported_modes->empty()) {
-    size += this->supported_modes->size() * 2;
+  size += 2 + msg.name.size();
+  size += ProtoSize::calc_bool(1, msg.supports_current_temperature);
+  size += ProtoSize::calc_bool(1, msg.supports_two_point_target_temperature);
+  if (!msg.supported_modes->empty()) {
+    size += msg.supported_modes->size() * 2;
   }
-  size += ProtoSize::calc_float(1, this->visual_min_temperature);
-  size += ProtoSize::calc_float(1, this->visual_max_temperature);
-  size += ProtoSize::calc_float(1, this->visual_target_temperature_step);
-  size += ProtoSize::calc_bool(1, this->supports_action);
-  if (!this->supported_fan_modes->empty()) {
-    size += this->supported_fan_modes->size() * 2;
+  size += ProtoSize::calc_float(1, msg.visual_min_temperature);
+  size += ProtoSize::calc_float(1, msg.visual_max_temperature);
+  size += ProtoSize::calc_float(1, msg.visual_target_temperature_step);
+  size += ProtoSize::calc_bool(1, msg.supports_action);
+  if (!msg.supported_fan_modes->empty()) {
+    size += msg.supported_fan_modes->size() * 2;
   }
-  if (!this->supported_swing_modes->empty()) {
-    size += this->supported_swing_modes->size() * 2;
+  if (!msg.supported_swing_modes->empty()) {
+    size += msg.supported_swing_modes->size() * 2;
   }
-  if (!this->supported_custom_fan_modes->empty()) {
-    for (const char *it : *this->supported_custom_fan_modes) {
+  if (!msg.supported_custom_fan_modes->empty()) {
+    for (const char *it : *msg.supported_custom_fan_modes) {
       size += ProtoSize::calc_length_force(1, strlen(it));
     }
   }
-  if (!this->supported_presets->empty()) {
-    size += this->supported_presets->size() * 3;
+  if (!msg.supported_presets->empty()) {
+    size += msg.supported_presets->size() * 3;
   }
-  if (!this->supported_custom_presets->empty()) {
-    for (const char *it : *this->supported_custom_presets) {
+  if (!msg.supported_custom_presets->empty()) {
+    for (const char *it : *msg.supported_custom_presets) {
       size += ProtoSize::calc_length_force(2, strlen(it));
     }
   }
-  size += ProtoSize::calc_bool(2, this->disabled_by_default);
+  size += ProtoSize::calc_bool(2, msg.disabled_by_default);
 #ifdef USE_ENTITY_ICON
-  size += !this->icon.empty() ? 3 + this->icon.size() : 0;
+  size += !msg.icon.empty() ? 3 + msg.icon.size() : 0;
 #endif
-  size += this->entity_category ? 3 : 0;
-  size += ProtoSize::calc_float(2, this->visual_current_temperature_step);
-  size += ProtoSize::calc_bool(2, this->supports_current_humidity);
-  size += ProtoSize::calc_bool(2, this->supports_target_humidity);
-  size += ProtoSize::calc_float(2, this->visual_min_humidity);
-  size += ProtoSize::calc_float(2, this->visual_max_humidity);
+  size += msg.entity_category ? 3 : 0;
+  size += ProtoSize::calc_float(2, msg.visual_current_temperature_step);
+  size += ProtoSize::calc_bool(2, msg.supports_current_humidity);
+  size += ProtoSize::calc_bool(2, msg.supports_target_humidity);
+  size += ProtoSize::calc_float(2, msg.visual_min_humidity);
+  size += ProtoSize::calc_float(2, msg.visual_max_humidity);
 #ifdef USE_DEVICES
-  size += ProtoSize::calc_uint32(2, this->device_id);
+  size += ProtoSize::calc_uint32(2, msg.device_id);
 #endif
-  size += ProtoSize::calc_uint32(2, this->feature_flags);
-  size += this->temperature_unit ? 3 : 0;
+  size += ProtoSize::calc_uint32(2, msg.feature_flags);
+  size += msg.temperature_unit ? 3 : 0;
   return size;
 }
-uint8_t *ClimateStateResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *ClimateStateResponse::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const ClimateStateResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 13, this->key);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, static_cast<uint32_t>(this->mode));
-  if (uint32_t raw = float_to_raw(this->current_temperature); raw != 0) [[likely]] {
+  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 13, msg.key);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, static_cast<uint32_t>(msg.mode));
+  if (uint32_t raw = float_to_raw(msg.current_temperature); raw != 0) [[likely]] {
     pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 29, raw);
   }
-  if (uint32_t raw = float_to_raw(this->target_temperature); raw != 0) [[likely]] {
+  if (uint32_t raw = float_to_raw(msg.target_temperature); raw != 0) [[likely]] {
     pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 37, raw);
   }
-  if (uint32_t raw = float_to_raw(this->target_temperature_low); raw != 0) [[likely]] {
+  if (uint32_t raw = float_to_raw(msg.target_temperature_low); raw != 0) [[likely]] {
     pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 45, raw);
   }
-  if (uint32_t raw = float_to_raw(this->target_temperature_high); raw != 0) [[likely]] {
+  if (uint32_t raw = float_to_raw(msg.target_temperature_high); raw != 0) [[likely]] {
     pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 53, raw);
   }
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 8, static_cast<uint32_t>(this->action));
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 9, static_cast<uint32_t>(this->fan_mode));
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 10, static_cast<uint32_t>(this->swing_mode));
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 11, this->custom_fan_mode);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 12, static_cast<uint32_t>(this->preset));
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 13, this->custom_preset);
-  if (uint32_t raw = float_to_raw(this->current_humidity); raw != 0) [[likely]] {
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 8, static_cast<uint32_t>(msg.action));
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 9, static_cast<uint32_t>(msg.fan_mode));
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 10, static_cast<uint32_t>(msg.swing_mode));
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 11, msg.custom_fan_mode);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 12, static_cast<uint32_t>(msg.preset));
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 13, msg.custom_preset);
+  if (uint32_t raw = float_to_raw(msg.current_humidity); raw != 0) [[likely]] {
     pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 117, raw);
   }
-  if (uint32_t raw = float_to_raw(this->target_humidity); raw != 0) [[likely]] {
+  if (uint32_t raw = float_to_raw(msg.target_humidity); raw != 0) [[likely]] {
     pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 125, raw);
   }
 #ifdef USE_DEVICES
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 16, this->device_id);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 16, msg.device_id);
 #endif
   return pos;
 }
-uint32_t ClimateStateResponse::calculate_size() const {
+uint32_t ClimateStateResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const ClimateStateResponse *>(self);
   uint32_t size = 0;
   size += 5;
-  size += this->mode ? 2 : 0;
-  size += ProtoSize::calc_float(1, this->current_temperature);
-  size += ProtoSize::calc_float(1, this->target_temperature);
-  size += ProtoSize::calc_float(1, this->target_temperature_low);
-  size += ProtoSize::calc_float(1, this->target_temperature_high);
-  size += this->action ? 2 : 0;
-  size += this->fan_mode ? 2 : 0;
-  size += this->swing_mode ? 2 : 0;
-  size += ProtoSize::calc_length(1, this->custom_fan_mode.size());
-  size += this->preset ? 2 : 0;
-  size += ProtoSize::calc_length(1, this->custom_preset.size());
-  size += ProtoSize::calc_float(1, this->current_humidity);
-  size += ProtoSize::calc_float(1, this->target_humidity);
+  size += msg.mode ? 2 : 0;
+  size += ProtoSize::calc_float(1, msg.current_temperature);
+  size += ProtoSize::calc_float(1, msg.target_temperature);
+  size += ProtoSize::calc_float(1, msg.target_temperature_low);
+  size += ProtoSize::calc_float(1, msg.target_temperature_high);
+  size += msg.action ? 2 : 0;
+  size += msg.fan_mode ? 2 : 0;
+  size += msg.swing_mode ? 2 : 0;
+  size += ProtoSize::calc_length(1, msg.custom_fan_mode.size());
+  size += msg.preset ? 2 : 0;
+  size += ProtoSize::calc_length(1, msg.custom_preset.size());
+  size += ProtoSize::calc_float(1, msg.current_humidity);
+  size += ProtoSize::calc_float(1, msg.target_humidity);
 #ifdef USE_DEVICES
-  size += ProtoSize::calc_uint32(2, this->device_id);
+  size += ProtoSize::calc_uint32(2, msg.device_id);
 #endif
   return size;
 }
@@ -1792,92 +1868,97 @@ bool ClimateCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
 }
 #endif
 #ifdef USE_WATER_HEATER
-uint8_t *ListEntitiesWaterHeaterResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *ListEntitiesWaterHeaterResponse::encode_msg(const void *self,
+                                                     ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const ListEntitiesWaterHeaterResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 10, this->object_id);
-  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, this->key);
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, this->name);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 10, msg.object_id);
+  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, msg.key);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, msg.name);
 #ifdef USE_ENTITY_ICON
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 4, this->icon);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 4, msg.icon);
 #endif
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 5, this->disabled_by_default);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 6, static_cast<uint32_t>(this->entity_category));
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 5, msg.disabled_by_default);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 6, static_cast<uint32_t>(msg.entity_category));
 #ifdef USE_DEVICES
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 7, this->device_id);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 7, msg.device_id);
 #endif
-  if (uint32_t raw = float_to_raw(this->min_temperature); raw != 0) [[likely]] {
+  if (uint32_t raw = float_to_raw(msg.min_temperature); raw != 0) [[likely]] {
     pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 69, raw);
   }
-  if (uint32_t raw = float_to_raw(this->max_temperature); raw != 0) [[likely]] {
+  if (uint32_t raw = float_to_raw(msg.max_temperature); raw != 0) [[likely]] {
     pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 77, raw);
   }
-  if (uint32_t raw = float_to_raw(this->target_temperature_step); raw != 0) [[likely]] {
+  if (uint32_t raw = float_to_raw(msg.target_temperature_step); raw != 0) [[likely]] {
     pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 85, raw);
   }
-  for (const auto &it : *this->supported_modes) {
+  for (const auto &it : *msg.supported_modes) {
     pos = ProtoEncode::encode_uint32_force(pos PROTO_ENCODE_DEBUG_ARG, 11, static_cast<uint32_t>(it));
   }
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 12, this->supported_features);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 13, static_cast<uint32_t>(this->temperature_unit));
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 12, msg.supported_features);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 13, static_cast<uint32_t>(msg.temperature_unit));
   return pos;
 }
-uint32_t ListEntitiesWaterHeaterResponse::calculate_size() const {
+uint32_t ListEntitiesWaterHeaterResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const ListEntitiesWaterHeaterResponse *>(self);
   uint32_t size = 0;
-  size += 2 + this->object_id.size();
+  size += 2 + msg.object_id.size();
   size += 5;
-  size += 2 + this->name.size();
+  size += 2 + msg.name.size();
 #ifdef USE_ENTITY_ICON
-  size += !this->icon.empty() ? 2 + this->icon.size() : 0;
+  size += !msg.icon.empty() ? 2 + msg.icon.size() : 0;
 #endif
-  size += ProtoSize::calc_bool(1, this->disabled_by_default);
-  size += this->entity_category ? 2 : 0;
+  size += ProtoSize::calc_bool(1, msg.disabled_by_default);
+  size += msg.entity_category ? 2 : 0;
 #ifdef USE_DEVICES
-  size += ProtoSize::calc_uint32(1, this->device_id);
+  size += ProtoSize::calc_uint32(1, msg.device_id);
 #endif
-  size += ProtoSize::calc_float(1, this->min_temperature);
-  size += ProtoSize::calc_float(1, this->max_temperature);
-  size += ProtoSize::calc_float(1, this->target_temperature_step);
-  if (!this->supported_modes->empty()) {
-    size += this->supported_modes->size() * 2;
+  size += ProtoSize::calc_float(1, msg.min_temperature);
+  size += ProtoSize::calc_float(1, msg.max_temperature);
+  size += ProtoSize::calc_float(1, msg.target_temperature_step);
+  if (!msg.supported_modes->empty()) {
+    size += msg.supported_modes->size() * 2;
   }
-  size += ProtoSize::calc_uint32(1, this->supported_features);
-  size += this->temperature_unit ? 2 : 0;
+  size += ProtoSize::calc_uint32(1, msg.supported_features);
+  size += msg.temperature_unit ? 2 : 0;
   return size;
 }
-uint8_t *WaterHeaterStateResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *WaterHeaterStateResponse::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const WaterHeaterStateResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 13, this->key);
-  if (uint32_t raw = float_to_raw(this->current_temperature); raw != 0) [[likely]] {
+  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 13, msg.key);
+  if (uint32_t raw = float_to_raw(msg.current_temperature); raw != 0) [[likely]] {
     pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, raw);
   }
-  if (uint32_t raw = float_to_raw(this->target_temperature); raw != 0) [[likely]] {
+  if (uint32_t raw = float_to_raw(msg.target_temperature); raw != 0) [[likely]] {
     pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 29, raw);
   }
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 4, static_cast<uint32_t>(this->mode));
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 4, static_cast<uint32_t>(msg.mode));
 #ifdef USE_DEVICES
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 5, this->device_id);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 5, msg.device_id);
 #endif
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 6, this->state);
-  if (uint32_t raw = float_to_raw(this->target_temperature_low); raw != 0) [[likely]] {
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 6, msg.state);
+  if (uint32_t raw = float_to_raw(msg.target_temperature_low); raw != 0) [[likely]] {
     pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 61, raw);
   }
-  if (uint32_t raw = float_to_raw(this->target_temperature_high); raw != 0) [[likely]] {
+  if (uint32_t raw = float_to_raw(msg.target_temperature_high); raw != 0) [[likely]] {
     pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 69, raw);
   }
   return pos;
 }
-uint32_t WaterHeaterStateResponse::calculate_size() const {
+uint32_t WaterHeaterStateResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const WaterHeaterStateResponse *>(self);
   uint32_t size = 0;
   size += 5;
-  size += ProtoSize::calc_float(1, this->current_temperature);
-  size += ProtoSize::calc_float(1, this->target_temperature);
-  size += this->mode ? 2 : 0;
+  size += ProtoSize::calc_float(1, msg.current_temperature);
+  size += ProtoSize::calc_float(1, msg.target_temperature);
+  size += msg.mode ? 2 : 0;
 #ifdef USE_DEVICES
-  size += ProtoSize::calc_uint32(1, this->device_id);
+  size += ProtoSize::calc_uint32(1, msg.device_id);
 #endif
-  size += ProtoSize::calc_uint32(1, this->state);
-  size += ProtoSize::calc_float(1, this->target_temperature_low);
-  size += ProtoSize::calc_float(1, this->target_temperature_high);
+  size += ProtoSize::calc_uint32(1, msg.state);
+  size += ProtoSize::calc_float(1, msg.target_temperature_low);
+  size += ProtoSize::calc_float(1, msg.target_temperature_high);
   return size;
 }
 bool WaterHeaterCommandRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
@@ -1922,73 +2003,77 @@ bool WaterHeaterCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value
 }
 #endif
 #ifdef USE_NUMBER
-uint8_t *ListEntitiesNumberResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *ListEntitiesNumberResponse::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const ListEntitiesNumberResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 10, this->object_id);
-  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, this->key);
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, this->name);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 10, msg.object_id);
+  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, msg.key);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, msg.name);
 #ifdef USE_ENTITY_ICON
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 5, this->icon);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 5, msg.icon);
 #endif
-  if (uint32_t raw = float_to_raw(this->min_value); raw != 0) [[likely]] {
+  if (uint32_t raw = float_to_raw(msg.min_value); raw != 0) [[likely]] {
     pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 53, raw);
   }
-  if (uint32_t raw = float_to_raw(this->max_value); raw != 0) [[likely]] {
+  if (uint32_t raw = float_to_raw(msg.max_value); raw != 0) [[likely]] {
     pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 61, raw);
   }
-  if (uint32_t raw = float_to_raw(this->step); raw != 0) [[likely]] {
+  if (uint32_t raw = float_to_raw(msg.step); raw != 0) [[likely]] {
     pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 69, raw);
   }
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 9, this->disabled_by_default);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 10, static_cast<uint32_t>(this->entity_category));
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 11, this->unit_of_measurement);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 12, static_cast<uint32_t>(this->mode));
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 13, this->device_class);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 9, msg.disabled_by_default);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 10, static_cast<uint32_t>(msg.entity_category));
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 11, msg.unit_of_measurement);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 12, static_cast<uint32_t>(msg.mode));
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 13, msg.device_class);
 #ifdef USE_DEVICES
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 14, this->device_id);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 14, msg.device_id);
 #endif
   return pos;
 }
-uint32_t ListEntitiesNumberResponse::calculate_size() const {
+uint32_t ListEntitiesNumberResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const ListEntitiesNumberResponse *>(self);
   uint32_t size = 0;
-  size += 2 + this->object_id.size();
+  size += 2 + msg.object_id.size();
   size += 5;
-  size += 2 + this->name.size();
+  size += 2 + msg.name.size();
 #ifdef USE_ENTITY_ICON
-  size += !this->icon.empty() ? 2 + this->icon.size() : 0;
+  size += !msg.icon.empty() ? 2 + msg.icon.size() : 0;
 #endif
-  size += ProtoSize::calc_float(1, this->min_value);
-  size += ProtoSize::calc_float(1, this->max_value);
-  size += ProtoSize::calc_float(1, this->step);
-  size += ProtoSize::calc_bool(1, this->disabled_by_default);
-  size += this->entity_category ? 2 : 0;
-  size += !this->unit_of_measurement.empty() ? 2 + this->unit_of_measurement.size() : 0;
-  size += this->mode ? 2 : 0;
-  size += !this->device_class.empty() ? 2 + this->device_class.size() : 0;
+  size += ProtoSize::calc_float(1, msg.min_value);
+  size += ProtoSize::calc_float(1, msg.max_value);
+  size += ProtoSize::calc_float(1, msg.step);
+  size += ProtoSize::calc_bool(1, msg.disabled_by_default);
+  size += msg.entity_category ? 2 : 0;
+  size += !msg.unit_of_measurement.empty() ? 2 + msg.unit_of_measurement.size() : 0;
+  size += msg.mode ? 2 : 0;
+  size += !msg.device_class.empty() ? 2 + msg.device_class.size() : 0;
 #ifdef USE_DEVICES
-  size += ProtoSize::calc_uint32(1, this->device_id);
+  size += ProtoSize::calc_uint32(1, msg.device_id);
 #endif
   return size;
 }
-uint8_t *NumberStateResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *NumberStateResponse::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const NumberStateResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 13, this->key);
-  if (uint32_t raw = float_to_raw(this->state); raw != 0) [[likely]] {
+  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 13, msg.key);
+  if (uint32_t raw = float_to_raw(msg.state); raw != 0) [[likely]] {
     pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, raw);
   }
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 3, this->missing_state);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 3, msg.missing_state);
 #ifdef USE_DEVICES
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 4, this->device_id);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 4, msg.device_id);
 #endif
   return pos;
 }
-uint32_t NumberStateResponse::calculate_size() const {
+uint32_t NumberStateResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const NumberStateResponse *>(self);
   uint32_t size = 0;
   size += 5;
-  size += ProtoSize::calc_float(1, this->state);
-  size += ProtoSize::calc_bool(1, this->missing_state);
+  size += ProtoSize::calc_float(1, msg.state);
+  size += ProtoSize::calc_bool(1, msg.missing_state);
 #ifdef USE_DEVICES
-  size += ProtoSize::calc_uint32(1, this->device_id);
+  size += ProtoSize::calc_uint32(1, msg.device_id);
 #endif
   return size;
 }
@@ -2019,61 +2104,65 @@ bool NumberCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
 }
 #endif
 #ifdef USE_SELECT
-uint8_t *ListEntitiesSelectResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *ListEntitiesSelectResponse::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const ListEntitiesSelectResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 10, this->object_id);
-  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, this->key);
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, this->name);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 10, msg.object_id);
+  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, msg.key);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, msg.name);
 #ifdef USE_ENTITY_ICON
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 5, this->icon);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 5, msg.icon);
 #endif
-  for (const char *it : *this->options) {
+  for (const char *it : *msg.options) {
     pos = ProtoEncode::encode_string_force(pos PROTO_ENCODE_DEBUG_ARG, 6, it, strlen(it));
   }
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 7, this->disabled_by_default);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 8, static_cast<uint32_t>(this->entity_category));
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 7, msg.disabled_by_default);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 8, static_cast<uint32_t>(msg.entity_category));
 #ifdef USE_DEVICES
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 9, this->device_id);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 9, msg.device_id);
 #endif
   return pos;
 }
-uint32_t ListEntitiesSelectResponse::calculate_size() const {
+uint32_t ListEntitiesSelectResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const ListEntitiesSelectResponse *>(self);
   uint32_t size = 0;
-  size += 2 + this->object_id.size();
+  size += 2 + msg.object_id.size();
   size += 5;
-  size += 2 + this->name.size();
+  size += 2 + msg.name.size();
 #ifdef USE_ENTITY_ICON
-  size += !this->icon.empty() ? 2 + this->icon.size() : 0;
+  size += !msg.icon.empty() ? 2 + msg.icon.size() : 0;
 #endif
-  if (!this->options->empty()) {
-    for (const char *it : *this->options) {
+  if (!msg.options->empty()) {
+    for (const char *it : *msg.options) {
       size += ProtoSize::calc_length_force(1, strlen(it));
     }
   }
-  size += ProtoSize::calc_bool(1, this->disabled_by_default);
-  size += this->entity_category ? 2 : 0;
+  size += ProtoSize::calc_bool(1, msg.disabled_by_default);
+  size += msg.entity_category ? 2 : 0;
 #ifdef USE_DEVICES
-  size += ProtoSize::calc_uint32(1, this->device_id);
+  size += ProtoSize::calc_uint32(1, msg.device_id);
 #endif
   return size;
 }
-uint8_t *SelectStateResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *SelectStateResponse::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const SelectStateResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 13, this->key);
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 2, this->state);
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 3, this->missing_state);
+  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 13, msg.key);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 2, msg.state);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 3, msg.missing_state);
 #ifdef USE_DEVICES
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 4, this->device_id);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 4, msg.device_id);
 #endif
   return pos;
 }
-uint32_t SelectStateResponse::calculate_size() const {
+uint32_t SelectStateResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const SelectStateResponse *>(self);
   uint32_t size = 0;
   size += 5;
-  size += ProtoSize::calc_length(1, this->state.size());
-  size += ProtoSize::calc_bool(1, this->missing_state);
+  size += ProtoSize::calc_length(1, msg.state.size());
+  size += ProtoSize::calc_bool(1, msg.missing_state);
 #ifdef USE_DEVICES
-  size += ProtoSize::calc_uint32(1, this->device_id);
+  size += ProtoSize::calc_uint32(1, msg.device_id);
 #endif
   return size;
 }
@@ -2112,63 +2201,67 @@ bool SelectCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
 }
 #endif
 #ifdef USE_SIREN
-uint8_t *ListEntitiesSirenResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *ListEntitiesSirenResponse::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const ListEntitiesSirenResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 10, this->object_id);
-  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, this->key);
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, this->name);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 10, msg.object_id);
+  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, msg.key);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, msg.name);
 #ifdef USE_ENTITY_ICON
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 5, this->icon);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 5, msg.icon);
 #endif
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 6, this->disabled_by_default);
-  for (const char *it : *this->tones) {
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 6, msg.disabled_by_default);
+  for (const char *it : *msg.tones) {
     pos = ProtoEncode::encode_string_force(pos PROTO_ENCODE_DEBUG_ARG, 7, it, strlen(it));
   }
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 8, this->supports_duration);
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 9, this->supports_volume);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 10, static_cast<uint32_t>(this->entity_category));
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 8, msg.supports_duration);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 9, msg.supports_volume);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 10, static_cast<uint32_t>(msg.entity_category));
 #ifdef USE_DEVICES
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 11, this->device_id);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 11, msg.device_id);
 #endif
   return pos;
 }
-uint32_t ListEntitiesSirenResponse::calculate_size() const {
+uint32_t ListEntitiesSirenResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const ListEntitiesSirenResponse *>(self);
   uint32_t size = 0;
-  size += 2 + this->object_id.size();
+  size += 2 + msg.object_id.size();
   size += 5;
-  size += 2 + this->name.size();
+  size += 2 + msg.name.size();
 #ifdef USE_ENTITY_ICON
-  size += !this->icon.empty() ? 2 + this->icon.size() : 0;
+  size += !msg.icon.empty() ? 2 + msg.icon.size() : 0;
 #endif
-  size += ProtoSize::calc_bool(1, this->disabled_by_default);
-  if (!this->tones->empty()) {
-    for (const char *it : *this->tones) {
+  size += ProtoSize::calc_bool(1, msg.disabled_by_default);
+  if (!msg.tones->empty()) {
+    for (const char *it : *msg.tones) {
       size += ProtoSize::calc_length_force(1, strlen(it));
     }
   }
-  size += ProtoSize::calc_bool(1, this->supports_duration);
-  size += ProtoSize::calc_bool(1, this->supports_volume);
-  size += this->entity_category ? 2 : 0;
+  size += ProtoSize::calc_bool(1, msg.supports_duration);
+  size += ProtoSize::calc_bool(1, msg.supports_volume);
+  size += msg.entity_category ? 2 : 0;
 #ifdef USE_DEVICES
-  size += ProtoSize::calc_uint32(1, this->device_id);
+  size += ProtoSize::calc_uint32(1, msg.device_id);
 #endif
   return size;
 }
-uint8_t *SirenStateResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *SirenStateResponse::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const SirenStateResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 13, this->key);
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 2, this->state);
+  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 13, msg.key);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 2, msg.state);
 #ifdef USE_DEVICES
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 3, this->device_id);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 3, msg.device_id);
 #endif
   return pos;
 }
-uint32_t SirenStateResponse::calculate_size() const {
+uint32_t SirenStateResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const SirenStateResponse *>(self);
   uint32_t size = 0;
   size += 5;
-  size += ProtoSize::calc_bool(1, this->state);
+  size += ProtoSize::calc_bool(1, msg.state);
 #ifdef USE_DEVICES
-  size += ProtoSize::calc_uint32(1, this->device_id);
+  size += ProtoSize::calc_uint32(1, msg.device_id);
 #endif
   return size;
 }
@@ -2228,59 +2321,63 @@ bool SirenCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
 }
 #endif
 #ifdef USE_LOCK
-uint8_t *ListEntitiesLockResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *ListEntitiesLockResponse::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const ListEntitiesLockResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 10, this->object_id);
-  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, this->key);
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, this->name);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 10, msg.object_id);
+  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, msg.key);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, msg.name);
 #ifdef USE_ENTITY_ICON
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 5, this->icon);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 5, msg.icon);
 #endif
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 6, this->disabled_by_default);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 7, static_cast<uint32_t>(this->entity_category));
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 8, this->assumed_state);
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 9, this->supports_open);
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 10, this->requires_code);
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 11, this->code_format);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 6, msg.disabled_by_default);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 7, static_cast<uint32_t>(msg.entity_category));
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 8, msg.assumed_state);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 9, msg.supports_open);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 10, msg.requires_code);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 11, msg.code_format);
 #ifdef USE_DEVICES
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 12, this->device_id);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 12, msg.device_id);
 #endif
   return pos;
 }
-uint32_t ListEntitiesLockResponse::calculate_size() const {
+uint32_t ListEntitiesLockResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const ListEntitiesLockResponse *>(self);
   uint32_t size = 0;
-  size += 2 + this->object_id.size();
+  size += 2 + msg.object_id.size();
   size += 5;
-  size += 2 + this->name.size();
+  size += 2 + msg.name.size();
 #ifdef USE_ENTITY_ICON
-  size += !this->icon.empty() ? 2 + this->icon.size() : 0;
+  size += !msg.icon.empty() ? 2 + msg.icon.size() : 0;
 #endif
-  size += ProtoSize::calc_bool(1, this->disabled_by_default);
-  size += this->entity_category ? 2 : 0;
-  size += ProtoSize::calc_bool(1, this->assumed_state);
-  size += ProtoSize::calc_bool(1, this->supports_open);
-  size += ProtoSize::calc_bool(1, this->requires_code);
-  size += ProtoSize::calc_length(1, this->code_format.size());
+  size += ProtoSize::calc_bool(1, msg.disabled_by_default);
+  size += msg.entity_category ? 2 : 0;
+  size += ProtoSize::calc_bool(1, msg.assumed_state);
+  size += ProtoSize::calc_bool(1, msg.supports_open);
+  size += ProtoSize::calc_bool(1, msg.requires_code);
+  size += ProtoSize::calc_length(1, msg.code_format.size());
 #ifdef USE_DEVICES
-  size += ProtoSize::calc_uint32(1, this->device_id);
+  size += ProtoSize::calc_uint32(1, msg.device_id);
 #endif
   return size;
 }
-uint8_t *LockStateResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *LockStateResponse::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const LockStateResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 13, this->key);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, static_cast<uint32_t>(this->state));
+  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 13, msg.key);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, static_cast<uint32_t>(msg.state));
 #ifdef USE_DEVICES
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 3, this->device_id);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 3, msg.device_id);
 #endif
   return pos;
 }
-uint32_t LockStateResponse::calculate_size() const {
+uint32_t LockStateResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const LockStateResponse *>(self);
   uint32_t size = 0;
   size += 5;
-  size += this->state ? 2 : 0;
+  size += msg.state ? 2 : 0;
 #ifdef USE_DEVICES
-  size += ProtoSize::calc_uint32(1, this->device_id);
+  size += ProtoSize::calc_uint32(1, msg.device_id);
 #endif
   return size;
 }
@@ -2325,35 +2422,37 @@ bool LockCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
 }
 #endif
 #ifdef USE_BUTTON
-uint8_t *ListEntitiesButtonResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *ListEntitiesButtonResponse::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const ListEntitiesButtonResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 10, this->object_id);
-  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, this->key);
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, this->name);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 10, msg.object_id);
+  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, msg.key);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, msg.name);
 #ifdef USE_ENTITY_ICON
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 5, this->icon);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 5, msg.icon);
 #endif
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 6, this->disabled_by_default);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 7, static_cast<uint32_t>(this->entity_category));
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 8, this->device_class);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 6, msg.disabled_by_default);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 7, static_cast<uint32_t>(msg.entity_category));
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 8, msg.device_class);
 #ifdef USE_DEVICES
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 9, this->device_id);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 9, msg.device_id);
 #endif
   return pos;
 }
-uint32_t ListEntitiesButtonResponse::calculate_size() const {
+uint32_t ListEntitiesButtonResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const ListEntitiesButtonResponse *>(self);
   uint32_t size = 0;
-  size += 2 + this->object_id.size();
+  size += 2 + msg.object_id.size();
   size += 5;
-  size += 2 + this->name.size();
+  size += 2 + msg.name.size();
 #ifdef USE_ENTITY_ICON
-  size += !this->icon.empty() ? 2 + this->icon.size() : 0;
+  size += !msg.icon.empty() ? 2 + msg.icon.size() : 0;
 #endif
-  size += ProtoSize::calc_bool(1, this->disabled_by_default);
-  size += this->entity_category ? 2 : 0;
-  size += !this->device_class.empty() ? 2 + this->device_class.size() : 0;
+  size += ProtoSize::calc_bool(1, msg.disabled_by_default);
+  size += msg.entity_category ? 2 : 0;
+  size += !msg.device_class.empty() ? 2 + msg.device_class.size() : 0;
 #ifdef USE_DEVICES
-  size += ProtoSize::calc_uint32(1, this->device_id);
+  size += ProtoSize::calc_uint32(1, msg.device_id);
 #endif
   return size;
 }
@@ -2381,85 +2480,92 @@ bool ButtonCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
 }
 #endif
 #ifdef USE_MEDIA_PLAYER
-uint8_t *MediaPlayerSupportedFormat::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *MediaPlayerSupportedFormat::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const MediaPlayerSupportedFormat *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 1, this->format);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, this->sample_rate);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 3, this->num_channels);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 4, static_cast<uint32_t>(this->purpose));
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 5, this->sample_bytes);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.format);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, msg.sample_rate);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 3, msg.num_channels);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 4, static_cast<uint32_t>(msg.purpose));
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 5, msg.sample_bytes);
   return pos;
 }
-uint32_t MediaPlayerSupportedFormat::calculate_size() const {
+uint32_t MediaPlayerSupportedFormat::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const MediaPlayerSupportedFormat *>(self);
   uint32_t size = 0;
-  size += ProtoSize::calc_length(1, this->format.size());
-  size += ProtoSize::calc_uint32(1, this->sample_rate);
-  size += ProtoSize::calc_uint32(1, this->num_channels);
-  size += this->purpose ? 2 : 0;
-  size += ProtoSize::calc_uint32(1, this->sample_bytes);
+  size += ProtoSize::calc_length(1, msg.format.size());
+  size += ProtoSize::calc_uint32(1, msg.sample_rate);
+  size += ProtoSize::calc_uint32(1, msg.num_channels);
+  size += msg.purpose ? 2 : 0;
+  size += ProtoSize::calc_uint32(1, msg.sample_bytes);
   return size;
 }
-uint8_t *ListEntitiesMediaPlayerResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *ListEntitiesMediaPlayerResponse::encode_msg(const void *self,
+                                                     ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const ListEntitiesMediaPlayerResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 10, this->object_id);
-  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, this->key);
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, this->name);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 10, msg.object_id);
+  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, msg.key);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, msg.name);
 #ifdef USE_ENTITY_ICON
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 5, this->icon);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 5, msg.icon);
 #endif
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 6, this->disabled_by_default);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 7, static_cast<uint32_t>(this->entity_category));
-  for (auto &it : this->supported_formats) {
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 6, msg.disabled_by_default);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 7, static_cast<uint32_t>(msg.entity_category));
+  for (auto &it : msg.supported_formats) {
     pos = ProtoEncode::encode_sub_message(pos PROTO_ENCODE_DEBUG_ARG, buffer, 9, it);
   }
 #ifdef USE_DEVICES
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 10, this->device_id);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 10, msg.device_id);
 #endif
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 11, this->feature_flags);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 11, msg.feature_flags);
   return pos;
 }
-uint32_t ListEntitiesMediaPlayerResponse::calculate_size() const {
+uint32_t ListEntitiesMediaPlayerResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const ListEntitiesMediaPlayerResponse *>(self);
   uint32_t size = 0;
-  size += 2 + this->object_id.size();
+  size += 2 + msg.object_id.size();
   size += 5;
-  size += 2 + this->name.size();
+  size += 2 + msg.name.size();
 #ifdef USE_ENTITY_ICON
-  size += !this->icon.empty() ? 2 + this->icon.size() : 0;
+  size += !msg.icon.empty() ? 2 + msg.icon.size() : 0;
 #endif
-  size += ProtoSize::calc_bool(1, this->disabled_by_default);
-  size += this->entity_category ? 2 : 0;
-  if (!this->supported_formats.empty()) {
-    for (const auto &it : this->supported_formats) {
+  size += ProtoSize::calc_bool(1, msg.disabled_by_default);
+  size += msg.entity_category ? 2 : 0;
+  if (!msg.supported_formats.empty()) {
+    for (const auto &it : msg.supported_formats) {
       size += ProtoSize::calc_message_force(1, it.calculate_size());
     }
   }
 #ifdef USE_DEVICES
-  size += ProtoSize::calc_uint32(1, this->device_id);
+  size += ProtoSize::calc_uint32(1, msg.device_id);
 #endif
-  size += ProtoSize::calc_uint32(1, this->feature_flags);
+  size += ProtoSize::calc_uint32(1, msg.feature_flags);
   return size;
 }
-uint8_t *MediaPlayerStateResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *MediaPlayerStateResponse::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const MediaPlayerStateResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 13, this->key);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, static_cast<uint32_t>(this->state));
-  if (uint32_t raw = float_to_raw(this->volume); raw != 0) [[likely]] {
+  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 13, msg.key);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, static_cast<uint32_t>(msg.state));
+  if (uint32_t raw = float_to_raw(msg.volume); raw != 0) [[likely]] {
     pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 29, raw);
   }
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 4, this->muted);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 4, msg.muted);
 #ifdef USE_DEVICES
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 5, this->device_id);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 5, msg.device_id);
 #endif
   return pos;
 }
-uint32_t MediaPlayerStateResponse::calculate_size() const {
+uint32_t MediaPlayerStateResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const MediaPlayerStateResponse *>(self);
   uint32_t size = 0;
   size += 5;
-  size += this->state ? 2 : 0;
-  size += ProtoSize::calc_float(1, this->volume);
-  size += ProtoSize::calc_bool(1, this->muted);
+  size += msg.state ? 2 : 0;
+  size += ProtoSize::calc_float(1, msg.volume);
+  size += ProtoSize::calc_bool(1, msg.muted);
 #ifdef USE_DEVICES
-  size += ProtoSize::calc_uint32(1, this->device_id);
+  size += ProtoSize::calc_uint32(1, msg.device_id);
 #endif
   return size;
 }
@@ -2531,10 +2637,11 @@ bool SubscribeBluetoothLEAdvertisementsRequest::decode_varint(uint32_t field_id,
 }
 __attribute__((optimize("O2")))  // NOLINT(clang-diagnostic-unknown-attributes)
 uint8_t *
-BluetoothLERawAdvertisementsResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+BluetoothLERawAdvertisementsResponse::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const BluetoothLERawAdvertisementsResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  for (uint16_t i = 0; i < this->advertisements_len; i++) {
-    auto &sub_msg = this->advertisements[i];
+  for (uint16_t i = 0; i < msg.advertisements_len; i++) {
+    auto &sub_msg = msg.advertisements[i];
     pos = ProtoEncode::write_raw_byte(pos PROTO_ENCODE_DEBUG_ARG, 10);
     uint8_t *len_pos = pos;
     pos = ProtoEncode::reserve_byte(pos PROTO_ENCODE_DEBUG_ARG);
@@ -2555,10 +2662,11 @@ BluetoothLERawAdvertisementsResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCO
 }
 __attribute__((optimize("O2")))  // NOLINT(clang-diagnostic-unknown-attributes)
 uint32_t
-BluetoothLERawAdvertisementsResponse::calculate_size() const {
+BluetoothLERawAdvertisementsResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const BluetoothLERawAdvertisementsResponse *>(self);
   uint32_t size = 0;
-  for (uint16_t i = 0; i < this->advertisements_len; i++) {
-    auto &sub_msg = this->advertisements[i];
+  for (uint16_t i = 0; i < msg.advertisements_len; i++) {
+    auto &sub_msg = msg.advertisements[i];
     size += 2;
     size += ProtoSize::calc_uint64_48bit_force(1, sub_msg.address);
     size += ProtoSize::calc_sint32_force(1, sub_msg.rssi);
@@ -2588,20 +2696,23 @@ bool BluetoothDeviceRequest::decode_varint(uint32_t field_id, proto_varint_value
   }
   return true;
 }
-uint8_t *BluetoothDeviceConnectionResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *BluetoothDeviceConnectionResponse::encode_msg(const void *self,
+                                                       ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const BluetoothDeviceConnectionResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_uint64(pos PROTO_ENCODE_DEBUG_ARG, 1, this->address);
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 2, this->connected);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 3, this->mtu);
-  pos = ProtoEncode::encode_int32(pos PROTO_ENCODE_DEBUG_ARG, 4, this->error);
+  pos = ProtoEncode::encode_uint64(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.address);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 2, msg.connected);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 3, msg.mtu);
+  pos = ProtoEncode::encode_int32(pos PROTO_ENCODE_DEBUG_ARG, 4, msg.error);
   return pos;
 }
-uint32_t BluetoothDeviceConnectionResponse::calculate_size() const {
+uint32_t BluetoothDeviceConnectionResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const BluetoothDeviceConnectionResponse *>(self);
   uint32_t size = 0;
-  size += ProtoSize::calc_uint64(1, this->address);
-  size += ProtoSize::calc_bool(1, this->connected);
-  size += ProtoSize::calc_uint32(1, this->mtu);
-  size += ProtoSize::calc_int32(1, this->error);
+  size += ProtoSize::calc_uint64(1, msg.address);
+  size += ProtoSize::calc_bool(1, msg.connected);
+  size += ProtoSize::calc_uint32(1, msg.mtu);
+  size += ProtoSize::calc_int32(1, msg.error);
   return size;
 }
 bool BluetoothGATTGetServicesRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
@@ -2614,110 +2725,122 @@ bool BluetoothGATTGetServicesRequest::decode_varint(uint32_t field_id, proto_var
   }
   return true;
 }
-uint8_t *BluetoothGATTDescriptor::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *BluetoothGATTDescriptor::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const BluetoothGATTDescriptor *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  if (this->uuid[0] != 0 || this->uuid[1] != 0) {
-    pos = ProtoEncode::encode_uint64_force(pos PROTO_ENCODE_DEBUG_ARG, 1, this->uuid[0]);
-    pos = ProtoEncode::encode_uint64_force(pos PROTO_ENCODE_DEBUG_ARG, 1, this->uuid[1]);
+  if (msg.uuid[0] != 0 || msg.uuid[1] != 0) {
+    pos = ProtoEncode::encode_uint64_force(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.uuid[0]);
+    pos = ProtoEncode::encode_uint64_force(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.uuid[1]);
   }
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, this->handle);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 3, this->short_uuid);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, msg.handle);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 3, msg.short_uuid);
   return pos;
 }
-uint32_t BluetoothGATTDescriptor::calculate_size() const {
+uint32_t BluetoothGATTDescriptor::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const BluetoothGATTDescriptor *>(self);
   uint32_t size = 0;
-  if (this->uuid[0] != 0 || this->uuid[1] != 0) {
-    size += ProtoSize::calc_uint64_force(1, this->uuid[0]);
-    size += ProtoSize::calc_uint64_force(1, this->uuid[1]);
+  if (msg.uuid[0] != 0 || msg.uuid[1] != 0) {
+    size += ProtoSize::calc_uint64_force(1, msg.uuid[0]);
+    size += ProtoSize::calc_uint64_force(1, msg.uuid[1]);
   }
-  size += ProtoSize::calc_uint32(1, this->handle);
-  size += ProtoSize::calc_uint32(1, this->short_uuid);
+  size += ProtoSize::calc_uint32(1, msg.handle);
+  size += ProtoSize::calc_uint32(1, msg.short_uuid);
   return size;
 }
-uint8_t *BluetoothGATTCharacteristic::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *BluetoothGATTCharacteristic::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const BluetoothGATTCharacteristic *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  if (this->uuid[0] != 0 || this->uuid[1] != 0) {
-    pos = ProtoEncode::encode_uint64_force(pos PROTO_ENCODE_DEBUG_ARG, 1, this->uuid[0]);
-    pos = ProtoEncode::encode_uint64_force(pos PROTO_ENCODE_DEBUG_ARG, 1, this->uuid[1]);
+  if (msg.uuid[0] != 0 || msg.uuid[1] != 0) {
+    pos = ProtoEncode::encode_uint64_force(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.uuid[0]);
+    pos = ProtoEncode::encode_uint64_force(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.uuid[1]);
   }
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, this->handle);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 3, this->properties);
-  for (auto &it : this->descriptors) {
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, msg.handle);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 3, msg.properties);
+  for (auto &it : msg.descriptors) {
     pos = ProtoEncode::encode_sub_message(pos PROTO_ENCODE_DEBUG_ARG, buffer, 4, it);
   }
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 5, this->short_uuid);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 5, msg.short_uuid);
   return pos;
 }
-uint32_t BluetoothGATTCharacteristic::calculate_size() const {
+uint32_t BluetoothGATTCharacteristic::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const BluetoothGATTCharacteristic *>(self);
   uint32_t size = 0;
-  if (this->uuid[0] != 0 || this->uuid[1] != 0) {
-    size += ProtoSize::calc_uint64_force(1, this->uuid[0]);
-    size += ProtoSize::calc_uint64_force(1, this->uuid[1]);
+  if (msg.uuid[0] != 0 || msg.uuid[1] != 0) {
+    size += ProtoSize::calc_uint64_force(1, msg.uuid[0]);
+    size += ProtoSize::calc_uint64_force(1, msg.uuid[1]);
   }
-  size += ProtoSize::calc_uint32(1, this->handle);
-  size += ProtoSize::calc_uint32(1, this->properties);
-  if (!this->descriptors.empty()) {
-    for (const auto &it : this->descriptors) {
+  size += ProtoSize::calc_uint32(1, msg.handle);
+  size += ProtoSize::calc_uint32(1, msg.properties);
+  if (!msg.descriptors.empty()) {
+    for (const auto &it : msg.descriptors) {
       size += ProtoSize::calc_message_force(1, it.calculate_size());
     }
   }
-  size += ProtoSize::calc_uint32(1, this->short_uuid);
+  size += ProtoSize::calc_uint32(1, msg.short_uuid);
   return size;
 }
-uint8_t *BluetoothGATTService::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *BluetoothGATTService::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const BluetoothGATTService *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  if (this->uuid[0] != 0 || this->uuid[1] != 0) {
-    pos = ProtoEncode::encode_uint64_force(pos PROTO_ENCODE_DEBUG_ARG, 1, this->uuid[0]);
-    pos = ProtoEncode::encode_uint64_force(pos PROTO_ENCODE_DEBUG_ARG, 1, this->uuid[1]);
+  if (msg.uuid[0] != 0 || msg.uuid[1] != 0) {
+    pos = ProtoEncode::encode_uint64_force(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.uuid[0]);
+    pos = ProtoEncode::encode_uint64_force(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.uuid[1]);
   }
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, this->handle);
-  for (auto &it : this->characteristics) {
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, msg.handle);
+  for (auto &it : msg.characteristics) {
     pos = ProtoEncode::encode_sub_message(pos PROTO_ENCODE_DEBUG_ARG, buffer, 3, it);
   }
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 4, this->short_uuid);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 4, msg.short_uuid);
   return pos;
 }
-uint32_t BluetoothGATTService::calculate_size() const {
+uint32_t BluetoothGATTService::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const BluetoothGATTService *>(self);
   uint32_t size = 0;
-  if (this->uuid[0] != 0 || this->uuid[1] != 0) {
-    size += ProtoSize::calc_uint64_force(1, this->uuid[0]);
-    size += ProtoSize::calc_uint64_force(1, this->uuid[1]);
+  if (msg.uuid[0] != 0 || msg.uuid[1] != 0) {
+    size += ProtoSize::calc_uint64_force(1, msg.uuid[0]);
+    size += ProtoSize::calc_uint64_force(1, msg.uuid[1]);
   }
-  size += ProtoSize::calc_uint32(1, this->handle);
-  if (!this->characteristics.empty()) {
-    for (const auto &it : this->characteristics) {
+  size += ProtoSize::calc_uint32(1, msg.handle);
+  if (!msg.characteristics.empty()) {
+    for (const auto &it : msg.characteristics) {
       size += ProtoSize::calc_message_force(1, it.calculate_size());
     }
   }
-  size += ProtoSize::calc_uint32(1, this->short_uuid);
+  size += ProtoSize::calc_uint32(1, msg.short_uuid);
   return size;
 }
-uint8_t *BluetoothGATTGetServicesResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *BluetoothGATTGetServicesResponse::encode_msg(const void *self,
+                                                      ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const BluetoothGATTGetServicesResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_uint64(pos PROTO_ENCODE_DEBUG_ARG, 1, this->address);
-  for (auto &it : this->services) {
+  pos = ProtoEncode::encode_uint64(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.address);
+  for (auto &it : msg.services) {
     pos = ProtoEncode::encode_sub_message(pos PROTO_ENCODE_DEBUG_ARG, buffer, 2, it);
   }
   return pos;
 }
-uint32_t BluetoothGATTGetServicesResponse::calculate_size() const {
+uint32_t BluetoothGATTGetServicesResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const BluetoothGATTGetServicesResponse *>(self);
   uint32_t size = 0;
-  size += ProtoSize::calc_uint64(1, this->address);
-  if (!this->services.empty()) {
-    for (const auto &it : this->services) {
+  size += ProtoSize::calc_uint64(1, msg.address);
+  if (!msg.services.empty()) {
+    for (const auto &it : msg.services) {
       size += ProtoSize::calc_message_force(1, it.calculate_size());
     }
   }
   return size;
 }
-uint8_t *BluetoothGATTGetServicesDoneResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *BluetoothGATTGetServicesDoneResponse::encode_msg(const void *self,
+                                                          ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const BluetoothGATTGetServicesDoneResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_uint64(pos PROTO_ENCODE_DEBUG_ARG, 1, this->address);
+  pos = ProtoEncode::encode_uint64(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.address);
   return pos;
 }
-uint32_t BluetoothGATTGetServicesDoneResponse::calculate_size() const {
+uint32_t BluetoothGATTGetServicesDoneResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const BluetoothGATTGetServicesDoneResponse *>(self);
   uint32_t size = 0;
-  size += ProtoSize::calc_uint64(1, this->address);
+  size += ProtoSize::calc_uint64(1, msg.address);
   return size;
 }
 bool BluetoothGATTReadRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
@@ -2733,18 +2856,20 @@ bool BluetoothGATTReadRequest::decode_varint(uint32_t field_id, proto_varint_val
   }
   return true;
 }
-uint8_t *BluetoothGATTReadResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *BluetoothGATTReadResponse::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const BluetoothGATTReadResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_uint64(pos PROTO_ENCODE_DEBUG_ARG, 1, this->address);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, this->handle);
-  pos = ProtoEncode::encode_bytes(pos PROTO_ENCODE_DEBUG_ARG, 3, this->data_ptr_, this->data_len_);
+  pos = ProtoEncode::encode_uint64(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.address);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, msg.handle);
+  pos = ProtoEncode::encode_bytes(pos PROTO_ENCODE_DEBUG_ARG, 3, msg.data_ptr_, msg.data_len_);
   return pos;
 }
-uint32_t BluetoothGATTReadResponse::calculate_size() const {
+uint32_t BluetoothGATTReadResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const BluetoothGATTReadResponse *>(self);
   uint32_t size = 0;
-  size += ProtoSize::calc_uint64(1, this->address);
-  size += ProtoSize::calc_uint32(1, this->handle);
-  size += ProtoSize::calc_length(1, this->data_len_);
+  size += ProtoSize::calc_uint64(1, msg.address);
+  size += ProtoSize::calc_uint32(1, msg.handle);
+  size += ProtoSize::calc_length(1, msg.data_len_);
   return size;
 }
 bool BluetoothGATTWriteRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
@@ -2829,136 +2954,160 @@ bool BluetoothGATTNotifyRequest::decode_varint(uint32_t field_id, proto_varint_v
   }
   return true;
 }
-uint8_t *BluetoothGATTNotifyDataResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *BluetoothGATTNotifyDataResponse::encode_msg(const void *self,
+                                                     ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const BluetoothGATTNotifyDataResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_uint64(pos PROTO_ENCODE_DEBUG_ARG, 1, this->address);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, this->handle);
-  pos = ProtoEncode::encode_bytes(pos PROTO_ENCODE_DEBUG_ARG, 3, this->data_ptr_, this->data_len_);
+  pos = ProtoEncode::encode_uint64(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.address);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, msg.handle);
+  pos = ProtoEncode::encode_bytes(pos PROTO_ENCODE_DEBUG_ARG, 3, msg.data_ptr_, msg.data_len_);
   return pos;
 }
-uint32_t BluetoothGATTNotifyDataResponse::calculate_size() const {
+uint32_t BluetoothGATTNotifyDataResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const BluetoothGATTNotifyDataResponse *>(self);
   uint32_t size = 0;
-  size += ProtoSize::calc_uint64(1, this->address);
-  size += ProtoSize::calc_uint32(1, this->handle);
-  size += ProtoSize::calc_length(1, this->data_len_);
+  size += ProtoSize::calc_uint64(1, msg.address);
+  size += ProtoSize::calc_uint32(1, msg.handle);
+  size += ProtoSize::calc_length(1, msg.data_len_);
   return size;
 }
-uint8_t *BluetoothConnectionsFreeResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *BluetoothConnectionsFreeResponse::encode_msg(const void *self,
+                                                      ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const BluetoothConnectionsFreeResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 1, this->free);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, this->limit);
-  for (const auto &it : this->allocated) {
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.free);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, msg.limit);
+  for (const auto &it : msg.allocated) {
     if (it != 0) {
       pos = ProtoEncode::encode_uint64_force(pos PROTO_ENCODE_DEBUG_ARG, 3, it);
     }
   }
   return pos;
 }
-uint32_t BluetoothConnectionsFreeResponse::calculate_size() const {
+uint32_t BluetoothConnectionsFreeResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const BluetoothConnectionsFreeResponse *>(self);
   uint32_t size = 0;
-  size += ProtoSize::calc_uint32(1, this->free);
-  size += ProtoSize::calc_uint32(1, this->limit);
-  for (const auto &it : this->allocated) {
+  size += ProtoSize::calc_uint32(1, msg.free);
+  size += ProtoSize::calc_uint32(1, msg.limit);
+  for (const auto &it : msg.allocated) {
     if (it != 0) {
       size += ProtoSize::calc_uint64_force(1, it);
     }
   }
   return size;
 }
-uint8_t *BluetoothGATTErrorResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *BluetoothGATTErrorResponse::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const BluetoothGATTErrorResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_uint64(pos PROTO_ENCODE_DEBUG_ARG, 1, this->address);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, this->handle);
-  pos = ProtoEncode::encode_int32(pos PROTO_ENCODE_DEBUG_ARG, 3, this->error);
+  pos = ProtoEncode::encode_uint64(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.address);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, msg.handle);
+  pos = ProtoEncode::encode_int32(pos PROTO_ENCODE_DEBUG_ARG, 3, msg.error);
   return pos;
 }
-uint32_t BluetoothGATTErrorResponse::calculate_size() const {
+uint32_t BluetoothGATTErrorResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const BluetoothGATTErrorResponse *>(self);
   uint32_t size = 0;
-  size += ProtoSize::calc_uint64(1, this->address);
-  size += ProtoSize::calc_uint32(1, this->handle);
-  size += ProtoSize::calc_int32(1, this->error);
+  size += ProtoSize::calc_uint64(1, msg.address);
+  size += ProtoSize::calc_uint32(1, msg.handle);
+  size += ProtoSize::calc_int32(1, msg.error);
   return size;
 }
-uint8_t *BluetoothGATTWriteResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *BluetoothGATTWriteResponse::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const BluetoothGATTWriteResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_uint64(pos PROTO_ENCODE_DEBUG_ARG, 1, this->address);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, this->handle);
+  pos = ProtoEncode::encode_uint64(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.address);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, msg.handle);
   return pos;
 }
-uint32_t BluetoothGATTWriteResponse::calculate_size() const {
+uint32_t BluetoothGATTWriteResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const BluetoothGATTWriteResponse *>(self);
   uint32_t size = 0;
-  size += ProtoSize::calc_uint64(1, this->address);
-  size += ProtoSize::calc_uint32(1, this->handle);
+  size += ProtoSize::calc_uint64(1, msg.address);
+  size += ProtoSize::calc_uint32(1, msg.handle);
   return size;
 }
-uint8_t *BluetoothGATTNotifyResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *BluetoothGATTNotifyResponse::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const BluetoothGATTNotifyResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_uint64(pos PROTO_ENCODE_DEBUG_ARG, 1, this->address);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, this->handle);
+  pos = ProtoEncode::encode_uint64(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.address);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, msg.handle);
   return pos;
 }
-uint32_t BluetoothGATTNotifyResponse::calculate_size() const {
+uint32_t BluetoothGATTNotifyResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const BluetoothGATTNotifyResponse *>(self);
   uint32_t size = 0;
-  size += ProtoSize::calc_uint64(1, this->address);
-  size += ProtoSize::calc_uint32(1, this->handle);
+  size += ProtoSize::calc_uint64(1, msg.address);
+  size += ProtoSize::calc_uint32(1, msg.handle);
   return size;
 }
-uint8_t *BluetoothDevicePairingResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *BluetoothDevicePairingResponse::encode_msg(const void *self,
+                                                    ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const BluetoothDevicePairingResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_uint64(pos PROTO_ENCODE_DEBUG_ARG, 1, this->address);
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 2, this->paired);
-  pos = ProtoEncode::encode_int32(pos PROTO_ENCODE_DEBUG_ARG, 3, this->error);
+  pos = ProtoEncode::encode_uint64(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.address);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 2, msg.paired);
+  pos = ProtoEncode::encode_int32(pos PROTO_ENCODE_DEBUG_ARG, 3, msg.error);
   return pos;
 }
-uint32_t BluetoothDevicePairingResponse::calculate_size() const {
+uint32_t BluetoothDevicePairingResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const BluetoothDevicePairingResponse *>(self);
   uint32_t size = 0;
-  size += ProtoSize::calc_uint64(1, this->address);
-  size += ProtoSize::calc_bool(1, this->paired);
-  size += ProtoSize::calc_int32(1, this->error);
+  size += ProtoSize::calc_uint64(1, msg.address);
+  size += ProtoSize::calc_bool(1, msg.paired);
+  size += ProtoSize::calc_int32(1, msg.error);
   return size;
 }
-uint8_t *BluetoothDeviceUnpairingResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *BluetoothDeviceUnpairingResponse::encode_msg(const void *self,
+                                                      ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const BluetoothDeviceUnpairingResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_uint64(pos PROTO_ENCODE_DEBUG_ARG, 1, this->address);
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 2, this->success);
-  pos = ProtoEncode::encode_int32(pos PROTO_ENCODE_DEBUG_ARG, 3, this->error);
+  pos = ProtoEncode::encode_uint64(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.address);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 2, msg.success);
+  pos = ProtoEncode::encode_int32(pos PROTO_ENCODE_DEBUG_ARG, 3, msg.error);
   return pos;
 }
-uint32_t BluetoothDeviceUnpairingResponse::calculate_size() const {
+uint32_t BluetoothDeviceUnpairingResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const BluetoothDeviceUnpairingResponse *>(self);
   uint32_t size = 0;
-  size += ProtoSize::calc_uint64(1, this->address);
-  size += ProtoSize::calc_bool(1, this->success);
-  size += ProtoSize::calc_int32(1, this->error);
+  size += ProtoSize::calc_uint64(1, msg.address);
+  size += ProtoSize::calc_bool(1, msg.success);
+  size += ProtoSize::calc_int32(1, msg.error);
   return size;
 }
-uint8_t *BluetoothDeviceClearCacheResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *BluetoothDeviceClearCacheResponse::encode_msg(const void *self,
+                                                       ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const BluetoothDeviceClearCacheResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_uint64(pos PROTO_ENCODE_DEBUG_ARG, 1, this->address);
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 2, this->success);
-  pos = ProtoEncode::encode_int32(pos PROTO_ENCODE_DEBUG_ARG, 3, this->error);
+  pos = ProtoEncode::encode_uint64(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.address);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 2, msg.success);
+  pos = ProtoEncode::encode_int32(pos PROTO_ENCODE_DEBUG_ARG, 3, msg.error);
   return pos;
 }
-uint32_t BluetoothDeviceClearCacheResponse::calculate_size() const {
+uint32_t BluetoothDeviceClearCacheResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const BluetoothDeviceClearCacheResponse *>(self);
   uint32_t size = 0;
-  size += ProtoSize::calc_uint64(1, this->address);
-  size += ProtoSize::calc_bool(1, this->success);
-  size += ProtoSize::calc_int32(1, this->error);
+  size += ProtoSize::calc_uint64(1, msg.address);
+  size += ProtoSize::calc_bool(1, msg.success);
+  size += ProtoSize::calc_int32(1, msg.error);
   return size;
 }
 #endif
 #ifdef USE_BLUETOOTH_PROXY
-uint8_t *BluetoothScannerStateResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *BluetoothScannerStateResponse::encode_msg(const void *self,
+                                                   ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const BluetoothScannerStateResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 1, static_cast<uint32_t>(this->state));
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, static_cast<uint32_t>(this->mode));
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 3, static_cast<uint32_t>(this->configured_mode));
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 1, static_cast<uint32_t>(msg.state));
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, static_cast<uint32_t>(msg.mode));
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 3, static_cast<uint32_t>(msg.configured_mode));
   return pos;
 }
-uint32_t BluetoothScannerStateResponse::calculate_size() const {
+uint32_t BluetoothScannerStateResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const BluetoothScannerStateResponse *>(self);
   uint32_t size = 0;
-  size += this->state ? 2 : 0;
-  size += this->mode ? 2 : 0;
-  size += this->configured_mode ? 2 : 0;
+  size += msg.state ? 2 : 0;
+  size += msg.mode ? 2 : 0;
+  size += msg.configured_mode ? 2 : 0;
   return size;
 }
 bool BluetoothScannerSetModeRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
@@ -2986,38 +3135,42 @@ bool SubscribeVoiceAssistantRequest::decode_varint(uint32_t field_id, proto_vari
   }
   return true;
 }
-uint8_t *VoiceAssistantAudioSettings::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *VoiceAssistantAudioSettings::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const VoiceAssistantAudioSettings *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 1, this->noise_suppression_level);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, this->auto_gain);
-  if (uint32_t raw = float_to_raw(this->volume_multiplier); raw != 0) [[likely]] {
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.noise_suppression_level);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, msg.auto_gain);
+  if (uint32_t raw = float_to_raw(msg.volume_multiplier); raw != 0) [[likely]] {
     pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 29, raw);
   }
   return pos;
 }
-uint32_t VoiceAssistantAudioSettings::calculate_size() const {
+uint32_t VoiceAssistantAudioSettings::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const VoiceAssistantAudioSettings *>(self);
   uint32_t size = 0;
-  size += ProtoSize::calc_uint32(1, this->noise_suppression_level);
-  size += ProtoSize::calc_uint32(1, this->auto_gain);
-  size += ProtoSize::calc_float(1, this->volume_multiplier);
+  size += ProtoSize::calc_uint32(1, msg.noise_suppression_level);
+  size += ProtoSize::calc_uint32(1, msg.auto_gain);
+  size += ProtoSize::calc_float(1, msg.volume_multiplier);
   return size;
 }
-uint8_t *VoiceAssistantRequest::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *VoiceAssistantRequest::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const VoiceAssistantRequest *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 1, this->start);
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 2, this->conversation_id);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 3, this->flags);
-  pos = ProtoEncode::encode_optional_sub_message(pos PROTO_ENCODE_DEBUG_ARG, buffer, 4, this->audio_settings);
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 5, this->wake_word_phrase);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.start);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 2, msg.conversation_id);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 3, msg.flags);
+  pos = ProtoEncode::encode_optional_sub_message(pos PROTO_ENCODE_DEBUG_ARG, buffer, 4, msg.audio_settings);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 5, msg.wake_word_phrase);
   return pos;
 }
-uint32_t VoiceAssistantRequest::calculate_size() const {
+uint32_t VoiceAssistantRequest::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const VoiceAssistantRequest *>(self);
   uint32_t size = 0;
-  size += ProtoSize::calc_bool(1, this->start);
-  size += ProtoSize::calc_length(1, this->conversation_id.size());
-  size += ProtoSize::calc_uint32(1, this->flags);
-  size += ProtoSize::calc_message(1, this->audio_settings.calculate_size());
-  size += ProtoSize::calc_length(1, this->wake_word_phrase.size());
+  size += ProtoSize::calc_bool(1, msg.start);
+  size += ProtoSize::calc_length(1, msg.conversation_id.size());
+  size += ProtoSize::calc_uint32(1, msg.flags);
+  size += ProtoSize::calc_message(1, msg.audio_settings.calculate_size());
+  size += ProtoSize::calc_length(1, msg.wake_word_phrase.size());
   return size;
 }
 bool VoiceAssistantResponse::decode_varint(uint32_t field_id, proto_varint_value_t value) {
@@ -3096,18 +3249,20 @@ bool VoiceAssistantAudio::decode_length(uint32_t field_id, ProtoLengthDelimited
   }
   return true;
 }
-uint8_t *VoiceAssistantAudio::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *VoiceAssistantAudio::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const VoiceAssistantAudio *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_bytes(pos PROTO_ENCODE_DEBUG_ARG, 1, this->data, this->data_len);
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 2, this->end);
-  pos = ProtoEncode::encode_bytes(pos PROTO_ENCODE_DEBUG_ARG, 3, this->data2, this->data2_len);
+  pos = ProtoEncode::encode_bytes(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.data, msg.data_len);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 2, msg.end);
+  pos = ProtoEncode::encode_bytes(pos PROTO_ENCODE_DEBUG_ARG, 3, msg.data2, msg.data2_len);
   return pos;
 }
-uint32_t VoiceAssistantAudio::calculate_size() const {
+uint32_t VoiceAssistantAudio::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const VoiceAssistantAudio *>(self);
   uint32_t size = 0;
-  size += ProtoSize::calc_length(1, this->data_len);
-  size += ProtoSize::calc_bool(1, this->end);
-  size += ProtoSize::calc_length(1, this->data2_len);
+  size += ProtoSize::calc_length(1, msg.data_len);
+  size += ProtoSize::calc_bool(1, msg.end);
+  size += ProtoSize::calc_length(1, msg.data2_len);
   return size;
 }
 bool VoiceAssistantTimerEventResponse::decode_varint(uint32_t field_id, proto_varint_value_t value) {
@@ -3173,31 +3328,36 @@ bool VoiceAssistantAnnounceRequest::decode_length(uint32_t field_id, ProtoLength
   }
   return true;
 }
-uint8_t *VoiceAssistantAnnounceFinished::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *VoiceAssistantAnnounceFinished::encode_msg(const void *self,
+                                                    ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const VoiceAssistantAnnounceFinished *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 1, this->success);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.success);
   return pos;
 }
-uint32_t VoiceAssistantAnnounceFinished::calculate_size() const {
+uint32_t VoiceAssistantAnnounceFinished::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const VoiceAssistantAnnounceFinished *>(self);
   uint32_t size = 0;
-  size += ProtoSize::calc_bool(1, this->success);
+  size += ProtoSize::calc_bool(1, msg.success);
   return size;
 }
-uint8_t *VoiceAssistantWakeWord::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *VoiceAssistantWakeWord::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const VoiceAssistantWakeWord *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 1, this->id);
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 2, this->wake_word);
-  for (auto &it : this->trained_languages) {
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.id);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 2, msg.wake_word);
+  for (auto &it : msg.trained_languages) {
     pos = ProtoEncode::encode_string_force(pos PROTO_ENCODE_DEBUG_ARG, 3, it);
   }
   return pos;
 }
-uint32_t VoiceAssistantWakeWord::calculate_size() const {
+uint32_t VoiceAssistantWakeWord::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const VoiceAssistantWakeWord *>(self);
   uint32_t size = 0;
-  size += ProtoSize::calc_length(1, this->id.size());
-  size += ProtoSize::calc_length(1, this->wake_word.size());
-  if (!this->trained_languages.empty()) {
-    for (const auto &it : this->trained_languages) {
+  size += ProtoSize::calc_length(1, msg.id.size());
+  size += ProtoSize::calc_length(1, msg.wake_word.size());
+  if (!msg.trained_languages.empty()) {
+    for (const auto &it : msg.trained_languages) {
       size += ProtoSize::calc_length_force(1, it.size());
     }
   }
@@ -3254,30 +3414,33 @@ bool VoiceAssistantConfigurationRequest::decode_length(uint32_t field_id, ProtoL
   }
   return true;
 }
-uint8_t *VoiceAssistantConfigurationResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *VoiceAssistantConfigurationResponse::encode_msg(const void *self,
+                                                         ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const VoiceAssistantConfigurationResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  for (auto &it : this->available_wake_words) {
+  for (auto &it : msg.available_wake_words) {
     pos = ProtoEncode::encode_sub_message(pos PROTO_ENCODE_DEBUG_ARG, buffer, 1, it);
   }
-  for (const auto &it : *this->active_wake_words) {
+  for (const auto &it : *msg.active_wake_words) {
     pos = ProtoEncode::encode_string_force(pos PROTO_ENCODE_DEBUG_ARG, 2, it);
   }
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 3, this->max_active_wake_words);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 3, msg.max_active_wake_words);
   return pos;
 }
-uint32_t VoiceAssistantConfigurationResponse::calculate_size() const {
+uint32_t VoiceAssistantConfigurationResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const VoiceAssistantConfigurationResponse *>(self);
   uint32_t size = 0;
-  if (!this->available_wake_words.empty()) {
-    for (const auto &it : this->available_wake_words) {
+  if (!msg.available_wake_words.empty()) {
+    for (const auto &it : msg.available_wake_words) {
       size += ProtoSize::calc_message_force(1, it.calculate_size());
     }
   }
-  if (!this->active_wake_words->empty()) {
-    for (const auto &it : *this->active_wake_words) {
+  if (!msg.active_wake_words->empty()) {
+    for (const auto &it : *msg.active_wake_words) {
       size += ProtoSize::calc_length_force(1, it.size());
     }
   }
-  size += ProtoSize::calc_uint32(1, this->max_active_wake_words);
+  size += ProtoSize::calc_uint32(1, msg.max_active_wake_words);
   return size;
 }
 bool VoiceAssistantSetConfiguration::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
@@ -3292,57 +3455,63 @@ bool VoiceAssistantSetConfiguration::decode_length(uint32_t field_id, ProtoLengt
 }
 #endif
 #ifdef USE_ALARM_CONTROL_PANEL
-uint8_t *ListEntitiesAlarmControlPanelResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *ListEntitiesAlarmControlPanelResponse::encode_msg(const void *self,
+                                                           ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const ListEntitiesAlarmControlPanelResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 10, this->object_id);
-  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, this->key);
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, this->name);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 10, msg.object_id);
+  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, msg.key);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, msg.name);
 #ifdef USE_ENTITY_ICON
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 5, this->icon);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 5, msg.icon);
 #endif
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 6, this->disabled_by_default);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 7, static_cast<uint32_t>(this->entity_category));
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 8, this->supported_features);
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 9, this->requires_code);
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 10, this->requires_code_to_arm);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 6, msg.disabled_by_default);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 7, static_cast<uint32_t>(msg.entity_category));
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 8, msg.supported_features);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 9, msg.requires_code);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 10, msg.requires_code_to_arm);
 #ifdef USE_DEVICES
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 11, this->device_id);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 11, msg.device_id);
 #endif
   return pos;
 }
-uint32_t ListEntitiesAlarmControlPanelResponse::calculate_size() const {
+uint32_t ListEntitiesAlarmControlPanelResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const ListEntitiesAlarmControlPanelResponse *>(self);
   uint32_t size = 0;
-  size += 2 + this->object_id.size();
+  size += 2 + msg.object_id.size();
   size += 5;
-  size += 2 + this->name.size();
+  size += 2 + msg.name.size();
 #ifdef USE_ENTITY_ICON
-  size += !this->icon.empty() ? 2 + this->icon.size() : 0;
+  size += !msg.icon.empty() ? 2 + msg.icon.size() : 0;
 #endif
-  size += ProtoSize::calc_bool(1, this->disabled_by_default);
-  size += this->entity_category ? 2 : 0;
-  size += ProtoSize::calc_uint32(1, this->supported_features);
-  size += ProtoSize::calc_bool(1, this->requires_code);
-  size += ProtoSize::calc_bool(1, this->requires_code_to_arm);
+  size += ProtoSize::calc_bool(1, msg.disabled_by_default);
+  size += msg.entity_category ? 2 : 0;
+  size += ProtoSize::calc_uint32(1, msg.supported_features);
+  size += ProtoSize::calc_bool(1, msg.requires_code);
+  size += ProtoSize::calc_bool(1, msg.requires_code_to_arm);
 #ifdef USE_DEVICES
-  size += ProtoSize::calc_uint32(1, this->device_id);
+  size += ProtoSize::calc_uint32(1, msg.device_id);
 #endif
   return size;
 }
-uint8_t *AlarmControlPanelStateResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *AlarmControlPanelStateResponse::encode_msg(const void *self,
+                                                    ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const AlarmControlPanelStateResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 13, this->key);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, static_cast<uint32_t>(this->state));
+  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 13, msg.key);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, static_cast<uint32_t>(msg.state));
 #ifdef USE_DEVICES
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 3, this->device_id);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 3, msg.device_id);
 #endif
   return pos;
 }
-uint32_t AlarmControlPanelStateResponse::calculate_size() const {
+uint32_t AlarmControlPanelStateResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const AlarmControlPanelStateResponse *>(self);
   uint32_t size = 0;
   size += 5;
-  size += this->state ? 2 : 0;
+  size += msg.state ? 2 : 0;
 #ifdef USE_DEVICES
-  size += ProtoSize::calc_uint32(1, this->device_id);
+  size += ProtoSize::calc_uint32(1, msg.device_id);
 #endif
   return size;
 }
@@ -3384,61 +3553,65 @@ bool AlarmControlPanelCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit
 }
 #endif
 #ifdef USE_TEXT
-uint8_t *ListEntitiesTextResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *ListEntitiesTextResponse::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const ListEntitiesTextResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 10, this->object_id);
-  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, this->key);
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, this->name);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 10, msg.object_id);
+  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, msg.key);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, msg.name);
 #ifdef USE_ENTITY_ICON
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 5, this->icon);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 5, msg.icon);
 #endif
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 6, this->disabled_by_default);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 7, static_cast<uint32_t>(this->entity_category));
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 8, this->min_length);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 9, this->max_length);
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 10, this->pattern);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 11, static_cast<uint32_t>(this->mode));
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 6, msg.disabled_by_default);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 7, static_cast<uint32_t>(msg.entity_category));
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 8, msg.min_length);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 9, msg.max_length);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 10, msg.pattern);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 11, static_cast<uint32_t>(msg.mode));
 #ifdef USE_DEVICES
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 12, this->device_id);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 12, msg.device_id);
 #endif
   return pos;
 }
-uint32_t ListEntitiesTextResponse::calculate_size() const {
+uint32_t ListEntitiesTextResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const ListEntitiesTextResponse *>(self);
   uint32_t size = 0;
-  size += 2 + this->object_id.size();
+  size += 2 + msg.object_id.size();
   size += 5;
-  size += 2 + this->name.size();
+  size += 2 + msg.name.size();
 #ifdef USE_ENTITY_ICON
-  size += !this->icon.empty() ? 2 + this->icon.size() : 0;
+  size += !msg.icon.empty() ? 2 + msg.icon.size() : 0;
 #endif
-  size += ProtoSize::calc_bool(1, this->disabled_by_default);
-  size += this->entity_category ? 2 : 0;
-  size += ProtoSize::calc_uint32(1, this->min_length);
-  size += ProtoSize::calc_uint32(1, this->max_length);
-  size += ProtoSize::calc_length(1, this->pattern.size());
-  size += this->mode ? 2 : 0;
+  size += ProtoSize::calc_bool(1, msg.disabled_by_default);
+  size += msg.entity_category ? 2 : 0;
+  size += ProtoSize::calc_uint32(1, msg.min_length);
+  size += ProtoSize::calc_uint32(1, msg.max_length);
+  size += ProtoSize::calc_length(1, msg.pattern.size());
+  size += msg.mode ? 2 : 0;
 #ifdef USE_DEVICES
-  size += ProtoSize::calc_uint32(1, this->device_id);
+  size += ProtoSize::calc_uint32(1, msg.device_id);
 #endif
   return size;
 }
-uint8_t *TextStateResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *TextStateResponse::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const TextStateResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 13, this->key);
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 2, this->state);
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 3, this->missing_state);
+  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 13, msg.key);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 2, msg.state);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 3, msg.missing_state);
 #ifdef USE_DEVICES
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 4, this->device_id);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 4, msg.device_id);
 #endif
   return pos;
 }
-uint32_t TextStateResponse::calculate_size() const {
+uint32_t TextStateResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const TextStateResponse *>(self);
   uint32_t size = 0;
   size += 5;
-  size += ProtoSize::calc_length(1, this->state.size());
-  size += ProtoSize::calc_bool(1, this->missing_state);
+  size += ProtoSize::calc_length(1, msg.state.size());
+  size += ProtoSize::calc_bool(1, msg.missing_state);
 #ifdef USE_DEVICES
-  size += ProtoSize::calc_uint32(1, this->device_id);
+  size += ProtoSize::calc_uint32(1, msg.device_id);
 #endif
   return size;
 }
@@ -3477,57 +3650,61 @@ bool TextCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
 }
 #endif
 #ifdef USE_DATETIME_DATE
-uint8_t *ListEntitiesDateResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *ListEntitiesDateResponse::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const ListEntitiesDateResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 10, this->object_id);
-  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, this->key);
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, this->name);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 10, msg.object_id);
+  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, msg.key);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, msg.name);
 #ifdef USE_ENTITY_ICON
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 5, this->icon);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 5, msg.icon);
 #endif
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 6, this->disabled_by_default);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 7, static_cast<uint32_t>(this->entity_category));
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 6, msg.disabled_by_default);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 7, static_cast<uint32_t>(msg.entity_category));
 #ifdef USE_DEVICES
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 8, this->device_id);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 8, msg.device_id);
 #endif
   return pos;
 }
-uint32_t ListEntitiesDateResponse::calculate_size() const {
+uint32_t ListEntitiesDateResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const ListEntitiesDateResponse *>(self);
   uint32_t size = 0;
-  size += 2 + this->object_id.size();
+  size += 2 + msg.object_id.size();
   size += 5;
-  size += 2 + this->name.size();
+  size += 2 + msg.name.size();
 #ifdef USE_ENTITY_ICON
-  size += !this->icon.empty() ? 2 + this->icon.size() : 0;
+  size += !msg.icon.empty() ? 2 + msg.icon.size() : 0;
 #endif
-  size += ProtoSize::calc_bool(1, this->disabled_by_default);
-  size += this->entity_category ? 2 : 0;
+  size += ProtoSize::calc_bool(1, msg.disabled_by_default);
+  size += msg.entity_category ? 2 : 0;
 #ifdef USE_DEVICES
-  size += ProtoSize::calc_uint32(1, this->device_id);
+  size += ProtoSize::calc_uint32(1, msg.device_id);
 #endif
   return size;
 }
-uint8_t *DateStateResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *DateStateResponse::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const DateStateResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 13, this->key);
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 2, this->missing_state);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 3, this->year);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 4, this->month);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 5, this->day);
+  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 13, msg.key);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 2, msg.missing_state);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 3, msg.year);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 4, msg.month);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 5, msg.day);
 #ifdef USE_DEVICES
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 6, this->device_id);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 6, msg.device_id);
 #endif
   return pos;
 }
-uint32_t DateStateResponse::calculate_size() const {
+uint32_t DateStateResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const DateStateResponse *>(self);
   uint32_t size = 0;
   size += 5;
-  size += ProtoSize::calc_bool(1, this->missing_state);
-  size += ProtoSize::calc_uint32(1, this->year);
-  size += ProtoSize::calc_uint32(1, this->month);
-  size += ProtoSize::calc_uint32(1, this->day);
+  size += ProtoSize::calc_bool(1, msg.missing_state);
+  size += ProtoSize::calc_uint32(1, msg.year);
+  size += ProtoSize::calc_uint32(1, msg.month);
+  size += ProtoSize::calc_uint32(1, msg.day);
 #ifdef USE_DEVICES
-  size += ProtoSize::calc_uint32(1, this->device_id);
+  size += ProtoSize::calc_uint32(1, msg.device_id);
 #endif
   return size;
 }
@@ -3564,57 +3741,61 @@ bool DateCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
 }
 #endif
 #ifdef USE_DATETIME_TIME
-uint8_t *ListEntitiesTimeResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *ListEntitiesTimeResponse::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const ListEntitiesTimeResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 10, this->object_id);
-  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, this->key);
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, this->name);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 10, msg.object_id);
+  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, msg.key);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, msg.name);
 #ifdef USE_ENTITY_ICON
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 5, this->icon);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 5, msg.icon);
 #endif
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 6, this->disabled_by_default);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 7, static_cast<uint32_t>(this->entity_category));
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 6, msg.disabled_by_default);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 7, static_cast<uint32_t>(msg.entity_category));
 #ifdef USE_DEVICES
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 8, this->device_id);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 8, msg.device_id);
 #endif
   return pos;
 }
-uint32_t ListEntitiesTimeResponse::calculate_size() const {
+uint32_t ListEntitiesTimeResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const ListEntitiesTimeResponse *>(self);
   uint32_t size = 0;
-  size += 2 + this->object_id.size();
+  size += 2 + msg.object_id.size();
   size += 5;
-  size += 2 + this->name.size();
+  size += 2 + msg.name.size();
 #ifdef USE_ENTITY_ICON
-  size += !this->icon.empty() ? 2 + this->icon.size() : 0;
+  size += !msg.icon.empty() ? 2 + msg.icon.size() : 0;
 #endif
-  size += ProtoSize::calc_bool(1, this->disabled_by_default);
-  size += this->entity_category ? 2 : 0;
+  size += ProtoSize::calc_bool(1, msg.disabled_by_default);
+  size += msg.entity_category ? 2 : 0;
 #ifdef USE_DEVICES
-  size += ProtoSize::calc_uint32(1, this->device_id);
+  size += ProtoSize::calc_uint32(1, msg.device_id);
 #endif
   return size;
 }
-uint8_t *TimeStateResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *TimeStateResponse::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const TimeStateResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 13, this->key);
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 2, this->missing_state);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 3, this->hour);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 4, this->minute);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 5, this->second);
+  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 13, msg.key);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 2, msg.missing_state);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 3, msg.hour);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 4, msg.minute);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 5, msg.second);
 #ifdef USE_DEVICES
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 6, this->device_id);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 6, msg.device_id);
 #endif
   return pos;
 }
-uint32_t TimeStateResponse::calculate_size() const {
+uint32_t TimeStateResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const TimeStateResponse *>(self);
   uint32_t size = 0;
   size += 5;
-  size += ProtoSize::calc_bool(1, this->missing_state);
-  size += ProtoSize::calc_uint32(1, this->hour);
-  size += ProtoSize::calc_uint32(1, this->minute);
-  size += ProtoSize::calc_uint32(1, this->second);
+  size += ProtoSize::calc_bool(1, msg.missing_state);
+  size += ProtoSize::calc_uint32(1, msg.hour);
+  size += ProtoSize::calc_uint32(1, msg.minute);
+  size += ProtoSize::calc_uint32(1, msg.second);
 #ifdef USE_DEVICES
-  size += ProtoSize::calc_uint32(1, this->device_id);
+  size += ProtoSize::calc_uint32(1, msg.device_id);
 #endif
   return size;
 }
@@ -3651,123 +3832,131 @@ bool TimeCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
 }
 #endif
 #ifdef USE_EVENT
-uint8_t *ListEntitiesEventResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *ListEntitiesEventResponse::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const ListEntitiesEventResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 10, this->object_id);
-  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, this->key);
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, this->name);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 10, msg.object_id);
+  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, msg.key);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, msg.name);
 #ifdef USE_ENTITY_ICON
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 5, this->icon);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 5, msg.icon);
 #endif
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 6, this->disabled_by_default);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 7, static_cast<uint32_t>(this->entity_category));
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 8, this->device_class);
-  for (const char *it : *this->event_types) {
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 6, msg.disabled_by_default);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 7, static_cast<uint32_t>(msg.entity_category));
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 8, msg.device_class);
+  for (const char *it : *msg.event_types) {
     pos = ProtoEncode::encode_string_force(pos PROTO_ENCODE_DEBUG_ARG, 9, it, strlen(it));
   }
 #ifdef USE_DEVICES
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 10, this->device_id);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 10, msg.device_id);
 #endif
   return pos;
 }
-uint32_t ListEntitiesEventResponse::calculate_size() const {
+uint32_t ListEntitiesEventResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const ListEntitiesEventResponse *>(self);
   uint32_t size = 0;
-  size += 2 + this->object_id.size();
+  size += 2 + msg.object_id.size();
   size += 5;
-  size += 2 + this->name.size();
+  size += 2 + msg.name.size();
 #ifdef USE_ENTITY_ICON
-  size += !this->icon.empty() ? 2 + this->icon.size() : 0;
+  size += !msg.icon.empty() ? 2 + msg.icon.size() : 0;
 #endif
-  size += ProtoSize::calc_bool(1, this->disabled_by_default);
-  size += this->entity_category ? 2 : 0;
-  size += !this->device_class.empty() ? 2 + this->device_class.size() : 0;
-  if (!this->event_types->empty()) {
-    for (const char *it : *this->event_types) {
+  size += ProtoSize::calc_bool(1, msg.disabled_by_default);
+  size += msg.entity_category ? 2 : 0;
+  size += !msg.device_class.empty() ? 2 + msg.device_class.size() : 0;
+  if (!msg.event_types->empty()) {
+    for (const char *it : *msg.event_types) {
       size += ProtoSize::calc_length_force(1, strlen(it));
     }
   }
 #ifdef USE_DEVICES
-  size += ProtoSize::calc_uint32(1, this->device_id);
+  size += ProtoSize::calc_uint32(1, msg.device_id);
 #endif
   return size;
 }
-uint8_t *EventResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *EventResponse::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const EventResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 13, this->key);
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 2, this->event_type);
+  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 13, msg.key);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 2, msg.event_type);
 #ifdef USE_DEVICES
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 3, this->device_id);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 3, msg.device_id);
 #endif
   return pos;
 }
-uint32_t EventResponse::calculate_size() const {
+uint32_t EventResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const EventResponse *>(self);
   uint32_t size = 0;
   size += 5;
-  size += ProtoSize::calc_length(1, this->event_type.size());
+  size += ProtoSize::calc_length(1, msg.event_type.size());
 #ifdef USE_DEVICES
-  size += ProtoSize::calc_uint32(1, this->device_id);
+  size += ProtoSize::calc_uint32(1, msg.device_id);
 #endif
   return size;
 }
 #endif
 #ifdef USE_VALVE
-uint8_t *ListEntitiesValveResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *ListEntitiesValveResponse::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const ListEntitiesValveResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 10, this->object_id);
-  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, this->key);
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, this->name);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 10, msg.object_id);
+  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, msg.key);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, msg.name);
 #ifdef USE_ENTITY_ICON
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 5, this->icon);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 5, msg.icon);
 #endif
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 6, this->disabled_by_default);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 7, static_cast<uint32_t>(this->entity_category));
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 8, this->device_class);
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 9, this->assumed_state);
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 10, this->supports_position);
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 11, this->supports_stop);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 6, msg.disabled_by_default);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 7, static_cast<uint32_t>(msg.entity_category));
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 8, msg.device_class);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 9, msg.assumed_state);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 10, msg.supports_position);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 11, msg.supports_stop);
 #ifdef USE_DEVICES
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 12, this->device_id);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 12, msg.device_id);
 #endif
   return pos;
 }
-uint32_t ListEntitiesValveResponse::calculate_size() const {
+uint32_t ListEntitiesValveResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const ListEntitiesValveResponse *>(self);
   uint32_t size = 0;
-  size += 2 + this->object_id.size();
+  size += 2 + msg.object_id.size();
   size += 5;
-  size += 2 + this->name.size();
+  size += 2 + msg.name.size();
 #ifdef USE_ENTITY_ICON
-  size += !this->icon.empty() ? 2 + this->icon.size() : 0;
+  size += !msg.icon.empty() ? 2 + msg.icon.size() : 0;
 #endif
-  size += ProtoSize::calc_bool(1, this->disabled_by_default);
-  size += this->entity_category ? 2 : 0;
-  size += !this->device_class.empty() ? 2 + this->device_class.size() : 0;
-  size += ProtoSize::calc_bool(1, this->assumed_state);
-  size += ProtoSize::calc_bool(1, this->supports_position);
-  size += ProtoSize::calc_bool(1, this->supports_stop);
+  size += ProtoSize::calc_bool(1, msg.disabled_by_default);
+  size += msg.entity_category ? 2 : 0;
+  size += !msg.device_class.empty() ? 2 + msg.device_class.size() : 0;
+  size += ProtoSize::calc_bool(1, msg.assumed_state);
+  size += ProtoSize::calc_bool(1, msg.supports_position);
+  size += ProtoSize::calc_bool(1, msg.supports_stop);
 #ifdef USE_DEVICES
-  size += ProtoSize::calc_uint32(1, this->device_id);
+  size += ProtoSize::calc_uint32(1, msg.device_id);
 #endif
   return size;
 }
-uint8_t *ValveStateResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *ValveStateResponse::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const ValveStateResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 13, this->key);
-  if (uint32_t raw = float_to_raw(this->position); raw != 0) [[likely]] {
+  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 13, msg.key);
+  if (uint32_t raw = float_to_raw(msg.position); raw != 0) [[likely]] {
     pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, raw);
   }
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 3, static_cast<uint32_t>(this->current_operation));
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 3, static_cast<uint32_t>(msg.current_operation));
 #ifdef USE_DEVICES
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 4, this->device_id);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 4, msg.device_id);
 #endif
   return pos;
 }
-uint32_t ValveStateResponse::calculate_size() const {
+uint32_t ValveStateResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const ValveStateResponse *>(self);
   uint32_t size = 0;
   size += 5;
-  size += ProtoSize::calc_float(1, this->position);
-  size += this->current_operation ? 2 : 0;
+  size += ProtoSize::calc_float(1, msg.position);
+  size += msg.current_operation ? 2 : 0;
 #ifdef USE_DEVICES
-  size += ProtoSize::calc_uint32(1, this->device_id);
+  size += ProtoSize::calc_uint32(1, msg.device_id);
 #endif
   return size;
 }
@@ -3804,55 +3993,59 @@ bool ValveCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
 }
 #endif
 #ifdef USE_DATETIME_DATETIME
-uint8_t *ListEntitiesDateTimeResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *ListEntitiesDateTimeResponse::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const ListEntitiesDateTimeResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 10, this->object_id);
-  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, this->key);
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, this->name);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 10, msg.object_id);
+  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, msg.key);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, msg.name);
 #ifdef USE_ENTITY_ICON
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 5, this->icon);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 5, msg.icon);
 #endif
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 6, this->disabled_by_default);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 7, static_cast<uint32_t>(this->entity_category));
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 6, msg.disabled_by_default);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 7, static_cast<uint32_t>(msg.entity_category));
 #ifdef USE_DEVICES
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 8, this->device_id);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 8, msg.device_id);
 #endif
   return pos;
 }
-uint32_t ListEntitiesDateTimeResponse::calculate_size() const {
+uint32_t ListEntitiesDateTimeResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const ListEntitiesDateTimeResponse *>(self);
   uint32_t size = 0;
-  size += 2 + this->object_id.size();
+  size += 2 + msg.object_id.size();
   size += 5;
-  size += 2 + this->name.size();
+  size += 2 + msg.name.size();
 #ifdef USE_ENTITY_ICON
-  size += !this->icon.empty() ? 2 + this->icon.size() : 0;
+  size += !msg.icon.empty() ? 2 + msg.icon.size() : 0;
 #endif
-  size += ProtoSize::calc_bool(1, this->disabled_by_default);
-  size += this->entity_category ? 2 : 0;
+  size += ProtoSize::calc_bool(1, msg.disabled_by_default);
+  size += msg.entity_category ? 2 : 0;
 #ifdef USE_DEVICES
-  size += ProtoSize::calc_uint32(1, this->device_id);
+  size += ProtoSize::calc_uint32(1, msg.device_id);
 #endif
   return size;
 }
-uint8_t *DateTimeStateResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *DateTimeStateResponse::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const DateTimeStateResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 13, this->key);
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 2, this->missing_state);
-  if (uint32_t raw = this->epoch_seconds; raw != 0) [[likely]] {
+  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 13, msg.key);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 2, msg.missing_state);
+  if (uint32_t raw = msg.epoch_seconds; raw != 0) [[likely]] {
     pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 29, raw);
   }
 #ifdef USE_DEVICES
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 4, this->device_id);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 4, msg.device_id);
 #endif
   return pos;
 }
-uint32_t DateTimeStateResponse::calculate_size() const {
+uint32_t DateTimeStateResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const DateTimeStateResponse *>(self);
   uint32_t size = 0;
   size += 5;
-  size += ProtoSize::calc_bool(1, this->missing_state);
-  size += ProtoSize::calc_fixed32(1, this->epoch_seconds);
+  size += ProtoSize::calc_bool(1, msg.missing_state);
+  size += ProtoSize::calc_fixed32(1, msg.epoch_seconds);
 #ifdef USE_DEVICES
-  size += ProtoSize::calc_uint32(1, this->device_id);
+  size += ProtoSize::calc_uint32(1, msg.device_id);
 #endif
   return size;
 }
@@ -3883,71 +4076,75 @@ bool DateTimeCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
 }
 #endif
 #ifdef USE_UPDATE
-uint8_t *ListEntitiesUpdateResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *ListEntitiesUpdateResponse::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const ListEntitiesUpdateResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 10, this->object_id);
-  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, this->key);
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, this->name);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 10, msg.object_id);
+  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, msg.key);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, msg.name);
 #ifdef USE_ENTITY_ICON
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 5, this->icon);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 5, msg.icon);
 #endif
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 6, this->disabled_by_default);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 7, static_cast<uint32_t>(this->entity_category));
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 8, this->device_class);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 6, msg.disabled_by_default);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 7, static_cast<uint32_t>(msg.entity_category));
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 8, msg.device_class);
 #ifdef USE_DEVICES
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 9, this->device_id);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 9, msg.device_id);
 #endif
   return pos;
 }
-uint32_t ListEntitiesUpdateResponse::calculate_size() const {
+uint32_t ListEntitiesUpdateResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const ListEntitiesUpdateResponse *>(self);
   uint32_t size = 0;
-  size += 2 + this->object_id.size();
+  size += 2 + msg.object_id.size();
   size += 5;
-  size += 2 + this->name.size();
+  size += 2 + msg.name.size();
 #ifdef USE_ENTITY_ICON
-  size += !this->icon.empty() ? 2 + this->icon.size() : 0;
+  size += !msg.icon.empty() ? 2 + msg.icon.size() : 0;
 #endif
-  size += ProtoSize::calc_bool(1, this->disabled_by_default);
-  size += this->entity_category ? 2 : 0;
-  size += !this->device_class.empty() ? 2 + this->device_class.size() : 0;
+  size += ProtoSize::calc_bool(1, msg.disabled_by_default);
+  size += msg.entity_category ? 2 : 0;
+  size += !msg.device_class.empty() ? 2 + msg.device_class.size() : 0;
 #ifdef USE_DEVICES
-  size += ProtoSize::calc_uint32(1, this->device_id);
+  size += ProtoSize::calc_uint32(1, msg.device_id);
 #endif
   return size;
 }
-uint8_t *UpdateStateResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *UpdateStateResponse::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const UpdateStateResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 13, this->key);
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 2, this->missing_state);
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 3, this->in_progress);
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 4, this->has_progress);
-  if (uint32_t raw = float_to_raw(this->progress); raw != 0) [[likely]] {
+  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 13, msg.key);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 2, msg.missing_state);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 3, msg.in_progress);
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 4, msg.has_progress);
+  if (uint32_t raw = float_to_raw(msg.progress); raw != 0) [[likely]] {
     pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 45, raw);
   }
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 6, this->current_version);
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 7, this->latest_version);
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 8, this->title);
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 9, this->release_summary);
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 10, this->release_url);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 6, msg.current_version);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 7, msg.latest_version);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 8, msg.title);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 9, msg.release_summary);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 10, msg.release_url);
 #ifdef USE_DEVICES
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 11, this->device_id);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 11, msg.device_id);
 #endif
   return pos;
 }
-uint32_t UpdateStateResponse::calculate_size() const {
+uint32_t UpdateStateResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const UpdateStateResponse *>(self);
   uint32_t size = 0;
   size += 5;
-  size += ProtoSize::calc_bool(1, this->missing_state);
-  size += ProtoSize::calc_bool(1, this->in_progress);
-  size += ProtoSize::calc_bool(1, this->has_progress);
-  size += ProtoSize::calc_float(1, this->progress);
-  size += ProtoSize::calc_length(1, this->current_version.size());
-  size += ProtoSize::calc_length(1, this->latest_version.size());
-  size += ProtoSize::calc_length(1, this->title.size());
-  size += ProtoSize::calc_length(1, this->release_summary.size());
-  size += ProtoSize::calc_length(1, this->release_url.size());
+  size += ProtoSize::calc_bool(1, msg.missing_state);
+  size += ProtoSize::calc_bool(1, msg.in_progress);
+  size += ProtoSize::calc_bool(1, msg.has_progress);
+  size += ProtoSize::calc_float(1, msg.progress);
+  size += ProtoSize::calc_length(1, msg.current_version.size());
+  size += ProtoSize::calc_length(1, msg.latest_version.size());
+  size += ProtoSize::calc_length(1, msg.title.size());
+  size += ProtoSize::calc_length(1, msg.release_summary.size());
+  size += ProtoSize::calc_length(1, msg.release_url.size());
 #ifdef USE_DEVICES
-  size += ProtoSize::calc_uint32(1, this->device_id);
+  size += ProtoSize::calc_uint32(1, msg.device_id);
 #endif
   return size;
 }
@@ -3992,16 +4189,18 @@ bool ZWaveProxyFrame::decode_length(uint32_t field_id, ProtoLengthDelimited valu
 }
 __attribute__((optimize("O2")))  // NOLINT(clang-diagnostic-unknown-attributes)
 uint8_t *
-ZWaveProxyFrame::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+ZWaveProxyFrame::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const ZWaveProxyFrame *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_bytes(pos PROTO_ENCODE_DEBUG_ARG, 1, this->data, this->data_len);
+  pos = ProtoEncode::encode_bytes(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.data, msg.data_len);
   return pos;
 }
 __attribute__((optimize("O2")))  // NOLINT(clang-diagnostic-unknown-attributes)
 uint32_t
-ZWaveProxyFrame::calculate_size() const {
+ZWaveProxyFrame::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const ZWaveProxyFrame *>(self);
   uint32_t size = 0;
-  size += ProtoSize::calc_length(1, this->data_len);
+  size += ProtoSize::calc_length(1, msg.data_len);
   return size;
 }
 bool ZWaveProxyRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
@@ -4026,64 +4225,70 @@ bool ZWaveProxyRequest::decode_length(uint32_t field_id, ProtoLengthDelimited va
   }
   return true;
 }
-uint8_t *ZWaveProxyRequest::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *ZWaveProxyRequest::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const ZWaveProxyRequest *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 1, static_cast<uint32_t>(this->type));
-  pos = ProtoEncode::encode_bytes(pos PROTO_ENCODE_DEBUG_ARG, 2, this->data, this->data_len);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 1, static_cast<uint32_t>(msg.type));
+  pos = ProtoEncode::encode_bytes(pos PROTO_ENCODE_DEBUG_ARG, 2, msg.data, msg.data_len);
   return pos;
 }
-uint32_t ZWaveProxyRequest::calculate_size() const {
+uint32_t ZWaveProxyRequest::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const ZWaveProxyRequest *>(self);
   uint32_t size = 0;
-  size += this->type ? 2 : 0;
-  size += ProtoSize::calc_length(1, this->data_len);
+  size += msg.type ? 2 : 0;
+  size += ProtoSize::calc_length(1, msg.data_len);
   return size;
 }
-uint8_t *ZWaveProxyRequestResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *ZWaveProxyRequestResponse::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const ZWaveProxyRequestResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 1, static_cast<uint32_t>(this->type));
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, static_cast<uint32_t>(this->status));
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 1, static_cast<uint32_t>(msg.type));
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, static_cast<uint32_t>(msg.status));
   return pos;
 }
-uint32_t ZWaveProxyRequestResponse::calculate_size() const {
+uint32_t ZWaveProxyRequestResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const ZWaveProxyRequestResponse *>(self);
   uint32_t size = 0;
-  size += this->type ? 2 : 0;
-  size += this->status ? 2 : 0;
+  size += msg.type ? 2 : 0;
+  size += msg.status ? 2 : 0;
   return size;
 }
 #endif
 #ifdef USE_INFRARED
-uint8_t *ListEntitiesInfraredResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *ListEntitiesInfraredResponse::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const ListEntitiesInfraredResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 10, this->object_id);
-  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, this->key);
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, this->name);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 10, msg.object_id);
+  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, msg.key);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, msg.name);
 #ifdef USE_ENTITY_ICON
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 4, this->icon);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 4, msg.icon);
 #endif
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 5, this->disabled_by_default);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 6, static_cast<uint32_t>(this->entity_category));
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 5, msg.disabled_by_default);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 6, static_cast<uint32_t>(msg.entity_category));
 #ifdef USE_DEVICES
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 7, this->device_id);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 7, msg.device_id);
 #endif
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 8, this->capabilities);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 9, this->receiver_frequency);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 8, msg.capabilities);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 9, msg.receiver_frequency);
   return pos;
 }
-uint32_t ListEntitiesInfraredResponse::calculate_size() const {
+uint32_t ListEntitiesInfraredResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const ListEntitiesInfraredResponse *>(self);
   uint32_t size = 0;
-  size += 2 + this->object_id.size();
+  size += 2 + msg.object_id.size();
   size += 5;
-  size += 2 + this->name.size();
+  size += 2 + msg.name.size();
 #ifdef USE_ENTITY_ICON
-  size += !this->icon.empty() ? 2 + this->icon.size() : 0;
+  size += !msg.icon.empty() ? 2 + msg.icon.size() : 0;
 #endif
-  size += ProtoSize::calc_bool(1, this->disabled_by_default);
-  size += this->entity_category ? 2 : 0;
+  size += ProtoSize::calc_bool(1, msg.disabled_by_default);
+  size += msg.entity_category ? 2 : 0;
 #ifdef USE_DEVICES
-  size += ProtoSize::calc_uint32(1, this->device_id);
+  size += ProtoSize::calc_uint32(1, msg.device_id);
 #endif
-  size += ProtoSize::calc_uint32(1, this->capabilities);
-  size += ProtoSize::calc_uint32(1, this->receiver_frequency);
+  size += ProtoSize::calc_uint32(1, msg.capabilities);
+  size += ProtoSize::calc_uint32(1, msg.receiver_frequency);
   return size;
 }
 #endif
@@ -4134,27 +4339,29 @@ bool InfraredRFTransmitRawTimingsRequest::decode_32bit(uint32_t field_id, Proto3
 }
 __attribute__((optimize("O2")))  // NOLINT(clang-diagnostic-unknown-attributes)
 uint8_t *
-InfraredRFReceiveEvent::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+InfraredRFReceiveEvent::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const InfraredRFReceiveEvent *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
 #ifdef USE_DEVICES
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 1, this->device_id);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.device_id);
 #endif
-  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, this->key);
-  for (const auto &it : *this->timings) {
+  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, msg.key);
+  for (const auto &it : *msg.timings) {
     pos = ProtoEncode::encode_sint32_force(pos PROTO_ENCODE_DEBUG_ARG, 3, it);
   }
   return pos;
 }
 __attribute__((optimize("O2")))  // NOLINT(clang-diagnostic-unknown-attributes)
 uint32_t
-InfraredRFReceiveEvent::calculate_size() const {
+InfraredRFReceiveEvent::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const InfraredRFReceiveEvent *>(self);
   uint32_t size = 0;
 #ifdef USE_DEVICES
-  size += ProtoSize::calc_uint32(1, this->device_id);
+  size += ProtoSize::calc_uint32(1, msg.device_id);
 #endif
   size += 5;
-  if (!this->timings->empty()) {
-    for (const auto &it : *this->timings) {
+  if (!msg.timings->empty()) {
+    for (const auto &it : *msg.timings) {
       size += ProtoSize::calc_sint32_force(1, it);
     }
   }
@@ -4162,42 +4369,45 @@ InfraredRFReceiveEvent::calculate_size() const {
 }
 #endif
 #ifdef USE_RADIO_FREQUENCY
-uint8_t *ListEntitiesRadioFrequencyResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *ListEntitiesRadioFrequencyResponse::encode_msg(const void *self,
+                                                        ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const ListEntitiesRadioFrequencyResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 10, this->object_id);
-  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, this->key);
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, this->name);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 10, msg.object_id);
+  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, msg.key);
+  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, msg.name);
 #ifdef USE_ENTITY_ICON
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 4, this->icon);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 4, msg.icon);
 #endif
-  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 5, this->disabled_by_default);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 6, static_cast<uint32_t>(this->entity_category));
+  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 5, msg.disabled_by_default);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 6, static_cast<uint32_t>(msg.entity_category));
 #ifdef USE_DEVICES
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 7, this->device_id);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 7, msg.device_id);
 #endif
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 8, this->capabilities);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 9, this->frequency_min);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 10, this->frequency_max);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 11, this->supported_modulations);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 8, msg.capabilities);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 9, msg.frequency_min);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 10, msg.frequency_max);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 11, msg.supported_modulations);
   return pos;
 }
-uint32_t ListEntitiesRadioFrequencyResponse::calculate_size() const {
+uint32_t ListEntitiesRadioFrequencyResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const ListEntitiesRadioFrequencyResponse *>(self);
   uint32_t size = 0;
-  size += 2 + this->object_id.size();
+  size += 2 + msg.object_id.size();
   size += 5;
-  size += 2 + this->name.size();
+  size += 2 + msg.name.size();
 #ifdef USE_ENTITY_ICON
-  size += !this->icon.empty() ? 2 + this->icon.size() : 0;
+  size += !msg.icon.empty() ? 2 + msg.icon.size() : 0;
 #endif
-  size += ProtoSize::calc_bool(1, this->disabled_by_default);
-  size += this->entity_category ? 2 : 0;
+  size += ProtoSize::calc_bool(1, msg.disabled_by_default);
+  size += msg.entity_category ? 2 : 0;
 #ifdef USE_DEVICES
-  size += ProtoSize::calc_uint32(1, this->device_id);
+  size += ProtoSize::calc_uint32(1, msg.device_id);
 #endif
-  size += ProtoSize::calc_uint32(1, this->capabilities);
-  size += ProtoSize::calc_uint32(1, this->frequency_min);
-  size += ProtoSize::calc_uint32(1, this->frequency_max);
-  size += ProtoSize::calc_uint32(1, this->supported_modulations);
+  size += ProtoSize::calc_uint32(1, msg.capabilities);
+  size += ProtoSize::calc_uint32(1, msg.frequency_min);
+  size += ProtoSize::calc_uint32(1, msg.frequency_max);
+  size += ProtoSize::calc_uint32(1, msg.supported_modulations);
   return size;
 }
 #endif
@@ -4229,18 +4439,20 @@ bool SerialProxyConfigureRequest::decode_varint(uint32_t field_id, proto_varint_
 }
 __attribute__((optimize("O2")))  // NOLINT(clang-diagnostic-unknown-attributes)
 uint8_t *
-SerialProxyDataReceived::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+SerialProxyDataReceived::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const SerialProxyDataReceived *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 1, this->instance);
-  pos = ProtoEncode::encode_bytes(pos PROTO_ENCODE_DEBUG_ARG, 2, this->data_ptr_, this->data_len_);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.instance);
+  pos = ProtoEncode::encode_bytes(pos PROTO_ENCODE_DEBUG_ARG, 2, msg.data_ptr_, msg.data_len_);
   return pos;
 }
 __attribute__((optimize("O2")))  // NOLINT(clang-diagnostic-unknown-attributes)
 uint32_t
-SerialProxyDataReceived::calculate_size() const {
+SerialProxyDataReceived::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const SerialProxyDataReceived *>(self);
   uint32_t size = 0;
-  size += ProtoSize::calc_uint32(1, this->instance);
-  size += ProtoSize::calc_length(1, this->data_len_);
+  size += ProtoSize::calc_uint32(1, msg.instance);
+  size += ProtoSize::calc_length(1, msg.data_len_);
   return size;
 }
 bool SerialProxyWriteRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
@@ -4288,18 +4500,21 @@ bool SerialProxyGetModemPinsRequest::decode_varint(uint32_t field_id, proto_vari
   }
   return true;
 }
-uint8_t *SerialProxyGetModemPinsResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *SerialProxyGetModemPinsResponse::encode_msg(const void *self,
+                                                     ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const SerialProxyGetModemPinsResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 1, this->instance);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, this->line_states);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 3, static_cast<uint32_t>(this->status));
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.instance);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, msg.line_states);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 3, static_cast<uint32_t>(msg.status));
   return pos;
 }
-uint32_t SerialProxyGetModemPinsResponse::calculate_size() const {
+uint32_t SerialProxyGetModemPinsResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const SerialProxyGetModemPinsResponse *>(self);
   uint32_t size = 0;
-  size += ProtoSize::calc_uint32(1, this->instance);
-  size += ProtoSize::calc_uint32(1, this->line_states);
-  size += this->status ? 2 : 0;
+  size += ProtoSize::calc_uint32(1, msg.instance);
+  size += ProtoSize::calc_uint32(1, msg.line_states);
+  size += msg.status ? 2 : 0;
   return size;
 }
 bool SerialProxyRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
@@ -4315,20 +4530,22 @@ bool SerialProxyRequest::decode_varint(uint32_t field_id, proto_varint_value_t v
   }
   return true;
 }
-uint8_t *SerialProxyRequestResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *SerialProxyRequestResponse::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const SerialProxyRequestResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 1, this->instance);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, static_cast<uint32_t>(this->type));
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 3, static_cast<uint32_t>(this->status));
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 4, this->error_message);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.instance);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, static_cast<uint32_t>(msg.type));
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 3, static_cast<uint32_t>(msg.status));
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 4, msg.error_message);
   return pos;
 }
-uint32_t SerialProxyRequestResponse::calculate_size() const {
+uint32_t SerialProxyRequestResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const SerialProxyRequestResponse *>(self);
   uint32_t size = 0;
-  size += ProtoSize::calc_uint32(1, this->instance);
-  size += this->type ? 2 : 0;
-  size += this->status ? 2 : 0;
-  size += ProtoSize::calc_length(1, this->error_message.size());
+  size += ProtoSize::calc_uint32(1, msg.instance);
+  size += msg.type ? 2 : 0;
+  size += msg.status ? 2 : 0;
+  size += ProtoSize::calc_length(1, msg.error_message.size());
   return size;
 }
 #endif
@@ -4355,16 +4572,19 @@ bool BluetoothSetConnectionParamsRequest::decode_varint(uint32_t field_id, proto
   }
   return true;
 }
-uint8_t *BluetoothSetConnectionParamsResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *BluetoothSetConnectionParamsResponse::encode_msg(const void *self,
+                                                          ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const BluetoothSetConnectionParamsResponse *>(self);
   uint8_t *__restrict__ pos = buffer.get_pos();
-  pos = ProtoEncode::encode_uint64(pos PROTO_ENCODE_DEBUG_ARG, 1, this->address);
-  pos = ProtoEncode::encode_int32(pos PROTO_ENCODE_DEBUG_ARG, 2, this->error);
+  pos = ProtoEncode::encode_uint64(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.address);
+  pos = ProtoEncode::encode_int32(pos PROTO_ENCODE_DEBUG_ARG, 2, msg.error);
   return pos;
 }
-uint32_t BluetoothSetConnectionParamsResponse::calculate_size() const {
+uint32_t BluetoothSetConnectionParamsResponse::calc_size_msg(const void *self) {
+  const auto &msg = *static_cast<const BluetoothSetConnectionParamsResponse *>(self);
   uint32_t size = 0;
-  size += ProtoSize::calc_uint64(1, this->address);
-  size += ProtoSize::calc_int32(1, this->error);
+  size += ProtoSize::calc_uint64(1, msg.address);
+  size += ProtoSize::calc_int32(1, msg.error);
   return size;
 }
 #endif
diff --git a/esphome/components/api/api_pb2.h b/esphome/components/api/api_pb2.h
index 5c3429a63a..0c33ac5bc2 100644
--- a/esphome/components/api/api_pb2.h
+++ b/esphome/components/api/api_pb2.h
@@ -438,8 +438,12 @@ class HelloResponse final : public ProtoMessage {
   uint32_t api_version_minor{0};
   StringRef server_info{};
   StringRef name{};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -454,8 +458,12 @@ class DisconnectRequest final : public ProtoDecodableMessage {
   const LogString *message_name() const override { return LOG_STR("disconnect_request"); }
 #endif
   enums::DisconnectReason reason{};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -507,8 +515,12 @@ class AreaInfo final : public ProtoMessage {
  public:
   uint32_t area_id{0};
   StringRef name{};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -522,8 +534,12 @@ class DeviceInfo final : public ProtoMessage {
   uint32_t device_id{0};
   StringRef name{};
   uint32_t area_id{0};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -537,8 +553,12 @@ class SerialProxyInfo final : public ProtoMessage {
   StringRef name{};
   enums::SerialProxyPortType port_type{};
   uint32_t configured_line_states{0};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -608,8 +628,12 @@ class DeviceInfoResponse final : public ProtoMessage {
 #ifdef USE_API_NOISE
   bool api_encryption_provisionable{false};
 #endif
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -621,8 +645,12 @@ class BluetoothProxyCapabilities final : public ProtoMessage {
  public:
   uint32_t feature_flags{0};
   StringRef mac_address{};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -634,8 +662,12 @@ class BluetoothProxyCapabilities final : public ProtoMessage {
 class VoiceAssistantCapabilities final : public ProtoMessage {
  public:
   uint32_t feature_flags{0};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -648,8 +680,12 @@ class ZWaveProxyCapabilities final : public ProtoMessage {
  public:
   uint32_t feature_flags{0};
   uint32_t home_id{0};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -676,8 +712,12 @@ class DeviceCapabilitiesResponse final : public ProtoMessage {
 #ifdef USE_SERIAL_PROXY
   std::array<SerialProxyInfo, SERIAL_PROXY_COUNT> serial_proxies{};
 #endif
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -707,8 +747,12 @@ class ListEntitiesBinarySensorResponse final : public InfoResponseProtoMessage {
 #endif
   StringRef device_class{};
   bool is_status_binary_sensor{false};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -724,8 +768,12 @@ class BinarySensorStateResponse final : public StateResponseProtoMessage {
 #endif
   bool state{false};
   bool missing_state{false};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -746,8 +794,12 @@ class ListEntitiesCoverResponse final : public InfoResponseProtoMessage {
   bool supports_tilt{false};
   StringRef device_class{};
   bool supports_stop{false};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -764,8 +816,12 @@ class CoverStateResponse final : public StateResponseProtoMessage {
   float position{0.0f};
   float tilt{0.0f};
   enums::CoverOperation current_operation{};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -806,8 +862,12 @@ class ListEntitiesFanResponse final : public InfoResponseProtoMessage {
   bool supports_direction{false};
   int32_t supported_speed_count{0};
   const std::vector<const char *> *supported_preset_modes{};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -826,8 +886,12 @@ class FanStateResponse final : public StateResponseProtoMessage {
   enums::FanDirection direction{};
   int32_t speed_level{0};
   StringRef preset_mode{};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -873,8 +937,12 @@ class ListEntitiesLightResponse final : public InfoResponseProtoMessage {
   float min_mireds{0.0f};
   float max_mireds{0.0f};
   const FixedVector<const char *> *effects{};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -900,8 +968,12 @@ class LightStateResponse final : public StateResponseProtoMessage {
   float cold_white{0.0f};
   float warm_white{0.0f};
   StringRef effect{};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -964,8 +1036,12 @@ class ListEntitiesSensorResponse final : public InfoResponseProtoMessage {
   bool force_update{false};
   StringRef device_class{};
   enums::SensorStateClass state_class{};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -981,8 +1057,12 @@ class SensorStateResponse final : public StateResponseProtoMessage {
 #endif
   float state{0.0f};
   bool missing_state{false};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -1000,8 +1080,12 @@ class ListEntitiesSwitchResponse final : public InfoResponseProtoMessage {
 #endif
   bool assumed_state{false};
   StringRef device_class{};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -1016,8 +1100,12 @@ class SwitchStateResponse final : public StateResponseProtoMessage {
   const LogString *message_name() const override { return LOG_STR("switch_state_response"); }
 #endif
   bool state{false};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -1050,8 +1138,12 @@ class ListEntitiesTextSensorResponse final : public InfoResponseProtoMessage {
   const LogString *message_name() const override { return LOG_STR("list_entities_text_sensor_response"); }
 #endif
   StringRef device_class{};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -1067,8 +1159,12 @@ class TextSensorStateResponse final : public StateResponseProtoMessage {
 #endif
   StringRef state{};
   bool missing_state{false};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -1106,8 +1202,12 @@ class SubscribeLogsResponse final : public ProtoMessage {
     this->message_ptr_ = data;
     this->message_len_ = len;
   }
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -1139,8 +1239,12 @@ class NoiseEncryptionSetKeyResponse final : public ProtoMessage {
   const LogString *message_name() const override { return LOG_STR("noise_encryption_set_key_response"); }
 #endif
   bool success{false};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -1153,8 +1257,12 @@ class HomeassistantServiceMap final : public ProtoMessage {
  public:
   StringRef key{};
   StringRef value{};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -1182,8 +1290,12 @@ class HomeassistantActionRequest final : public ProtoMessage {
 #ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
   StringRef response_template{};
 #endif
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -1226,8 +1338,12 @@ class SubscribeHomeAssistantStateResponse final : public ProtoMessage {
   StringRef entity_id{};
   StringRef attribute{};
   bool once{false};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -1323,8 +1439,12 @@ class ListEntitiesServicesArgument final : public ProtoMessage {
 #ifdef USE_API_USER_DEFINED_ACTION_METADATA
   StringRef example{};
 #endif
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -1345,8 +1465,12 @@ class ListEntitiesServicesResponse final : public ProtoMessage {
 #ifdef USE_API_USER_DEFINED_ACTION_METADATA
   StringRef description{};
 #endif
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -1415,8 +1539,12 @@ class ExecuteServiceResponse final : public ProtoMessage {
   const uint8_t *response_data{nullptr};
   uint16_t response_data_len{0};
 #endif
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -1432,8 +1560,12 @@ class ListEntitiesCameraResponse final : public InfoResponseProtoMessage {
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const LogString *message_name() const override { return LOG_STR("list_entities_camera_response"); }
 #endif
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -1454,8 +1586,12 @@ class CameraImageResponse final : public StateResponseProtoMessage {
     this->data_len_ = len;
   }
   bool done{false};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -1506,8 +1642,12 @@ class ListEntitiesClimateResponse final : public InfoResponseProtoMessage {
   float visual_max_humidity{0.0f};
   uint32_t feature_flags{0};
   enums::TemperatureUnit temperature_unit{};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -1534,8 +1674,12 @@ class ClimateStateResponse final : public StateResponseProtoMessage {
   StringRef custom_preset{};
   float current_humidity{0.0f};
   float target_humidity{0.0f};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -1593,8 +1737,12 @@ class ListEntitiesWaterHeaterResponse final : public InfoResponseProtoMessage {
   const water_heater::WaterHeaterModeMask *supported_modes{};
   uint32_t supported_features{0};
   enums::TemperatureUnit temperature_unit{};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -1614,8 +1762,12 @@ class WaterHeaterStateResponse final : public StateResponseProtoMessage {
   uint32_t state{0};
   float target_temperature_low{0.0f};
   float target_temperature_high{0.0f};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -1658,8 +1810,12 @@ class ListEntitiesNumberResponse final : public InfoResponseProtoMessage {
   StringRef unit_of_measurement{};
   enums::NumberMode mode{};
   StringRef device_class{};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -1675,8 +1831,12 @@ class NumberStateResponse final : public StateResponseProtoMessage {
 #endif
   float state{0.0f};
   bool missing_state{false};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -1709,8 +1869,12 @@ class ListEntitiesSelectResponse final : public InfoResponseProtoMessage {
   const LogString *message_name() const override { return LOG_STR("list_entities_select_response"); }
 #endif
   const FixedVector<const char *> *options{};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -1726,8 +1890,12 @@ class SelectStateResponse final : public StateResponseProtoMessage {
 #endif
   StringRef state{};
   bool missing_state{false};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -1763,8 +1931,12 @@ class ListEntitiesSirenResponse final : public InfoResponseProtoMessage {
   const FixedVector<const char *> *tones{};
   bool supports_duration{false};
   bool supports_volume{false};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -1779,8 +1951,12 @@ class SirenStateResponse final : public StateResponseProtoMessage {
   const LogString *message_name() const override { return LOG_STR("siren_state_response"); }
 #endif
   bool state{false};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -1824,8 +2000,12 @@ class ListEntitiesLockResponse final : public InfoResponseProtoMessage {
   bool supports_open{false};
   bool requires_code{false};
   StringRef code_format{};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -1840,8 +2020,12 @@ class LockStateResponse final : public StateResponseProtoMessage {
   const LogString *message_name() const override { return LOG_STR("lock_state_response"); }
 #endif
   enums::LockState state{};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -1877,8 +2061,12 @@ class ListEntitiesButtonResponse final : public InfoResponseProtoMessage {
   const LogString *message_name() const override { return LOG_STR("list_entities_button_response"); }
 #endif
   StringRef device_class{};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -1909,8 +2097,12 @@ class MediaPlayerSupportedFormat final : public ProtoMessage {
   uint32_t num_channels{0};
   enums::MediaPlayerFormatPurpose purpose{};
   uint32_t sample_bytes{0};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -1926,8 +2118,12 @@ class ListEntitiesMediaPlayerResponse final : public InfoResponseProtoMessage {
 #endif
   std::vector<MediaPlayerSupportedFormat> supported_formats{};
   uint32_t feature_flags{0};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -1944,8 +2140,12 @@ class MediaPlayerStateResponse final : public StateResponseProtoMessage {
   enums::MediaPlayerState state{};
   float volume{0.0f};
   bool muted{false};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -2015,8 +2215,12 @@ class BluetoothLERawAdvertisementsResponse final : public ProtoMessage {
 #endif
   std::array<BluetoothLERawAdvertisement, BLUETOOTH_PROXY_ADVERTISEMENT_BATCH_SIZE> advertisements{};
   uint16_t advertisements_len{0};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -2054,8 +2258,12 @@ class BluetoothDeviceConnectionResponse final : public ProtoMessage {
   bool connected{false};
   uint32_t mtu{0};
   int32_t error{0};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -2082,8 +2290,12 @@ class BluetoothGATTDescriptor final : public ProtoMessage {
   std::array<uint64_t, 2> uuid{};
   uint32_t handle{0};
   uint32_t short_uuid{0};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -2097,8 +2309,12 @@ class BluetoothGATTCharacteristic final : public ProtoMessage {
   uint32_t properties{0};
   FixedVector<BluetoothGATTDescriptor> descriptors{};
   uint32_t short_uuid{0};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -2111,8 +2327,12 @@ class BluetoothGATTService final : public ProtoMessage {
   uint32_t handle{0};
   FixedVector<BluetoothGATTCharacteristic> characteristics{};
   uint32_t short_uuid{0};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -2128,8 +2348,12 @@ class BluetoothGATTGetServicesResponse final : public ProtoMessage {
 #endif
   uint64_t address{0};
   std::vector<BluetoothGATTService> services{};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -2144,8 +2368,12 @@ class BluetoothGATTGetServicesDoneResponse final : public ProtoMessage {
   const LogString *message_name() const override { return LOG_STR("bluetooth_gatt_get_services_done_response"); }
 #endif
   uint64_t address{0};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -2183,8 +2411,12 @@ class BluetoothGATTReadResponse final : public ProtoMessage {
     this->data_ptr_ = data;
     this->data_len_ = len;
   }
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -2278,8 +2510,12 @@ class BluetoothGATTNotifyDataResponse final : public ProtoMessage {
     this->data_ptr_ = data;
     this->data_len_ = len;
   }
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -2296,8 +2532,12 @@ class BluetoothConnectionsFreeResponse final : public ProtoMessage {
   uint32_t free{0};
   uint32_t limit{0};
   std::array<uint64_t, BLUETOOTH_PROXY_MAX_CONNECTIONS> allocated{};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -2314,8 +2554,12 @@ class BluetoothGATTErrorResponse final : public ProtoMessage {
   uint64_t address{0};
   uint32_t handle{0};
   int32_t error{0};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -2331,8 +2575,12 @@ class BluetoothGATTWriteResponse final : public ProtoMessage {
 #endif
   uint64_t address{0};
   uint32_t handle{0};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -2348,8 +2596,12 @@ class BluetoothGATTNotifyResponse final : public ProtoMessage {
 #endif
   uint64_t address{0};
   uint32_t handle{0};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -2366,8 +2618,12 @@ class BluetoothDevicePairingResponse final : public ProtoMessage {
   uint64_t address{0};
   bool paired{false};
   int32_t error{0};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -2384,8 +2640,12 @@ class BluetoothDeviceUnpairingResponse final : public ProtoMessage {
   uint64_t address{0};
   bool success{false};
   int32_t error{0};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -2402,8 +2662,12 @@ class BluetoothDeviceClearCacheResponse final : public ProtoMessage {
   uint64_t address{0};
   bool success{false};
   int32_t error{0};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -2422,8 +2686,12 @@ class BluetoothScannerStateResponse final : public ProtoMessage {
   enums::BluetoothScannerState state{};
   enums::BluetoothScannerMode mode{};
   enums::BluetoothScannerMode configured_mode{};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -2468,8 +2736,12 @@ class VoiceAssistantAudioSettings final : public ProtoMessage {
   uint32_t noise_suppression_level{0};
   uint32_t auto_gain{0};
   float volume_multiplier{0.0f};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -2488,8 +2760,12 @@ class VoiceAssistantRequest final : public ProtoMessage {
   uint32_t flags{0};
   VoiceAssistantAudioSettings audio_settings{};
   StringRef wake_word_phrase{};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -2552,8 +2828,12 @@ class VoiceAssistantAudio final : public ProtoDecodableMessage {
   bool end{false};
   const uint8_t *data2{nullptr};
   uint16_t data2_len{0};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -2610,8 +2890,12 @@ class VoiceAssistantAnnounceFinished final : public ProtoMessage {
   const LogString *message_name() const override { return LOG_STR("voice_assistant_announce_finished"); }
 #endif
   bool success{false};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -2623,8 +2907,12 @@ class VoiceAssistantWakeWord final : public ProtoMessage {
   StringRef id{};
   StringRef wake_word{};
   std::vector<std::string> trained_languages{};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -2673,8 +2961,12 @@ class VoiceAssistantConfigurationResponse final : public ProtoMessage {
   std::vector<VoiceAssistantWakeWord> available_wake_words{};
   const std::vector<std::string> *active_wake_words{};
   uint32_t max_active_wake_words{0};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -2708,8 +3000,12 @@ class ListEntitiesAlarmControlPanelResponse final : public InfoResponseProtoMess
   uint32_t supported_features{0};
   bool requires_code{false};
   bool requires_code_to_arm{false};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -2724,8 +3020,12 @@ class AlarmControlPanelStateResponse final : public StateResponseProtoMessage {
   const LogString *message_name() const override { return LOG_STR("alarm_control_panel_state_response"); }
 #endif
   enums::AlarmControlPanelState state{};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -2763,8 +3063,12 @@ class ListEntitiesTextResponse final : public InfoResponseProtoMessage {
   uint32_t max_length{0};
   StringRef pattern{};
   enums::TextMode mode{};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -2780,8 +3084,12 @@ class TextStateResponse final : public StateResponseProtoMessage {
 #endif
   StringRef state{};
   bool missing_state{false};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -2814,8 +3122,12 @@ class ListEntitiesDateResponse final : public InfoResponseProtoMessage {
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const LogString *message_name() const override { return LOG_STR("list_entities_date_response"); }
 #endif
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -2833,8 +3145,12 @@ class DateStateResponse final : public StateResponseProtoMessage {
   uint32_t year{0};
   uint32_t month{0};
   uint32_t day{0};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -2868,8 +3184,12 @@ class ListEntitiesTimeResponse final : public InfoResponseProtoMessage {
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const LogString *message_name() const override { return LOG_STR("list_entities_time_response"); }
 #endif
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -2887,8 +3207,12 @@ class TimeStateResponse final : public StateResponseProtoMessage {
   uint32_t hour{0};
   uint32_t minute{0};
   uint32_t second{0};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -2924,8 +3248,12 @@ class ListEntitiesEventResponse final : public InfoResponseProtoMessage {
 #endif
   StringRef device_class{};
   const FixedVector<const char *> *event_types{};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -2940,8 +3268,12 @@ class EventResponse final : public StateResponseProtoMessage {
   const LogString *message_name() const override { return LOG_STR("event_response"); }
 #endif
   StringRef event_type{};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -2961,8 +3293,12 @@ class ListEntitiesValveResponse final : public InfoResponseProtoMessage {
   bool assumed_state{false};
   bool supports_position{false};
   bool supports_stop{false};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -2978,8 +3314,12 @@ class ValveStateResponse final : public StateResponseProtoMessage {
 #endif
   float position{0.0f};
   enums::ValveOperation current_operation{};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -3013,8 +3353,12 @@ class ListEntitiesDateTimeResponse final : public InfoResponseProtoMessage {
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const LogString *message_name() const override { return LOG_STR("list_entities_date_time_response"); }
 #endif
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -3030,8 +3374,12 @@ class DateTimeStateResponse final : public StateResponseProtoMessage {
 #endif
   bool missing_state{false};
   uint32_t epoch_seconds{0};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -3064,8 +3412,12 @@ class ListEntitiesUpdateResponse final : public InfoResponseProtoMessage {
   const LogString *message_name() const override { return LOG_STR("list_entities_update_response"); }
 #endif
   StringRef device_class{};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -3088,8 +3440,12 @@ class UpdateStateResponse final : public StateResponseProtoMessage {
   StringRef title{};
   StringRef release_summary{};
   StringRef release_url{};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -3123,8 +3479,12 @@ class ZWaveProxyFrame final : public ProtoDecodableMessage {
 #endif
   const uint8_t *data{nullptr};
   uint16_t data_len{0};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -3142,8 +3502,12 @@ class ZWaveProxyRequest final : public ProtoDecodableMessage {
   enums::ZWaveProxyRequestType type{};
   const uint8_t *data{nullptr};
   uint16_t data_len{0};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -3161,8 +3525,12 @@ class ZWaveProxyRequestResponse final : public ProtoMessage {
 #endif
   enums::ZWaveProxyRequestType type{};
   enums::ZWaveProxyStatus status{};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -3180,8 +3548,12 @@ class ListEntitiesInfraredResponse final : public InfoResponseProtoMessage {
 #endif
   uint32_t capabilities{0};
   uint32_t receiver_frequency{0};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -3228,8 +3600,12 @@ class InfraredRFReceiveEvent final : public ProtoMessage {
 #endif
   uint32_t key{0};
   const std::vector<int32_t> *timings{};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -3249,8 +3625,12 @@ class ListEntitiesRadioFrequencyResponse final : public InfoResponseProtoMessage
   uint32_t frequency_min{0};
   uint32_t frequency_max{0};
   uint32_t supported_modulations{0};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -3293,8 +3673,12 @@ class SerialProxyDataReceived final : public ProtoMessage {
     this->data_ptr_ = data;
     this->data_len_ = len;
   }
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -3360,8 +3744,12 @@ class SerialProxyGetModemPinsResponse final : public ProtoMessage {
   uint32_t instance{0};
   uint32_t line_states{0};
   enums::SerialProxyStatus status{};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -3395,8 +3783,12 @@ class SerialProxyRequestResponse final : public ProtoMessage {
   enums::SerialProxyRequestType type{};
   enums::SerialProxyStatus status{};
   StringRef error_message{};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -3433,8 +3825,12 @@ class BluetoothSetConnectionParamsResponse final : public ProtoMessage {
 #endif
   uint64_t address{0};
   int32_t error{0};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+    return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);
+  }
+  static uint32_t calc_size_msg(const void *self);
+  uint32_t calculate_size() const { return calc_size_msg(this); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif
diff --git a/esphome/components/api/proto.h b/esphome/components/api/proto.h
index 0d6b455a0e..f0ac0b346f 100644
--- a/esphome/components/api/proto.h
+++ b/esphome/components/api/proto.h
@@ -697,6 +697,14 @@ class ProtoMessage {
   // All call sites use templates to preserve the concrete type, so virtual
   // dispatch is not needed. This eliminates per-message vtable entries for
   // encode/calculate_size, saving ~1.3 KB of flash across all message types.
+  //
+  // encode_msg/calc_size_msg are the type-erased entry points: generated messages define them as
+  // static functions over const void *, so &T::encode_msg is passed directly where a function
+  // pointer is needed and no per-type thunk exists. The member forms forward to them.
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+    return buffer.get_pos();
+  }
+  static uint32_t calc_size_msg(const void *self) { return 0; }
   uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const { return buffer.get_pos(); }
   uint32_t calculate_size() const { return 0; }
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -944,19 +952,14 @@ class ProtoSize {
 
 // Implementation of methods that depend on ProtoSize being fully defined
 
-// Encode thunk — converts void* back to concrete type for direct encode() call
-template<typename T> uint8_t *proto_encode_msg(const void *msg, ProtoWriteBuffer &buf PROTO_ENCODE_DEBUG_PARAM) {
-  return static_cast<const T *>(msg)->encode(buf PROTO_ENCODE_DEBUG_ARG);
-}
-
 // Thin template wrapper; delegates to non-template core in proto.cpp.
 template<typename T> inline void ProtoWriteBuffer::encode_sub_message(uint32_t field_id, const T &value) {
-  this->encode_sub_message(field_id, &value, &proto_encode_msg<T>);
+  this->encode_sub_message(field_id, &value, &T::encode_msg);
 }
 
 // Thin template wrapper; delegates to non-template core.
 template<typename T> inline void ProtoWriteBuffer::encode_optional_sub_message(uint32_t field_id, const T &value) {
-  this->encode_optional_sub_message(field_id, value.calculate_size(), &value, &proto_encode_msg<T>);
+  this->encode_optional_sub_message(field_id, T::calc_size_msg(&value), &value, &T::encode_msg);
 }
 
 // Template decode_to_message - preserves concrete type so decode() resolves statically
diff --git a/script/api_protobuf/api_protobuf.py b/script/api_protobuf/api_protobuf.py
index 561eb296cb..0131c75484 100755
--- a/script/api_protobuf/api_protobuf.py
+++ b/script/api_protobuf/api_protobuf.py
@@ -2841,28 +2841,39 @@ def build_message_type(
             )
             for line in encode
         ]
-        o = f"{speed_attr}uint8_t *{desc.name}::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {{\n"
+        # The body is a static function taking the message as const void *, so its address is
+        # already a MessageEncodeFn and callers need no per-type thunk. The member encode() below
+        # forwards to it for direct callers.
+        o = f"{speed_attr}uint8_t *{desc.name}::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {{\n"
+        o += f"  const auto &msg = *static_cast<const {desc.name} *>(self);\n"
         o += "  uint8_t *__restrict__ pos = buffer.get_pos();\n"
-        o += indent("\n".join(encode_debug)) + "\n"
+        o += indent("\n".join(encode_debug)).replace("this->", "msg.") + "\n"
         o += "  return pos;\n"
         o += "}\n"
         cpp += o
-        prot = (
-            "uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;"
+        public_content.append(
+            "static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);"
+        )
+        public_content.append(
+            "uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {\n"
+            "  return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);\n"
+            "}"
         )
-        public_content.append(prot)
     # If no fields to encode or message doesn't need encoding, the default implementation in ProtoMessage will be used
 
     # Add calculate_size method only if this message needs encoding and has fields
     if needs_encode and size_calc and not is_inline_only:
-        o = f"{speed_attr}uint32_t {desc.name}::calculate_size() const {{\n"
+        o = f"{speed_attr}uint32_t {desc.name}::calc_size_msg(const void *self) {{\n"
+        o += f"  const auto &msg = *static_cast<const {desc.name} *>(self);\n"
         o += "  uint32_t size = 0;\n"
-        o += indent("\n".join(size_calc)) + "\n"
+        o += indent("\n".join(size_calc)).replace("this->", "msg.") + "\n"
         o += "  return size;\n"
         o += "}\n"
         cpp += o
-        prot = "uint32_t calculate_size() const;"
-        public_content.append(prot)
+        public_content.append("static uint32_t calc_size_msg(const void *self);")
+        public_content.append(
+            "uint32_t calculate_size() const { return calc_size_msg(this); }"
+        )
     # If no fields to calculate size for or message doesn't need encoding, the default implementation in ProtoMessage will be used
 
     # dump_to method declaration in header
diff --git a/tests/unit_tests/components/api/test_api_proto.py b/tests/unit_tests/components/api/test_api_proto.py
index a194511f2b..3e2f37e16c 100644
--- a/tests/unit_tests/components/api/test_api_proto.py
+++ b/tests/unit_tests/components/api/test_api_proto.py
@@ -194,17 +194,17 @@ def test_superseded_device_info_fields_still_declared_in_header() -> None:
 
 def test_superseded_device_info_fields_still_encoded_and_sized() -> None:
     """Each superseded field must still be touched by DeviceInfoResponse's
-    generated encode() and calculate_size(), i.e. it is still put on the wire.
+    generated encode_msg() and calc_size_msg(), i.e. it is still put on the wire.
     """
-    encode_body = _extract_function_body(CPP_TEXT, "DeviceInfoResponse::encode")
-    size_body = _extract_function_body(CPP_TEXT, "DeviceInfoResponse::calculate_size")
+    encode_body = _extract_function_body(CPP_TEXT, "DeviceInfoResponse::encode_msg")
+    size_body = _extract_function_body(CPP_TEXT, "DeviceInfoResponse::calc_size_msg")
     for field_name in SUPERSEDED_FIELDS:
-        assert f"this->{field_name}" in encode_body, (
-            f"DeviceInfoResponse::encode() no longer references {field_name}. "
+        assert f"msg.{field_name}" in encode_body, (
+            f"DeviceInfoResponse::encode_msg() no longer references {field_name}. "
             f"{DEPRECATED_FIELD_TRAP}"
         )
-        assert f"this->{field_name}" in size_body, (
-            f"DeviceInfoResponse::calculate_size() no longer references "
+        assert f"msg.{field_name}" in size_body, (
+            f"DeviceInfoResponse::calc_size_msg() no longer references "
             f"{field_name}. {DEPRECATED_FIELD_TRAP}"
         )