grpc 1.39.0 → 1.40.0.pre1

data/src/core/ext/upb-generated/envoy/type/matcher/v3/regex.upb.c

@@ -10,6 +10,7 @@
 #include "upb/msg.h"
 #include "envoy/type/matcher/v3/regex.upb.h"
 #include "google/protobuf/wrappers.upb.h"
+#include "envoy/annotations/deprecation.upb.h"
 #include "udpa/annotations/status.upb.h"
 #include "udpa/annotations/versioning.upb.h"
 #include "validate/validate.upb.h"

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

@@ -71,196 +71,208 @@ const upb_msglayout validate_FieldRules_msginit = {
   UPB_SIZE(16, 32), 22, false, 255,
 };
 
-static const upb_msglayout_field validate_FloatRules__fields[7] = {
+static const upb_msglayout_field validate_FloatRules__fields[8] = {
   {1, UPB_SIZE(4, 4), 1, 0, 2, 1},
   {2, UPB_SIZE(8, 8), 2, 0, 2, 1},
   {3, UPB_SIZE(12, 12), 3, 0, 2, 1},
   {4, UPB_SIZE(16, 16), 4, 0, 2, 1},
   {5, UPB_SIZE(20, 20), 5, 0, 2, 1},
-  {6, UPB_SIZE(24, 24), 0, 0, 2, 3},
-  {7, UPB_SIZE(28, 32), 0, 0, 2, 3},
+  {6, UPB_SIZE(28, 32), 0, 0, 2, 3},
+  {7, UPB_SIZE(32, 40), 0, 0, 2, 3},
+  {8, UPB_SIZE(24, 24), 6, 0, 8, 1},
 };
 
 const upb_msglayout validate_FloatRules_msginit = {
   NULL,
   &validate_FloatRules__fields[0],
-  UPB_SIZE(32, 40), 7, false, 255,
+  UPB_SIZE(40, 48), 8, false, 255,
 };
 
-static const upb_msglayout_field validate_DoubleRules__fields[7] = {
+static const upb_msglayout_field validate_DoubleRules__fields[8] = {
   {1, UPB_SIZE(8, 8), 1, 0, 1, 1},
   {2, UPB_SIZE(16, 16), 2, 0, 1, 1},
   {3, UPB_SIZE(24, 24), 3, 0, 1, 1},
   {4, UPB_SIZE(32, 32), 4, 0, 1, 1},
   {5, UPB_SIZE(40, 40), 5, 0, 1, 1},
-  {6, UPB_SIZE(48, 48), 0, 0, 1, 3},
-  {7, UPB_SIZE(52, 56), 0, 0, 1, 3},
+  {6, UPB_SIZE(52, 56), 0, 0, 1, 3},
+  {7, UPB_SIZE(56, 64), 0, 0, 1, 3},
+  {8, UPB_SIZE(48, 48), 6, 0, 8, 1},
 };
 
 const upb_msglayout validate_DoubleRules_msginit = {
   NULL,
   &validate_DoubleRules__fields[0],
-  UPB_SIZE(56, 64), 7, false, 255,
+  UPB_SIZE(64, 72), 8, false, 255,
 };
 
-static const upb_msglayout_field validate_Int32Rules__fields[7] = {
+static const upb_msglayout_field validate_Int32Rules__fields[8] = {
   {1, UPB_SIZE(4, 4), 1, 0, 5, 1},
   {2, UPB_SIZE(8, 8), 2, 0, 5, 1},
   {3, UPB_SIZE(12, 12), 3, 0, 5, 1},
   {4, UPB_SIZE(16, 16), 4, 0, 5, 1},
   {5, UPB_SIZE(20, 20), 5, 0, 5, 1},
-  {6, UPB_SIZE(24, 24), 0, 0, 5, 3},
-  {7, UPB_SIZE(28, 32), 0, 0, 5, 3},
+  {6, UPB_SIZE(28, 32), 0, 0, 5, 3},
+  {7, UPB_SIZE(32, 40), 0, 0, 5, 3},
+  {8, UPB_SIZE(24, 24), 6, 0, 8, 1},
 };
 
 const upb_msglayout validate_Int32Rules_msginit = {
   NULL,
   &validate_Int32Rules__fields[0],
-  UPB_SIZE(32, 40), 7, false, 255,
+  UPB_SIZE(40, 48), 8, false, 255,
 };
 
-static const upb_msglayout_field validate_Int64Rules__fields[7] = {
+static const upb_msglayout_field validate_Int64Rules__fields[8] = {
   {1, UPB_SIZE(8, 8), 1, 0, 3, 1},
   {2, UPB_SIZE(16, 16), 2, 0, 3, 1},
   {3, UPB_SIZE(24, 24), 3, 0, 3, 1},
   {4, UPB_SIZE(32, 32), 4, 0, 3, 1},
   {5, UPB_SIZE(40, 40), 5, 0, 3, 1},
-  {6, UPB_SIZE(48, 48), 0, 0, 3, 3},
-  {7, UPB_SIZE(52, 56), 0, 0, 3, 3},
+  {6, UPB_SIZE(52, 56), 0, 0, 3, 3},
+  {7, UPB_SIZE(56, 64), 0, 0, 3, 3},
+  {8, UPB_SIZE(48, 48), 6, 0, 8, 1},
 };
 
 const upb_msglayout validate_Int64Rules_msginit = {
   NULL,
   &validate_Int64Rules__fields[0],
-  UPB_SIZE(56, 64), 7, false, 255,
+  UPB_SIZE(64, 72), 8, false, 255,
 };
 
-static const upb_msglayout_field validate_UInt32Rules__fields[7] = {
+static const upb_msglayout_field validate_UInt32Rules__fields[8] = {
   {1, UPB_SIZE(4, 4), 1, 0, 13, 1},
   {2, UPB_SIZE(8, 8), 2, 0, 13, 1},
   {3, UPB_SIZE(12, 12), 3, 0, 13, 1},
   {4, UPB_SIZE(16, 16), 4, 0, 13, 1},
   {5, UPB_SIZE(20, 20), 5, 0, 13, 1},
-  {6, UPB_SIZE(24, 24), 0, 0, 13, 3},
-  {7, UPB_SIZE(28, 32), 0, 0, 13, 3},
+  {6, UPB_SIZE(28, 32), 0, 0, 13, 3},
+  {7, UPB_SIZE(32, 40), 0, 0, 13, 3},
+  {8, UPB_SIZE(24, 24), 6, 0, 8, 1},
 };
 
 const upb_msglayout validate_UInt32Rules_msginit = {
   NULL,
   &validate_UInt32Rules__fields[0],
-  UPB_SIZE(32, 40), 7, false, 255,
+  UPB_SIZE(40, 48), 8, false, 255,
 };
 
-static const upb_msglayout_field validate_UInt64Rules__fields[7] = {
+static const upb_msglayout_field validate_UInt64Rules__fields[8] = {
   {1, UPB_SIZE(8, 8), 1, 0, 4, 1},
   {2, UPB_SIZE(16, 16), 2, 0, 4, 1},
   {3, UPB_SIZE(24, 24), 3, 0, 4, 1},
   {4, UPB_SIZE(32, 32), 4, 0, 4, 1},
   {5, UPB_SIZE(40, 40), 5, 0, 4, 1},
-  {6, UPB_SIZE(48, 48), 0, 0, 4, 3},
-  {7, UPB_SIZE(52, 56), 0, 0, 4, 3},
+  {6, UPB_SIZE(52, 56), 0, 0, 4, 3},
+  {7, UPB_SIZE(56, 64), 0, 0, 4, 3},
+  {8, UPB_SIZE(48, 48), 6, 0, 8, 1},
 };
 
 const upb_msglayout validate_UInt64Rules_msginit = {
   NULL,
   &validate_UInt64Rules__fields[0],
-  UPB_SIZE(56, 64), 7, false, 255,
+  UPB_SIZE(64, 72), 8, false, 255,
 };
 
-static const upb_msglayout_field validate_SInt32Rules__fields[7] = {
+static const upb_msglayout_field validate_SInt32Rules__fields[8] = {
   {1, UPB_SIZE(4, 4), 1, 0, 17, 1},
   {2, UPB_SIZE(8, 8), 2, 0, 17, 1},
   {3, UPB_SIZE(12, 12), 3, 0, 17, 1},
   {4, UPB_SIZE(16, 16), 4, 0, 17, 1},
   {5, UPB_SIZE(20, 20), 5, 0, 17, 1},
-  {6, UPB_SIZE(24, 24), 0, 0, 17, 3},
-  {7, UPB_SIZE(28, 32), 0, 0, 17, 3},
+  {6, UPB_SIZE(28, 32), 0, 0, 17, 3},
+  {7, UPB_SIZE(32, 40), 0, 0, 17, 3},
+  {8, UPB_SIZE(24, 24), 6, 0, 8, 1},
 };
 
 const upb_msglayout validate_SInt32Rules_msginit = {
   NULL,
   &validate_SInt32Rules__fields[0],
-  UPB_SIZE(32, 40), 7, false, 255,
+  UPB_SIZE(40, 48), 8, false, 255,
 };
 
-static const upb_msglayout_field validate_SInt64Rules__fields[7] = {
+static const upb_msglayout_field validate_SInt64Rules__fields[8] = {
   {1, UPB_SIZE(8, 8), 1, 0, 18, 1},
   {2, UPB_SIZE(16, 16), 2, 0, 18, 1},
   {3, UPB_SIZE(24, 24), 3, 0, 18, 1},
   {4, UPB_SIZE(32, 32), 4, 0, 18, 1},
   {5, UPB_SIZE(40, 40), 5, 0, 18, 1},
-  {6, UPB_SIZE(48, 48), 0, 0, 18, 3},
-  {7, UPB_SIZE(52, 56), 0, 0, 18, 3},
+  {6, UPB_SIZE(52, 56), 0, 0, 18, 3},
+  {7, UPB_SIZE(56, 64), 0, 0, 18, 3},
+  {8, UPB_SIZE(48, 48), 6, 0, 8, 1},
 };
 
 const upb_msglayout validate_SInt64Rules_msginit = {
   NULL,
   &validate_SInt64Rules__fields[0],
-  UPB_SIZE(56, 64), 7, false, 255,
+  UPB_SIZE(64, 72), 8, false, 255,
 };
 
-static const upb_msglayout_field validate_Fixed32Rules__fields[7] = {
+static const upb_msglayout_field validate_Fixed32Rules__fields[8] = {
   {1, UPB_SIZE(4, 4), 1, 0, 7, 1},
   {2, UPB_SIZE(8, 8), 2, 0, 7, 1},
   {3, UPB_SIZE(12, 12), 3, 0, 7, 1},
   {4, UPB_SIZE(16, 16), 4, 0, 7, 1},
   {5, UPB_SIZE(20, 20), 5, 0, 7, 1},
-  {6, UPB_SIZE(24, 24), 0, 0, 7, 3},
-  {7, UPB_SIZE(28, 32), 0, 0, 7, 3},
+  {6, UPB_SIZE(28, 32), 0, 0, 7, 3},
+  {7, UPB_SIZE(32, 40), 0, 0, 7, 3},
+  {8, UPB_SIZE(24, 24), 6, 0, 8, 1},
 };
 
 const upb_msglayout validate_Fixed32Rules_msginit = {
   NULL,
   &validate_Fixed32Rules__fields[0],
-  UPB_SIZE(32, 40), 7, false, 255,
+  UPB_SIZE(40, 48), 8, false, 255,
 };
 
-static const upb_msglayout_field validate_Fixed64Rules__fields[7] = {
+static const upb_msglayout_field validate_Fixed64Rules__fields[8] = {
   {1, UPB_SIZE(8, 8), 1, 0, 6, 1},
   {2, UPB_SIZE(16, 16), 2, 0, 6, 1},
   {3, UPB_SIZE(24, 24), 3, 0, 6, 1},
   {4, UPB_SIZE(32, 32), 4, 0, 6, 1},
   {5, UPB_SIZE(40, 40), 5, 0, 6, 1},
-  {6, UPB_SIZE(48, 48), 0, 0, 6, 3},
-  {7, UPB_SIZE(52, 56), 0, 0, 6, 3},
+  {6, UPB_SIZE(52, 56), 0, 0, 6, 3},
+  {7, UPB_SIZE(56, 64), 0, 0, 6, 3},
+  {8, UPB_SIZE(48, 48), 6, 0, 8, 1},
 };
 
 const upb_msglayout validate_Fixed64Rules_msginit = {
   NULL,
   &validate_Fixed64Rules__fields[0],
-  UPB_SIZE(56, 64), 7, false, 255,
+  UPB_SIZE(64, 72), 8, false, 255,
 };
 
-static const upb_msglayout_field validate_SFixed32Rules__fields[7] = {
+static const upb_msglayout_field validate_SFixed32Rules__fields[8] = {
   {1, UPB_SIZE(4, 4), 1, 0, 15, 1},
   {2, UPB_SIZE(8, 8), 2, 0, 15, 1},
   {3, UPB_SIZE(12, 12), 3, 0, 15, 1},
   {4, UPB_SIZE(16, 16), 4, 0, 15, 1},
   {5, UPB_SIZE(20, 20), 5, 0, 15, 1},
-  {6, UPB_SIZE(24, 24), 0, 0, 15, 3},
-  {7, UPB_SIZE(28, 32), 0, 0, 15, 3},
+  {6, UPB_SIZE(28, 32), 0, 0, 15, 3},
+  {7, UPB_SIZE(32, 40), 0, 0, 15, 3},
+  {8, UPB_SIZE(24, 24), 6, 0, 8, 1},
 };
 
 const upb_msglayout validate_SFixed32Rules_msginit = {
   NULL,
   &validate_SFixed32Rules__fields[0],
-  UPB_SIZE(32, 40), 7, false, 255,
+  UPB_SIZE(40, 48), 8, false, 255,
 };
 
-static const upb_msglayout_field validate_SFixed64Rules__fields[7] = {
+static const upb_msglayout_field validate_SFixed64Rules__fields[8] = {
   {1, UPB_SIZE(8, 8), 1, 0, 16, 1},
   {2, UPB_SIZE(16, 16), 2, 0, 16, 1},
   {3, UPB_SIZE(24, 24), 3, 0, 16, 1},
   {4, UPB_SIZE(32, 32), 4, 0, 16, 1},
   {5, UPB_SIZE(40, 40), 5, 0, 16, 1},
-  {6, UPB_SIZE(48, 48), 0, 0, 16, 3},
-  {7, UPB_SIZE(52, 56), 0, 0, 16, 3},
+  {6, UPB_SIZE(52, 56), 0, 0, 16, 3},
+  {7, UPB_SIZE(56, 64), 0, 0, 16, 3},
+  {8, UPB_SIZE(48, 48), 6, 0, 8, 1},
 };
 
 const upb_msglayout validate_SFixed64Rules_msginit = {
   NULL,
   &validate_SFixed64Rules__fields[0],
-  UPB_SIZE(56, 64), 7, false, 255,
+  UPB_SIZE(64, 72), 8, false, 255,
 };
 
 static const upb_msglayout_field validate_BoolRules__fields[1] = {
@@ -273,7 +285,7 @@ const upb_msglayout validate_BoolRules_msginit = {
   UPB_SIZE(8, 8), 1, false, 255,
 };
 
-static const upb_msglayout_field validate_StringRules__fields[25] = {
+static const upb_msglayout_field validate_StringRules__fields[26] = {
   {1, UPB_SIZE(60, 64), 1, 0, 12, 1},
   {2, UPB_SIZE(8, 8), 2, 0, 4, 1},
   {3, UPB_SIZE(16, 16), 3, 0, 4, 1},
@@ -299,34 +311,36 @@ static const upb_msglayout_field validate_StringRules__fields[25] = {
   {23, UPB_SIZE(100, 144), 12, 0, 12, 1},
   {24, UPB_SIZE(116, 176), UPB_SIZE(-121, -181), 0, 14, 1},
   {25, UPB_SIZE(56, 56), 13, 0, 8, 1},
+  {26, UPB_SIZE(57, 57), 14, 0, 8, 1},
 };
 
 const upb_msglayout validate_StringRules_msginit = {
   NULL,
   &validate_StringRules__fields[0],
-  UPB_SIZE(128, 192), 25, false, 255,
+  UPB_SIZE(128, 192), 26, false, 255,
 };
 
-static const upb_msglayout_field validate_BytesRules__fields[13] = {
-  {1, UPB_SIZE(32, 32), 1, 0, 12, 1},
+static const upb_msglayout_field validate_BytesRules__fields[14] = {
+  {1, UPB_SIZE(36, 40), 1, 0, 12, 1},
   {2, UPB_SIZE(8, 8), 2, 0, 4, 1},
   {3, UPB_SIZE(16, 16), 3, 0, 4, 1},
-  {4, UPB_SIZE(40, 48), 4, 0, 12, 1},
-  {5, UPB_SIZE(48, 64), 5, 0, 12, 1},
-  {6, UPB_SIZE(56, 80), 6, 0, 12, 1},
-  {7, UPB_SIZE(64, 96), 7, 0, 12, 1},
-  {8, UPB_SIZE(72, 112), 0, 0, 12, 3},
-  {9, UPB_SIZE(76, 120), 0, 0, 12, 3},
-  {10, UPB_SIZE(80, 128), UPB_SIZE(-85, -133), 0, 8, 1},
-  {11, UPB_SIZE(80, 128), UPB_SIZE(-85, -133), 0, 8, 1},
-  {12, UPB_SIZE(80, 128), UPB_SIZE(-85, -133), 0, 8, 1},
+  {4, UPB_SIZE(44, 56), 4, 0, 12, 1},
+  {5, UPB_SIZE(52, 72), 5, 0, 12, 1},
+  {6, UPB_SIZE(60, 88), 6, 0, 12, 1},
+  {7, UPB_SIZE(68, 104), 7, 0, 12, 1},
+  {8, UPB_SIZE(76, 120), 0, 0, 12, 3},
+  {9, UPB_SIZE(80, 128), 0, 0, 12, 3},
+  {10, UPB_SIZE(84, 136), UPB_SIZE(-89, -141), 0, 8, 1},
+  {11, UPB_SIZE(84, 136), UPB_SIZE(-89, -141), 0, 8, 1},
+  {12, UPB_SIZE(84, 136), UPB_SIZE(-89, -141), 0, 8, 1},
   {13, UPB_SIZE(24, 24), 8, 0, 4, 1},
+  {14, UPB_SIZE(32, 32), 9, 0, 8, 1},
 };
 
 const upb_msglayout validate_BytesRules_msginit = {
   NULL,
   &validate_BytesRules__fields[0],
-  UPB_SIZE(88, 144), 13, false, 255,
+  UPB_SIZE(96, 144), 14, false, 255,
 };
 
 static const upb_msglayout_field validate_EnumRules__fields[4] = {
@@ -357,35 +371,37 @@ static const upb_msglayout *const validate_RepeatedRules_submsgs[1] = {
   &validate_FieldRules_msginit,
 };
 
-static const upb_msglayout_field validate_RepeatedRules__fields[4] = {
+static const upb_msglayout_field validate_RepeatedRules__fields[5] = {
   {1, UPB_SIZE(8, 8), 1, 0, 4, 1},
   {2, UPB_SIZE(16, 16), 2, 0, 4, 1},
   {3, UPB_SIZE(24, 24), 3, 0, 8, 1},
   {4, UPB_SIZE(28, 32), 4, 0, 11, 1},
+  {5, UPB_SIZE(25, 25), 5, 0, 8, 1},
 };
 
 const upb_msglayout validate_RepeatedRules_msginit = {
   &validate_RepeatedRules_submsgs[0],
   &validate_RepeatedRules__fields[0],
-  UPB_SIZE(32, 40), 4, false, 255,
+  UPB_SIZE(32, 40), 5, false, 255,
 };
 
 static const upb_msglayout *const validate_MapRules_submsgs[1] = {
   &validate_FieldRules_msginit,
 };
 
-static const upb_msglayout_field validate_MapRules__fields[5] = {
+static const upb_msglayout_field validate_MapRules__fields[6] = {
   {1, UPB_SIZE(8, 8), 1, 0, 4, 1},
   {2, UPB_SIZE(16, 16), 2, 0, 4, 1},
   {3, UPB_SIZE(24, 24), 3, 0, 8, 1},
   {4, UPB_SIZE(28, 32), 4, 0, 11, 1},
   {5, UPB_SIZE(32, 40), 5, 0, 11, 1},
+  {6, UPB_SIZE(25, 25), 6, 0, 8, 1},
 };
 
 const upb_msglayout validate_MapRules_msginit = {
   &validate_MapRules_submsgs[0],
   &validate_MapRules__fields[0],
-  UPB_SIZE(40, 48), 5, false, 255,
+  UPB_SIZE(40, 48), 6, false, 255,
 };
 
 static const upb_msglayout_field validate_AnyRules__fields[3] = {

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

@@ -488,8 +488,10 @@ UPB_INLINE bool validate_FloatRules_has_gt(const validate_FloatRules *msg) { ret
 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 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(24, 24), 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(28, 32), len); }
+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 bool validate_FloatRules_ignore_empty(const validate_FloatRules *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(24, 24), bool); }
 
 UPB_INLINE void validate_FloatRules_set_const(validate_FloatRules *msg, float value) {
   _upb_sethas(msg, 1);
@@ -512,25 +514,29 @@ UPB_INLINE void validate_FloatRules_set_gte(validate_FloatRules *msg, float valu
   *UPB_PTR_AT(msg, UPB_SIZE(20, 20), float) = value;
 }
 UPB_INLINE float* validate_FloatRules_mutable_in(validate_FloatRules *msg, size_t *len) {
-  return (float*)_upb_array_mutable_accessor(msg, UPB_SIZE(24, 24), 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) {
-  return (float*)_upb_array_resize_accessor2(msg, UPB_SIZE(24, 24), len, 2, 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(24, 24), 2, &val,
+  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) {
-  return (float*)_upb_array_mutable_accessor(msg, UPB_SIZE(28, 32), 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) {
-  return (float*)_upb_array_resize_accessor2(msg, UPB_SIZE(28, 32), len, 2, 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(28, 32), 2, &val,
+  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);
+  *UPB_PTR_AT(msg, UPB_SIZE(24, 24), bool) = value;
+}
 
 /* validate.DoubleRules */
 
@@ -562,8 +568,10 @@ UPB_INLINE bool validate_DoubleRules_has_gt(const validate_DoubleRules *msg) { r
 UPB_INLINE double validate_DoubleRules_gt(const validate_DoubleRules *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(32, 32), double); }
 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); }
-UPB_INLINE double const* validate_DoubleRules_in(const validate_DoubleRules *msg, size_t *len) { return (double const*)_upb_array_accessor(msg, UPB_SIZE(48, 48), 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(52, 56), len); }
+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); }
 
 UPB_INLINE void validate_DoubleRules_set_const(validate_DoubleRules *msg, double value) {
   _upb_sethas(msg, 1);
@@ -586,25 +594,29 @@ UPB_INLINE void validate_DoubleRules_set_gte(validate_DoubleRules *msg, double v
   *UPB_PTR_AT(msg, UPB_SIZE(40, 40), double) = value;
 }
 UPB_INLINE double* validate_DoubleRules_mutable_in(validate_DoubleRules *msg, size_t *len) {
-  return (double*)_upb_array_mutable_accessor(msg, UPB_SIZE(48, 48), len);
+  return (double*)_upb_array_mutable_accessor(msg, UPB_SIZE(52, 56), 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(48, 48), len, 3, arena);
+  return (double*)_upb_array_resize_accessor2(msg, UPB_SIZE(52, 56), 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(48, 48), 3, &val,
+  return _upb_array_append_accessor2(msg, UPB_SIZE(52, 56), 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(52, 56), len);
+  return (double*)_upb_array_mutable_accessor(msg, UPB_SIZE(56, 64), 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(52, 56), len, 3, arena);
+  return (double*)_upb_array_resize_accessor2(msg, UPB_SIZE(56, 64), 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(52, 56), 3, &val,
+  return _upb_array_append_accessor2(msg, UPB_SIZE(56, 64), 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;
+}
 
 /* validate.Int32Rules */
 
@@ -636,8 +648,10 @@ UPB_INLINE bool validate_Int32Rules_has_gt(const validate_Int32Rules *msg) { ret
 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 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(24, 24), 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(28, 32), len); }
+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 bool validate_Int32Rules_ignore_empty(const validate_Int32Rules *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(24, 24), bool); }
 
 UPB_INLINE void validate_Int32Rules_set_const(validate_Int32Rules *msg, int32_t value) {
   _upb_sethas(msg, 1);
@@ -660,25 +674,29 @@ UPB_INLINE void validate_Int32Rules_set_gte(validate_Int32Rules *msg, int32_t va
   *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) {
-  return (int32_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(24, 24), 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) {
-  return (int32_t*)_upb_array_resize_accessor2(msg, UPB_SIZE(24, 24), len, 2, 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(24, 24), 2, &val,
+  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) {
-  return (int32_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(28, 32), 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) {
-  return (int32_t*)_upb_array_resize_accessor2(msg, UPB_SIZE(28, 32), len, 2, 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(28, 32), 2, &val,
+  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);
+  *UPB_PTR_AT(msg, UPB_SIZE(24, 24), bool) = value;
+}
 
 /* validate.Int64Rules */
 
@@ -710,8 +728,10 @@ UPB_INLINE bool validate_Int64Rules_has_gt(const validate_Int64Rules *msg) { ret
 UPB_INLINE int64_t validate_Int64Rules_gt(const validate_Int64Rules *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(32, 32), int64_t); }
 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); }
-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(48, 48), 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(52, 56), len); }
+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); }
 
 UPB_INLINE void validate_Int64Rules_set_const(validate_Int64Rules *msg, int64_t value) {
   _upb_sethas(msg, 1);
@@ -734,25 +754,29 @@ UPB_INLINE void validate_Int64Rules_set_gte(validate_Int64Rules *msg, int64_t va
   *UPB_PTR_AT(msg, UPB_SIZE(40, 40), 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(48, 48), len);
+  return (int64_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(52, 56), 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(48, 48), len, 3, arena);
+  return (int64_t*)_upb_array_resize_accessor2(msg, UPB_SIZE(52, 56), 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(48, 48), 3, &val,
+  return _upb_array_append_accessor2(msg, UPB_SIZE(52, 56), 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(52, 56), len);
+  return (int64_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(56, 64), 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(52, 56), len, 3, arena);
+  return (int64_t*)_upb_array_resize_accessor2(msg, UPB_SIZE(56, 64), 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(52, 56), 3, &val,
+  return _upb_array_append_accessor2(msg, UPB_SIZE(56, 64), 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;
+}
 
 /* validate.UInt32Rules */
 
@@ -784,8 +808,10 @@ UPB_INLINE bool validate_UInt32Rules_has_gt(const validate_UInt32Rules *msg) { r
 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 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(24, 24), 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(28, 32), len); }
+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 bool validate_UInt32Rules_ignore_empty(const validate_UInt32Rules *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(24, 24), bool); }
 
 UPB_INLINE void validate_UInt32Rules_set_const(validate_UInt32Rules *msg, uint32_t value) {
   _upb_sethas(msg, 1);
@@ -808,25 +834,29 @@ UPB_INLINE void validate_UInt32Rules_set_gte(validate_UInt32Rules *msg, uint32_t
   *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) {
-  return (uint32_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(24, 24), 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) {
-  return (uint32_t*)_upb_array_resize_accessor2(msg, UPB_SIZE(24, 24), len, 2, 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(24, 24), 2, &val,
+  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) {
-  return (uint32_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(28, 32), 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) {
-  return (uint32_t*)_upb_array_resize_accessor2(msg, UPB_SIZE(28, 32), len, 2, 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(28, 32), 2, &val,
+  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);
+  *UPB_PTR_AT(msg, UPB_SIZE(24, 24), bool) = value;
+}
 
 /* validate.UInt64Rules */
 
@@ -858,8 +888,10 @@ UPB_INLINE bool validate_UInt64Rules_has_gt(const validate_UInt64Rules *msg) { r
 UPB_INLINE uint64_t validate_UInt64Rules_gt(const validate_UInt64Rules *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(32, 32), uint64_t); }
 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); }
-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(48, 48), 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(52, 56), len); }
+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); }
 
 UPB_INLINE void validate_UInt64Rules_set_const(validate_UInt64Rules *msg, uint64_t value) {
   _upb_sethas(msg, 1);
@@ -882,25 +914,29 @@ UPB_INLINE void validate_UInt64Rules_set_gte(validate_UInt64Rules *msg, uint64_t
   *UPB_PTR_AT(msg, UPB_SIZE(40, 40), 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(48, 48), len);
+  return (uint64_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(52, 56), 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(48, 48), len, 3, arena);
+  return (uint64_t*)_upb_array_resize_accessor2(msg, UPB_SIZE(52, 56), 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(48, 48), 3, &val,
+  return _upb_array_append_accessor2(msg, UPB_SIZE(52, 56), 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(52, 56), len);
+  return (uint64_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(56, 64), 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(52, 56), len, 3, arena);
+  return (uint64_t*)_upb_array_resize_accessor2(msg, UPB_SIZE(56, 64), 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(52, 56), 3, &val,
+  return _upb_array_append_accessor2(msg, UPB_SIZE(56, 64), 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;
+}
 
 /* validate.SInt32Rules */
 
@@ -932,8 +968,10 @@ UPB_INLINE bool validate_SInt32Rules_has_gt(const validate_SInt32Rules *msg) { r
 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 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(24, 24), 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(28, 32), len); }
+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 bool validate_SInt32Rules_ignore_empty(const validate_SInt32Rules *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(24, 24), bool); }
 
 UPB_INLINE void validate_SInt32Rules_set_const(validate_SInt32Rules *msg, int32_t value) {
   _upb_sethas(msg, 1);
@@ -956,25 +994,29 @@ UPB_INLINE void validate_SInt32Rules_set_gte(validate_SInt32Rules *msg, int32_t
   *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) {
-  return (int32_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(24, 24), 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) {
-  return (int32_t*)_upb_array_resize_accessor2(msg, UPB_SIZE(24, 24), len, 2, 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(24, 24), 2, &val,
+  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) {
-  return (int32_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(28, 32), 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) {
-  return (int32_t*)_upb_array_resize_accessor2(msg, UPB_SIZE(28, 32), len, 2, 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(28, 32), 2, &val,
+  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);
+  *UPB_PTR_AT(msg, UPB_SIZE(24, 24), bool) = value;
+}
 
 /* validate.SInt64Rules */
 
@@ -1006,8 +1048,10 @@ UPB_INLINE bool validate_SInt64Rules_has_gt(const validate_SInt64Rules *msg) { r
 UPB_INLINE int64_t validate_SInt64Rules_gt(const validate_SInt64Rules *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(32, 32), int64_t); }
 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); }
-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(48, 48), 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(52, 56), len); }
+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); }
 
 UPB_INLINE void validate_SInt64Rules_set_const(validate_SInt64Rules *msg, int64_t value) {
   _upb_sethas(msg, 1);
@@ -1030,25 +1074,29 @@ UPB_INLINE void validate_SInt64Rules_set_gte(validate_SInt64Rules *msg, int64_t
   *UPB_PTR_AT(msg, UPB_SIZE(40, 40), 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(48, 48), len);
+  return (int64_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(52, 56), 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(48, 48), len, 3, arena);
+  return (int64_t*)_upb_array_resize_accessor2(msg, UPB_SIZE(52, 56), 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(48, 48), 3, &val,
+  return _upb_array_append_accessor2(msg, UPB_SIZE(52, 56), 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(52, 56), len);
+  return (int64_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(56, 64), 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(52, 56), len, 3, arena);
+  return (int64_t*)_upb_array_resize_accessor2(msg, UPB_SIZE(56, 64), 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(52, 56), 3, &val,
+  return _upb_array_append_accessor2(msg, UPB_SIZE(56, 64), 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;
+}
 
 /* validate.Fixed32Rules */
 
@@ -1080,8 +1128,10 @@ UPB_INLINE bool validate_Fixed32Rules_has_gt(const validate_Fixed32Rules *msg) {
 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 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(24, 24), 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(28, 32), len); }
+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 bool validate_Fixed32Rules_ignore_empty(const validate_Fixed32Rules *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(24, 24), bool); }
 
 UPB_INLINE void validate_Fixed32Rules_set_const(validate_Fixed32Rules *msg, uint32_t value) {
   _upb_sethas(msg, 1);
@@ -1104,25 +1154,29 @@ UPB_INLINE void validate_Fixed32Rules_set_gte(validate_Fixed32Rules *msg, uint32
   *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) {
-  return (uint32_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(24, 24), 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) {
-  return (uint32_t*)_upb_array_resize_accessor2(msg, UPB_SIZE(24, 24), len, 2, 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(24, 24), 2, &val,
+  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) {
-  return (uint32_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(28, 32), 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) {
-  return (uint32_t*)_upb_array_resize_accessor2(msg, UPB_SIZE(28, 32), len, 2, 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(28, 32), 2, &val,
+  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);
+  *UPB_PTR_AT(msg, UPB_SIZE(24, 24), bool) = value;
+}
 
 /* validate.Fixed64Rules */
 
@@ -1154,8 +1208,10 @@ UPB_INLINE bool validate_Fixed64Rules_has_gt(const validate_Fixed64Rules *msg) {
 UPB_INLINE uint64_t validate_Fixed64Rules_gt(const validate_Fixed64Rules *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(32, 32), uint64_t); }
 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); }
-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(48, 48), 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(52, 56), len); }
+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); }
 
 UPB_INLINE void validate_Fixed64Rules_set_const(validate_Fixed64Rules *msg, uint64_t value) {
   _upb_sethas(msg, 1);
@@ -1178,25 +1234,29 @@ UPB_INLINE void validate_Fixed64Rules_set_gte(validate_Fixed64Rules *msg, uint64
   *UPB_PTR_AT(msg, UPB_SIZE(40, 40), 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(48, 48), len);
+  return (uint64_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(52, 56), 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(48, 48), len, 3, arena);
+  return (uint64_t*)_upb_array_resize_accessor2(msg, UPB_SIZE(52, 56), 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(48, 48), 3, &val,
+  return _upb_array_append_accessor2(msg, UPB_SIZE(52, 56), 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(52, 56), len);
+  return (uint64_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(56, 64), 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(52, 56), len, 3, arena);
+  return (uint64_t*)_upb_array_resize_accessor2(msg, UPB_SIZE(56, 64), 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(52, 56), 3, &val,
+  return _upb_array_append_accessor2(msg, UPB_SIZE(56, 64), 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;
+}
 
 /* validate.SFixed32Rules */
 
@@ -1228,8 +1288,10 @@ UPB_INLINE bool validate_SFixed32Rules_has_gt(const validate_SFixed32Rules *msg)
 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 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(24, 24), 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(28, 32), len); }
+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 bool validate_SFixed32Rules_ignore_empty(const validate_SFixed32Rules *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(24, 24), bool); }
 
 UPB_INLINE void validate_SFixed32Rules_set_const(validate_SFixed32Rules *msg, int32_t value) {
   _upb_sethas(msg, 1);
@@ -1252,25 +1314,29 @@ UPB_INLINE void validate_SFixed32Rules_set_gte(validate_SFixed32Rules *msg, int3
   *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) {
-  return (int32_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(24, 24), 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) {
-  return (int32_t*)_upb_array_resize_accessor2(msg, UPB_SIZE(24, 24), len, 2, 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(24, 24), 2, &val,
+  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) {
-  return (int32_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(28, 32), 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) {
-  return (int32_t*)_upb_array_resize_accessor2(msg, UPB_SIZE(28, 32), len, 2, 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(28, 32), 2, &val,
+  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);
+  *UPB_PTR_AT(msg, UPB_SIZE(24, 24), bool) = value;
+}
 
 /* validate.SFixed64Rules */
 
@@ -1302,8 +1368,10 @@ UPB_INLINE bool validate_SFixed64Rules_has_gt(const validate_SFixed64Rules *msg)
 UPB_INLINE int64_t validate_SFixed64Rules_gt(const validate_SFixed64Rules *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(32, 32), int64_t); }
 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); }
-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(48, 48), 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(52, 56), len); }
+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); }
 
 UPB_INLINE void validate_SFixed64Rules_set_const(validate_SFixed64Rules *msg, int64_t value) {
   _upb_sethas(msg, 1);
@@ -1326,25 +1394,29 @@ UPB_INLINE void validate_SFixed64Rules_set_gte(validate_SFixed64Rules *msg, int6
   *UPB_PTR_AT(msg, UPB_SIZE(40, 40), 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(48, 48), len);
+  return (int64_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(52, 56), 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(48, 48), len, 3, arena);
+  return (int64_t*)_upb_array_resize_accessor2(msg, UPB_SIZE(52, 56), 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(48, 48), 3, &val,
+  return _upb_array_append_accessor2(msg, UPB_SIZE(52, 56), 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(52, 56), len);
+  return (int64_t*)_upb_array_mutable_accessor(msg, UPB_SIZE(56, 64), 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(52, 56), len, 3, arena);
+  return (int64_t*)_upb_array_resize_accessor2(msg, UPB_SIZE(56, 64), 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(52, 56), 3, &val,
+  return _upb_array_append_accessor2(msg, UPB_SIZE(56, 64), 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;
+}
 
 /* validate.BoolRules */
 
@@ -1457,6 +1529,8 @@ UPB_INLINE bool validate_StringRules_has_well_known_regex(const validate_StringR
 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 *UPB_PTR_AT(msg, UPB_SIZE(56, 56), bool); }
+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); }
 
 UPB_INLINE void validate_StringRules_set_const(validate_StringRules *msg, upb_strview value) {
   _upb_sethas(msg, 1);
@@ -1560,6 +1634,10 @@ UPB_INLINE void validate_StringRules_set_strict(validate_StringRules *msg, bool
   _upb_sethas(msg, 13);
   *UPB_PTR_AT(msg, UPB_SIZE(56, 56), 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;
+}
 
 /* validate.BytesRules */
 
@@ -1587,36 +1665,38 @@ 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(84, 132), int32_t); }
+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 upb_strview validate_BytesRules_const(const validate_BytesRules *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(32, 32), upb_strview); }
+UPB_INLINE upb_strview validate_BytesRules_const(const validate_BytesRules *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(36, 40), upb_strview); }
 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); }
 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); }
 UPB_INLINE bool validate_BytesRules_has_pattern(const validate_BytesRules *msg) { return _upb_hasbit(msg, 4); }
-UPB_INLINE upb_strview validate_BytesRules_pattern(const validate_BytesRules *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(40, 48), upb_strview); }
+UPB_INLINE upb_strview validate_BytesRules_pattern(const validate_BytesRules *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(44, 56), upb_strview); }
 UPB_INLINE bool validate_BytesRules_has_prefix(const validate_BytesRules *msg) { return _upb_hasbit(msg, 5); }
-UPB_INLINE upb_strview validate_BytesRules_prefix(const validate_BytesRules *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(48, 64), upb_strview); }
+UPB_INLINE upb_strview validate_BytesRules_prefix(const validate_BytesRules *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(52, 72), upb_strview); }
 UPB_INLINE bool validate_BytesRules_has_suffix(const validate_BytesRules *msg) { return _upb_hasbit(msg, 6); }
-UPB_INLINE upb_strview validate_BytesRules_suffix(const validate_BytesRules *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(56, 80), upb_strview); }
+UPB_INLINE upb_strview validate_BytesRules_suffix(const validate_BytesRules *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(60, 88), upb_strview); }
 UPB_INLINE bool validate_BytesRules_has_contains(const validate_BytesRules *msg) { return _upb_hasbit(msg, 7); }
-UPB_INLINE upb_strview validate_BytesRules_contains(const validate_BytesRules *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(64, 96), upb_strview); }
-UPB_INLINE upb_strview const* validate_BytesRules_in(const validate_BytesRules *msg, size_t *len) { return (upb_strview const*)_upb_array_accessor(msg, UPB_SIZE(72, 112), len); }
-UPB_INLINE upb_strview const* validate_BytesRules_not_in(const validate_BytesRules *msg, size_t *len) { return (upb_strview const*)_upb_array_accessor(msg, UPB_SIZE(76, 120), len); }
-UPB_INLINE bool validate_BytesRules_has_ip(const validate_BytesRules *msg) { return _upb_getoneofcase(msg, UPB_SIZE(84, 132)) == 10; }
-UPB_INLINE bool validate_BytesRules_ip(const validate_BytesRules *msg) { return UPB_READ_ONEOF(msg, bool, UPB_SIZE(80, 128), UPB_SIZE(84, 132), 10, false); }
-UPB_INLINE bool validate_BytesRules_has_ipv4(const validate_BytesRules *msg) { return _upb_getoneofcase(msg, UPB_SIZE(84, 132)) == 11; }
-UPB_INLINE bool validate_BytesRules_ipv4(const validate_BytesRules *msg) { return UPB_READ_ONEOF(msg, bool, UPB_SIZE(80, 128), UPB_SIZE(84, 132), 11, false); }
-UPB_INLINE bool validate_BytesRules_has_ipv6(const validate_BytesRules *msg) { return _upb_getoneofcase(msg, UPB_SIZE(84, 132)) == 12; }
-UPB_INLINE bool validate_BytesRules_ipv6(const validate_BytesRules *msg) { return UPB_READ_ONEOF(msg, bool, UPB_SIZE(80, 128), UPB_SIZE(84, 132), 12, false); }
+UPB_INLINE upb_strview validate_BytesRules_contains(const validate_BytesRules *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(68, 104), upb_strview); }
+UPB_INLINE upb_strview const* validate_BytesRules_in(const validate_BytesRules *msg, size_t *len) { return (upb_strview const*)_upb_array_accessor(msg, UPB_SIZE(76, 120), len); }
+UPB_INLINE upb_strview const* validate_BytesRules_not_in(const validate_BytesRules *msg, size_t *len) { return (upb_strview 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); }
 UPB_INLINE uint64_t validate_BytesRules_len(const validate_BytesRules *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(24, 24), uint64_t); }
+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); }
 
 UPB_INLINE void validate_BytesRules_set_const(validate_BytesRules *msg, upb_strview value) {
   _upb_sethas(msg, 1);
-  *UPB_PTR_AT(msg, UPB_SIZE(32, 32), upb_strview) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(36, 40), upb_strview) = value;
 }
 UPB_INLINE void validate_BytesRules_set_min_len(validate_BytesRules *msg, uint64_t value) {
   _upb_sethas(msg, 2);
@@ -1628,53 +1708,57 @@ UPB_INLINE void validate_BytesRules_set_max_len(validate_BytesRules *msg, uint64
 }
 UPB_INLINE void validate_BytesRules_set_pattern(validate_BytesRules *msg, upb_strview value) {
   _upb_sethas(msg, 4);
-  *UPB_PTR_AT(msg, UPB_SIZE(40, 48), upb_strview) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(44, 56), upb_strview) = value;
 }
 UPB_INLINE void validate_BytesRules_set_prefix(validate_BytesRules *msg, upb_strview value) {
   _upb_sethas(msg, 5);
-  *UPB_PTR_AT(msg, UPB_SIZE(48, 64), upb_strview) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(52, 72), upb_strview) = value;
 }
 UPB_INLINE void validate_BytesRules_set_suffix(validate_BytesRules *msg, upb_strview value) {
   _upb_sethas(msg, 6);
-  *UPB_PTR_AT(msg, UPB_SIZE(56, 80), upb_strview) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(60, 88), upb_strview) = value;
 }
 UPB_INLINE void validate_BytesRules_set_contains(validate_BytesRules *msg, upb_strview value) {
   _upb_sethas(msg, 7);
-  *UPB_PTR_AT(msg, UPB_SIZE(64, 96), upb_strview) = value;
+  *UPB_PTR_AT(msg, UPB_SIZE(68, 104), upb_strview) = value;
 }
 UPB_INLINE upb_strview* validate_BytesRules_mutable_in(validate_BytesRules *msg, size_t *len) {
-  return (upb_strview*)_upb_array_mutable_accessor(msg, UPB_SIZE(72, 112), len);
+  return (upb_strview*)_upb_array_mutable_accessor(msg, UPB_SIZE(76, 120), len);
 }
 UPB_INLINE upb_strview* validate_BytesRules_resize_in(validate_BytesRules *msg, size_t len, upb_arena *arena) {
-  return (upb_strview*)_upb_array_resize_accessor2(msg, UPB_SIZE(72, 112), len, UPB_SIZE(3, 4), arena);
+  return (upb_strview*)_upb_array_resize_accessor2(msg, UPB_SIZE(76, 120), len, UPB_SIZE(3, 4), arena);
 }
 UPB_INLINE bool validate_BytesRules_add_in(validate_BytesRules *msg, upb_strview val, upb_arena *arena) {
-  return _upb_array_append_accessor2(msg, UPB_SIZE(72, 112), UPB_SIZE(3, 4), &val,
+  return _upb_array_append_accessor2(msg, UPB_SIZE(76, 120), UPB_SIZE(3, 4), &val,
       arena);
 }
 UPB_INLINE upb_strview* validate_BytesRules_mutable_not_in(validate_BytesRules *msg, size_t *len) {
-  return (upb_strview*)_upb_array_mutable_accessor(msg, UPB_SIZE(76, 120), len);
+  return (upb_strview*)_upb_array_mutable_accessor(msg, UPB_SIZE(80, 128), len);
 }
 UPB_INLINE upb_strview* validate_BytesRules_resize_not_in(validate_BytesRules *msg, size_t len, upb_arena *arena) {
-  return (upb_strview*)_upb_array_resize_accessor2(msg, UPB_SIZE(76, 120), len, UPB_SIZE(3, 4), arena);
+  return (upb_strview*)_upb_array_resize_accessor2(msg, UPB_SIZE(80, 128), len, UPB_SIZE(3, 4), arena);
 }
 UPB_INLINE bool validate_BytesRules_add_not_in(validate_BytesRules *msg, upb_strview val, upb_arena *arena) {
-  return _upb_array_append_accessor2(msg, UPB_SIZE(76, 120), UPB_SIZE(3, 4), &val,
+  return _upb_array_append_accessor2(msg, UPB_SIZE(80, 128), 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(80, 128), value, UPB_SIZE(84, 132), 10);
+  UPB_WRITE_ONEOF(msg, bool, UPB_SIZE(84, 136), value, UPB_SIZE(88, 140), 10);
 }
 UPB_INLINE void validate_BytesRules_set_ipv4(validate_BytesRules *msg, bool value) {
-  UPB_WRITE_ONEOF(msg, bool, UPB_SIZE(80, 128), value, UPB_SIZE(84, 132), 11);
+  UPB_WRITE_ONEOF(msg, bool, UPB_SIZE(84, 136), value, UPB_SIZE(88, 140), 11);
 }
 UPB_INLINE void validate_BytesRules_set_ipv6(validate_BytesRules *msg, bool value) {
-  UPB_WRITE_ONEOF(msg, bool, UPB_SIZE(80, 128), value, UPB_SIZE(84, 132), 12);
+  UPB_WRITE_ONEOF(msg, bool, UPB_SIZE(84, 136), value, UPB_SIZE(88, 140), 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_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;
+}
 
 /* validate.EnumRules */
 
@@ -1794,6 +1878,8 @@ UPB_INLINE bool validate_RepeatedRules_has_unique(const validate_RepeatedRules *
 UPB_INLINE bool validate_RepeatedRules_unique(const validate_RepeatedRules *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(24, 24), bool); }
 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*); }
+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); }
 
 UPB_INLINE void validate_RepeatedRules_set_min_items(validate_RepeatedRules *msg, uint64_t value) {
   _upb_sethas(msg, 1);
@@ -1820,6 +1906,10 @@ UPB_INLINE struct validate_FieldRules* validate_RepeatedRules_mutable_items(vali
   }
   return sub;
 }
+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;
+}
 
 /* validate.MapRules */
 
@@ -1851,6 +1941,8 @@ UPB_INLINE bool validate_MapRules_has_keys(const validate_MapRules *msg) { retur
 UPB_INLINE const validate_FieldRules* validate_MapRules_keys(const validate_MapRules *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(28, 32), const validate_FieldRules*); }
 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*); }
+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); }
 
 UPB_INLINE void validate_MapRules_set_min_pairs(validate_MapRules *msg, uint64_t value) {
   _upb_sethas(msg, 1);
@@ -1890,6 +1982,10 @@ UPB_INLINE struct validate_FieldRules* validate_MapRules_mutable_values(validate
   }
   return sub;
 }
+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;
+}
 
 /* validate.AnyRules */