// Copyright 2023-2025 Buf Technologies, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.6
// 	protoc        (unknown)
// source: buf/validate/conformance/cases/predefined_rules_proto2.proto

//go:build !protoopaque

package cases

import (
	validate "buf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go/buf/validate"
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	durationpb "google.golang.org/protobuf/types/known/durationpb"
	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
	wrapperspb "google.golang.org/protobuf/types/known/wrapperspb"
	reflect "reflect"
	unsafe "unsafe"
)

const (
	// Verify that this generated code is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
	// Verify that runtime/protoimpl is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)

type PredefinedEnumRuleProto2_EnumProto2 int32

const (
	PredefinedEnumRuleProto2_ENUM_PROTO2_ZERO_UNSPECIFIED PredefinedEnumRuleProto2_EnumProto2 = 0
	PredefinedEnumRuleProto2_ENUM_PROTO2_ONE              PredefinedEnumRuleProto2_EnumProto2 = 1
)

// Enum value maps for PredefinedEnumRuleProto2_EnumProto2.
var (
	PredefinedEnumRuleProto2_EnumProto2_name = map[int32]string{
		0: "ENUM_PROTO2_ZERO_UNSPECIFIED",
		1: "ENUM_PROTO2_ONE",
	}
	PredefinedEnumRuleProto2_EnumProto2_value = map[string]int32{
		"ENUM_PROTO2_ZERO_UNSPECIFIED": 0,
		"ENUM_PROTO2_ONE":              1,
	}
)

func (x PredefinedEnumRuleProto2_EnumProto2) Enum() *PredefinedEnumRuleProto2_EnumProto2 {
	p := new(PredefinedEnumRuleProto2_EnumProto2)
	*p = x
	return p
}

func (x PredefinedEnumRuleProto2_EnumProto2) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (PredefinedEnumRuleProto2_EnumProto2) Descriptor() protoreflect.EnumDescriptor {
	return file_buf_validate_conformance_cases_predefined_rules_proto2_proto_enumTypes[0].Descriptor()
}

func (PredefinedEnumRuleProto2_EnumProto2) Type() protoreflect.EnumType {
	return &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_enumTypes[0]
}

func (x PredefinedEnumRuleProto2_EnumProto2) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

type PredefinedFloatRuleProto2 struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           *float32               `protobuf:"fixed32,1,opt,name=val" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PredefinedFloatRuleProto2) Reset() {
	*x = PredefinedFloatRuleProto2{}
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[0]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PredefinedFloatRuleProto2) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PredefinedFloatRuleProto2) ProtoMessage() {}

func (x *PredefinedFloatRuleProto2) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[0]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *PredefinedFloatRuleProto2) GetVal() float32 {
	if x != nil && x.Val != nil {
		return *x.Val
	}
	return 0
}

func (x *PredefinedFloatRuleProto2) SetVal(v float32) {
	x.Val = &v
}

func (x *PredefinedFloatRuleProto2) HasVal() bool {
	if x == nil {
		return false
	}
	return x.Val != nil
}

func (x *PredefinedFloatRuleProto2) ClearVal() {
	x.Val = nil
}

type PredefinedFloatRuleProto2_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val *float32
}

func (b0 PredefinedFloatRuleProto2_builder) Build() *PredefinedFloatRuleProto2 {
	m0 := &PredefinedFloatRuleProto2{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type PredefinedDoubleRuleProto2 struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           *float64               `protobuf:"fixed64,1,opt,name=val" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PredefinedDoubleRuleProto2) Reset() {
	*x = PredefinedDoubleRuleProto2{}
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[1]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PredefinedDoubleRuleProto2) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PredefinedDoubleRuleProto2) ProtoMessage() {}

func (x *PredefinedDoubleRuleProto2) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[1]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *PredefinedDoubleRuleProto2) GetVal() float64 {
	if x != nil && x.Val != nil {
		return *x.Val
	}
	return 0
}

func (x *PredefinedDoubleRuleProto2) SetVal(v float64) {
	x.Val = &v
}

func (x *PredefinedDoubleRuleProto2) HasVal() bool {
	if x == nil {
		return false
	}
	return x.Val != nil
}

func (x *PredefinedDoubleRuleProto2) ClearVal() {
	x.Val = nil
}

type PredefinedDoubleRuleProto2_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val *float64
}

func (b0 PredefinedDoubleRuleProto2_builder) Build() *PredefinedDoubleRuleProto2 {
	m0 := &PredefinedDoubleRuleProto2{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type PredefinedInt32RuleProto2 struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           *int32                 `protobuf:"varint,1,opt,name=val" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PredefinedInt32RuleProto2) Reset() {
	*x = PredefinedInt32RuleProto2{}
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[2]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PredefinedInt32RuleProto2) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PredefinedInt32RuleProto2) ProtoMessage() {}

func (x *PredefinedInt32RuleProto2) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[2]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *PredefinedInt32RuleProto2) GetVal() int32 {
	if x != nil && x.Val != nil {
		return *x.Val
	}
	return 0
}

func (x *PredefinedInt32RuleProto2) SetVal(v int32) {
	x.Val = &v
}

func (x *PredefinedInt32RuleProto2) HasVal() bool {
	if x == nil {
		return false
	}
	return x.Val != nil
}

func (x *PredefinedInt32RuleProto2) ClearVal() {
	x.Val = nil
}

type PredefinedInt32RuleProto2_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val *int32
}

func (b0 PredefinedInt32RuleProto2_builder) Build() *PredefinedInt32RuleProto2 {
	m0 := &PredefinedInt32RuleProto2{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type PredefinedInt64RuleProto2 struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           *int64                 `protobuf:"varint,1,opt,name=val" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PredefinedInt64RuleProto2) Reset() {
	*x = PredefinedInt64RuleProto2{}
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[3]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PredefinedInt64RuleProto2) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PredefinedInt64RuleProto2) ProtoMessage() {}

func (x *PredefinedInt64RuleProto2) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[3]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *PredefinedInt64RuleProto2) GetVal() int64 {
	if x != nil && x.Val != nil {
		return *x.Val
	}
	return 0
}

func (x *PredefinedInt64RuleProto2) SetVal(v int64) {
	x.Val = &v
}

func (x *PredefinedInt64RuleProto2) HasVal() bool {
	if x == nil {
		return false
	}
	return x.Val != nil
}

func (x *PredefinedInt64RuleProto2) ClearVal() {
	x.Val = nil
}

type PredefinedInt64RuleProto2_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val *int64
}

func (b0 PredefinedInt64RuleProto2_builder) Build() *PredefinedInt64RuleProto2 {
	m0 := &PredefinedInt64RuleProto2{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type PredefinedUInt32RuleProto2 struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           *uint32                `protobuf:"varint,1,opt,name=val" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PredefinedUInt32RuleProto2) Reset() {
	*x = PredefinedUInt32RuleProto2{}
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[4]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PredefinedUInt32RuleProto2) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PredefinedUInt32RuleProto2) ProtoMessage() {}

func (x *PredefinedUInt32RuleProto2) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[4]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *PredefinedUInt32RuleProto2) GetVal() uint32 {
	if x != nil && x.Val != nil {
		return *x.Val
	}
	return 0
}

func (x *PredefinedUInt32RuleProto2) SetVal(v uint32) {
	x.Val = &v
}

func (x *PredefinedUInt32RuleProto2) HasVal() bool {
	if x == nil {
		return false
	}
	return x.Val != nil
}

func (x *PredefinedUInt32RuleProto2) ClearVal() {
	x.Val = nil
}

type PredefinedUInt32RuleProto2_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val *uint32
}

func (b0 PredefinedUInt32RuleProto2_builder) Build() *PredefinedUInt32RuleProto2 {
	m0 := &PredefinedUInt32RuleProto2{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type PredefinedUInt64RuleProto2 struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           *uint64                `protobuf:"varint,1,opt,name=val" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PredefinedUInt64RuleProto2) Reset() {
	*x = PredefinedUInt64RuleProto2{}
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[5]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PredefinedUInt64RuleProto2) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PredefinedUInt64RuleProto2) ProtoMessage() {}

func (x *PredefinedUInt64RuleProto2) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[5]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *PredefinedUInt64RuleProto2) GetVal() uint64 {
	if x != nil && x.Val != nil {
		return *x.Val
	}
	return 0
}

func (x *PredefinedUInt64RuleProto2) SetVal(v uint64) {
	x.Val = &v
}

func (x *PredefinedUInt64RuleProto2) HasVal() bool {
	if x == nil {
		return false
	}
	return x.Val != nil
}

func (x *PredefinedUInt64RuleProto2) ClearVal() {
	x.Val = nil
}

type PredefinedUInt64RuleProto2_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val *uint64
}

func (b0 PredefinedUInt64RuleProto2_builder) Build() *PredefinedUInt64RuleProto2 {
	m0 := &PredefinedUInt64RuleProto2{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type PredefinedSInt32RuleProto2 struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           *int32                 `protobuf:"zigzag32,1,opt,name=val" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PredefinedSInt32RuleProto2) Reset() {
	*x = PredefinedSInt32RuleProto2{}
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[6]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PredefinedSInt32RuleProto2) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PredefinedSInt32RuleProto2) ProtoMessage() {}

func (x *PredefinedSInt32RuleProto2) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[6]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *PredefinedSInt32RuleProto2) GetVal() int32 {
	if x != nil && x.Val != nil {
		return *x.Val
	}
	return 0
}

func (x *PredefinedSInt32RuleProto2) SetVal(v int32) {
	x.Val = &v
}

func (x *PredefinedSInt32RuleProto2) HasVal() bool {
	if x == nil {
		return false
	}
	return x.Val != nil
}

func (x *PredefinedSInt32RuleProto2) ClearVal() {
	x.Val = nil
}

type PredefinedSInt32RuleProto2_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val *int32
}

func (b0 PredefinedSInt32RuleProto2_builder) Build() *PredefinedSInt32RuleProto2 {
	m0 := &PredefinedSInt32RuleProto2{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type PredefinedSInt64RuleProto2 struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           *int64                 `protobuf:"zigzag64,1,opt,name=val" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PredefinedSInt64RuleProto2) Reset() {
	*x = PredefinedSInt64RuleProto2{}
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[7]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PredefinedSInt64RuleProto2) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PredefinedSInt64RuleProto2) ProtoMessage() {}

func (x *PredefinedSInt64RuleProto2) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[7]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *PredefinedSInt64RuleProto2) GetVal() int64 {
	if x != nil && x.Val != nil {
		return *x.Val
	}
	return 0
}

func (x *PredefinedSInt64RuleProto2) SetVal(v int64) {
	x.Val = &v
}

func (x *PredefinedSInt64RuleProto2) HasVal() bool {
	if x == nil {
		return false
	}
	return x.Val != nil
}

func (x *PredefinedSInt64RuleProto2) ClearVal() {
	x.Val = nil
}

type PredefinedSInt64RuleProto2_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val *int64
}

func (b0 PredefinedSInt64RuleProto2_builder) Build() *PredefinedSInt64RuleProto2 {
	m0 := &PredefinedSInt64RuleProto2{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type PredefinedFixed32RuleProto2 struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           *uint32                `protobuf:"fixed32,1,opt,name=val" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PredefinedFixed32RuleProto2) Reset() {
	*x = PredefinedFixed32RuleProto2{}
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[8]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PredefinedFixed32RuleProto2) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PredefinedFixed32RuleProto2) ProtoMessage() {}

func (x *PredefinedFixed32RuleProto2) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[8]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *PredefinedFixed32RuleProto2) GetVal() uint32 {
	if x != nil && x.Val != nil {
		return *x.Val
	}
	return 0
}

func (x *PredefinedFixed32RuleProto2) SetVal(v uint32) {
	x.Val = &v
}

func (x *PredefinedFixed32RuleProto2) HasVal() bool {
	if x == nil {
		return false
	}
	return x.Val != nil
}

func (x *PredefinedFixed32RuleProto2) ClearVal() {
	x.Val = nil
}

type PredefinedFixed32RuleProto2_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val *uint32
}

func (b0 PredefinedFixed32RuleProto2_builder) Build() *PredefinedFixed32RuleProto2 {
	m0 := &PredefinedFixed32RuleProto2{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type PredefinedFixed64RuleProto2 struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           *uint64                `protobuf:"fixed64,1,opt,name=val" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PredefinedFixed64RuleProto2) Reset() {
	*x = PredefinedFixed64RuleProto2{}
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[9]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PredefinedFixed64RuleProto2) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PredefinedFixed64RuleProto2) ProtoMessage() {}

func (x *PredefinedFixed64RuleProto2) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[9]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *PredefinedFixed64RuleProto2) GetVal() uint64 {
	if x != nil && x.Val != nil {
		return *x.Val
	}
	return 0
}

func (x *PredefinedFixed64RuleProto2) SetVal(v uint64) {
	x.Val = &v
}

func (x *PredefinedFixed64RuleProto2) HasVal() bool {
	if x == nil {
		return false
	}
	return x.Val != nil
}

func (x *PredefinedFixed64RuleProto2) ClearVal() {
	x.Val = nil
}

type PredefinedFixed64RuleProto2_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val *uint64
}

func (b0 PredefinedFixed64RuleProto2_builder) Build() *PredefinedFixed64RuleProto2 {
	m0 := &PredefinedFixed64RuleProto2{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type PredefinedSFixed32RuleProto2 struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           *int32                 `protobuf:"fixed32,1,opt,name=val" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PredefinedSFixed32RuleProto2) Reset() {
	*x = PredefinedSFixed32RuleProto2{}
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[10]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PredefinedSFixed32RuleProto2) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PredefinedSFixed32RuleProto2) ProtoMessage() {}

func (x *PredefinedSFixed32RuleProto2) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[10]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *PredefinedSFixed32RuleProto2) GetVal() int32 {
	if x != nil && x.Val != nil {
		return *x.Val
	}
	return 0
}

func (x *PredefinedSFixed32RuleProto2) SetVal(v int32) {
	x.Val = &v
}

func (x *PredefinedSFixed32RuleProto2) HasVal() bool {
	if x == nil {
		return false
	}
	return x.Val != nil
}

func (x *PredefinedSFixed32RuleProto2) ClearVal() {
	x.Val = nil
}

type PredefinedSFixed32RuleProto2_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val *int32
}

func (b0 PredefinedSFixed32RuleProto2_builder) Build() *PredefinedSFixed32RuleProto2 {
	m0 := &PredefinedSFixed32RuleProto2{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type PredefinedSFixed64RuleProto2 struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           *int64                 `protobuf:"fixed64,1,opt,name=val" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PredefinedSFixed64RuleProto2) Reset() {
	*x = PredefinedSFixed64RuleProto2{}
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[11]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PredefinedSFixed64RuleProto2) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PredefinedSFixed64RuleProto2) ProtoMessage() {}

func (x *PredefinedSFixed64RuleProto2) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[11]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *PredefinedSFixed64RuleProto2) GetVal() int64 {
	if x != nil && x.Val != nil {
		return *x.Val
	}
	return 0
}

func (x *PredefinedSFixed64RuleProto2) SetVal(v int64) {
	x.Val = &v
}

func (x *PredefinedSFixed64RuleProto2) HasVal() bool {
	if x == nil {
		return false
	}
	return x.Val != nil
}

func (x *PredefinedSFixed64RuleProto2) ClearVal() {
	x.Val = nil
}

type PredefinedSFixed64RuleProto2_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val *int64
}

func (b0 PredefinedSFixed64RuleProto2_builder) Build() *PredefinedSFixed64RuleProto2 {
	m0 := &PredefinedSFixed64RuleProto2{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type PredefinedBoolRuleProto2 struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           *bool                  `protobuf:"varint,1,opt,name=val" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PredefinedBoolRuleProto2) Reset() {
	*x = PredefinedBoolRuleProto2{}
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[12]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PredefinedBoolRuleProto2) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PredefinedBoolRuleProto2) ProtoMessage() {}

func (x *PredefinedBoolRuleProto2) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[12]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *PredefinedBoolRuleProto2) GetVal() bool {
	if x != nil && x.Val != nil {
		return *x.Val
	}
	return false
}

func (x *PredefinedBoolRuleProto2) SetVal(v bool) {
	x.Val = &v
}

func (x *PredefinedBoolRuleProto2) HasVal() bool {
	if x == nil {
		return false
	}
	return x.Val != nil
}

func (x *PredefinedBoolRuleProto2) ClearVal() {
	x.Val = nil
}

type PredefinedBoolRuleProto2_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val *bool
}

func (b0 PredefinedBoolRuleProto2_builder) Build() *PredefinedBoolRuleProto2 {
	m0 := &PredefinedBoolRuleProto2{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type PredefinedStringRuleProto2 struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           *string                `protobuf:"bytes,1,opt,name=val" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PredefinedStringRuleProto2) Reset() {
	*x = PredefinedStringRuleProto2{}
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[13]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PredefinedStringRuleProto2) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PredefinedStringRuleProto2) ProtoMessage() {}

func (x *PredefinedStringRuleProto2) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[13]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *PredefinedStringRuleProto2) GetVal() string {
	if x != nil && x.Val != nil {
		return *x.Val
	}
	return ""
}

func (x *PredefinedStringRuleProto2) SetVal(v string) {
	x.Val = &v
}

func (x *PredefinedStringRuleProto2) HasVal() bool {
	if x == nil {
		return false
	}
	return x.Val != nil
}

func (x *PredefinedStringRuleProto2) ClearVal() {
	x.Val = nil
}

type PredefinedStringRuleProto2_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val *string
}

func (b0 PredefinedStringRuleProto2_builder) Build() *PredefinedStringRuleProto2 {
	m0 := &PredefinedStringRuleProto2{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type PredefinedBytesRuleProto2 struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           []byte                 `protobuf:"bytes,1,opt,name=val" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PredefinedBytesRuleProto2) Reset() {
	*x = PredefinedBytesRuleProto2{}
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[14]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PredefinedBytesRuleProto2) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PredefinedBytesRuleProto2) ProtoMessage() {}

func (x *PredefinedBytesRuleProto2) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[14]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *PredefinedBytesRuleProto2) GetVal() []byte {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *PredefinedBytesRuleProto2) SetVal(v []byte) {
	if v == nil {
		v = []byte{}
	}
	x.Val = v
}

func (x *PredefinedBytesRuleProto2) HasVal() bool {
	if x == nil {
		return false
	}
	return x.Val != nil
}

func (x *PredefinedBytesRuleProto2) ClearVal() {
	x.Val = nil
}

type PredefinedBytesRuleProto2_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val []byte
}

func (b0 PredefinedBytesRuleProto2_builder) Build() *PredefinedBytesRuleProto2 {
	m0 := &PredefinedBytesRuleProto2{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type PredefinedEnumRuleProto2 struct {
	state         protoimpl.MessageState               `protogen:"hybrid.v1"`
	Val           *PredefinedEnumRuleProto2_EnumProto2 `protobuf:"varint,1,opt,name=val,enum=buf.validate.conformance.cases.PredefinedEnumRuleProto2_EnumProto2" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PredefinedEnumRuleProto2) Reset() {
	*x = PredefinedEnumRuleProto2{}
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[15]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PredefinedEnumRuleProto2) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PredefinedEnumRuleProto2) ProtoMessage() {}

func (x *PredefinedEnumRuleProto2) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[15]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *PredefinedEnumRuleProto2) GetVal() PredefinedEnumRuleProto2_EnumProto2 {
	if x != nil && x.Val != nil {
		return *x.Val
	}
	return PredefinedEnumRuleProto2_ENUM_PROTO2_ZERO_UNSPECIFIED
}

func (x *PredefinedEnumRuleProto2) SetVal(v PredefinedEnumRuleProto2_EnumProto2) {
	x.Val = &v
}

func (x *PredefinedEnumRuleProto2) HasVal() bool {
	if x == nil {
		return false
	}
	return x.Val != nil
}

func (x *PredefinedEnumRuleProto2) ClearVal() {
	x.Val = nil
}

type PredefinedEnumRuleProto2_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val *PredefinedEnumRuleProto2_EnumProto2
}

func (b0 PredefinedEnumRuleProto2_builder) Build() *PredefinedEnumRuleProto2 {
	m0 := &PredefinedEnumRuleProto2{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type PredefinedRepeatedRuleProto2 struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           []uint64               `protobuf:"varint,1,rep,name=val" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PredefinedRepeatedRuleProto2) Reset() {
	*x = PredefinedRepeatedRuleProto2{}
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[16]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PredefinedRepeatedRuleProto2) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PredefinedRepeatedRuleProto2) ProtoMessage() {}

func (x *PredefinedRepeatedRuleProto2) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[16]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *PredefinedRepeatedRuleProto2) GetVal() []uint64 {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *PredefinedRepeatedRuleProto2) SetVal(v []uint64) {
	x.Val = v
}

type PredefinedRepeatedRuleProto2_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val []uint64
}

func (b0 PredefinedRepeatedRuleProto2_builder) Build() *PredefinedRepeatedRuleProto2 {
	m0 := &PredefinedRepeatedRuleProto2{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type PredefinedDurationRuleProto2 struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           *durationpb.Duration   `protobuf:"bytes,1,opt,name=val" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PredefinedDurationRuleProto2) Reset() {
	*x = PredefinedDurationRuleProto2{}
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[17]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PredefinedDurationRuleProto2) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PredefinedDurationRuleProto2) ProtoMessage() {}

func (x *PredefinedDurationRuleProto2) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[17]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *PredefinedDurationRuleProto2) GetVal() *durationpb.Duration {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *PredefinedDurationRuleProto2) SetVal(v *durationpb.Duration) {
	x.Val = v
}

func (x *PredefinedDurationRuleProto2) HasVal() bool {
	if x == nil {
		return false
	}
	return x.Val != nil
}

func (x *PredefinedDurationRuleProto2) ClearVal() {
	x.Val = nil
}

type PredefinedDurationRuleProto2_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val *durationpb.Duration
}

func (b0 PredefinedDurationRuleProto2_builder) Build() *PredefinedDurationRuleProto2 {
	m0 := &PredefinedDurationRuleProto2{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type PredefinedTimestampRuleProto2 struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=val" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PredefinedTimestampRuleProto2) Reset() {
	*x = PredefinedTimestampRuleProto2{}
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[18]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PredefinedTimestampRuleProto2) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PredefinedTimestampRuleProto2) ProtoMessage() {}

func (x *PredefinedTimestampRuleProto2) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[18]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *PredefinedTimestampRuleProto2) GetVal() *timestamppb.Timestamp {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *PredefinedTimestampRuleProto2) SetVal(v *timestamppb.Timestamp) {
	x.Val = v
}

func (x *PredefinedTimestampRuleProto2) HasVal() bool {
	if x == nil {
		return false
	}
	return x.Val != nil
}

func (x *PredefinedTimestampRuleProto2) ClearVal() {
	x.Val = nil
}

type PredefinedTimestampRuleProto2_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val *timestamppb.Timestamp
}

func (b0 PredefinedTimestampRuleProto2_builder) Build() *PredefinedTimestampRuleProto2 {
	m0 := &PredefinedTimestampRuleProto2{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type PredefinedWrappedFloatRuleProto2 struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           *wrapperspb.FloatValue `protobuf:"bytes,1,opt,name=val" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PredefinedWrappedFloatRuleProto2) Reset() {
	*x = PredefinedWrappedFloatRuleProto2{}
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[19]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PredefinedWrappedFloatRuleProto2) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PredefinedWrappedFloatRuleProto2) ProtoMessage() {}

func (x *PredefinedWrappedFloatRuleProto2) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[19]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *PredefinedWrappedFloatRuleProto2) GetVal() *wrapperspb.FloatValue {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *PredefinedWrappedFloatRuleProto2) SetVal(v *wrapperspb.FloatValue) {
	x.Val = v
}

func (x *PredefinedWrappedFloatRuleProto2) HasVal() bool {
	if x == nil {
		return false
	}
	return x.Val != nil
}

func (x *PredefinedWrappedFloatRuleProto2) ClearVal() {
	x.Val = nil
}

type PredefinedWrappedFloatRuleProto2_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val *wrapperspb.FloatValue
}

func (b0 PredefinedWrappedFloatRuleProto2_builder) Build() *PredefinedWrappedFloatRuleProto2 {
	m0 := &PredefinedWrappedFloatRuleProto2{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type PredefinedWrappedDoubleRuleProto2 struct {
	state         protoimpl.MessageState  `protogen:"hybrid.v1"`
	Val           *wrapperspb.DoubleValue `protobuf:"bytes,1,opt,name=val" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PredefinedWrappedDoubleRuleProto2) Reset() {
	*x = PredefinedWrappedDoubleRuleProto2{}
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[20]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PredefinedWrappedDoubleRuleProto2) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PredefinedWrappedDoubleRuleProto2) ProtoMessage() {}

func (x *PredefinedWrappedDoubleRuleProto2) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[20]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *PredefinedWrappedDoubleRuleProto2) GetVal() *wrapperspb.DoubleValue {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *PredefinedWrappedDoubleRuleProto2) SetVal(v *wrapperspb.DoubleValue) {
	x.Val = v
}

func (x *PredefinedWrappedDoubleRuleProto2) HasVal() bool {
	if x == nil {
		return false
	}
	return x.Val != nil
}

func (x *PredefinedWrappedDoubleRuleProto2) ClearVal() {
	x.Val = nil
}

type PredefinedWrappedDoubleRuleProto2_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val *wrapperspb.DoubleValue
}

func (b0 PredefinedWrappedDoubleRuleProto2_builder) Build() *PredefinedWrappedDoubleRuleProto2 {
	m0 := &PredefinedWrappedDoubleRuleProto2{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type PredefinedWrappedInt32RuleProto2 struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           *wrapperspb.Int32Value `protobuf:"bytes,1,opt,name=val" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PredefinedWrappedInt32RuleProto2) Reset() {
	*x = PredefinedWrappedInt32RuleProto2{}
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[21]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PredefinedWrappedInt32RuleProto2) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PredefinedWrappedInt32RuleProto2) ProtoMessage() {}

func (x *PredefinedWrappedInt32RuleProto2) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[21]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *PredefinedWrappedInt32RuleProto2) GetVal() *wrapperspb.Int32Value {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *PredefinedWrappedInt32RuleProto2) SetVal(v *wrapperspb.Int32Value) {
	x.Val = v
}

func (x *PredefinedWrappedInt32RuleProto2) HasVal() bool {
	if x == nil {
		return false
	}
	return x.Val != nil
}

func (x *PredefinedWrappedInt32RuleProto2) ClearVal() {
	x.Val = nil
}

type PredefinedWrappedInt32RuleProto2_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val *wrapperspb.Int32Value
}

func (b0 PredefinedWrappedInt32RuleProto2_builder) Build() *PredefinedWrappedInt32RuleProto2 {
	m0 := &PredefinedWrappedInt32RuleProto2{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type PredefinedWrappedInt64RuleProto2 struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           *wrapperspb.Int64Value `protobuf:"bytes,1,opt,name=val" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PredefinedWrappedInt64RuleProto2) Reset() {
	*x = PredefinedWrappedInt64RuleProto2{}
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[22]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PredefinedWrappedInt64RuleProto2) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PredefinedWrappedInt64RuleProto2) ProtoMessage() {}

func (x *PredefinedWrappedInt64RuleProto2) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[22]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *PredefinedWrappedInt64RuleProto2) GetVal() *wrapperspb.Int64Value {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *PredefinedWrappedInt64RuleProto2) SetVal(v *wrapperspb.Int64Value) {
	x.Val = v
}

func (x *PredefinedWrappedInt64RuleProto2) HasVal() bool {
	if x == nil {
		return false
	}
	return x.Val != nil
}

func (x *PredefinedWrappedInt64RuleProto2) ClearVal() {
	x.Val = nil
}

type PredefinedWrappedInt64RuleProto2_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val *wrapperspb.Int64Value
}

func (b0 PredefinedWrappedInt64RuleProto2_builder) Build() *PredefinedWrappedInt64RuleProto2 {
	m0 := &PredefinedWrappedInt64RuleProto2{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type PredefinedWrappedUInt32RuleProto2 struct {
	state         protoimpl.MessageState  `protogen:"hybrid.v1"`
	Val           *wrapperspb.UInt32Value `protobuf:"bytes,1,opt,name=val" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PredefinedWrappedUInt32RuleProto2) Reset() {
	*x = PredefinedWrappedUInt32RuleProto2{}
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[23]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PredefinedWrappedUInt32RuleProto2) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PredefinedWrappedUInt32RuleProto2) ProtoMessage() {}

func (x *PredefinedWrappedUInt32RuleProto2) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[23]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *PredefinedWrappedUInt32RuleProto2) GetVal() *wrapperspb.UInt32Value {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *PredefinedWrappedUInt32RuleProto2) SetVal(v *wrapperspb.UInt32Value) {
	x.Val = v
}

func (x *PredefinedWrappedUInt32RuleProto2) HasVal() bool {
	if x == nil {
		return false
	}
	return x.Val != nil
}

func (x *PredefinedWrappedUInt32RuleProto2) ClearVal() {
	x.Val = nil
}

type PredefinedWrappedUInt32RuleProto2_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val *wrapperspb.UInt32Value
}

func (b0 PredefinedWrappedUInt32RuleProto2_builder) Build() *PredefinedWrappedUInt32RuleProto2 {
	m0 := &PredefinedWrappedUInt32RuleProto2{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type PredefinedWrappedUInt64RuleProto2 struct {
	state         protoimpl.MessageState  `protogen:"hybrid.v1"`
	Val           *wrapperspb.UInt64Value `protobuf:"bytes,1,opt,name=val" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PredefinedWrappedUInt64RuleProto2) Reset() {
	*x = PredefinedWrappedUInt64RuleProto2{}
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[24]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PredefinedWrappedUInt64RuleProto2) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PredefinedWrappedUInt64RuleProto2) ProtoMessage() {}

func (x *PredefinedWrappedUInt64RuleProto2) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[24]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *PredefinedWrappedUInt64RuleProto2) GetVal() *wrapperspb.UInt64Value {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *PredefinedWrappedUInt64RuleProto2) SetVal(v *wrapperspb.UInt64Value) {
	x.Val = v
}

func (x *PredefinedWrappedUInt64RuleProto2) HasVal() bool {
	if x == nil {
		return false
	}
	return x.Val != nil
}

func (x *PredefinedWrappedUInt64RuleProto2) ClearVal() {
	x.Val = nil
}

type PredefinedWrappedUInt64RuleProto2_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val *wrapperspb.UInt64Value
}

func (b0 PredefinedWrappedUInt64RuleProto2_builder) Build() *PredefinedWrappedUInt64RuleProto2 {
	m0 := &PredefinedWrappedUInt64RuleProto2{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type PredefinedWrappedBoolRuleProto2 struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           *wrapperspb.BoolValue  `protobuf:"bytes,1,opt,name=val" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PredefinedWrappedBoolRuleProto2) Reset() {
	*x = PredefinedWrappedBoolRuleProto2{}
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[25]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PredefinedWrappedBoolRuleProto2) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PredefinedWrappedBoolRuleProto2) ProtoMessage() {}

func (x *PredefinedWrappedBoolRuleProto2) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[25]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *PredefinedWrappedBoolRuleProto2) GetVal() *wrapperspb.BoolValue {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *PredefinedWrappedBoolRuleProto2) SetVal(v *wrapperspb.BoolValue) {
	x.Val = v
}

func (x *PredefinedWrappedBoolRuleProto2) HasVal() bool {
	if x == nil {
		return false
	}
	return x.Val != nil
}

func (x *PredefinedWrappedBoolRuleProto2) ClearVal() {
	x.Val = nil
}

type PredefinedWrappedBoolRuleProto2_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val *wrapperspb.BoolValue
}

func (b0 PredefinedWrappedBoolRuleProto2_builder) Build() *PredefinedWrappedBoolRuleProto2 {
	m0 := &PredefinedWrappedBoolRuleProto2{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type PredefinedWrappedStringRuleProto2 struct {
	state         protoimpl.MessageState  `protogen:"hybrid.v1"`
	Val           *wrapperspb.StringValue `protobuf:"bytes,1,opt,name=val" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PredefinedWrappedStringRuleProto2) Reset() {
	*x = PredefinedWrappedStringRuleProto2{}
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[26]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PredefinedWrappedStringRuleProto2) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PredefinedWrappedStringRuleProto2) ProtoMessage() {}

func (x *PredefinedWrappedStringRuleProto2) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[26]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *PredefinedWrappedStringRuleProto2) GetVal() *wrapperspb.StringValue {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *PredefinedWrappedStringRuleProto2) SetVal(v *wrapperspb.StringValue) {
	x.Val = v
}

func (x *PredefinedWrappedStringRuleProto2) HasVal() bool {
	if x == nil {
		return false
	}
	return x.Val != nil
}

func (x *PredefinedWrappedStringRuleProto2) ClearVal() {
	x.Val = nil
}

type PredefinedWrappedStringRuleProto2_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val *wrapperspb.StringValue
}

func (b0 PredefinedWrappedStringRuleProto2_builder) Build() *PredefinedWrappedStringRuleProto2 {
	m0 := &PredefinedWrappedStringRuleProto2{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type PredefinedWrappedBytesRuleProto2 struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           *wrapperspb.BytesValue `protobuf:"bytes,1,opt,name=val" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PredefinedWrappedBytesRuleProto2) Reset() {
	*x = PredefinedWrappedBytesRuleProto2{}
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[27]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PredefinedWrappedBytesRuleProto2) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PredefinedWrappedBytesRuleProto2) ProtoMessage() {}

func (x *PredefinedWrappedBytesRuleProto2) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[27]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *PredefinedWrappedBytesRuleProto2) GetVal() *wrapperspb.BytesValue {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *PredefinedWrappedBytesRuleProto2) SetVal(v *wrapperspb.BytesValue) {
	x.Val = v
}

func (x *PredefinedWrappedBytesRuleProto2) HasVal() bool {
	if x == nil {
		return false
	}
	return x.Val != nil
}

func (x *PredefinedWrappedBytesRuleProto2) ClearVal() {
	x.Val = nil
}

type PredefinedWrappedBytesRuleProto2_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val *wrapperspb.BytesValue
}

func (b0 PredefinedWrappedBytesRuleProto2_builder) Build() *PredefinedWrappedBytesRuleProto2 {
	m0 := &PredefinedWrappedBytesRuleProto2{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type PredefinedRepeatedWrappedFloatRuleProto2 struct {
	state         protoimpl.MessageState   `protogen:"hybrid.v1"`
	Val           []*wrapperspb.FloatValue `protobuf:"bytes,1,rep,name=val" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PredefinedRepeatedWrappedFloatRuleProto2) Reset() {
	*x = PredefinedRepeatedWrappedFloatRuleProto2{}
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[28]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PredefinedRepeatedWrappedFloatRuleProto2) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PredefinedRepeatedWrappedFloatRuleProto2) ProtoMessage() {}

func (x *PredefinedRepeatedWrappedFloatRuleProto2) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[28]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *PredefinedRepeatedWrappedFloatRuleProto2) GetVal() []*wrapperspb.FloatValue {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *PredefinedRepeatedWrappedFloatRuleProto2) SetVal(v []*wrapperspb.FloatValue) {
	x.Val = v
}

type PredefinedRepeatedWrappedFloatRuleProto2_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val []*wrapperspb.FloatValue
}

func (b0 PredefinedRepeatedWrappedFloatRuleProto2_builder) Build() *PredefinedRepeatedWrappedFloatRuleProto2 {
	m0 := &PredefinedRepeatedWrappedFloatRuleProto2{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type PredefinedRepeatedWrappedDoubleRuleProto2 struct {
	state         protoimpl.MessageState    `protogen:"hybrid.v1"`
	Val           []*wrapperspb.DoubleValue `protobuf:"bytes,1,rep,name=val" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PredefinedRepeatedWrappedDoubleRuleProto2) Reset() {
	*x = PredefinedRepeatedWrappedDoubleRuleProto2{}
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[29]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PredefinedRepeatedWrappedDoubleRuleProto2) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PredefinedRepeatedWrappedDoubleRuleProto2) ProtoMessage() {}

func (x *PredefinedRepeatedWrappedDoubleRuleProto2) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[29]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *PredefinedRepeatedWrappedDoubleRuleProto2) GetVal() []*wrapperspb.DoubleValue {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *PredefinedRepeatedWrappedDoubleRuleProto2) SetVal(v []*wrapperspb.DoubleValue) {
	x.Val = v
}

type PredefinedRepeatedWrappedDoubleRuleProto2_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val []*wrapperspb.DoubleValue
}

func (b0 PredefinedRepeatedWrappedDoubleRuleProto2_builder) Build() *PredefinedRepeatedWrappedDoubleRuleProto2 {
	m0 := &PredefinedRepeatedWrappedDoubleRuleProto2{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type PredefinedRepeatedWrappedInt32RuleProto2 struct {
	state         protoimpl.MessageState   `protogen:"hybrid.v1"`
	Val           []*wrapperspb.Int32Value `protobuf:"bytes,1,rep,name=val" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PredefinedRepeatedWrappedInt32RuleProto2) Reset() {
	*x = PredefinedRepeatedWrappedInt32RuleProto2{}
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[30]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PredefinedRepeatedWrappedInt32RuleProto2) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PredefinedRepeatedWrappedInt32RuleProto2) ProtoMessage() {}

func (x *PredefinedRepeatedWrappedInt32RuleProto2) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[30]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *PredefinedRepeatedWrappedInt32RuleProto2) GetVal() []*wrapperspb.Int32Value {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *PredefinedRepeatedWrappedInt32RuleProto2) SetVal(v []*wrapperspb.Int32Value) {
	x.Val = v
}

type PredefinedRepeatedWrappedInt32RuleProto2_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val []*wrapperspb.Int32Value
}

func (b0 PredefinedRepeatedWrappedInt32RuleProto2_builder) Build() *PredefinedRepeatedWrappedInt32RuleProto2 {
	m0 := &PredefinedRepeatedWrappedInt32RuleProto2{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type PredefinedRepeatedWrappedInt64RuleProto2 struct {
	state         protoimpl.MessageState   `protogen:"hybrid.v1"`
	Val           []*wrapperspb.Int64Value `protobuf:"bytes,1,rep,name=val" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PredefinedRepeatedWrappedInt64RuleProto2) Reset() {
	*x = PredefinedRepeatedWrappedInt64RuleProto2{}
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[31]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PredefinedRepeatedWrappedInt64RuleProto2) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PredefinedRepeatedWrappedInt64RuleProto2) ProtoMessage() {}

func (x *PredefinedRepeatedWrappedInt64RuleProto2) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[31]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *PredefinedRepeatedWrappedInt64RuleProto2) GetVal() []*wrapperspb.Int64Value {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *PredefinedRepeatedWrappedInt64RuleProto2) SetVal(v []*wrapperspb.Int64Value) {
	x.Val = v
}

type PredefinedRepeatedWrappedInt64RuleProto2_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val []*wrapperspb.Int64Value
}

func (b0 PredefinedRepeatedWrappedInt64RuleProto2_builder) Build() *PredefinedRepeatedWrappedInt64RuleProto2 {
	m0 := &PredefinedRepeatedWrappedInt64RuleProto2{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type PredefinedRepeatedWrappedUInt32RuleProto2 struct {
	state         protoimpl.MessageState    `protogen:"hybrid.v1"`
	Val           []*wrapperspb.UInt32Value `protobuf:"bytes,1,rep,name=val" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PredefinedRepeatedWrappedUInt32RuleProto2) Reset() {
	*x = PredefinedRepeatedWrappedUInt32RuleProto2{}
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[32]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PredefinedRepeatedWrappedUInt32RuleProto2) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PredefinedRepeatedWrappedUInt32RuleProto2) ProtoMessage() {}

func (x *PredefinedRepeatedWrappedUInt32RuleProto2) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[32]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *PredefinedRepeatedWrappedUInt32RuleProto2) GetVal() []*wrapperspb.UInt32Value {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *PredefinedRepeatedWrappedUInt32RuleProto2) SetVal(v []*wrapperspb.UInt32Value) {
	x.Val = v
}

type PredefinedRepeatedWrappedUInt32RuleProto2_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val []*wrapperspb.UInt32Value
}

func (b0 PredefinedRepeatedWrappedUInt32RuleProto2_builder) Build() *PredefinedRepeatedWrappedUInt32RuleProto2 {
	m0 := &PredefinedRepeatedWrappedUInt32RuleProto2{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type PredefinedRepeatedWrappedUInt64RuleProto2 struct {
	state         protoimpl.MessageState    `protogen:"hybrid.v1"`
	Val           []*wrapperspb.UInt64Value `protobuf:"bytes,1,rep,name=val" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PredefinedRepeatedWrappedUInt64RuleProto2) Reset() {
	*x = PredefinedRepeatedWrappedUInt64RuleProto2{}
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[33]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PredefinedRepeatedWrappedUInt64RuleProto2) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PredefinedRepeatedWrappedUInt64RuleProto2) ProtoMessage() {}

func (x *PredefinedRepeatedWrappedUInt64RuleProto2) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[33]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *PredefinedRepeatedWrappedUInt64RuleProto2) GetVal() []*wrapperspb.UInt64Value {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *PredefinedRepeatedWrappedUInt64RuleProto2) SetVal(v []*wrapperspb.UInt64Value) {
	x.Val = v
}

type PredefinedRepeatedWrappedUInt64RuleProto2_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val []*wrapperspb.UInt64Value
}

func (b0 PredefinedRepeatedWrappedUInt64RuleProto2_builder) Build() *PredefinedRepeatedWrappedUInt64RuleProto2 {
	m0 := &PredefinedRepeatedWrappedUInt64RuleProto2{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type PredefinedRepeatedWrappedBoolRuleProto2 struct {
	state         protoimpl.MessageState  `protogen:"hybrid.v1"`
	Val           []*wrapperspb.BoolValue `protobuf:"bytes,1,rep,name=val" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PredefinedRepeatedWrappedBoolRuleProto2) Reset() {
	*x = PredefinedRepeatedWrappedBoolRuleProto2{}
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[34]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PredefinedRepeatedWrappedBoolRuleProto2) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PredefinedRepeatedWrappedBoolRuleProto2) ProtoMessage() {}

func (x *PredefinedRepeatedWrappedBoolRuleProto2) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[34]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *PredefinedRepeatedWrappedBoolRuleProto2) GetVal() []*wrapperspb.BoolValue {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *PredefinedRepeatedWrappedBoolRuleProto2) SetVal(v []*wrapperspb.BoolValue) {
	x.Val = v
}

type PredefinedRepeatedWrappedBoolRuleProto2_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val []*wrapperspb.BoolValue
}

func (b0 PredefinedRepeatedWrappedBoolRuleProto2_builder) Build() *PredefinedRepeatedWrappedBoolRuleProto2 {
	m0 := &PredefinedRepeatedWrappedBoolRuleProto2{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type PredefinedRepeatedWrappedStringRuleProto2 struct {
	state         protoimpl.MessageState    `protogen:"hybrid.v1"`
	Val           []*wrapperspb.StringValue `protobuf:"bytes,1,rep,name=val" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PredefinedRepeatedWrappedStringRuleProto2) Reset() {
	*x = PredefinedRepeatedWrappedStringRuleProto2{}
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[35]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PredefinedRepeatedWrappedStringRuleProto2) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PredefinedRepeatedWrappedStringRuleProto2) ProtoMessage() {}

func (x *PredefinedRepeatedWrappedStringRuleProto2) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[35]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *PredefinedRepeatedWrappedStringRuleProto2) GetVal() []*wrapperspb.StringValue {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *PredefinedRepeatedWrappedStringRuleProto2) SetVal(v []*wrapperspb.StringValue) {
	x.Val = v
}

type PredefinedRepeatedWrappedStringRuleProto2_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val []*wrapperspb.StringValue
}

func (b0 PredefinedRepeatedWrappedStringRuleProto2_builder) Build() *PredefinedRepeatedWrappedStringRuleProto2 {
	m0 := &PredefinedRepeatedWrappedStringRuleProto2{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type PredefinedRepeatedWrappedBytesRuleProto2 struct {
	state         protoimpl.MessageState   `protogen:"hybrid.v1"`
	Val           []*wrapperspb.BytesValue `protobuf:"bytes,1,rep,name=val" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PredefinedRepeatedWrappedBytesRuleProto2) Reset() {
	*x = PredefinedRepeatedWrappedBytesRuleProto2{}
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[36]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PredefinedRepeatedWrappedBytesRuleProto2) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PredefinedRepeatedWrappedBytesRuleProto2) ProtoMessage() {}

func (x *PredefinedRepeatedWrappedBytesRuleProto2) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[36]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *PredefinedRepeatedWrappedBytesRuleProto2) GetVal() []*wrapperspb.BytesValue {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *PredefinedRepeatedWrappedBytesRuleProto2) SetVal(v []*wrapperspb.BytesValue) {
	x.Val = v
}

type PredefinedRepeatedWrappedBytesRuleProto2_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val []*wrapperspb.BytesValue
}

func (b0 PredefinedRepeatedWrappedBytesRuleProto2_builder) Build() *PredefinedRepeatedWrappedBytesRuleProto2 {
	m0 := &PredefinedRepeatedWrappedBytesRuleProto2{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type PredefinedAndCustomRuleProto2 struct {
	state         protoimpl.MessageState                `protogen:"hybrid.v1"`
	A             *int32                                `protobuf:"zigzag32,1,opt,name=a" json:"a,omitempty"`
	B             *PredefinedAndCustomRuleProto2_Nested `protobuf:"bytes,2,opt,name=b" json:"b,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PredefinedAndCustomRuleProto2) Reset() {
	*x = PredefinedAndCustomRuleProto2{}
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[37]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PredefinedAndCustomRuleProto2) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PredefinedAndCustomRuleProto2) ProtoMessage() {}

func (x *PredefinedAndCustomRuleProto2) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[37]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *PredefinedAndCustomRuleProto2) GetA() int32 {
	if x != nil && x.A != nil {
		return *x.A
	}
	return 0
}

func (x *PredefinedAndCustomRuleProto2) GetB() *PredefinedAndCustomRuleProto2_Nested {
	if x != nil {
		return x.B
	}
	return nil
}

func (x *PredefinedAndCustomRuleProto2) SetA(v int32) {
	x.A = &v
}

func (x *PredefinedAndCustomRuleProto2) SetB(v *PredefinedAndCustomRuleProto2_Nested) {
	x.B = v
}

func (x *PredefinedAndCustomRuleProto2) HasA() bool {
	if x == nil {
		return false
	}
	return x.A != nil
}

func (x *PredefinedAndCustomRuleProto2) HasB() bool {
	if x == nil {
		return false
	}
	return x.B != nil
}

func (x *PredefinedAndCustomRuleProto2) ClearA() {
	x.A = nil
}

func (x *PredefinedAndCustomRuleProto2) ClearB() {
	x.B = nil
}

type PredefinedAndCustomRuleProto2_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	A *int32
	B *PredefinedAndCustomRuleProto2_Nested
}

func (b0 PredefinedAndCustomRuleProto2_builder) Build() *PredefinedAndCustomRuleProto2 {
	m0 := &PredefinedAndCustomRuleProto2{}
	b, x := &b0, m0
	_, _ = b, x
	x.A = b.A
	x.B = b.B
	return m0
}

type StandardPredefinedAndCustomRuleProto2 struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	A             *int32                 `protobuf:"zigzag32,1,opt,name=a" json:"a,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *StandardPredefinedAndCustomRuleProto2) Reset() {
	*x = StandardPredefinedAndCustomRuleProto2{}
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[38]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *StandardPredefinedAndCustomRuleProto2) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*StandardPredefinedAndCustomRuleProto2) ProtoMessage() {}

func (x *StandardPredefinedAndCustomRuleProto2) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[38]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *StandardPredefinedAndCustomRuleProto2) GetA() int32 {
	if x != nil && x.A != nil {
		return *x.A
	}
	return 0
}

func (x *StandardPredefinedAndCustomRuleProto2) SetA(v int32) {
	x.A = &v
}

func (x *StandardPredefinedAndCustomRuleProto2) HasA() bool {
	if x == nil {
		return false
	}
	return x.A != nil
}

func (x *StandardPredefinedAndCustomRuleProto2) ClearA() {
	x.A = nil
}

type StandardPredefinedAndCustomRuleProto2_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	A *int32
}

func (b0 StandardPredefinedAndCustomRuleProto2_builder) Build() *StandardPredefinedAndCustomRuleProto2 {
	m0 := &StandardPredefinedAndCustomRuleProto2{}
	b, x := &b0, m0
	_, _ = b, x
	x.A = b.A
	return m0
}

type PredefinedAndCustomRuleProto2_Nested struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	C             *int32                 `protobuf:"zigzag32,1,opt,name=c" json:"c,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PredefinedAndCustomRuleProto2_Nested) Reset() {
	*x = PredefinedAndCustomRuleProto2_Nested{}
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[39]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PredefinedAndCustomRuleProto2_Nested) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PredefinedAndCustomRuleProto2_Nested) ProtoMessage() {}

func (x *PredefinedAndCustomRuleProto2_Nested) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes[39]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *PredefinedAndCustomRuleProto2_Nested) GetC() int32 {
	if x != nil && x.C != nil {
		return *x.C
	}
	return 0
}

func (x *PredefinedAndCustomRuleProto2_Nested) SetC(v int32) {
	x.C = &v
}

func (x *PredefinedAndCustomRuleProto2_Nested) HasC() bool {
	if x == nil {
		return false
	}
	return x.C != nil
}

func (x *PredefinedAndCustomRuleProto2_Nested) ClearC() {
	x.C = nil
}

type PredefinedAndCustomRuleProto2_Nested_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	C *int32
}

func (b0 PredefinedAndCustomRuleProto2_Nested_builder) Build() *PredefinedAndCustomRuleProto2_Nested {
	m0 := &PredefinedAndCustomRuleProto2_Nested{}
	b, x := &b0, m0
	_, _ = b, x
	x.C = b.C
	return m0
}

var file_buf_validate_conformance_cases_predefined_rules_proto2_proto_extTypes = []protoimpl.ExtensionInfo{
	{
		ExtendedType:  (*validate.FloatRules)(nil),
		ExtensionType: (*float32)(nil),
		Field:         1161,
		Name:          "buf.validate.conformance.cases.float_abs_range_proto2",
		Tag:           "fixed32,1161,opt,name=float_abs_range_proto2",
		Filename:      "buf/validate/conformance/cases/predefined_rules_proto2.proto",
	},
	{
		ExtendedType:  (*validate.DoubleRules)(nil),
		ExtensionType: (*float64)(nil),
		Field:         1161,
		Name:          "buf.validate.conformance.cases.double_abs_range_proto2",
		Tag:           "fixed64,1161,opt,name=double_abs_range_proto2",
		Filename:      "buf/validate/conformance/cases/predefined_rules_proto2.proto",
	},
	{
		ExtendedType:  (*validate.Int32Rules)(nil),
		ExtensionType: ([]int32)(nil),
		Field:         1161,
		Name:          "buf.validate.conformance.cases.int32_abs_in_proto2",
		Tag:           "varint,1161,rep,name=int32_abs_in_proto2",
		Filename:      "buf/validate/conformance/cases/predefined_rules_proto2.proto",
	},
	{
		ExtendedType:  (*validate.Int64Rules)(nil),
		ExtensionType: ([]*wrapperspb.Int64Value)(nil),
		Field:         1161,
		Name:          "buf.validate.conformance.cases.int64_abs_in_proto2",
		Tag:           "bytes,1161,rep,name=int64_abs_in_proto2",
		Filename:      "buf/validate/conformance/cases/predefined_rules_proto2.proto",
	},
	{
		ExtendedType:  (*validate.UInt32Rules)(nil),
		ExtensionType: (*bool)(nil),
		Field:         1161,
		Name:          "buf.validate.conformance.cases.uint32_even_proto2",
		Tag:           "varint,1161,opt,name=uint32_even_proto2",
		Filename:      "buf/validate/conformance/cases/predefined_rules_proto2.proto",
	},
	{
		ExtendedType:  (*validate.UInt64Rules)(nil),
		ExtensionType: (*bool)(nil),
		Field:         1161,
		Name:          "buf.validate.conformance.cases.uint64_even_proto2",
		Tag:           "varint,1161,opt,name=uint64_even_proto2",
		Filename:      "buf/validate/conformance/cases/predefined_rules_proto2.proto",
	},
	{
		ExtendedType:  (*validate.SInt32Rules)(nil),
		ExtensionType: (*bool)(nil),
		Field:         1161,
		Name:          "buf.validate.conformance.cases.sint32_even_proto2",
		Tag:           "varint,1161,opt,name=sint32_even_proto2",
		Filename:      "buf/validate/conformance/cases/predefined_rules_proto2.proto",
	},
	{
		ExtendedType:  (*validate.SInt64Rules)(nil),
		ExtensionType: (*bool)(nil),
		Field:         1161,
		Name:          "buf.validate.conformance.cases.sint64_even_proto2",
		Tag:           "varint,1161,opt,name=sint64_even_proto2",
		Filename:      "buf/validate/conformance/cases/predefined_rules_proto2.proto",
	},
	{
		ExtendedType:  (*validate.Fixed32Rules)(nil),
		ExtensionType: (*bool)(nil),
		Field:         1161,
		Name:          "buf.validate.conformance.cases.fixed32_even_proto2",
		Tag:           "varint,1161,opt,name=fixed32_even_proto2",
		Filename:      "buf/validate/conformance/cases/predefined_rules_proto2.proto",
	},
	{
		ExtendedType:  (*validate.Fixed64Rules)(nil),
		ExtensionType: (*bool)(nil),
		Field:         1161,
		Name:          "buf.validate.conformance.cases.fixed64_even_proto2",
		Tag:           "varint,1161,opt,name=fixed64_even_proto2",
		Filename:      "buf/validate/conformance/cases/predefined_rules_proto2.proto",
	},
	{
		ExtendedType:  (*validate.SFixed32Rules)(nil),
		ExtensionType: (*bool)(nil),
		Field:         1161,
		Name:          "buf.validate.conformance.cases.sfixed32_even_proto2",
		Tag:           "varint,1161,opt,name=sfixed32_even_proto2",
		Filename:      "buf/validate/conformance/cases/predefined_rules_proto2.proto",
	},
	{
		ExtendedType:  (*validate.SFixed64Rules)(nil),
		ExtensionType: (*bool)(nil),
		Field:         1161,
		Name:          "buf.validate.conformance.cases.sfixed64_even_proto2",
		Tag:           "varint,1161,opt,name=sfixed64_even_proto2",
		Filename:      "buf/validate/conformance/cases/predefined_rules_proto2.proto",
	},
	{
		ExtendedType:  (*validate.BoolRules)(nil),
		ExtensionType: (*bool)(nil),
		Field:         1161,
		Name:          "buf.validate.conformance.cases.bool_false_proto2",
		Tag:           "varint,1161,opt,name=bool_false_proto2",
		Filename:      "buf/validate/conformance/cases/predefined_rules_proto2.proto",
	},
	{
		ExtendedType:  (*validate.StringRules)(nil),
		ExtensionType: (*bool)(nil),
		Field:         1161,
		Name:          "buf.validate.conformance.cases.string_valid_path_proto2",
		Tag:           "varint,1161,opt,name=string_valid_path_proto2",
		Filename:      "buf/validate/conformance/cases/predefined_rules_proto2.proto",
	},
	{
		ExtendedType:  (*validate.BytesRules)(nil),
		ExtensionType: (*bool)(nil),
		Field:         1161,
		Name:          "buf.validate.conformance.cases.bytes_valid_path_proto2",
		Tag:           "varint,1161,opt,name=bytes_valid_path_proto2",
		Filename:      "buf/validate/conformance/cases/predefined_rules_proto2.proto",
	},
	{
		ExtendedType:  (*validate.EnumRules)(nil),
		ExtensionType: (*bool)(nil),
		Field:         1161,
		Name:          "buf.validate.conformance.cases.enum_non_zero_proto2",
		Tag:           "varint,1161,opt,name=enum_non_zero_proto2",
		Filename:      "buf/validate/conformance/cases/predefined_rules_proto2.proto",
	},
	{
		ExtendedType:  (*validate.RepeatedRules)(nil),
		ExtensionType: (*bool)(nil),
		Field:         1161,
		Name:          "buf.validate.conformance.cases.repeated_at_least_five_proto2",
		Tag:           "varint,1161,opt,name=repeated_at_least_five_proto2",
		Filename:      "buf/validate/conformance/cases/predefined_rules_proto2.proto",
	},
	{
		ExtendedType:  (*validate.DurationRules)(nil),
		ExtensionType: (*bool)(nil),
		Field:         1161,
		Name:          "buf.validate.conformance.cases.duration_too_long_proto2",
		Tag:           "varint,1161,opt,name=duration_too_long_proto2",
		Filename:      "buf/validate/conformance/cases/predefined_rules_proto2.proto",
	},
	{
		ExtendedType:  (*validate.TimestampRules)(nil),
		ExtensionType: (*bool)(nil),
		Field:         1161,
		Name:          "buf.validate.conformance.cases.timestamp_in_range_proto2",
		Tag:           "varint,1161,opt,name=timestamp_in_range_proto2",
		Filename:      "buf/validate/conformance/cases/predefined_rules_proto2.proto",
	},
}

// Extension fields to validate.FloatRules.
var (
	// optional float float_abs_range_proto2 = 1161;
	E_FloatAbsRangeProto2 = &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_extTypes[0]
)

// Extension fields to validate.DoubleRules.
var (
	// optional double double_abs_range_proto2 = 1161;
	E_DoubleAbsRangeProto2 = &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_extTypes[1]
)

// Extension fields to validate.Int32Rules.
var (
	// repeated int32 int32_abs_in_proto2 = 1161;
	E_Int32AbsInProto2 = &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_extTypes[2]
)

// Extension fields to validate.Int64Rules.
var (
	// repeated google.protobuf.Int64Value int64_abs_in_proto2 = 1161;
	E_Int64AbsInProto2 = &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_extTypes[3]
)

// Extension fields to validate.UInt32Rules.
var (
	// optional bool uint32_even_proto2 = 1161;
	E_Uint32EvenProto2 = &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_extTypes[4]
)

// Extension fields to validate.UInt64Rules.
var (
	// optional bool uint64_even_proto2 = 1161;
	E_Uint64EvenProto2 = &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_extTypes[5]
)

// Extension fields to validate.SInt32Rules.
var (
	// optional bool sint32_even_proto2 = 1161;
	E_Sint32EvenProto2 = &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_extTypes[6]
)

// Extension fields to validate.SInt64Rules.
var (
	// optional bool sint64_even_proto2 = 1161;
	E_Sint64EvenProto2 = &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_extTypes[7]
)

// Extension fields to validate.Fixed32Rules.
var (
	// optional bool fixed32_even_proto2 = 1161;
	E_Fixed32EvenProto2 = &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_extTypes[8]
)

// Extension fields to validate.Fixed64Rules.
var (
	// optional bool fixed64_even_proto2 = 1161;
	E_Fixed64EvenProto2 = &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_extTypes[9]
)

// Extension fields to validate.SFixed32Rules.
var (
	// optional bool sfixed32_even_proto2 = 1161;
	E_Sfixed32EvenProto2 = &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_extTypes[10]
)

// Extension fields to validate.SFixed64Rules.
var (
	// optional bool sfixed64_even_proto2 = 1161;
	E_Sfixed64EvenProto2 = &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_extTypes[11]
)

// Extension fields to validate.BoolRules.
var (
	// optional bool bool_false_proto2 = 1161;
	E_BoolFalseProto2 = &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_extTypes[12]
)

// Extension fields to validate.StringRules.
var (
	// optional bool string_valid_path_proto2 = 1161;
	E_StringValidPathProto2 = &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_extTypes[13]
)

// Extension fields to validate.BytesRules.
var (
	// optional bool bytes_valid_path_proto2 = 1161;
	E_BytesValidPathProto2 = &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_extTypes[14]
)

// Extension fields to validate.EnumRules.
var (
	// optional bool enum_non_zero_proto2 = 1161;
	E_EnumNonZeroProto2 = &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_extTypes[15]
)

// Extension fields to validate.RepeatedRules.
var (
	// optional bool repeated_at_least_five_proto2 = 1161;
	E_RepeatedAtLeastFiveProto2 = &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_extTypes[16]
)

// Extension fields to validate.DurationRules.
var (
	// optional bool duration_too_long_proto2 = 1161;
	E_DurationTooLongProto2 = &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_extTypes[17]
)

// Extension fields to validate.TimestampRules.
var (
	// optional bool timestamp_in_range_proto2 = 1161;
	E_TimestampInRangeProto2 = &file_buf_validate_conformance_cases_predefined_rules_proto2_proto_extTypes[18]
)

var File_buf_validate_conformance_cases_predefined_rules_proto2_proto protoreflect.FileDescriptor

const file_buf_validate_conformance_cases_predefined_rules_proto2_proto_rawDesc = "" +
	"\n" +
	"<buf/validate/conformance/cases/predefined_rules_proto2.proto\x12\x1ebuf.validate.conformance.cases\x1a\x1bbuf/validate/validate.proto\x1a\x1egoogle/protobuf/duration.proto\x1a\x1fgoogle/protobuf/timestamp.proto\x1a\x1egoogle/protobuf/wrappers.proto\":\n" +
	"\x19PredefinedFloatRuleProto2\x12\x1d\n" +
	"\x03val\x18\x01 \x01(\x02B\v\xbaH\b\n" +
	"\x06\xcdH\x00\x00\x80?R\x03val\"?\n" +
	"\x1aPredefinedDoubleRuleProto2\x12!\n" +
	"\x03val\x18\x01 \x01(\x01B\x0f\xbaH\f\x12\n" +
	"\xc9H\x00\x00\x00\x00\x00\x00\xf0?R\x03val\"@\n" +
	"\x19PredefinedInt32RuleProto2\x12#\n" +
	"\x03val\x18\x01 \x01(\x05B\x11\xbaH\x0e\x1a\f\xc8H\xfe\xff\xff\xff\xff\xff\xff\xff\xff\x01R\x03val\"B\n" +
	"\x19PredefinedInt64RuleProto2\x12%\n" +
	"\x03val\x18\x01 \x01(\x03B\x13\xbaH\x10\"\x0e\xcaH\v\b\xfe\xff\xff\xff\xff\xff\xff\xff\xff\x01R\x03val\"8\n" +
	"\x1aPredefinedUInt32RuleProto2\x12\x1a\n" +
	"\x03val\x18\x01 \x01(\rB\b\xbaH\x05*\x03\xc8H\x01R\x03val\"8\n" +
	"\x1aPredefinedUInt64RuleProto2\x12\x1a\n" +
	"\x03val\x18\x01 \x01(\x04B\b\xbaH\x052\x03\xc8H\x01R\x03val\"8\n" +
	"\x1aPredefinedSInt32RuleProto2\x12\x1a\n" +
	"\x03val\x18\x01 \x01(\x11B\b\xbaH\x05:\x03\xc8H\x01R\x03val\"8\n" +
	"\x1aPredefinedSInt64RuleProto2\x12\x1a\n" +
	"\x03val\x18\x01 \x01(\x12B\b\xbaH\x05B\x03\xc8H\x01R\x03val\"9\n" +
	"\x1bPredefinedFixed32RuleProto2\x12\x1a\n" +
	"\x03val\x18\x01 \x01(\aB\b\xbaH\x05J\x03\xc8H\x01R\x03val\"9\n" +
	"\x1bPredefinedFixed64RuleProto2\x12\x1a\n" +
	"\x03val\x18\x01 \x01(\x06B\b\xbaH\x05R\x03\xc8H\x01R\x03val\":\n" +
	"\x1cPredefinedSFixed32RuleProto2\x12\x1a\n" +
	"\x03val\x18\x01 \x01(\x0fB\b\xbaH\x05Z\x03\xc8H\x01R\x03val\":\n" +
	"\x1cPredefinedSFixed64RuleProto2\x12\x1a\n" +
	"\x03val\x18\x01 \x01(\x10B\b\xbaH\x05b\x03\xc8H\x01R\x03val\"6\n" +
	"\x18PredefinedBoolRuleProto2\x12\x1a\n" +
	"\x03val\x18\x01 \x01(\bB\b\xbaH\x05j\x03\xc8H\x01R\x03val\"8\n" +
	"\x1aPredefinedStringRuleProto2\x12\x1a\n" +
	"\x03val\x18\x01 \x01(\tB\b\xbaH\x05r\x03\xc8H\x01R\x03val\"7\n" +
	"\x19PredefinedBytesRuleProto2\x12\x1a\n" +
	"\x03val\x18\x01 \x01(\fB\b\xbaH\x05z\x03\xc8H\x01R\x03val\"\xc1\x01\n" +
	"\x18PredefinedEnumRuleProto2\x12`\n" +
	"\x03val\x18\x01 \x01(\x0e2C.buf.validate.conformance.cases.PredefinedEnumRuleProto2.EnumProto2B\t\xbaH\x06\x82\x01\x03\xc8H\x01R\x03val\"C\n" +
	"\n" +
	"EnumProto2\x12 \n" +
	"\x1cENUM_PROTO2_ZERO_UNSPECIFIED\x10\x00\x12\x13\n" +
	"\x0fENUM_PROTO2_ONE\x10\x01\";\n" +
	"\x1cPredefinedRepeatedRuleProto2\x12\x1b\n" +
	"\x03val\x18\x01 \x03(\x04B\t\xbaH\x06\x92\x01\x03\xc8H\x01R\x03val\"V\n" +
	"\x1cPredefinedDurationRuleProto2\x126\n" +
	"\x03val\x18\x01 \x01(\v2\x19.google.protobuf.DurationB\t\xbaH\x06\xaa\x01\x03\xc8H\x01R\x03val\"X\n" +
	"\x1dPredefinedTimestampRuleProto2\x127\n" +
	"\x03val\x18\x01 \x01(\v2\x1a.google.protobuf.TimestampB\t\xbaH\x06\xb2\x01\x03\xc8H\x01R\x03val\"^\n" +
	" PredefinedWrappedFloatRuleProto2\x12:\n" +
	"\x03val\x18\x01 \x01(\v2\x1b.google.protobuf.FloatValueB\v\xbaH\b\n" +
	"\x06\xcdH\x00\x00\x80?R\x03val\"d\n" +
	"!PredefinedWrappedDoubleRuleProto2\x12?\n" +
	"\x03val\x18\x01 \x01(\v2\x1c.google.protobuf.DoubleValueB\x0f\xbaH\f\x12\n" +
	"\xc9H\x00\x00\x00\x00\x00\x00\xf0?R\x03val\"d\n" +
	" PredefinedWrappedInt32RuleProto2\x12@\n" +
	"\x03val\x18\x01 \x01(\v2\x1b.google.protobuf.Int32ValueB\x11\xbaH\x0e\x1a\f\xc8H\xfe\xff\xff\xff\xff\xff\xff\xff\xff\x01R\x03val\"f\n" +
	" PredefinedWrappedInt64RuleProto2\x12B\n" +
	"\x03val\x18\x01 \x01(\v2\x1b.google.protobuf.Int64ValueB\x13\xbaH\x10\"\x0e\xcaH\v\b\xfe\xff\xff\xff\xff\xff\xff\xff\xff\x01R\x03val\"]\n" +
	"!PredefinedWrappedUInt32RuleProto2\x128\n" +
	"\x03val\x18\x01 \x01(\v2\x1c.google.protobuf.UInt32ValueB\b\xbaH\x05*\x03\xc8H\x01R\x03val\"]\n" +
	"!PredefinedWrappedUInt64RuleProto2\x128\n" +
	"\x03val\x18\x01 \x01(\v2\x1c.google.protobuf.UInt64ValueB\b\xbaH\x052\x03\xc8H\x01R\x03val\"Y\n" +
	"\x1fPredefinedWrappedBoolRuleProto2\x126\n" +
	"\x03val\x18\x01 \x01(\v2\x1a.google.protobuf.BoolValueB\b\xbaH\x05j\x03\xc8H\x01R\x03val\"]\n" +
	"!PredefinedWrappedStringRuleProto2\x128\n" +
	"\x03val\x18\x01 \x01(\v2\x1c.google.protobuf.StringValueB\b\xbaH\x05r\x03\xc8H\x01R\x03val\"[\n" +
	" PredefinedWrappedBytesRuleProto2\x127\n" +
	"\x03val\x18\x01 \x01(\v2\x1b.google.protobuf.BytesValueB\b\xbaH\x05z\x03\xc8H\x01R\x03val\"k\n" +
	"(PredefinedRepeatedWrappedFloatRuleProto2\x12?\n" +
	"\x03val\x18\x01 \x03(\v2\x1b.google.protobuf.FloatValueB\x10\xbaH\r\x92\x01\n" +
	"\"\b\n" +
	"\x06\xcdH\x00\x00\x80?R\x03val\"q\n" +
	")PredefinedRepeatedWrappedDoubleRuleProto2\x12D\n" +
	"\x03val\x18\x01 \x03(\v2\x1c.google.protobuf.DoubleValueB\x14\xbaH\x11\x92\x01\x0e\"\f\x12\n" +
	"\xc9H\x00\x00\x00\x00\x00\x00\xf0?R\x03val\"q\n" +
	"(PredefinedRepeatedWrappedInt32RuleProto2\x12E\n" +
	"\x03val\x18\x01 \x03(\v2\x1b.google.protobuf.Int32ValueB\x16\xbaH\x13\x92\x01\x10\"\x0e\x1a\f\xc8H\xfe\xff\xff\xff\xff\xff\xff\xff\xff\x01R\x03val\"s\n" +
	"(PredefinedRepeatedWrappedInt64RuleProto2\x12G\n" +
	"\x03val\x18\x01 \x03(\v2\x1b.google.protobuf.Int64ValueB\x18\xbaH\x15\x92\x01\x12\"\x10\"\x0e\xcaH\v\b\xfe\xff\xff\xff\xff\xff\xff\xff\xff\x01R\x03val\"j\n" +
	")PredefinedRepeatedWrappedUInt32RuleProto2\x12=\n" +
	"\x03val\x18\x01 \x03(\v2\x1c.google.protobuf.UInt32ValueB\r\xbaH\n" +
	"\x92\x01\a\"\x05*\x03\xc8H\x01R\x03val\"j\n" +
	")PredefinedRepeatedWrappedUInt64RuleProto2\x12=\n" +
	"\x03val\x18\x01 \x03(\v2\x1c.google.protobuf.UInt64ValueB\r\xbaH\n" +
	"\x92\x01\a\"\x052\x03\xc8H\x01R\x03val\"f\n" +
	"'PredefinedRepeatedWrappedBoolRuleProto2\x12;\n" +
	"\x03val\x18\x01 \x03(\v2\x1a.google.protobuf.BoolValueB\r\xbaH\n" +
	"\x92\x01\a\"\x05j\x03\xc8H\x01R\x03val\"j\n" +
	")PredefinedRepeatedWrappedStringRuleProto2\x12=\n" +
	"\x03val\x18\x01 \x03(\v2\x1c.google.protobuf.StringValueB\r\xbaH\n" +
	"\x92\x01\a\"\x05r\x03\xc8H\x01R\x03val\"h\n" +
	"(PredefinedRepeatedWrappedBytesRuleProto2\x12<\n" +
	"\x03val\x18\x01 \x03(\v2\x1b.google.protobuf.BytesValueB\r\xbaH\n" +
	"\x92\x01\a\"\x05z\x03\xc8H\x01R\x03val\"\xbe\x03\n" +
	"\x1dPredefinedAndCustomRuleProto2\x12q\n" +
	"\x01a\x18\x01 \x01(\x11Bc\xbaH`\xba\x01X\n" +
	"(predefined_and_custom_rule_scalar_proto2\x1a,this > 24 ? '' : 'a must be greater than 24':\x03\xc8H\x01R\x01a\x12\xb4\x01\n" +
	"\x01b\x18\x02 \x01(\v2D.buf.validate.conformance.cases.PredefinedAndCustomRuleProto2.NestedB`\xbaH]\xba\x01Z\n" +
	"*predefined_and_custom_rule_embedded_proto2\x12\x1bb.c must be a multiple of 3\x1a\x0fthis.c % 3 == 0R\x01b\x1as\n" +
	"\x06Nested\x12i\n" +
	"\x01c\x18\x01 \x01(\x11B[\xbaHX\xba\x01P\n" +
	"(predefined_and_custom_rule_nested_proto2\x1a$this > 0 ? '' : 'c must be positive':\x03\xc8H\x01R\x01c\"\xa5\x01\n" +
	"%StandardPredefinedAndCustomRuleProto2\x12|\n" +
	"\x01a\x18\x01 \x01(\x11Bn\xbaHk\xba\x01a\n" +
	"1standard_predefined_and_custom_rule_scalar_proto2\x1a,this > 24 ? '' : 'a must be greater than 24':\x05\xc8H\x01\x108R\x01a:\xa9\x01\n" +
	"\x16float_abs_range_proto2\x12\x18.buf.validate.FloatRules\x18\x89\t \x01(\x02BY\xc2HV\n" +
	"T\n" +
	"\x16float.abs_range.proto2\x12\x1bfloat value is out of range\x1a\x1dthis >= -rule && this <= ruleR\x13floatAbsRangeProto2:\xae\x01\n" +
	"\x17double_abs_range_proto2\x12\x19.buf.validate.DoubleRules\x18\x89\t \x01(\x01B[\xc2HX\n" +
	"V\n" +
	"\x17double.abs_range.proto2\x12\x1cdouble value is out of range\x1a\x1dthis >= -rule && this <= ruleR\x14doubleAbsRangeProto2:\xb6\x01\n" +
	"\x13int32_abs_in_proto2\x12\x18.buf.validate.Int32Rules\x18\x89\t \x03(\x05Bl\xc2Hi\n" +
	"g\n" +
	"\x13int32.abs_in.proto2\x12'value must be in absolute value of list\x1a'this in rule || this in rule.map(n, -n)R\x10int32AbsInProto2:\xd3\x01\n" +
	"\x13int64_abs_in_proto2\x12\x18.buf.validate.Int64Rules\x18\x89\t \x03(\v2\x1b.google.protobuf.Int64ValueBl\xc2Hi\n" +
	"g\n" +
	"\x13int64.abs_in.proto2\x12'value must be in absolute value of list\x1a'this in rule || this in rule.map(n, -n)R\x10int64AbsInProto2:\x8e\x01\n" +
	"\x12uint32_even_proto2\x12\x19.buf.validate.UInt32Rules\x18\x89\t \x01(\bBD\xc2HA\n" +
	"?\n" +
	"\x12uint32.even.proto2\x12\x18uint32 value is not even\x1a\x0fthis % 2u == 0uR\x10uint32EvenProto2:\x8e\x01\n" +
	"\x12uint64_even_proto2\x12\x19.buf.validate.UInt64Rules\x18\x89\t \x01(\bBD\xc2HA\n" +
	"?\n" +
	"\x12uint64.even.proto2\x12\x18uint64 value is not even\x1a\x0fthis % 2u == 0uR\x10uint64EvenProto2:\x8c\x01\n" +
	"\x12sint32_even_proto2\x12\x19.buf.validate.SInt32Rules\x18\x89\t \x01(\bBB\xc2H?\n" +
	"=\n" +
	"\x12sint32.even.proto2\x12\x18sint32 value is not even\x1a\rthis % 2 == 0R\x10sint32EvenProto2:\x8c\x01\n" +
	"\x12sint64_even_proto2\x12\x19.buf.validate.SInt64Rules\x18\x89\t \x01(\bBB\xc2H?\n" +
	"=\n" +
	"\x12sint64.even.proto2\x12\x18sint64 value is not even\x1a\rthis % 2 == 0R\x10sint64EvenProto2:\x93\x01\n" +
	"\x13fixed32_even_proto2\x12\x1a.buf.validate.Fixed32Rules\x18\x89\t \x01(\bBF\xc2HC\n" +
	"A\n" +
	"\x13fixed32.even.proto2\x12\x19fixed32 value is not even\x1a\x0fthis % 2u == 0uR\x11fixed32EvenProto2:\x93\x01\n" +
	"\x13fixed64_even_proto2\x12\x1a.buf.validate.Fixed64Rules\x18\x89\t \x01(\bBF\xc2HC\n" +
	"A\n" +
	"\x13fixed64.even.proto2\x12\x19fixed64 value is not even\x1a\x0fthis % 2u == 0uR\x11fixed64EvenProto2:\x96\x01\n" +
	"\x14sfixed32_even_proto2\x12\x1b.buf.validate.SFixed32Rules\x18\x89\t \x01(\bBF\xc2HC\n" +
	"A\n" +
	"\x14sfixed32.even.proto2\x12\x1asfixed32 value is not even\x1a\rthis % 2 == 0R\x12sfixed32EvenProto2:\x96\x01\n" +
	"\x14sfixed64_even_proto2\x12\x1b.buf.validate.SFixed64Rules\x18\x89\t \x01(\bBF\xc2HC\n" +
	"A\n" +
	"\x14sfixed64.even.proto2\x12\x1asfixed64 value is not even\x1a\rthis % 2 == 0R\x12sfixed64EvenProto2:\x86\x01\n" +
	"\x11bool_false_proto2\x12\x17.buf.validate.BoolRules\x18\x89\t \x01(\bB@\xc2H=\n" +
	";\n" +
	"\x11bool.false.proto2\x12\x17bool value is not false\x1a\rthis == falseR\x0fboolFalseProto2:\xfe\x01\n" +
	"\x18string_valid_path_proto2\x12\x19.buf.validate.StringRules\x18\x89\t \x01(\bB\xa8\x01\xc2H\xa4\x01\n" +
	"\xa1\x01\n" +
	"\x18string.valid_path.proto2\x1a\x84\x01!this.matches('^([^/.][^/]?|[^/][^/.]|[^/]{3,})(/([^/.][^/]?|[^/][^/.]|[^/]{3,}))*$') ? 'not a valid path: `%s`'.format([this]) : ''R\x15stringValidPathProto2:\x82\x02\n" +
	"\x17bytes_valid_path_proto2\x12\x18.buf.validate.BytesRules\x18\x89\t \x01(\bB\xaf\x01\xc2H\xab\x01\n" +
	"\xa8\x01\n" +
	"\x17bytes.valid_path.proto2\x1a\x8c\x01!string(this).matches('^([^/.][^/]?|[^/][^/.]|[^/]{3,})(/([^/.][^/]?|[^/][^/.]|[^/]{3,}))*$') ? 'not a valid path: `%s`'.format([this]) : ''R\x14bytesValidPathProto2:\x92\x01\n" +
	"\x14enum_non_zero_proto2\x12\x17.buf.validate.EnumRules\x18\x89\t \x01(\bBG\xc2HD\n" +
	"B\n" +
	"\x14enum.non_zero.proto2\x12\x1aenum value is not non-zero\x1a\x0eint(this) != 0R\x11enumNonZeroProto2:\xcc\x01\n" +
	"\x1drepeated_at_least_five_proto2\x12\x1b.buf.validate.RepeatedRules\x18\x89\t \x01(\bBl\xc2Hi\n" +
	"g\n" +
	"\x1drepeated.at_least_five.proto2\x12-repeated field must have at least five values\x1a\x17uint(this.size()) >= 5uR\x19repeatedAtLeastFiveProto2:\xb9\x01\n" +
	"\x18duration_too_long_proto2\x12\x1b.buf.validate.DurationRules\x18\x89\t \x01(\bBb\xc2H_\n" +
	"]\n" +
	"\x18duration.too_long.proto2\x12(duration can't be longer than 10 seconds\x1a\x17this <= duration('10s')R\x15durationTooLongProto2:\xc8\x01\n" +
	"\x19timestamp_in_range_proto2\x12\x1c.buf.validate.TimestampRules\x18\x89\t \x01(\bBn\xc2Hk\n" +
	"i\n" +
	"\x1btimestamp.time_range.proto2\x12\x16timestamp out of range\x1a2int(this) >= 1049587200 && int(this) <= 1080432000R\x16timestampInRangeProto2B\xa4\x02\n" +
	"\"com.buf.validate.conformance.casesB\x1aPredefinedRulesProto2ProtoP\x01ZFbuf.build/go/protovalidate/internal/gen/buf/validate/conformance/cases\xa2\x02\x04BVCC\xaa\x02\x1eBuf.Validate.Conformance.Cases\xca\x02\x1eBuf\\Validate\\Conformance\\Cases\xe2\x02*Buf\\Validate\\Conformance\\Cases\\GPBMetadata\xea\x02!Buf::Validate::Conformance::Cases"

var file_buf_validate_conformance_cases_predefined_rules_proto2_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
var file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes = make([]protoimpl.MessageInfo, 40)
var file_buf_validate_conformance_cases_predefined_rules_proto2_proto_goTypes = []any{
	(PredefinedEnumRuleProto2_EnumProto2)(0),          // 0: buf.validate.conformance.cases.PredefinedEnumRuleProto2.EnumProto2
	(*PredefinedFloatRuleProto2)(nil),                 // 1: buf.validate.conformance.cases.PredefinedFloatRuleProto2
	(*PredefinedDoubleRuleProto2)(nil),                // 2: buf.validate.conformance.cases.PredefinedDoubleRuleProto2
	(*PredefinedInt32RuleProto2)(nil),                 // 3: buf.validate.conformance.cases.PredefinedInt32RuleProto2
	(*PredefinedInt64RuleProto2)(nil),                 // 4: buf.validate.conformance.cases.PredefinedInt64RuleProto2
	(*PredefinedUInt32RuleProto2)(nil),                // 5: buf.validate.conformance.cases.PredefinedUInt32RuleProto2
	(*PredefinedUInt64RuleProto2)(nil),                // 6: buf.validate.conformance.cases.PredefinedUInt64RuleProto2
	(*PredefinedSInt32RuleProto2)(nil),                // 7: buf.validate.conformance.cases.PredefinedSInt32RuleProto2
	(*PredefinedSInt64RuleProto2)(nil),                // 8: buf.validate.conformance.cases.PredefinedSInt64RuleProto2
	(*PredefinedFixed32RuleProto2)(nil),               // 9: buf.validate.conformance.cases.PredefinedFixed32RuleProto2
	(*PredefinedFixed64RuleProto2)(nil),               // 10: buf.validate.conformance.cases.PredefinedFixed64RuleProto2
	(*PredefinedSFixed32RuleProto2)(nil),              // 11: buf.validate.conformance.cases.PredefinedSFixed32RuleProto2
	(*PredefinedSFixed64RuleProto2)(nil),              // 12: buf.validate.conformance.cases.PredefinedSFixed64RuleProto2
	(*PredefinedBoolRuleProto2)(nil),                  // 13: buf.validate.conformance.cases.PredefinedBoolRuleProto2
	(*PredefinedStringRuleProto2)(nil),                // 14: buf.validate.conformance.cases.PredefinedStringRuleProto2
	(*PredefinedBytesRuleProto2)(nil),                 // 15: buf.validate.conformance.cases.PredefinedBytesRuleProto2
	(*PredefinedEnumRuleProto2)(nil),                  // 16: buf.validate.conformance.cases.PredefinedEnumRuleProto2
	(*PredefinedRepeatedRuleProto2)(nil),              // 17: buf.validate.conformance.cases.PredefinedRepeatedRuleProto2
	(*PredefinedDurationRuleProto2)(nil),              // 18: buf.validate.conformance.cases.PredefinedDurationRuleProto2
	(*PredefinedTimestampRuleProto2)(nil),             // 19: buf.validate.conformance.cases.PredefinedTimestampRuleProto2
	(*PredefinedWrappedFloatRuleProto2)(nil),          // 20: buf.validate.conformance.cases.PredefinedWrappedFloatRuleProto2
	(*PredefinedWrappedDoubleRuleProto2)(nil),         // 21: buf.validate.conformance.cases.PredefinedWrappedDoubleRuleProto2
	(*PredefinedWrappedInt32RuleProto2)(nil),          // 22: buf.validate.conformance.cases.PredefinedWrappedInt32RuleProto2
	(*PredefinedWrappedInt64RuleProto2)(nil),          // 23: buf.validate.conformance.cases.PredefinedWrappedInt64RuleProto2
	(*PredefinedWrappedUInt32RuleProto2)(nil),         // 24: buf.validate.conformance.cases.PredefinedWrappedUInt32RuleProto2
	(*PredefinedWrappedUInt64RuleProto2)(nil),         // 25: buf.validate.conformance.cases.PredefinedWrappedUInt64RuleProto2
	(*PredefinedWrappedBoolRuleProto2)(nil),           // 26: buf.validate.conformance.cases.PredefinedWrappedBoolRuleProto2
	(*PredefinedWrappedStringRuleProto2)(nil),         // 27: buf.validate.conformance.cases.PredefinedWrappedStringRuleProto2
	(*PredefinedWrappedBytesRuleProto2)(nil),          // 28: buf.validate.conformance.cases.PredefinedWrappedBytesRuleProto2
	(*PredefinedRepeatedWrappedFloatRuleProto2)(nil),  // 29: buf.validate.conformance.cases.PredefinedRepeatedWrappedFloatRuleProto2
	(*PredefinedRepeatedWrappedDoubleRuleProto2)(nil), // 30: buf.validate.conformance.cases.PredefinedRepeatedWrappedDoubleRuleProto2
	(*PredefinedRepeatedWrappedInt32RuleProto2)(nil),  // 31: buf.validate.conformance.cases.PredefinedRepeatedWrappedInt32RuleProto2
	(*PredefinedRepeatedWrappedInt64RuleProto2)(nil),  // 32: buf.validate.conformance.cases.PredefinedRepeatedWrappedInt64RuleProto2
	(*PredefinedRepeatedWrappedUInt32RuleProto2)(nil), // 33: buf.validate.conformance.cases.PredefinedRepeatedWrappedUInt32RuleProto2
	(*PredefinedRepeatedWrappedUInt64RuleProto2)(nil), // 34: buf.validate.conformance.cases.PredefinedRepeatedWrappedUInt64RuleProto2
	(*PredefinedRepeatedWrappedBoolRuleProto2)(nil),   // 35: buf.validate.conformance.cases.PredefinedRepeatedWrappedBoolRuleProto2
	(*PredefinedRepeatedWrappedStringRuleProto2)(nil), // 36: buf.validate.conformance.cases.PredefinedRepeatedWrappedStringRuleProto2
	(*PredefinedRepeatedWrappedBytesRuleProto2)(nil),  // 37: buf.validate.conformance.cases.PredefinedRepeatedWrappedBytesRuleProto2
	(*PredefinedAndCustomRuleProto2)(nil),             // 38: buf.validate.conformance.cases.PredefinedAndCustomRuleProto2
	(*StandardPredefinedAndCustomRuleProto2)(nil),     // 39: buf.validate.conformance.cases.StandardPredefinedAndCustomRuleProto2
	(*PredefinedAndCustomRuleProto2_Nested)(nil),      // 40: buf.validate.conformance.cases.PredefinedAndCustomRuleProto2.Nested
	(*durationpb.Duration)(nil),                       // 41: google.protobuf.Duration
	(*timestamppb.Timestamp)(nil),                     // 42: google.protobuf.Timestamp
	(*wrapperspb.FloatValue)(nil),                     // 43: google.protobuf.FloatValue
	(*wrapperspb.DoubleValue)(nil),                    // 44: google.protobuf.DoubleValue
	(*wrapperspb.Int32Value)(nil),                     // 45: google.protobuf.Int32Value
	(*wrapperspb.Int64Value)(nil),                     // 46: google.protobuf.Int64Value
	(*wrapperspb.UInt32Value)(nil),                    // 47: google.protobuf.UInt32Value
	(*wrapperspb.UInt64Value)(nil),                    // 48: google.protobuf.UInt64Value
	(*wrapperspb.BoolValue)(nil),                      // 49: google.protobuf.BoolValue
	(*wrapperspb.StringValue)(nil),                    // 50: google.protobuf.StringValue
	(*wrapperspb.BytesValue)(nil),                     // 51: google.protobuf.BytesValue
	(*validate.FloatRules)(nil),                       // 52: buf.validate.FloatRules
	(*validate.DoubleRules)(nil),                      // 53: buf.validate.DoubleRules
	(*validate.Int32Rules)(nil),                       // 54: buf.validate.Int32Rules
	(*validate.Int64Rules)(nil),                       // 55: buf.validate.Int64Rules
	(*validate.UInt32Rules)(nil),                      // 56: buf.validate.UInt32Rules
	(*validate.UInt64Rules)(nil),                      // 57: buf.validate.UInt64Rules
	(*validate.SInt32Rules)(nil),                      // 58: buf.validate.SInt32Rules
	(*validate.SInt64Rules)(nil),                      // 59: buf.validate.SInt64Rules
	(*validate.Fixed32Rules)(nil),                     // 60: buf.validate.Fixed32Rules
	(*validate.Fixed64Rules)(nil),                     // 61: buf.validate.Fixed64Rules
	(*validate.SFixed32Rules)(nil),                    // 62: buf.validate.SFixed32Rules
	(*validate.SFixed64Rules)(nil),                    // 63: buf.validate.SFixed64Rules
	(*validate.BoolRules)(nil),                        // 64: buf.validate.BoolRules
	(*validate.StringRules)(nil),                      // 65: buf.validate.StringRules
	(*validate.BytesRules)(nil),                       // 66: buf.validate.BytesRules
	(*validate.EnumRules)(nil),                        // 67: buf.validate.EnumRules
	(*validate.RepeatedRules)(nil),                    // 68: buf.validate.RepeatedRules
	(*validate.DurationRules)(nil),                    // 69: buf.validate.DurationRules
	(*validate.TimestampRules)(nil),                   // 70: buf.validate.TimestampRules
}
var file_buf_validate_conformance_cases_predefined_rules_proto2_proto_depIdxs = []int32{
	0,  // 0: buf.validate.conformance.cases.PredefinedEnumRuleProto2.val:type_name -> buf.validate.conformance.cases.PredefinedEnumRuleProto2.EnumProto2
	41, // 1: buf.validate.conformance.cases.PredefinedDurationRuleProto2.val:type_name -> google.protobuf.Duration
	42, // 2: buf.validate.conformance.cases.PredefinedTimestampRuleProto2.val:type_name -> google.protobuf.Timestamp
	43, // 3: buf.validate.conformance.cases.PredefinedWrappedFloatRuleProto2.val:type_name -> google.protobuf.FloatValue
	44, // 4: buf.validate.conformance.cases.PredefinedWrappedDoubleRuleProto2.val:type_name -> google.protobuf.DoubleValue
	45, // 5: buf.validate.conformance.cases.PredefinedWrappedInt32RuleProto2.val:type_name -> google.protobuf.Int32Value
	46, // 6: buf.validate.conformance.cases.PredefinedWrappedInt64RuleProto2.val:type_name -> google.protobuf.Int64Value
	47, // 7: buf.validate.conformance.cases.PredefinedWrappedUInt32RuleProto2.val:type_name -> google.protobuf.UInt32Value
	48, // 8: buf.validate.conformance.cases.PredefinedWrappedUInt64RuleProto2.val:type_name -> google.protobuf.UInt64Value
	49, // 9: buf.validate.conformance.cases.PredefinedWrappedBoolRuleProto2.val:type_name -> google.protobuf.BoolValue
	50, // 10: buf.validate.conformance.cases.PredefinedWrappedStringRuleProto2.val:type_name -> google.protobuf.StringValue
	51, // 11: buf.validate.conformance.cases.PredefinedWrappedBytesRuleProto2.val:type_name -> google.protobuf.BytesValue
	43, // 12: buf.validate.conformance.cases.PredefinedRepeatedWrappedFloatRuleProto2.val:type_name -> google.protobuf.FloatValue
	44, // 13: buf.validate.conformance.cases.PredefinedRepeatedWrappedDoubleRuleProto2.val:type_name -> google.protobuf.DoubleValue
	45, // 14: buf.validate.conformance.cases.PredefinedRepeatedWrappedInt32RuleProto2.val:type_name -> google.protobuf.Int32Value
	46, // 15: buf.validate.conformance.cases.PredefinedRepeatedWrappedInt64RuleProto2.val:type_name -> google.protobuf.Int64Value
	47, // 16: buf.validate.conformance.cases.PredefinedRepeatedWrappedUInt32RuleProto2.val:type_name -> google.protobuf.UInt32Value
	48, // 17: buf.validate.conformance.cases.PredefinedRepeatedWrappedUInt64RuleProto2.val:type_name -> google.protobuf.UInt64Value
	49, // 18: buf.validate.conformance.cases.PredefinedRepeatedWrappedBoolRuleProto2.val:type_name -> google.protobuf.BoolValue
	50, // 19: buf.validate.conformance.cases.PredefinedRepeatedWrappedStringRuleProto2.val:type_name -> google.protobuf.StringValue
	51, // 20: buf.validate.conformance.cases.PredefinedRepeatedWrappedBytesRuleProto2.val:type_name -> google.protobuf.BytesValue
	40, // 21: buf.validate.conformance.cases.PredefinedAndCustomRuleProto2.b:type_name -> buf.validate.conformance.cases.PredefinedAndCustomRuleProto2.Nested
	52, // 22: buf.validate.conformance.cases.float_abs_range_proto2:extendee -> buf.validate.FloatRules
	53, // 23: buf.validate.conformance.cases.double_abs_range_proto2:extendee -> buf.validate.DoubleRules
	54, // 24: buf.validate.conformance.cases.int32_abs_in_proto2:extendee -> buf.validate.Int32Rules
	55, // 25: buf.validate.conformance.cases.int64_abs_in_proto2:extendee -> buf.validate.Int64Rules
	56, // 26: buf.validate.conformance.cases.uint32_even_proto2:extendee -> buf.validate.UInt32Rules
	57, // 27: buf.validate.conformance.cases.uint64_even_proto2:extendee -> buf.validate.UInt64Rules
	58, // 28: buf.validate.conformance.cases.sint32_even_proto2:extendee -> buf.validate.SInt32Rules
	59, // 29: buf.validate.conformance.cases.sint64_even_proto2:extendee -> buf.validate.SInt64Rules
	60, // 30: buf.validate.conformance.cases.fixed32_even_proto2:extendee -> buf.validate.Fixed32Rules
	61, // 31: buf.validate.conformance.cases.fixed64_even_proto2:extendee -> buf.validate.Fixed64Rules
	62, // 32: buf.validate.conformance.cases.sfixed32_even_proto2:extendee -> buf.validate.SFixed32Rules
	63, // 33: buf.validate.conformance.cases.sfixed64_even_proto2:extendee -> buf.validate.SFixed64Rules
	64, // 34: buf.validate.conformance.cases.bool_false_proto2:extendee -> buf.validate.BoolRules
	65, // 35: buf.validate.conformance.cases.string_valid_path_proto2:extendee -> buf.validate.StringRules
	66, // 36: buf.validate.conformance.cases.bytes_valid_path_proto2:extendee -> buf.validate.BytesRules
	67, // 37: buf.validate.conformance.cases.enum_non_zero_proto2:extendee -> buf.validate.EnumRules
	68, // 38: buf.validate.conformance.cases.repeated_at_least_five_proto2:extendee -> buf.validate.RepeatedRules
	69, // 39: buf.validate.conformance.cases.duration_too_long_proto2:extendee -> buf.validate.DurationRules
	70, // 40: buf.validate.conformance.cases.timestamp_in_range_proto2:extendee -> buf.validate.TimestampRules
	46, // 41: buf.validate.conformance.cases.int64_abs_in_proto2:type_name -> google.protobuf.Int64Value
	42, // [42:42] is the sub-list for method output_type
	42, // [42:42] is the sub-list for method input_type
	41, // [41:42] is the sub-list for extension type_name
	22, // [22:41] is the sub-list for extension extendee
	0,  // [0:22] is the sub-list for field type_name
}

func init() { file_buf_validate_conformance_cases_predefined_rules_proto2_proto_init() }
func file_buf_validate_conformance_cases_predefined_rules_proto2_proto_init() {
	if File_buf_validate_conformance_cases_predefined_rules_proto2_proto != nil {
		return
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_buf_validate_conformance_cases_predefined_rules_proto2_proto_rawDesc), len(file_buf_validate_conformance_cases_predefined_rules_proto2_proto_rawDesc)),
			NumEnums:      1,
			NumMessages:   40,
			NumExtensions: 19,
			NumServices:   0,
		},
		GoTypes:           file_buf_validate_conformance_cases_predefined_rules_proto2_proto_goTypes,
		DependencyIndexes: file_buf_validate_conformance_cases_predefined_rules_proto2_proto_depIdxs,
		EnumInfos:         file_buf_validate_conformance_cases_predefined_rules_proto2_proto_enumTypes,
		MessageInfos:      file_buf_validate_conformance_cases_predefined_rules_proto2_proto_msgTypes,
		ExtensionInfos:    file_buf_validate_conformance_cases_predefined_rules_proto2_proto_extTypes,
	}.Build()
	File_buf_validate_conformance_cases_predefined_rules_proto2_proto = out.File
	file_buf_validate_conformance_cases_predefined_rules_proto2_proto_goTypes = nil
	file_buf_validate_conformance_cases_predefined_rules_proto2_proto_depIdxs = nil
}
