grpc 1.48.0-x86_64-linux → 1.49.0.pre1-x86_64-linux

data/src/core/ext/upb-generated/validate/validate.upb.h

@@ -138,11 +138,15 @@ UPB_INLINE validate_FieldRules* validate_FieldRules_parse_ex(const char* buf, si
   return ret;
 }
 UPB_INLINE char* validate_FieldRules_serialize(const validate_FieldRules* msg, upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &validate_FieldRules_msginit, 0, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &validate_FieldRules_msginit, 0, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE char* validate_FieldRules_serialize_ex(const validate_FieldRules* msg, int options,
                                  upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &validate_FieldRules_msginit, options, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &validate_FieldRules_msginit, options, arena, &ptr, len);
+  return ptr;
 }
 typedef enum {
   validate_FieldRules_type_float = 1,
@@ -661,11 +665,15 @@ UPB_INLINE validate_FloatRules* validate_FloatRules_parse_ex(const char* buf, si
   return ret;
 }
 UPB_INLINE char* validate_FloatRules_serialize(const validate_FloatRules* msg, upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &validate_FloatRules_msginit, 0, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &validate_FloatRules_msginit, 0, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE char* validate_FloatRules_serialize_ex(const validate_FloatRules* msg, int options,
                                  upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &validate_FloatRules_msginit, options, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &validate_FloatRules_msginit, options, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE bool validate_FloatRules_has_const(const validate_FloatRules* msg) {
   return _upb_hasbit(msg, 1);
@@ -808,11 +816,15 @@ UPB_INLINE validate_DoubleRules* validate_DoubleRules_parse_ex(const char* buf,
   return ret;
 }
 UPB_INLINE char* validate_DoubleRules_serialize(const validate_DoubleRules* msg, upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &validate_DoubleRules_msginit, 0, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &validate_DoubleRules_msginit, 0, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE char* validate_DoubleRules_serialize_ex(const validate_DoubleRules* msg, int options,
                                  upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &validate_DoubleRules_msginit, options, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &validate_DoubleRules_msginit, options, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE bool validate_DoubleRules_has_const(const validate_DoubleRules* msg) {
   return _upb_hasbit(msg, 1);
@@ -955,11 +967,15 @@ UPB_INLINE validate_Int32Rules* validate_Int32Rules_parse_ex(const char* buf, si
   return ret;
 }
 UPB_INLINE char* validate_Int32Rules_serialize(const validate_Int32Rules* msg, upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &validate_Int32Rules_msginit, 0, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &validate_Int32Rules_msginit, 0, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE char* validate_Int32Rules_serialize_ex(const validate_Int32Rules* msg, int options,
                                  upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &validate_Int32Rules_msginit, options, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &validate_Int32Rules_msginit, options, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE bool validate_Int32Rules_has_const(const validate_Int32Rules* msg) {
   return _upb_hasbit(msg, 1);
@@ -1102,11 +1118,15 @@ UPB_INLINE validate_Int64Rules* validate_Int64Rules_parse_ex(const char* buf, si
   return ret;
 }
 UPB_INLINE char* validate_Int64Rules_serialize(const validate_Int64Rules* msg, upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &validate_Int64Rules_msginit, 0, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &validate_Int64Rules_msginit, 0, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE char* validate_Int64Rules_serialize_ex(const validate_Int64Rules* msg, int options,
                                  upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &validate_Int64Rules_msginit, options, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &validate_Int64Rules_msginit, options, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE bool validate_Int64Rules_has_const(const validate_Int64Rules* msg) {
   return _upb_hasbit(msg, 1);
@@ -1249,11 +1269,15 @@ UPB_INLINE validate_UInt32Rules* validate_UInt32Rules_parse_ex(const char* buf,
   return ret;
 }
 UPB_INLINE char* validate_UInt32Rules_serialize(const validate_UInt32Rules* msg, upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &validate_UInt32Rules_msginit, 0, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &validate_UInt32Rules_msginit, 0, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE char* validate_UInt32Rules_serialize_ex(const validate_UInt32Rules* msg, int options,
                                  upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &validate_UInt32Rules_msginit, options, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &validate_UInt32Rules_msginit, options, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE bool validate_UInt32Rules_has_const(const validate_UInt32Rules* msg) {
   return _upb_hasbit(msg, 1);
@@ -1396,11 +1420,15 @@ UPB_INLINE validate_UInt64Rules* validate_UInt64Rules_parse_ex(const char* buf,
   return ret;
 }
 UPB_INLINE char* validate_UInt64Rules_serialize(const validate_UInt64Rules* msg, upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &validate_UInt64Rules_msginit, 0, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &validate_UInt64Rules_msginit, 0, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE char* validate_UInt64Rules_serialize_ex(const validate_UInt64Rules* msg, int options,
                                  upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &validate_UInt64Rules_msginit, options, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &validate_UInt64Rules_msginit, options, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE bool validate_UInt64Rules_has_const(const validate_UInt64Rules* msg) {
   return _upb_hasbit(msg, 1);
@@ -1543,11 +1571,15 @@ UPB_INLINE validate_SInt32Rules* validate_SInt32Rules_parse_ex(const char* buf,
   return ret;
 }
 UPB_INLINE char* validate_SInt32Rules_serialize(const validate_SInt32Rules* msg, upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &validate_SInt32Rules_msginit, 0, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &validate_SInt32Rules_msginit, 0, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE char* validate_SInt32Rules_serialize_ex(const validate_SInt32Rules* msg, int options,
                                  upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &validate_SInt32Rules_msginit, options, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &validate_SInt32Rules_msginit, options, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE bool validate_SInt32Rules_has_const(const validate_SInt32Rules* msg) {
   return _upb_hasbit(msg, 1);
@@ -1690,11 +1722,15 @@ UPB_INLINE validate_SInt64Rules* validate_SInt64Rules_parse_ex(const char* buf,
   return ret;
 }
 UPB_INLINE char* validate_SInt64Rules_serialize(const validate_SInt64Rules* msg, upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &validate_SInt64Rules_msginit, 0, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &validate_SInt64Rules_msginit, 0, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE char* validate_SInt64Rules_serialize_ex(const validate_SInt64Rules* msg, int options,
                                  upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &validate_SInt64Rules_msginit, options, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &validate_SInt64Rules_msginit, options, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE bool validate_SInt64Rules_has_const(const validate_SInt64Rules* msg) {
   return _upb_hasbit(msg, 1);
@@ -1837,11 +1873,15 @@ UPB_INLINE validate_Fixed32Rules* validate_Fixed32Rules_parse_ex(const char* buf
   return ret;
 }
 UPB_INLINE char* validate_Fixed32Rules_serialize(const validate_Fixed32Rules* msg, upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &validate_Fixed32Rules_msginit, 0, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &validate_Fixed32Rules_msginit, 0, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE char* validate_Fixed32Rules_serialize_ex(const validate_Fixed32Rules* msg, int options,
                                  upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &validate_Fixed32Rules_msginit, options, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &validate_Fixed32Rules_msginit, options, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE bool validate_Fixed32Rules_has_const(const validate_Fixed32Rules* msg) {
   return _upb_hasbit(msg, 1);
@@ -1984,11 +2024,15 @@ UPB_INLINE validate_Fixed64Rules* validate_Fixed64Rules_parse_ex(const char* buf
   return ret;
 }
 UPB_INLINE char* validate_Fixed64Rules_serialize(const validate_Fixed64Rules* msg, upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &validate_Fixed64Rules_msginit, 0, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &validate_Fixed64Rules_msginit, 0, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE char* validate_Fixed64Rules_serialize_ex(const validate_Fixed64Rules* msg, int options,
                                  upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &validate_Fixed64Rules_msginit, options, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &validate_Fixed64Rules_msginit, options, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE bool validate_Fixed64Rules_has_const(const validate_Fixed64Rules* msg) {
   return _upb_hasbit(msg, 1);
@@ -2131,11 +2175,15 @@ UPB_INLINE validate_SFixed32Rules* validate_SFixed32Rules_parse_ex(const char* b
   return ret;
 }
 UPB_INLINE char* validate_SFixed32Rules_serialize(const validate_SFixed32Rules* msg, upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &validate_SFixed32Rules_msginit, 0, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &validate_SFixed32Rules_msginit, 0, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE char* validate_SFixed32Rules_serialize_ex(const validate_SFixed32Rules* msg, int options,
                                  upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &validate_SFixed32Rules_msginit, options, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &validate_SFixed32Rules_msginit, options, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE bool validate_SFixed32Rules_has_const(const validate_SFixed32Rules* msg) {
   return _upb_hasbit(msg, 1);
@@ -2278,11 +2326,15 @@ UPB_INLINE validate_SFixed64Rules* validate_SFixed64Rules_parse_ex(const char* b
   return ret;
 }
 UPB_INLINE char* validate_SFixed64Rules_serialize(const validate_SFixed64Rules* msg, upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &validate_SFixed64Rules_msginit, 0, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &validate_SFixed64Rules_msginit, 0, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE char* validate_SFixed64Rules_serialize_ex(const validate_SFixed64Rules* msg, int options,
                                  upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &validate_SFixed64Rules_msginit, options, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &validate_SFixed64Rules_msginit, options, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE bool validate_SFixed64Rules_has_const(const validate_SFixed64Rules* msg) {
   return _upb_hasbit(msg, 1);
@@ -2425,11 +2477,15 @@ UPB_INLINE validate_BoolRules* validate_BoolRules_parse_ex(const char* buf, size
   return ret;
 }
 UPB_INLINE char* validate_BoolRules_serialize(const validate_BoolRules* msg, upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &validate_BoolRules_msginit, 0, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &validate_BoolRules_msginit, 0, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE char* validate_BoolRules_serialize_ex(const validate_BoolRules* msg, int options,
                                  upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &validate_BoolRules_msginit, options, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &validate_BoolRules_msginit, options, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE bool validate_BoolRules_has_const(const validate_BoolRules* msg) {
   return _upb_hasbit(msg, 1);
@@ -2472,11 +2528,15 @@ UPB_INLINE validate_StringRules* validate_StringRules_parse_ex(const char* buf,
   return ret;
 }
 UPB_INLINE char* validate_StringRules_serialize(const validate_StringRules* msg, upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &validate_StringRules_msginit, 0, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &validate_StringRules_msginit, 0, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE char* validate_StringRules_serialize_ex(const validate_StringRules* msg, int options,
                                  upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &validate_StringRules_msginit, options, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &validate_StringRules_msginit, options, arena, &ptr, len);
+  return ptr;
 }
 typedef enum {
   validate_StringRules_well_known_email = 12,
@@ -2867,11 +2927,15 @@ UPB_INLINE validate_BytesRules* validate_BytesRules_parse_ex(const char* buf, si
   return ret;
 }
 UPB_INLINE char* validate_BytesRules_serialize(const validate_BytesRules* msg, upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &validate_BytesRules_msginit, 0, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &validate_BytesRules_msginit, 0, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE char* validate_BytesRules_serialize_ex(const validate_BytesRules* msg, int options,
                                  upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &validate_BytesRules_msginit, options, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &validate_BytesRules_msginit, options, arena, &ptr, len);
+  return ptr;
 }
 typedef enum {
   validate_BytesRules_well_known_ip = 10,
@@ -3101,11 +3165,15 @@ UPB_INLINE validate_EnumRules* validate_EnumRules_parse_ex(const char* buf, size
   return ret;
 }
 UPB_INLINE char* validate_EnumRules_serialize(const validate_EnumRules* msg, upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &validate_EnumRules_msginit, 0, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &validate_EnumRules_msginit, 0, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE char* validate_EnumRules_serialize_ex(const validate_EnumRules* msg, int options,
                                  upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &validate_EnumRules_msginit, options, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &validate_EnumRules_msginit, options, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE bool validate_EnumRules_has_const(const validate_EnumRules* msg) {
   return _upb_hasbit(msg, 1);
@@ -3192,11 +3260,15 @@ UPB_INLINE validate_MessageRules* validate_MessageRules_parse_ex(const char* buf
   return ret;
 }
 UPB_INLINE char* validate_MessageRules_serialize(const validate_MessageRules* msg, upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &validate_MessageRules_msginit, 0, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &validate_MessageRules_msginit, 0, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE char* validate_MessageRules_serialize_ex(const validate_MessageRules* msg, int options,
                                  upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &validate_MessageRules_msginit, options, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &validate_MessageRules_msginit, options, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE bool validate_MessageRules_has_skip(const validate_MessageRules* msg) {
   return _upb_hasbit(msg, 1);
@@ -3253,11 +3325,15 @@ UPB_INLINE validate_RepeatedRules* validate_RepeatedRules_parse_ex(const char* b
   return ret;
 }
 UPB_INLINE char* validate_RepeatedRules_serialize(const validate_RepeatedRules* msg, upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &validate_RepeatedRules_msginit, 0, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &validate_RepeatedRules_msginit, 0, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE char* validate_RepeatedRules_serialize_ex(const validate_RepeatedRules* msg, int options,
                                  upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &validate_RepeatedRules_msginit, options, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &validate_RepeatedRules_msginit, options, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE bool validate_RepeatedRules_has_min_items(const validate_RepeatedRules* msg) {
   return _upb_hasbit(msg, 1);
@@ -3364,11 +3440,15 @@ UPB_INLINE validate_MapRules* validate_MapRules_parse_ex(const char* buf, size_t
   return ret;
 }
 UPB_INLINE char* validate_MapRules_serialize(const validate_MapRules* msg, upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &validate_MapRules_msginit, 0, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &validate_MapRules_msginit, 0, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE char* validate_MapRules_serialize_ex(const validate_MapRules* msg, int options,
                                  upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &validate_MapRules_msginit, options, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &validate_MapRules_msginit, options, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE bool validate_MapRules_has_min_pairs(const validate_MapRules* msg) {
   return _upb_hasbit(msg, 1);
@@ -3497,11 +3577,15 @@ UPB_INLINE validate_AnyRules* validate_AnyRules_parse_ex(const char* buf, size_t
   return ret;
 }
 UPB_INLINE char* validate_AnyRules_serialize(const validate_AnyRules* msg, upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &validate_AnyRules_msginit, 0, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &validate_AnyRules_msginit, 0, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE char* validate_AnyRules_serialize_ex(const validate_AnyRules* msg, int options,
                                  upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &validate_AnyRules_msginit, options, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &validate_AnyRules_msginit, options, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE bool validate_AnyRules_has_required(const validate_AnyRules* msg) {
   return _upb_hasbit(msg, 1);
@@ -3574,11 +3658,15 @@ UPB_INLINE validate_DurationRules* validate_DurationRules_parse_ex(const char* b
   return ret;
 }
 UPB_INLINE char* validate_DurationRules_serialize(const validate_DurationRules* msg, upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &validate_DurationRules_msginit, 0, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &validate_DurationRules_msginit, 0, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE char* validate_DurationRules_serialize_ex(const validate_DurationRules* msg, int options,
                                  upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &validate_DurationRules_msginit, options, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &validate_DurationRules_msginit, options, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE bool validate_DurationRules_has_required(const validate_DurationRules* msg) {
   return _upb_hasbit(msg, 1);
@@ -3773,11 +3861,15 @@ UPB_INLINE validate_TimestampRules* validate_TimestampRules_parse_ex(const char*
   return ret;
 }
 UPB_INLINE char* validate_TimestampRules_serialize(const validate_TimestampRules* msg, upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &validate_TimestampRules_msginit, 0, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &validate_TimestampRules_msginit, 0, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE char* validate_TimestampRules_serialize_ex(const validate_TimestampRules* msg, int options,
                                  upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &validate_TimestampRules_msginit, options, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &validate_TimestampRules_msginit, options, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE bool validate_TimestampRules_has_required(const validate_TimestampRules* msg) {
   return _upb_hasbit(msg, 1);
@@ -3998,7 +4090,7 @@ UPB_INLINE const validate_FieldRules* validate_rules(const struct google_protobu
 }
 UPB_INLINE void validate_set_rules(struct google_protobuf_FieldOptions* msg, const validate_FieldRules* ext, upb_Arena* arena) {
   const upb_Message_Extension* msg_ext =
-      _upb_Message_Getorcreateext(msg, &validate_rules_ext, arena);
+      _upb_Message_GetOrCreateExtension(msg, &validate_rules_ext, arena);
   UPB_ASSERT(msg_ext);
   *UPB_PTR_AT(&msg_ext->data, 0, const validate_FieldRules*) = ext;
 }

data/src/core/ext/upb-generated/xds/annotations/v3/migrate.upb.c

@@ -20,7 +20,7 @@ static const upb_MiniTable_Field xds_annotations_v3_MigrateAnnotation__fields[1]
 const upb_MiniTable xds_annotations_v3_MigrateAnnotation_msginit = {
   NULL,
   &xds_annotations_v3_MigrateAnnotation__fields[0],
-  UPB_SIZE(8, 24), 1, kUpb_ExtMode_NonExtendable, 1, 255, 0,
+  UPB_SIZE(8, 16), 1, kUpb_ExtMode_NonExtendable, 1, 255, 0,
 };
 
 static const upb_MiniTable_Field xds_annotations_v3_FieldMigrateAnnotation__fields[2] = {
@@ -31,7 +31,7 @@ static const upb_MiniTable_Field xds_annotations_v3_FieldMigrateAnnotation__fiel
 const upb_MiniTable xds_annotations_v3_FieldMigrateAnnotation_msginit = {
   NULL,
   &xds_annotations_v3_FieldMigrateAnnotation__fields[0],
-  UPB_SIZE(16, 40), 2, kUpb_ExtMode_NonExtendable, 2, 255, 0,
+  UPB_SIZE(16, 32), 2, kUpb_ExtMode_NonExtendable, 2, 255, 0,
 };
 
 static const upb_MiniTable_Field xds_annotations_v3_FileMigrateAnnotation__fields[1] = {
@@ -41,7 +41,7 @@ static const upb_MiniTable_Field xds_annotations_v3_FileMigrateAnnotation__field
 const upb_MiniTable xds_annotations_v3_FileMigrateAnnotation_msginit = {
   NULL,
   &xds_annotations_v3_FileMigrateAnnotation__fields[0],
-  UPB_SIZE(8, 24), 1, kUpb_ExtMode_NonExtendable, 0, 255, 0,
+  UPB_SIZE(8, 16), 1, kUpb_ExtMode_NonExtendable, 0, 255, 0,
 };
 
 static const upb_MiniTable *messages_layout[3] = {

data/src/core/ext/upb-generated/xds/annotations/v3/migrate.upb.h

@@ -72,11 +72,15 @@ UPB_INLINE xds_annotations_v3_MigrateAnnotation* xds_annotations_v3_MigrateAnnot
   return ret;
 }
 UPB_INLINE char* xds_annotations_v3_MigrateAnnotation_serialize(const xds_annotations_v3_MigrateAnnotation* msg, upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &xds_annotations_v3_MigrateAnnotation_msginit, 0, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &xds_annotations_v3_MigrateAnnotation_msginit, 0, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE char* xds_annotations_v3_MigrateAnnotation_serialize_ex(const xds_annotations_v3_MigrateAnnotation* msg, int options,
                                  upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &xds_annotations_v3_MigrateAnnotation_msginit, options, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &xds_annotations_v3_MigrateAnnotation_msginit, options, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE void xds_annotations_v3_MigrateAnnotation_clear_rename(const xds_annotations_v3_MigrateAnnotation* msg) {
   *UPB_PTR_AT(msg, UPB_SIZE(0, 0), upb_StringView) = upb_StringView_FromDataAndSize(NULL, 0);
@@ -114,11 +118,15 @@ UPB_INLINE xds_annotations_v3_FieldMigrateAnnotation* xds_annotations_v3_FieldMi
   return ret;
 }
 UPB_INLINE char* xds_annotations_v3_FieldMigrateAnnotation_serialize(const xds_annotations_v3_FieldMigrateAnnotation* msg, upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &xds_annotations_v3_FieldMigrateAnnotation_msginit, 0, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &xds_annotations_v3_FieldMigrateAnnotation_msginit, 0, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE char* xds_annotations_v3_FieldMigrateAnnotation_serialize_ex(const xds_annotations_v3_FieldMigrateAnnotation* msg, int options,
                                  upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &xds_annotations_v3_FieldMigrateAnnotation_msginit, options, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &xds_annotations_v3_FieldMigrateAnnotation_msginit, options, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE void xds_annotations_v3_FieldMigrateAnnotation_clear_rename(const xds_annotations_v3_FieldMigrateAnnotation* msg) {
   *UPB_PTR_AT(msg, UPB_SIZE(0, 0), upb_StringView) = upb_StringView_FromDataAndSize(NULL, 0);
@@ -165,11 +173,15 @@ UPB_INLINE xds_annotations_v3_FileMigrateAnnotation* xds_annotations_v3_FileMigr
   return ret;
 }
 UPB_INLINE char* xds_annotations_v3_FileMigrateAnnotation_serialize(const xds_annotations_v3_FileMigrateAnnotation* msg, upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &xds_annotations_v3_FileMigrateAnnotation_msginit, 0, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &xds_annotations_v3_FileMigrateAnnotation_msginit, 0, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE char* xds_annotations_v3_FileMigrateAnnotation_serialize_ex(const xds_annotations_v3_FileMigrateAnnotation* msg, int options,
                                  upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &xds_annotations_v3_FileMigrateAnnotation_msginit, options, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &xds_annotations_v3_FileMigrateAnnotation_msginit, options, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE void xds_annotations_v3_FileMigrateAnnotation_clear_move_to_package(const xds_annotations_v3_FileMigrateAnnotation* msg) {
   *UPB_PTR_AT(msg, UPB_SIZE(0, 0), upb_StringView) = upb_StringView_FromDataAndSize(NULL, 0);
@@ -195,7 +207,7 @@ UPB_INLINE const xds_annotations_v3_MigrateAnnotation* xds_annotations_v3_messag
 }
 UPB_INLINE void xds_annotations_v3_set_message_migrate(struct google_protobuf_MessageOptions* msg, const xds_annotations_v3_MigrateAnnotation* ext, upb_Arena* arena) {
   const upb_Message_Extension* msg_ext =
-      _upb_Message_Getorcreateext(msg, &xds_annotations_v3_message_migrate_ext, arena);
+      _upb_Message_GetOrCreateExtension(msg, &xds_annotations_v3_message_migrate_ext, arena);
   UPB_ASSERT(msg_ext);
   *UPB_PTR_AT(&msg_ext->data, 0, const xds_annotations_v3_MigrateAnnotation*) = ext;
 }
@@ -212,7 +224,7 @@ UPB_INLINE const xds_annotations_v3_FieldMigrateAnnotation* xds_annotations_v3_f
 }
 UPB_INLINE void xds_annotations_v3_set_field_migrate(struct google_protobuf_FieldOptions* msg, const xds_annotations_v3_FieldMigrateAnnotation* ext, upb_Arena* arena) {
   const upb_Message_Extension* msg_ext =
-      _upb_Message_Getorcreateext(msg, &xds_annotations_v3_field_migrate_ext, arena);
+      _upb_Message_GetOrCreateExtension(msg, &xds_annotations_v3_field_migrate_ext, arena);
   UPB_ASSERT(msg_ext);
   *UPB_PTR_AT(&msg_ext->data, 0, const xds_annotations_v3_FieldMigrateAnnotation*) = ext;
 }
@@ -229,7 +241,7 @@ UPB_INLINE const xds_annotations_v3_MigrateAnnotation* xds_annotations_v3_enum_m
 }
 UPB_INLINE void xds_annotations_v3_set_enum_migrate(struct google_protobuf_EnumOptions* msg, const xds_annotations_v3_MigrateAnnotation* ext, upb_Arena* arena) {
   const upb_Message_Extension* msg_ext =
-      _upb_Message_Getorcreateext(msg, &xds_annotations_v3_enum_migrate_ext, arena);
+      _upb_Message_GetOrCreateExtension(msg, &xds_annotations_v3_enum_migrate_ext, arena);
   UPB_ASSERT(msg_ext);
   *UPB_PTR_AT(&msg_ext->data, 0, const xds_annotations_v3_MigrateAnnotation*) = ext;
 }
@@ -246,7 +258,7 @@ UPB_INLINE const xds_annotations_v3_MigrateAnnotation* xds_annotations_v3_enum_v
 }
 UPB_INLINE void xds_annotations_v3_set_enum_value_migrate(struct google_protobuf_EnumValueOptions* msg, const xds_annotations_v3_MigrateAnnotation* ext, upb_Arena* arena) {
   const upb_Message_Extension* msg_ext =
-      _upb_Message_Getorcreateext(msg, &xds_annotations_v3_enum_value_migrate_ext, arena);
+      _upb_Message_GetOrCreateExtension(msg, &xds_annotations_v3_enum_value_migrate_ext, arena);
   UPB_ASSERT(msg_ext);
   *UPB_PTR_AT(&msg_ext->data, 0, const xds_annotations_v3_MigrateAnnotation*) = ext;
 }
@@ -263,7 +275,7 @@ UPB_INLINE const xds_annotations_v3_FileMigrateAnnotation* xds_annotations_v3_fi
 }
 UPB_INLINE void xds_annotations_v3_set_file_migrate(struct google_protobuf_FileOptions* msg, const xds_annotations_v3_FileMigrateAnnotation* ext, upb_Arena* arena) {
   const upb_Message_Extension* msg_ext =
-      _upb_Message_Getorcreateext(msg, &xds_annotations_v3_file_migrate_ext, arena);
+      _upb_Message_GetOrCreateExtension(msg, &xds_annotations_v3_file_migrate_ext, arena);
   UPB_ASSERT(msg_ext);
   *UPB_PTR_AT(&msg_ext->data, 0, const xds_annotations_v3_FileMigrateAnnotation*) = ext;
 }

data/src/core/ext/upb-generated/xds/annotations/v3/security.upb.c

@@ -22,7 +22,7 @@ static const upb_MiniTable_Field xds_annotations_v3_FieldSecurityAnnotation__fie
 const upb_MiniTable xds_annotations_v3_FieldSecurityAnnotation_msginit = {
   NULL,
   &xds_annotations_v3_FieldSecurityAnnotation__fields[0],
-  UPB_SIZE(2, 8), 2, kUpb_ExtMode_NonExtendable, 2, 255, 0,
+  UPB_SIZE(8, 8), 2, kUpb_ExtMode_NonExtendable, 2, 255, 0,
 };
 
 static const upb_MiniTable *messages_layout[1] = {

data/src/core/ext/upb-generated/xds/annotations/v3/security.upb.h

@@ -54,11 +54,15 @@ UPB_INLINE xds_annotations_v3_FieldSecurityAnnotation* xds_annotations_v3_FieldS
   return ret;
 }
 UPB_INLINE char* xds_annotations_v3_FieldSecurityAnnotation_serialize(const xds_annotations_v3_FieldSecurityAnnotation* msg, upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &xds_annotations_v3_FieldSecurityAnnotation_msginit, 0, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &xds_annotations_v3_FieldSecurityAnnotation_msginit, 0, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE char* xds_annotations_v3_FieldSecurityAnnotation_serialize_ex(const xds_annotations_v3_FieldSecurityAnnotation* msg, int options,
                                  upb_Arena* arena, size_t* len) {
-  return upb_Encode(msg, &xds_annotations_v3_FieldSecurityAnnotation_msginit, options, arena, len);
+  char* ptr;
+  (void)upb_Encode(msg, &xds_annotations_v3_FieldSecurityAnnotation_msginit, options, arena, &ptr, len);
+  return ptr;
 }
 UPB_INLINE void xds_annotations_v3_FieldSecurityAnnotation_clear_configure_for_untrusted_downstream(const xds_annotations_v3_FieldSecurityAnnotation* msg) {
   *UPB_PTR_AT(msg, UPB_SIZE(0, 0), bool) = 0;
@@ -93,7 +97,7 @@ UPB_INLINE const xds_annotations_v3_FieldSecurityAnnotation* xds_annotations_v3_
 }
 UPB_INLINE void xds_annotations_v3_set_security(struct google_protobuf_FieldOptions* msg, const xds_annotations_v3_FieldSecurityAnnotation* ext, upb_Arena* arena) {
   const upb_Message_Extension* msg_ext =
-      _upb_Message_Getorcreateext(msg, &xds_annotations_v3_security_ext, arena);
+      _upb_Message_GetOrCreateExtension(msg, &xds_annotations_v3_security_ext, arena);
   UPB_ASSERT(msg_ext);
   *UPB_PTR_AT(&msg_ext->data, 0, const xds_annotations_v3_FieldSecurityAnnotation*) = ext;
 }

data/src/core/ext/upb-generated/xds/annotations/v3/status.upb.c

@@ -20,7 +20,7 @@ static const upb_MiniTable_Field xds_annotations_v3_FileStatusAnnotation__fields
 const upb_MiniTable xds_annotations_v3_FileStatusAnnotation_msginit = {
   NULL,
   &xds_annotations_v3_FileStatusAnnotation__fields[0],
-  UPB_SIZE(1, 8), 1, kUpb_ExtMode_NonExtendable, 1, 255, 0,
+  UPB_SIZE(8, 8), 1, kUpb_ExtMode_NonExtendable, 1, 255, 0,
 };
 
 static const upb_MiniTable_Field xds_annotations_v3_MessageStatusAnnotation__fields[1] = {
@@ -30,7 +30,7 @@ static const upb_MiniTable_Field xds_annotations_v3_MessageStatusAnnotation__fie
 const upb_MiniTable xds_annotations_v3_MessageStatusAnnotation_msginit = {
   NULL,
   &xds_annotations_v3_MessageStatusAnnotation__fields[0],
-  UPB_SIZE(1, 8), 1, kUpb_ExtMode_NonExtendable, 1, 255, 0,
+  UPB_SIZE(8, 8), 1, kUpb_ExtMode_NonExtendable, 1, 255, 0,
 };
 
 static const upb_MiniTable_Field xds_annotations_v3_FieldStatusAnnotation__fields[1] = {
@@ -40,7 +40,7 @@ static const upb_MiniTable_Field xds_annotations_v3_FieldStatusAnnotation__field
 const upb_MiniTable xds_annotations_v3_FieldStatusAnnotation_msginit = {
   NULL,
   &xds_annotations_v3_FieldStatusAnnotation__fields[0],
-  UPB_SIZE(1, 8), 1, kUpb_ExtMode_NonExtendable, 1, 255, 0,
+  UPB_SIZE(8, 8), 1, kUpb_ExtMode_NonExtendable, 1, 255, 0,
 };
 
 static const upb_MiniTable_Field xds_annotations_v3_StatusAnnotation__fields[2] = {