grpc 1.45.0 → 1.53.0

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,
@@ -168,59 +172,212 @@ typedef enum {
   validate_FieldRules_type_timestamp = 22,
   validate_FieldRules_type_NOT_SET = 0
 } validate_FieldRules_type_oneofcases;
-UPB_INLINE validate_FieldRules_type_oneofcases validate_FieldRules_type_case(const validate_FieldRules* msg) { return (validate_FieldRules_type_oneofcases)*UPB_PTR_AT(msg, UPB_SIZE(12, 24), int32_t); }
-
-UPB_INLINE bool validate_FieldRules_has_float(const validate_FieldRules *msg) { return _upb_getoneofcase(msg, UPB_SIZE(12, 24)) == 1; }
-UPB_INLINE const validate_FloatRules* validate_FieldRules_float(const validate_FieldRules *msg) { return UPB_READ_ONEOF(msg, const validate_FloatRules*, UPB_SIZE(8, 16), UPB_SIZE(12, 24), 1, NULL); }
-UPB_INLINE bool validate_FieldRules_has_double(const validate_FieldRules *msg) { return _upb_getoneofcase(msg, UPB_SIZE(12, 24)) == 2; }
-UPB_INLINE const validate_DoubleRules* validate_FieldRules_double(const validate_FieldRules *msg) { return UPB_READ_ONEOF(msg, const validate_DoubleRules*, UPB_SIZE(8, 16), UPB_SIZE(12, 24), 2, NULL); }
-UPB_INLINE bool validate_FieldRules_has_int32(const validate_FieldRules *msg) { return _upb_getoneofcase(msg, UPB_SIZE(12, 24)) == 3; }
-UPB_INLINE const validate_Int32Rules* validate_FieldRules_int32(const validate_FieldRules *msg) { return UPB_READ_ONEOF(msg, const validate_Int32Rules*, UPB_SIZE(8, 16), UPB_SIZE(12, 24), 3, NULL); }
-UPB_INLINE bool validate_FieldRules_has_int64(const validate_FieldRules *msg) { return _upb_getoneofcase(msg, UPB_SIZE(12, 24)) == 4; }
-UPB_INLINE const validate_Int64Rules* validate_FieldRules_int64(const validate_FieldRules *msg) { return UPB_READ_ONEOF(msg, const validate_Int64Rules*, UPB_SIZE(8, 16), UPB_SIZE(12, 24), 4, NULL); }
-UPB_INLINE bool validate_FieldRules_has_uint32(const validate_FieldRules *msg) { return _upb_getoneofcase(msg, UPB_SIZE(12, 24)) == 5; }
-UPB_INLINE const validate_UInt32Rules* validate_FieldRules_uint32(const validate_FieldRules *msg) { return UPB_READ_ONEOF(msg, const validate_UInt32Rules*, UPB_SIZE(8, 16), UPB_SIZE(12, 24), 5, NULL); }
-UPB_INLINE bool validate_FieldRules_has_uint64(const validate_FieldRules *msg) { return _upb_getoneofcase(msg, UPB_SIZE(12, 24)) == 6; }
-UPB_INLINE const validate_UInt64Rules* validate_FieldRules_uint64(const validate_FieldRules *msg) { return UPB_READ_ONEOF(msg, const validate_UInt64Rules*, UPB_SIZE(8, 16), UPB_SIZE(12, 24), 6, NULL); }
-UPB_INLINE bool validate_FieldRules_has_sint32(const validate_FieldRules *msg) { return _upb_getoneofcase(msg, UPB_SIZE(12, 24)) == 7; }
-UPB_INLINE const validate_SInt32Rules* validate_FieldRules_sint32(const validate_FieldRules *msg) { return UPB_READ_ONEOF(msg, const validate_SInt32Rules*, UPB_SIZE(8, 16), UPB_SIZE(12, 24), 7, NULL); }
-UPB_INLINE bool validate_FieldRules_has_sint64(const validate_FieldRules *msg) { return _upb_getoneofcase(msg, UPB_SIZE(12, 24)) == 8; }
-UPB_INLINE const validate_SInt64Rules* validate_FieldRules_sint64(const validate_FieldRules *msg) { return UPB_READ_ONEOF(msg, const validate_SInt64Rules*, UPB_SIZE(8, 16), UPB_SIZE(12, 24), 8, NULL); }
-UPB_INLINE bool validate_FieldRules_has_fixed32(const validate_FieldRules *msg) { return _upb_getoneofcase(msg, UPB_SIZE(12, 24)) == 9; }
-UPB_INLINE const validate_Fixed32Rules* validate_FieldRules_fixed32(const validate_FieldRules *msg) { return UPB_READ_ONEOF(msg, const validate_Fixed32Rules*, UPB_SIZE(8, 16), UPB_SIZE(12, 24), 9, NULL); }
-UPB_INLINE bool validate_FieldRules_has_fixed64(const validate_FieldRules *msg) { return _upb_getoneofcase(msg, UPB_SIZE(12, 24)) == 10; }
-UPB_INLINE const validate_Fixed64Rules* validate_FieldRules_fixed64(const validate_FieldRules *msg) { return UPB_READ_ONEOF(msg, const validate_Fixed64Rules*, UPB_SIZE(8, 16), UPB_SIZE(12, 24), 10, NULL); }
-UPB_INLINE bool validate_FieldRules_has_sfixed32(const validate_FieldRules *msg) { return _upb_getoneofcase(msg, UPB_SIZE(12, 24)) == 11; }
-UPB_INLINE const validate_SFixed32Rules* validate_FieldRules_sfixed32(const validate_FieldRules *msg) { return UPB_READ_ONEOF(msg, const validate_SFixed32Rules*, UPB_SIZE(8, 16), UPB_SIZE(12, 24), 11, NULL); }
-UPB_INLINE bool validate_FieldRules_has_sfixed64(const validate_FieldRules *msg) { return _upb_getoneofcase(msg, UPB_SIZE(12, 24)) == 12; }
-UPB_INLINE const validate_SFixed64Rules* validate_FieldRules_sfixed64(const validate_FieldRules *msg) { return UPB_READ_ONEOF(msg, const validate_SFixed64Rules*, UPB_SIZE(8, 16), UPB_SIZE(12, 24), 12, NULL); }
-UPB_INLINE bool validate_FieldRules_has_bool(const validate_FieldRules *msg) { return _upb_getoneofcase(msg, UPB_SIZE(12, 24)) == 13; }
-UPB_INLINE const validate_BoolRules* validate_FieldRules_bool(const validate_FieldRules *msg) { return UPB_READ_ONEOF(msg, const validate_BoolRules*, UPB_SIZE(8, 16), UPB_SIZE(12, 24), 13, NULL); }
-UPB_INLINE bool validate_FieldRules_has_string(const validate_FieldRules *msg) { return _upb_getoneofcase(msg, UPB_SIZE(12, 24)) == 14; }
-UPB_INLINE const validate_StringRules* validate_FieldRules_string(const validate_FieldRules *msg) { return UPB_READ_ONEOF(msg, const validate_StringRules*, UPB_SIZE(8, 16), UPB_SIZE(12, 24), 14, NULL); }
-UPB_INLINE bool validate_FieldRules_has_bytes(const validate_FieldRules *msg) { return _upb_getoneofcase(msg, UPB_SIZE(12, 24)) == 15; }
-UPB_INLINE const validate_BytesRules* validate_FieldRules_bytes(const validate_FieldRules *msg) { return UPB_READ_ONEOF(msg, const validate_BytesRules*, UPB_SIZE(8, 16), UPB_SIZE(12, 24), 15, NULL); }
-UPB_INLINE bool validate_FieldRules_has_enum(const validate_FieldRules *msg) { return _upb_getoneofcase(msg, UPB_SIZE(12, 24)) == 16; }
-UPB_INLINE const validate_EnumRules* validate_FieldRules_enum(const validate_FieldRules *msg) { return UPB_READ_ONEOF(msg, const validate_EnumRules*, UPB_SIZE(8, 16), UPB_SIZE(12, 24), 16, NULL); }
-UPB_INLINE bool validate_FieldRules_has_message(const validate_FieldRules *msg) { return _upb_hasbit(msg, 1); }
+UPB_INLINE validate_FieldRules_type_oneofcases validate_FieldRules_type_case(const validate_FieldRules* msg) {
+  return (validate_FieldRules_type_oneofcases)*UPB_PTR_AT(msg, UPB_SIZE(4, 4), int32_t);
+}
+UPB_INLINE bool validate_FieldRules_has_float(const validate_FieldRules* msg) {
+  return _upb_getoneofcase(msg, UPB_SIZE(4, 4)) == 1;
+}
+UPB_INLINE void validate_FieldRules_clear_float(const validate_FieldRules* msg) {
+  UPB_WRITE_ONEOF(msg, validate_FloatRules*, UPB_SIZE(12, 16), 0, UPB_SIZE(4, 4), validate_FieldRules_type_NOT_SET);
+}
+UPB_INLINE const validate_FloatRules* validate_FieldRules_float(const validate_FieldRules* msg) {
+  return UPB_READ_ONEOF(msg, const validate_FloatRules*, UPB_SIZE(12, 16), UPB_SIZE(4, 4), 1, NULL);
+}
+UPB_INLINE bool validate_FieldRules_has_double(const validate_FieldRules* msg) {
+  return _upb_getoneofcase(msg, UPB_SIZE(4, 4)) == 2;
+}
+UPB_INLINE void validate_FieldRules_clear_double(const validate_FieldRules* msg) {
+  UPB_WRITE_ONEOF(msg, validate_DoubleRules*, UPB_SIZE(12, 16), 0, UPB_SIZE(4, 4), validate_FieldRules_type_NOT_SET);
+}
+UPB_INLINE const validate_DoubleRules* validate_FieldRules_double(const validate_FieldRules* msg) {
+  return UPB_READ_ONEOF(msg, const validate_DoubleRules*, UPB_SIZE(12, 16), UPB_SIZE(4, 4), 2, NULL);
+}
+UPB_INLINE bool validate_FieldRules_has_int32(const validate_FieldRules* msg) {
+  return _upb_getoneofcase(msg, UPB_SIZE(4, 4)) == 3;
+}
+UPB_INLINE void validate_FieldRules_clear_int32(const validate_FieldRules* msg) {
+  UPB_WRITE_ONEOF(msg, validate_Int32Rules*, UPB_SIZE(12, 16), 0, UPB_SIZE(4, 4), validate_FieldRules_type_NOT_SET);
+}
+UPB_INLINE const validate_Int32Rules* validate_FieldRules_int32(const validate_FieldRules* msg) {
+  return UPB_READ_ONEOF(msg, const validate_Int32Rules*, UPB_SIZE(12, 16), UPB_SIZE(4, 4), 3, NULL);
+}
+UPB_INLINE bool validate_FieldRules_has_int64(const validate_FieldRules* msg) {
+  return _upb_getoneofcase(msg, UPB_SIZE(4, 4)) == 4;
+}
+UPB_INLINE void validate_FieldRules_clear_int64(const validate_FieldRules* msg) {
+  UPB_WRITE_ONEOF(msg, validate_Int64Rules*, UPB_SIZE(12, 16), 0, UPB_SIZE(4, 4), validate_FieldRules_type_NOT_SET);
+}
+UPB_INLINE const validate_Int64Rules* validate_FieldRules_int64(const validate_FieldRules* msg) {
+  return UPB_READ_ONEOF(msg, const validate_Int64Rules*, UPB_SIZE(12, 16), UPB_SIZE(4, 4), 4, NULL);
+}
+UPB_INLINE bool validate_FieldRules_has_uint32(const validate_FieldRules* msg) {
+  return _upb_getoneofcase(msg, UPB_SIZE(4, 4)) == 5;
+}
+UPB_INLINE void validate_FieldRules_clear_uint32(const validate_FieldRules* msg) {
+  UPB_WRITE_ONEOF(msg, validate_UInt32Rules*, UPB_SIZE(12, 16), 0, UPB_SIZE(4, 4), validate_FieldRules_type_NOT_SET);
+}
+UPB_INLINE const validate_UInt32Rules* validate_FieldRules_uint32(const validate_FieldRules* msg) {
+  return UPB_READ_ONEOF(msg, const validate_UInt32Rules*, UPB_SIZE(12, 16), UPB_SIZE(4, 4), 5, NULL);
+}
+UPB_INLINE bool validate_FieldRules_has_uint64(const validate_FieldRules* msg) {
+  return _upb_getoneofcase(msg, UPB_SIZE(4, 4)) == 6;
+}
+UPB_INLINE void validate_FieldRules_clear_uint64(const validate_FieldRules* msg) {
+  UPB_WRITE_ONEOF(msg, validate_UInt64Rules*, UPB_SIZE(12, 16), 0, UPB_SIZE(4, 4), validate_FieldRules_type_NOT_SET);
+}
+UPB_INLINE const validate_UInt64Rules* validate_FieldRules_uint64(const validate_FieldRules* msg) {
+  return UPB_READ_ONEOF(msg, const validate_UInt64Rules*, UPB_SIZE(12, 16), UPB_SIZE(4, 4), 6, NULL);
+}
+UPB_INLINE bool validate_FieldRules_has_sint32(const validate_FieldRules* msg) {
+  return _upb_getoneofcase(msg, UPB_SIZE(4, 4)) == 7;
+}
+UPB_INLINE void validate_FieldRules_clear_sint32(const validate_FieldRules* msg) {
+  UPB_WRITE_ONEOF(msg, validate_SInt32Rules*, UPB_SIZE(12, 16), 0, UPB_SIZE(4, 4), validate_FieldRules_type_NOT_SET);
+}
+UPB_INLINE const validate_SInt32Rules* validate_FieldRules_sint32(const validate_FieldRules* msg) {
+  return UPB_READ_ONEOF(msg, const validate_SInt32Rules*, UPB_SIZE(12, 16), UPB_SIZE(4, 4), 7, NULL);
+}
+UPB_INLINE bool validate_FieldRules_has_sint64(const validate_FieldRules* msg) {
+  return _upb_getoneofcase(msg, UPB_SIZE(4, 4)) == 8;
+}
+UPB_INLINE void validate_FieldRules_clear_sint64(const validate_FieldRules* msg) {
+  UPB_WRITE_ONEOF(msg, validate_SInt64Rules*, UPB_SIZE(12, 16), 0, UPB_SIZE(4, 4), validate_FieldRules_type_NOT_SET);
+}
+UPB_INLINE const validate_SInt64Rules* validate_FieldRules_sint64(const validate_FieldRules* msg) {
+  return UPB_READ_ONEOF(msg, const validate_SInt64Rules*, UPB_SIZE(12, 16), UPB_SIZE(4, 4), 8, NULL);
+}
+UPB_INLINE bool validate_FieldRules_has_fixed32(const validate_FieldRules* msg) {
+  return _upb_getoneofcase(msg, UPB_SIZE(4, 4)) == 9;
+}
+UPB_INLINE void validate_FieldRules_clear_fixed32(const validate_FieldRules* msg) {
+  UPB_WRITE_ONEOF(msg, validate_Fixed32Rules*, UPB_SIZE(12, 16), 0, UPB_SIZE(4, 4), validate_FieldRules_type_NOT_SET);
+}
+UPB_INLINE const validate_Fixed32Rules* validate_FieldRules_fixed32(const validate_FieldRules* msg) {
+  return UPB_READ_ONEOF(msg, const validate_Fixed32Rules*, UPB_SIZE(12, 16), UPB_SIZE(4, 4), 9, NULL);
+}
+UPB_INLINE bool validate_FieldRules_has_fixed64(const validate_FieldRules* msg) {
+  return _upb_getoneofcase(msg, UPB_SIZE(4, 4)) == 10;
+}
+UPB_INLINE void validate_FieldRules_clear_fixed64(const validate_FieldRules* msg) {
+  UPB_WRITE_ONEOF(msg, validate_Fixed64Rules*, UPB_SIZE(12, 16), 0, UPB_SIZE(4, 4), validate_FieldRules_type_NOT_SET);
+}
+UPB_INLINE const validate_Fixed64Rules* validate_FieldRules_fixed64(const validate_FieldRules* msg) {
+  return UPB_READ_ONEOF(msg, const validate_Fixed64Rules*, UPB_SIZE(12, 16), UPB_SIZE(4, 4), 10, NULL);
+}
+UPB_INLINE bool validate_FieldRules_has_sfixed32(const validate_FieldRules* msg) {
+  return _upb_getoneofcase(msg, UPB_SIZE(4, 4)) == 11;
+}
+UPB_INLINE void validate_FieldRules_clear_sfixed32(const validate_FieldRules* msg) {
+  UPB_WRITE_ONEOF(msg, validate_SFixed32Rules*, UPB_SIZE(12, 16), 0, UPB_SIZE(4, 4), validate_FieldRules_type_NOT_SET);
+}
+UPB_INLINE const validate_SFixed32Rules* validate_FieldRules_sfixed32(const validate_FieldRules* msg) {
+  return UPB_READ_ONEOF(msg, const validate_SFixed32Rules*, UPB_SIZE(12, 16), UPB_SIZE(4, 4), 11, NULL);
+}
+UPB_INLINE bool validate_FieldRules_has_sfixed64(const validate_FieldRules* msg) {
+  return _upb_getoneofcase(msg, UPB_SIZE(4, 4)) == 12;
+}
+UPB_INLINE void validate_FieldRules_clear_sfixed64(const validate_FieldRules* msg) {
+  UPB_WRITE_ONEOF(msg, validate_SFixed64Rules*, UPB_SIZE(12, 16), 0, UPB_SIZE(4, 4), validate_FieldRules_type_NOT_SET);
+}
+UPB_INLINE const validate_SFixed64Rules* validate_FieldRules_sfixed64(const validate_FieldRules* msg) {
+  return UPB_READ_ONEOF(msg, const validate_SFixed64Rules*, UPB_SIZE(12, 16), UPB_SIZE(4, 4), 12, NULL);
+}
+UPB_INLINE bool validate_FieldRules_has_bool(const validate_FieldRules* msg) {
+  return _upb_getoneofcase(msg, UPB_SIZE(4, 4)) == 13;
+}
+UPB_INLINE void validate_FieldRules_clear_bool(const validate_FieldRules* msg) {
+  UPB_WRITE_ONEOF(msg, validate_BoolRules*, UPB_SIZE(12, 16), 0, UPB_SIZE(4, 4), validate_FieldRules_type_NOT_SET);
+}
+UPB_INLINE const validate_BoolRules* validate_FieldRules_bool(const validate_FieldRules* msg) {
+  return UPB_READ_ONEOF(msg, const validate_BoolRules*, UPB_SIZE(12, 16), UPB_SIZE(4, 4), 13, NULL);
+}
+UPB_INLINE bool validate_FieldRules_has_string(const validate_FieldRules* msg) {
+  return _upb_getoneofcase(msg, UPB_SIZE(4, 4)) == 14;
+}
+UPB_INLINE void validate_FieldRules_clear_string(const validate_FieldRules* msg) {
+  UPB_WRITE_ONEOF(msg, validate_StringRules*, UPB_SIZE(12, 16), 0, UPB_SIZE(4, 4), validate_FieldRules_type_NOT_SET);
+}
+UPB_INLINE const validate_StringRules* validate_FieldRules_string(const validate_FieldRules* msg) {
+  return UPB_READ_ONEOF(msg, const validate_StringRules*, UPB_SIZE(12, 16), UPB_SIZE(4, 4), 14, NULL);
+}
+UPB_INLINE bool validate_FieldRules_has_bytes(const validate_FieldRules* msg) {
+  return _upb_getoneofcase(msg, UPB_SIZE(4, 4)) == 15;
+}
+UPB_INLINE void validate_FieldRules_clear_bytes(const validate_FieldRules* msg) {
+  UPB_WRITE_ONEOF(msg, validate_BytesRules*, UPB_SIZE(12, 16), 0, UPB_SIZE(4, 4), validate_FieldRules_type_NOT_SET);
+}
+UPB_INLINE const validate_BytesRules* validate_FieldRules_bytes(const validate_FieldRules* msg) {
+  return UPB_READ_ONEOF(msg, const validate_BytesRules*, UPB_SIZE(12, 16), UPB_SIZE(4, 4), 15, NULL);
+}
+UPB_INLINE bool validate_FieldRules_has_enum(const validate_FieldRules* msg) {
+  return _upb_getoneofcase(msg, UPB_SIZE(4, 4)) == 16;
+}
+UPB_INLINE void validate_FieldRules_clear_enum(const validate_FieldRules* msg) {
+  UPB_WRITE_ONEOF(msg, validate_EnumRules*, UPB_SIZE(12, 16), 0, UPB_SIZE(4, 4), validate_FieldRules_type_NOT_SET);
+}
+UPB_INLINE const validate_EnumRules* validate_FieldRules_enum(const validate_FieldRules* msg) {
+  return UPB_READ_ONEOF(msg, const validate_EnumRules*, UPB_SIZE(12, 16), UPB_SIZE(4, 4), 16, NULL);
+}
+UPB_INLINE bool validate_FieldRules_has_message(const validate_FieldRules* msg) {
+  return _upb_hasbit(msg, 1);
+}
+UPB_INLINE void validate_FieldRules_clear_message(const validate_FieldRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(8, 8), const upb_Message*) = NULL;
+}
 UPB_INLINE const validate_MessageRules* validate_FieldRules_message(const validate_FieldRules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(4, 8), const validate_MessageRules*);
-}
-UPB_INLINE bool validate_FieldRules_has_repeated(const validate_FieldRules *msg) { return _upb_getoneofcase(msg, UPB_SIZE(12, 24)) == 18; }
-UPB_INLINE const validate_RepeatedRules* validate_FieldRules_repeated(const validate_FieldRules *msg) { return UPB_READ_ONEOF(msg, const validate_RepeatedRules*, UPB_SIZE(8, 16), UPB_SIZE(12, 24), 18, NULL); }
-UPB_INLINE bool validate_FieldRules_has_map(const validate_FieldRules *msg) { return _upb_getoneofcase(msg, UPB_SIZE(12, 24)) == 19; }
-UPB_INLINE const validate_MapRules* validate_FieldRules_map(const validate_FieldRules *msg) { return UPB_READ_ONEOF(msg, const validate_MapRules*, UPB_SIZE(8, 16), UPB_SIZE(12, 24), 19, NULL); }
-UPB_INLINE bool validate_FieldRules_has_any(const validate_FieldRules *msg) { return _upb_getoneofcase(msg, UPB_SIZE(12, 24)) == 20; }
-UPB_INLINE const validate_AnyRules* validate_FieldRules_any(const validate_FieldRules *msg) { return UPB_READ_ONEOF(msg, const validate_AnyRules*, UPB_SIZE(8, 16), UPB_SIZE(12, 24), 20, NULL); }
-UPB_INLINE bool validate_FieldRules_has_duration(const validate_FieldRules *msg) { return _upb_getoneofcase(msg, UPB_SIZE(12, 24)) == 21; }
-UPB_INLINE const validate_DurationRules* validate_FieldRules_duration(const validate_FieldRules *msg) { return UPB_READ_ONEOF(msg, const validate_DurationRules*, UPB_SIZE(8, 16), UPB_SIZE(12, 24), 21, NULL); }
-UPB_INLINE bool validate_FieldRules_has_timestamp(const validate_FieldRules *msg) { return _upb_getoneofcase(msg, UPB_SIZE(12, 24)) == 22; }
-UPB_INLINE const validate_TimestampRules* validate_FieldRules_timestamp(const validate_FieldRules *msg) { return UPB_READ_ONEOF(msg, const validate_TimestampRules*, UPB_SIZE(8, 16), UPB_SIZE(12, 24), 22, NULL); }
+  return *UPB_PTR_AT(msg, UPB_SIZE(8, 8), const validate_MessageRules*);
+}
+UPB_INLINE bool validate_FieldRules_has_repeated(const validate_FieldRules* msg) {
+  return _upb_getoneofcase(msg, UPB_SIZE(4, 4)) == 18;
+}
+UPB_INLINE void validate_FieldRules_clear_repeated(const validate_FieldRules* msg) {
+  UPB_WRITE_ONEOF(msg, validate_RepeatedRules*, UPB_SIZE(12, 16), 0, UPB_SIZE(4, 4), validate_FieldRules_type_NOT_SET);
+}
+UPB_INLINE const validate_RepeatedRules* validate_FieldRules_repeated(const validate_FieldRules* msg) {
+  return UPB_READ_ONEOF(msg, const validate_RepeatedRules*, UPB_SIZE(12, 16), UPB_SIZE(4, 4), 18, NULL);
+}
+UPB_INLINE bool validate_FieldRules_has_map(const validate_FieldRules* msg) {
+  return _upb_getoneofcase(msg, UPB_SIZE(4, 4)) == 19;
+}
+UPB_INLINE void validate_FieldRules_clear_map(const validate_FieldRules* msg) {
+  UPB_WRITE_ONEOF(msg, validate_MapRules*, UPB_SIZE(12, 16), 0, UPB_SIZE(4, 4), validate_FieldRules_type_NOT_SET);
+}
+UPB_INLINE const validate_MapRules* validate_FieldRules_map(const validate_FieldRules* msg) {
+  return UPB_READ_ONEOF(msg, const validate_MapRules*, UPB_SIZE(12, 16), UPB_SIZE(4, 4), 19, NULL);
+}
+UPB_INLINE bool validate_FieldRules_has_any(const validate_FieldRules* msg) {
+  return _upb_getoneofcase(msg, UPB_SIZE(4, 4)) == 20;
+}
+UPB_INLINE void validate_FieldRules_clear_any(const validate_FieldRules* msg) {
+  UPB_WRITE_ONEOF(msg, validate_AnyRules*, UPB_SIZE(12, 16), 0, UPB_SIZE(4, 4), validate_FieldRules_type_NOT_SET);
+}
+UPB_INLINE const validate_AnyRules* validate_FieldRules_any(const validate_FieldRules* msg) {
+  return UPB_READ_ONEOF(msg, const validate_AnyRules*, UPB_SIZE(12, 16), UPB_SIZE(4, 4), 20, NULL);
+}
+UPB_INLINE bool validate_FieldRules_has_duration(const validate_FieldRules* msg) {
+  return _upb_getoneofcase(msg, UPB_SIZE(4, 4)) == 21;
+}
+UPB_INLINE void validate_FieldRules_clear_duration(const validate_FieldRules* msg) {
+  UPB_WRITE_ONEOF(msg, validate_DurationRules*, UPB_SIZE(12, 16), 0, UPB_SIZE(4, 4), validate_FieldRules_type_NOT_SET);
+}
+UPB_INLINE const validate_DurationRules* validate_FieldRules_duration(const validate_FieldRules* msg) {
+  return UPB_READ_ONEOF(msg, const validate_DurationRules*, UPB_SIZE(12, 16), UPB_SIZE(4, 4), 21, NULL);
+}
+UPB_INLINE bool validate_FieldRules_has_timestamp(const validate_FieldRules* msg) {
+  return _upb_getoneofcase(msg, UPB_SIZE(4, 4)) == 22;
+}
+UPB_INLINE void validate_FieldRules_clear_timestamp(const validate_FieldRules* msg) {
+  UPB_WRITE_ONEOF(msg, validate_TimestampRules*, UPB_SIZE(12, 16), 0, UPB_SIZE(4, 4), validate_FieldRules_type_NOT_SET);
+}
+UPB_INLINE const validate_TimestampRules* validate_FieldRules_timestamp(const validate_FieldRules* msg) {
+  return UPB_READ_ONEOF(msg, const validate_TimestampRules*, UPB_SIZE(12, 16), UPB_SIZE(4, 4), 22, NULL);
+}
 
 UPB_INLINE void validate_FieldRules_set_float(validate_FieldRules *msg, validate_FloatRules* value) {
-  UPB_WRITE_ONEOF(msg, validate_FloatRules*, UPB_SIZE(8, 16), value, UPB_SIZE(12, 24), 1);
+  UPB_WRITE_ONEOF(msg, validate_FloatRules*, UPB_SIZE(12, 16), value, UPB_SIZE(4, 4), 1);
 }
-UPB_INLINE struct validate_FloatRules* validate_FieldRules_mutable_float(validate_FieldRules *msg, upb_Arena *arena) {
+UPB_INLINE struct validate_FloatRules* validate_FieldRules_mutable_float(validate_FieldRules* msg, upb_Arena* arena) {
   struct validate_FloatRules* sub = (struct validate_FloatRules*)validate_FieldRules_float(msg);
   if (sub == NULL) {
     sub = (struct validate_FloatRules*)_upb_Message_New(&validate_FloatRules_msginit, arena);
@@ -230,9 +387,9 @@ UPB_INLINE struct validate_FloatRules* validate_FieldRules_mutable_float(validat
   return sub;
 }
 UPB_INLINE void validate_FieldRules_set_double(validate_FieldRules *msg, validate_DoubleRules* value) {
-  UPB_WRITE_ONEOF(msg, validate_DoubleRules*, UPB_SIZE(8, 16), value, UPB_SIZE(12, 24), 2);
+  UPB_WRITE_ONEOF(msg, validate_DoubleRules*, UPB_SIZE(12, 16), value, UPB_SIZE(4, 4), 2);
 }
-UPB_INLINE struct validate_DoubleRules* validate_FieldRules_mutable_double(validate_FieldRules *msg, upb_Arena *arena) {
+UPB_INLINE struct validate_DoubleRules* validate_FieldRules_mutable_double(validate_FieldRules* msg, upb_Arena* arena) {
   struct validate_DoubleRules* sub = (struct validate_DoubleRules*)validate_FieldRules_double(msg);
   if (sub == NULL) {
     sub = (struct validate_DoubleRules*)_upb_Message_New(&validate_DoubleRules_msginit, arena);
@@ -242,9 +399,9 @@ UPB_INLINE struct validate_DoubleRules* validate_FieldRules_mutable_double(valid
   return sub;
 }
 UPB_INLINE void validate_FieldRules_set_int32(validate_FieldRules *msg, validate_Int32Rules* value) {
-  UPB_WRITE_ONEOF(msg, validate_Int32Rules*, UPB_SIZE(8, 16), value, UPB_SIZE(12, 24), 3);
+  UPB_WRITE_ONEOF(msg, validate_Int32Rules*, UPB_SIZE(12, 16), value, UPB_SIZE(4, 4), 3);
 }
-UPB_INLINE struct validate_Int32Rules* validate_FieldRules_mutable_int32(validate_FieldRules *msg, upb_Arena *arena) {
+UPB_INLINE struct validate_Int32Rules* validate_FieldRules_mutable_int32(validate_FieldRules* msg, upb_Arena* arena) {
   struct validate_Int32Rules* sub = (struct validate_Int32Rules*)validate_FieldRules_int32(msg);
   if (sub == NULL) {
     sub = (struct validate_Int32Rules*)_upb_Message_New(&validate_Int32Rules_msginit, arena);
@@ -254,9 +411,9 @@ UPB_INLINE struct validate_Int32Rules* validate_FieldRules_mutable_int32(validat
   return sub;
 }
 UPB_INLINE void validate_FieldRules_set_int64(validate_FieldRules *msg, validate_Int64Rules* value) {
-  UPB_WRITE_ONEOF(msg, validate_Int64Rules*, UPB_SIZE(8, 16), value, UPB_SIZE(12, 24), 4);
+  UPB_WRITE_ONEOF(msg, validate_Int64Rules*, UPB_SIZE(12, 16), value, UPB_SIZE(4, 4), 4);
 }
-UPB_INLINE struct validate_Int64Rules* validate_FieldRules_mutable_int64(validate_FieldRules *msg, upb_Arena *arena) {
+UPB_INLINE struct validate_Int64Rules* validate_FieldRules_mutable_int64(validate_FieldRules* msg, upb_Arena* arena) {
   struct validate_Int64Rules* sub = (struct validate_Int64Rules*)validate_FieldRules_int64(msg);
   if (sub == NULL) {
     sub = (struct validate_Int64Rules*)_upb_Message_New(&validate_Int64Rules_msginit, arena);
@@ -266,9 +423,9 @@ UPB_INLINE struct validate_Int64Rules* validate_FieldRules_mutable_int64(validat
   return sub;
 }
 UPB_INLINE void validate_FieldRules_set_uint32(validate_FieldRules *msg, validate_UInt32Rules* value) {
-  UPB_WRITE_ONEOF(msg, validate_UInt32Rules*, UPB_SIZE(8, 16), value, UPB_SIZE(12, 24), 5);
+  UPB_WRITE_ONEOF(msg, validate_UInt32Rules*, UPB_SIZE(12, 16), value, UPB_SIZE(4, 4), 5);
 }
-UPB_INLINE struct validate_UInt32Rules* validate_FieldRules_mutable_uint32(validate_FieldRules *msg, upb_Arena *arena) {
+UPB_INLINE struct validate_UInt32Rules* validate_FieldRules_mutable_uint32(validate_FieldRules* msg, upb_Arena* arena) {
   struct validate_UInt32Rules* sub = (struct validate_UInt32Rules*)validate_FieldRules_uint32(msg);
   if (sub == NULL) {
     sub = (struct validate_UInt32Rules*)_upb_Message_New(&validate_UInt32Rules_msginit, arena);
@@ -278,9 +435,9 @@ UPB_INLINE struct validate_UInt32Rules* validate_FieldRules_mutable_uint32(valid
   return sub;
 }
 UPB_INLINE void validate_FieldRules_set_uint64(validate_FieldRules *msg, validate_UInt64Rules* value) {
-  UPB_WRITE_ONEOF(msg, validate_UInt64Rules*, UPB_SIZE(8, 16), value, UPB_SIZE(12, 24), 6);
+  UPB_WRITE_ONEOF(msg, validate_UInt64Rules*, UPB_SIZE(12, 16), value, UPB_SIZE(4, 4), 6);
 }
-UPB_INLINE struct validate_UInt64Rules* validate_FieldRules_mutable_uint64(validate_FieldRules *msg, upb_Arena *arena) {
+UPB_INLINE struct validate_UInt64Rules* validate_FieldRules_mutable_uint64(validate_FieldRules* msg, upb_Arena* arena) {
   struct validate_UInt64Rules* sub = (struct validate_UInt64Rules*)validate_FieldRules_uint64(msg);
   if (sub == NULL) {
     sub = (struct validate_UInt64Rules*)_upb_Message_New(&validate_UInt64Rules_msginit, arena);
@@ -290,9 +447,9 @@ UPB_INLINE struct validate_UInt64Rules* validate_FieldRules_mutable_uint64(valid
   return sub;
 }
 UPB_INLINE void validate_FieldRules_set_sint32(validate_FieldRules *msg, validate_SInt32Rules* value) {
-  UPB_WRITE_ONEOF(msg, validate_SInt32Rules*, UPB_SIZE(8, 16), value, UPB_SIZE(12, 24), 7);
+  UPB_WRITE_ONEOF(msg, validate_SInt32Rules*, UPB_SIZE(12, 16), value, UPB_SIZE(4, 4), 7);
 }
-UPB_INLINE struct validate_SInt32Rules* validate_FieldRules_mutable_sint32(validate_FieldRules *msg, upb_Arena *arena) {
+UPB_INLINE struct validate_SInt32Rules* validate_FieldRules_mutable_sint32(validate_FieldRules* msg, upb_Arena* arena) {
   struct validate_SInt32Rules* sub = (struct validate_SInt32Rules*)validate_FieldRules_sint32(msg);
   if (sub == NULL) {
     sub = (struct validate_SInt32Rules*)_upb_Message_New(&validate_SInt32Rules_msginit, arena);
@@ -302,9 +459,9 @@ UPB_INLINE struct validate_SInt32Rules* validate_FieldRules_mutable_sint32(valid
   return sub;
 }
 UPB_INLINE void validate_FieldRules_set_sint64(validate_FieldRules *msg, validate_SInt64Rules* value) {
-  UPB_WRITE_ONEOF(msg, validate_SInt64Rules*, UPB_SIZE(8, 16), value, UPB_SIZE(12, 24), 8);
+  UPB_WRITE_ONEOF(msg, validate_SInt64Rules*, UPB_SIZE(12, 16), value, UPB_SIZE(4, 4), 8);
 }
-UPB_INLINE struct validate_SInt64Rules* validate_FieldRules_mutable_sint64(validate_FieldRules *msg, upb_Arena *arena) {
+UPB_INLINE struct validate_SInt64Rules* validate_FieldRules_mutable_sint64(validate_FieldRules* msg, upb_Arena* arena) {
   struct validate_SInt64Rules* sub = (struct validate_SInt64Rules*)validate_FieldRules_sint64(msg);
   if (sub == NULL) {
     sub = (struct validate_SInt64Rules*)_upb_Message_New(&validate_SInt64Rules_msginit, arena);
@@ -314,9 +471,9 @@ UPB_INLINE struct validate_SInt64Rules* validate_FieldRules_mutable_sint64(valid
   return sub;
 }
 UPB_INLINE void validate_FieldRules_set_fixed32(validate_FieldRules *msg, validate_Fixed32Rules* value) {
-  UPB_WRITE_ONEOF(msg, validate_Fixed32Rules*, UPB_SIZE(8, 16), value, UPB_SIZE(12, 24), 9);
+  UPB_WRITE_ONEOF(msg, validate_Fixed32Rules*, UPB_SIZE(12, 16), value, UPB_SIZE(4, 4), 9);
 }
-UPB_INLINE struct validate_Fixed32Rules* validate_FieldRules_mutable_fixed32(validate_FieldRules *msg, upb_Arena *arena) {
+UPB_INLINE struct validate_Fixed32Rules* validate_FieldRules_mutable_fixed32(validate_FieldRules* msg, upb_Arena* arena) {
   struct validate_Fixed32Rules* sub = (struct validate_Fixed32Rules*)validate_FieldRules_fixed32(msg);
   if (sub == NULL) {
     sub = (struct validate_Fixed32Rules*)_upb_Message_New(&validate_Fixed32Rules_msginit, arena);
@@ -326,9 +483,9 @@ UPB_INLINE struct validate_Fixed32Rules* validate_FieldRules_mutable_fixed32(val
   return sub;
 }
 UPB_INLINE void validate_FieldRules_set_fixed64(validate_FieldRules *msg, validate_Fixed64Rules* value) {
-  UPB_WRITE_ONEOF(msg, validate_Fixed64Rules*, UPB_SIZE(8, 16), value, UPB_SIZE(12, 24), 10);
+  UPB_WRITE_ONEOF(msg, validate_Fixed64Rules*, UPB_SIZE(12, 16), value, UPB_SIZE(4, 4), 10);
 }
-UPB_INLINE struct validate_Fixed64Rules* validate_FieldRules_mutable_fixed64(validate_FieldRules *msg, upb_Arena *arena) {
+UPB_INLINE struct validate_Fixed64Rules* validate_FieldRules_mutable_fixed64(validate_FieldRules* msg, upb_Arena* arena) {
   struct validate_Fixed64Rules* sub = (struct validate_Fixed64Rules*)validate_FieldRules_fixed64(msg);
   if (sub == NULL) {
     sub = (struct validate_Fixed64Rules*)_upb_Message_New(&validate_Fixed64Rules_msginit, arena);
@@ -338,9 +495,9 @@ UPB_INLINE struct validate_Fixed64Rules* validate_FieldRules_mutable_fixed64(val
   return sub;
 }
 UPB_INLINE void validate_FieldRules_set_sfixed32(validate_FieldRules *msg, validate_SFixed32Rules* value) {
-  UPB_WRITE_ONEOF(msg, validate_SFixed32Rules*, UPB_SIZE(8, 16), value, UPB_SIZE(12, 24), 11);
+  UPB_WRITE_ONEOF(msg, validate_SFixed32Rules*, UPB_SIZE(12, 16), value, UPB_SIZE(4, 4), 11);
 }
-UPB_INLINE struct validate_SFixed32Rules* validate_FieldRules_mutable_sfixed32(validate_FieldRules *msg, upb_Arena *arena) {
+UPB_INLINE struct validate_SFixed32Rules* validate_FieldRules_mutable_sfixed32(validate_FieldRules* msg, upb_Arena* arena) {
   struct validate_SFixed32Rules* sub = (struct validate_SFixed32Rules*)validate_FieldRules_sfixed32(msg);
   if (sub == NULL) {
     sub = (struct validate_SFixed32Rules*)_upb_Message_New(&validate_SFixed32Rules_msginit, arena);
@@ -350,9 +507,9 @@ UPB_INLINE struct validate_SFixed32Rules* validate_FieldRules_mutable_sfixed32(v
   return sub;
 }
 UPB_INLINE void validate_FieldRules_set_sfixed64(validate_FieldRules *msg, validate_SFixed64Rules* value) {
-  UPB_WRITE_ONEOF(msg, validate_SFixed64Rules*, UPB_SIZE(8, 16), value, UPB_SIZE(12, 24), 12);
+  UPB_WRITE_ONEOF(msg, validate_SFixed64Rules*, UPB_SIZE(12, 16), value, UPB_SIZE(4, 4), 12);
 }
-UPB_INLINE struct validate_SFixed64Rules* validate_FieldRules_mutable_sfixed64(validate_FieldRules *msg, upb_Arena *arena) {
+UPB_INLINE struct validate_SFixed64Rules* validate_FieldRules_mutable_sfixed64(validate_FieldRules* msg, upb_Arena* arena) {
   struct validate_SFixed64Rules* sub = (struct validate_SFixed64Rules*)validate_FieldRules_sfixed64(msg);
   if (sub == NULL) {
     sub = (struct validate_SFixed64Rules*)_upb_Message_New(&validate_SFixed64Rules_msginit, arena);
@@ -362,9 +519,9 @@ UPB_INLINE struct validate_SFixed64Rules* validate_FieldRules_mutable_sfixed64(v
   return sub;
 }
 UPB_INLINE void validate_FieldRules_set_bool(validate_FieldRules *msg, validate_BoolRules* value) {
-  UPB_WRITE_ONEOF(msg, validate_BoolRules*, UPB_SIZE(8, 16), value, UPB_SIZE(12, 24), 13);
+  UPB_WRITE_ONEOF(msg, validate_BoolRules*, UPB_SIZE(12, 16), value, UPB_SIZE(4, 4), 13);
 }
-UPB_INLINE struct validate_BoolRules* validate_FieldRules_mutable_bool(validate_FieldRules *msg, upb_Arena *arena) {
+UPB_INLINE struct validate_BoolRules* validate_FieldRules_mutable_bool(validate_FieldRules* msg, upb_Arena* arena) {
   struct validate_BoolRules* sub = (struct validate_BoolRules*)validate_FieldRules_bool(msg);
   if (sub == NULL) {
     sub = (struct validate_BoolRules*)_upb_Message_New(&validate_BoolRules_msginit, arena);
@@ -374,9 +531,9 @@ UPB_INLINE struct validate_BoolRules* validate_FieldRules_mutable_bool(validate_
   return sub;
 }
 UPB_INLINE void validate_FieldRules_set_string(validate_FieldRules *msg, validate_StringRules* value) {
-  UPB_WRITE_ONEOF(msg, validate_StringRules*, UPB_SIZE(8, 16), value, UPB_SIZE(12, 24), 14);
+  UPB_WRITE_ONEOF(msg, validate_StringRules*, UPB_SIZE(12, 16), value, UPB_SIZE(4, 4), 14);
 }
-UPB_INLINE struct validate_StringRules* validate_FieldRules_mutable_string(validate_FieldRules *msg, upb_Arena *arena) {
+UPB_INLINE struct validate_StringRules* validate_FieldRules_mutable_string(validate_FieldRules* msg, upb_Arena* arena) {
   struct validate_StringRules* sub = (struct validate_StringRules*)validate_FieldRules_string(msg);
   if (sub == NULL) {
     sub = (struct validate_StringRules*)_upb_Message_New(&validate_StringRules_msginit, arena);
@@ -386,9 +543,9 @@ UPB_INLINE struct validate_StringRules* validate_FieldRules_mutable_string(valid
   return sub;
 }
 UPB_INLINE void validate_FieldRules_set_bytes(validate_FieldRules *msg, validate_BytesRules* value) {
-  UPB_WRITE_ONEOF(msg, validate_BytesRules*, UPB_SIZE(8, 16), value, UPB_SIZE(12, 24), 15);
+  UPB_WRITE_ONEOF(msg, validate_BytesRules*, UPB_SIZE(12, 16), value, UPB_SIZE(4, 4), 15);
 }
-UPB_INLINE struct validate_BytesRules* validate_FieldRules_mutable_bytes(validate_FieldRules *msg, upb_Arena *arena) {
+UPB_INLINE struct validate_BytesRules* validate_FieldRules_mutable_bytes(validate_FieldRules* msg, upb_Arena* arena) {
   struct validate_BytesRules* sub = (struct validate_BytesRules*)validate_FieldRules_bytes(msg);
   if (sub == NULL) {
     sub = (struct validate_BytesRules*)_upb_Message_New(&validate_BytesRules_msginit, arena);
@@ -398,9 +555,9 @@ UPB_INLINE struct validate_BytesRules* validate_FieldRules_mutable_bytes(validat
   return sub;
 }
 UPB_INLINE void validate_FieldRules_set_enum(validate_FieldRules *msg, validate_EnumRules* value) {
-  UPB_WRITE_ONEOF(msg, validate_EnumRules*, UPB_SIZE(8, 16), value, UPB_SIZE(12, 24), 16);
+  UPB_WRITE_ONEOF(msg, validate_EnumRules*, UPB_SIZE(12, 16), value, UPB_SIZE(4, 4), 16);
 }
-UPB_INLINE struct validate_EnumRules* validate_FieldRules_mutable_enum(validate_FieldRules *msg, upb_Arena *arena) {
+UPB_INLINE struct validate_EnumRules* validate_FieldRules_mutable_enum(validate_FieldRules* msg, upb_Arena* arena) {
   struct validate_EnumRules* sub = (struct validate_EnumRules*)validate_FieldRules_enum(msg);
   if (sub == NULL) {
     sub = (struct validate_EnumRules*)_upb_Message_New(&validate_EnumRules_msginit, arena);
@@ -411,9 +568,9 @@ UPB_INLINE struct validate_EnumRules* validate_FieldRules_mutable_enum(validate_
 }
 UPB_INLINE void validate_FieldRules_set_message(validate_FieldRules *msg, validate_MessageRules* value) {
   _upb_sethas(msg, 1);
-  *UPB_PTR_AT(msg, UPB_SIZE(4, 8), validate_MessageRules*) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(8, 8), validate_MessageRules*) = value;
 }
-UPB_INLINE struct validate_MessageRules* validate_FieldRules_mutable_message(validate_FieldRules *msg, upb_Arena *arena) {
+UPB_INLINE struct validate_MessageRules* validate_FieldRules_mutable_message(validate_FieldRules* msg, upb_Arena* arena) {
   struct validate_MessageRules* sub = (struct validate_MessageRules*)validate_FieldRules_message(msg);
   if (sub == NULL) {
     sub = (struct validate_MessageRules*)_upb_Message_New(&validate_MessageRules_msginit, arena);
@@ -423,9 +580,9 @@ UPB_INLINE struct validate_MessageRules* validate_FieldRules_mutable_message(val
   return sub;
 }
 UPB_INLINE void validate_FieldRules_set_repeated(validate_FieldRules *msg, validate_RepeatedRules* value) {
-  UPB_WRITE_ONEOF(msg, validate_RepeatedRules*, UPB_SIZE(8, 16), value, UPB_SIZE(12, 24), 18);
+  UPB_WRITE_ONEOF(msg, validate_RepeatedRules*, UPB_SIZE(12, 16), value, UPB_SIZE(4, 4), 18);
 }
-UPB_INLINE struct validate_RepeatedRules* validate_FieldRules_mutable_repeated(validate_FieldRules *msg, upb_Arena *arena) {
+UPB_INLINE struct validate_RepeatedRules* validate_FieldRules_mutable_repeated(validate_FieldRules* msg, upb_Arena* arena) {
   struct validate_RepeatedRules* sub = (struct validate_RepeatedRules*)validate_FieldRules_repeated(msg);
   if (sub == NULL) {
     sub = (struct validate_RepeatedRules*)_upb_Message_New(&validate_RepeatedRules_msginit, arena);
@@ -435,9 +592,9 @@ UPB_INLINE struct validate_RepeatedRules* validate_FieldRules_mutable_repeated(v
   return sub;
 }
 UPB_INLINE void validate_FieldRules_set_map(validate_FieldRules *msg, validate_MapRules* value) {
-  UPB_WRITE_ONEOF(msg, validate_MapRules*, UPB_SIZE(8, 16), value, UPB_SIZE(12, 24), 19);
+  UPB_WRITE_ONEOF(msg, validate_MapRules*, UPB_SIZE(12, 16), value, UPB_SIZE(4, 4), 19);
 }
-UPB_INLINE struct validate_MapRules* validate_FieldRules_mutable_map(validate_FieldRules *msg, upb_Arena *arena) {
+UPB_INLINE struct validate_MapRules* validate_FieldRules_mutable_map(validate_FieldRules* msg, upb_Arena* arena) {
   struct validate_MapRules* sub = (struct validate_MapRules*)validate_FieldRules_map(msg);
   if (sub == NULL) {
     sub = (struct validate_MapRules*)_upb_Message_New(&validate_MapRules_msginit, arena);
@@ -447,9 +604,9 @@ UPB_INLINE struct validate_MapRules* validate_FieldRules_mutable_map(validate_Fi
   return sub;
 }
 UPB_INLINE void validate_FieldRules_set_any(validate_FieldRules *msg, validate_AnyRules* value) {
-  UPB_WRITE_ONEOF(msg, validate_AnyRules*, UPB_SIZE(8, 16), value, UPB_SIZE(12, 24), 20);
+  UPB_WRITE_ONEOF(msg, validate_AnyRules*, UPB_SIZE(12, 16), value, UPB_SIZE(4, 4), 20);
 }
-UPB_INLINE struct validate_AnyRules* validate_FieldRules_mutable_any(validate_FieldRules *msg, upb_Arena *arena) {
+UPB_INLINE struct validate_AnyRules* validate_FieldRules_mutable_any(validate_FieldRules* msg, upb_Arena* arena) {
   struct validate_AnyRules* sub = (struct validate_AnyRules*)validate_FieldRules_any(msg);
   if (sub == NULL) {
     sub = (struct validate_AnyRules*)_upb_Message_New(&validate_AnyRules_msginit, arena);
@@ -459,9 +616,9 @@ UPB_INLINE struct validate_AnyRules* validate_FieldRules_mutable_any(validate_Fi
   return sub;
 }
 UPB_INLINE void validate_FieldRules_set_duration(validate_FieldRules *msg, validate_DurationRules* value) {
-  UPB_WRITE_ONEOF(msg, validate_DurationRules*, UPB_SIZE(8, 16), value, UPB_SIZE(12, 24), 21);
+  UPB_WRITE_ONEOF(msg, validate_DurationRules*, UPB_SIZE(12, 16), value, UPB_SIZE(4, 4), 21);
 }
-UPB_INLINE struct validate_DurationRules* validate_FieldRules_mutable_duration(validate_FieldRules *msg, upb_Arena *arena) {
+UPB_INLINE struct validate_DurationRules* validate_FieldRules_mutable_duration(validate_FieldRules* msg, upb_Arena* arena) {
   struct validate_DurationRules* sub = (struct validate_DurationRules*)validate_FieldRules_duration(msg);
   if (sub == NULL) {
     sub = (struct validate_DurationRules*)_upb_Message_New(&validate_DurationRules_msginit, arena);
@@ -471,9 +628,9 @@ UPB_INLINE struct validate_DurationRules* validate_FieldRules_mutable_duration(v
   return sub;
 }
 UPB_INLINE void validate_FieldRules_set_timestamp(validate_FieldRules *msg, validate_TimestampRules* value) {
-  UPB_WRITE_ONEOF(msg, validate_TimestampRules*, UPB_SIZE(8, 16), value, UPB_SIZE(12, 24), 22);
+  UPB_WRITE_ONEOF(msg, validate_TimestampRules*, UPB_SIZE(12, 16), value, UPB_SIZE(4, 4), 22);
 }
-UPB_INLINE struct validate_TimestampRules* validate_FieldRules_mutable_timestamp(validate_FieldRules *msg, upb_Arena *arena) {
+UPB_INLINE struct validate_TimestampRules* validate_FieldRules_mutable_timestamp(validate_FieldRules* msg, upb_Arena* arena) {
   struct validate_TimestampRules* sub = (struct validate_TimestampRules*)validate_FieldRules_timestamp(msg);
   if (sub == NULL) {
     sub = (struct validate_TimestampRules*)_upb_Message_New(&validate_TimestampRules_msginit, arena);
@@ -508,35 +665,85 @@ 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);
+}
+UPB_INLINE void validate_FloatRules_clear_const(const validate_FloatRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(4, 4), float) = 0;
+  _upb_clearhas(msg, 1);
 }
-UPB_INLINE bool validate_FloatRules_has_const(const validate_FloatRules *msg) { return _upb_hasbit(msg, 1); }
 UPB_INLINE float validate_FloatRules_const(const validate_FloatRules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(4, 4), float);
 }
-UPB_INLINE bool validate_FloatRules_has_lt(const validate_FloatRules *msg) { return _upb_hasbit(msg, 2); }
+UPB_INLINE bool validate_FloatRules_has_lt(const validate_FloatRules* msg) {
+  return _upb_hasbit(msg, 2);
+}
+UPB_INLINE void validate_FloatRules_clear_lt(const validate_FloatRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(8, 8), float) = 0;
+  _upb_clearhas(msg, 2);
+}
 UPB_INLINE float validate_FloatRules_lt(const validate_FloatRules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(8, 8), float);
 }
-UPB_INLINE bool validate_FloatRules_has_lte(const validate_FloatRules *msg) { return _upb_hasbit(msg, 3); }
+UPB_INLINE bool validate_FloatRules_has_lte(const validate_FloatRules* msg) {
+  return _upb_hasbit(msg, 3);
+}
+UPB_INLINE void validate_FloatRules_clear_lte(const validate_FloatRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(12, 12), float) = 0;
+  _upb_clearhas(msg, 3);
+}
 UPB_INLINE float validate_FloatRules_lte(const validate_FloatRules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(12, 12), float);
 }
-UPB_INLINE bool validate_FloatRules_has_gt(const validate_FloatRules *msg) { return _upb_hasbit(msg, 4); }
+UPB_INLINE bool validate_FloatRules_has_gt(const validate_FloatRules* msg) {
+  return _upb_hasbit(msg, 4);
+}
+UPB_INLINE void validate_FloatRules_clear_gt(const validate_FloatRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(16, 16), float) = 0;
+  _upb_clearhas(msg, 4);
+}
 UPB_INLINE float validate_FloatRules_gt(const validate_FloatRules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(16, 16), float);
 }
-UPB_INLINE bool validate_FloatRules_has_gte(const validate_FloatRules *msg) { return _upb_hasbit(msg, 5); }
+UPB_INLINE bool validate_FloatRules_has_gte(const validate_FloatRules* msg) {
+  return _upb_hasbit(msg, 5);
+}
+UPB_INLINE void validate_FloatRules_clear_gte(const validate_FloatRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(20, 20), float) = 0;
+  _upb_clearhas(msg, 5);
+}
 UPB_INLINE float validate_FloatRules_gte(const validate_FloatRules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(20, 20), float);
 }
-UPB_INLINE float const* validate_FloatRules_in(const validate_FloatRules *msg, size_t *len) { return (float const*)_upb_array_accessor(msg, UPB_SIZE(28, 32), len); }
-UPB_INLINE float const* validate_FloatRules_not_in(const validate_FloatRules *msg, size_t *len) { return (float const*)_upb_array_accessor(msg, UPB_SIZE(32, 40), len); }
-UPB_INLINE bool validate_FloatRules_has_ignore_empty(const validate_FloatRules *msg) { return _upb_hasbit(msg, 6); }
+UPB_INLINE void validate_FloatRules_clear_in(const validate_FloatRules* msg) {
+  _upb_array_detach(msg, UPB_SIZE(28, 32));
+}
+UPB_INLINE float const* validate_FloatRules_in(const validate_FloatRules* msg, size_t* len) {
+  return (float const*)_upb_array_accessor(msg, UPB_SIZE(28, 32), len);
+}
+UPB_INLINE void validate_FloatRules_clear_not_in(const validate_FloatRules* msg) {
+  _upb_array_detach(msg, UPB_SIZE(32, 40));
+}
+UPB_INLINE float const* validate_FloatRules_not_in(const validate_FloatRules* msg, size_t* len) {
+  return (float const*)_upb_array_accessor(msg, UPB_SIZE(32, 40), len);
+}
+UPB_INLINE bool validate_FloatRules_has_ignore_empty(const validate_FloatRules* msg) {
+  return _upb_hasbit(msg, 6);
+}
+UPB_INLINE void validate_FloatRules_clear_ignore_empty(const validate_FloatRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(24, 24), bool) = 0;
+  _upb_clearhas(msg, 6);
+}
 UPB_INLINE bool validate_FloatRules_ignore_empty(const validate_FloatRules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(24, 24), bool);
 }
@@ -561,25 +768,23 @@ UPB_INLINE void validate_FloatRules_set_gte(validate_FloatRules *msg, float valu
   _upb_sethas(msg, 5);
   *UPB_PTR_AT(msg, UPB_SIZE(20, 20), float) = value;
 }
-UPB_INLINE float* validate_FloatRules_mutable_in(validate_FloatRules *msg, size_t *len) {
+UPB_INLINE float* validate_FloatRules_mutable_in(validate_FloatRules* msg, size_t* len) {
   return (float*)_upb_array_mutable_accessor(msg, UPB_SIZE(28, 32), len);
 }
-UPB_INLINE float* validate_FloatRules_resize_in(validate_FloatRules *msg, size_t len, upb_Arena *arena) {
+UPB_INLINE float* validate_FloatRules_resize_in(validate_FloatRules* msg, size_t len, upb_Arena* arena) {
   return (float*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(28, 32), len, 2, arena);
 }
-UPB_INLINE bool validate_FloatRules_add_in(validate_FloatRules *msg, float val, upb_Arena *arena) {
-  return _upb_Array_Append_accessor2(msg, UPB_SIZE(28, 32), 2, &val,
-      arena);
+UPB_INLINE bool validate_FloatRules_add_in(validate_FloatRules* msg, float val, upb_Arena* arena) {
+  return _upb_Array_Append_accessor2(msg, UPB_SIZE(28, 32), 2, &val, arena);
 }
-UPB_INLINE float* validate_FloatRules_mutable_not_in(validate_FloatRules *msg, size_t *len) {
+UPB_INLINE float* validate_FloatRules_mutable_not_in(validate_FloatRules* msg, size_t* len) {
   return (float*)_upb_array_mutable_accessor(msg, UPB_SIZE(32, 40), len);
 }
-UPB_INLINE float* validate_FloatRules_resize_not_in(validate_FloatRules *msg, size_t len, upb_Arena *arena) {
+UPB_INLINE float* validate_FloatRules_resize_not_in(validate_FloatRules* msg, size_t len, upb_Arena* arena) {
   return (float*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(32, 40), len, 2, arena);
 }
-UPB_INLINE bool validate_FloatRules_add_not_in(validate_FloatRules *msg, float val, upb_Arena *arena) {
-  return _upb_Array_Append_accessor2(msg, UPB_SIZE(32, 40), 2, &val,
-      arena);
+UPB_INLINE bool validate_FloatRules_add_not_in(validate_FloatRules* msg, float val, upb_Arena* arena) {
+  return _upb_Array_Append_accessor2(msg, UPB_SIZE(32, 40), 2, &val, arena);
 }
 UPB_INLINE void validate_FloatRules_set_ignore_empty(validate_FloatRules *msg, bool value) {
   _upb_sethas(msg, 6);
@@ -611,82 +816,130 @@ 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);
+}
+UPB_INLINE void validate_DoubleRules_clear_const(const validate_DoubleRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(16, 24), double) = 0;
+  _upb_clearhas(msg, 1);
 }
-UPB_INLINE bool validate_DoubleRules_has_const(const validate_DoubleRules *msg) { return _upb_hasbit(msg, 1); }
 UPB_INLINE double validate_DoubleRules_const(const validate_DoubleRules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(8, 8), double);
+  return *UPB_PTR_AT(msg, UPB_SIZE(16, 24), double);
+}
+UPB_INLINE bool validate_DoubleRules_has_lt(const validate_DoubleRules* msg) {
+  return _upb_hasbit(msg, 2);
+}
+UPB_INLINE void validate_DoubleRules_clear_lt(const validate_DoubleRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(24, 32), double) = 0;
+  _upb_clearhas(msg, 2);
 }
-UPB_INLINE bool validate_DoubleRules_has_lt(const validate_DoubleRules *msg) { return _upb_hasbit(msg, 2); }
 UPB_INLINE double validate_DoubleRules_lt(const validate_DoubleRules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(16, 16), double);
+  return *UPB_PTR_AT(msg, UPB_SIZE(24, 32), double);
+}
+UPB_INLINE bool validate_DoubleRules_has_lte(const validate_DoubleRules* msg) {
+  return _upb_hasbit(msg, 3);
+}
+UPB_INLINE void validate_DoubleRules_clear_lte(const validate_DoubleRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(32, 40), double) = 0;
+  _upb_clearhas(msg, 3);
 }
-UPB_INLINE bool validate_DoubleRules_has_lte(const validate_DoubleRules *msg) { return _upb_hasbit(msg, 3); }
 UPB_INLINE double validate_DoubleRules_lte(const validate_DoubleRules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(24, 24), double);
+  return *UPB_PTR_AT(msg, UPB_SIZE(32, 40), double);
+}
+UPB_INLINE bool validate_DoubleRules_has_gt(const validate_DoubleRules* msg) {
+  return _upb_hasbit(msg, 4);
+}
+UPB_INLINE void validate_DoubleRules_clear_gt(const validate_DoubleRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(40, 48), double) = 0;
+  _upb_clearhas(msg, 4);
 }
-UPB_INLINE bool validate_DoubleRules_has_gt(const validate_DoubleRules *msg) { return _upb_hasbit(msg, 4); }
 UPB_INLINE double validate_DoubleRules_gt(const validate_DoubleRules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(32, 32), double);
+  return *UPB_PTR_AT(msg, UPB_SIZE(40, 48), double);
+}
+UPB_INLINE bool validate_DoubleRules_has_gte(const validate_DoubleRules* msg) {
+  return _upb_hasbit(msg, 5);
+}
+UPB_INLINE void validate_DoubleRules_clear_gte(const validate_DoubleRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(48, 56), double) = 0;
+  _upb_clearhas(msg, 5);
 }
-UPB_INLINE bool validate_DoubleRules_has_gte(const validate_DoubleRules *msg) { return _upb_hasbit(msg, 5); }
 UPB_INLINE double validate_DoubleRules_gte(const validate_DoubleRules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(40, 40), double);
+  return *UPB_PTR_AT(msg, UPB_SIZE(48, 56), double);
+}
+UPB_INLINE void validate_DoubleRules_clear_in(const validate_DoubleRules* msg) {
+  _upb_array_detach(msg, UPB_SIZE(4, 8));
+}
+UPB_INLINE double const* validate_DoubleRules_in(const validate_DoubleRules* msg, size_t* len) {
+  return (double const*)_upb_array_accessor(msg, UPB_SIZE(4, 8), len);
+}
+UPB_INLINE void validate_DoubleRules_clear_not_in(const validate_DoubleRules* msg) {
+  _upb_array_detach(msg, UPB_SIZE(8, 16));
+}
+UPB_INLINE double const* validate_DoubleRules_not_in(const validate_DoubleRules* msg, size_t* len) {
+  return (double const*)_upb_array_accessor(msg, UPB_SIZE(8, 16), len);
+}
+UPB_INLINE bool validate_DoubleRules_has_ignore_empty(const validate_DoubleRules* msg) {
+  return _upb_hasbit(msg, 6);
+}
+UPB_INLINE void validate_DoubleRules_clear_ignore_empty(const validate_DoubleRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool) = 0;
+  _upb_clearhas(msg, 6);
 }
-UPB_INLINE double const* validate_DoubleRules_in(const validate_DoubleRules *msg, size_t *len) { return (double const*)_upb_array_accessor(msg, UPB_SIZE(52, 56), len); }
-UPB_INLINE double const* validate_DoubleRules_not_in(const validate_DoubleRules *msg, size_t *len) { return (double const*)_upb_array_accessor(msg, UPB_SIZE(56, 64), len); }
-UPB_INLINE bool validate_DoubleRules_has_ignore_empty(const validate_DoubleRules *msg) { return _upb_hasbit(msg, 6); }
 UPB_INLINE bool validate_DoubleRules_ignore_empty(const validate_DoubleRules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(48, 48), bool);
+  return *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool);
 }
 
 UPB_INLINE void validate_DoubleRules_set_const(validate_DoubleRules *msg, double value) {
   _upb_sethas(msg, 1);
-  *UPB_PTR_AT(msg, UPB_SIZE(8, 8), double) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(16, 24), double) = value;
 }
 UPB_INLINE void validate_DoubleRules_set_lt(validate_DoubleRules *msg, double value) {
   _upb_sethas(msg, 2);
-  *UPB_PTR_AT(msg, UPB_SIZE(16, 16), double) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(24, 32), double) = value;
 }
 UPB_INLINE void validate_DoubleRules_set_lte(validate_DoubleRules *msg, double value) {
   _upb_sethas(msg, 3);
-  *UPB_PTR_AT(msg, UPB_SIZE(24, 24), double) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(32, 40), double) = value;
 }
 UPB_INLINE void validate_DoubleRules_set_gt(validate_DoubleRules *msg, double value) {
   _upb_sethas(msg, 4);
-  *UPB_PTR_AT(msg, UPB_SIZE(32, 32), double) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(40, 48), double) = value;
 }
 UPB_INLINE void validate_DoubleRules_set_gte(validate_DoubleRules *msg, double value) {
   _upb_sethas(msg, 5);
-  *UPB_PTR_AT(msg, UPB_SIZE(40, 40), double) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(48, 56), double) = value;
 }
-UPB_INLINE double* validate_DoubleRules_mutable_in(validate_DoubleRules *msg, size_t *len) {
-  return (double*)_upb_array_mutable_accessor(msg, UPB_SIZE(52, 56), len);
+UPB_INLINE double* validate_DoubleRules_mutable_in(validate_DoubleRules* msg, size_t* len) {
+  return (double*)_upb_array_mutable_accessor(msg, UPB_SIZE(4, 8), len);
 }
-UPB_INLINE double* validate_DoubleRules_resize_in(validate_DoubleRules *msg, size_t len, upb_Arena *arena) {
-  return (double*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(52, 56), len, 3, arena);
+UPB_INLINE double* validate_DoubleRules_resize_in(validate_DoubleRules* msg, size_t len, upb_Arena* arena) {
+  return (double*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(4, 8), len, 3, arena);
 }
-UPB_INLINE bool validate_DoubleRules_add_in(validate_DoubleRules *msg, double val, upb_Arena *arena) {
-  return _upb_Array_Append_accessor2(msg, UPB_SIZE(52, 56), 3, &val,
-      arena);
+UPB_INLINE bool validate_DoubleRules_add_in(validate_DoubleRules* msg, double val, upb_Arena* arena) {
+  return _upb_Array_Append_accessor2(msg, UPB_SIZE(4, 8), 3, &val, arena);
 }
-UPB_INLINE double* validate_DoubleRules_mutable_not_in(validate_DoubleRules *msg, size_t *len) {
-  return (double*)_upb_array_mutable_accessor(msg, UPB_SIZE(56, 64), len);
+UPB_INLINE double* validate_DoubleRules_mutable_not_in(validate_DoubleRules* msg, size_t* len) {
+  return (double*)_upb_array_mutable_accessor(msg, UPB_SIZE(8, 16), len);
 }
-UPB_INLINE double* validate_DoubleRules_resize_not_in(validate_DoubleRules *msg, size_t len, upb_Arena *arena) {
-  return (double*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(56, 64), len, 3, arena);
+UPB_INLINE double* validate_DoubleRules_resize_not_in(validate_DoubleRules* msg, size_t len, upb_Arena* arena) {
+  return (double*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(8, 16), len, 3, arena);
 }
-UPB_INLINE bool validate_DoubleRules_add_not_in(validate_DoubleRules *msg, double val, upb_Arena *arena) {
-  return _upb_Array_Append_accessor2(msg, UPB_SIZE(56, 64), 3, &val,
-      arena);
+UPB_INLINE bool validate_DoubleRules_add_not_in(validate_DoubleRules* msg, double val, upb_Arena* arena) {
+  return _upb_Array_Append_accessor2(msg, UPB_SIZE(8, 16), 3, &val, arena);
 }
 UPB_INLINE void validate_DoubleRules_set_ignore_empty(validate_DoubleRules *msg, bool value) {
   _upb_sethas(msg, 6);
-  *UPB_PTR_AT(msg, UPB_SIZE(48, 48), bool) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool) = value;
 }
 
 /* validate.Int32Rules */
@@ -714,35 +967,85 @@ 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);
+}
+UPB_INLINE void validate_Int32Rules_clear_const(const validate_Int32Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(4, 4), int32_t) = 0;
+  _upb_clearhas(msg, 1);
 }
-UPB_INLINE bool validate_Int32Rules_has_const(const validate_Int32Rules *msg) { return _upb_hasbit(msg, 1); }
 UPB_INLINE int32_t validate_Int32Rules_const(const validate_Int32Rules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(4, 4), int32_t);
 }
-UPB_INLINE bool validate_Int32Rules_has_lt(const validate_Int32Rules *msg) { return _upb_hasbit(msg, 2); }
+UPB_INLINE bool validate_Int32Rules_has_lt(const validate_Int32Rules* msg) {
+  return _upb_hasbit(msg, 2);
+}
+UPB_INLINE void validate_Int32Rules_clear_lt(const validate_Int32Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(8, 8), int32_t) = 0;
+  _upb_clearhas(msg, 2);
+}
 UPB_INLINE int32_t validate_Int32Rules_lt(const validate_Int32Rules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(8, 8), int32_t);
 }
-UPB_INLINE bool validate_Int32Rules_has_lte(const validate_Int32Rules *msg) { return _upb_hasbit(msg, 3); }
+UPB_INLINE bool validate_Int32Rules_has_lte(const validate_Int32Rules* msg) {
+  return _upb_hasbit(msg, 3);
+}
+UPB_INLINE void validate_Int32Rules_clear_lte(const validate_Int32Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(12, 12), int32_t) = 0;
+  _upb_clearhas(msg, 3);
+}
 UPB_INLINE int32_t validate_Int32Rules_lte(const validate_Int32Rules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(12, 12), int32_t);
 }
-UPB_INLINE bool validate_Int32Rules_has_gt(const validate_Int32Rules *msg) { return _upb_hasbit(msg, 4); }
+UPB_INLINE bool validate_Int32Rules_has_gt(const validate_Int32Rules* msg) {
+  return _upb_hasbit(msg, 4);
+}
+UPB_INLINE void validate_Int32Rules_clear_gt(const validate_Int32Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(16, 16), int32_t) = 0;
+  _upb_clearhas(msg, 4);
+}
 UPB_INLINE int32_t validate_Int32Rules_gt(const validate_Int32Rules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(16, 16), int32_t);
 }
-UPB_INLINE bool validate_Int32Rules_has_gte(const validate_Int32Rules *msg) { return _upb_hasbit(msg, 5); }
+UPB_INLINE bool validate_Int32Rules_has_gte(const validate_Int32Rules* msg) {
+  return _upb_hasbit(msg, 5);
+}
+UPB_INLINE void validate_Int32Rules_clear_gte(const validate_Int32Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(20, 20), int32_t) = 0;
+  _upb_clearhas(msg, 5);
+}
 UPB_INLINE int32_t validate_Int32Rules_gte(const validate_Int32Rules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(20, 20), int32_t);
 }
-UPB_INLINE int32_t const* validate_Int32Rules_in(const validate_Int32Rules *msg, size_t *len) { return (int32_t const*)_upb_array_accessor(msg, UPB_SIZE(28, 32), len); }
-UPB_INLINE int32_t const* validate_Int32Rules_not_in(const validate_Int32Rules *msg, size_t *len) { return (int32_t const*)_upb_array_accessor(msg, UPB_SIZE(32, 40), len); }
-UPB_INLINE bool validate_Int32Rules_has_ignore_empty(const validate_Int32Rules *msg) { return _upb_hasbit(msg, 6); }
+UPB_INLINE void validate_Int32Rules_clear_in(const validate_Int32Rules* msg) {
+  _upb_array_detach(msg, UPB_SIZE(28, 32));
+}
+UPB_INLINE int32_t const* validate_Int32Rules_in(const validate_Int32Rules* msg, size_t* len) {
+  return (int32_t const*)_upb_array_accessor(msg, UPB_SIZE(28, 32), len);
+}
+UPB_INLINE void validate_Int32Rules_clear_not_in(const validate_Int32Rules* msg) {
+  _upb_array_detach(msg, UPB_SIZE(32, 40));
+}
+UPB_INLINE int32_t const* validate_Int32Rules_not_in(const validate_Int32Rules* msg, size_t* len) {
+  return (int32_t const*)_upb_array_accessor(msg, UPB_SIZE(32, 40), len);
+}
+UPB_INLINE bool validate_Int32Rules_has_ignore_empty(const validate_Int32Rules* msg) {
+  return _upb_hasbit(msg, 6);
+}
+UPB_INLINE void validate_Int32Rules_clear_ignore_empty(const validate_Int32Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(24, 24), bool) = 0;
+  _upb_clearhas(msg, 6);
+}
 UPB_INLINE bool validate_Int32Rules_ignore_empty(const validate_Int32Rules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(24, 24), bool);
 }
@@ -767,25 +1070,23 @@ UPB_INLINE void validate_Int32Rules_set_gte(validate_Int32Rules *msg, int32_t va
   _upb_sethas(msg, 5);
   *UPB_PTR_AT(msg, UPB_SIZE(20, 20), int32_t) = value;
 }
-UPB_INLINE int32_t* validate_Int32Rules_mutable_in(validate_Int32Rules *msg, size_t *len) {
+UPB_INLINE int32_t* validate_Int32Rules_mutable_in(validate_Int32Rules* msg, size_t* len) {
   return (int32_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(28, 32), len);
 }
-UPB_INLINE int32_t* validate_Int32Rules_resize_in(validate_Int32Rules *msg, size_t len, upb_Arena *arena) {
+UPB_INLINE int32_t* validate_Int32Rules_resize_in(validate_Int32Rules* msg, size_t len, upb_Arena* arena) {
   return (int32_t*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(28, 32), len, 2, arena);
 }
-UPB_INLINE bool validate_Int32Rules_add_in(validate_Int32Rules *msg, int32_t val, upb_Arena *arena) {
-  return _upb_Array_Append_accessor2(msg, UPB_SIZE(28, 32), 2, &val,
-      arena);
+UPB_INLINE bool validate_Int32Rules_add_in(validate_Int32Rules* msg, int32_t val, upb_Arena* arena) {
+  return _upb_Array_Append_accessor2(msg, UPB_SIZE(28, 32), 2, &val, arena);
 }
-UPB_INLINE int32_t* validate_Int32Rules_mutable_not_in(validate_Int32Rules *msg, size_t *len) {
+UPB_INLINE int32_t* validate_Int32Rules_mutable_not_in(validate_Int32Rules* msg, size_t* len) {
   return (int32_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(32, 40), len);
 }
-UPB_INLINE int32_t* validate_Int32Rules_resize_not_in(validate_Int32Rules *msg, size_t len, upb_Arena *arena) {
+UPB_INLINE int32_t* validate_Int32Rules_resize_not_in(validate_Int32Rules* msg, size_t len, upb_Arena* arena) {
   return (int32_t*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(32, 40), len, 2, arena);
 }
-UPB_INLINE bool validate_Int32Rules_add_not_in(validate_Int32Rules *msg, int32_t val, upb_Arena *arena) {
-  return _upb_Array_Append_accessor2(msg, UPB_SIZE(32, 40), 2, &val,
-      arena);
+UPB_INLINE bool validate_Int32Rules_add_not_in(validate_Int32Rules* msg, int32_t val, upb_Arena* arena) {
+  return _upb_Array_Append_accessor2(msg, UPB_SIZE(32, 40), 2, &val, arena);
 }
 UPB_INLINE void validate_Int32Rules_set_ignore_empty(validate_Int32Rules *msg, bool value) {
   _upb_sethas(msg, 6);
@@ -817,82 +1118,130 @@ 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);
+}
+UPB_INLINE void validate_Int64Rules_clear_const(const validate_Int64Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(16, 24), int64_t) = 0;
+  _upb_clearhas(msg, 1);
 }
-UPB_INLINE bool validate_Int64Rules_has_const(const validate_Int64Rules *msg) { return _upb_hasbit(msg, 1); }
 UPB_INLINE int64_t validate_Int64Rules_const(const validate_Int64Rules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(8, 8), int64_t);
+  return *UPB_PTR_AT(msg, UPB_SIZE(16, 24), int64_t);
+}
+UPB_INLINE bool validate_Int64Rules_has_lt(const validate_Int64Rules* msg) {
+  return _upb_hasbit(msg, 2);
+}
+UPB_INLINE void validate_Int64Rules_clear_lt(const validate_Int64Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(24, 32), int64_t) = 0;
+  _upb_clearhas(msg, 2);
 }
-UPB_INLINE bool validate_Int64Rules_has_lt(const validate_Int64Rules *msg) { return _upb_hasbit(msg, 2); }
 UPB_INLINE int64_t validate_Int64Rules_lt(const validate_Int64Rules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(16, 16), int64_t);
+  return *UPB_PTR_AT(msg, UPB_SIZE(24, 32), int64_t);
+}
+UPB_INLINE bool validate_Int64Rules_has_lte(const validate_Int64Rules* msg) {
+  return _upb_hasbit(msg, 3);
+}
+UPB_INLINE void validate_Int64Rules_clear_lte(const validate_Int64Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(32, 40), int64_t) = 0;
+  _upb_clearhas(msg, 3);
 }
-UPB_INLINE bool validate_Int64Rules_has_lte(const validate_Int64Rules *msg) { return _upb_hasbit(msg, 3); }
 UPB_INLINE int64_t validate_Int64Rules_lte(const validate_Int64Rules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(24, 24), int64_t);
+  return *UPB_PTR_AT(msg, UPB_SIZE(32, 40), int64_t);
+}
+UPB_INLINE bool validate_Int64Rules_has_gt(const validate_Int64Rules* msg) {
+  return _upb_hasbit(msg, 4);
+}
+UPB_INLINE void validate_Int64Rules_clear_gt(const validate_Int64Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(40, 48), int64_t) = 0;
+  _upb_clearhas(msg, 4);
 }
-UPB_INLINE bool validate_Int64Rules_has_gt(const validate_Int64Rules *msg) { return _upb_hasbit(msg, 4); }
 UPB_INLINE int64_t validate_Int64Rules_gt(const validate_Int64Rules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(32, 32), int64_t);
+  return *UPB_PTR_AT(msg, UPB_SIZE(40, 48), int64_t);
+}
+UPB_INLINE bool validate_Int64Rules_has_gte(const validate_Int64Rules* msg) {
+  return _upb_hasbit(msg, 5);
+}
+UPB_INLINE void validate_Int64Rules_clear_gte(const validate_Int64Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(48, 56), int64_t) = 0;
+  _upb_clearhas(msg, 5);
 }
-UPB_INLINE bool validate_Int64Rules_has_gte(const validate_Int64Rules *msg) { return _upb_hasbit(msg, 5); }
 UPB_INLINE int64_t validate_Int64Rules_gte(const validate_Int64Rules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(40, 40), int64_t);
+  return *UPB_PTR_AT(msg, UPB_SIZE(48, 56), int64_t);
+}
+UPB_INLINE void validate_Int64Rules_clear_in(const validate_Int64Rules* msg) {
+  _upb_array_detach(msg, UPB_SIZE(4, 8));
+}
+UPB_INLINE int64_t const* validate_Int64Rules_in(const validate_Int64Rules* msg, size_t* len) {
+  return (int64_t const*)_upb_array_accessor(msg, UPB_SIZE(4, 8), len);
+}
+UPB_INLINE void validate_Int64Rules_clear_not_in(const validate_Int64Rules* msg) {
+  _upb_array_detach(msg, UPB_SIZE(8, 16));
+}
+UPB_INLINE int64_t const* validate_Int64Rules_not_in(const validate_Int64Rules* msg, size_t* len) {
+  return (int64_t const*)_upb_array_accessor(msg, UPB_SIZE(8, 16), len);
+}
+UPB_INLINE bool validate_Int64Rules_has_ignore_empty(const validate_Int64Rules* msg) {
+  return _upb_hasbit(msg, 6);
+}
+UPB_INLINE void validate_Int64Rules_clear_ignore_empty(const validate_Int64Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool) = 0;
+  _upb_clearhas(msg, 6);
 }
-UPB_INLINE int64_t const* validate_Int64Rules_in(const validate_Int64Rules *msg, size_t *len) { return (int64_t const*)_upb_array_accessor(msg, UPB_SIZE(52, 56), len); }
-UPB_INLINE int64_t const* validate_Int64Rules_not_in(const validate_Int64Rules *msg, size_t *len) { return (int64_t const*)_upb_array_accessor(msg, UPB_SIZE(56, 64), len); }
-UPB_INLINE bool validate_Int64Rules_has_ignore_empty(const validate_Int64Rules *msg) { return _upb_hasbit(msg, 6); }
 UPB_INLINE bool validate_Int64Rules_ignore_empty(const validate_Int64Rules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(48, 48), bool);
+  return *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool);
 }
 
 UPB_INLINE void validate_Int64Rules_set_const(validate_Int64Rules *msg, int64_t value) {
   _upb_sethas(msg, 1);
-  *UPB_PTR_AT(msg, UPB_SIZE(8, 8), int64_t) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(16, 24), int64_t) = value;
 }
 UPB_INLINE void validate_Int64Rules_set_lt(validate_Int64Rules *msg, int64_t value) {
   _upb_sethas(msg, 2);
-  *UPB_PTR_AT(msg, UPB_SIZE(16, 16), int64_t) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(24, 32), int64_t) = value;
 }
 UPB_INLINE void validate_Int64Rules_set_lte(validate_Int64Rules *msg, int64_t value) {
   _upb_sethas(msg, 3);
-  *UPB_PTR_AT(msg, UPB_SIZE(24, 24), int64_t) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(32, 40), int64_t) = value;
 }
 UPB_INLINE void validate_Int64Rules_set_gt(validate_Int64Rules *msg, int64_t value) {
   _upb_sethas(msg, 4);
-  *UPB_PTR_AT(msg, UPB_SIZE(32, 32), int64_t) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(40, 48), int64_t) = value;
 }
 UPB_INLINE void validate_Int64Rules_set_gte(validate_Int64Rules *msg, int64_t value) {
   _upb_sethas(msg, 5);
-  *UPB_PTR_AT(msg, UPB_SIZE(40, 40), int64_t) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(48, 56), int64_t) = value;
 }
-UPB_INLINE int64_t* validate_Int64Rules_mutable_in(validate_Int64Rules *msg, size_t *len) {
-  return (int64_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(52, 56), len);
+UPB_INLINE int64_t* validate_Int64Rules_mutable_in(validate_Int64Rules* msg, size_t* len) {
+  return (int64_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(4, 8), len);
 }
-UPB_INLINE int64_t* validate_Int64Rules_resize_in(validate_Int64Rules *msg, size_t len, upb_Arena *arena) {
-  return (int64_t*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(52, 56), len, 3, arena);
+UPB_INLINE int64_t* validate_Int64Rules_resize_in(validate_Int64Rules* msg, size_t len, upb_Arena* arena) {
+  return (int64_t*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(4, 8), len, 3, arena);
 }
-UPB_INLINE bool validate_Int64Rules_add_in(validate_Int64Rules *msg, int64_t val, upb_Arena *arena) {
-  return _upb_Array_Append_accessor2(msg, UPB_SIZE(52, 56), 3, &val,
-      arena);
+UPB_INLINE bool validate_Int64Rules_add_in(validate_Int64Rules* msg, int64_t val, upb_Arena* arena) {
+  return _upb_Array_Append_accessor2(msg, UPB_SIZE(4, 8), 3, &val, arena);
 }
-UPB_INLINE int64_t* validate_Int64Rules_mutable_not_in(validate_Int64Rules *msg, size_t *len) {
-  return (int64_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(56, 64), len);
+UPB_INLINE int64_t* validate_Int64Rules_mutable_not_in(validate_Int64Rules* msg, size_t* len) {
+  return (int64_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(8, 16), len);
 }
-UPB_INLINE int64_t* validate_Int64Rules_resize_not_in(validate_Int64Rules *msg, size_t len, upb_Arena *arena) {
-  return (int64_t*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(56, 64), len, 3, arena);
+UPB_INLINE int64_t* validate_Int64Rules_resize_not_in(validate_Int64Rules* msg, size_t len, upb_Arena* arena) {
+  return (int64_t*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(8, 16), len, 3, arena);
 }
-UPB_INLINE bool validate_Int64Rules_add_not_in(validate_Int64Rules *msg, int64_t val, upb_Arena *arena) {
-  return _upb_Array_Append_accessor2(msg, UPB_SIZE(56, 64), 3, &val,
-      arena);
+UPB_INLINE bool validate_Int64Rules_add_not_in(validate_Int64Rules* msg, int64_t val, upb_Arena* arena) {
+  return _upb_Array_Append_accessor2(msg, UPB_SIZE(8, 16), 3, &val, arena);
 }
 UPB_INLINE void validate_Int64Rules_set_ignore_empty(validate_Int64Rules *msg, bool value) {
   _upb_sethas(msg, 6);
-  *UPB_PTR_AT(msg, UPB_SIZE(48, 48), bool) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool) = value;
 }
 
 /* validate.UInt32Rules */
@@ -920,35 +1269,85 @@ 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);
+}
+UPB_INLINE void validate_UInt32Rules_clear_const(const validate_UInt32Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(4, 4), uint32_t) = 0;
+  _upb_clearhas(msg, 1);
 }
-UPB_INLINE bool validate_UInt32Rules_has_const(const validate_UInt32Rules *msg) { return _upb_hasbit(msg, 1); }
 UPB_INLINE uint32_t validate_UInt32Rules_const(const validate_UInt32Rules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(4, 4), uint32_t);
 }
-UPB_INLINE bool validate_UInt32Rules_has_lt(const validate_UInt32Rules *msg) { return _upb_hasbit(msg, 2); }
+UPB_INLINE bool validate_UInt32Rules_has_lt(const validate_UInt32Rules* msg) {
+  return _upb_hasbit(msg, 2);
+}
+UPB_INLINE void validate_UInt32Rules_clear_lt(const validate_UInt32Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(8, 8), uint32_t) = 0;
+  _upb_clearhas(msg, 2);
+}
 UPB_INLINE uint32_t validate_UInt32Rules_lt(const validate_UInt32Rules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(8, 8), uint32_t);
 }
-UPB_INLINE bool validate_UInt32Rules_has_lte(const validate_UInt32Rules *msg) { return _upb_hasbit(msg, 3); }
+UPB_INLINE bool validate_UInt32Rules_has_lte(const validate_UInt32Rules* msg) {
+  return _upb_hasbit(msg, 3);
+}
+UPB_INLINE void validate_UInt32Rules_clear_lte(const validate_UInt32Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(12, 12), uint32_t) = 0;
+  _upb_clearhas(msg, 3);
+}
 UPB_INLINE uint32_t validate_UInt32Rules_lte(const validate_UInt32Rules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(12, 12), uint32_t);
 }
-UPB_INLINE bool validate_UInt32Rules_has_gt(const validate_UInt32Rules *msg) { return _upb_hasbit(msg, 4); }
+UPB_INLINE bool validate_UInt32Rules_has_gt(const validate_UInt32Rules* msg) {
+  return _upb_hasbit(msg, 4);
+}
+UPB_INLINE void validate_UInt32Rules_clear_gt(const validate_UInt32Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(16, 16), uint32_t) = 0;
+  _upb_clearhas(msg, 4);
+}
 UPB_INLINE uint32_t validate_UInt32Rules_gt(const validate_UInt32Rules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(16, 16), uint32_t);
 }
-UPB_INLINE bool validate_UInt32Rules_has_gte(const validate_UInt32Rules *msg) { return _upb_hasbit(msg, 5); }
+UPB_INLINE bool validate_UInt32Rules_has_gte(const validate_UInt32Rules* msg) {
+  return _upb_hasbit(msg, 5);
+}
+UPB_INLINE void validate_UInt32Rules_clear_gte(const validate_UInt32Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(20, 20), uint32_t) = 0;
+  _upb_clearhas(msg, 5);
+}
 UPB_INLINE uint32_t validate_UInt32Rules_gte(const validate_UInt32Rules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(20, 20), uint32_t);
 }
-UPB_INLINE uint32_t const* validate_UInt32Rules_in(const validate_UInt32Rules *msg, size_t *len) { return (uint32_t const*)_upb_array_accessor(msg, UPB_SIZE(28, 32), len); }
-UPB_INLINE uint32_t const* validate_UInt32Rules_not_in(const validate_UInt32Rules *msg, size_t *len) { return (uint32_t const*)_upb_array_accessor(msg, UPB_SIZE(32, 40), len); }
-UPB_INLINE bool validate_UInt32Rules_has_ignore_empty(const validate_UInt32Rules *msg) { return _upb_hasbit(msg, 6); }
+UPB_INLINE void validate_UInt32Rules_clear_in(const validate_UInt32Rules* msg) {
+  _upb_array_detach(msg, UPB_SIZE(28, 32));
+}
+UPB_INLINE uint32_t const* validate_UInt32Rules_in(const validate_UInt32Rules* msg, size_t* len) {
+  return (uint32_t const*)_upb_array_accessor(msg, UPB_SIZE(28, 32), len);
+}
+UPB_INLINE void validate_UInt32Rules_clear_not_in(const validate_UInt32Rules* msg) {
+  _upb_array_detach(msg, UPB_SIZE(32, 40));
+}
+UPB_INLINE uint32_t const* validate_UInt32Rules_not_in(const validate_UInt32Rules* msg, size_t* len) {
+  return (uint32_t const*)_upb_array_accessor(msg, UPB_SIZE(32, 40), len);
+}
+UPB_INLINE bool validate_UInt32Rules_has_ignore_empty(const validate_UInt32Rules* msg) {
+  return _upb_hasbit(msg, 6);
+}
+UPB_INLINE void validate_UInt32Rules_clear_ignore_empty(const validate_UInt32Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(24, 24), bool) = 0;
+  _upb_clearhas(msg, 6);
+}
 UPB_INLINE bool validate_UInt32Rules_ignore_empty(const validate_UInt32Rules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(24, 24), bool);
 }
@@ -973,25 +1372,23 @@ UPB_INLINE void validate_UInt32Rules_set_gte(validate_UInt32Rules *msg, uint32_t
   _upb_sethas(msg, 5);
   *UPB_PTR_AT(msg, UPB_SIZE(20, 20), uint32_t) = value;
 }
-UPB_INLINE uint32_t* validate_UInt32Rules_mutable_in(validate_UInt32Rules *msg, size_t *len) {
+UPB_INLINE uint32_t* validate_UInt32Rules_mutable_in(validate_UInt32Rules* msg, size_t* len) {
   return (uint32_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(28, 32), len);
 }
-UPB_INLINE uint32_t* validate_UInt32Rules_resize_in(validate_UInt32Rules *msg, size_t len, upb_Arena *arena) {
+UPB_INLINE uint32_t* validate_UInt32Rules_resize_in(validate_UInt32Rules* msg, size_t len, upb_Arena* arena) {
   return (uint32_t*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(28, 32), len, 2, arena);
 }
-UPB_INLINE bool validate_UInt32Rules_add_in(validate_UInt32Rules *msg, uint32_t val, upb_Arena *arena) {
-  return _upb_Array_Append_accessor2(msg, UPB_SIZE(28, 32), 2, &val,
-      arena);
+UPB_INLINE bool validate_UInt32Rules_add_in(validate_UInt32Rules* msg, uint32_t val, upb_Arena* arena) {
+  return _upb_Array_Append_accessor2(msg, UPB_SIZE(28, 32), 2, &val, arena);
 }
-UPB_INLINE uint32_t* validate_UInt32Rules_mutable_not_in(validate_UInt32Rules *msg, size_t *len) {
+UPB_INLINE uint32_t* validate_UInt32Rules_mutable_not_in(validate_UInt32Rules* msg, size_t* len) {
   return (uint32_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(32, 40), len);
 }
-UPB_INLINE uint32_t* validate_UInt32Rules_resize_not_in(validate_UInt32Rules *msg, size_t len, upb_Arena *arena) {
+UPB_INLINE uint32_t* validate_UInt32Rules_resize_not_in(validate_UInt32Rules* msg, size_t len, upb_Arena* arena) {
   return (uint32_t*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(32, 40), len, 2, arena);
 }
-UPB_INLINE bool validate_UInt32Rules_add_not_in(validate_UInt32Rules *msg, uint32_t val, upb_Arena *arena) {
-  return _upb_Array_Append_accessor2(msg, UPB_SIZE(32, 40), 2, &val,
-      arena);
+UPB_INLINE bool validate_UInt32Rules_add_not_in(validate_UInt32Rules* msg, uint32_t val, upb_Arena* arena) {
+  return _upb_Array_Append_accessor2(msg, UPB_SIZE(32, 40), 2, &val, arena);
 }
 UPB_INLINE void validate_UInt32Rules_set_ignore_empty(validate_UInt32Rules *msg, bool value) {
   _upb_sethas(msg, 6);
@@ -1023,82 +1420,130 @@ 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);
+}
+UPB_INLINE void validate_UInt64Rules_clear_const(const validate_UInt64Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(16, 24), uint64_t) = 0;
+  _upb_clearhas(msg, 1);
 }
-UPB_INLINE bool validate_UInt64Rules_has_const(const validate_UInt64Rules *msg) { return _upb_hasbit(msg, 1); }
 UPB_INLINE uint64_t validate_UInt64Rules_const(const validate_UInt64Rules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(8, 8), uint64_t);
+  return *UPB_PTR_AT(msg, UPB_SIZE(16, 24), uint64_t);
+}
+UPB_INLINE bool validate_UInt64Rules_has_lt(const validate_UInt64Rules* msg) {
+  return _upb_hasbit(msg, 2);
+}
+UPB_INLINE void validate_UInt64Rules_clear_lt(const validate_UInt64Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(24, 32), uint64_t) = 0;
+  _upb_clearhas(msg, 2);
 }
-UPB_INLINE bool validate_UInt64Rules_has_lt(const validate_UInt64Rules *msg) { return _upb_hasbit(msg, 2); }
 UPB_INLINE uint64_t validate_UInt64Rules_lt(const validate_UInt64Rules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(16, 16), uint64_t);
+  return *UPB_PTR_AT(msg, UPB_SIZE(24, 32), uint64_t);
+}
+UPB_INLINE bool validate_UInt64Rules_has_lte(const validate_UInt64Rules* msg) {
+  return _upb_hasbit(msg, 3);
+}
+UPB_INLINE void validate_UInt64Rules_clear_lte(const validate_UInt64Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(32, 40), uint64_t) = 0;
+  _upb_clearhas(msg, 3);
 }
-UPB_INLINE bool validate_UInt64Rules_has_lte(const validate_UInt64Rules *msg) { return _upb_hasbit(msg, 3); }
 UPB_INLINE uint64_t validate_UInt64Rules_lte(const validate_UInt64Rules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(24, 24), uint64_t);
+  return *UPB_PTR_AT(msg, UPB_SIZE(32, 40), uint64_t);
+}
+UPB_INLINE bool validate_UInt64Rules_has_gt(const validate_UInt64Rules* msg) {
+  return _upb_hasbit(msg, 4);
+}
+UPB_INLINE void validate_UInt64Rules_clear_gt(const validate_UInt64Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(40, 48), uint64_t) = 0;
+  _upb_clearhas(msg, 4);
 }
-UPB_INLINE bool validate_UInt64Rules_has_gt(const validate_UInt64Rules *msg) { return _upb_hasbit(msg, 4); }
 UPB_INLINE uint64_t validate_UInt64Rules_gt(const validate_UInt64Rules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(32, 32), uint64_t);
+  return *UPB_PTR_AT(msg, UPB_SIZE(40, 48), uint64_t);
+}
+UPB_INLINE bool validate_UInt64Rules_has_gte(const validate_UInt64Rules* msg) {
+  return _upb_hasbit(msg, 5);
+}
+UPB_INLINE void validate_UInt64Rules_clear_gte(const validate_UInt64Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(48, 56), uint64_t) = 0;
+  _upb_clearhas(msg, 5);
 }
-UPB_INLINE bool validate_UInt64Rules_has_gte(const validate_UInt64Rules *msg) { return _upb_hasbit(msg, 5); }
 UPB_INLINE uint64_t validate_UInt64Rules_gte(const validate_UInt64Rules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(40, 40), uint64_t);
+  return *UPB_PTR_AT(msg, UPB_SIZE(48, 56), uint64_t);
+}
+UPB_INLINE void validate_UInt64Rules_clear_in(const validate_UInt64Rules* msg) {
+  _upb_array_detach(msg, UPB_SIZE(4, 8));
+}
+UPB_INLINE uint64_t const* validate_UInt64Rules_in(const validate_UInt64Rules* msg, size_t* len) {
+  return (uint64_t const*)_upb_array_accessor(msg, UPB_SIZE(4, 8), len);
+}
+UPB_INLINE void validate_UInt64Rules_clear_not_in(const validate_UInt64Rules* msg) {
+  _upb_array_detach(msg, UPB_SIZE(8, 16));
+}
+UPB_INLINE uint64_t const* validate_UInt64Rules_not_in(const validate_UInt64Rules* msg, size_t* len) {
+  return (uint64_t const*)_upb_array_accessor(msg, UPB_SIZE(8, 16), len);
+}
+UPB_INLINE bool validate_UInt64Rules_has_ignore_empty(const validate_UInt64Rules* msg) {
+  return _upb_hasbit(msg, 6);
+}
+UPB_INLINE void validate_UInt64Rules_clear_ignore_empty(const validate_UInt64Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool) = 0;
+  _upb_clearhas(msg, 6);
 }
-UPB_INLINE uint64_t const* validate_UInt64Rules_in(const validate_UInt64Rules *msg, size_t *len) { return (uint64_t const*)_upb_array_accessor(msg, UPB_SIZE(52, 56), len); }
-UPB_INLINE uint64_t const* validate_UInt64Rules_not_in(const validate_UInt64Rules *msg, size_t *len) { return (uint64_t const*)_upb_array_accessor(msg, UPB_SIZE(56, 64), len); }
-UPB_INLINE bool validate_UInt64Rules_has_ignore_empty(const validate_UInt64Rules *msg) { return _upb_hasbit(msg, 6); }
 UPB_INLINE bool validate_UInt64Rules_ignore_empty(const validate_UInt64Rules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(48, 48), bool);
+  return *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool);
 }
 
 UPB_INLINE void validate_UInt64Rules_set_const(validate_UInt64Rules *msg, uint64_t value) {
   _upb_sethas(msg, 1);
-  *UPB_PTR_AT(msg, UPB_SIZE(8, 8), uint64_t) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(16, 24), uint64_t) = value;
 }
 UPB_INLINE void validate_UInt64Rules_set_lt(validate_UInt64Rules *msg, uint64_t value) {
   _upb_sethas(msg, 2);
-  *UPB_PTR_AT(msg, UPB_SIZE(16, 16), uint64_t) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(24, 32), uint64_t) = value;
 }
 UPB_INLINE void validate_UInt64Rules_set_lte(validate_UInt64Rules *msg, uint64_t value) {
   _upb_sethas(msg, 3);
-  *UPB_PTR_AT(msg, UPB_SIZE(24, 24), uint64_t) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(32, 40), uint64_t) = value;
 }
 UPB_INLINE void validate_UInt64Rules_set_gt(validate_UInt64Rules *msg, uint64_t value) {
   _upb_sethas(msg, 4);
-  *UPB_PTR_AT(msg, UPB_SIZE(32, 32), uint64_t) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(40, 48), uint64_t) = value;
 }
 UPB_INLINE void validate_UInt64Rules_set_gte(validate_UInt64Rules *msg, uint64_t value) {
   _upb_sethas(msg, 5);
-  *UPB_PTR_AT(msg, UPB_SIZE(40, 40), uint64_t) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(48, 56), uint64_t) = value;
 }
-UPB_INLINE uint64_t* validate_UInt64Rules_mutable_in(validate_UInt64Rules *msg, size_t *len) {
-  return (uint64_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(52, 56), len);
+UPB_INLINE uint64_t* validate_UInt64Rules_mutable_in(validate_UInt64Rules* msg, size_t* len) {
+  return (uint64_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(4, 8), len);
 }
-UPB_INLINE uint64_t* validate_UInt64Rules_resize_in(validate_UInt64Rules *msg, size_t len, upb_Arena *arena) {
-  return (uint64_t*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(52, 56), len, 3, arena);
+UPB_INLINE uint64_t* validate_UInt64Rules_resize_in(validate_UInt64Rules* msg, size_t len, upb_Arena* arena) {
+  return (uint64_t*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(4, 8), len, 3, arena);
 }
-UPB_INLINE bool validate_UInt64Rules_add_in(validate_UInt64Rules *msg, uint64_t val, upb_Arena *arena) {
-  return _upb_Array_Append_accessor2(msg, UPB_SIZE(52, 56), 3, &val,
-      arena);
+UPB_INLINE bool validate_UInt64Rules_add_in(validate_UInt64Rules* msg, uint64_t val, upb_Arena* arena) {
+  return _upb_Array_Append_accessor2(msg, UPB_SIZE(4, 8), 3, &val, arena);
 }
-UPB_INLINE uint64_t* validate_UInt64Rules_mutable_not_in(validate_UInt64Rules *msg, size_t *len) {
-  return (uint64_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(56, 64), len);
+UPB_INLINE uint64_t* validate_UInt64Rules_mutable_not_in(validate_UInt64Rules* msg, size_t* len) {
+  return (uint64_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(8, 16), len);
 }
-UPB_INLINE uint64_t* validate_UInt64Rules_resize_not_in(validate_UInt64Rules *msg, size_t len, upb_Arena *arena) {
-  return (uint64_t*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(56, 64), len, 3, arena);
+UPB_INLINE uint64_t* validate_UInt64Rules_resize_not_in(validate_UInt64Rules* msg, size_t len, upb_Arena* arena) {
+  return (uint64_t*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(8, 16), len, 3, arena);
 }
-UPB_INLINE bool validate_UInt64Rules_add_not_in(validate_UInt64Rules *msg, uint64_t val, upb_Arena *arena) {
-  return _upb_Array_Append_accessor2(msg, UPB_SIZE(56, 64), 3, &val,
-      arena);
+UPB_INLINE bool validate_UInt64Rules_add_not_in(validate_UInt64Rules* msg, uint64_t val, upb_Arena* arena) {
+  return _upb_Array_Append_accessor2(msg, UPB_SIZE(8, 16), 3, &val, arena);
 }
 UPB_INLINE void validate_UInt64Rules_set_ignore_empty(validate_UInt64Rules *msg, bool value) {
   _upb_sethas(msg, 6);
-  *UPB_PTR_AT(msg, UPB_SIZE(48, 48), bool) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool) = value;
 }
 
 /* validate.SInt32Rules */
@@ -1126,35 +1571,85 @@ 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);
+}
+UPB_INLINE void validate_SInt32Rules_clear_const(const validate_SInt32Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(4, 4), int32_t) = 0;
+  _upb_clearhas(msg, 1);
 }
-UPB_INLINE bool validate_SInt32Rules_has_const(const validate_SInt32Rules *msg) { return _upb_hasbit(msg, 1); }
 UPB_INLINE int32_t validate_SInt32Rules_const(const validate_SInt32Rules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(4, 4), int32_t);
 }
-UPB_INLINE bool validate_SInt32Rules_has_lt(const validate_SInt32Rules *msg) { return _upb_hasbit(msg, 2); }
+UPB_INLINE bool validate_SInt32Rules_has_lt(const validate_SInt32Rules* msg) {
+  return _upb_hasbit(msg, 2);
+}
+UPB_INLINE void validate_SInt32Rules_clear_lt(const validate_SInt32Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(8, 8), int32_t) = 0;
+  _upb_clearhas(msg, 2);
+}
 UPB_INLINE int32_t validate_SInt32Rules_lt(const validate_SInt32Rules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(8, 8), int32_t);
 }
-UPB_INLINE bool validate_SInt32Rules_has_lte(const validate_SInt32Rules *msg) { return _upb_hasbit(msg, 3); }
+UPB_INLINE bool validate_SInt32Rules_has_lte(const validate_SInt32Rules* msg) {
+  return _upb_hasbit(msg, 3);
+}
+UPB_INLINE void validate_SInt32Rules_clear_lte(const validate_SInt32Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(12, 12), int32_t) = 0;
+  _upb_clearhas(msg, 3);
+}
 UPB_INLINE int32_t validate_SInt32Rules_lte(const validate_SInt32Rules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(12, 12), int32_t);
 }
-UPB_INLINE bool validate_SInt32Rules_has_gt(const validate_SInt32Rules *msg) { return _upb_hasbit(msg, 4); }
+UPB_INLINE bool validate_SInt32Rules_has_gt(const validate_SInt32Rules* msg) {
+  return _upb_hasbit(msg, 4);
+}
+UPB_INLINE void validate_SInt32Rules_clear_gt(const validate_SInt32Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(16, 16), int32_t) = 0;
+  _upb_clearhas(msg, 4);
+}
 UPB_INLINE int32_t validate_SInt32Rules_gt(const validate_SInt32Rules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(16, 16), int32_t);
 }
-UPB_INLINE bool validate_SInt32Rules_has_gte(const validate_SInt32Rules *msg) { return _upb_hasbit(msg, 5); }
+UPB_INLINE bool validate_SInt32Rules_has_gte(const validate_SInt32Rules* msg) {
+  return _upb_hasbit(msg, 5);
+}
+UPB_INLINE void validate_SInt32Rules_clear_gte(const validate_SInt32Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(20, 20), int32_t) = 0;
+  _upb_clearhas(msg, 5);
+}
 UPB_INLINE int32_t validate_SInt32Rules_gte(const validate_SInt32Rules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(20, 20), int32_t);
 }
-UPB_INLINE int32_t const* validate_SInt32Rules_in(const validate_SInt32Rules *msg, size_t *len) { return (int32_t const*)_upb_array_accessor(msg, UPB_SIZE(28, 32), len); }
-UPB_INLINE int32_t const* validate_SInt32Rules_not_in(const validate_SInt32Rules *msg, size_t *len) { return (int32_t const*)_upb_array_accessor(msg, UPB_SIZE(32, 40), len); }
-UPB_INLINE bool validate_SInt32Rules_has_ignore_empty(const validate_SInt32Rules *msg) { return _upb_hasbit(msg, 6); }
+UPB_INLINE void validate_SInt32Rules_clear_in(const validate_SInt32Rules* msg) {
+  _upb_array_detach(msg, UPB_SIZE(28, 32));
+}
+UPB_INLINE int32_t const* validate_SInt32Rules_in(const validate_SInt32Rules* msg, size_t* len) {
+  return (int32_t const*)_upb_array_accessor(msg, UPB_SIZE(28, 32), len);
+}
+UPB_INLINE void validate_SInt32Rules_clear_not_in(const validate_SInt32Rules* msg) {
+  _upb_array_detach(msg, UPB_SIZE(32, 40));
+}
+UPB_INLINE int32_t const* validate_SInt32Rules_not_in(const validate_SInt32Rules* msg, size_t* len) {
+  return (int32_t const*)_upb_array_accessor(msg, UPB_SIZE(32, 40), len);
+}
+UPB_INLINE bool validate_SInt32Rules_has_ignore_empty(const validate_SInt32Rules* msg) {
+  return _upb_hasbit(msg, 6);
+}
+UPB_INLINE void validate_SInt32Rules_clear_ignore_empty(const validate_SInt32Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(24, 24), bool) = 0;
+  _upb_clearhas(msg, 6);
+}
 UPB_INLINE bool validate_SInt32Rules_ignore_empty(const validate_SInt32Rules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(24, 24), bool);
 }
@@ -1179,25 +1674,23 @@ UPB_INLINE void validate_SInt32Rules_set_gte(validate_SInt32Rules *msg, int32_t
   _upb_sethas(msg, 5);
   *UPB_PTR_AT(msg, UPB_SIZE(20, 20), int32_t) = value;
 }
-UPB_INLINE int32_t* validate_SInt32Rules_mutable_in(validate_SInt32Rules *msg, size_t *len) {
+UPB_INLINE int32_t* validate_SInt32Rules_mutable_in(validate_SInt32Rules* msg, size_t* len) {
   return (int32_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(28, 32), len);
 }
-UPB_INLINE int32_t* validate_SInt32Rules_resize_in(validate_SInt32Rules *msg, size_t len, upb_Arena *arena) {
+UPB_INLINE int32_t* validate_SInt32Rules_resize_in(validate_SInt32Rules* msg, size_t len, upb_Arena* arena) {
   return (int32_t*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(28, 32), len, 2, arena);
 }
-UPB_INLINE bool validate_SInt32Rules_add_in(validate_SInt32Rules *msg, int32_t val, upb_Arena *arena) {
-  return _upb_Array_Append_accessor2(msg, UPB_SIZE(28, 32), 2, &val,
-      arena);
+UPB_INLINE bool validate_SInt32Rules_add_in(validate_SInt32Rules* msg, int32_t val, upb_Arena* arena) {
+  return _upb_Array_Append_accessor2(msg, UPB_SIZE(28, 32), 2, &val, arena);
 }
-UPB_INLINE int32_t* validate_SInt32Rules_mutable_not_in(validate_SInt32Rules *msg, size_t *len) {
+UPB_INLINE int32_t* validate_SInt32Rules_mutable_not_in(validate_SInt32Rules* msg, size_t* len) {
   return (int32_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(32, 40), len);
 }
-UPB_INLINE int32_t* validate_SInt32Rules_resize_not_in(validate_SInt32Rules *msg, size_t len, upb_Arena *arena) {
+UPB_INLINE int32_t* validate_SInt32Rules_resize_not_in(validate_SInt32Rules* msg, size_t len, upb_Arena* arena) {
   return (int32_t*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(32, 40), len, 2, arena);
 }
-UPB_INLINE bool validate_SInt32Rules_add_not_in(validate_SInt32Rules *msg, int32_t val, upb_Arena *arena) {
-  return _upb_Array_Append_accessor2(msg, UPB_SIZE(32, 40), 2, &val,
-      arena);
+UPB_INLINE bool validate_SInt32Rules_add_not_in(validate_SInt32Rules* msg, int32_t val, upb_Arena* arena) {
+  return _upb_Array_Append_accessor2(msg, UPB_SIZE(32, 40), 2, &val, arena);
 }
 UPB_INLINE void validate_SInt32Rules_set_ignore_empty(validate_SInt32Rules *msg, bool value) {
   _upb_sethas(msg, 6);
@@ -1229,82 +1722,130 @@ 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);
+}
+UPB_INLINE void validate_SInt64Rules_clear_const(const validate_SInt64Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(16, 24), int64_t) = 0;
+  _upb_clearhas(msg, 1);
 }
-UPB_INLINE bool validate_SInt64Rules_has_const(const validate_SInt64Rules *msg) { return _upb_hasbit(msg, 1); }
 UPB_INLINE int64_t validate_SInt64Rules_const(const validate_SInt64Rules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(8, 8), int64_t);
+  return *UPB_PTR_AT(msg, UPB_SIZE(16, 24), int64_t);
+}
+UPB_INLINE bool validate_SInt64Rules_has_lt(const validate_SInt64Rules* msg) {
+  return _upb_hasbit(msg, 2);
+}
+UPB_INLINE void validate_SInt64Rules_clear_lt(const validate_SInt64Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(24, 32), int64_t) = 0;
+  _upb_clearhas(msg, 2);
 }
-UPB_INLINE bool validate_SInt64Rules_has_lt(const validate_SInt64Rules *msg) { return _upb_hasbit(msg, 2); }
 UPB_INLINE int64_t validate_SInt64Rules_lt(const validate_SInt64Rules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(16, 16), int64_t);
+  return *UPB_PTR_AT(msg, UPB_SIZE(24, 32), int64_t);
+}
+UPB_INLINE bool validate_SInt64Rules_has_lte(const validate_SInt64Rules* msg) {
+  return _upb_hasbit(msg, 3);
+}
+UPB_INLINE void validate_SInt64Rules_clear_lte(const validate_SInt64Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(32, 40), int64_t) = 0;
+  _upb_clearhas(msg, 3);
 }
-UPB_INLINE bool validate_SInt64Rules_has_lte(const validate_SInt64Rules *msg) { return _upb_hasbit(msg, 3); }
 UPB_INLINE int64_t validate_SInt64Rules_lte(const validate_SInt64Rules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(24, 24), int64_t);
+  return *UPB_PTR_AT(msg, UPB_SIZE(32, 40), int64_t);
+}
+UPB_INLINE bool validate_SInt64Rules_has_gt(const validate_SInt64Rules* msg) {
+  return _upb_hasbit(msg, 4);
+}
+UPB_INLINE void validate_SInt64Rules_clear_gt(const validate_SInt64Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(40, 48), int64_t) = 0;
+  _upb_clearhas(msg, 4);
 }
-UPB_INLINE bool validate_SInt64Rules_has_gt(const validate_SInt64Rules *msg) { return _upb_hasbit(msg, 4); }
 UPB_INLINE int64_t validate_SInt64Rules_gt(const validate_SInt64Rules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(32, 32), int64_t);
+  return *UPB_PTR_AT(msg, UPB_SIZE(40, 48), int64_t);
+}
+UPB_INLINE bool validate_SInt64Rules_has_gte(const validate_SInt64Rules* msg) {
+  return _upb_hasbit(msg, 5);
+}
+UPB_INLINE void validate_SInt64Rules_clear_gte(const validate_SInt64Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(48, 56), int64_t) = 0;
+  _upb_clearhas(msg, 5);
 }
-UPB_INLINE bool validate_SInt64Rules_has_gte(const validate_SInt64Rules *msg) { return _upb_hasbit(msg, 5); }
 UPB_INLINE int64_t validate_SInt64Rules_gte(const validate_SInt64Rules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(40, 40), int64_t);
+  return *UPB_PTR_AT(msg, UPB_SIZE(48, 56), int64_t);
+}
+UPB_INLINE void validate_SInt64Rules_clear_in(const validate_SInt64Rules* msg) {
+  _upb_array_detach(msg, UPB_SIZE(4, 8));
+}
+UPB_INLINE int64_t const* validate_SInt64Rules_in(const validate_SInt64Rules* msg, size_t* len) {
+  return (int64_t const*)_upb_array_accessor(msg, UPB_SIZE(4, 8), len);
+}
+UPB_INLINE void validate_SInt64Rules_clear_not_in(const validate_SInt64Rules* msg) {
+  _upb_array_detach(msg, UPB_SIZE(8, 16));
+}
+UPB_INLINE int64_t const* validate_SInt64Rules_not_in(const validate_SInt64Rules* msg, size_t* len) {
+  return (int64_t const*)_upb_array_accessor(msg, UPB_SIZE(8, 16), len);
+}
+UPB_INLINE bool validate_SInt64Rules_has_ignore_empty(const validate_SInt64Rules* msg) {
+  return _upb_hasbit(msg, 6);
+}
+UPB_INLINE void validate_SInt64Rules_clear_ignore_empty(const validate_SInt64Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool) = 0;
+  _upb_clearhas(msg, 6);
 }
-UPB_INLINE int64_t const* validate_SInt64Rules_in(const validate_SInt64Rules *msg, size_t *len) { return (int64_t const*)_upb_array_accessor(msg, UPB_SIZE(52, 56), len); }
-UPB_INLINE int64_t const* validate_SInt64Rules_not_in(const validate_SInt64Rules *msg, size_t *len) { return (int64_t const*)_upb_array_accessor(msg, UPB_SIZE(56, 64), len); }
-UPB_INLINE bool validate_SInt64Rules_has_ignore_empty(const validate_SInt64Rules *msg) { return _upb_hasbit(msg, 6); }
 UPB_INLINE bool validate_SInt64Rules_ignore_empty(const validate_SInt64Rules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(48, 48), bool);
+  return *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool);
 }
 
 UPB_INLINE void validate_SInt64Rules_set_const(validate_SInt64Rules *msg, int64_t value) {
   _upb_sethas(msg, 1);
-  *UPB_PTR_AT(msg, UPB_SIZE(8, 8), int64_t) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(16, 24), int64_t) = value;
 }
 UPB_INLINE void validate_SInt64Rules_set_lt(validate_SInt64Rules *msg, int64_t value) {
   _upb_sethas(msg, 2);
-  *UPB_PTR_AT(msg, UPB_SIZE(16, 16), int64_t) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(24, 32), int64_t) = value;
 }
 UPB_INLINE void validate_SInt64Rules_set_lte(validate_SInt64Rules *msg, int64_t value) {
   _upb_sethas(msg, 3);
-  *UPB_PTR_AT(msg, UPB_SIZE(24, 24), int64_t) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(32, 40), int64_t) = value;
 }
 UPB_INLINE void validate_SInt64Rules_set_gt(validate_SInt64Rules *msg, int64_t value) {
   _upb_sethas(msg, 4);
-  *UPB_PTR_AT(msg, UPB_SIZE(32, 32), int64_t) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(40, 48), int64_t) = value;
 }
 UPB_INLINE void validate_SInt64Rules_set_gte(validate_SInt64Rules *msg, int64_t value) {
   _upb_sethas(msg, 5);
-  *UPB_PTR_AT(msg, UPB_SIZE(40, 40), int64_t) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(48, 56), int64_t) = value;
 }
-UPB_INLINE int64_t* validate_SInt64Rules_mutable_in(validate_SInt64Rules *msg, size_t *len) {
-  return (int64_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(52, 56), len);
+UPB_INLINE int64_t* validate_SInt64Rules_mutable_in(validate_SInt64Rules* msg, size_t* len) {
+  return (int64_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(4, 8), len);
 }
-UPB_INLINE int64_t* validate_SInt64Rules_resize_in(validate_SInt64Rules *msg, size_t len, upb_Arena *arena) {
-  return (int64_t*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(52, 56), len, 3, arena);
+UPB_INLINE int64_t* validate_SInt64Rules_resize_in(validate_SInt64Rules* msg, size_t len, upb_Arena* arena) {
+  return (int64_t*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(4, 8), len, 3, arena);
 }
-UPB_INLINE bool validate_SInt64Rules_add_in(validate_SInt64Rules *msg, int64_t val, upb_Arena *arena) {
-  return _upb_Array_Append_accessor2(msg, UPB_SIZE(52, 56), 3, &val,
-      arena);
+UPB_INLINE bool validate_SInt64Rules_add_in(validate_SInt64Rules* msg, int64_t val, upb_Arena* arena) {
+  return _upb_Array_Append_accessor2(msg, UPB_SIZE(4, 8), 3, &val, arena);
 }
-UPB_INLINE int64_t* validate_SInt64Rules_mutable_not_in(validate_SInt64Rules *msg, size_t *len) {
-  return (int64_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(56, 64), len);
+UPB_INLINE int64_t* validate_SInt64Rules_mutable_not_in(validate_SInt64Rules* msg, size_t* len) {
+  return (int64_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(8, 16), len);
 }
-UPB_INLINE int64_t* validate_SInt64Rules_resize_not_in(validate_SInt64Rules *msg, size_t len, upb_Arena *arena) {
-  return (int64_t*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(56, 64), len, 3, arena);
+UPB_INLINE int64_t* validate_SInt64Rules_resize_not_in(validate_SInt64Rules* msg, size_t len, upb_Arena* arena) {
+  return (int64_t*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(8, 16), len, 3, arena);
 }
-UPB_INLINE bool validate_SInt64Rules_add_not_in(validate_SInt64Rules *msg, int64_t val, upb_Arena *arena) {
-  return _upb_Array_Append_accessor2(msg, UPB_SIZE(56, 64), 3, &val,
-      arena);
+UPB_INLINE bool validate_SInt64Rules_add_not_in(validate_SInt64Rules* msg, int64_t val, upb_Arena* arena) {
+  return _upb_Array_Append_accessor2(msg, UPB_SIZE(8, 16), 3, &val, arena);
 }
 UPB_INLINE void validate_SInt64Rules_set_ignore_empty(validate_SInt64Rules *msg, bool value) {
   _upb_sethas(msg, 6);
-  *UPB_PTR_AT(msg, UPB_SIZE(48, 48), bool) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool) = value;
 }
 
 /* validate.Fixed32Rules */
@@ -1332,35 +1873,85 @@ 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);
+}
+UPB_INLINE void validate_Fixed32Rules_clear_const(const validate_Fixed32Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(4, 4), uint32_t) = 0;
+  _upb_clearhas(msg, 1);
 }
-UPB_INLINE bool validate_Fixed32Rules_has_const(const validate_Fixed32Rules *msg) { return _upb_hasbit(msg, 1); }
 UPB_INLINE uint32_t validate_Fixed32Rules_const(const validate_Fixed32Rules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(4, 4), uint32_t);
 }
-UPB_INLINE bool validate_Fixed32Rules_has_lt(const validate_Fixed32Rules *msg) { return _upb_hasbit(msg, 2); }
+UPB_INLINE bool validate_Fixed32Rules_has_lt(const validate_Fixed32Rules* msg) {
+  return _upb_hasbit(msg, 2);
+}
+UPB_INLINE void validate_Fixed32Rules_clear_lt(const validate_Fixed32Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(8, 8), uint32_t) = 0;
+  _upb_clearhas(msg, 2);
+}
 UPB_INLINE uint32_t validate_Fixed32Rules_lt(const validate_Fixed32Rules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(8, 8), uint32_t);
 }
-UPB_INLINE bool validate_Fixed32Rules_has_lte(const validate_Fixed32Rules *msg) { return _upb_hasbit(msg, 3); }
+UPB_INLINE bool validate_Fixed32Rules_has_lte(const validate_Fixed32Rules* msg) {
+  return _upb_hasbit(msg, 3);
+}
+UPB_INLINE void validate_Fixed32Rules_clear_lte(const validate_Fixed32Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(12, 12), uint32_t) = 0;
+  _upb_clearhas(msg, 3);
+}
 UPB_INLINE uint32_t validate_Fixed32Rules_lte(const validate_Fixed32Rules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(12, 12), uint32_t);
 }
-UPB_INLINE bool validate_Fixed32Rules_has_gt(const validate_Fixed32Rules *msg) { return _upb_hasbit(msg, 4); }
+UPB_INLINE bool validate_Fixed32Rules_has_gt(const validate_Fixed32Rules* msg) {
+  return _upb_hasbit(msg, 4);
+}
+UPB_INLINE void validate_Fixed32Rules_clear_gt(const validate_Fixed32Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(16, 16), uint32_t) = 0;
+  _upb_clearhas(msg, 4);
+}
 UPB_INLINE uint32_t validate_Fixed32Rules_gt(const validate_Fixed32Rules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(16, 16), uint32_t);
 }
-UPB_INLINE bool validate_Fixed32Rules_has_gte(const validate_Fixed32Rules *msg) { return _upb_hasbit(msg, 5); }
+UPB_INLINE bool validate_Fixed32Rules_has_gte(const validate_Fixed32Rules* msg) {
+  return _upb_hasbit(msg, 5);
+}
+UPB_INLINE void validate_Fixed32Rules_clear_gte(const validate_Fixed32Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(20, 20), uint32_t) = 0;
+  _upb_clearhas(msg, 5);
+}
 UPB_INLINE uint32_t validate_Fixed32Rules_gte(const validate_Fixed32Rules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(20, 20), uint32_t);
 }
-UPB_INLINE uint32_t const* validate_Fixed32Rules_in(const validate_Fixed32Rules *msg, size_t *len) { return (uint32_t const*)_upb_array_accessor(msg, UPB_SIZE(28, 32), len); }
-UPB_INLINE uint32_t const* validate_Fixed32Rules_not_in(const validate_Fixed32Rules *msg, size_t *len) { return (uint32_t const*)_upb_array_accessor(msg, UPB_SIZE(32, 40), len); }
-UPB_INLINE bool validate_Fixed32Rules_has_ignore_empty(const validate_Fixed32Rules *msg) { return _upb_hasbit(msg, 6); }
+UPB_INLINE void validate_Fixed32Rules_clear_in(const validate_Fixed32Rules* msg) {
+  _upb_array_detach(msg, UPB_SIZE(28, 32));
+}
+UPB_INLINE uint32_t const* validate_Fixed32Rules_in(const validate_Fixed32Rules* msg, size_t* len) {
+  return (uint32_t const*)_upb_array_accessor(msg, UPB_SIZE(28, 32), len);
+}
+UPB_INLINE void validate_Fixed32Rules_clear_not_in(const validate_Fixed32Rules* msg) {
+  _upb_array_detach(msg, UPB_SIZE(32, 40));
+}
+UPB_INLINE uint32_t const* validate_Fixed32Rules_not_in(const validate_Fixed32Rules* msg, size_t* len) {
+  return (uint32_t const*)_upb_array_accessor(msg, UPB_SIZE(32, 40), len);
+}
+UPB_INLINE bool validate_Fixed32Rules_has_ignore_empty(const validate_Fixed32Rules* msg) {
+  return _upb_hasbit(msg, 6);
+}
+UPB_INLINE void validate_Fixed32Rules_clear_ignore_empty(const validate_Fixed32Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(24, 24), bool) = 0;
+  _upb_clearhas(msg, 6);
+}
 UPB_INLINE bool validate_Fixed32Rules_ignore_empty(const validate_Fixed32Rules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(24, 24), bool);
 }
@@ -1385,25 +1976,23 @@ UPB_INLINE void validate_Fixed32Rules_set_gte(validate_Fixed32Rules *msg, uint32
   _upb_sethas(msg, 5);
   *UPB_PTR_AT(msg, UPB_SIZE(20, 20), uint32_t) = value;
 }
-UPB_INLINE uint32_t* validate_Fixed32Rules_mutable_in(validate_Fixed32Rules *msg, size_t *len) {
+UPB_INLINE uint32_t* validate_Fixed32Rules_mutable_in(validate_Fixed32Rules* msg, size_t* len) {
   return (uint32_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(28, 32), len);
 }
-UPB_INLINE uint32_t* validate_Fixed32Rules_resize_in(validate_Fixed32Rules *msg, size_t len, upb_Arena *arena) {
+UPB_INLINE uint32_t* validate_Fixed32Rules_resize_in(validate_Fixed32Rules* msg, size_t len, upb_Arena* arena) {
   return (uint32_t*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(28, 32), len, 2, arena);
 }
-UPB_INLINE bool validate_Fixed32Rules_add_in(validate_Fixed32Rules *msg, uint32_t val, upb_Arena *arena) {
-  return _upb_Array_Append_accessor2(msg, UPB_SIZE(28, 32), 2, &val,
-      arena);
+UPB_INLINE bool validate_Fixed32Rules_add_in(validate_Fixed32Rules* msg, uint32_t val, upb_Arena* arena) {
+  return _upb_Array_Append_accessor2(msg, UPB_SIZE(28, 32), 2, &val, arena);
 }
-UPB_INLINE uint32_t* validate_Fixed32Rules_mutable_not_in(validate_Fixed32Rules *msg, size_t *len) {
+UPB_INLINE uint32_t* validate_Fixed32Rules_mutable_not_in(validate_Fixed32Rules* msg, size_t* len) {
   return (uint32_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(32, 40), len);
 }
-UPB_INLINE uint32_t* validate_Fixed32Rules_resize_not_in(validate_Fixed32Rules *msg, size_t len, upb_Arena *arena) {
+UPB_INLINE uint32_t* validate_Fixed32Rules_resize_not_in(validate_Fixed32Rules* msg, size_t len, upb_Arena* arena) {
   return (uint32_t*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(32, 40), len, 2, arena);
 }
-UPB_INLINE bool validate_Fixed32Rules_add_not_in(validate_Fixed32Rules *msg, uint32_t val, upb_Arena *arena) {
-  return _upb_Array_Append_accessor2(msg, UPB_SIZE(32, 40), 2, &val,
-      arena);
+UPB_INLINE bool validate_Fixed32Rules_add_not_in(validate_Fixed32Rules* msg, uint32_t val, upb_Arena* arena) {
+  return _upb_Array_Append_accessor2(msg, UPB_SIZE(32, 40), 2, &val, arena);
 }
 UPB_INLINE void validate_Fixed32Rules_set_ignore_empty(validate_Fixed32Rules *msg, bool value) {
   _upb_sethas(msg, 6);
@@ -1435,82 +2024,130 @@ 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);
+}
+UPB_INLINE void validate_Fixed64Rules_clear_const(const validate_Fixed64Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(16, 24), uint64_t) = 0;
+  _upb_clearhas(msg, 1);
 }
-UPB_INLINE bool validate_Fixed64Rules_has_const(const validate_Fixed64Rules *msg) { return _upb_hasbit(msg, 1); }
 UPB_INLINE uint64_t validate_Fixed64Rules_const(const validate_Fixed64Rules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(8, 8), uint64_t);
+  return *UPB_PTR_AT(msg, UPB_SIZE(16, 24), uint64_t);
+}
+UPB_INLINE bool validate_Fixed64Rules_has_lt(const validate_Fixed64Rules* msg) {
+  return _upb_hasbit(msg, 2);
+}
+UPB_INLINE void validate_Fixed64Rules_clear_lt(const validate_Fixed64Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(24, 32), uint64_t) = 0;
+  _upb_clearhas(msg, 2);
 }
-UPB_INLINE bool validate_Fixed64Rules_has_lt(const validate_Fixed64Rules *msg) { return _upb_hasbit(msg, 2); }
 UPB_INLINE uint64_t validate_Fixed64Rules_lt(const validate_Fixed64Rules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(16, 16), uint64_t);
+  return *UPB_PTR_AT(msg, UPB_SIZE(24, 32), uint64_t);
+}
+UPB_INLINE bool validate_Fixed64Rules_has_lte(const validate_Fixed64Rules* msg) {
+  return _upb_hasbit(msg, 3);
+}
+UPB_INLINE void validate_Fixed64Rules_clear_lte(const validate_Fixed64Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(32, 40), uint64_t) = 0;
+  _upb_clearhas(msg, 3);
 }
-UPB_INLINE bool validate_Fixed64Rules_has_lte(const validate_Fixed64Rules *msg) { return _upb_hasbit(msg, 3); }
 UPB_INLINE uint64_t validate_Fixed64Rules_lte(const validate_Fixed64Rules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(24, 24), uint64_t);
+  return *UPB_PTR_AT(msg, UPB_SIZE(32, 40), uint64_t);
+}
+UPB_INLINE bool validate_Fixed64Rules_has_gt(const validate_Fixed64Rules* msg) {
+  return _upb_hasbit(msg, 4);
+}
+UPB_INLINE void validate_Fixed64Rules_clear_gt(const validate_Fixed64Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(40, 48), uint64_t) = 0;
+  _upb_clearhas(msg, 4);
 }
-UPB_INLINE bool validate_Fixed64Rules_has_gt(const validate_Fixed64Rules *msg) { return _upb_hasbit(msg, 4); }
 UPB_INLINE uint64_t validate_Fixed64Rules_gt(const validate_Fixed64Rules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(32, 32), uint64_t);
+  return *UPB_PTR_AT(msg, UPB_SIZE(40, 48), uint64_t);
+}
+UPB_INLINE bool validate_Fixed64Rules_has_gte(const validate_Fixed64Rules* msg) {
+  return _upb_hasbit(msg, 5);
+}
+UPB_INLINE void validate_Fixed64Rules_clear_gte(const validate_Fixed64Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(48, 56), uint64_t) = 0;
+  _upb_clearhas(msg, 5);
 }
-UPB_INLINE bool validate_Fixed64Rules_has_gte(const validate_Fixed64Rules *msg) { return _upb_hasbit(msg, 5); }
 UPB_INLINE uint64_t validate_Fixed64Rules_gte(const validate_Fixed64Rules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(40, 40), uint64_t);
+  return *UPB_PTR_AT(msg, UPB_SIZE(48, 56), uint64_t);
+}
+UPB_INLINE void validate_Fixed64Rules_clear_in(const validate_Fixed64Rules* msg) {
+  _upb_array_detach(msg, UPB_SIZE(4, 8));
+}
+UPB_INLINE uint64_t const* validate_Fixed64Rules_in(const validate_Fixed64Rules* msg, size_t* len) {
+  return (uint64_t const*)_upb_array_accessor(msg, UPB_SIZE(4, 8), len);
+}
+UPB_INLINE void validate_Fixed64Rules_clear_not_in(const validate_Fixed64Rules* msg) {
+  _upb_array_detach(msg, UPB_SIZE(8, 16));
+}
+UPB_INLINE uint64_t const* validate_Fixed64Rules_not_in(const validate_Fixed64Rules* msg, size_t* len) {
+  return (uint64_t const*)_upb_array_accessor(msg, UPB_SIZE(8, 16), len);
+}
+UPB_INLINE bool validate_Fixed64Rules_has_ignore_empty(const validate_Fixed64Rules* msg) {
+  return _upb_hasbit(msg, 6);
+}
+UPB_INLINE void validate_Fixed64Rules_clear_ignore_empty(const validate_Fixed64Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool) = 0;
+  _upb_clearhas(msg, 6);
 }
-UPB_INLINE uint64_t const* validate_Fixed64Rules_in(const validate_Fixed64Rules *msg, size_t *len) { return (uint64_t const*)_upb_array_accessor(msg, UPB_SIZE(52, 56), len); }
-UPB_INLINE uint64_t const* validate_Fixed64Rules_not_in(const validate_Fixed64Rules *msg, size_t *len) { return (uint64_t const*)_upb_array_accessor(msg, UPB_SIZE(56, 64), len); }
-UPB_INLINE bool validate_Fixed64Rules_has_ignore_empty(const validate_Fixed64Rules *msg) { return _upb_hasbit(msg, 6); }
 UPB_INLINE bool validate_Fixed64Rules_ignore_empty(const validate_Fixed64Rules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(48, 48), bool);
+  return *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool);
 }
 
 UPB_INLINE void validate_Fixed64Rules_set_const(validate_Fixed64Rules *msg, uint64_t value) {
   _upb_sethas(msg, 1);
-  *UPB_PTR_AT(msg, UPB_SIZE(8, 8), uint64_t) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(16, 24), uint64_t) = value;
 }
 UPB_INLINE void validate_Fixed64Rules_set_lt(validate_Fixed64Rules *msg, uint64_t value) {
   _upb_sethas(msg, 2);
-  *UPB_PTR_AT(msg, UPB_SIZE(16, 16), uint64_t) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(24, 32), uint64_t) = value;
 }
 UPB_INLINE void validate_Fixed64Rules_set_lte(validate_Fixed64Rules *msg, uint64_t value) {
   _upb_sethas(msg, 3);
-  *UPB_PTR_AT(msg, UPB_SIZE(24, 24), uint64_t) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(32, 40), uint64_t) = value;
 }
 UPB_INLINE void validate_Fixed64Rules_set_gt(validate_Fixed64Rules *msg, uint64_t value) {
   _upb_sethas(msg, 4);
-  *UPB_PTR_AT(msg, UPB_SIZE(32, 32), uint64_t) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(40, 48), uint64_t) = value;
 }
 UPB_INLINE void validate_Fixed64Rules_set_gte(validate_Fixed64Rules *msg, uint64_t value) {
   _upb_sethas(msg, 5);
-  *UPB_PTR_AT(msg, UPB_SIZE(40, 40), uint64_t) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(48, 56), uint64_t) = value;
 }
-UPB_INLINE uint64_t* validate_Fixed64Rules_mutable_in(validate_Fixed64Rules *msg, size_t *len) {
-  return (uint64_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(52, 56), len);
+UPB_INLINE uint64_t* validate_Fixed64Rules_mutable_in(validate_Fixed64Rules* msg, size_t* len) {
+  return (uint64_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(4, 8), len);
 }
-UPB_INLINE uint64_t* validate_Fixed64Rules_resize_in(validate_Fixed64Rules *msg, size_t len, upb_Arena *arena) {
-  return (uint64_t*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(52, 56), len, 3, arena);
+UPB_INLINE uint64_t* validate_Fixed64Rules_resize_in(validate_Fixed64Rules* msg, size_t len, upb_Arena* arena) {
+  return (uint64_t*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(4, 8), len, 3, arena);
 }
-UPB_INLINE bool validate_Fixed64Rules_add_in(validate_Fixed64Rules *msg, uint64_t val, upb_Arena *arena) {
-  return _upb_Array_Append_accessor2(msg, UPB_SIZE(52, 56), 3, &val,
-      arena);
+UPB_INLINE bool validate_Fixed64Rules_add_in(validate_Fixed64Rules* msg, uint64_t val, upb_Arena* arena) {
+  return _upb_Array_Append_accessor2(msg, UPB_SIZE(4, 8), 3, &val, arena);
 }
-UPB_INLINE uint64_t* validate_Fixed64Rules_mutable_not_in(validate_Fixed64Rules *msg, size_t *len) {
-  return (uint64_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(56, 64), len);
+UPB_INLINE uint64_t* validate_Fixed64Rules_mutable_not_in(validate_Fixed64Rules* msg, size_t* len) {
+  return (uint64_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(8, 16), len);
 }
-UPB_INLINE uint64_t* validate_Fixed64Rules_resize_not_in(validate_Fixed64Rules *msg, size_t len, upb_Arena *arena) {
-  return (uint64_t*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(56, 64), len, 3, arena);
+UPB_INLINE uint64_t* validate_Fixed64Rules_resize_not_in(validate_Fixed64Rules* msg, size_t len, upb_Arena* arena) {
+  return (uint64_t*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(8, 16), len, 3, arena);
 }
-UPB_INLINE bool validate_Fixed64Rules_add_not_in(validate_Fixed64Rules *msg, uint64_t val, upb_Arena *arena) {
-  return _upb_Array_Append_accessor2(msg, UPB_SIZE(56, 64), 3, &val,
-      arena);
+UPB_INLINE bool validate_Fixed64Rules_add_not_in(validate_Fixed64Rules* msg, uint64_t val, upb_Arena* arena) {
+  return _upb_Array_Append_accessor2(msg, UPB_SIZE(8, 16), 3, &val, arena);
 }
 UPB_INLINE void validate_Fixed64Rules_set_ignore_empty(validate_Fixed64Rules *msg, bool value) {
   _upb_sethas(msg, 6);
-  *UPB_PTR_AT(msg, UPB_SIZE(48, 48), bool) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool) = value;
 }
 
 /* validate.SFixed32Rules */
@@ -1538,35 +2175,85 @@ 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);
+}
+UPB_INLINE void validate_SFixed32Rules_clear_const(const validate_SFixed32Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(4, 4), int32_t) = 0;
+  _upb_clearhas(msg, 1);
 }
-UPB_INLINE bool validate_SFixed32Rules_has_const(const validate_SFixed32Rules *msg) { return _upb_hasbit(msg, 1); }
 UPB_INLINE int32_t validate_SFixed32Rules_const(const validate_SFixed32Rules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(4, 4), int32_t);
 }
-UPB_INLINE bool validate_SFixed32Rules_has_lt(const validate_SFixed32Rules *msg) { return _upb_hasbit(msg, 2); }
+UPB_INLINE bool validate_SFixed32Rules_has_lt(const validate_SFixed32Rules* msg) {
+  return _upb_hasbit(msg, 2);
+}
+UPB_INLINE void validate_SFixed32Rules_clear_lt(const validate_SFixed32Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(8, 8), int32_t) = 0;
+  _upb_clearhas(msg, 2);
+}
 UPB_INLINE int32_t validate_SFixed32Rules_lt(const validate_SFixed32Rules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(8, 8), int32_t);
 }
-UPB_INLINE bool validate_SFixed32Rules_has_lte(const validate_SFixed32Rules *msg) { return _upb_hasbit(msg, 3); }
+UPB_INLINE bool validate_SFixed32Rules_has_lte(const validate_SFixed32Rules* msg) {
+  return _upb_hasbit(msg, 3);
+}
+UPB_INLINE void validate_SFixed32Rules_clear_lte(const validate_SFixed32Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(12, 12), int32_t) = 0;
+  _upb_clearhas(msg, 3);
+}
 UPB_INLINE int32_t validate_SFixed32Rules_lte(const validate_SFixed32Rules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(12, 12), int32_t);
 }
-UPB_INLINE bool validate_SFixed32Rules_has_gt(const validate_SFixed32Rules *msg) { return _upb_hasbit(msg, 4); }
+UPB_INLINE bool validate_SFixed32Rules_has_gt(const validate_SFixed32Rules* msg) {
+  return _upb_hasbit(msg, 4);
+}
+UPB_INLINE void validate_SFixed32Rules_clear_gt(const validate_SFixed32Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(16, 16), int32_t) = 0;
+  _upb_clearhas(msg, 4);
+}
 UPB_INLINE int32_t validate_SFixed32Rules_gt(const validate_SFixed32Rules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(16, 16), int32_t);
 }
-UPB_INLINE bool validate_SFixed32Rules_has_gte(const validate_SFixed32Rules *msg) { return _upb_hasbit(msg, 5); }
+UPB_INLINE bool validate_SFixed32Rules_has_gte(const validate_SFixed32Rules* msg) {
+  return _upb_hasbit(msg, 5);
+}
+UPB_INLINE void validate_SFixed32Rules_clear_gte(const validate_SFixed32Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(20, 20), int32_t) = 0;
+  _upb_clearhas(msg, 5);
+}
 UPB_INLINE int32_t validate_SFixed32Rules_gte(const validate_SFixed32Rules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(20, 20), int32_t);
 }
-UPB_INLINE int32_t const* validate_SFixed32Rules_in(const validate_SFixed32Rules *msg, size_t *len) { return (int32_t const*)_upb_array_accessor(msg, UPB_SIZE(28, 32), len); }
-UPB_INLINE int32_t const* validate_SFixed32Rules_not_in(const validate_SFixed32Rules *msg, size_t *len) { return (int32_t const*)_upb_array_accessor(msg, UPB_SIZE(32, 40), len); }
-UPB_INLINE bool validate_SFixed32Rules_has_ignore_empty(const validate_SFixed32Rules *msg) { return _upb_hasbit(msg, 6); }
+UPB_INLINE void validate_SFixed32Rules_clear_in(const validate_SFixed32Rules* msg) {
+  _upb_array_detach(msg, UPB_SIZE(28, 32));
+}
+UPB_INLINE int32_t const* validate_SFixed32Rules_in(const validate_SFixed32Rules* msg, size_t* len) {
+  return (int32_t const*)_upb_array_accessor(msg, UPB_SIZE(28, 32), len);
+}
+UPB_INLINE void validate_SFixed32Rules_clear_not_in(const validate_SFixed32Rules* msg) {
+  _upb_array_detach(msg, UPB_SIZE(32, 40));
+}
+UPB_INLINE int32_t const* validate_SFixed32Rules_not_in(const validate_SFixed32Rules* msg, size_t* len) {
+  return (int32_t const*)_upb_array_accessor(msg, UPB_SIZE(32, 40), len);
+}
+UPB_INLINE bool validate_SFixed32Rules_has_ignore_empty(const validate_SFixed32Rules* msg) {
+  return _upb_hasbit(msg, 6);
+}
+UPB_INLINE void validate_SFixed32Rules_clear_ignore_empty(const validate_SFixed32Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(24, 24), bool) = 0;
+  _upb_clearhas(msg, 6);
+}
 UPB_INLINE bool validate_SFixed32Rules_ignore_empty(const validate_SFixed32Rules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(24, 24), bool);
 }
@@ -1591,25 +2278,23 @@ UPB_INLINE void validate_SFixed32Rules_set_gte(validate_SFixed32Rules *msg, int3
   _upb_sethas(msg, 5);
   *UPB_PTR_AT(msg, UPB_SIZE(20, 20), int32_t) = value;
 }
-UPB_INLINE int32_t* validate_SFixed32Rules_mutable_in(validate_SFixed32Rules *msg, size_t *len) {
+UPB_INLINE int32_t* validate_SFixed32Rules_mutable_in(validate_SFixed32Rules* msg, size_t* len) {
   return (int32_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(28, 32), len);
 }
-UPB_INLINE int32_t* validate_SFixed32Rules_resize_in(validate_SFixed32Rules *msg, size_t len, upb_Arena *arena) {
+UPB_INLINE int32_t* validate_SFixed32Rules_resize_in(validate_SFixed32Rules* msg, size_t len, upb_Arena* arena) {
   return (int32_t*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(28, 32), len, 2, arena);
 }
-UPB_INLINE bool validate_SFixed32Rules_add_in(validate_SFixed32Rules *msg, int32_t val, upb_Arena *arena) {
-  return _upb_Array_Append_accessor2(msg, UPB_SIZE(28, 32), 2, &val,
-      arena);
+UPB_INLINE bool validate_SFixed32Rules_add_in(validate_SFixed32Rules* msg, int32_t val, upb_Arena* arena) {
+  return _upb_Array_Append_accessor2(msg, UPB_SIZE(28, 32), 2, &val, arena);
 }
-UPB_INLINE int32_t* validate_SFixed32Rules_mutable_not_in(validate_SFixed32Rules *msg, size_t *len) {
+UPB_INLINE int32_t* validate_SFixed32Rules_mutable_not_in(validate_SFixed32Rules* msg, size_t* len) {
   return (int32_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(32, 40), len);
 }
-UPB_INLINE int32_t* validate_SFixed32Rules_resize_not_in(validate_SFixed32Rules *msg, size_t len, upb_Arena *arena) {
+UPB_INLINE int32_t* validate_SFixed32Rules_resize_not_in(validate_SFixed32Rules* msg, size_t len, upb_Arena* arena) {
   return (int32_t*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(32, 40), len, 2, arena);
 }
-UPB_INLINE bool validate_SFixed32Rules_add_not_in(validate_SFixed32Rules *msg, int32_t val, upb_Arena *arena) {
-  return _upb_Array_Append_accessor2(msg, UPB_SIZE(32, 40), 2, &val,
-      arena);
+UPB_INLINE bool validate_SFixed32Rules_add_not_in(validate_SFixed32Rules* msg, int32_t val, upb_Arena* arena) {
+  return _upb_Array_Append_accessor2(msg, UPB_SIZE(32, 40), 2, &val, arena);
 }
 UPB_INLINE void validate_SFixed32Rules_set_ignore_empty(validate_SFixed32Rules *msg, bool value) {
   _upb_sethas(msg, 6);
@@ -1641,82 +2326,130 @@ 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);
+}
+UPB_INLINE void validate_SFixed64Rules_clear_const(const validate_SFixed64Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(16, 24), int64_t) = 0;
+  _upb_clearhas(msg, 1);
 }
-UPB_INLINE bool validate_SFixed64Rules_has_const(const validate_SFixed64Rules *msg) { return _upb_hasbit(msg, 1); }
 UPB_INLINE int64_t validate_SFixed64Rules_const(const validate_SFixed64Rules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(8, 8), int64_t);
+  return *UPB_PTR_AT(msg, UPB_SIZE(16, 24), int64_t);
+}
+UPB_INLINE bool validate_SFixed64Rules_has_lt(const validate_SFixed64Rules* msg) {
+  return _upb_hasbit(msg, 2);
+}
+UPB_INLINE void validate_SFixed64Rules_clear_lt(const validate_SFixed64Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(24, 32), int64_t) = 0;
+  _upb_clearhas(msg, 2);
 }
-UPB_INLINE bool validate_SFixed64Rules_has_lt(const validate_SFixed64Rules *msg) { return _upb_hasbit(msg, 2); }
 UPB_INLINE int64_t validate_SFixed64Rules_lt(const validate_SFixed64Rules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(16, 16), int64_t);
+  return *UPB_PTR_AT(msg, UPB_SIZE(24, 32), int64_t);
+}
+UPB_INLINE bool validate_SFixed64Rules_has_lte(const validate_SFixed64Rules* msg) {
+  return _upb_hasbit(msg, 3);
+}
+UPB_INLINE void validate_SFixed64Rules_clear_lte(const validate_SFixed64Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(32, 40), int64_t) = 0;
+  _upb_clearhas(msg, 3);
 }
-UPB_INLINE bool validate_SFixed64Rules_has_lte(const validate_SFixed64Rules *msg) { return _upb_hasbit(msg, 3); }
 UPB_INLINE int64_t validate_SFixed64Rules_lte(const validate_SFixed64Rules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(24, 24), int64_t);
+  return *UPB_PTR_AT(msg, UPB_SIZE(32, 40), int64_t);
+}
+UPB_INLINE bool validate_SFixed64Rules_has_gt(const validate_SFixed64Rules* msg) {
+  return _upb_hasbit(msg, 4);
+}
+UPB_INLINE void validate_SFixed64Rules_clear_gt(const validate_SFixed64Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(40, 48), int64_t) = 0;
+  _upb_clearhas(msg, 4);
 }
-UPB_INLINE bool validate_SFixed64Rules_has_gt(const validate_SFixed64Rules *msg) { return _upb_hasbit(msg, 4); }
 UPB_INLINE int64_t validate_SFixed64Rules_gt(const validate_SFixed64Rules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(32, 32), int64_t);
+  return *UPB_PTR_AT(msg, UPB_SIZE(40, 48), int64_t);
+}
+UPB_INLINE bool validate_SFixed64Rules_has_gte(const validate_SFixed64Rules* msg) {
+  return _upb_hasbit(msg, 5);
+}
+UPB_INLINE void validate_SFixed64Rules_clear_gte(const validate_SFixed64Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(48, 56), int64_t) = 0;
+  _upb_clearhas(msg, 5);
 }
-UPB_INLINE bool validate_SFixed64Rules_has_gte(const validate_SFixed64Rules *msg) { return _upb_hasbit(msg, 5); }
 UPB_INLINE int64_t validate_SFixed64Rules_gte(const validate_SFixed64Rules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(40, 40), int64_t);
+  return *UPB_PTR_AT(msg, UPB_SIZE(48, 56), int64_t);
+}
+UPB_INLINE void validate_SFixed64Rules_clear_in(const validate_SFixed64Rules* msg) {
+  _upb_array_detach(msg, UPB_SIZE(4, 8));
+}
+UPB_INLINE int64_t const* validate_SFixed64Rules_in(const validate_SFixed64Rules* msg, size_t* len) {
+  return (int64_t const*)_upb_array_accessor(msg, UPB_SIZE(4, 8), len);
+}
+UPB_INLINE void validate_SFixed64Rules_clear_not_in(const validate_SFixed64Rules* msg) {
+  _upb_array_detach(msg, UPB_SIZE(8, 16));
+}
+UPB_INLINE int64_t const* validate_SFixed64Rules_not_in(const validate_SFixed64Rules* msg, size_t* len) {
+  return (int64_t const*)_upb_array_accessor(msg, UPB_SIZE(8, 16), len);
+}
+UPB_INLINE bool validate_SFixed64Rules_has_ignore_empty(const validate_SFixed64Rules* msg) {
+  return _upb_hasbit(msg, 6);
+}
+UPB_INLINE void validate_SFixed64Rules_clear_ignore_empty(const validate_SFixed64Rules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool) = 0;
+  _upb_clearhas(msg, 6);
 }
-UPB_INLINE int64_t const* validate_SFixed64Rules_in(const validate_SFixed64Rules *msg, size_t *len) { return (int64_t const*)_upb_array_accessor(msg, UPB_SIZE(52, 56), len); }
-UPB_INLINE int64_t const* validate_SFixed64Rules_not_in(const validate_SFixed64Rules *msg, size_t *len) { return (int64_t const*)_upb_array_accessor(msg, UPB_SIZE(56, 64), len); }
-UPB_INLINE bool validate_SFixed64Rules_has_ignore_empty(const validate_SFixed64Rules *msg) { return _upb_hasbit(msg, 6); }
 UPB_INLINE bool validate_SFixed64Rules_ignore_empty(const validate_SFixed64Rules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(48, 48), bool);
+  return *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool);
 }
 
 UPB_INLINE void validate_SFixed64Rules_set_const(validate_SFixed64Rules *msg, int64_t value) {
   _upb_sethas(msg, 1);
-  *UPB_PTR_AT(msg, UPB_SIZE(8, 8), int64_t) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(16, 24), int64_t) = value;
 }
 UPB_INLINE void validate_SFixed64Rules_set_lt(validate_SFixed64Rules *msg, int64_t value) {
   _upb_sethas(msg, 2);
-  *UPB_PTR_AT(msg, UPB_SIZE(16, 16), int64_t) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(24, 32), int64_t) = value;
 }
 UPB_INLINE void validate_SFixed64Rules_set_lte(validate_SFixed64Rules *msg, int64_t value) {
   _upb_sethas(msg, 3);
-  *UPB_PTR_AT(msg, UPB_SIZE(24, 24), int64_t) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(32, 40), int64_t) = value;
 }
 UPB_INLINE void validate_SFixed64Rules_set_gt(validate_SFixed64Rules *msg, int64_t value) {
   _upb_sethas(msg, 4);
-  *UPB_PTR_AT(msg, UPB_SIZE(32, 32), int64_t) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(40, 48), int64_t) = value;
 }
 UPB_INLINE void validate_SFixed64Rules_set_gte(validate_SFixed64Rules *msg, int64_t value) {
   _upb_sethas(msg, 5);
-  *UPB_PTR_AT(msg, UPB_SIZE(40, 40), int64_t) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(48, 56), int64_t) = value;
 }
-UPB_INLINE int64_t* validate_SFixed64Rules_mutable_in(validate_SFixed64Rules *msg, size_t *len) {
-  return (int64_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(52, 56), len);
+UPB_INLINE int64_t* validate_SFixed64Rules_mutable_in(validate_SFixed64Rules* msg, size_t* len) {
+  return (int64_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(4, 8), len);
 }
-UPB_INLINE int64_t* validate_SFixed64Rules_resize_in(validate_SFixed64Rules *msg, size_t len, upb_Arena *arena) {
-  return (int64_t*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(52, 56), len, 3, arena);
+UPB_INLINE int64_t* validate_SFixed64Rules_resize_in(validate_SFixed64Rules* msg, size_t len, upb_Arena* arena) {
+  return (int64_t*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(4, 8), len, 3, arena);
 }
-UPB_INLINE bool validate_SFixed64Rules_add_in(validate_SFixed64Rules *msg, int64_t val, upb_Arena *arena) {
-  return _upb_Array_Append_accessor2(msg, UPB_SIZE(52, 56), 3, &val,
-      arena);
+UPB_INLINE bool validate_SFixed64Rules_add_in(validate_SFixed64Rules* msg, int64_t val, upb_Arena* arena) {
+  return _upb_Array_Append_accessor2(msg, UPB_SIZE(4, 8), 3, &val, arena);
 }
-UPB_INLINE int64_t* validate_SFixed64Rules_mutable_not_in(validate_SFixed64Rules *msg, size_t *len) {
-  return (int64_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(56, 64), len);
+UPB_INLINE int64_t* validate_SFixed64Rules_mutable_not_in(validate_SFixed64Rules* msg, size_t* len) {
+  return (int64_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(8, 16), len);
 }
-UPB_INLINE int64_t* validate_SFixed64Rules_resize_not_in(validate_SFixed64Rules *msg, size_t len, upb_Arena *arena) {
-  return (int64_t*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(56, 64), len, 3, arena);
+UPB_INLINE int64_t* validate_SFixed64Rules_resize_not_in(validate_SFixed64Rules* msg, size_t len, upb_Arena* arena) {
+  return (int64_t*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(8, 16), len, 3, arena);
 }
-UPB_INLINE bool validate_SFixed64Rules_add_not_in(validate_SFixed64Rules *msg, int64_t val, upb_Arena *arena) {
-  return _upb_Array_Append_accessor2(msg, UPB_SIZE(56, 64), 3, &val,
-      arena);
+UPB_INLINE bool validate_SFixed64Rules_add_not_in(validate_SFixed64Rules* msg, int64_t val, upb_Arena* arena) {
+  return _upb_Array_Append_accessor2(msg, UPB_SIZE(8, 16), 3, &val, arena);
 }
 UPB_INLINE void validate_SFixed64Rules_set_ignore_empty(validate_SFixed64Rules *msg, bool value) {
   _upb_sethas(msg, 6);
-  *UPB_PTR_AT(msg, UPB_SIZE(48, 48), bool) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool) = value;
 }
 
 /* validate.BoolRules */
@@ -1744,13 +2477,23 @@ 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);
+}
+UPB_INLINE void validate_BoolRules_clear_const(const validate_BoolRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool) = 0;
+  _upb_clearhas(msg, 1);
 }
-UPB_INLINE bool validate_BoolRules_has_const(const validate_BoolRules *msg) { return _upb_hasbit(msg, 1); }
 UPB_INLINE bool validate_BoolRules_const(const validate_BoolRules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool);
 }
@@ -1785,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,
@@ -1804,192 +2551,355 @@ typedef enum {
   validate_StringRules_well_known_well_known_regex = 24,
   validate_StringRules_well_known_NOT_SET = 0
 } validate_StringRules_well_known_oneofcases;
-UPB_INLINE validate_StringRules_well_known_oneofcases validate_StringRules_well_known_case(const validate_StringRules* msg) { return (validate_StringRules_well_known_oneofcases)*UPB_PTR_AT(msg, UPB_SIZE(120, 180), int32_t); }
-
-UPB_INLINE bool validate_StringRules_has_const(const validate_StringRules *msg) { return _upb_hasbit(msg, 1); }
+UPB_INLINE validate_StringRules_well_known_oneofcases validate_StringRules_well_known_case(const validate_StringRules* msg) {
+  return (validate_StringRules_well_known_oneofcases)*UPB_PTR_AT(msg, UPB_SIZE(4, 4), int32_t);
+}
+UPB_INLINE bool validate_StringRules_has_const(const validate_StringRules* msg) {
+  return _upb_hasbit(msg, 1);
+}
+UPB_INLINE void validate_StringRules_clear_const(const validate_StringRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(16, 16), upb_StringView) = upb_StringView_FromDataAndSize(NULL, 0);
+  _upb_clearhas(msg, 1);
+}
 UPB_INLINE upb_StringView validate_StringRules_const(const validate_StringRules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(60, 64), upb_StringView);
+  return *UPB_PTR_AT(msg, UPB_SIZE(16, 16), upb_StringView);
+}
+UPB_INLINE bool validate_StringRules_has_min_len(const validate_StringRules* msg) {
+  return _upb_hasbit(msg, 2);
+}
+UPB_INLINE void validate_StringRules_clear_min_len(const validate_StringRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(72, 128), uint64_t) = 0;
+  _upb_clearhas(msg, 2);
 }
-UPB_INLINE bool validate_StringRules_has_min_len(const validate_StringRules *msg) { return _upb_hasbit(msg, 2); }
 UPB_INLINE uint64_t validate_StringRules_min_len(const validate_StringRules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(8, 8), uint64_t);
+  return *UPB_PTR_AT(msg, UPB_SIZE(72, 128), uint64_t);
+}
+UPB_INLINE bool validate_StringRules_has_max_len(const validate_StringRules* msg) {
+  return _upb_hasbit(msg, 3);
+}
+UPB_INLINE void validate_StringRules_clear_max_len(const validate_StringRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(80, 136), uint64_t) = 0;
+  _upb_clearhas(msg, 3);
 }
-UPB_INLINE bool validate_StringRules_has_max_len(const validate_StringRules *msg) { return _upb_hasbit(msg, 3); }
 UPB_INLINE uint64_t validate_StringRules_max_len(const validate_StringRules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(16, 16), uint64_t);
+  return *UPB_PTR_AT(msg, UPB_SIZE(80, 136), uint64_t);
+}
+UPB_INLINE bool validate_StringRules_has_min_bytes(const validate_StringRules* msg) {
+  return _upb_hasbit(msg, 4);
+}
+UPB_INLINE void validate_StringRules_clear_min_bytes(const validate_StringRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(88, 144), uint64_t) = 0;
+  _upb_clearhas(msg, 4);
 }
-UPB_INLINE bool validate_StringRules_has_min_bytes(const validate_StringRules *msg) { return _upb_hasbit(msg, 4); }
 UPB_INLINE uint64_t validate_StringRules_min_bytes(const validate_StringRules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(24, 24), uint64_t);
+  return *UPB_PTR_AT(msg, UPB_SIZE(88, 144), uint64_t);
+}
+UPB_INLINE bool validate_StringRules_has_max_bytes(const validate_StringRules* msg) {
+  return _upb_hasbit(msg, 5);
+}
+UPB_INLINE void validate_StringRules_clear_max_bytes(const validate_StringRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(96, 152), uint64_t) = 0;
+  _upb_clearhas(msg, 5);
 }
-UPB_INLINE bool validate_StringRules_has_max_bytes(const validate_StringRules *msg) { return _upb_hasbit(msg, 5); }
 UPB_INLINE uint64_t validate_StringRules_max_bytes(const validate_StringRules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(32, 32), uint64_t);
+  return *UPB_PTR_AT(msg, UPB_SIZE(96, 152), uint64_t);
+}
+UPB_INLINE bool validate_StringRules_has_pattern(const validate_StringRules* msg) {
+  return _upb_hasbit(msg, 6);
+}
+UPB_INLINE void validate_StringRules_clear_pattern(const validate_StringRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(24, 32), upb_StringView) = upb_StringView_FromDataAndSize(NULL, 0);
+  _upb_clearhas(msg, 6);
 }
-UPB_INLINE bool validate_StringRules_has_pattern(const validate_StringRules *msg) { return _upb_hasbit(msg, 6); }
 UPB_INLINE upb_StringView validate_StringRules_pattern(const validate_StringRules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(68, 80), upb_StringView);
+  return *UPB_PTR_AT(msg, UPB_SIZE(24, 32), upb_StringView);
+}
+UPB_INLINE bool validate_StringRules_has_prefix(const validate_StringRules* msg) {
+  return _upb_hasbit(msg, 7);
+}
+UPB_INLINE void validate_StringRules_clear_prefix(const validate_StringRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(32, 48), upb_StringView) = upb_StringView_FromDataAndSize(NULL, 0);
+  _upb_clearhas(msg, 7);
 }
-UPB_INLINE bool validate_StringRules_has_prefix(const validate_StringRules *msg) { return _upb_hasbit(msg, 7); }
 UPB_INLINE upb_StringView validate_StringRules_prefix(const validate_StringRules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(76, 96), upb_StringView);
+  return *UPB_PTR_AT(msg, UPB_SIZE(32, 48), upb_StringView);
+}
+UPB_INLINE bool validate_StringRules_has_suffix(const validate_StringRules* msg) {
+  return _upb_hasbit(msg, 8);
+}
+UPB_INLINE void validate_StringRules_clear_suffix(const validate_StringRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(40, 64), upb_StringView) = upb_StringView_FromDataAndSize(NULL, 0);
+  _upb_clearhas(msg, 8);
 }
-UPB_INLINE bool validate_StringRules_has_suffix(const validate_StringRules *msg) { return _upb_hasbit(msg, 8); }
 UPB_INLINE upb_StringView validate_StringRules_suffix(const validate_StringRules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(84, 112), upb_StringView);
+  return *UPB_PTR_AT(msg, UPB_SIZE(40, 64), upb_StringView);
+}
+UPB_INLINE bool validate_StringRules_has_contains(const validate_StringRules* msg) {
+  return _upb_hasbit(msg, 9);
+}
+UPB_INLINE void validate_StringRules_clear_contains(const validate_StringRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(48, 80), upb_StringView) = upb_StringView_FromDataAndSize(NULL, 0);
+  _upb_clearhas(msg, 9);
 }
-UPB_INLINE bool validate_StringRules_has_contains(const validate_StringRules *msg) { return _upb_hasbit(msg, 9); }
 UPB_INLINE upb_StringView validate_StringRules_contains(const validate_StringRules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(92, 128), upb_StringView);
-}
-UPB_INLINE upb_StringView const* validate_StringRules_in(const validate_StringRules *msg, size_t *len) { return (upb_StringView const*)_upb_array_accessor(msg, UPB_SIZE(108, 160), len); }
-UPB_INLINE upb_StringView const* validate_StringRules_not_in(const validate_StringRules *msg, size_t *len) { return (upb_StringView const*)_upb_array_accessor(msg, UPB_SIZE(112, 168), len); }
-UPB_INLINE bool validate_StringRules_has_email(const validate_StringRules *msg) { return _upb_getoneofcase(msg, UPB_SIZE(120, 180)) == 12; }
-UPB_INLINE bool validate_StringRules_email(const validate_StringRules *msg) { return UPB_READ_ONEOF(msg, bool, UPB_SIZE(116, 176), UPB_SIZE(120, 180), 12, false); }
-UPB_INLINE bool validate_StringRules_has_hostname(const validate_StringRules *msg) { return _upb_getoneofcase(msg, UPB_SIZE(120, 180)) == 13; }
-UPB_INLINE bool validate_StringRules_hostname(const validate_StringRules *msg) { return UPB_READ_ONEOF(msg, bool, UPB_SIZE(116, 176), UPB_SIZE(120, 180), 13, false); }
-UPB_INLINE bool validate_StringRules_has_ip(const validate_StringRules *msg) { return _upb_getoneofcase(msg, UPB_SIZE(120, 180)) == 14; }
-UPB_INLINE bool validate_StringRules_ip(const validate_StringRules *msg) { return UPB_READ_ONEOF(msg, bool, UPB_SIZE(116, 176), UPB_SIZE(120, 180), 14, false); }
-UPB_INLINE bool validate_StringRules_has_ipv4(const validate_StringRules *msg) { return _upb_getoneofcase(msg, UPB_SIZE(120, 180)) == 15; }
-UPB_INLINE bool validate_StringRules_ipv4(const validate_StringRules *msg) { return UPB_READ_ONEOF(msg, bool, UPB_SIZE(116, 176), UPB_SIZE(120, 180), 15, false); }
-UPB_INLINE bool validate_StringRules_has_ipv6(const validate_StringRules *msg) { return _upb_getoneofcase(msg, UPB_SIZE(120, 180)) == 16; }
-UPB_INLINE bool validate_StringRules_ipv6(const validate_StringRules *msg) { return UPB_READ_ONEOF(msg, bool, UPB_SIZE(116, 176), UPB_SIZE(120, 180), 16, false); }
-UPB_INLINE bool validate_StringRules_has_uri(const validate_StringRules *msg) { return _upb_getoneofcase(msg, UPB_SIZE(120, 180)) == 17; }
-UPB_INLINE bool validate_StringRules_uri(const validate_StringRules *msg) { return UPB_READ_ONEOF(msg, bool, UPB_SIZE(116, 176), UPB_SIZE(120, 180), 17, false); }
-UPB_INLINE bool validate_StringRules_has_uri_ref(const validate_StringRules *msg) { return _upb_getoneofcase(msg, UPB_SIZE(120, 180)) == 18; }
-UPB_INLINE bool validate_StringRules_uri_ref(const validate_StringRules *msg) { return UPB_READ_ONEOF(msg, bool, UPB_SIZE(116, 176), UPB_SIZE(120, 180), 18, false); }
-UPB_INLINE bool validate_StringRules_has_len(const validate_StringRules *msg) { return _upb_hasbit(msg, 10); }
+  return *UPB_PTR_AT(msg, UPB_SIZE(48, 80), upb_StringView);
+}
+UPB_INLINE void validate_StringRules_clear_in(const validate_StringRules* msg) {
+  _upb_array_detach(msg, UPB_SIZE(56, 96));
+}
+UPB_INLINE upb_StringView const* validate_StringRules_in(const validate_StringRules* msg, size_t* len) {
+  return (upb_StringView const*)_upb_array_accessor(msg, UPB_SIZE(56, 96), len);
+}
+UPB_INLINE void validate_StringRules_clear_not_in(const validate_StringRules* msg) {
+  _upb_array_detach(msg, UPB_SIZE(60, 104));
+}
+UPB_INLINE upb_StringView const* validate_StringRules_not_in(const validate_StringRules* msg, size_t* len) {
+  return (upb_StringView const*)_upb_array_accessor(msg, UPB_SIZE(60, 104), len);
+}
+UPB_INLINE bool validate_StringRules_has_email(const validate_StringRules* msg) {
+  return _upb_getoneofcase(msg, UPB_SIZE(4, 4)) == 12;
+}
+UPB_INLINE void validate_StringRules_clear_email(const validate_StringRules* msg) {
+  UPB_WRITE_ONEOF(msg, bool, UPB_SIZE(12, 12), 0, UPB_SIZE(4, 4), validate_StringRules_well_known_NOT_SET);
+}
+UPB_INLINE bool validate_StringRules_email(const validate_StringRules* msg) {
+  return UPB_READ_ONEOF(msg, bool, UPB_SIZE(12, 12), UPB_SIZE(4, 4), 12, false);
+}
+UPB_INLINE bool validate_StringRules_has_hostname(const validate_StringRules* msg) {
+  return _upb_getoneofcase(msg, UPB_SIZE(4, 4)) == 13;
+}
+UPB_INLINE void validate_StringRules_clear_hostname(const validate_StringRules* msg) {
+  UPB_WRITE_ONEOF(msg, bool, UPB_SIZE(12, 12), 0, UPB_SIZE(4, 4), validate_StringRules_well_known_NOT_SET);
+}
+UPB_INLINE bool validate_StringRules_hostname(const validate_StringRules* msg) {
+  return UPB_READ_ONEOF(msg, bool, UPB_SIZE(12, 12), UPB_SIZE(4, 4), 13, false);
+}
+UPB_INLINE bool validate_StringRules_has_ip(const validate_StringRules* msg) {
+  return _upb_getoneofcase(msg, UPB_SIZE(4, 4)) == 14;
+}
+UPB_INLINE void validate_StringRules_clear_ip(const validate_StringRules* msg) {
+  UPB_WRITE_ONEOF(msg, bool, UPB_SIZE(12, 12), 0, UPB_SIZE(4, 4), validate_StringRules_well_known_NOT_SET);
+}
+UPB_INLINE bool validate_StringRules_ip(const validate_StringRules* msg) {
+  return UPB_READ_ONEOF(msg, bool, UPB_SIZE(12, 12), UPB_SIZE(4, 4), 14, false);
+}
+UPB_INLINE bool validate_StringRules_has_ipv4(const validate_StringRules* msg) {
+  return _upb_getoneofcase(msg, UPB_SIZE(4, 4)) == 15;
+}
+UPB_INLINE void validate_StringRules_clear_ipv4(const validate_StringRules* msg) {
+  UPB_WRITE_ONEOF(msg, bool, UPB_SIZE(12, 12), 0, UPB_SIZE(4, 4), validate_StringRules_well_known_NOT_SET);
+}
+UPB_INLINE bool validate_StringRules_ipv4(const validate_StringRules* msg) {
+  return UPB_READ_ONEOF(msg, bool, UPB_SIZE(12, 12), UPB_SIZE(4, 4), 15, false);
+}
+UPB_INLINE bool validate_StringRules_has_ipv6(const validate_StringRules* msg) {
+  return _upb_getoneofcase(msg, UPB_SIZE(4, 4)) == 16;
+}
+UPB_INLINE void validate_StringRules_clear_ipv6(const validate_StringRules* msg) {
+  UPB_WRITE_ONEOF(msg, bool, UPB_SIZE(12, 12), 0, UPB_SIZE(4, 4), validate_StringRules_well_known_NOT_SET);
+}
+UPB_INLINE bool validate_StringRules_ipv6(const validate_StringRules* msg) {
+  return UPB_READ_ONEOF(msg, bool, UPB_SIZE(12, 12), UPB_SIZE(4, 4), 16, false);
+}
+UPB_INLINE bool validate_StringRules_has_uri(const validate_StringRules* msg) {
+  return _upb_getoneofcase(msg, UPB_SIZE(4, 4)) == 17;
+}
+UPB_INLINE void validate_StringRules_clear_uri(const validate_StringRules* msg) {
+  UPB_WRITE_ONEOF(msg, bool, UPB_SIZE(12, 12), 0, UPB_SIZE(4, 4), validate_StringRules_well_known_NOT_SET);
+}
+UPB_INLINE bool validate_StringRules_uri(const validate_StringRules* msg) {
+  return UPB_READ_ONEOF(msg, bool, UPB_SIZE(12, 12), UPB_SIZE(4, 4), 17, false);
+}
+UPB_INLINE bool validate_StringRules_has_uri_ref(const validate_StringRules* msg) {
+  return _upb_getoneofcase(msg, UPB_SIZE(4, 4)) == 18;
+}
+UPB_INLINE void validate_StringRules_clear_uri_ref(const validate_StringRules* msg) {
+  UPB_WRITE_ONEOF(msg, bool, UPB_SIZE(12, 12), 0, UPB_SIZE(4, 4), validate_StringRules_well_known_NOT_SET);
+}
+UPB_INLINE bool validate_StringRules_uri_ref(const validate_StringRules* msg) {
+  return UPB_READ_ONEOF(msg, bool, UPB_SIZE(12, 12), UPB_SIZE(4, 4), 18, false);
+}
+UPB_INLINE bool validate_StringRules_has_len(const validate_StringRules* msg) {
+  return _upb_hasbit(msg, 10);
+}
+UPB_INLINE void validate_StringRules_clear_len(const validate_StringRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(104, 160), uint64_t) = 0;
+  _upb_clearhas(msg, 10);
+}
 UPB_INLINE uint64_t validate_StringRules_len(const validate_StringRules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(40, 40), uint64_t);
+  return *UPB_PTR_AT(msg, UPB_SIZE(104, 160), uint64_t);
+}
+UPB_INLINE bool validate_StringRules_has_len_bytes(const validate_StringRules* msg) {
+  return _upb_hasbit(msg, 11);
+}
+UPB_INLINE void validate_StringRules_clear_len_bytes(const validate_StringRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(112, 168), uint64_t) = 0;
+  _upb_clearhas(msg, 11);
 }
-UPB_INLINE bool validate_StringRules_has_len_bytes(const validate_StringRules *msg) { return _upb_hasbit(msg, 11); }
 UPB_INLINE uint64_t validate_StringRules_len_bytes(const validate_StringRules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(48, 48), uint64_t);
+  return *UPB_PTR_AT(msg, UPB_SIZE(112, 168), uint64_t);
+}
+UPB_INLINE bool validate_StringRules_has_address(const validate_StringRules* msg) {
+  return _upb_getoneofcase(msg, UPB_SIZE(4, 4)) == 21;
+}
+UPB_INLINE void validate_StringRules_clear_address(const validate_StringRules* msg) {
+  UPB_WRITE_ONEOF(msg, bool, UPB_SIZE(12, 12), 0, UPB_SIZE(4, 4), validate_StringRules_well_known_NOT_SET);
+}
+UPB_INLINE bool validate_StringRules_address(const validate_StringRules* msg) {
+  return UPB_READ_ONEOF(msg, bool, UPB_SIZE(12, 12), UPB_SIZE(4, 4), 21, false);
+}
+UPB_INLINE bool validate_StringRules_has_uuid(const validate_StringRules* msg) {
+  return _upb_getoneofcase(msg, UPB_SIZE(4, 4)) == 22;
+}
+UPB_INLINE void validate_StringRules_clear_uuid(const validate_StringRules* msg) {
+  UPB_WRITE_ONEOF(msg, bool, UPB_SIZE(12, 12), 0, UPB_SIZE(4, 4), validate_StringRules_well_known_NOT_SET);
+}
+UPB_INLINE bool validate_StringRules_uuid(const validate_StringRules* msg) {
+  return UPB_READ_ONEOF(msg, bool, UPB_SIZE(12, 12), UPB_SIZE(4, 4), 22, false);
+}
+UPB_INLINE bool validate_StringRules_has_not_contains(const validate_StringRules* msg) {
+  return _upb_hasbit(msg, 12);
+}
+UPB_INLINE void validate_StringRules_clear_not_contains(const validate_StringRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(64, 112), upb_StringView) = upb_StringView_FromDataAndSize(NULL, 0);
+  _upb_clearhas(msg, 12);
 }
-UPB_INLINE bool validate_StringRules_has_address(const validate_StringRules *msg) { return _upb_getoneofcase(msg, UPB_SIZE(120, 180)) == 21; }
-UPB_INLINE bool validate_StringRules_address(const validate_StringRules *msg) { return UPB_READ_ONEOF(msg, bool, UPB_SIZE(116, 176), UPB_SIZE(120, 180), 21, false); }
-UPB_INLINE bool validate_StringRules_has_uuid(const validate_StringRules *msg) { return _upb_getoneofcase(msg, UPB_SIZE(120, 180)) == 22; }
-UPB_INLINE bool validate_StringRules_uuid(const validate_StringRules *msg) { return UPB_READ_ONEOF(msg, bool, UPB_SIZE(116, 176), UPB_SIZE(120, 180), 22, false); }
-UPB_INLINE bool validate_StringRules_has_not_contains(const validate_StringRules *msg) { return _upb_hasbit(msg, 12); }
 UPB_INLINE upb_StringView validate_StringRules_not_contains(const validate_StringRules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(100, 144), upb_StringView);
+  return *UPB_PTR_AT(msg, UPB_SIZE(64, 112), upb_StringView);
+}
+UPB_INLINE bool validate_StringRules_has_well_known_regex(const validate_StringRules* msg) {
+  return _upb_getoneofcase(msg, UPB_SIZE(4, 4)) == 24;
+}
+UPB_INLINE void validate_StringRules_clear_well_known_regex(const validate_StringRules* msg) {
+  UPB_WRITE_ONEOF(msg, int32_t, UPB_SIZE(12, 12), 0, UPB_SIZE(4, 4), validate_StringRules_well_known_NOT_SET);
+}
+UPB_INLINE int32_t validate_StringRules_well_known_regex(const validate_StringRules* msg) {
+  return UPB_READ_ONEOF(msg, int32_t, UPB_SIZE(12, 12), UPB_SIZE(4, 4), 24, 0);
+}
+UPB_INLINE bool validate_StringRules_has_strict(const validate_StringRules* msg) {
+  return _upb_hasbit(msg, 13);
+}
+UPB_INLINE void validate_StringRules_clear_strict(const validate_StringRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(8, 8), bool) = 0;
+  _upb_clearhas(msg, 13);
 }
-UPB_INLINE bool validate_StringRules_has_well_known_regex(const validate_StringRules *msg) { return _upb_getoneofcase(msg, UPB_SIZE(120, 180)) == 24; }
-UPB_INLINE int32_t validate_StringRules_well_known_regex(const validate_StringRules *msg) { return UPB_READ_ONEOF(msg, int32_t, UPB_SIZE(116, 176), UPB_SIZE(120, 180), 24, 0); }
-UPB_INLINE bool validate_StringRules_has_strict(const validate_StringRules *msg) { return _upb_hasbit(msg, 13); }
 UPB_INLINE bool validate_StringRules_strict(const validate_StringRules* msg) {
-  return validate_StringRules_has_strict(msg) ? *UPB_PTR_AT(msg, UPB_SIZE(56, 56), bool) : true;
+  return validate_StringRules_has_strict(msg) ? *UPB_PTR_AT(msg, UPB_SIZE(8, 8), bool) : true;
+}
+UPB_INLINE bool validate_StringRules_has_ignore_empty(const validate_StringRules* msg) {
+  return _upb_hasbit(msg, 14);
+}
+UPB_INLINE void validate_StringRules_clear_ignore_empty(const validate_StringRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(9, 9), bool) = 0;
+  _upb_clearhas(msg, 14);
 }
-UPB_INLINE bool validate_StringRules_has_ignore_empty(const validate_StringRules *msg) { return _upb_hasbit(msg, 14); }
 UPB_INLINE bool validate_StringRules_ignore_empty(const validate_StringRules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(57, 57), bool);
+  return *UPB_PTR_AT(msg, UPB_SIZE(9, 9), bool);
 }
 
 UPB_INLINE void validate_StringRules_set_const(validate_StringRules *msg, upb_StringView value) {
   _upb_sethas(msg, 1);
-  *UPB_PTR_AT(msg, UPB_SIZE(60, 64), upb_StringView) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(16, 16), upb_StringView) = value;
 }
 UPB_INLINE void validate_StringRules_set_min_len(validate_StringRules *msg, uint64_t value) {
   _upb_sethas(msg, 2);
-  *UPB_PTR_AT(msg, UPB_SIZE(8, 8), uint64_t) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(72, 128), uint64_t) = value;
 }
 UPB_INLINE void validate_StringRules_set_max_len(validate_StringRules *msg, uint64_t value) {
   _upb_sethas(msg, 3);
-  *UPB_PTR_AT(msg, UPB_SIZE(16, 16), uint64_t) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(80, 136), uint64_t) = value;
 }
 UPB_INLINE void validate_StringRules_set_min_bytes(validate_StringRules *msg, uint64_t value) {
   _upb_sethas(msg, 4);
-  *UPB_PTR_AT(msg, UPB_SIZE(24, 24), uint64_t) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(88, 144), uint64_t) = value;
 }
 UPB_INLINE void validate_StringRules_set_max_bytes(validate_StringRules *msg, uint64_t value) {
   _upb_sethas(msg, 5);
-  *UPB_PTR_AT(msg, UPB_SIZE(32, 32), uint64_t) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(96, 152), uint64_t) = value;
 }
 UPB_INLINE void validate_StringRules_set_pattern(validate_StringRules *msg, upb_StringView value) {
   _upb_sethas(msg, 6);
-  *UPB_PTR_AT(msg, UPB_SIZE(68, 80), upb_StringView) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(24, 32), upb_StringView) = value;
 }
 UPB_INLINE void validate_StringRules_set_prefix(validate_StringRules *msg, upb_StringView value) {
   _upb_sethas(msg, 7);
-  *UPB_PTR_AT(msg, UPB_SIZE(76, 96), upb_StringView) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(32, 48), upb_StringView) = value;
 }
 UPB_INLINE void validate_StringRules_set_suffix(validate_StringRules *msg, upb_StringView value) {
   _upb_sethas(msg, 8);
-  *UPB_PTR_AT(msg, UPB_SIZE(84, 112), upb_StringView) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(40, 64), upb_StringView) = value;
 }
 UPB_INLINE void validate_StringRules_set_contains(validate_StringRules *msg, upb_StringView value) {
   _upb_sethas(msg, 9);
-  *UPB_PTR_AT(msg, UPB_SIZE(92, 128), upb_StringView) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(48, 80), upb_StringView) = value;
 }
-UPB_INLINE upb_StringView* validate_StringRules_mutable_in(validate_StringRules *msg, size_t *len) {
-  return (upb_StringView*)_upb_array_mutable_accessor(msg, UPB_SIZE(108, 160), len);
+UPB_INLINE upb_StringView* validate_StringRules_mutable_in(validate_StringRules* msg, size_t* len) {
+  return (upb_StringView*)_upb_array_mutable_accessor(msg, UPB_SIZE(56, 96), len);
 }
-UPB_INLINE upb_StringView* validate_StringRules_resize_in(validate_StringRules *msg, size_t len, upb_Arena *arena) {
-  return (upb_StringView*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(108, 160), len, UPB_SIZE(3, 4), arena);
+UPB_INLINE upb_StringView* validate_StringRules_resize_in(validate_StringRules* msg, size_t len, upb_Arena* arena) {
+  return (upb_StringView*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(56, 96), len, UPB_SIZE(3, 4), arena);
 }
-UPB_INLINE bool validate_StringRules_add_in(validate_StringRules *msg, upb_StringView val, upb_Arena *arena) {
-  return _upb_Array_Append_accessor2(msg, UPB_SIZE(108, 160), UPB_SIZE(3, 4), &val,
-      arena);
+UPB_INLINE bool validate_StringRules_add_in(validate_StringRules* msg, upb_StringView val, upb_Arena* arena) {
+  return _upb_Array_Append_accessor2(msg, UPB_SIZE(56, 96), UPB_SIZE(3, 4), &val, arena);
 }
-UPB_INLINE upb_StringView* validate_StringRules_mutable_not_in(validate_StringRules *msg, size_t *len) {
-  return (upb_StringView*)_upb_array_mutable_accessor(msg, UPB_SIZE(112, 168), len);
+UPB_INLINE upb_StringView* validate_StringRules_mutable_not_in(validate_StringRules* msg, size_t* len) {
+  return (upb_StringView*)_upb_array_mutable_accessor(msg, UPB_SIZE(60, 104), len);
 }
-UPB_INLINE upb_StringView* validate_StringRules_resize_not_in(validate_StringRules *msg, size_t len, upb_Arena *arena) {
-  return (upb_StringView*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(112, 168), len, UPB_SIZE(3, 4), arena);
+UPB_INLINE upb_StringView* validate_StringRules_resize_not_in(validate_StringRules* msg, size_t len, upb_Arena* arena) {
+  return (upb_StringView*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(60, 104), len, UPB_SIZE(3, 4), arena);
 }
-UPB_INLINE bool validate_StringRules_add_not_in(validate_StringRules *msg, upb_StringView val, upb_Arena *arena) {
-  return _upb_Array_Append_accessor2(msg, UPB_SIZE(112, 168), UPB_SIZE(3, 4), &val,
-      arena);
+UPB_INLINE bool validate_StringRules_add_not_in(validate_StringRules* msg, upb_StringView val, upb_Arena* arena) {
+  return _upb_Array_Append_accessor2(msg, UPB_SIZE(60, 104), UPB_SIZE(3, 4), &val, arena);
 }
 UPB_INLINE void validate_StringRules_set_email(validate_StringRules *msg, bool value) {
-  UPB_WRITE_ONEOF(msg, bool, UPB_SIZE(116, 176), value, UPB_SIZE(120, 180), 12);
+  UPB_WRITE_ONEOF(msg, bool, UPB_SIZE(12, 12), value, UPB_SIZE(4, 4), 12);
 }
 UPB_INLINE void validate_StringRules_set_hostname(validate_StringRules *msg, bool value) {
-  UPB_WRITE_ONEOF(msg, bool, UPB_SIZE(116, 176), value, UPB_SIZE(120, 180), 13);
+  UPB_WRITE_ONEOF(msg, bool, UPB_SIZE(12, 12), value, UPB_SIZE(4, 4), 13);
 }
 UPB_INLINE void validate_StringRules_set_ip(validate_StringRules *msg, bool value) {
-  UPB_WRITE_ONEOF(msg, bool, UPB_SIZE(116, 176), value, UPB_SIZE(120, 180), 14);
+  UPB_WRITE_ONEOF(msg, bool, UPB_SIZE(12, 12), value, UPB_SIZE(4, 4), 14);
 }
 UPB_INLINE void validate_StringRules_set_ipv4(validate_StringRules *msg, bool value) {
-  UPB_WRITE_ONEOF(msg, bool, UPB_SIZE(116, 176), value, UPB_SIZE(120, 180), 15);
+  UPB_WRITE_ONEOF(msg, bool, UPB_SIZE(12, 12), value, UPB_SIZE(4, 4), 15);
 }
 UPB_INLINE void validate_StringRules_set_ipv6(validate_StringRules *msg, bool value) {
-  UPB_WRITE_ONEOF(msg, bool, UPB_SIZE(116, 176), value, UPB_SIZE(120, 180), 16);
+  UPB_WRITE_ONEOF(msg, bool, UPB_SIZE(12, 12), value, UPB_SIZE(4, 4), 16);
 }
 UPB_INLINE void validate_StringRules_set_uri(validate_StringRules *msg, bool value) {
-  UPB_WRITE_ONEOF(msg, bool, UPB_SIZE(116, 176), value, UPB_SIZE(120, 180), 17);
+  UPB_WRITE_ONEOF(msg, bool, UPB_SIZE(12, 12), value, UPB_SIZE(4, 4), 17);
 }
 UPB_INLINE void validate_StringRules_set_uri_ref(validate_StringRules *msg, bool value) {
-  UPB_WRITE_ONEOF(msg, bool, UPB_SIZE(116, 176), value, UPB_SIZE(120, 180), 18);
+  UPB_WRITE_ONEOF(msg, bool, UPB_SIZE(12, 12), value, UPB_SIZE(4, 4), 18);
 }
 UPB_INLINE void validate_StringRules_set_len(validate_StringRules *msg, uint64_t value) {
   _upb_sethas(msg, 10);
-  *UPB_PTR_AT(msg, UPB_SIZE(40, 40), uint64_t) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(104, 160), uint64_t) = value;
 }
 UPB_INLINE void validate_StringRules_set_len_bytes(validate_StringRules *msg, uint64_t value) {
   _upb_sethas(msg, 11);
-  *UPB_PTR_AT(msg, UPB_SIZE(48, 48), uint64_t) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(112, 168), uint64_t) = value;
 }
 UPB_INLINE void validate_StringRules_set_address(validate_StringRules *msg, bool value) {
-  UPB_WRITE_ONEOF(msg, bool, UPB_SIZE(116, 176), value, UPB_SIZE(120, 180), 21);
+  UPB_WRITE_ONEOF(msg, bool, UPB_SIZE(12, 12), value, UPB_SIZE(4, 4), 21);
 }
 UPB_INLINE void validate_StringRules_set_uuid(validate_StringRules *msg, bool value) {
-  UPB_WRITE_ONEOF(msg, bool, UPB_SIZE(116, 176), value, UPB_SIZE(120, 180), 22);
+  UPB_WRITE_ONEOF(msg, bool, UPB_SIZE(12, 12), value, UPB_SIZE(4, 4), 22);
 }
 UPB_INLINE void validate_StringRules_set_not_contains(validate_StringRules *msg, upb_StringView value) {
   _upb_sethas(msg, 12);
-  *UPB_PTR_AT(msg, UPB_SIZE(100, 144), upb_StringView) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(64, 112), upb_StringView) = value;
 }
 UPB_INLINE void validate_StringRules_set_well_known_regex(validate_StringRules *msg, int32_t value) {
-  UPB_WRITE_ONEOF(msg, int32_t, UPB_SIZE(116, 176), value, UPB_SIZE(120, 180), 24);
+  UPB_WRITE_ONEOF(msg, int32_t, UPB_SIZE(12, 12), value, UPB_SIZE(4, 4), 24);
 }
 UPB_INLINE void validate_StringRules_set_strict(validate_StringRules *msg, bool value) {
   _upb_sethas(msg, 13);
-  *UPB_PTR_AT(msg, UPB_SIZE(56, 56), bool) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(8, 8), bool) = value;
 }
 UPB_INLINE void validate_StringRules_set_ignore_empty(validate_StringRules *msg, bool value) {
   _upb_sethas(msg, 14);
-  *UPB_PTR_AT(msg, UPB_SIZE(57, 57), bool) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(9, 9), bool) = value;
 }
 
 /* validate.BytesRules */
@@ -2017,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,
@@ -2029,117 +2943,201 @@ typedef enum {
   validate_BytesRules_well_known_ipv6 = 12,
   validate_BytesRules_well_known_NOT_SET = 0
 } validate_BytesRules_well_known_oneofcases;
-UPB_INLINE validate_BytesRules_well_known_oneofcases validate_BytesRules_well_known_case(const validate_BytesRules* msg) { return (validate_BytesRules_well_known_oneofcases)*UPB_PTR_AT(msg, UPB_SIZE(88, 140), int32_t); }
-
-UPB_INLINE bool validate_BytesRules_has_const(const validate_BytesRules *msg) { return _upb_hasbit(msg, 1); }
+UPB_INLINE validate_BytesRules_well_known_oneofcases validate_BytesRules_well_known_case(const validate_BytesRules* msg) {
+  return (validate_BytesRules_well_known_oneofcases)*UPB_PTR_AT(msg, UPB_SIZE(4, 4), int32_t);
+}
+UPB_INLINE bool validate_BytesRules_has_const(const validate_BytesRules* msg) {
+  return _upb_hasbit(msg, 1);
+}
+UPB_INLINE void validate_BytesRules_clear_const(const validate_BytesRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(12, 16), upb_StringView) = upb_StringView_FromDataAndSize(NULL, 0);
+  _upb_clearhas(msg, 1);
+}
 UPB_INLINE upb_StringView validate_BytesRules_const(const validate_BytesRules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(36, 40), upb_StringView);
+  return *UPB_PTR_AT(msg, UPB_SIZE(12, 16), upb_StringView);
+}
+UPB_INLINE bool validate_BytesRules_has_min_len(const validate_BytesRules* msg) {
+  return _upb_hasbit(msg, 2);
+}
+UPB_INLINE void validate_BytesRules_clear_min_len(const validate_BytesRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(64, 112), uint64_t) = 0;
+  _upb_clearhas(msg, 2);
 }
-UPB_INLINE bool validate_BytesRules_has_min_len(const validate_BytesRules *msg) { return _upb_hasbit(msg, 2); }
 UPB_INLINE uint64_t validate_BytesRules_min_len(const validate_BytesRules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(8, 8), uint64_t);
+  return *UPB_PTR_AT(msg, UPB_SIZE(64, 112), uint64_t);
+}
+UPB_INLINE bool validate_BytesRules_has_max_len(const validate_BytesRules* msg) {
+  return _upb_hasbit(msg, 3);
+}
+UPB_INLINE void validate_BytesRules_clear_max_len(const validate_BytesRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(72, 120), uint64_t) = 0;
+  _upb_clearhas(msg, 3);
 }
-UPB_INLINE bool validate_BytesRules_has_max_len(const validate_BytesRules *msg) { return _upb_hasbit(msg, 3); }
 UPB_INLINE uint64_t validate_BytesRules_max_len(const validate_BytesRules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(16, 16), uint64_t);
+  return *UPB_PTR_AT(msg, UPB_SIZE(72, 120), uint64_t);
+}
+UPB_INLINE bool validate_BytesRules_has_pattern(const validate_BytesRules* msg) {
+  return _upb_hasbit(msg, 4);
+}
+UPB_INLINE void validate_BytesRules_clear_pattern(const validate_BytesRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(20, 32), upb_StringView) = upb_StringView_FromDataAndSize(NULL, 0);
+  _upb_clearhas(msg, 4);
 }
-UPB_INLINE bool validate_BytesRules_has_pattern(const validate_BytesRules *msg) { return _upb_hasbit(msg, 4); }
 UPB_INLINE upb_StringView validate_BytesRules_pattern(const validate_BytesRules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(44, 56), upb_StringView);
+  return *UPB_PTR_AT(msg, UPB_SIZE(20, 32), upb_StringView);
+}
+UPB_INLINE bool validate_BytesRules_has_prefix(const validate_BytesRules* msg) {
+  return _upb_hasbit(msg, 5);
+}
+UPB_INLINE void validate_BytesRules_clear_prefix(const validate_BytesRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(28, 48), upb_StringView) = upb_StringView_FromDataAndSize(NULL, 0);
+  _upb_clearhas(msg, 5);
 }
-UPB_INLINE bool validate_BytesRules_has_prefix(const validate_BytesRules *msg) { return _upb_hasbit(msg, 5); }
 UPB_INLINE upb_StringView validate_BytesRules_prefix(const validate_BytesRules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(52, 72), upb_StringView);
+  return *UPB_PTR_AT(msg, UPB_SIZE(28, 48), upb_StringView);
+}
+UPB_INLINE bool validate_BytesRules_has_suffix(const validate_BytesRules* msg) {
+  return _upb_hasbit(msg, 6);
+}
+UPB_INLINE void validate_BytesRules_clear_suffix(const validate_BytesRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(36, 64), upb_StringView) = upb_StringView_FromDataAndSize(NULL, 0);
+  _upb_clearhas(msg, 6);
 }
-UPB_INLINE bool validate_BytesRules_has_suffix(const validate_BytesRules *msg) { return _upb_hasbit(msg, 6); }
 UPB_INLINE upb_StringView validate_BytesRules_suffix(const validate_BytesRules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(60, 88), upb_StringView);
+  return *UPB_PTR_AT(msg, UPB_SIZE(36, 64), upb_StringView);
+}
+UPB_INLINE bool validate_BytesRules_has_contains(const validate_BytesRules* msg) {
+  return _upb_hasbit(msg, 7);
+}
+UPB_INLINE void validate_BytesRules_clear_contains(const validate_BytesRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(44, 80), upb_StringView) = upb_StringView_FromDataAndSize(NULL, 0);
+  _upb_clearhas(msg, 7);
 }
-UPB_INLINE bool validate_BytesRules_has_contains(const validate_BytesRules *msg) { return _upb_hasbit(msg, 7); }
 UPB_INLINE upb_StringView validate_BytesRules_contains(const validate_BytesRules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(68, 104), upb_StringView);
-}
-UPB_INLINE upb_StringView const* validate_BytesRules_in(const validate_BytesRules *msg, size_t *len) { return (upb_StringView const*)_upb_array_accessor(msg, UPB_SIZE(76, 120), len); }
-UPB_INLINE upb_StringView const* validate_BytesRules_not_in(const validate_BytesRules *msg, size_t *len) { return (upb_StringView const*)_upb_array_accessor(msg, UPB_SIZE(80, 128), len); }
-UPB_INLINE bool validate_BytesRules_has_ip(const validate_BytesRules *msg) { return _upb_getoneofcase(msg, UPB_SIZE(88, 140)) == 10; }
-UPB_INLINE bool validate_BytesRules_ip(const validate_BytesRules *msg) { return UPB_READ_ONEOF(msg, bool, UPB_SIZE(84, 136), UPB_SIZE(88, 140), 10, false); }
-UPB_INLINE bool validate_BytesRules_has_ipv4(const validate_BytesRules *msg) { return _upb_getoneofcase(msg, UPB_SIZE(88, 140)) == 11; }
-UPB_INLINE bool validate_BytesRules_ipv4(const validate_BytesRules *msg) { return UPB_READ_ONEOF(msg, bool, UPB_SIZE(84, 136), UPB_SIZE(88, 140), 11, false); }
-UPB_INLINE bool validate_BytesRules_has_ipv6(const validate_BytesRules *msg) { return _upb_getoneofcase(msg, UPB_SIZE(88, 140)) == 12; }
-UPB_INLINE bool validate_BytesRules_ipv6(const validate_BytesRules *msg) { return UPB_READ_ONEOF(msg, bool, UPB_SIZE(84, 136), UPB_SIZE(88, 140), 12, false); }
-UPB_INLINE bool validate_BytesRules_has_len(const validate_BytesRules *msg) { return _upb_hasbit(msg, 8); }
+  return *UPB_PTR_AT(msg, UPB_SIZE(44, 80), upb_StringView);
+}
+UPB_INLINE void validate_BytesRules_clear_in(const validate_BytesRules* msg) {
+  _upb_array_detach(msg, UPB_SIZE(52, 96));
+}
+UPB_INLINE upb_StringView const* validate_BytesRules_in(const validate_BytesRules* msg, size_t* len) {
+  return (upb_StringView const*)_upb_array_accessor(msg, UPB_SIZE(52, 96), len);
+}
+UPB_INLINE void validate_BytesRules_clear_not_in(const validate_BytesRules* msg) {
+  _upb_array_detach(msg, UPB_SIZE(56, 104));
+}
+UPB_INLINE upb_StringView const* validate_BytesRules_not_in(const validate_BytesRules* msg, size_t* len) {
+  return (upb_StringView const*)_upb_array_accessor(msg, UPB_SIZE(56, 104), len);
+}
+UPB_INLINE bool validate_BytesRules_has_ip(const validate_BytesRules* msg) {
+  return _upb_getoneofcase(msg, UPB_SIZE(4, 4)) == 10;
+}
+UPB_INLINE void validate_BytesRules_clear_ip(const validate_BytesRules* msg) {
+  UPB_WRITE_ONEOF(msg, bool, UPB_SIZE(2, 2), 0, UPB_SIZE(4, 4), validate_BytesRules_well_known_NOT_SET);
+}
+UPB_INLINE bool validate_BytesRules_ip(const validate_BytesRules* msg) {
+  return UPB_READ_ONEOF(msg, bool, UPB_SIZE(2, 2), UPB_SIZE(4, 4), 10, false);
+}
+UPB_INLINE bool validate_BytesRules_has_ipv4(const validate_BytesRules* msg) {
+  return _upb_getoneofcase(msg, UPB_SIZE(4, 4)) == 11;
+}
+UPB_INLINE void validate_BytesRules_clear_ipv4(const validate_BytesRules* msg) {
+  UPB_WRITE_ONEOF(msg, bool, UPB_SIZE(2, 2), 0, UPB_SIZE(4, 4), validate_BytesRules_well_known_NOT_SET);
+}
+UPB_INLINE bool validate_BytesRules_ipv4(const validate_BytesRules* msg) {
+  return UPB_READ_ONEOF(msg, bool, UPB_SIZE(2, 2), UPB_SIZE(4, 4), 11, false);
+}
+UPB_INLINE bool validate_BytesRules_has_ipv6(const validate_BytesRules* msg) {
+  return _upb_getoneofcase(msg, UPB_SIZE(4, 4)) == 12;
+}
+UPB_INLINE void validate_BytesRules_clear_ipv6(const validate_BytesRules* msg) {
+  UPB_WRITE_ONEOF(msg, bool, UPB_SIZE(2, 2), 0, UPB_SIZE(4, 4), validate_BytesRules_well_known_NOT_SET);
+}
+UPB_INLINE bool validate_BytesRules_ipv6(const validate_BytesRules* msg) {
+  return UPB_READ_ONEOF(msg, bool, UPB_SIZE(2, 2), UPB_SIZE(4, 4), 12, false);
+}
+UPB_INLINE bool validate_BytesRules_has_len(const validate_BytesRules* msg) {
+  return _upb_hasbit(msg, 8);
+}
+UPB_INLINE void validate_BytesRules_clear_len(const validate_BytesRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(80, 128), uint64_t) = 0;
+  _upb_clearhas(msg, 8);
+}
 UPB_INLINE uint64_t validate_BytesRules_len(const validate_BytesRules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(24, 24), uint64_t);
+  return *UPB_PTR_AT(msg, UPB_SIZE(80, 128), uint64_t);
+}
+UPB_INLINE bool validate_BytesRules_has_ignore_empty(const validate_BytesRules* msg) {
+  return _upb_hasbit(msg, 9);
+}
+UPB_INLINE void validate_BytesRules_clear_ignore_empty(const validate_BytesRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(8, 8), bool) = 0;
+  _upb_clearhas(msg, 9);
 }
-UPB_INLINE bool validate_BytesRules_has_ignore_empty(const validate_BytesRules *msg) { return _upb_hasbit(msg, 9); }
 UPB_INLINE bool validate_BytesRules_ignore_empty(const validate_BytesRules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(32, 32), bool);
+  return *UPB_PTR_AT(msg, UPB_SIZE(8, 8), bool);
 }
 
 UPB_INLINE void validate_BytesRules_set_const(validate_BytesRules *msg, upb_StringView value) {
   _upb_sethas(msg, 1);
-  *UPB_PTR_AT(msg, UPB_SIZE(36, 40), upb_StringView) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(12, 16), upb_StringView) = value;
 }
 UPB_INLINE void validate_BytesRules_set_min_len(validate_BytesRules *msg, uint64_t value) {
   _upb_sethas(msg, 2);
-  *UPB_PTR_AT(msg, UPB_SIZE(8, 8), uint64_t) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(64, 112), uint64_t) = value;
 }
 UPB_INLINE void validate_BytesRules_set_max_len(validate_BytesRules *msg, uint64_t value) {
   _upb_sethas(msg, 3);
-  *UPB_PTR_AT(msg, UPB_SIZE(16, 16), uint64_t) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(72, 120), uint64_t) = value;
 }
 UPB_INLINE void validate_BytesRules_set_pattern(validate_BytesRules *msg, upb_StringView value) {
   _upb_sethas(msg, 4);
-  *UPB_PTR_AT(msg, UPB_SIZE(44, 56), upb_StringView) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(20, 32), upb_StringView) = value;
 }
 UPB_INLINE void validate_BytesRules_set_prefix(validate_BytesRules *msg, upb_StringView value) {
   _upb_sethas(msg, 5);
-  *UPB_PTR_AT(msg, UPB_SIZE(52, 72), upb_StringView) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(28, 48), upb_StringView) = value;
 }
 UPB_INLINE void validate_BytesRules_set_suffix(validate_BytesRules *msg, upb_StringView value) {
   _upb_sethas(msg, 6);
-  *UPB_PTR_AT(msg, UPB_SIZE(60, 88), upb_StringView) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(36, 64), upb_StringView) = value;
 }
 UPB_INLINE void validate_BytesRules_set_contains(validate_BytesRules *msg, upb_StringView value) {
   _upb_sethas(msg, 7);
-  *UPB_PTR_AT(msg, UPB_SIZE(68, 104), upb_StringView) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(44, 80), upb_StringView) = value;
 }
-UPB_INLINE upb_StringView* validate_BytesRules_mutable_in(validate_BytesRules *msg, size_t *len) {
-  return (upb_StringView*)_upb_array_mutable_accessor(msg, UPB_SIZE(76, 120), len);
+UPB_INLINE upb_StringView* validate_BytesRules_mutable_in(validate_BytesRules* msg, size_t* len) {
+  return (upb_StringView*)_upb_array_mutable_accessor(msg, UPB_SIZE(52, 96), len);
 }
-UPB_INLINE upb_StringView* validate_BytesRules_resize_in(validate_BytesRules *msg, size_t len, upb_Arena *arena) {
-  return (upb_StringView*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(76, 120), len, UPB_SIZE(3, 4), arena);
+UPB_INLINE upb_StringView* validate_BytesRules_resize_in(validate_BytesRules* msg, size_t len, upb_Arena* arena) {
+  return (upb_StringView*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(52, 96), len, UPB_SIZE(3, 4), arena);
 }
-UPB_INLINE bool validate_BytesRules_add_in(validate_BytesRules *msg, upb_StringView val, upb_Arena *arena) {
-  return _upb_Array_Append_accessor2(msg, UPB_SIZE(76, 120), UPB_SIZE(3, 4), &val,
-      arena);
+UPB_INLINE bool validate_BytesRules_add_in(validate_BytesRules* msg, upb_StringView val, upb_Arena* arena) {
+  return _upb_Array_Append_accessor2(msg, UPB_SIZE(52, 96), UPB_SIZE(3, 4), &val, arena);
 }
-UPB_INLINE upb_StringView* validate_BytesRules_mutable_not_in(validate_BytesRules *msg, size_t *len) {
-  return (upb_StringView*)_upb_array_mutable_accessor(msg, UPB_SIZE(80, 128), len);
+UPB_INLINE upb_StringView* validate_BytesRules_mutable_not_in(validate_BytesRules* msg, size_t* len) {
+  return (upb_StringView*)_upb_array_mutable_accessor(msg, UPB_SIZE(56, 104), len);
 }
-UPB_INLINE upb_StringView* validate_BytesRules_resize_not_in(validate_BytesRules *msg, size_t len, upb_Arena *arena) {
-  return (upb_StringView*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(80, 128), len, UPB_SIZE(3, 4), arena);
+UPB_INLINE upb_StringView* validate_BytesRules_resize_not_in(validate_BytesRules* msg, size_t len, upb_Arena* arena) {
+  return (upb_StringView*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(56, 104), len, UPB_SIZE(3, 4), arena);
 }
-UPB_INLINE bool validate_BytesRules_add_not_in(validate_BytesRules *msg, upb_StringView val, upb_Arena *arena) {
-  return _upb_Array_Append_accessor2(msg, UPB_SIZE(80, 128), UPB_SIZE(3, 4), &val,
-      arena);
+UPB_INLINE bool validate_BytesRules_add_not_in(validate_BytesRules* msg, upb_StringView val, upb_Arena* arena) {
+  return _upb_Array_Append_accessor2(msg, UPB_SIZE(56, 104), UPB_SIZE(3, 4), &val, arena);
 }
 UPB_INLINE void validate_BytesRules_set_ip(validate_BytesRules *msg, bool value) {
-  UPB_WRITE_ONEOF(msg, bool, UPB_SIZE(84, 136), value, UPB_SIZE(88, 140), 10);
+  UPB_WRITE_ONEOF(msg, bool, UPB_SIZE(2, 2), value, UPB_SIZE(4, 4), 10);
 }
 UPB_INLINE void validate_BytesRules_set_ipv4(validate_BytesRules *msg, bool value) {
-  UPB_WRITE_ONEOF(msg, bool, UPB_SIZE(84, 136), value, UPB_SIZE(88, 140), 11);
+  UPB_WRITE_ONEOF(msg, bool, UPB_SIZE(2, 2), value, UPB_SIZE(4, 4), 11);
 }
 UPB_INLINE void validate_BytesRules_set_ipv6(validate_BytesRules *msg, bool value) {
-  UPB_WRITE_ONEOF(msg, bool, UPB_SIZE(84, 136), value, UPB_SIZE(88, 140), 12);
+  UPB_WRITE_ONEOF(msg, bool, UPB_SIZE(2, 2), value, UPB_SIZE(4, 4), 12);
 }
 UPB_INLINE void validate_BytesRules_set_len(validate_BytesRules *msg, uint64_t value) {
   _upb_sethas(msg, 8);
-  *UPB_PTR_AT(msg, UPB_SIZE(24, 24), uint64_t) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(80, 128), uint64_t) = value;
 }
 UPB_INLINE void validate_BytesRules_set_ignore_empty(validate_BytesRules *msg, bool value) {
   _upb_sethas(msg, 9);
-  *UPB_PTR_AT(msg, UPB_SIZE(32, 32), bool) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(8, 8), bool) = value;
 }
 
 /* validate.EnumRules */
@@ -2167,22 +3165,48 @@ 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);
+}
+UPB_INLINE void validate_EnumRules_clear_const(const validate_EnumRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(4, 4), int32_t) = 0;
+  _upb_clearhas(msg, 1);
 }
-UPB_INLINE bool validate_EnumRules_has_const(const validate_EnumRules *msg) { return _upb_hasbit(msg, 1); }
 UPB_INLINE int32_t validate_EnumRules_const(const validate_EnumRules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(4, 4), int32_t);
 }
-UPB_INLINE bool validate_EnumRules_has_defined_only(const validate_EnumRules *msg) { return _upb_hasbit(msg, 2); }
+UPB_INLINE bool validate_EnumRules_has_defined_only(const validate_EnumRules* msg) {
+  return _upb_hasbit(msg, 2);
+}
+UPB_INLINE void validate_EnumRules_clear_defined_only(const validate_EnumRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(8, 8), bool) = 0;
+  _upb_clearhas(msg, 2);
+}
 UPB_INLINE bool validate_EnumRules_defined_only(const validate_EnumRules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(8, 8), bool);
 }
-UPB_INLINE int32_t const* validate_EnumRules_in(const validate_EnumRules *msg, size_t *len) { return (int32_t const*)_upb_array_accessor(msg, UPB_SIZE(12, 16), len); }
-UPB_INLINE int32_t const* validate_EnumRules_not_in(const validate_EnumRules *msg, size_t *len) { return (int32_t const*)_upb_array_accessor(msg, UPB_SIZE(16, 24), len); }
+UPB_INLINE void validate_EnumRules_clear_in(const validate_EnumRules* msg) {
+  _upb_array_detach(msg, UPB_SIZE(12, 16));
+}
+UPB_INLINE int32_t const* validate_EnumRules_in(const validate_EnumRules* msg, size_t* len) {
+  return (int32_t const*)_upb_array_accessor(msg, UPB_SIZE(12, 16), len);
+}
+UPB_INLINE void validate_EnumRules_clear_not_in(const validate_EnumRules* msg) {
+  _upb_array_detach(msg, UPB_SIZE(16, 24));
+}
+UPB_INLINE int32_t const* validate_EnumRules_not_in(const validate_EnumRules* msg, size_t* len) {
+  return (int32_t const*)_upb_array_accessor(msg, UPB_SIZE(16, 24), len);
+}
 
 UPB_INLINE void validate_EnumRules_set_const(validate_EnumRules *msg, int32_t value) {
   _upb_sethas(msg, 1);
@@ -2192,25 +3216,23 @@ UPB_INLINE void validate_EnumRules_set_defined_only(validate_EnumRules *msg, boo
   _upb_sethas(msg, 2);
   *UPB_PTR_AT(msg, UPB_SIZE(8, 8), bool) = value;
 }
-UPB_INLINE int32_t* validate_EnumRules_mutable_in(validate_EnumRules *msg, size_t *len) {
+UPB_INLINE int32_t* validate_EnumRules_mutable_in(validate_EnumRules* msg, size_t* len) {
   return (int32_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(12, 16), len);
 }
-UPB_INLINE int32_t* validate_EnumRules_resize_in(validate_EnumRules *msg, size_t len, upb_Arena *arena) {
+UPB_INLINE int32_t* validate_EnumRules_resize_in(validate_EnumRules* msg, size_t len, upb_Arena* arena) {
   return (int32_t*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(12, 16), len, 2, arena);
 }
-UPB_INLINE bool validate_EnumRules_add_in(validate_EnumRules *msg, int32_t val, upb_Arena *arena) {
-  return _upb_Array_Append_accessor2(msg, UPB_SIZE(12, 16), 2, &val,
-      arena);
+UPB_INLINE bool validate_EnumRules_add_in(validate_EnumRules* msg, int32_t val, upb_Arena* arena) {
+  return _upb_Array_Append_accessor2(msg, UPB_SIZE(12, 16), 2, &val, arena);
 }
-UPB_INLINE int32_t* validate_EnumRules_mutable_not_in(validate_EnumRules *msg, size_t *len) {
+UPB_INLINE int32_t* validate_EnumRules_mutable_not_in(validate_EnumRules* msg, size_t* len) {
   return (int32_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(16, 24), len);
 }
-UPB_INLINE int32_t* validate_EnumRules_resize_not_in(validate_EnumRules *msg, size_t len, upb_Arena *arena) {
+UPB_INLINE int32_t* validate_EnumRules_resize_not_in(validate_EnumRules* msg, size_t len, upb_Arena* arena) {
   return (int32_t*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(16, 24), len, 2, arena);
 }
-UPB_INLINE bool validate_EnumRules_add_not_in(validate_EnumRules *msg, int32_t val, upb_Arena *arena) {
-  return _upb_Array_Append_accessor2(msg, UPB_SIZE(16, 24), 2, &val,
-      arena);
+UPB_INLINE bool validate_EnumRules_add_not_in(validate_EnumRules* msg, int32_t val, upb_Arena* arena) {
+  return _upb_Array_Append_accessor2(msg, UPB_SIZE(16, 24), 2, &val, arena);
 }
 
 /* validate.MessageRules */
@@ -2238,17 +3260,33 @@ 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);
+}
+UPB_INLINE void validate_MessageRules_clear_skip(const validate_MessageRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool) = 0;
+  _upb_clearhas(msg, 1);
 }
-UPB_INLINE bool validate_MessageRules_has_skip(const validate_MessageRules *msg) { return _upb_hasbit(msg, 1); }
 UPB_INLINE bool validate_MessageRules_skip(const validate_MessageRules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool);
 }
-UPB_INLINE bool validate_MessageRules_has_required(const validate_MessageRules *msg) { return _upb_hasbit(msg, 2); }
+UPB_INLINE bool validate_MessageRules_has_required(const validate_MessageRules* msg) {
+  return _upb_hasbit(msg, 2);
+}
+UPB_INLINE void validate_MessageRules_clear_required(const validate_MessageRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(2, 2), bool) = 0;
+  _upb_clearhas(msg, 2);
+}
 UPB_INLINE bool validate_MessageRules_required(const validate_MessageRules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(2, 2), bool);
 }
@@ -2287,50 +3325,83 @@ 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);
+}
+UPB_INLINE void validate_RepeatedRules_clear_min_items(const validate_RepeatedRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(8, 16), uint64_t) = 0;
+  _upb_clearhas(msg, 1);
 }
-UPB_INLINE bool validate_RepeatedRules_has_min_items(const validate_RepeatedRules *msg) { return _upb_hasbit(msg, 1); }
 UPB_INLINE uint64_t validate_RepeatedRules_min_items(const validate_RepeatedRules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(8, 8), uint64_t);
+  return *UPB_PTR_AT(msg, UPB_SIZE(8, 16), uint64_t);
+}
+UPB_INLINE bool validate_RepeatedRules_has_max_items(const validate_RepeatedRules* msg) {
+  return _upb_hasbit(msg, 2);
+}
+UPB_INLINE void validate_RepeatedRules_clear_max_items(const validate_RepeatedRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(16, 24), uint64_t) = 0;
+  _upb_clearhas(msg, 2);
 }
-UPB_INLINE bool validate_RepeatedRules_has_max_items(const validate_RepeatedRules *msg) { return _upb_hasbit(msg, 2); }
 UPB_INLINE uint64_t validate_RepeatedRules_max_items(const validate_RepeatedRules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(16, 16), uint64_t);
+  return *UPB_PTR_AT(msg, UPB_SIZE(16, 24), uint64_t);
+}
+UPB_INLINE bool validate_RepeatedRules_has_unique(const validate_RepeatedRules* msg) {
+  return _upb_hasbit(msg, 3);
+}
+UPB_INLINE void validate_RepeatedRules_clear_unique(const validate_RepeatedRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool) = 0;
+  _upb_clearhas(msg, 3);
 }
-UPB_INLINE bool validate_RepeatedRules_has_unique(const validate_RepeatedRules *msg) { return _upb_hasbit(msg, 3); }
 UPB_INLINE bool validate_RepeatedRules_unique(const validate_RepeatedRules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(24, 24), bool);
+  return *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool);
+}
+UPB_INLINE bool validate_RepeatedRules_has_items(const validate_RepeatedRules* msg) {
+  return _upb_hasbit(msg, 4);
+}
+UPB_INLINE void validate_RepeatedRules_clear_items(const validate_RepeatedRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(4, 8), const upb_Message*) = NULL;
 }
-UPB_INLINE bool validate_RepeatedRules_has_items(const validate_RepeatedRules *msg) { return _upb_hasbit(msg, 4); }
 UPB_INLINE const validate_FieldRules* validate_RepeatedRules_items(const validate_RepeatedRules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(28, 32), const validate_FieldRules*);
+  return *UPB_PTR_AT(msg, UPB_SIZE(4, 8), const validate_FieldRules*);
+}
+UPB_INLINE bool validate_RepeatedRules_has_ignore_empty(const validate_RepeatedRules* msg) {
+  return _upb_hasbit(msg, 5);
+}
+UPB_INLINE void validate_RepeatedRules_clear_ignore_empty(const validate_RepeatedRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(2, 2), bool) = 0;
+  _upb_clearhas(msg, 5);
 }
-UPB_INLINE bool validate_RepeatedRules_has_ignore_empty(const validate_RepeatedRules *msg) { return _upb_hasbit(msg, 5); }
 UPB_INLINE bool validate_RepeatedRules_ignore_empty(const validate_RepeatedRules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(25, 25), bool);
+  return *UPB_PTR_AT(msg, UPB_SIZE(2, 2), bool);
 }
 
 UPB_INLINE void validate_RepeatedRules_set_min_items(validate_RepeatedRules *msg, uint64_t value) {
   _upb_sethas(msg, 1);
-  *UPB_PTR_AT(msg, UPB_SIZE(8, 8), uint64_t) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(8, 16), uint64_t) = value;
 }
 UPB_INLINE void validate_RepeatedRules_set_max_items(validate_RepeatedRules *msg, uint64_t value) {
   _upb_sethas(msg, 2);
-  *UPB_PTR_AT(msg, UPB_SIZE(16, 16), uint64_t) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(16, 24), uint64_t) = value;
 }
 UPB_INLINE void validate_RepeatedRules_set_unique(validate_RepeatedRules *msg, bool value) {
   _upb_sethas(msg, 3);
-  *UPB_PTR_AT(msg, UPB_SIZE(24, 24), bool) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool) = value;
 }
 UPB_INLINE void validate_RepeatedRules_set_items(validate_RepeatedRules *msg, validate_FieldRules* value) {
   _upb_sethas(msg, 4);
-  *UPB_PTR_AT(msg, UPB_SIZE(28, 32), validate_FieldRules*) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(4, 8), validate_FieldRules*) = value;
 }
-UPB_INLINE struct validate_FieldRules* validate_RepeatedRules_mutable_items(validate_RepeatedRules *msg, upb_Arena *arena) {
+UPB_INLINE struct validate_FieldRules* validate_RepeatedRules_mutable_items(validate_RepeatedRules* msg, upb_Arena* arena) {
   struct validate_FieldRules* sub = (struct validate_FieldRules*)validate_RepeatedRules_items(msg);
   if (sub == NULL) {
     sub = (struct validate_FieldRules*)_upb_Message_New(&validate_FieldRules_msginit, arena);
@@ -2341,7 +3412,7 @@ UPB_INLINE struct validate_FieldRules* validate_RepeatedRules_mutable_items(vali
 }
 UPB_INLINE void validate_RepeatedRules_set_ignore_empty(validate_RepeatedRules *msg, bool value) {
   _upb_sethas(msg, 5);
-  *UPB_PTR_AT(msg, UPB_SIZE(25, 25), bool) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(2, 2), bool) = value;
 }
 
 /* validate.MapRules */
@@ -2369,54 +3440,92 @@ 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);
+}
+UPB_INLINE void validate_MapRules_clear_min_pairs(const validate_MapRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(16, 24), uint64_t) = 0;
+  _upb_clearhas(msg, 1);
 }
-UPB_INLINE bool validate_MapRules_has_min_pairs(const validate_MapRules *msg) { return _upb_hasbit(msg, 1); }
 UPB_INLINE uint64_t validate_MapRules_min_pairs(const validate_MapRules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(8, 8), uint64_t);
+  return *UPB_PTR_AT(msg, UPB_SIZE(16, 24), uint64_t);
+}
+UPB_INLINE bool validate_MapRules_has_max_pairs(const validate_MapRules* msg) {
+  return _upb_hasbit(msg, 2);
+}
+UPB_INLINE void validate_MapRules_clear_max_pairs(const validate_MapRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(24, 32), uint64_t) = 0;
+  _upb_clearhas(msg, 2);
 }
-UPB_INLINE bool validate_MapRules_has_max_pairs(const validate_MapRules *msg) { return _upb_hasbit(msg, 2); }
 UPB_INLINE uint64_t validate_MapRules_max_pairs(const validate_MapRules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(16, 16), uint64_t);
+  return *UPB_PTR_AT(msg, UPB_SIZE(24, 32), uint64_t);
+}
+UPB_INLINE bool validate_MapRules_has_no_sparse(const validate_MapRules* msg) {
+  return _upb_hasbit(msg, 3);
+}
+UPB_INLINE void validate_MapRules_clear_no_sparse(const validate_MapRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool) = 0;
+  _upb_clearhas(msg, 3);
 }
-UPB_INLINE bool validate_MapRules_has_no_sparse(const validate_MapRules *msg) { return _upb_hasbit(msg, 3); }
 UPB_INLINE bool validate_MapRules_no_sparse(const validate_MapRules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(24, 24), bool);
+  return *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool);
+}
+UPB_INLINE bool validate_MapRules_has_keys(const validate_MapRules* msg) {
+  return _upb_hasbit(msg, 4);
+}
+UPB_INLINE void validate_MapRules_clear_keys(const validate_MapRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(4, 8), const upb_Message*) = NULL;
 }
-UPB_INLINE bool validate_MapRules_has_keys(const validate_MapRules *msg) { return _upb_hasbit(msg, 4); }
 UPB_INLINE const validate_FieldRules* validate_MapRules_keys(const validate_MapRules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(28, 32), const validate_FieldRules*);
+  return *UPB_PTR_AT(msg, UPB_SIZE(4, 8), const validate_FieldRules*);
+}
+UPB_INLINE bool validate_MapRules_has_values(const validate_MapRules* msg) {
+  return _upb_hasbit(msg, 5);
+}
+UPB_INLINE void validate_MapRules_clear_values(const validate_MapRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(8, 16), const upb_Message*) = NULL;
 }
-UPB_INLINE bool validate_MapRules_has_values(const validate_MapRules *msg) { return _upb_hasbit(msg, 5); }
 UPB_INLINE const validate_FieldRules* validate_MapRules_values(const validate_MapRules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(32, 40), const validate_FieldRules*);
+  return *UPB_PTR_AT(msg, UPB_SIZE(8, 16), const validate_FieldRules*);
+}
+UPB_INLINE bool validate_MapRules_has_ignore_empty(const validate_MapRules* msg) {
+  return _upb_hasbit(msg, 6);
+}
+UPB_INLINE void validate_MapRules_clear_ignore_empty(const validate_MapRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(2, 2), bool) = 0;
+  _upb_clearhas(msg, 6);
 }
-UPB_INLINE bool validate_MapRules_has_ignore_empty(const validate_MapRules *msg) { return _upb_hasbit(msg, 6); }
 UPB_INLINE bool validate_MapRules_ignore_empty(const validate_MapRules* msg) {
-  return *UPB_PTR_AT(msg, UPB_SIZE(25, 25), bool);
+  return *UPB_PTR_AT(msg, UPB_SIZE(2, 2), bool);
 }
 
 UPB_INLINE void validate_MapRules_set_min_pairs(validate_MapRules *msg, uint64_t value) {
   _upb_sethas(msg, 1);
-  *UPB_PTR_AT(msg, UPB_SIZE(8, 8), uint64_t) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(16, 24), uint64_t) = value;
 }
 UPB_INLINE void validate_MapRules_set_max_pairs(validate_MapRules *msg, uint64_t value) {
   _upb_sethas(msg, 2);
-  *UPB_PTR_AT(msg, UPB_SIZE(16, 16), uint64_t) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(24, 32), uint64_t) = value;
 }
 UPB_INLINE void validate_MapRules_set_no_sparse(validate_MapRules *msg, bool value) {
   _upb_sethas(msg, 3);
-  *UPB_PTR_AT(msg, UPB_SIZE(24, 24), bool) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool) = value;
 }
 UPB_INLINE void validate_MapRules_set_keys(validate_MapRules *msg, validate_FieldRules* value) {
   _upb_sethas(msg, 4);
-  *UPB_PTR_AT(msg, UPB_SIZE(28, 32), validate_FieldRules*) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(4, 8), validate_FieldRules*) = value;
 }
-UPB_INLINE struct validate_FieldRules* validate_MapRules_mutable_keys(validate_MapRules *msg, upb_Arena *arena) {
+UPB_INLINE struct validate_FieldRules* validate_MapRules_mutable_keys(validate_MapRules* msg, upb_Arena* arena) {
   struct validate_FieldRules* sub = (struct validate_FieldRules*)validate_MapRules_keys(msg);
   if (sub == NULL) {
     sub = (struct validate_FieldRules*)_upb_Message_New(&validate_FieldRules_msginit, arena);
@@ -2427,9 +3536,9 @@ UPB_INLINE struct validate_FieldRules* validate_MapRules_mutable_keys(validate_M
 }
 UPB_INLINE void validate_MapRules_set_values(validate_MapRules *msg, validate_FieldRules* value) {
   _upb_sethas(msg, 5);
-  *UPB_PTR_AT(msg, UPB_SIZE(32, 40), validate_FieldRules*) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(8, 16), validate_FieldRules*) = value;
 }
-UPB_INLINE struct validate_FieldRules* validate_MapRules_mutable_values(validate_MapRules *msg, upb_Arena *arena) {
+UPB_INLINE struct validate_FieldRules* validate_MapRules_mutable_values(validate_MapRules* msg, upb_Arena* arena) {
   struct validate_FieldRules* sub = (struct validate_FieldRules*)validate_MapRules_values(msg);
   if (sub == NULL) {
     sub = (struct validate_FieldRules*)_upb_Message_New(&validate_FieldRules_msginit, arena);
@@ -2440,7 +3549,7 @@ UPB_INLINE struct validate_FieldRules* validate_MapRules_mutable_values(validate
 }
 UPB_INLINE void validate_MapRules_set_ignore_empty(validate_MapRules *msg, bool value) {
   _upb_sethas(msg, 6);
-  *UPB_PTR_AT(msg, UPB_SIZE(25, 25), bool) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(2, 2), bool) = value;
 }
 
 /* validate.AnyRules */
@@ -2468,42 +3577,60 @@ 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);
+}
+UPB_INLINE void validate_AnyRules_clear_required(const validate_AnyRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool) = 0;
+  _upb_clearhas(msg, 1);
 }
-UPB_INLINE bool validate_AnyRules_has_required(const validate_AnyRules *msg) { return _upb_hasbit(msg, 1); }
 UPB_INLINE bool validate_AnyRules_required(const validate_AnyRules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool);
 }
-UPB_INLINE upb_StringView const* validate_AnyRules_in(const validate_AnyRules *msg, size_t *len) { return (upb_StringView const*)_upb_array_accessor(msg, UPB_SIZE(4, 8), len); }
-UPB_INLINE upb_StringView const* validate_AnyRules_not_in(const validate_AnyRules *msg, size_t *len) { return (upb_StringView const*)_upb_array_accessor(msg, UPB_SIZE(8, 16), len); }
+UPB_INLINE void validate_AnyRules_clear_in(const validate_AnyRules* msg) {
+  _upb_array_detach(msg, UPB_SIZE(4, 8));
+}
+UPB_INLINE upb_StringView const* validate_AnyRules_in(const validate_AnyRules* msg, size_t* len) {
+  return (upb_StringView const*)_upb_array_accessor(msg, UPB_SIZE(4, 8), len);
+}
+UPB_INLINE void validate_AnyRules_clear_not_in(const validate_AnyRules* msg) {
+  _upb_array_detach(msg, UPB_SIZE(8, 16));
+}
+UPB_INLINE upb_StringView const* validate_AnyRules_not_in(const validate_AnyRules* msg, size_t* len) {
+  return (upb_StringView const*)_upb_array_accessor(msg, UPB_SIZE(8, 16), len);
+}
 
 UPB_INLINE void validate_AnyRules_set_required(validate_AnyRules *msg, bool value) {
   _upb_sethas(msg, 1);
   *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool) = value;
 }
-UPB_INLINE upb_StringView* validate_AnyRules_mutable_in(validate_AnyRules *msg, size_t *len) {
+UPB_INLINE upb_StringView* validate_AnyRules_mutable_in(validate_AnyRules* msg, size_t* len) {
   return (upb_StringView*)_upb_array_mutable_accessor(msg, UPB_SIZE(4, 8), len);
 }
-UPB_INLINE upb_StringView* validate_AnyRules_resize_in(validate_AnyRules *msg, size_t len, upb_Arena *arena) {
+UPB_INLINE upb_StringView* validate_AnyRules_resize_in(validate_AnyRules* msg, size_t len, upb_Arena* arena) {
   return (upb_StringView*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(4, 8), len, UPB_SIZE(3, 4), arena);
 }
-UPB_INLINE bool validate_AnyRules_add_in(validate_AnyRules *msg, upb_StringView val, upb_Arena *arena) {
-  return _upb_Array_Append_accessor2(msg, UPB_SIZE(4, 8), UPB_SIZE(3, 4), &val,
-      arena);
+UPB_INLINE bool validate_AnyRules_add_in(validate_AnyRules* msg, upb_StringView val, upb_Arena* arena) {
+  return _upb_Array_Append_accessor2(msg, UPB_SIZE(4, 8), UPB_SIZE(3, 4), &val, arena);
 }
-UPB_INLINE upb_StringView* validate_AnyRules_mutable_not_in(validate_AnyRules *msg, size_t *len) {
+UPB_INLINE upb_StringView* validate_AnyRules_mutable_not_in(validate_AnyRules* msg, size_t* len) {
   return (upb_StringView*)_upb_array_mutable_accessor(msg, UPB_SIZE(8, 16), len);
 }
-UPB_INLINE upb_StringView* validate_AnyRules_resize_not_in(validate_AnyRules *msg, size_t len, upb_Arena *arena) {
+UPB_INLINE upb_StringView* validate_AnyRules_resize_not_in(validate_AnyRules* msg, size_t len, upb_Arena* arena) {
   return (upb_StringView*)_upb_Array_Resize_accessor2(msg, UPB_SIZE(8, 16), len, UPB_SIZE(3, 4), arena);
 }
-UPB_INLINE bool validate_AnyRules_add_not_in(validate_AnyRules *msg, upb_StringView val, upb_Arena *arena) {
-  return _upb_Array_Append_accessor2(msg, UPB_SIZE(8, 16), UPB_SIZE(3, 4), &val,
-      arena);
+UPB_INLINE bool validate_AnyRules_add_not_in(validate_AnyRules* msg, upb_StringView val, upb_Arena* arena) {
+  return _upb_Array_Append_accessor2(msg, UPB_SIZE(8, 16), UPB_SIZE(3, 4), &val, arena);
 }
 
 /* validate.DurationRules */
@@ -2531,40 +3658,89 @@ 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);
+}
+UPB_INLINE void validate_DurationRules_clear_required(const validate_DurationRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool) = 0;
+  _upb_clearhas(msg, 1);
 }
-UPB_INLINE bool validate_DurationRules_has_required(const validate_DurationRules *msg) { return _upb_hasbit(msg, 1); }
 UPB_INLINE bool validate_DurationRules_required(const validate_DurationRules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool);
 }
-UPB_INLINE bool validate_DurationRules_has_const(const validate_DurationRules *msg) { return _upb_hasbit(msg, 2); }
+UPB_INLINE bool validate_DurationRules_has_const(const validate_DurationRules* msg) {
+  return _upb_hasbit(msg, 2);
+}
+UPB_INLINE void validate_DurationRules_clear_const(const validate_DurationRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(4, 8), const upb_Message*) = NULL;
+}
 UPB_INLINE const struct google_protobuf_Duration* validate_DurationRules_const(const validate_DurationRules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(4, 8), const struct google_protobuf_Duration*);
 }
-UPB_INLINE bool validate_DurationRules_has_lt(const validate_DurationRules *msg) { return _upb_hasbit(msg, 3); }
+UPB_INLINE bool validate_DurationRules_has_lt(const validate_DurationRules* msg) {
+  return _upb_hasbit(msg, 3);
+}
+UPB_INLINE void validate_DurationRules_clear_lt(const validate_DurationRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(8, 16), const upb_Message*) = NULL;
+}
 UPB_INLINE const struct google_protobuf_Duration* validate_DurationRules_lt(const validate_DurationRules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(8, 16), const struct google_protobuf_Duration*);
 }
-UPB_INLINE bool validate_DurationRules_has_lte(const validate_DurationRules *msg) { return _upb_hasbit(msg, 4); }
+UPB_INLINE bool validate_DurationRules_has_lte(const validate_DurationRules* msg) {
+  return _upb_hasbit(msg, 4);
+}
+UPB_INLINE void validate_DurationRules_clear_lte(const validate_DurationRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(12, 24), const upb_Message*) = NULL;
+}
 UPB_INLINE const struct google_protobuf_Duration* validate_DurationRules_lte(const validate_DurationRules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(12, 24), const struct google_protobuf_Duration*);
 }
-UPB_INLINE bool validate_DurationRules_has_gt(const validate_DurationRules *msg) { return _upb_hasbit(msg, 5); }
+UPB_INLINE bool validate_DurationRules_has_gt(const validate_DurationRules* msg) {
+  return _upb_hasbit(msg, 5);
+}
+UPB_INLINE void validate_DurationRules_clear_gt(const validate_DurationRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(16, 32), const upb_Message*) = NULL;
+}
 UPB_INLINE const struct google_protobuf_Duration* validate_DurationRules_gt(const validate_DurationRules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(16, 32), const struct google_protobuf_Duration*);
 }
-UPB_INLINE bool validate_DurationRules_has_gte(const validate_DurationRules *msg) { return _upb_hasbit(msg, 6); }
+UPB_INLINE bool validate_DurationRules_has_gte(const validate_DurationRules* msg) {
+  return _upb_hasbit(msg, 6);
+}
+UPB_INLINE void validate_DurationRules_clear_gte(const validate_DurationRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(20, 40), const upb_Message*) = NULL;
+}
 UPB_INLINE const struct google_protobuf_Duration* validate_DurationRules_gte(const validate_DurationRules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(20, 40), const struct google_protobuf_Duration*);
 }
-UPB_INLINE bool validate_DurationRules_has_in(const validate_DurationRules *msg) { return _upb_has_submsg_nohasbit(msg, UPB_SIZE(24, 48)); }
-UPB_INLINE const struct google_protobuf_Duration* const* validate_DurationRules_in(const validate_DurationRules *msg, size_t *len) { return (const struct google_protobuf_Duration* const*)_upb_array_accessor(msg, UPB_SIZE(24, 48), len); }
-UPB_INLINE bool validate_DurationRules_has_not_in(const validate_DurationRules *msg) { return _upb_has_submsg_nohasbit(msg, UPB_SIZE(28, 56)); }
-UPB_INLINE const struct google_protobuf_Duration* const* validate_DurationRules_not_in(const validate_DurationRules *msg, size_t *len) { return (const struct google_protobuf_Duration* const*)_upb_array_accessor(msg, UPB_SIZE(28, 56), len); }
+UPB_INLINE bool validate_DurationRules_has_in(const validate_DurationRules* msg) {
+  return _upb_has_submsg_nohasbit(msg, UPB_SIZE(24, 48));
+}
+UPB_INLINE void validate_DurationRules_clear_in(const validate_DurationRules* msg) {
+  _upb_array_detach(msg, UPB_SIZE(24, 48));
+}
+UPB_INLINE const struct google_protobuf_Duration* const* validate_DurationRules_in(const validate_DurationRules* msg, size_t* len) {
+  return (const struct google_protobuf_Duration* const*)_upb_array_accessor(msg, UPB_SIZE(24, 48), len);
+}
+UPB_INLINE bool validate_DurationRules_has_not_in(const validate_DurationRules* msg) {
+  return _upb_has_submsg_nohasbit(msg, UPB_SIZE(28, 56));
+}
+UPB_INLINE void validate_DurationRules_clear_not_in(const validate_DurationRules* msg) {
+  _upb_array_detach(msg, UPB_SIZE(28, 56));
+}
+UPB_INLINE const struct google_protobuf_Duration* const* validate_DurationRules_not_in(const validate_DurationRules* msg, size_t* len) {
+  return (const struct google_protobuf_Duration* const*)_upb_array_accessor(msg, UPB_SIZE(28, 56), len);
+}
 
 UPB_INLINE void validate_DurationRules_set_required(validate_DurationRules *msg, bool value) {
   _upb_sethas(msg, 1);
@@ -2574,7 +3750,7 @@ UPB_INLINE void validate_DurationRules_set_const(validate_DurationRules *msg, st
   _upb_sethas(msg, 2);
   *UPB_PTR_AT(msg, UPB_SIZE(4, 8), struct google_protobuf_Duration*) = value;
 }
-UPB_INLINE struct google_protobuf_Duration* validate_DurationRules_mutable_const(validate_DurationRules *msg, upb_Arena *arena) {
+UPB_INLINE struct google_protobuf_Duration* validate_DurationRules_mutable_const(validate_DurationRules* msg, upb_Arena* arena) {
   struct google_protobuf_Duration* sub = (struct google_protobuf_Duration*)validate_DurationRules_const(msg);
   if (sub == NULL) {
     sub = (struct google_protobuf_Duration*)_upb_Message_New(&google_protobuf_Duration_msginit, arena);
@@ -2587,7 +3763,7 @@ UPB_INLINE void validate_DurationRules_set_lt(validate_DurationRules *msg, struc
   _upb_sethas(msg, 3);
   *UPB_PTR_AT(msg, UPB_SIZE(8, 16), struct google_protobuf_Duration*) = value;
 }
-UPB_INLINE struct google_protobuf_Duration* validate_DurationRules_mutable_lt(validate_DurationRules *msg, upb_Arena *arena) {
+UPB_INLINE struct google_protobuf_Duration* validate_DurationRules_mutable_lt(validate_DurationRules* msg, upb_Arena* arena) {
   struct google_protobuf_Duration* sub = (struct google_protobuf_Duration*)validate_DurationRules_lt(msg);
   if (sub == NULL) {
     sub = (struct google_protobuf_Duration*)_upb_Message_New(&google_protobuf_Duration_msginit, arena);
@@ -2600,7 +3776,7 @@ UPB_INLINE void validate_DurationRules_set_lte(validate_DurationRules *msg, stru
   _upb_sethas(msg, 4);
   *UPB_PTR_AT(msg, UPB_SIZE(12, 24), struct google_protobuf_Duration*) = value;
 }
-UPB_INLINE struct google_protobuf_Duration* validate_DurationRules_mutable_lte(validate_DurationRules *msg, upb_Arena *arena) {
+UPB_INLINE struct google_protobuf_Duration* validate_DurationRules_mutable_lte(validate_DurationRules* msg, upb_Arena* arena) {
   struct google_protobuf_Duration* sub = (struct google_protobuf_Duration*)validate_DurationRules_lte(msg);
   if (sub == NULL) {
     sub = (struct google_protobuf_Duration*)_upb_Message_New(&google_protobuf_Duration_msginit, arena);
@@ -2613,7 +3789,7 @@ UPB_INLINE void validate_DurationRules_set_gt(validate_DurationRules *msg, struc
   _upb_sethas(msg, 5);
   *UPB_PTR_AT(msg, UPB_SIZE(16, 32), struct google_protobuf_Duration*) = value;
 }
-UPB_INLINE struct google_protobuf_Duration* validate_DurationRules_mutable_gt(validate_DurationRules *msg, upb_Arena *arena) {
+UPB_INLINE struct google_protobuf_Duration* validate_DurationRules_mutable_gt(validate_DurationRules* msg, upb_Arena* arena) {
   struct google_protobuf_Duration* sub = (struct google_protobuf_Duration*)validate_DurationRules_gt(msg);
   if (sub == NULL) {
     sub = (struct google_protobuf_Duration*)_upb_Message_New(&google_protobuf_Duration_msginit, arena);
@@ -2626,7 +3802,7 @@ UPB_INLINE void validate_DurationRules_set_gte(validate_DurationRules *msg, stru
   _upb_sethas(msg, 6);
   *UPB_PTR_AT(msg, UPB_SIZE(20, 40), struct google_protobuf_Duration*) = value;
 }
-UPB_INLINE struct google_protobuf_Duration* validate_DurationRules_mutable_gte(validate_DurationRules *msg, upb_Arena *arena) {
+UPB_INLINE struct google_protobuf_Duration* validate_DurationRules_mutable_gte(validate_DurationRules* msg, upb_Arena* arena) {
   struct google_protobuf_Duration* sub = (struct google_protobuf_Duration*)validate_DurationRules_gte(msg);
   if (sub == NULL) {
     sub = (struct google_protobuf_Duration*)_upb_Message_New(&google_protobuf_Duration_msginit, arena);
@@ -2635,29 +3811,27 @@ UPB_INLINE struct google_protobuf_Duration* validate_DurationRules_mutable_gte(v
   }
   return sub;
 }
-UPB_INLINE struct google_protobuf_Duration** validate_DurationRules_mutable_in(validate_DurationRules *msg, size_t *len) {
+UPB_INLINE struct google_protobuf_Duration** validate_DurationRules_mutable_in(validate_DurationRules* msg, size_t* len) {
   return (struct google_protobuf_Duration**)_upb_array_mutable_accessor(msg, UPB_SIZE(24, 48), len);
 }
-UPB_INLINE struct google_protobuf_Duration** validate_DurationRules_resize_in(validate_DurationRules *msg, size_t len, upb_Arena *arena) {
+UPB_INLINE struct google_protobuf_Duration** validate_DurationRules_resize_in(validate_DurationRules* msg, size_t len, upb_Arena* arena) {
   return (struct google_protobuf_Duration**)_upb_Array_Resize_accessor2(msg, UPB_SIZE(24, 48), len, UPB_SIZE(2, 3), arena);
 }
-UPB_INLINE struct google_protobuf_Duration* validate_DurationRules_add_in(validate_DurationRules *msg, upb_Arena *arena) {
+UPB_INLINE struct google_protobuf_Duration* validate_DurationRules_add_in(validate_DurationRules* msg, upb_Arena* arena) {
   struct google_protobuf_Duration* sub = (struct google_protobuf_Duration*)_upb_Message_New(&google_protobuf_Duration_msginit, arena);
-  bool ok = _upb_Array_Append_accessor2(
-      msg, UPB_SIZE(24, 48), UPB_SIZE(2, 3), &sub, arena);
+  bool ok = _upb_Array_Append_accessor2(msg, UPB_SIZE(24, 48), UPB_SIZE(2, 3), &sub, arena);
   if (!ok) return NULL;
   return sub;
 }
-UPB_INLINE struct google_protobuf_Duration** validate_DurationRules_mutable_not_in(validate_DurationRules *msg, size_t *len) {
+UPB_INLINE struct google_protobuf_Duration** validate_DurationRules_mutable_not_in(validate_DurationRules* msg, size_t* len) {
   return (struct google_protobuf_Duration**)_upb_array_mutable_accessor(msg, UPB_SIZE(28, 56), len);
 }
-UPB_INLINE struct google_protobuf_Duration** validate_DurationRules_resize_not_in(validate_DurationRules *msg, size_t len, upb_Arena *arena) {
+UPB_INLINE struct google_protobuf_Duration** validate_DurationRules_resize_not_in(validate_DurationRules* msg, size_t len, upb_Arena* arena) {
   return (struct google_protobuf_Duration**)_upb_Array_Resize_accessor2(msg, UPB_SIZE(28, 56), len, UPB_SIZE(2, 3), arena);
 }
-UPB_INLINE struct google_protobuf_Duration* validate_DurationRules_add_not_in(validate_DurationRules *msg, upb_Arena *arena) {
+UPB_INLINE struct google_protobuf_Duration* validate_DurationRules_add_not_in(validate_DurationRules* msg, upb_Arena* arena) {
   struct google_protobuf_Duration* sub = (struct google_protobuf_Duration*)_upb_Message_New(&google_protobuf_Duration_msginit, arena);
-  bool ok = _upb_Array_Append_accessor2(
-      msg, UPB_SIZE(28, 56), UPB_SIZE(2, 3), &sub, arena);
+  bool ok = _upb_Array_Append_accessor2(msg, UPB_SIZE(28, 56), UPB_SIZE(2, 3), &sub, arena);
   if (!ok) return NULL;
   return sub;
 }
@@ -2687,45 +3861,97 @@ 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);
+}
+UPB_INLINE void validate_TimestampRules_clear_required(const validate_TimestampRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(2, 2), bool) = 0;
+  _upb_clearhas(msg, 1);
 }
-UPB_INLINE bool validate_TimestampRules_has_required(const validate_TimestampRules *msg) { return _upb_hasbit(msg, 1); }
 UPB_INLINE bool validate_TimestampRules_required(const validate_TimestampRules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(2, 2), bool);
 }
-UPB_INLINE bool validate_TimestampRules_has_const(const validate_TimestampRules *msg) { return _upb_hasbit(msg, 2); }
+UPB_INLINE bool validate_TimestampRules_has_const(const validate_TimestampRules* msg) {
+  return _upb_hasbit(msg, 2);
+}
+UPB_INLINE void validate_TimestampRules_clear_const(const validate_TimestampRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(8, 8), const upb_Message*) = NULL;
+}
 UPB_INLINE const struct google_protobuf_Timestamp* validate_TimestampRules_const(const validate_TimestampRules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(8, 8), const struct google_protobuf_Timestamp*);
 }
-UPB_INLINE bool validate_TimestampRules_has_lt(const validate_TimestampRules *msg) { return _upb_hasbit(msg, 3); }
+UPB_INLINE bool validate_TimestampRules_has_lt(const validate_TimestampRules* msg) {
+  return _upb_hasbit(msg, 3);
+}
+UPB_INLINE void validate_TimestampRules_clear_lt(const validate_TimestampRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(12, 16), const upb_Message*) = NULL;
+}
 UPB_INLINE const struct google_protobuf_Timestamp* validate_TimestampRules_lt(const validate_TimestampRules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(12, 16), const struct google_protobuf_Timestamp*);
 }
-UPB_INLINE bool validate_TimestampRules_has_lte(const validate_TimestampRules *msg) { return _upb_hasbit(msg, 4); }
+UPB_INLINE bool validate_TimestampRules_has_lte(const validate_TimestampRules* msg) {
+  return _upb_hasbit(msg, 4);
+}
+UPB_INLINE void validate_TimestampRules_clear_lte(const validate_TimestampRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(16, 24), const upb_Message*) = NULL;
+}
 UPB_INLINE const struct google_protobuf_Timestamp* validate_TimestampRules_lte(const validate_TimestampRules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(16, 24), const struct google_protobuf_Timestamp*);
 }
-UPB_INLINE bool validate_TimestampRules_has_gt(const validate_TimestampRules *msg) { return _upb_hasbit(msg, 5); }
+UPB_INLINE bool validate_TimestampRules_has_gt(const validate_TimestampRules* msg) {
+  return _upb_hasbit(msg, 5);
+}
+UPB_INLINE void validate_TimestampRules_clear_gt(const validate_TimestampRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(20, 32), const upb_Message*) = NULL;
+}
 UPB_INLINE const struct google_protobuf_Timestamp* validate_TimestampRules_gt(const validate_TimestampRules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(20, 32), const struct google_protobuf_Timestamp*);
 }
-UPB_INLINE bool validate_TimestampRules_has_gte(const validate_TimestampRules *msg) { return _upb_hasbit(msg, 6); }
+UPB_INLINE bool validate_TimestampRules_has_gte(const validate_TimestampRules* msg) {
+  return _upb_hasbit(msg, 6);
+}
+UPB_INLINE void validate_TimestampRules_clear_gte(const validate_TimestampRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(24, 40), const upb_Message*) = NULL;
+}
 UPB_INLINE const struct google_protobuf_Timestamp* validate_TimestampRules_gte(const validate_TimestampRules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(24, 40), const struct google_protobuf_Timestamp*);
 }
-UPB_INLINE bool validate_TimestampRules_has_lt_now(const validate_TimestampRules *msg) { return _upb_hasbit(msg, 7); }
+UPB_INLINE bool validate_TimestampRules_has_lt_now(const validate_TimestampRules* msg) {
+  return _upb_hasbit(msg, 7);
+}
+UPB_INLINE void validate_TimestampRules_clear_lt_now(const validate_TimestampRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(3, 3), bool) = 0;
+  _upb_clearhas(msg, 7);
+}
 UPB_INLINE bool validate_TimestampRules_lt_now(const validate_TimestampRules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(3, 3), bool);
 }
-UPB_INLINE bool validate_TimestampRules_has_gt_now(const validate_TimestampRules *msg) { return _upb_hasbit(msg, 8); }
+UPB_INLINE bool validate_TimestampRules_has_gt_now(const validate_TimestampRules* msg) {
+  return _upb_hasbit(msg, 8);
+}
+UPB_INLINE void validate_TimestampRules_clear_gt_now(const validate_TimestampRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(4, 4), bool) = 0;
+  _upb_clearhas(msg, 8);
+}
 UPB_INLINE bool validate_TimestampRules_gt_now(const validate_TimestampRules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(4, 4), bool);
 }
-UPB_INLINE bool validate_TimestampRules_has_within(const validate_TimestampRules *msg) { return _upb_hasbit(msg, 9); }
+UPB_INLINE bool validate_TimestampRules_has_within(const validate_TimestampRules* msg) {
+  return _upb_hasbit(msg, 9);
+}
+UPB_INLINE void validate_TimestampRules_clear_within(const validate_TimestampRules* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(28, 48), const upb_Message*) = NULL;
+}
 UPB_INLINE const struct google_protobuf_Duration* validate_TimestampRules_within(const validate_TimestampRules* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(28, 48), const struct google_protobuf_Duration*);
 }
@@ -2738,7 +3964,7 @@ UPB_INLINE void validate_TimestampRules_set_const(validate_TimestampRules *msg,
   _upb_sethas(msg, 2);
   *UPB_PTR_AT(msg, UPB_SIZE(8, 8), struct google_protobuf_Timestamp*) = value;
 }
-UPB_INLINE struct google_protobuf_Timestamp* validate_TimestampRules_mutable_const(validate_TimestampRules *msg, upb_Arena *arena) {
+UPB_INLINE struct google_protobuf_Timestamp* validate_TimestampRules_mutable_const(validate_TimestampRules* msg, upb_Arena* arena) {
   struct google_protobuf_Timestamp* sub = (struct google_protobuf_Timestamp*)validate_TimestampRules_const(msg);
   if (sub == NULL) {
     sub = (struct google_protobuf_Timestamp*)_upb_Message_New(&google_protobuf_Timestamp_msginit, arena);
@@ -2751,7 +3977,7 @@ UPB_INLINE void validate_TimestampRules_set_lt(validate_TimestampRules *msg, str
   _upb_sethas(msg, 3);
   *UPB_PTR_AT(msg, UPB_SIZE(12, 16), struct google_protobuf_Timestamp*) = value;
 }
-UPB_INLINE struct google_protobuf_Timestamp* validate_TimestampRules_mutable_lt(validate_TimestampRules *msg, upb_Arena *arena) {
+UPB_INLINE struct google_protobuf_Timestamp* validate_TimestampRules_mutable_lt(validate_TimestampRules* msg, upb_Arena* arena) {
   struct google_protobuf_Timestamp* sub = (struct google_protobuf_Timestamp*)validate_TimestampRules_lt(msg);
   if (sub == NULL) {
     sub = (struct google_protobuf_Timestamp*)_upb_Message_New(&google_protobuf_Timestamp_msginit, arena);
@@ -2764,7 +3990,7 @@ UPB_INLINE void validate_TimestampRules_set_lte(validate_TimestampRules *msg, st
   _upb_sethas(msg, 4);
   *UPB_PTR_AT(msg, UPB_SIZE(16, 24), struct google_protobuf_Timestamp*) = value;
 }
-UPB_INLINE struct google_protobuf_Timestamp* validate_TimestampRules_mutable_lte(validate_TimestampRules *msg, upb_Arena *arena) {
+UPB_INLINE struct google_protobuf_Timestamp* validate_TimestampRules_mutable_lte(validate_TimestampRules* msg, upb_Arena* arena) {
   struct google_protobuf_Timestamp* sub = (struct google_protobuf_Timestamp*)validate_TimestampRules_lte(msg);
   if (sub == NULL) {
     sub = (struct google_protobuf_Timestamp*)_upb_Message_New(&google_protobuf_Timestamp_msginit, arena);
@@ -2777,7 +4003,7 @@ UPB_INLINE void validate_TimestampRules_set_gt(validate_TimestampRules *msg, str
   _upb_sethas(msg, 5);
   *UPB_PTR_AT(msg, UPB_SIZE(20, 32), struct google_protobuf_Timestamp*) = value;
 }
-UPB_INLINE struct google_protobuf_Timestamp* validate_TimestampRules_mutable_gt(validate_TimestampRules *msg, upb_Arena *arena) {
+UPB_INLINE struct google_protobuf_Timestamp* validate_TimestampRules_mutable_gt(validate_TimestampRules* msg, upb_Arena* arena) {
   struct google_protobuf_Timestamp* sub = (struct google_protobuf_Timestamp*)validate_TimestampRules_gt(msg);
   if (sub == NULL) {
     sub = (struct google_protobuf_Timestamp*)_upb_Message_New(&google_protobuf_Timestamp_msginit, arena);
@@ -2790,7 +4016,7 @@ UPB_INLINE void validate_TimestampRules_set_gte(validate_TimestampRules *msg, st
   _upb_sethas(msg, 6);
   *UPB_PTR_AT(msg, UPB_SIZE(24, 40), struct google_protobuf_Timestamp*) = value;
 }
-UPB_INLINE struct google_protobuf_Timestamp* validate_TimestampRules_mutable_gte(validate_TimestampRules *msg, upb_Arena *arena) {
+UPB_INLINE struct google_protobuf_Timestamp* validate_TimestampRules_mutable_gte(validate_TimestampRules* msg, upb_Arena* arena) {
   struct google_protobuf_Timestamp* sub = (struct google_protobuf_Timestamp*)validate_TimestampRules_gte(msg);
   if (sub == NULL) {
     sub = (struct google_protobuf_Timestamp*)_upb_Message_New(&google_protobuf_Timestamp_msginit, arena);
@@ -2811,7 +4037,7 @@ UPB_INLINE void validate_TimestampRules_set_within(validate_TimestampRules *msg,
   _upb_sethas(msg, 9);
   *UPB_PTR_AT(msg, UPB_SIZE(28, 48), struct google_protobuf_Duration*) = value;
 }
-UPB_INLINE struct google_protobuf_Duration* validate_TimestampRules_mutable_within(validate_TimestampRules *msg, upb_Arena *arena) {
+UPB_INLINE struct google_protobuf_Duration* validate_TimestampRules_mutable_within(validate_TimestampRules* msg, upb_Arena* arena) {
   struct google_protobuf_Duration* sub = (struct google_protobuf_Duration*)validate_TimestampRules_within(msg);
   if (sub == NULL) {
     sub = (struct google_protobuf_Duration*)_upb_Message_New(&google_protobuf_Duration_msginit, arena);
@@ -2821,14 +4047,53 @@ UPB_INLINE struct google_protobuf_Duration* validate_TimestampRules_mutable_with
   return sub;
 }
 
-UPB_INLINE bool validate_has_disabled(const struct google_protobuf_MessageOptions *msg) { return _upb_Message_Getext(msg, &validate_disabled_ext) != NULL; }
-UPB_INLINE bool validate_disabled(const struct google_protobuf_MessageOptions *msg) { const upb_Message_Extension *ext = _upb_Message_Getext(msg, &validate_disabled_ext); return ext ? *UPB_PTR_AT(&ext->data, 0, bool) : false; }
-UPB_INLINE bool validate_has_ignored(const struct google_protobuf_MessageOptions *msg) { return _upb_Message_Getext(msg, &validate_ignored_ext) != NULL; }
-UPB_INLINE bool validate_ignored(const struct google_protobuf_MessageOptions *msg) { const upb_Message_Extension *ext = _upb_Message_Getext(msg, &validate_ignored_ext); return ext ? *UPB_PTR_AT(&ext->data, 0, bool) : false; }
-UPB_INLINE bool validate_has_required(const struct google_protobuf_OneofOptions *msg) { return _upb_Message_Getext(msg, &validate_required_ext) != NULL; }
-UPB_INLINE bool validate_required(const struct google_protobuf_OneofOptions *msg) { const upb_Message_Extension *ext = _upb_Message_Getext(msg, &validate_required_ext); return ext ? *UPB_PTR_AT(&ext->data, 0, bool) : false; }
-UPB_INLINE bool validate_has_rules(const struct google_protobuf_FieldOptions *msg) { return _upb_Message_Getext(msg, &validate_rules_ext) != NULL; }
-UPB_INLINE const validate_FieldRules* validate_rules(const struct google_protobuf_FieldOptions *msg) { const upb_Message_Extension *ext = _upb_Message_Getext(msg, &validate_rules_ext); UPB_ASSERT(ext); return *UPB_PTR_AT(&ext->data, 0, const validate_FieldRules*); }
+UPB_INLINE bool validate_has_disabled(const struct google_protobuf_MessageOptions* msg) {
+  return _upb_Message_Getext(msg, &validate_disabled_ext) != NULL;
+}
+UPB_INLINE void validate_clear_disabled(struct google_protobuf_MessageOptions* msg) {
+  _upb_Message_Clearext(msg, &validate_disabled_ext);
+}
+UPB_INLINE bool validate_disabled(const struct google_protobuf_MessageOptions* msg) {
+  const upb_Message_Extension* ext = _upb_Message_Getext(msg, &validate_disabled_ext);
+  return ext ? *UPB_PTR_AT(&ext->data, 0, bool) : false;
+}
+UPB_INLINE bool validate_has_ignored(const struct google_protobuf_MessageOptions* msg) {
+  return _upb_Message_Getext(msg, &validate_ignored_ext) != NULL;
+}
+UPB_INLINE void validate_clear_ignored(struct google_protobuf_MessageOptions* msg) {
+  _upb_Message_Clearext(msg, &validate_ignored_ext);
+}
+UPB_INLINE bool validate_ignored(const struct google_protobuf_MessageOptions* msg) {
+  const upb_Message_Extension* ext = _upb_Message_Getext(msg, &validate_ignored_ext);
+  return ext ? *UPB_PTR_AT(&ext->data, 0, bool) : false;
+}
+UPB_INLINE bool validate_has_required(const struct google_protobuf_OneofOptions* msg) {
+  return _upb_Message_Getext(msg, &validate_required_ext) != NULL;
+}
+UPB_INLINE void validate_clear_required(struct google_protobuf_OneofOptions* msg) {
+  _upb_Message_Clearext(msg, &validate_required_ext);
+}
+UPB_INLINE bool validate_required(const struct google_protobuf_OneofOptions* msg) {
+  const upb_Message_Extension* ext = _upb_Message_Getext(msg, &validate_required_ext);
+  return ext ? *UPB_PTR_AT(&ext->data, 0, bool) : false;
+}
+UPB_INLINE bool validate_has_rules(const struct google_protobuf_FieldOptions* msg) {
+  return _upb_Message_Getext(msg, &validate_rules_ext) != NULL;
+}
+UPB_INLINE void validate_clear_rules(struct google_protobuf_FieldOptions* msg) {
+  _upb_Message_Clearext(msg, &validate_rules_ext);
+}
+UPB_INLINE const validate_FieldRules* validate_rules(const struct google_protobuf_FieldOptions* msg) {
+  const upb_Message_Extension* ext = _upb_Message_Getext(msg, &validate_rules_ext);
+  UPB_ASSERT(ext);
+  return *UPB_PTR_AT(&ext->data, 0, const validate_FieldRules*);
+}
+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_GetOrCreateExtension(msg, &validate_rules_ext, arena);
+  UPB_ASSERT(msg_ext);
+  *UPB_PTR_AT(&msg_ext->data, 0, const validate_FieldRules*) = ext;
+}
 extern const upb_MiniTable_File validate_validate_proto_upb_file_layout;
 
 #ifdef __cplusplus