validate

type AnyRules struct {

	// `in` requires the field's `type_url` to be equal to one of the
	// specified values. If it doesn't match any of the specified values, an error
	// message is generated.
	//
	// “`proto
	//
	//	message MyAny {
	//	  //  The `value` field must have a `type_url` equal to one of the specified values.
	//	  google.protobuf.Any value = 1 [(buf.validate.field).any = {
	//	      in: ["type.googleapis.com/MyType1", "type.googleapis.com/MyType2"]
	//	  }];
	//	}
	//
	// “`
	In []string `protobuf:"bytes,2,rep,name=in" json:"in,omitempty"`
	// requires the field's type_url to be not equal to any of the specified values. If it matches any of the specified values, an error message is generated.
	//
	// “`proto
	//
	//	message MyAny {
	//	  //  The `value` field must not have a `type_url` equal to any of the specified values.
	//	  google.protobuf.Any value = 1 [(buf.validate.field).any = {
	//	      not_in: ["type.googleapis.com/ForbiddenType1", "type.googleapis.com/ForbiddenType2"]
	//	  }];
	//	}
	//
	// “`
	NotIn []string `protobuf:"bytes,3,rep,name=not_in,json=notIn" json:"not_in,omitempty"`
	// contains filtered or unexported fields
}

type BoolRules struct {

	// `const` requires the field value to exactly match the specified boolean value.
	// If the field value doesn't match, an error message is generated.
	//
	// “`proto
	//
	//	message MyBool {
	//	  // value must equal true
	//	  bool value = 1 [(buf.validate.field).bool.const = true];
	//	}
	//
	// “`
	Const *bool `protobuf:"varint,1,opt,name=const" json:"const,omitempty"`
	// `example` specifies values that the field may have. These values SHOULD
	// conform to other rules. `example` values will not impact validation
	// but may be used as helpful guidance on how to populate the given field.
	//
	// “`proto
	//
	//	message MyBool {
	//	  bool value = 1 [
	//	    (buf.validate.field).bool.example = 1,
	//	    (buf.validate.field).bool.example = 2
	//	  ];
	//	}
	//
	// “`
	Example []bool `protobuf:"varint,2,rep,name=example" json:"example,omitempty"`
	// contains filtered or unexported fields
}

type BytesRules struct {

	// `const` requires the field value to exactly match the specified bytes
	// value. If the field value doesn't match, an error message is generated.
	//
	// “`proto
	//
	//	message MyBytes {
	//	  // value must be "\x01\x02\x03\x04"
	//	  bytes value = 1 [(buf.validate.field).bytes.const = "\x01\x02\x03\x04"];
	//	}
	//
	// “`
	Const []byte `protobuf:"bytes,1,opt,name=const" json:"const,omitempty"`
	// `len` requires the field value to have the specified length in bytes.
	// If the field value doesn't match, an error message is generated.
	//
	// “`proto
	//
	//	message MyBytes {
	//	  // value length must be 4 bytes.
	//	  optional bytes value = 1 [(buf.validate.field).bytes.len = 4];
	//	}
	//
	// “`
	Len *uint64 `protobuf:"varint,13,opt,name=len" json:"len,omitempty"`
	// `min_len` requires the field value to have at least the specified minimum
	// length in bytes.
	// If the field value doesn't meet the requirement, an error message is generated.
	//
	// “`proto
	//
	//	message MyBytes {
	//	  // value length must be at least 2 bytes.
	//	  optional bytes value = 1 [(buf.validate.field).bytes.min_len = 2];
	//	}
	//
	// “`
	MinLen *uint64 `protobuf:"varint,2,opt,name=min_len,json=minLen" json:"min_len,omitempty"`
	// `max_len` requires the field value to have at most the specified maximum
	// length in bytes.
	// If the field value exceeds the requirement, an error message is generated.
	//
	// “`proto
	//
	//	message MyBytes {
	//	  // value must be at most 6 bytes.
	//	  optional bytes value = 1 [(buf.validate.field).bytes.max_len = 6];
	//	}
	//
	// “`
	MaxLen *uint64 `protobuf:"varint,3,opt,name=max_len,json=maxLen" json:"max_len,omitempty"`
	// `pattern` requires the field value to match the specified regular
	// expression ([RE2 syntax](https://github.com/google/re2/wiki/Syntax)).
	// The value of the field must be valid UTF-8 or validation will fail with a
	// runtime error.
	// If the field value doesn't match the pattern, an error message is generated.
	//
	// “`proto
	//
	//	message MyBytes {
	//	  // value must match regex pattern "^[a-zA-Z0-9]+$".
	//	  optional bytes value = 1 [(buf.validate.field).bytes.pattern = "^[a-zA-Z0-9]+$"];
	//	}
	//
	// “`
	Pattern *string `protobuf:"bytes,4,opt,name=pattern" json:"pattern,omitempty"`
	// `prefix` requires the field value to have the specified bytes at the
	// beginning of the string.
	// If the field value doesn't meet the requirement, an error message is generated.
	//
	// “`proto
	//
	//	message MyBytes {
	//	  // value does not have prefix \x01\x02
	//	  optional bytes value = 1 [(buf.validate.field).bytes.prefix = "\x01\x02"];
	//	}
	//
	// “`
	Prefix []byte `protobuf:"bytes,5,opt,name=prefix" json:"prefix,omitempty"`
	// `suffix` requires the field value to have the specified bytes at the end
	// of the string.
	// If the field value doesn't meet the requirement, an error message is generated.
	//
	// “`proto
	//
	//	message MyBytes {
	//	  // value does not have suffix \x03\x04
	//	  optional bytes value = 1 [(buf.validate.field).bytes.suffix = "\x03\x04"];
	//	}
	//
	// “`
	Suffix []byte `protobuf:"bytes,6,opt,name=suffix" json:"suffix,omitempty"`
	// `contains` requires the field value to have the specified bytes anywhere in
	// the string.
	// If the field value doesn't meet the requirement, an error message is generated.
	//
	// “`proto
	//
	//	message MyBytes {
	//	  // value does not contain \x02\x03
	//	  optional bytes value = 1 [(buf.validate.field).bytes.contains = "\x02\x03"];
	//	}
	//
	// “`
	Contains []byte `protobuf:"bytes,7,opt,name=contains" json:"contains,omitempty"`
	// `in` requires the field value to be equal to one of the specified
	// values. If the field value doesn't match any of the specified values, an
	// error message is generated.
	//
	// “`proto
	//
	//	message MyBytes {
	//	  // value must in ["\x01\x02", "\x02\x03", "\x03\x04"]
	//	  optional bytes value = 1 [(buf.validate.field).bytes.in = {"\x01\x02", "\x02\x03", "\x03\x04"}];
	//	}
	//
	// “`
	In [][]byte `protobuf:"bytes,8,rep,name=in" json:"in,omitempty"`
	// `not_in` requires the field value to be not equal to any of the specified
	// values.
	// If the field value matches any of the specified values, an error message is
	// generated.
	//
	// “`proto
	//
	//	message MyBytes {
	//	  // value must not in ["\x01\x02", "\x02\x03", "\x03\x04"]
	//	  optional bytes value = 1 [(buf.validate.field).bytes.not_in = {"\x01\x02", "\x02\x03", "\x03\x04"}];
	//	}
	//
	// “`
	NotIn [][]byte `protobuf:"bytes,9,rep,name=not_in,json=notIn" json:"not_in,omitempty"`
	// WellKnown rules provide advanced rules against common byte
	// patterns
	//
	// Types that are valid to be assigned to WellKnown:
	//
	//	*BytesRules_Ip
	//	*BytesRules_Ipv4
	//	*BytesRules_Ipv6
	//	*BytesRules_Uuid
	WellKnown isBytesRules_WellKnown `protobuf_oneof:"well_known"`
	// `example` specifies values that the field may have. These values SHOULD
	// conform to other rules. `example` values will not impact validation
	// but may be used as helpful guidance on how to populate the given field.
	//
	// “`proto
	//
	//	message MyBytes {
	//	  bytes value = 1 [
	//	    (buf.validate.field).bytes.example = "\x01\x02",
	//	    (buf.validate.field).bytes.example = "\x02\x03"
	//	  ];
	//	}
	//
	// “`
	Example [][]byte `protobuf:"bytes,14,rep,name=example" json:"example,omitempty"`
	// contains filtered or unexported fields
}

type BytesRules_Ip struct {
	// `ip` ensures that the field `value` is a valid IP address (v4 or v6) in byte format.
	// If the field value doesn't meet this rule, an error message is generated.
	//
	// “`proto
	//
	//	message MyBytes {
	//	  // value must be a valid IP address
	//	  optional bytes value = 1 [(buf.validate.field).bytes.ip = true];
	//	}
	//
	// “`
	Ip bool `protobuf:"varint,10,opt,name=ip,oneof"`
}

type BytesRules_Ipv4 struct {
	// `ipv4` ensures that the field `value` is a valid IPv4 address in byte format.
	// If the field value doesn't meet this rule, an error message is generated.
	//
	// “`proto
	//
	//	message MyBytes {
	//	  // value must be a valid IPv4 address
	//	  optional bytes value = 1 [(buf.validate.field).bytes.ipv4 = true];
	//	}
	//
	// “`
	Ipv4 bool `protobuf:"varint,11,opt,name=ipv4,oneof"`
}

type BytesRules_Ipv6 struct {
	// `ipv6` ensures that the field `value` is a valid IPv6 address in byte format.
	// If the field value doesn't meet this rule, an error message is generated.
	// “`proto
	//
	//	message MyBytes {
	//	  // value must be a valid IPv6 address
	//	  optional bytes value = 1 [(buf.validate.field).bytes.ipv6 = true];
	//	}
	//
	// “`
	Ipv6 bool `protobuf:"varint,12,opt,name=ipv6,oneof"`
}

type BytesRules_Uuid struct {
	// `uuid` ensures that the field `value` encodes the 128-bit UUID data as
	// defined by [RFC 4122](https://datatracker.ietf.org/doc/html/rfc4122#section-4.1.2).
	// The field must contain exactly 16 bytes
	// representing the UUID. If the field value isn't a valid UUID, an error
	// message will be generated.
	//
	// “`proto
	//
	//	message MyBytes {
	//	  // value must be a valid UUID
	//	  optional bytes value = 1 [(buf.validate.field).bytes.uuid = true];
	//	}
	//
	// “`
	Uuid bool `protobuf:"varint,15,opt,name=uuid,oneof"`
}

type DoubleRules struct {

	// `const` requires the field value to exactly match the specified value. If
	// the field value doesn't match, an error message is generated.
	//
	// “`proto
	//
	//	message MyDouble {
	//	  // value must equal 42.0
	//	  double value = 1 [(buf.validate.field).double.const = 42.0];
	//	}
	//
	// “`
	Const *float64 `protobuf:"fixed64,1,opt,name=const" json:"const,omitempty"`
	// Types that are valid to be assigned to LessThan:
	//
	//	*DoubleRules_Lt
	//	*DoubleRules_Lte
	LessThan isDoubleRules_LessThan `protobuf_oneof:"less_than"`
	// Types that are valid to be assigned to GreaterThan:
	//
	//	*DoubleRules_Gt
	//	*DoubleRules_Gte
	GreaterThan isDoubleRules_GreaterThan `protobuf_oneof:"greater_than"`
	// `in` requires the field value to be equal to one of the specified values.
	// If the field value isn't one of the specified values, an error message is
	// generated.
	//
	// “`proto
	//
	//	message MyDouble {
	//	  // value must be in list [1.0, 2.0, 3.0]
	//	  double value = 1 [(buf.validate.field).double = { in: [1.0, 2.0, 3.0] }];
	//	}
	//
	// “`
	In []float64 `protobuf:"fixed64,6,rep,name=in" json:"in,omitempty"`
	// `not_in` requires the field value to not be equal to any of the specified
	// values. If the field value is one of the specified values, an error
	// message is generated.
	//
	// “`proto
	//
	//	message MyDouble {
	//	  // value must not be in list [1.0, 2.0, 3.0]
	//	  double value = 1 [(buf.validate.field).double = { not_in: [1.0, 2.0, 3.0] }];
	//	}
	//
	// “`
	NotIn []float64 `protobuf:"fixed64,7,rep,name=not_in,json=notIn" json:"not_in,omitempty"`
	// `finite` requires the field value to be finite. If the field value is
	// infinite or NaN, an error message is generated.
	Finite *bool `protobuf:"varint,8,opt,name=finite" json:"finite,omitempty"`
	// `example` specifies values that the field may have. These values SHOULD
	// conform to other rules. `example` values will not impact validation
	// but may be used as helpful guidance on how to populate the given field.
	//
	// “`proto
	//
	//	message MyDouble {
	//	  double value = 1 [
	//	    (buf.validate.field).double.example = 1.0,
	//	    (buf.validate.field).double.example = inf
	//	  ];
	//	}
	//
	// “`
	Example []float64 `protobuf:"fixed64,9,rep,name=example" json:"example,omitempty"`
	// contains filtered or unexported fields
}

type DoubleRules_Gt struct {
	// `gt` requires the field value to be greater than the specified value
	// (exclusive). If the value of `gt` is larger than a specified `lt` or `lte`,
	// the range is reversed, and the field value must be outside the specified
	// range. If the field value doesn't meet the required conditions, an error
	// message is generated.
	//
	// “`proto
	//
	//	message MyDouble {
	//	  // value must be greater than 5.0 [double.gt]
	//	  double value = 1 [(buf.validate.field).double.gt = 5.0];
	//
	//	  // value must be greater than 5 and less than 10.0 [double.gt_lt]
	//	  double other_value = 2 [(buf.validate.field).double = { gt: 5.0, lt: 10.0 }];
	//
	//	  // value must be greater than 10 or less than 5.0 [double.gt_lt_exclusive]
	//	  double another_value = 3 [(buf.validate.field).double = { gt: 10.0, lt: 5.0 }];
	//	}
	//
	// “`
	Gt float64 `protobuf:"fixed64,4,opt,name=gt,oneof"`
}

type DoubleRules_Gte struct {
	// `gte` requires the field value to be greater than or equal to the specified
	// value (exclusive). If the value of `gte` is larger than a specified `lt` or
	// `lte`, the range is reversed, and the field value must be outside the
	// specified range. If the field value doesn't meet the required conditions,
	// an error message is generated.
	//
	// “`proto
	//
	//	message MyDouble {
	//	  // value must be greater than or equal to 5.0 [double.gte]
	//	  double value = 1 [(buf.validate.field).double.gte = 5.0];
	//
	//	  // value must be greater than or equal to 5.0 and less than 10.0 [double.gte_lt]
	//	  double other_value = 2 [(buf.validate.field).double = { gte: 5.0, lt: 10.0 }];
	//
	//	  // value must be greater than or equal to 10.0 or less than 5.0 [double.gte_lt_exclusive]
	//	  double another_value = 3 [(buf.validate.field).double = { gte: 10.0, lt: 5.0 }];
	//	}
	//
	// “`
	Gte float64 `protobuf:"fixed64,5,opt,name=gte,oneof"`
}

type DoubleRules_Lt struct {
	// `lt` requires the field value to be less than the specified value (field <
	// value). If the field value is equal to or greater than the specified
	// value, an error message is generated.
	//
	// “`proto
	//
	//	message MyDouble {
	//	  // value must be less than 10.0
	//	  double value = 1 [(buf.validate.field).double.lt = 10.0];
	//	}
	//
	// “`
	Lt float64 `protobuf:"fixed64,2,opt,name=lt,oneof"`
}

type DoubleRules_Lte struct {
	// `lte` requires the field value to be less than or equal to the specified value
	// (field <= value). If the field value is greater than the specified value,
	// an error message is generated.
	//
	// “`proto
	//
	//	message MyDouble {
	//	  // value must be less than or equal to 10.0
	//	  double value = 1 [(buf.validate.field).double.lte = 10.0];
	//	}
	//
	// “`
	Lte float64 `protobuf:"fixed64,3,opt,name=lte,oneof"`
}

type DurationRules struct {

	// `const` dictates that the field must match the specified value of the `google.protobuf.Duration` type exactly.
	// If the field's value deviates from the specified value, an error message
	// will be generated.
	//
	// “`proto
	//
	//	message MyDuration {
	//	  // value must equal 5s
	//	  google.protobuf.Duration value = 1 [(buf.validate.field).duration.const = "5s"];
	//	}
	//
	// “`
	Const *durationpb.Duration `protobuf:"bytes,2,opt,name=const" json:"const,omitempty"`
	// Types that are valid to be assigned to LessThan:
	//
	//	*DurationRules_Lt
	//	*DurationRules_Lte
	LessThan isDurationRules_LessThan `protobuf_oneof:"less_than"`
	// Types that are valid to be assigned to GreaterThan:
	//
	//	*DurationRules_Gt
	//	*DurationRules_Gte
	GreaterThan isDurationRules_GreaterThan `protobuf_oneof:"greater_than"`
	// `in` asserts that the field must be equal to one of the specified values of the `google.protobuf.Duration` type.
	// If the field's value doesn't correspond to any of the specified values,
	// an error message will be generated.
	//
	// “`proto
	//
	//	message MyDuration {
	//	  // value must be in list [1s, 2s, 3s]
	//	  google.protobuf.Duration value = 1 [(buf.validate.field).duration.in = ["1s", "2s", "3s"]];
	//	}
	//
	// “`
	In []*durationpb.Duration `protobuf:"bytes,7,rep,name=in" json:"in,omitempty"`
	// `not_in` denotes that the field must not be equal to
	// any of the specified values of the `google.protobuf.Duration` type.
	// If the field's value matches any of these values, an error message will be
	// generated.
	//
	// “`proto
	//
	//	message MyDuration {
	//	  // value must not be in list [1s, 2s, 3s]
	//	  google.protobuf.Duration value = 1 [(buf.validate.field).duration.not_in = ["1s", "2s", "3s"]];
	//	}
	//
	// “`
	NotIn []*durationpb.Duration `protobuf:"bytes,8,rep,name=not_in,json=notIn" json:"not_in,omitempty"`
	// `example` specifies values that the field may have. These values SHOULD
	// conform to other rules. `example` values will not impact validation
	// but may be used as helpful guidance on how to populate the given field.
	//
	// “`proto
	//
	//	message MyDuration {
	//	  google.protobuf.Duration value = 1 [
	//	    (buf.validate.field).duration.example = { seconds: 1 },
	//	    (buf.validate.field).duration.example = { seconds: 2 },
	//	  ];
	//	}
	//
	// “`
	Example []*durationpb.Duration `protobuf:"bytes,9,rep,name=example" json:"example,omitempty"`
	// contains filtered or unexported fields
}

type DurationRules_Gt struct {
	// `gt` requires the duration field value to be greater than the specified
	// value (exclusive). If the value of `gt` is larger than a specified `lt`
	// or `lte`, the range is reversed, and the field value must be outside the
	// specified range. If the field value doesn't meet the required conditions,
	// an error message is generated.
	//
	// “`proto
	//
	//	message MyDuration {
	//	  // duration must be greater than 5s [duration.gt]
	//	  google.protobuf.Duration value = 1 [(buf.validate.field).duration.gt = { seconds: 5 }];
	//
	//	  // duration must be greater than 5s and less than 10s [duration.gt_lt]
	//	  google.protobuf.Duration another_value = 2 [(buf.validate.field).duration = { gt: { seconds: 5 }, lt: { seconds: 10 } }];
	//
	//	  // duration must be greater than 10s or less than 5s [duration.gt_lt_exclusive]
	//	  google.protobuf.Duration other_value = 3 [(buf.validate.field).duration = { gt: { seconds: 10 }, lt: { seconds: 5 } }];
	//	}
	//
	// “`
	Gt *durationpb.Duration `protobuf:"bytes,5,opt,name=gt,oneof"`
}

type DurationRules_Gte struct {
	// `gte` requires the duration field value to be greater than or equal to the
	// specified value (exclusive). If the value of `gte` is larger than a
	// specified `lt` or `lte`, the range is reversed, and the field value must
	// be outside the specified range. If the field value doesn't meet the
	// required conditions, an error message is generated.
	//
	// “`proto
	//
	//	message MyDuration {
	//	 // duration must be greater than or equal to 5s [duration.gte]
	//	 google.protobuf.Duration value = 1 [(buf.validate.field).duration.gte = { seconds: 5 }];
	//
	//	 // duration must be greater than or equal to 5s and less than 10s [duration.gte_lt]
	//	 google.protobuf.Duration another_value = 2 [(buf.validate.field).duration = { gte: { seconds: 5 }, lt: { seconds: 10 } }];
	//
	//	 // duration must be greater than or equal to 10s or less than 5s [duration.gte_lt_exclusive]
	//	 google.protobuf.Duration other_value = 3 [(buf.validate.field).duration = { gte: { seconds: 10 }, lt: { seconds: 5 } }];
	//	}
	//
	// “`
	Gte *durationpb.Duration `protobuf:"bytes,6,opt,name=gte,oneof"`
}

type DurationRules_Lt struct {
	// `lt` stipulates that the field must be less than the specified value of the `google.protobuf.Duration` type,
	// exclusive. If the field's value is greater than or equal to the specified
	// value, an error message will be generated.
	//
	// “`proto
	//
	//	message MyDuration {
	//	  // value must be less than 5s
	//	  google.protobuf.Duration value = 1 [(buf.validate.field).duration.lt = "5s"];
	//	}
	//
	// “`
	Lt *durationpb.Duration `protobuf:"bytes,3,opt,name=lt,oneof"`
}

type DurationRules_Lte struct {
	// `lte` indicates that the field must be less than or equal to the specified
	// value of the `google.protobuf.Duration` type, inclusive. If the field's value is greater than the specified value,
	// an error message will be generated.
	//
	// “`proto
	//
	//	message MyDuration {
	//	  // value must be less than or equal to 10s
	//	  google.protobuf.Duration value = 1 [(buf.validate.field).duration.lte = "10s"];
	//	}
	//
	// “`
	Lte *durationpb.Duration `protobuf:"bytes,4,opt,name=lte,oneof"`
}

type EnumRules struct {

	// `const` requires the field value to exactly match the specified enum value.
	// If the field value doesn't match, an error message is generated.
	//
	// “`proto
	//
	//	enum MyEnum {
	//	  MY_ENUM_UNSPECIFIED = 0;
	//	  MY_ENUM_VALUE1 = 1;
	//	  MY_ENUM_VALUE2 = 2;
	//	}
	//
	//	message MyMessage {
	//	  // The field `value` must be exactly MY_ENUM_VALUE1.
	//	  MyEnum value = 1 [(buf.validate.field).enum.const = 1];
	//	}
	//
	// “`
	Const *int32 `protobuf:"varint,1,opt,name=const" json:"const,omitempty"`
	// `defined_only` requires the field value to be one of the defined values for
	// this enum, failing on any undefined value.
	//
	// “`proto
	//
	//	enum MyEnum {
	//	  MY_ENUM_UNSPECIFIED = 0;
	//	  MY_ENUM_VALUE1 = 1;
	//	  MY_ENUM_VALUE2 = 2;
	//	}
	//
	//	message MyMessage {
	//	  // The field `value` must be a defined value of MyEnum.
	//	  MyEnum value = 1 [(buf.validate.field).enum.defined_only = true];
	//	}
	//
	// “`
	DefinedOnly *bool `protobuf:"varint,2,opt,name=defined_only,json=definedOnly" json:"defined_only,omitempty"`
	// `in` requires the field value to be equal to one of the
	// specified enum values. If the field value doesn't match any of the
	// specified values, an error message is generated.
	//
	// “`proto
	//
	//	enum MyEnum {
	//	  MY_ENUM_UNSPECIFIED = 0;
	//	  MY_ENUM_VALUE1 = 1;
	//	  MY_ENUM_VALUE2 = 2;
	//	}
	//
	//	message MyMessage {
	//	  // The field `value` must be equal to one of the specified values.
	//	  MyEnum value = 1 [(buf.validate.field).enum = { in: [1, 2]}];
	//	}
	//
	// “`
	In []int32 `protobuf:"varint,3,rep,name=in" json:"in,omitempty"`
	// `not_in` requires the field value to be not equal to any of the
	// specified enum values. If the field value matches one of the specified
	// values, an error message is generated.
	//
	// “`proto
	//
	//	enum MyEnum {
	//	  MY_ENUM_UNSPECIFIED = 0;
	//	  MY_ENUM_VALUE1 = 1;
	//	  MY_ENUM_VALUE2 = 2;
	//	}
	//
	//	message MyMessage {
	//	  // The field `value` must not be equal to any of the specified values.
	//	  MyEnum value = 1 [(buf.validate.field).enum = { not_in: [1, 2]}];
	//	}
	//
	// “`
	NotIn []int32 `protobuf:"varint,4,rep,name=not_in,json=notIn" json:"not_in,omitempty"`
	// `example` specifies values that the field may have. These values SHOULD
	// conform to other rules. `example` values will not impact validation
	// but may be used as helpful guidance on how to populate the given field.
	//
	// “`proto
	//
	//	enum MyEnum {
	//	  MY_ENUM_UNSPECIFIED = 0;
	//	  MY_ENUM_VALUE1 = 1;
	//	  MY_ENUM_VALUE2 = 2;
	//	}
	//
	//	message MyMessage {
	//	    (buf.validate.field).enum.example = 1,
	//	    (buf.validate.field).enum.example = 2
	//	}
	//
	// “`
	Example []int32 `protobuf:"varint,5,rep,name=example" json:"example,omitempty"`
	// contains filtered or unexported fields
}

type FieldMaskRules struct {

	// `const` dictates that the field must match the specified value of the `google.protobuf.FieldMask` type exactly.
	// If the field's value deviates from the specified value, an error message
	// will be generated.
	//
	// “`proto
	//
	//	message MyFieldMask {
	//	  // value must equal ["a"]
	//	  google.protobuf.FieldMask value = 1 [(buf.validate.field).field_mask.const = {
	//	      paths: ["a"]
	//	  }];
	//	}
	//
	// “`
	Const *fieldmaskpb.FieldMask `protobuf:"bytes,1,opt,name=const" json:"const,omitempty"`
	// `in` requires the field value to only contain paths matching specified
	// values or their subpaths.
	// If any of the field value's paths doesn't match the rule,
	// an error message is generated.
	// See: https://protobuf.dev/reference/protobuf/google.protobuf/#field-mask
	//
	// “`proto
	//
	//	message MyFieldMask {
	//	  //  The `value` FieldMask must only contain paths listed in `in`.
	//	  google.protobuf.FieldMask value = 1 [(buf.validate.field).field_mask = {
	//	      in: ["a", "b", "c.a"]
	//	  }];
	//	}
	//
	// “`
	In []string `protobuf:"bytes,2,rep,name=in" json:"in,omitempty"`
	// `not_in` requires the field value to not contain paths matching specified
	// values or their subpaths.
	// If any of the field value's paths matches the rule,
	// an error message is generated.
	// See: https://protobuf.dev/reference/protobuf/google.protobuf/#field-mask
	//
	// “`proto
	//
	//	message MyFieldMask {
	//	  //  The `value` FieldMask shall not contain paths listed in `not_in`.
	//	  google.protobuf.FieldMask value = 1 [(buf.validate.field).field_mask = {
	//	      not_in: ["forbidden", "immutable", "c.a"]
	//	  }];
	//	}
	//
	// “`
	NotIn []string `protobuf:"bytes,3,rep,name=not_in,json=notIn" json:"not_in,omitempty"`
	// `example` specifies values that the field may have. These values SHOULD
	// conform to other rules. `example` values will not impact validation
	// but may be used as helpful guidance on how to populate the given field.
	//
	// “`proto
	//
	//	message MyFieldMask {
	//	  google.protobuf.FieldMask value = 1 [
	//	    (buf.validate.field).field_mask.example = { paths: ["a", "b"] },
	//	    (buf.validate.field).field_mask.example = { paths: ["c.a", "d"] },
	//	  ];
	//	}
	//
	// “`
	Example []*fieldmaskpb.FieldMask `protobuf:"bytes,4,rep,name=example" json:"example,omitempty"`
	// contains filtered or unexported fields
}

type FieldPath struct {

	// `elements` contains each element of the path, starting from the root and recursing downward.
	Elements []*FieldPathElement `protobuf:"bytes,1,rep,name=elements" json:"elements,omitempty"`
	// contains filtered or unexported fields
}

type FieldPathElement struct {

	// `field_number` is the field number this path element refers to.
	FieldNumber *int32 `protobuf:"varint,1,opt,name=field_number,json=fieldNumber" json:"field_number,omitempty"`
	// `field_name` contains the field name this path element refers to.
	// This can be used to display a human-readable path even if the field number is unknown.
	FieldName *string `protobuf:"bytes,2,opt,name=field_name,json=fieldName" json:"field_name,omitempty"`
	// `field_type` specifies the type of this field. When using reflection, this value is not needed.
	//
	// This value is provided to make it possible to traverse unknown fields through wire data.
	// When traversing wire data, be mindful of both packed[1] and delimited[2] encoding schemes.
	//
	// N.B.: Although groups are deprecated, the corresponding delimited encoding scheme is not, and
	// can be explicitly used in Protocol Buffers 2023 Edition.
	//
	// [1]: https://protobuf.dev/programming-guides/encoding/#packed
	// [2]: https://protobuf.dev/programming-guides/encoding/#groups
	FieldType *descriptorpb.FieldDescriptorProto_Type `` /* 129-byte string literal not displayed */
	// `key_type` specifies the map key type of this field. This value is useful when traversing
	// unknown fields through wire data: specifically, it allows handling the differences between
	// different integer encodings.
	KeyType *descriptorpb.FieldDescriptorProto_Type `protobuf:"varint,4,opt,name=key_type,json=keyType,enum=google.protobuf.FieldDescriptorProto_Type" json:"key_type,omitempty"`
	// `value_type` specifies map value type of this field. This is useful if you want to display a
	// value inside unknown fields through wire data.
	ValueType *descriptorpb.FieldDescriptorProto_Type `` /* 129-byte string literal not displayed */
	// `subscript` contains a repeated index or map key, if this path element nests into a repeated or map field.
	//
	// Types that are valid to be assigned to Subscript:
	//
	//	*FieldPathElement_Index
	//	*FieldPathElement_BoolKey
	//	*FieldPathElement_IntKey
	//	*FieldPathElement_UintKey
	//	*FieldPathElement_StringKey
	Subscript isFieldPathElement_Subscript `protobuf_oneof:"subscript"`
	// contains filtered or unexported fields
}

type FieldPathElement_BoolKey struct {
	// `bool_key` specifies a map key of type bool.
	BoolKey bool `protobuf:"varint,7,opt,name=bool_key,json=boolKey,oneof"`
}

type FieldPathElement_Index struct {
	// `index` specifies a 0-based index into a repeated field.
	Index uint64 `protobuf:"varint,6,opt,name=index,oneof"`
}

type FieldPathElement_IntKey struct {
	// `int_key` specifies a map key of type int32, int64, sint32, sint64, sfixed32 or sfixed64.
	IntKey int64 `protobuf:"varint,8,opt,name=int_key,json=intKey,oneof"`
}

type FieldPathElement_StringKey struct {
	// `string_key` specifies a map key of type string.
	StringKey string `protobuf:"bytes,10,opt,name=string_key,json=stringKey,oneof"`
}

type FieldPathElement_UintKey struct {
	// `uint_key` specifies a map key of type uint32, uint64, fixed32 or fixed64.
	UintKey uint64 `protobuf:"varint,9,opt,name=uint_key,json=uintKey,oneof"`
}

type FieldRules struct {

	// `cel_expression` is a repeated field CEL expressions. Each expression specifies a validation
	// rule to be applied to this message. These rules are written in Common Expression Language (CEL) syntax.
	//
	// This is a simplified form of the `cel` Rule field, where only `expression` is set. This allows for
	// simpler syntax when defining CEL Rules where `id` and `message` derived from the `expression`. `id` will
	// be same as the `expression`.
	//
	// For more information, [see our documentation](https://buf.build/docs/protovalidate/schemas/custom-rules/).
	//
	// “`proto
	//
	//	message MyMessage {
	//	  // The field `value` must be greater than 42.
	//	  optional int32 value = 1 [(buf.validate.field).cel_expression = "this > 42"];
	//	}
	//
	// “`
	CelExpression []string `protobuf:"bytes,29,rep,name=cel_expression,json=celExpression" json:"cel_expression,omitempty"`
	// `cel` is a repeated field used to represent a textual expression
	// in the Common Expression Language (CEL) syntax. For more information,
	// [see our documentation](https://buf.build/docs/protovalidate/schemas/custom-rules/).
	//
	// “`proto
	//
	//	message MyMessage {
	//	  // The field `value` must be greater than 42.
	//	  optional int32 value = 1 [(buf.validate.field).cel = {
	//	    id: "my_message.value",
	//	    message: "value must be greater than 42",
	//	    expression: "this > 42",
	//	  }];
	//	}
	//
	// “`
	Cel []*Rule `protobuf:"bytes,23,rep,name=cel" json:"cel,omitempty"`
	// If `required` is true, the field must be set. A validation error is returned
	// if the field is not set.
	//
	// “`proto
	// syntax="proto3";
	//
	//	message FieldsWithPresence {
	//	  // Requires any string to be set, including the empty string.
	//	  optional string link = 1 [
	//	    (buf.validate.field).required = true
	//	  ];
	//	  // Requires true or false to be set.
	//	  optional bool disabled = 2 [
	//	    (buf.validate.field).required = true
	//	  ];
	//	  // Requires a message to be set, including the empty message.
	//	  SomeMessage msg = 4 [
	//	    (buf.validate.field).required = true
	//	  ];
	//	}
	//
	// “`
	//
	// All fields in the example above track presence. By default, Protovalidate
	// ignores rules on those fields if no value is set. `required` ensures that
	// the fields are set and valid.
	//
	// Fields that don't track presence are always validated by Protovalidate,
	// whether they are set or not. It is not necessary to add `required`. It
	// can be added to indicate that the field cannot be the zero value.
	//
	// “`proto
	// syntax="proto3";
	//
	//	message FieldsWithoutPresence {
	//	  // `string.email` always applies, even to an empty string.
	//	  string link = 1 [
	//	    (buf.validate.field).string.email = true
	//	  ];
	//	  // `repeated.min_items` always applies, even to an empty list.
	//	  repeated string labels = 2 [
	//	    (buf.validate.field).repeated.min_items = 1
	//	  ];
	//	  // `required`, for fields that don't track presence, indicates
	//	  // the value of the field can't be the zero value.
	//	  int32 zero_value_not_allowed = 3 [
	//	    (buf.validate.field).required = true
	//	  ];
	//	}
	//
	// “`
	//
	// To learn which fields track presence, see the
	// [Field Presence cheat sheet](https://protobuf.dev/programming-guides/field_presence/#cheat).
	//
	// Note: While field rules can be applied to repeated items, map keys, and map
	// values, the elements are always considered to be set. Consequently,
	// specifying `repeated.items.required` is redundant.
	Required *bool `protobuf:"varint,25,opt,name=required" json:"required,omitempty"`
	// Ignore validation rules on the field if its value matches the specified
	// criteria. See the `Ignore` enum for details.
	//
	// “`proto
	//
	//	message UpdateRequest {
	//	  // The uri rule only applies if the field is not an empty string.
	//	  string url = 1 [
	//	    (buf.validate.field).ignore = IGNORE_IF_ZERO_VALUE,
	//	    (buf.validate.field).string.uri = true
	//	  ];
	//	}
	//
	// “`
	Ignore *Ignore `protobuf:"varint,27,opt,name=ignore,enum=buf.validate.Ignore" json:"ignore,omitempty"`
	// Types that are valid to be assigned to Type:
	//
	//	*FieldRules_Float
	//	*FieldRules_Double
	//	*FieldRules_Int32
	//	*FieldRules_Int64
	//	*FieldRules_Uint32
	//	*FieldRules_Uint64
	//	*FieldRules_Sint32
	//	*FieldRules_Sint64
	//	*FieldRules_Fixed32
	//	*FieldRules_Fixed64
	//	*FieldRules_Sfixed32
	//	*FieldRules_Sfixed64
	//	*FieldRules_Bool
	//	*FieldRules_String_
	//	*FieldRules_Bytes
	//	*FieldRules_Enum
	//	*FieldRules_Repeated
	//	*FieldRules_Map
	//	*FieldRules_Any
	//	*FieldRules_Duration
	//	*FieldRules_FieldMask
	//	*FieldRules_Timestamp
	Type isFieldRules_Type `protobuf_oneof:"type"`
	// contains filtered or unexported fields
}

type FieldRules_Any struct {
	// Well-Known Field Types
	Any *AnyRules `protobuf:"bytes,20,opt,name=any,oneof"`
}

type FieldRules_Bool struct {
	Bool *BoolRules `protobuf:"bytes,13,opt,name=bool,oneof"`
}

type FieldRules_Bytes struct {
	Bytes *BytesRules `protobuf:"bytes,15,opt,name=bytes,oneof"`
}

type FieldRules_Double struct {
	Double *DoubleRules `protobuf:"bytes,2,opt,name=double,oneof"`
}

type FieldRules_Duration struct {
	Duration *DurationRules `protobuf:"bytes,21,opt,name=duration,oneof"`
}

type FieldRules_Enum struct {
	// Complex Field Types
	Enum *EnumRules `protobuf:"bytes,16,opt,name=enum,oneof"`
}

type FieldRules_FieldMask struct {
	FieldMask *FieldMaskRules `protobuf:"bytes,28,opt,name=field_mask,json=fieldMask,oneof"`
}

type FieldRules_Fixed32 struct {
	Fixed32 *Fixed32Rules `protobuf:"bytes,9,opt,name=fixed32,oneof"`
}

type FieldRules_Fixed64 struct {
	Fixed64 *Fixed64Rules `protobuf:"bytes,10,opt,name=fixed64,oneof"`
}

type FieldRules_Float struct {
	// Scalar Field Types
	Float *FloatRules `protobuf:"bytes,1,opt,name=float,oneof"`
}

type FieldRules_Int32 struct {
	Int32 *Int32Rules `protobuf:"bytes,3,opt,name=int32,oneof"`
}

type FieldRules_Int64 struct {
	Int64 *Int64Rules `protobuf:"bytes,4,opt,name=int64,oneof"`
}

type FieldRules_Map struct {
	Map *MapRules `protobuf:"bytes,19,opt,name=map,oneof"`
}

type FieldRules_Repeated struct {
	Repeated *RepeatedRules `protobuf:"bytes,18,opt,name=repeated,oneof"`
}

type FieldRules_Sfixed32 struct {
	Sfixed32 *SFixed32Rules `protobuf:"bytes,11,opt,name=sfixed32,oneof"`
}

type FieldRules_Sfixed64 struct {
	Sfixed64 *SFixed64Rules `protobuf:"bytes,12,opt,name=sfixed64,oneof"`
}

type FieldRules_Sint32 struct {
	Sint32 *SInt32Rules `protobuf:"bytes,7,opt,name=sint32,oneof"`
}

type FieldRules_Sint64 struct {
	Sint64 *SInt64Rules `protobuf:"bytes,8,opt,name=sint64,oneof"`
}

type FieldRules_String_ struct {
	String_ *StringRules `protobuf:"bytes,14,opt,name=string,oneof"`
}

type FieldRules_Timestamp struct {
	Timestamp *TimestampRules `protobuf:"bytes,22,opt,name=timestamp,oneof"`
}

type FieldRules_Uint32 struct {
	Uint32 *UInt32Rules `protobuf:"bytes,5,opt,name=uint32,oneof"`
}

type FieldRules_Uint64 struct {
	Uint64 *UInt64Rules `protobuf:"bytes,6,opt,name=uint64,oneof"`
}

type Fixed32Rules struct {

	// `const` requires the field value to exactly match the specified value.
	// If the field value doesn't match, an error message is generated.
	//
	// “`proto
	//
	//	message MyFixed32 {
	//	  // value must equal 42
	//	  fixed32 value = 1 [(buf.validate.field).fixed32.const = 42];
	//	}
	//
	// “`
	Const *uint32 `protobuf:"fixed32,1,opt,name=const" json:"const,omitempty"`
	// Types that are valid to be assigned to LessThan:
	//
	//	*Fixed32Rules_Lt
	//	*Fixed32Rules_Lte
	LessThan isFixed32Rules_LessThan `protobuf_oneof:"less_than"`
	// Types that are valid to be assigned to GreaterThan:
	//
	//	*Fixed32Rules_Gt
	//	*Fixed32Rules_Gte
	GreaterThan isFixed32Rules_GreaterThan `protobuf_oneof:"greater_than"`
	// `in` requires the field value to be equal to one of the specified values.
	// If the field value isn't one of the specified values, an error message
	// is generated.
	//
	// “`proto
	//
	//	message MyFixed32 {
	//	  // value must be in list [1, 2, 3]
	//	  fixed32 value = 1 [(buf.validate.field).fixed32 = { in: [1, 2, 3] }];
	//	}
	//
	// “`
	In []uint32 `protobuf:"fixed32,6,rep,name=in" json:"in,omitempty"`
	// `not_in` requires the field value to not be equal to any of the specified
	// values. If the field value is one of the specified values, an error
	// message is generated.
	//
	// “`proto
	//
	//	message MyFixed32 {
	//	  // value must not be in list [1, 2, 3]
	//	  fixed32 value = 1 [(buf.validate.field).fixed32 = { not_in: [1, 2, 3] }];
	//	}
	//
	// “`
	NotIn []uint32 `protobuf:"fixed32,7,rep,name=not_in,json=notIn" json:"not_in,omitempty"`
	// `example` specifies values that the field may have. These values SHOULD
	// conform to other rules. `example` values will not impact validation
	// but may be used as helpful guidance on how to populate the given field.
	//
	// “`proto
	//
	//	message MyFixed32 {
	//	  fixed32 value = 1 [
	//	    (buf.validate.field).fixed32.example = 1,
	//	    (buf.validate.field).fixed32.example = 2
	//	  ];
	//	}
	//
	// “`
	Example []uint32 `protobuf:"fixed32,8,rep,name=example" json:"example,omitempty"`
	// contains filtered or unexported fields
}

type Fixed32Rules_Gt struct {
	// `gt` requires the field value to be greater than the specified value
	// (exclusive). If the value of `gt` is larger than a specified `lt` or
	// `lte`, the range is reversed, and the field value must be outside the
	// specified range. If the field value doesn't meet the required conditions,
	// an error message is generated.
	//
	// “`proto
	//
	//	message MyFixed32 {
	//	  // value must be greater than 5 [fixed32.gt]
	//	  fixed32 value = 1 [(buf.validate.field).fixed32.gt = 5];
	//
	//	  // value must be greater than 5 and less than 10 [fixed32.gt_lt]
	//	  fixed32 other_value = 2 [(buf.validate.field).fixed32 = { gt: 5, lt: 10 }];
	//
	//	  // value must be greater than 10 or less than 5 [fixed32.gt_lt_exclusive]
	//	  fixed32 another_value = 3 [(buf.validate.field).fixed32 = { gt: 10, lt: 5 }];
	//	}
	//
	// “`
	Gt uint32 `protobuf:"fixed32,4,opt,name=gt,oneof"`
}

type Fixed32Rules_Gte struct {
	// `gte` requires the field value to be greater than or equal to the specified
	// value (exclusive). If the value of `gte` is larger than a specified `lt`
	// or `lte`, the range is reversed, and the field value must be outside the
	// specified range. If the field value doesn't meet the required conditions,
	// an error message is generated.
	//
	// “`proto
	//
	//	message MyFixed32 {
	//	  // value must be greater than or equal to 5 [fixed32.gte]
	//	  fixed32 value = 1 [(buf.validate.field).fixed32.gte = 5];
	//
	//	  // value must be greater than or equal to 5 and less than 10 [fixed32.gte_lt]
	//	  fixed32 other_value = 2 [(buf.validate.field).fixed32 = { gte: 5, lt: 10 }];
	//
	//	  // value must be greater than or equal to 10 or less than 5 [fixed32.gte_lt_exclusive]
	//	  fixed32 another_value = 3 [(buf.validate.field).fixed32 = { gte: 10, lt: 5 }];
	//	}
	//
	// “`
	Gte uint32 `protobuf:"fixed32,5,opt,name=gte,oneof"`
}

type Fixed32Rules_Lt struct {
	// `lt` requires the field value to be less than the specified value (field <
	// value). If the field value is equal to or greater than the specified value,
	// an error message is generated.
	//
	// “`proto
	//
	//	message MyFixed32 {
	//	  // value must be less than 10
	//	  fixed32 value = 1 [(buf.validate.field).fixed32.lt = 10];
	//	}
	//
	// “`
	Lt uint32 `protobuf:"fixed32,2,opt,name=lt,oneof"`
}

type Fixed32Rules_Lte struct {
	// `lte` requires the field value to be less than or equal to the specified
	// value (field <= value). If the field value is greater than the specified
	// value, an error message is generated.
	//
	// “`proto
	//
	//	message MyFixed32 {
	//	  // value must be less than or equal to 10
	//	  fixed32 value = 1 [(buf.validate.field).fixed32.lte = 10];
	//	}
	//
	// “`
	Lte uint32 `protobuf:"fixed32,3,opt,name=lte,oneof"`
}

type Fixed64Rules struct {

	// `const` requires the field value to exactly match the specified value. If
	// the field value doesn't match, an error message is generated.
	//
	// “`proto
	//
	//	message MyFixed64 {
	//	  // value must equal 42
	//	  fixed64 value = 1 [(buf.validate.field).fixed64.const = 42];
	//	}
	//
	// “`
	Const *uint64 `protobuf:"fixed64,1,opt,name=const" json:"const,omitempty"`
	// Types that are valid to be assigned to LessThan:
	//
	//	*Fixed64Rules_Lt
	//	*Fixed64Rules_Lte
	LessThan isFixed64Rules_LessThan `protobuf_oneof:"less_than"`
	// Types that are valid to be assigned to GreaterThan:
	//
	//	*Fixed64Rules_Gt
	//	*Fixed64Rules_Gte
	GreaterThan isFixed64Rules_GreaterThan `protobuf_oneof:"greater_than"`
	// `in` requires the field value to be equal to one of the specified values.
	// If the field value isn't one of the specified values, an error message is
	// generated.
	//
	// “`proto
	//
	//	message MyFixed64 {
	//	  // value must be in list [1, 2, 3]
	//	  fixed64 value = 1 [(buf.validate.field).fixed64 = { in: [1, 2, 3] }];
	//	}
	//
	// “`
	In []uint64 `protobuf:"fixed64,6,rep,name=in" json:"in,omitempty"`
	// `not_in` requires the field value to not be equal to any of the specified
	// values. If the field value is one of the specified values, an error
	// message is generated.
	//
	// “`proto
	//
	//	message MyFixed64 {
	//	  // value must not be in list [1, 2, 3]
	//	  fixed64 value = 1 [(buf.validate.field).fixed64 = { not_in: [1, 2, 3] }];
	//	}
	//
	// “`
	NotIn []uint64 `protobuf:"fixed64,7,rep,name=not_in,json=notIn" json:"not_in,omitempty"`
	// `example` specifies values that the field may have. These values SHOULD
	// conform to other rules. `example` values will not impact validation
	// but may be used as helpful guidance on how to populate the given field.
	//
	// “`proto
	//
	//	message MyFixed64 {
	//	  fixed64 value = 1 [
	//	    (buf.validate.field).fixed64.example = 1,
	//	    (buf.validate.field).fixed64.example = 2
	//	  ];
	//	}
	//
	// “`
	Example []uint64 `protobuf:"fixed64,8,rep,name=example" json:"example,omitempty"`
	// contains filtered or unexported fields
}

type Fixed64Rules_Gt struct {
	// `gt` requires the field value to be greater than the specified value
	// (exclusive). If the value of `gt` is larger than a specified `lt` or
	// `lte`, the range is reversed, and the field value must be outside the
	// specified range. If the field value doesn't meet the required conditions,
	// an error message is generated.
	//
	// “`proto
	//
	//	message MyFixed64 {
	//	  // value must be greater than 5 [fixed64.gt]
	//	  fixed64 value = 1 [(buf.validate.field).fixed64.gt = 5];
	//
	//	  // value must be greater than 5 and less than 10 [fixed64.gt_lt]
	//	  fixed64 other_value = 2 [(buf.validate.field).fixed64 = { gt: 5, lt: 10 }];
	//
	//	  // value must be greater than 10 or less than 5 [fixed64.gt_lt_exclusive]
	//	  fixed64 another_value = 3 [(buf.validate.field).fixed64 = { gt: 10, lt: 5 }];
	//	}
	//
	// “`
	Gt uint64 `protobuf:"fixed64,4,opt,name=gt,oneof"`
}

type Fixed64Rules_Gte struct {
	// `gte` requires the field value to be greater than or equal to the specified
	// value (exclusive). If the value of `gte` is larger than a specified `lt`
	// or `lte`, the range is reversed, and the field value must be outside the
	// specified range. If the field value doesn't meet the required conditions,
	// an error message is generated.
	//
	// “`proto
	//
	//	message MyFixed64 {
	//	  // value must be greater than or equal to 5 [fixed64.gte]
	//	  fixed64 value = 1 [(buf.validate.field).fixed64.gte = 5];
	//
	//	  // value must be greater than or equal to 5 and less than 10 [fixed64.gte_lt]
	//	  fixed64 other_value = 2 [(buf.validate.field).fixed64 = { gte: 5, lt: 10 }];
	//
	//	  // value must be greater than or equal to 10 or less than 5 [fixed64.gte_lt_exclusive]
	//	  fixed64 another_value = 3 [(buf.validate.field).fixed64 = { gte: 10, lt: 5 }];
	//	}
	//
	// “`
	Gte uint64 `protobuf:"fixed64,5,opt,name=gte,oneof"`
}

type Fixed64Rules_Lt struct {
	// `lt` requires the field value to be less than the specified value (field <
	// value). If the field value is equal to or greater than the specified value,
	// an error message is generated.
	//
	// “`proto
	//
	//	message MyFixed64 {
	//	  // value must be less than 10
	//	  fixed64 value = 1 [(buf.validate.field).fixed64.lt = 10];
	//	}
	//
	// “`
	Lt uint64 `protobuf:"fixed64,2,opt,name=lt,oneof"`
}

type Fixed64Rules_Lte struct {
	// `lte` requires the field value to be less than or equal to the specified
	// value (field <= value). If the field value is greater than the specified
	// value, an error message is generated.
	//
	// “`proto
	//
	//	message MyFixed64 {
	//	  // value must be less than or equal to 10
	//	  fixed64 value = 1 [(buf.validate.field).fixed64.lte = 10];
	//	}
	//
	// “`
	Lte uint64 `protobuf:"fixed64,3,opt,name=lte,oneof"`
}

type FloatRules struct {

	// `const` requires the field value to exactly match the specified value. If
	// the field value doesn't match, an error message is generated.
	//
	// “`proto
	//
	//	message MyFloat {
	//	  // value must equal 42.0
	//	  float value = 1 [(buf.validate.field).float.const = 42.0];
	//	}
	//
	// “`
	Const *float32 `protobuf:"fixed32,1,opt,name=const" json:"const,omitempty"`
	// Types that are valid to be assigned to LessThan:
	//
	//	*FloatRules_Lt
	//	*FloatRules_Lte
	LessThan isFloatRules_LessThan `protobuf_oneof:"less_than"`
	// Types that are valid to be assigned to GreaterThan:
	//
	//	*FloatRules_Gt
	//	*FloatRules_Gte
	GreaterThan isFloatRules_GreaterThan `protobuf_oneof:"greater_than"`
	// `in` requires the field value to be equal to one of the specified values.
	// If the field value isn't one of the specified values, an error message
	// is generated.
	//
	// “`proto
	//
	//	message MyFloat {
	//	  // value must be in list [1.0, 2.0, 3.0]
	//	  float value = 1 [(buf.validate.field).float = { in: [1.0, 2.0, 3.0] }];
	//	}
	//
	// “`
	In []float32 `protobuf:"fixed32,6,rep,name=in" json:"in,omitempty"`
	// `in` requires the field value to not be equal to any of the specified
	// values. If the field value is one of the specified values, an error
	// message is generated.
	//
	// “`proto
	//
	//	message MyFloat {
	//	  // value must not be in list [1.0, 2.0, 3.0]
	//	  float value = 1 [(buf.validate.field).float = { not_in: [1.0, 2.0, 3.0] }];
	//	}
	//
	// “`
	NotIn []float32 `protobuf:"fixed32,7,rep,name=not_in,json=notIn" json:"not_in,omitempty"`
	// `finite` requires the field value to be finite. If the field value is
	// infinite or NaN, an error message is generated.
	Finite *bool `protobuf:"varint,8,opt,name=finite" json:"finite,omitempty"`
	// `example` specifies values that the field may have. These values SHOULD
	// conform to other rules. `example` values will not impact validation
	// but may be used as helpful guidance on how to populate the given field.
	//
	// “`proto
	//
	//	message MyFloat {
	//	  float value = 1 [
	//	    (buf.validate.field).float.example = 1.0,
	//	    (buf.validate.field).float.example = inf
	//	  ];
	//	}
	//
	// “`
	Example []float32 `protobuf:"fixed32,9,rep,name=example" json:"example,omitempty"`
	// contains filtered or unexported fields
}

type FloatRules_Gt struct {
	// `gt` requires the field value to be greater than the specified value
	// (exclusive). If the value of `gt` is larger than a specified `lt` or
	// `lte`, the range is reversed, and the field value must be outside the
	// specified range. If the field value doesn't meet the required conditions,
	// an error message is generated.
	//
	// “`proto
	//
	//	message MyFloat {
	//	  // value must be greater than 5.0 [float.gt]
	//	  float value = 1 [(buf.validate.field).float.gt = 5.0];
	//
	//	  // value must be greater than 5 and less than 10.0 [float.gt_lt]
	//	  float other_value = 2 [(buf.validate.field).float = { gt: 5.0, lt: 10.0 }];
	//
	//	  // value must be greater than 10 or less than 5.0 [float.gt_lt_exclusive]
	//	  float another_value = 3 [(buf.validate.field).float = { gt: 10.0, lt: 5.0 }];
	//	}
	//
	// “`
	Gt float32 `protobuf:"fixed32,4,opt,name=gt,oneof"`
}

type FloatRules_Gte struct {
	// `gte` requires the field value to be greater than or equal to the specified
	// value (exclusive). If the value of `gte` is larger than a specified `lt`
	// or `lte`, the range is reversed, and the field value must be outside the
	// specified range. If the field value doesn't meet the required conditions,
	// an error message is generated.
	//
	// “`proto
	//
	//	message MyFloat {
	//	  // value must be greater than or equal to 5.0 [float.gte]
	//	  float value = 1 [(buf.validate.field).float.gte = 5.0];
	//
	//	  // value must be greater than or equal to 5.0 and less than 10.0 [float.gte_lt]
	//	  float other_value = 2 [(buf.validate.field).float = { gte: 5.0, lt: 10.0 }];
	//
	//	  // value must be greater than or equal to 10.0 or less than 5.0 [float.gte_lt_exclusive]
	//	  float another_value = 3 [(buf.validate.field).float = { gte: 10.0, lt: 5.0 }];
	//	}
	//
	// “`
	Gte float32 `protobuf:"fixed32,5,opt,name=gte,oneof"`
}

type FloatRules_Lt struct {
	// `lt` requires the field value to be less than the specified value (field <
	// value). If the field value is equal to or greater than the specified value,
	// an error message is generated.
	//
	// “`proto
	//
	//	message MyFloat {
	//	  // value must be less than 10.0
	//	  float value = 1 [(buf.validate.field).float.lt = 10.0];
	//	}
	//
	// “`
	Lt float32 `protobuf:"fixed32,2,opt,name=lt,oneof"`
}

type FloatRules_Lte struct {
	// `lte` requires the field value to be less than or equal to the specified
	// value (field <= value). If the field value is greater than the specified
	// value, an error message is generated.
	//
	// “`proto
	//
	//	message MyFloat {
	//	  // value must be less than or equal to 10.0
	//	  float value = 1 [(buf.validate.field).float.lte = 10.0];
	//	}
	//
	// “`
	Lte float32 `protobuf:"fixed32,3,opt,name=lte,oneof"`
}

type Ignore int32

type Int32Rules struct {

	// `const` requires the field value to exactly match the specified value. If
	// the field value doesn't match, an error message is generated.
	//
	// “`proto
	//
	//	message MyInt32 {
	//	  // value must equal 42
	//	  int32 value = 1 [(buf.validate.field).int32.const = 42];
	//	}
	//
	// “`
	Const *int32 `protobuf:"varint,1,opt,name=const" json:"const,omitempty"`
	// Types that are valid to be assigned to LessThan:
	//
	//	*Int32Rules_Lt
	//	*Int32Rules_Lte
	LessThan isInt32Rules_LessThan `protobuf_oneof:"less_than"`
	// Types that are valid to be assigned to GreaterThan:
	//
	//	*Int32Rules_Gt
	//	*Int32Rules_Gte
	GreaterThan isInt32Rules_GreaterThan `protobuf_oneof:"greater_than"`
	// `in` requires the field value to be equal to one of the specified values.
	// If the field value isn't one of the specified values, an error message is
	// generated.
	//
	// “`proto
	//
	//	message MyInt32 {
	//	  // value must be in list [1, 2, 3]
	//	  int32 value = 1 [(buf.validate.field).int32 = { in: [1, 2, 3] }];
	//	}
	//
	// “`
	In []int32 `protobuf:"varint,6,rep,name=in" json:"in,omitempty"`
	// `not_in` requires the field value to not be equal to any of the specified
	// values. If the field value is one of the specified values, an error message
	// is generated.
	//
	// “`proto
	//
	//	message MyInt32 {
	//	  // value must not be in list [1, 2, 3]
	//	  int32 value = 1 [(buf.validate.field).int32 = { not_in: [1, 2, 3] }];
	//	}
	//
	// “`
	NotIn []int32 `protobuf:"varint,7,rep,name=not_in,json=notIn" json:"not_in,omitempty"`
	// `example` specifies values that the field may have. These values SHOULD
	// conform to other rules. `example` values will not impact validation
	// but may be used as helpful guidance on how to populate the given field.
	//
	// “`proto
	//
	//	message MyInt32 {
	//	  int32 value = 1 [
	//	    (buf.validate.field).int32.example = 1,
	//	    (buf.validate.field).int32.example = -10
	//	  ];
	//	}
	//
	// “`
	Example []int32 `protobuf:"varint,8,rep,name=example" json:"example,omitempty"`
	// contains filtered or unexported fields
}

type Int32Rules_Gt struct {
	// `gt` requires the field value to be greater than the specified value
	// (exclusive). If the value of `gt` is larger than a specified `lt` or
	// `lte`, the range is reversed, and the field value must be outside the
	// specified range. If the field value doesn't meet the required conditions,
	// an error message is generated.
	//
	// “`proto
	//
	//	message MyInt32 {
	//	  // value must be greater than 5 [int32.gt]
	//	  int32 value = 1 [(buf.validate.field).int32.gt = 5];
	//
	//	  // value must be greater than 5 and less than 10 [int32.gt_lt]
	//	  int32 other_value = 2 [(buf.validate.field).int32 = { gt: 5, lt: 10 }];
	//
	//	  // value must be greater than 10 or less than 5 [int32.gt_lt_exclusive]
	//	  int32 another_value = 3 [(buf.validate.field).int32 = { gt: 10, lt: 5 }];
	//	}
	//
	// “`
	Gt int32 `protobuf:"varint,4,opt,name=gt,oneof"`
}

type Int32Rules_Gte struct {
	// `gte` requires the field value to be greater than or equal to the specified value
	// (exclusive). If the value of `gte` is larger than a specified `lt` or
	// `lte`, the range is reversed, and the field value must be outside the
	// specified range. If the field value doesn't meet the required conditions,
	// an error message is generated.
	//
	// “`proto
	//
	//	message MyInt32 {
	//	  // value must be greater than or equal to 5 [int32.gte]
	//	  int32 value = 1 [(buf.validate.field).int32.gte = 5];
	//
	//	  // value must be greater than or equal to 5 and less than 10 [int32.gte_lt]
	//	  int32 other_value = 2 [(buf.validate.field).int32 = { gte: 5, lt: 10 }];
	//
	//	  // value must be greater than or equal to 10 or less than 5 [int32.gte_lt_exclusive]
	//	  int32 another_value = 3 [(buf.validate.field).int32 = { gte: 10, lt: 5 }];
	//	}
	//
	// “`
	Gte int32 `protobuf:"varint,5,opt,name=gte,oneof"`
}

type Int32Rules_Lt struct {
	// `lt` requires the field value to be less than the specified value (field
	// < value). If the field value is equal to or greater than the specified
	// value, an error message is generated.
	//
	// “`proto
	//
	//	message MyInt32 {
	//	  // value must be less than 10
	//	  int32 value = 1 [(buf.validate.field).int32.lt = 10];
	//	}
	//
	// “`
	Lt int32 `protobuf:"varint,2,opt,name=lt,oneof"`
}

type Int32Rules_Lte struct {
	// `lte` requires the field value to be less than or equal to the specified
	// value (field <= value). If the field value is greater than the specified
	// value, an error message is generated.
	//
	// “`proto
	//
	//	message MyInt32 {
	//	  // value must be less than or equal to 10
	//	  int32 value = 1 [(buf.validate.field).int32.lte = 10];
	//	}
	//
	// “`
	Lte int32 `protobuf:"varint,3,opt,name=lte,oneof"`
}

type Int64Rules struct {

	// `const` requires the field value to exactly match the specified value. If
	// the field value doesn't match, an error message is generated.
	//
	// “`proto
	//
	//	message MyInt64 {
	//	  // value must equal 42
	//	  int64 value = 1 [(buf.validate.field).int64.const = 42];
	//	}
	//
	// “`
	Const *int64 `protobuf:"varint,1,opt,name=const" json:"const,omitempty"`
	// Types that are valid to be assigned to LessThan:
	//
	//	*Int64Rules_Lt
	//	*Int64Rules_Lte
	LessThan isInt64Rules_LessThan `protobuf_oneof:"less_than"`
	// Types that are valid to be assigned to GreaterThan:
	//
	//	*Int64Rules_Gt
	//	*Int64Rules_Gte
	GreaterThan isInt64Rules_GreaterThan `protobuf_oneof:"greater_than"`
	// `in` requires the field value to be equal to one of the specified values.
	// If the field value isn't one of the specified values, an error message is
	// generated.
	//
	// “`proto
	//
	//	message MyInt64 {
	//	  // value must be in list [1, 2, 3]
	//	  int64 value = 1 [(buf.validate.field).int64 = { in: [1, 2, 3] }];
	//	}
	//
	// “`
	In []int64 `protobuf:"varint,6,rep,name=in" json:"in,omitempty"`
	// `not_in` requires the field value to not be equal to any of the specified
	// values. If the field value is one of the specified values, an error
	// message is generated.
	//
	// “`proto
	//
	//	message MyInt64 {
	//	  // value must not be in list [1, 2, 3]
	//	  int64 value = 1 [(buf.validate.field).int64 = { not_in: [1, 2, 3] }];
	//	}
	//
	// “`
	NotIn []int64 `protobuf:"varint,7,rep,name=not_in,json=notIn" json:"not_in,omitempty"`
	// `example` specifies values that the field may have. These values SHOULD
	// conform to other rules. `example` values will not impact validation
	// but may be used as helpful guidance on how to populate the given field.
	//
	// “`proto
	//
	//	message MyInt64 {
	//	  int64 value = 1 [
	//	    (buf.validate.field).int64.example = 1,
	//	    (buf.validate.field).int64.example = -10
	//	  ];
	//	}
	//
	// “`
	Example []int64 `protobuf:"varint,9,rep,name=example" json:"example,omitempty"`
	// contains filtered or unexported fields
}

type Int64Rules_Gt struct {
	// `gt` requires the field value to be greater than the specified value
	// (exclusive). If the value of `gt` is larger than a specified `lt` or
	// `lte`, the range is reversed, and the field value must be outside the
	// specified range. If the field value doesn't meet the required conditions,
	// an error message is generated.
	//
	// “`proto
	//
	//	message MyInt64 {
	//	  // value must be greater than 5 [int64.gt]
	//	  int64 value = 1 [(buf.validate.field).int64.gt = 5];
	//
	//	  // value must be greater than 5 and less than 10 [int64.gt_lt]
	//	  int64 other_value = 2 [(buf.validate.field).int64 = { gt: 5, lt: 10 }];
	//
	//	  // value must be greater than 10 or less than 5 [int64.gt_lt_exclusive]
	//	  int64 another_value = 3 [(buf.validate.field).int64 = { gt: 10, lt: 5 }];
	//	}
	//
	// “`
	Gt int64 `protobuf:"varint,4,opt,name=gt,oneof"`
}

type Int64Rules_Gte struct {
	// `gte` requires the field value to be greater than or equal to the specified
	// value (exclusive). If the value of `gte` is larger than a specified `lt`
	// or `lte`, the range is reversed, and the field value must be outside the
	// specified range. If the field value doesn't meet the required conditions,
	// an error message is generated.
	//
	// “`proto
	//
	//	message MyInt64 {
	//	  // value must be greater than or equal to 5 [int64.gte]
	//	  int64 value = 1 [(buf.validate.field).int64.gte = 5];
	//
	//	  // value must be greater than or equal to 5 and less than 10 [int64.gte_lt]
	//	  int64 other_value = 2 [(buf.validate.field).int64 = { gte: 5, lt: 10 }];
	//
	//	  // value must be greater than or equal to 10 or less than 5 [int64.gte_lt_exclusive]
	//	  int64 another_value = 3 [(buf.validate.field).int64 = { gte: 10, lt: 5 }];
	//	}
	//
	// “`
	Gte int64 `protobuf:"varint,5,opt,name=gte,oneof"`
}

type Int64Rules_Lt struct {
	// `lt` requires the field value to be less than the specified value (field <
	// value). If the field value is equal to or greater than the specified value,
	// an error message is generated.
	//
	// “`proto
	//
	//	message MyInt64 {
	//	  // value must be less than 10
	//	  int64 value = 1 [(buf.validate.field).int64.lt = 10];
	//	}
	//
	// “`
	Lt int64 `protobuf:"varint,2,opt,name=lt,oneof"`
}

type Int64Rules_Lte struct {
	// `lte` requires the field value to be less than or equal to the specified
	// value (field <= value). If the field value is greater than the specified
	// value, an error message is generated.
	//
	// “`proto
	//
	//	message MyInt64 {
	//	  // value must be less than or equal to 10
	//	  int64 value = 1 [(buf.validate.field).int64.lte = 10];
	//	}
	//
	// “`
	Lte int64 `protobuf:"varint,3,opt,name=lte,oneof"`
}

type KnownRegex int32

type MapRules struct {

	// Specifies the minimum number of key-value pairs allowed. If the field has
	// fewer key-value pairs than specified, an error message is generated.
	//
	// “`proto
	//
	//	message MyMap {
	//	  // The field `value` must have at least 2 key-value pairs.
	//	  map<string, string> value = 1 [(buf.validate.field).map.min_pairs = 2];
	//	}
	//
	// “`
	MinPairs *uint64 `protobuf:"varint,1,opt,name=min_pairs,json=minPairs" json:"min_pairs,omitempty"`
	// Specifies the maximum number of key-value pairs allowed. If the field has
	// more key-value pairs than specified, an error message is generated.
	//
	// “`proto
	//
	//	message MyMap {
	//	  // The field `value` must have at most 3 key-value pairs.
	//	  map<string, string> value = 1 [(buf.validate.field).map.max_pairs = 3];
	//	}
	//
	// “`
	MaxPairs *uint64 `protobuf:"varint,2,opt,name=max_pairs,json=maxPairs" json:"max_pairs,omitempty"`
	// Specifies the rules to be applied to each key in the field.
	//
	// “`proto
	//
	//	message MyMap {
	//	  // The keys in the field `value` must follow the specified rules.
	//	  map<string, string> value = 1 [(buf.validate.field).map.keys = {
	//	    string: {
	//	      min_len: 3
	//	      max_len: 10
	//	    }
	//	  }];
	//	}
	//
	// “`
	//
	// Note that the `required` rule does not apply. Map keys cannot be unset.
	Keys *FieldRules `protobuf:"bytes,4,opt,name=keys" json:"keys,omitempty"`
	// Specifies the rules to be applied to the value of each key in the
	// field. Message values will still have their validations evaluated unless
	// `ignore` is specified.
	//
	// “`proto
	//
	//	message MyMap {
	//	  // The values in the field `value` must follow the specified rules.
	//	  map<string, string> value = 1 [(buf.validate.field).map.values = {
	//	    string: {
	//	      min_len: 5
	//	      max_len: 20
	//	    }
	//	  }];
	//	}
	//
	// “`
	// Note that the `required` rule does not apply. Map values cannot be unset.
	Values *FieldRules `protobuf:"bytes,5,opt,name=values" json:"values,omitempty"`
	// contains filtered or unexported fields
}

type MessageOneofRule struct {

	// A list of field names to include in the oneof. All field names must be
	// defined in the message. At least one field must be specified, and
	// duplicates are not permitted.
	Fields []string `protobuf:"bytes,1,rep,name=fields" json:"fields,omitempty"`
	// If true, one of the fields specified _must_ be set.
	Required *bool `protobuf:"varint,2,opt,name=required" json:"required,omitempty"`
	// contains filtered or unexported fields
}

type MessageRules struct {

	// `cel_expression` is a repeated field CEL expressions. Each expression specifies a validation
	// rule to be applied to this message. These rules are written in Common Expression Language (CEL) syntax.
	//
	// This is a simplified form of the `cel` Rule field, where only `expression` is set. This allows for
	// simpler syntax when defining CEL Rules where `id` and `message` derived from the `expression`. `id` will
	// be same as the `expression`.
	//
	// For more information, [see our documentation](https://buf.build/docs/protovalidate/schemas/custom-rules/).
	//
	// “`proto
	//
	//	message MyMessage {
	//	  // The field `foo` must be greater than 42.
	//	  option (buf.validate.message).cel_expression = "this.foo > 42";
	//	  // The field `foo` must be less than 84.
	//	  option (buf.validate.message).cel_expression = "this.foo < 84";
	//	  optional int32 foo = 1;
	//	}
	//
	// “`
	CelExpression []string `protobuf:"bytes,5,rep,name=cel_expression,json=celExpression" json:"cel_expression,omitempty"`
	// `cel` is a repeated field of type Rule. Each Rule specifies a validation rule to be applied to this message.
	// These rules are written in Common Expression Language (CEL) syntax. For more information,
	// [see our documentation](https://buf.build/docs/protovalidate/schemas/custom-rules/).
	//
	// “`proto
	//
	//	message MyMessage {
	//	  // The field `foo` must be greater than 42.
	//	  option (buf.validate.message).cel = {
	//	    id: "my_message.value",
	//	    message: "value must be greater than 42",
	//	    expression: "this.foo > 42",
	//	  };
	//	  optional int32 foo = 1;
	//	}
	//
	// “`
	Cel []*Rule `protobuf:"bytes,3,rep,name=cel" json:"cel,omitempty"`
	// `oneof` is a repeated field of type MessageOneofRule that specifies a list of fields
	// of which at most one can be present. If `required` is also specified, then exactly one
	// of the specified fields _must_ be present.
	//
	// This will enforce oneof-like constraints with a few features not provided by
	// actual Protobuf oneof declarations:
	//  1. Repeated and map fields are allowed in this validation. In a Protobuf oneof,
	//     only scalar fields are allowed.
	//  2. Fields with implicit presence are allowed. In a Protobuf oneof, all member
	//     fields have explicit presence. This means that, for the purpose of determining
	//     how many fields are set, explicitly setting such a field to its zero value is
	//     effectively the same as not setting it at all.
	//  3. This will always generate validation errors for a message unmarshalled from
	//     serialized data that sets more than one field. With a Protobuf oneof, when
	//     multiple fields are present in the serialized form, earlier values are usually
	//     silently ignored when unmarshalling, with only the last field being set when
	//     unmarshalling completes.
	//
	// Note that adding a field to a `oneof` will also set the IGNORE_IF_ZERO_VALUE on the fields. This means
	// only the field that is set will be validated and the unset fields are not validated according to the field rules.
	// This behavior can be overridden by setting `ignore` against a field.
	//
	// “`proto
	//
	//	message MyMessage {
	//	  // Only one of `field1` or `field2` _can_ be present in this message.
	//	  option (buf.validate.message).oneof = { fields: ["field1", "field2"] };
	//	  // Exactly one of `field3` or `field4` _must_ be present in this message.
	//	  option (buf.validate.message).oneof = { fields: ["field3", "field4"], required: true };
	//	  string field1 = 1;
	//	  bytes field2 = 2;
	//	  bool field3 = 3;
	//	  int32 field4 = 4;
	//	}
	//
	// “`
	Oneof []*MessageOneofRule `protobuf:"bytes,4,rep,name=oneof" json:"oneof,omitempty"`
	// contains filtered or unexported fields
}

type OneofRules struct {

	// If `required` is true, exactly one field of the oneof must be set. A
	// validation error is returned if no fields in the oneof are set. Further rules
	// should be placed on the fields themselves to ensure they are valid values,
	// such as `min_len` or `gt`.
	//
	// “`proto
	//
	//	message MyMessage {
	//	  oneof value {
	//	    // Either `a` or `b` must be set. If `a` is set, it must also be
	//	    // non-empty; whereas if `b` is set, it can still be an empty string.
	//	    option (buf.validate.oneof).required = true;
	//	    string a = 1 [(buf.validate.field).string.min_len = 1];
	//	    string b = 2;
	//	  }
	//	}
	//
	// “`
	Required *bool `protobuf:"varint,1,opt,name=required" json:"required,omitempty"`
	// contains filtered or unexported fields
}

type PredefinedRules struct {

	// `cel` is a repeated field used to represent a textual expression
	// in the Common Expression Language (CEL) syntax. For more information,
	// [see our documentation](https://buf.build/docs/protovalidate/schemas/predefined-rules/).
	//
	// “`proto
	//
	//	message MyMessage {
	//	  // The field `value` must be greater than 42.
	//	  optional int32 value = 1 [(buf.validate.predefined).cel = {
	//	    id: "my_message.value",
	//	    message: "value must be greater than 42",
	//	    expression: "this > 42",
	//	  }];
	//	}
	//
	// “`
	Cel []*Rule `protobuf:"bytes,1,rep,name=cel" json:"cel,omitempty"`
	// contains filtered or unexported fields
}

type RepeatedRules struct {

	// `min_items` requires that this field must contain at least the specified
	// minimum number of items.
	//
	// Note that `min_items = 1` is equivalent to setting a field as `required`.
	//
	// “`proto
	//
	//	message MyRepeated {
	//	  // value must contain at least  2 items
	//	  repeated string value = 1 [(buf.validate.field).repeated.min_items = 2];
	//	}
	//
	// “`
	MinItems *uint64 `protobuf:"varint,1,opt,name=min_items,json=minItems" json:"min_items,omitempty"`
	// `max_items` denotes that this field must not exceed a
	// certain number of items as the upper limit. If the field contains more
	// items than specified, an error message will be generated, requiring the
	// field to maintain no more than the specified number of items.
	//
	// “`proto
	//
	//	message MyRepeated {
	//	  // value must contain no more than 3 item(s)
	//	  repeated string value = 1 [(buf.validate.field).repeated.max_items = 3];
	//	}
	//
	// “`
	MaxItems *uint64 `protobuf:"varint,2,opt,name=max_items,json=maxItems" json:"max_items,omitempty"`
	// `unique` indicates that all elements in this field must
	// be unique. This rule is strictly applicable to scalar and enum
	// types, with message types not being supported.
	//
	// “`proto
	//
	//	message MyRepeated {
	//	  // repeated value must contain unique items
	//	  repeated string value = 1 [(buf.validate.field).repeated.unique = true];
	//	}
	//
	// “`
	Unique *bool `protobuf:"varint,3,opt,name=unique" json:"unique,omitempty"`
	// `items` details the rules to be applied to each item
	// in the field. Even for repeated message fields, validation is executed
	// against each item unless `ignore` is specified.
	//
	// “`proto
	//
	//	message MyRepeated {
	//	  // The items in the field `value` must follow the specified rules.
	//	  repeated string value = 1 [(buf.validate.field).repeated.items = {
	//	    string: {
	//	      min_len: 3
	//	      max_len: 10
	//	    }
	//	  }];
	//	}
	//
	// “`
	//
	// Note that the `required` rule does not apply. Repeated items
	// cannot be unset.
	Items *FieldRules `protobuf:"bytes,4,opt,name=items" json:"items,omitempty"`
	// contains filtered or unexported fields
}

type Rule struct {

	// `id` is a string that serves as a machine-readable name for this Rule.
	// It should be unique within its scope, which could be either a message or a field.
	Id *string `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
	// `message` is an optional field that provides a human-readable error message
	// for this Rule when the CEL expression evaluates to false. If a
	// non-empty message is provided, any strings resulting from the CEL
	// expression evaluation are ignored.
	Message *string `protobuf:"bytes,2,opt,name=message" json:"message,omitempty"`
	// `expression` is the actual CEL expression that will be evaluated for
	// validation. This string must resolve to either a boolean or a string
	// value. If the expression evaluates to false or a non-empty string, the
	// validation is considered failed, and the message is rejected.
	Expression *string `protobuf:"bytes,3,opt,name=expression" json:"expression,omitempty"`
	// contains filtered or unexported fields
}

type SFixed32Rules struct {

	// `const` requires the field value to exactly match the specified value. If
	// the field value doesn't match, an error message is generated.
	//
	// “`proto
	//
	//	message MySFixed32 {
	//	  // value must equal 42
	//	  sfixed32 value = 1 [(buf.validate.field).sfixed32.const = 42];
	//	}
	//
	// “`
	Const *int32 `protobuf:"fixed32,1,opt,name=const" json:"const,omitempty"`
	// Types that are valid to be assigned to LessThan:
	//
	//	*SFixed32Rules_Lt
	//	*SFixed32Rules_Lte
	LessThan isSFixed32Rules_LessThan `protobuf_oneof:"less_than"`
	// Types that are valid to be assigned to GreaterThan:
	//
	//	*SFixed32Rules_Gt
	//	*SFixed32Rules_Gte
	GreaterThan isSFixed32Rules_GreaterThan `protobuf_oneof:"greater_than"`
	// `in` requires the field value to be equal to one of the specified values.
	// If the field value isn't one of the specified values, an error message is
	// generated.
	//
	// “`proto
	//
	//	message MySFixed32 {
	//	  // value must be in list [1, 2, 3]
	//	  sfixed32 value = 1 [(buf.validate.field).sfixed32 = { in: [1, 2, 3] }];
	//	}
	//
	// “`
	In []int32 `protobuf:"fixed32,6,rep,name=in" json:"in,omitempty"`
	// `not_in` requires the field value to not be equal to any of the specified
	// values. If the field value is one of the specified values, an error
	// message is generated.
	//
	// “`proto
	//
	//	message MySFixed32 {
	//	  // value must not be in list [1, 2, 3]
	//	  sfixed32 value = 1 [(buf.validate.field).sfixed32 = { not_in: [1, 2, 3] }];
	//	}
	//
	// “`
	NotIn []int32 `protobuf:"fixed32,7,rep,name=not_in,json=notIn" json:"not_in,omitempty"`
	// `example` specifies values that the field may have. These values SHOULD
	// conform to other rules. `example` values will not impact validation
	// but may be used as helpful guidance on how to populate the given field.
	//
	// “`proto
	//
	//	message MySFixed32 {
	//	  sfixed32 value = 1 [
	//	    (buf.validate.field).sfixed32.example = 1,
	//	    (buf.validate.field).sfixed32.example = 2
	//	  ];
	//	}
	//
	// “`
	Example []int32 `protobuf:"fixed32,8,rep,name=example" json:"example,omitempty"`
	// contains filtered or unexported fields
}

type SFixed32Rules_Gt struct {
	// `gt` requires the field value to be greater than the specified value
	// (exclusive). If the value of `gt` is larger than a specified `lt` or
	// `lte`, the range is reversed, and the field value must be outside the
	// specified range. If the field value doesn't meet the required conditions,
	// an error message is generated.
	//
	// “`proto
	//
	//	message MySFixed32 {
	//	  // value must be greater than 5 [sfixed32.gt]
	//	  sfixed32 value = 1 [(buf.validate.field).sfixed32.gt = 5];
	//
	//	  // value must be greater than 5 and less than 10 [sfixed32.gt_lt]
	//	  sfixed32 other_value = 2 [(buf.validate.field).sfixed32 = { gt: 5, lt: 10 }];
	//
	//	  // value must be greater than 10 or less than 5 [sfixed32.gt_lt_exclusive]
	//	  sfixed32 another_value = 3 [(buf.validate.field).sfixed32 = { gt: 10, lt: 5 }];
	//	}
	//
	// “`
	Gt int32 `protobuf:"fixed32,4,opt,name=gt,oneof"`
}

type SFixed32Rules_Gte struct {
	// `gte` requires the field value to be greater than or equal to the specified
	// value (exclusive). If the value of `gte` is larger than a specified `lt`
	// or `lte`, the range is reversed, and the field value must be outside the
	// specified range. If the field value doesn't meet the required conditions,
	// an error message is generated.
	//
	// “`proto
	//
	//	message MySFixed32 {
	//	  // value must be greater than or equal to 5 [sfixed32.gte]
	//	  sfixed32 value = 1 [(buf.validate.field).sfixed32.gte = 5];
	//
	//	  // value must be greater than or equal to 5 and less than 10 [sfixed32.gte_lt]
	//	  sfixed32 other_value = 2 [(buf.validate.field).sfixed32 = { gte: 5, lt: 10 }];
	//
	//	  // value must be greater than or equal to 10 or less than 5 [sfixed32.gte_lt_exclusive]
	//	  sfixed32 another_value = 3 [(buf.validate.field).sfixed32 = { gte: 10, lt: 5 }];
	//	}
	//
	// “`
	Gte int32 `protobuf:"fixed32,5,opt,name=gte,oneof"`
}

type SFixed32Rules_Lt struct {
	// `lt` requires the field value to be less than the specified value (field <
	// value). If the field value is equal to or greater than the specified value,
	// an error message is generated.
	//
	// “`proto
	//
	//	message MySFixed32 {
	//	  // value must be less than 10
	//	  sfixed32 value = 1 [(buf.validate.field).sfixed32.lt = 10];
	//	}
	//
	// “`
	Lt int32 `protobuf:"fixed32,2,opt,name=lt,oneof"`
}

type SFixed32Rules_Lte struct {
	// `lte` requires the field value to be less than or equal to the specified
	// value (field <= value). If the field value is greater than the specified
	// value, an error message is generated.
	//
	// “`proto
	//
	//	message MySFixed32 {
	//	  // value must be less than or equal to 10
	//	  sfixed32 value = 1 [(buf.validate.field).sfixed32.lte = 10];
	//	}
	//
	// “`
	Lte int32 `protobuf:"fixed32,3,opt,name=lte,oneof"`
}

type SFixed64Rules struct {

	// `const` requires the field value to exactly match the specified value. If
	// the field value doesn't match, an error message is generated.
	//
	// “`proto
	//
	//	message MySFixed64 {
	//	  // value must equal 42
	//	  sfixed64 value = 1 [(buf.validate.field).sfixed64.const = 42];
	//	}
	//
	// “`
	Const *int64 `protobuf:"fixed64,1,opt,name=const" json:"const,omitempty"`
	// Types that are valid to be assigned to LessThan:
	//
	//	*SFixed64Rules_Lt
	//	*SFixed64Rules_Lte
	LessThan isSFixed64Rules_LessThan `protobuf_oneof:"less_than"`
	// Types that are valid to be assigned to GreaterThan:
	//
	//	*SFixed64Rules_Gt
	//	*SFixed64Rules_Gte
	GreaterThan isSFixed64Rules_GreaterThan `protobuf_oneof:"greater_than"`
	// `in` requires the field value to be equal to one of the specified values.
	// If the field value isn't one of the specified values, an error message is
	// generated.
	//
	// “`proto
	//
	//	message MySFixed64 {
	//	  // value must be in list [1, 2, 3]
	//	  sfixed64 value = 1 [(buf.validate.field).sfixed64 = { in: [1, 2, 3] }];
	//	}
	//
	// “`
	In []int64 `protobuf:"fixed64,6,rep,name=in" json:"in,omitempty"`
	// `not_in` requires the field value to not be equal to any of the specified
	// values. If the field value is one of the specified values, an error
	// message is generated.
	//
	// “`proto
	//
	//	message MySFixed64 {
	//	  // value must not be in list [1, 2, 3]
	//	  sfixed64 value = 1 [(buf.validate.field).sfixed64 = { not_in: [1, 2, 3] }];
	//	}
	//
	// “`
	NotIn []int64 `protobuf:"fixed64,7,rep,name=not_in,json=notIn" json:"not_in,omitempty"`
	// `example` specifies values that the field may have. These values SHOULD
	// conform to other rules. `example` values will not impact validation
	// but may be used as helpful guidance on how to populate the given field.
	//
	// “`proto
	//
	//	message MySFixed64 {
	//	  sfixed64 value = 1 [
	//	    (buf.validate.field).sfixed64.example = 1,
	//	    (buf.validate.field).sfixed64.example = 2
	//	  ];
	//	}
	//
	// “`
	Example []int64 `protobuf:"fixed64,8,rep,name=example" json:"example,omitempty"`
	// contains filtered or unexported fields
}

type SFixed64Rules_Gt struct {
	// `gt` requires the field value to be greater than the specified value
	// (exclusive). If the value of `gt` is larger than a specified `lt` or
	// `lte`, the range is reversed, and the field value must be outside the
	// specified range. If the field value doesn't meet the required conditions,
	// an error message is generated.
	//
	// “`proto
	//
	//	message MySFixed64 {
	//	  // value must be greater than 5 [sfixed64.gt]
	//	  sfixed64 value = 1 [(buf.validate.field).sfixed64.gt = 5];
	//
	//	  // value must be greater than 5 and less than 10 [sfixed64.gt_lt]
	//	  sfixed64 other_value = 2 [(buf.validate.field).sfixed64 = { gt: 5, lt: 10 }];
	//
	//	  // value must be greater than 10 or less than 5 [sfixed64.gt_lt_exclusive]
	//	  sfixed64 another_value = 3 [(buf.validate.field).sfixed64 = { gt: 10, lt: 5 }];
	//	}
	//
	// “`
	Gt int64 `protobuf:"fixed64,4,opt,name=gt,oneof"`
}

type SFixed64Rules_Gte struct {
	// `gte` requires the field value to be greater than or equal to the specified
	// value (exclusive). If the value of `gte` is larger than a specified `lt`
	// or `lte`, the range is reversed, and the field value must be outside the
	// specified range. If the field value doesn't meet the required conditions,
	// an error message is generated.
	//
	// “`proto
	//
	//	message MySFixed64 {
	//	  // value must be greater than or equal to 5 [sfixed64.gte]
	//	  sfixed64 value = 1 [(buf.validate.field).sfixed64.gte = 5];
	//
	//	  // value must be greater than or equal to 5 and less than 10 [sfixed64.gte_lt]
	//	  sfixed64 other_value = 2 [(buf.validate.field).sfixed64 = { gte: 5, lt: 10 }];
	//
	//	  // value must be greater than or equal to 10 or less than 5 [sfixed64.gte_lt_exclusive]
	//	  sfixed64 another_value = 3 [(buf.validate.field).sfixed64 = { gte: 10, lt: 5 }];
	//	}
	//
	// “`
	Gte int64 `protobuf:"fixed64,5,opt,name=gte,oneof"`
}

type SFixed64Rules_Lt struct {
	// `lt` requires the field value to be less than the specified value (field <
	// value). If the field value is equal to or greater than the specified value,
	// an error message is generated.
	//
	// “`proto
	//
	//	message MySFixed64 {
	//	  // value must be less than 10
	//	  sfixed64 value = 1 [(buf.validate.field).sfixed64.lt = 10];
	//	}
	//
	// “`
	Lt int64 `protobuf:"fixed64,2,opt,name=lt,oneof"`
}

type SFixed64Rules_Lte struct {
	// `lte` requires the field value to be less than or equal to the specified
	// value (field <= value). If the field value is greater than the specified
	// value, an error message is generated.
	//
	// “`proto
	//
	//	message MySFixed64 {
	//	  // value must be less than or equal to 10
	//	  sfixed64 value = 1 [(buf.validate.field).sfixed64.lte = 10];
	//	}
	//
	// “`
	Lte int64 `protobuf:"fixed64,3,opt,name=lte,oneof"`
}

type SInt32Rules struct {

	// `const` requires the field value to exactly match the specified value. If
	// the field value doesn't match, an error message is generated.
	//
	// “`proto
	//
	//	message MySInt32 {
	//	  // value must equal 42
	//	  sint32 value = 1 [(buf.validate.field).sint32.const = 42];
	//	}
	//
	// “`
	Const *int32 `protobuf:"zigzag32,1,opt,name=const" json:"const,omitempty"`
	// Types that are valid to be assigned to LessThan:
	//
	//	*SInt32Rules_Lt
	//	*SInt32Rules_Lte
	LessThan isSInt32Rules_LessThan `protobuf_oneof:"less_than"`
	// Types that are valid to be assigned to GreaterThan:
	//
	//	*SInt32Rules_Gt
	//	*SInt32Rules_Gte
	GreaterThan isSInt32Rules_GreaterThan `protobuf_oneof:"greater_than"`
	// `in` requires the field value to be equal to one of the specified values.
	// If the field value isn't one of the specified values, an error message is
	// generated.
	//
	// “`proto
	//
	//	message MySInt32 {
	//	  // value must be in list [1, 2, 3]
	//	  sint32 value = 1 [(buf.validate.field).sint32 = { in: [1, 2, 3] }];
	//	}
	//
	// “`
	In []int32 `protobuf:"zigzag32,6,rep,name=in" json:"in,omitempty"`
	// `not_in` requires the field value to not be equal to any of the specified
	// values. If the field value is one of the specified values, an error
	// message is generated.
	//
	// “`proto
	//
	//	message MySInt32 {
	//	  // value must not be in list [1, 2, 3]
	//	  sint32 value = 1 [(buf.validate.field).sint32 = { not_in: [1, 2, 3] }];
	//	}
	//
	// “`
	NotIn []int32 `protobuf:"zigzag32,7,rep,name=not_in,json=notIn" json:"not_in,omitempty"`
	// `example` specifies values that the field may have. These values SHOULD
	// conform to other rules. `example` values will not impact validation
	// but may be used as helpful guidance on how to populate the given field.
	//
	// “`proto
	//
	//	message MySInt32 {
	//	  sint32 value = 1 [
	//	    (buf.validate.field).sint32.example = 1,
	//	    (buf.validate.field).sint32.example = -10
	//	  ];
	//	}
	//
	// “`
	Example []int32 `protobuf:"zigzag32,8,rep,name=example" json:"example,omitempty"`
	// contains filtered or unexported fields
}