// 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_proto3.proto

//go:build protoopaque

package cases

import (
	_ "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 PredefinedEnumRuleProto3_EnumProto3 int32

const (
	PredefinedEnumRuleProto3_ENUM_PROTO3_ZERO_UNSPECIFIED PredefinedEnumRuleProto3_EnumProto3 = 0
	PredefinedEnumRuleProto3_ENUM_PROTO3_ONE              PredefinedEnumRuleProto3_EnumProto3 = 1
)

// Enum value maps for PredefinedEnumRuleProto3_EnumProto3.
var (
	PredefinedEnumRuleProto3_EnumProto3_name = map[int32]string{
		0: "ENUM_PROTO3_ZERO_UNSPECIFIED",
		1: "ENUM_PROTO3_ONE",
	}
	PredefinedEnumRuleProto3_EnumProto3_value = map[string]int32{
		"ENUM_PROTO3_ZERO_UNSPECIFIED": 0,
		"ENUM_PROTO3_ONE":              1,
	}
)

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

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

func (PredefinedEnumRuleProto3_EnumProto3) Descriptor() protoreflect.EnumDescriptor {
	return file_buf_validate_conformance_cases_predefined_rules_proto3_proto_enumTypes[0].Descriptor()
}

func (PredefinedEnumRuleProto3_EnumProto3) Type() protoreflect.EnumType {
	return &file_buf_validate_conformance_cases_predefined_rules_proto3_proto_enumTypes[0]
}

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

type PredefinedFloatRuleProto3 struct {
	state          protoimpl.MessageState `protogen:"opaque.v1"`
	xxx_hidden_Val float32                `protobuf:"fixed32,1,opt,name=val,proto3"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*PredefinedFloatRuleProto3) ProtoMessage() {}

func (x *PredefinedFloatRuleProto3) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto3_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 *PredefinedFloatRuleProto3) GetVal() float32 {
	if x != nil {
		return x.xxx_hidden_Val
	}
	return 0
}

func (x *PredefinedFloatRuleProto3) SetVal(v float32) {
	x.xxx_hidden_Val = v
}

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

	Val float32
}

func (b0 PredefinedFloatRuleProto3_builder) Build() *PredefinedFloatRuleProto3 {
	m0 := &PredefinedFloatRuleProto3{}
	b, x := &b0, m0
	_, _ = b, x
	x.xxx_hidden_Val = b.Val
	return m0
}

type PredefinedDoubleRuleProto3 struct {
	state          protoimpl.MessageState `protogen:"opaque.v1"`
	xxx_hidden_Val float64                `protobuf:"fixed64,1,opt,name=val,proto3"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*PredefinedDoubleRuleProto3) ProtoMessage() {}

func (x *PredefinedDoubleRuleProto3) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto3_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 *PredefinedDoubleRuleProto3) GetVal() float64 {
	if x != nil {
		return x.xxx_hidden_Val
	}
	return 0
}

func (x *PredefinedDoubleRuleProto3) SetVal(v float64) {
	x.xxx_hidden_Val = v
}

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

	Val float64
}

func (b0 PredefinedDoubleRuleProto3_builder) Build() *PredefinedDoubleRuleProto3 {
	m0 := &PredefinedDoubleRuleProto3{}
	b, x := &b0, m0
	_, _ = b, x
	x.xxx_hidden_Val = b.Val
	return m0
}

type PredefinedInt32RuleProto3 struct {
	state          protoimpl.MessageState `protogen:"opaque.v1"`
	xxx_hidden_Val int32                  `protobuf:"varint,1,opt,name=val,proto3"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*PredefinedInt32RuleProto3) ProtoMessage() {}

func (x *PredefinedInt32RuleProto3) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto3_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 *PredefinedInt32RuleProto3) GetVal() int32 {
	if x != nil {
		return x.xxx_hidden_Val
	}
	return 0
}

func (x *PredefinedInt32RuleProto3) SetVal(v int32) {
	x.xxx_hidden_Val = v
}

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

	Val int32
}

func (b0 PredefinedInt32RuleProto3_builder) Build() *PredefinedInt32RuleProto3 {
	m0 := &PredefinedInt32RuleProto3{}
	b, x := &b0, m0
	_, _ = b, x
	x.xxx_hidden_Val = b.Val
	return m0
}

type PredefinedInt64RuleProto3 struct {
	state          protoimpl.MessageState `protogen:"opaque.v1"`
	xxx_hidden_Val int64                  `protobuf:"varint,1,opt,name=val,proto3"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*PredefinedInt64RuleProto3) ProtoMessage() {}

func (x *PredefinedInt64RuleProto3) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto3_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 *PredefinedInt64RuleProto3) GetVal() int64 {
	if x != nil {
		return x.xxx_hidden_Val
	}
	return 0
}

func (x *PredefinedInt64RuleProto3) SetVal(v int64) {
	x.xxx_hidden_Val = v
}

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

	Val int64
}

func (b0 PredefinedInt64RuleProto3_builder) Build() *PredefinedInt64RuleProto3 {
	m0 := &PredefinedInt64RuleProto3{}
	b, x := &b0, m0
	_, _ = b, x
	x.xxx_hidden_Val = b.Val
	return m0
}

type PredefinedUInt32RuleProto3 struct {
	state          protoimpl.MessageState `protogen:"opaque.v1"`
	xxx_hidden_Val uint32                 `protobuf:"varint,1,opt,name=val,proto3"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*PredefinedUInt32RuleProto3) ProtoMessage() {}

func (x *PredefinedUInt32RuleProto3) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto3_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 *PredefinedUInt32RuleProto3) GetVal() uint32 {
	if x != nil {
		return x.xxx_hidden_Val
	}
	return 0
}

func (x *PredefinedUInt32RuleProto3) SetVal(v uint32) {
	x.xxx_hidden_Val = v
}

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

	Val uint32
}

func (b0 PredefinedUInt32RuleProto3_builder) Build() *PredefinedUInt32RuleProto3 {
	m0 := &PredefinedUInt32RuleProto3{}
	b, x := &b0, m0
	_, _ = b, x
	x.xxx_hidden_Val = b.Val
	return m0
}

type PredefinedUInt64RuleProto3 struct {
	state          protoimpl.MessageState `protogen:"opaque.v1"`
	xxx_hidden_Val uint64                 `protobuf:"varint,1,opt,name=val,proto3"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*PredefinedUInt64RuleProto3) ProtoMessage() {}

func (x *PredefinedUInt64RuleProto3) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto3_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 *PredefinedUInt64RuleProto3) GetVal() uint64 {
	if x != nil {
		return x.xxx_hidden_Val
	}
	return 0
}

func (x *PredefinedUInt64RuleProto3) SetVal(v uint64) {
	x.xxx_hidden_Val = v
}

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

	Val uint64
}

func (b0 PredefinedUInt64RuleProto3_builder) Build() *PredefinedUInt64RuleProto3 {
	m0 := &PredefinedUInt64RuleProto3{}
	b, x := &b0, m0
	_, _ = b, x
	x.xxx_hidden_Val = b.Val
	return m0
}

type PredefinedSInt32RuleProto3 struct {
	state          protoimpl.MessageState `protogen:"opaque.v1"`
	xxx_hidden_Val int32                  `protobuf:"zigzag32,1,opt,name=val,proto3"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*PredefinedSInt32RuleProto3) ProtoMessage() {}

func (x *PredefinedSInt32RuleProto3) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto3_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 *PredefinedSInt32RuleProto3) GetVal() int32 {
	if x != nil {
		return x.xxx_hidden_Val
	}
	return 0
}

func (x *PredefinedSInt32RuleProto3) SetVal(v int32) {
	x.xxx_hidden_Val = v
}

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

	Val int32
}

func (b0 PredefinedSInt32RuleProto3_builder) Build() *PredefinedSInt32RuleProto3 {
	m0 := &PredefinedSInt32RuleProto3{}
	b, x := &b0, m0
	_, _ = b, x
	x.xxx_hidden_Val = b.Val
	return m0
}

type PredefinedSInt64RuleProto3 struct {
	state          protoimpl.MessageState `protogen:"opaque.v1"`
	xxx_hidden_Val int64                  `protobuf:"zigzag64,1,opt,name=val,proto3"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*PredefinedSInt64RuleProto3) ProtoMessage() {}

func (x *PredefinedSInt64RuleProto3) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto3_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 *PredefinedSInt64RuleProto3) GetVal() int64 {
	if x != nil {
		return x.xxx_hidden_Val
	}
	return 0
}

func (x *PredefinedSInt64RuleProto3) SetVal(v int64) {
	x.xxx_hidden_Val = v
}

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

	Val int64
}

func (b0 PredefinedSInt64RuleProto3_builder) Build() *PredefinedSInt64RuleProto3 {
	m0 := &PredefinedSInt64RuleProto3{}
	b, x := &b0, m0
	_, _ = b, x
	x.xxx_hidden_Val = b.Val
	return m0
}

type PredefinedFixed32RuleProto3 struct {
	state          protoimpl.MessageState `protogen:"opaque.v1"`
	xxx_hidden_Val uint32                 `protobuf:"fixed32,1,opt,name=val,proto3"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*PredefinedFixed32RuleProto3) ProtoMessage() {}

func (x *PredefinedFixed32RuleProto3) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto3_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 *PredefinedFixed32RuleProto3) GetVal() uint32 {
	if x != nil {
		return x.xxx_hidden_Val
	}
	return 0
}

func (x *PredefinedFixed32RuleProto3) SetVal(v uint32) {
	x.xxx_hidden_Val = v
}

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

	Val uint32
}

func (b0 PredefinedFixed32RuleProto3_builder) Build() *PredefinedFixed32RuleProto3 {
	m0 := &PredefinedFixed32RuleProto3{}
	b, x := &b0, m0
	_, _ = b, x
	x.xxx_hidden_Val = b.Val
	return m0
}

type PredefinedFixed64RuleProto3 struct {
	state          protoimpl.MessageState `protogen:"opaque.v1"`
	xxx_hidden_Val uint64                 `protobuf:"fixed64,1,opt,name=val,proto3"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*PredefinedFixed64RuleProto3) ProtoMessage() {}

func (x *PredefinedFixed64RuleProto3) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto3_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 *PredefinedFixed64RuleProto3) GetVal() uint64 {
	if x != nil {
		return x.xxx_hidden_Val
	}
	return 0
}

func (x *PredefinedFixed64RuleProto3) SetVal(v uint64) {
	x.xxx_hidden_Val = v
}

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

	Val uint64
}

func (b0 PredefinedFixed64RuleProto3_builder) Build() *PredefinedFixed64RuleProto3 {
	m0 := &PredefinedFixed64RuleProto3{}
	b, x := &b0, m0
	_, _ = b, x
	x.xxx_hidden_Val = b.Val
	return m0
}

type PredefinedSFixed32RuleProto3 struct {
	state          protoimpl.MessageState `protogen:"opaque.v1"`
	xxx_hidden_Val int32                  `protobuf:"fixed32,1,opt,name=val,proto3"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*PredefinedSFixed32RuleProto3) ProtoMessage() {}

func (x *PredefinedSFixed32RuleProto3) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto3_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 *PredefinedSFixed32RuleProto3) GetVal() int32 {
	if x != nil {
		return x.xxx_hidden_Val
	}
	return 0
}

func (x *PredefinedSFixed32RuleProto3) SetVal(v int32) {
	x.xxx_hidden_Val = v
}

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

	Val int32
}

func (b0 PredefinedSFixed32RuleProto3_builder) Build() *PredefinedSFixed32RuleProto3 {
	m0 := &PredefinedSFixed32RuleProto3{}
	b, x := &b0, m0
	_, _ = b, x
	x.xxx_hidden_Val = b.Val
	return m0
}

type PredefinedSFixed64RuleProto3 struct {
	state          protoimpl.MessageState `protogen:"opaque.v1"`
	xxx_hidden_Val int64                  `protobuf:"fixed64,1,opt,name=val,proto3"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*PredefinedSFixed64RuleProto3) ProtoMessage() {}

func (x *PredefinedSFixed64RuleProto3) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto3_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 *PredefinedSFixed64RuleProto3) GetVal() int64 {
	if x != nil {
		return x.xxx_hidden_Val
	}
	return 0
}

func (x *PredefinedSFixed64RuleProto3) SetVal(v int64) {
	x.xxx_hidden_Val = v
}

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

	Val int64
}

func (b0 PredefinedSFixed64RuleProto3_builder) Build() *PredefinedSFixed64RuleProto3 {
	m0 := &PredefinedSFixed64RuleProto3{}
	b, x := &b0, m0
	_, _ = b, x
	x.xxx_hidden_Val = b.Val
	return m0
}

type PredefinedBoolRuleProto3 struct {
	state          protoimpl.MessageState `protogen:"opaque.v1"`
	xxx_hidden_Val bool                   `protobuf:"varint,1,opt,name=val,proto3"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*PredefinedBoolRuleProto3) ProtoMessage() {}

func (x *PredefinedBoolRuleProto3) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto3_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 *PredefinedBoolRuleProto3) GetVal() bool {
	if x != nil {
		return x.xxx_hidden_Val
	}
	return false
}

func (x *PredefinedBoolRuleProto3) SetVal(v bool) {
	x.xxx_hidden_Val = v
}

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

	Val bool
}

func (b0 PredefinedBoolRuleProto3_builder) Build() *PredefinedBoolRuleProto3 {
	m0 := &PredefinedBoolRuleProto3{}
	b, x := &b0, m0
	_, _ = b, x
	x.xxx_hidden_Val = b.Val
	return m0
}

type PredefinedStringRuleProto3 struct {
	state          protoimpl.MessageState `protogen:"opaque.v1"`
	xxx_hidden_Val string                 `protobuf:"bytes,1,opt,name=val,proto3"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*PredefinedStringRuleProto3) ProtoMessage() {}

func (x *PredefinedStringRuleProto3) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto3_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 *PredefinedStringRuleProto3) GetVal() string {
	if x != nil {
		return x.xxx_hidden_Val
	}
	return ""
}

func (x *PredefinedStringRuleProto3) SetVal(v string) {
	x.xxx_hidden_Val = v
}

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

	Val string
}

func (b0 PredefinedStringRuleProto3_builder) Build() *PredefinedStringRuleProto3 {
	m0 := &PredefinedStringRuleProto3{}
	b, x := &b0, m0
	_, _ = b, x
	x.xxx_hidden_Val = b.Val
	return m0
}

type PredefinedBytesRuleProto3 struct {
	state          protoimpl.MessageState `protogen:"opaque.v1"`
	xxx_hidden_Val []byte                 `protobuf:"bytes,1,opt,name=val,proto3"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*PredefinedBytesRuleProto3) ProtoMessage() {}

func (x *PredefinedBytesRuleProto3) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto3_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 *PredefinedBytesRuleProto3) GetVal() []byte {
	if x != nil {
		return x.xxx_hidden_Val
	}
	return nil
}

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

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

	Val []byte
}

func (b0 PredefinedBytesRuleProto3_builder) Build() *PredefinedBytesRuleProto3 {
	m0 := &PredefinedBytesRuleProto3{}
	b, x := &b0, m0
	_, _ = b, x
	x.xxx_hidden_Val = b.Val
	return m0
}

type PredefinedEnumRuleProto3 struct {
	state          protoimpl.MessageState              `protogen:"opaque.v1"`
	xxx_hidden_Val PredefinedEnumRuleProto3_EnumProto3 `protobuf:"varint,1,opt,name=val,proto3,enum=buf.validate.conformance.cases.PredefinedEnumRuleProto3_EnumProto3"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*PredefinedEnumRuleProto3) ProtoMessage() {}

func (x *PredefinedEnumRuleProto3) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto3_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 *PredefinedEnumRuleProto3) GetVal() PredefinedEnumRuleProto3_EnumProto3 {
	if x != nil {
		return x.xxx_hidden_Val
	}
	return PredefinedEnumRuleProto3_ENUM_PROTO3_ZERO_UNSPECIFIED
}

func (x *PredefinedEnumRuleProto3) SetVal(v PredefinedEnumRuleProto3_EnumProto3) {
	x.xxx_hidden_Val = v
}

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

	Val PredefinedEnumRuleProto3_EnumProto3
}

func (b0 PredefinedEnumRuleProto3_builder) Build() *PredefinedEnumRuleProto3 {
	m0 := &PredefinedEnumRuleProto3{}
	b, x := &b0, m0
	_, _ = b, x
	x.xxx_hidden_Val = b.Val
	return m0
}

type PredefinedMapRuleProto3 struct {
	state          protoimpl.MessageState `protogen:"opaque.v1"`
	xxx_hidden_Val map[uint64]uint64      `protobuf:"bytes,1,rep,name=val,proto3" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*PredefinedMapRuleProto3) ProtoMessage() {}

func (x *PredefinedMapRuleProto3) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto3_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 *PredefinedMapRuleProto3) GetVal() map[uint64]uint64 {
	if x != nil {
		return x.xxx_hidden_Val
	}
	return nil
}

func (x *PredefinedMapRuleProto3) SetVal(v map[uint64]uint64) {
	x.xxx_hidden_Val = v
}

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

	Val map[uint64]uint64
}

func (b0 PredefinedMapRuleProto3_builder) Build() *PredefinedMapRuleProto3 {
	m0 := &PredefinedMapRuleProto3{}
	b, x := &b0, m0
	_, _ = b, x
	x.xxx_hidden_Val = b.Val
	return m0
}

type PredefinedRepeatedRuleProto3 struct {
	state          protoimpl.MessageState `protogen:"opaque.v1"`
	xxx_hidden_Val []uint64               `protobuf:"varint,1,rep,packed,name=val,proto3"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*PredefinedRepeatedRuleProto3) ProtoMessage() {}

func (x *PredefinedRepeatedRuleProto3) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto3_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 *PredefinedRepeatedRuleProto3) GetVal() []uint64 {
	if x != nil {
		return x.xxx_hidden_Val
	}
	return nil
}

func (x *PredefinedRepeatedRuleProto3) SetVal(v []uint64) {
	x.xxx_hidden_Val = v
}

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

	Val []uint64
}

func (b0 PredefinedRepeatedRuleProto3_builder) Build() *PredefinedRepeatedRuleProto3 {
	m0 := &PredefinedRepeatedRuleProto3{}
	b, x := &b0, m0
	_, _ = b, x
	x.xxx_hidden_Val = b.Val
	return m0
}

type PredefinedDurationRuleProto3 struct {
	state          protoimpl.MessageState `protogen:"opaque.v1"`
	xxx_hidden_Val *durationpb.Duration   `protobuf:"bytes,1,opt,name=val,proto3"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*PredefinedDurationRuleProto3) ProtoMessage() {}

func (x *PredefinedDurationRuleProto3) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto3_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 *PredefinedDurationRuleProto3) GetVal() *durationpb.Duration {
	if x != nil {
		return x.xxx_hidden_Val
	}
	return nil
}

func (x *PredefinedDurationRuleProto3) SetVal(v *durationpb.Duration) {
	x.xxx_hidden_Val = v
}

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

func (x *PredefinedDurationRuleProto3) ClearVal() {
	x.xxx_hidden_Val = nil
}

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

	Val *durationpb.Duration
}

func (b0 PredefinedDurationRuleProto3_builder) Build() *PredefinedDurationRuleProto3 {
	m0 := &PredefinedDurationRuleProto3{}
	b, x := &b0, m0
	_, _ = b, x
	x.xxx_hidden_Val = b.Val
	return m0
}

type PredefinedTimestampRuleProto3 struct {
	state          protoimpl.MessageState `protogen:"opaque.v1"`
	xxx_hidden_Val *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=val,proto3"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*PredefinedTimestampRuleProto3) ProtoMessage() {}

func (x *PredefinedTimestampRuleProto3) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto3_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 *PredefinedTimestampRuleProto3) GetVal() *timestamppb.Timestamp {
	if x != nil {
		return x.xxx_hidden_Val
	}
	return nil
}

func (x *PredefinedTimestampRuleProto3) SetVal(v *timestamppb.Timestamp) {
	x.xxx_hidden_Val = v
}

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

func (x *PredefinedTimestampRuleProto3) ClearVal() {
	x.xxx_hidden_Val = nil
}

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

	Val *timestamppb.Timestamp
}

func (b0 PredefinedTimestampRuleProto3_builder) Build() *PredefinedTimestampRuleProto3 {
	m0 := &PredefinedTimestampRuleProto3{}
	b, x := &b0, m0
	_, _ = b, x
	x.xxx_hidden_Val = b.Val
	return m0
}

type PredefinedWrappedFloatRuleProto3 struct {
	state          protoimpl.MessageState `protogen:"opaque.v1"`
	xxx_hidden_Val *wrapperspb.FloatValue `protobuf:"bytes,1,opt,name=val,proto3"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*PredefinedWrappedFloatRuleProto3) ProtoMessage() {}

func (x *PredefinedWrappedFloatRuleProto3) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto3_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 *PredefinedWrappedFloatRuleProto3) GetVal() *wrapperspb.FloatValue {
	if x != nil {
		return x.xxx_hidden_Val
	}
	return nil
}

func (x *PredefinedWrappedFloatRuleProto3) SetVal(v *wrapperspb.FloatValue) {
	x.xxx_hidden_Val = v
}

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

func (x *PredefinedWrappedFloatRuleProto3) ClearVal() {
	x.xxx_hidden_Val = nil
}

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

	Val *wrapperspb.FloatValue
}

func (b0 PredefinedWrappedFloatRuleProto3_builder) Build() *PredefinedWrappedFloatRuleProto3 {
	m0 := &PredefinedWrappedFloatRuleProto3{}
	b, x := &b0, m0
	_, _ = b, x
	x.xxx_hidden_Val = b.Val
	return m0
}

type PredefinedWrappedDoubleRuleProto3 struct {
	state          protoimpl.MessageState  `protogen:"opaque.v1"`
	xxx_hidden_Val *wrapperspb.DoubleValue `protobuf:"bytes,1,opt,name=val,proto3"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*PredefinedWrappedDoubleRuleProto3) ProtoMessage() {}

func (x *PredefinedWrappedDoubleRuleProto3) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto3_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 *PredefinedWrappedDoubleRuleProto3) GetVal() *wrapperspb.DoubleValue {
	if x != nil {
		return x.xxx_hidden_Val
	}
	return nil
}

func (x *PredefinedWrappedDoubleRuleProto3) SetVal(v *wrapperspb.DoubleValue) {
	x.xxx_hidden_Val = v
}

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

func (x *PredefinedWrappedDoubleRuleProto3) ClearVal() {
	x.xxx_hidden_Val = nil
}

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

	Val *wrapperspb.DoubleValue
}

func (b0 PredefinedWrappedDoubleRuleProto3_builder) Build() *PredefinedWrappedDoubleRuleProto3 {
	m0 := &PredefinedWrappedDoubleRuleProto3{}
	b, x := &b0, m0
	_, _ = b, x
	x.xxx_hidden_Val = b.Val
	return m0
}

type PredefinedWrappedInt32RuleProto3 struct {
	state          protoimpl.MessageState `protogen:"opaque.v1"`
	xxx_hidden_Val *wrapperspb.Int32Value `protobuf:"bytes,1,opt,name=val,proto3"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*PredefinedWrappedInt32RuleProto3) ProtoMessage() {}

func (x *PredefinedWrappedInt32RuleProto3) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto3_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 *PredefinedWrappedInt32RuleProto3) GetVal() *wrapperspb.Int32Value {
	if x != nil {
		return x.xxx_hidden_Val
	}
	return nil
}

func (x *PredefinedWrappedInt32RuleProto3) SetVal(v *wrapperspb.Int32Value) {
	x.xxx_hidden_Val = v
}

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

func (x *PredefinedWrappedInt32RuleProto3) ClearVal() {
	x.xxx_hidden_Val = nil
}

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

	Val *wrapperspb.Int32Value
}

func (b0 PredefinedWrappedInt32RuleProto3_builder) Build() *PredefinedWrappedInt32RuleProto3 {
	m0 := &PredefinedWrappedInt32RuleProto3{}
	b, x := &b0, m0
	_, _ = b, x
	x.xxx_hidden_Val = b.Val
	return m0
}

type PredefinedWrappedInt64RuleProto3 struct {
	state          protoimpl.MessageState `protogen:"opaque.v1"`
	xxx_hidden_Val *wrapperspb.Int64Value `protobuf:"bytes,1,opt,name=val,proto3"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*PredefinedWrappedInt64RuleProto3) ProtoMessage() {}

func (x *PredefinedWrappedInt64RuleProto3) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto3_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 *PredefinedWrappedInt64RuleProto3) GetVal() *wrapperspb.Int64Value {
	if x != nil {
		return x.xxx_hidden_Val
	}
	return nil
}

func (x *PredefinedWrappedInt64RuleProto3) SetVal(v *wrapperspb.Int64Value) {
	x.xxx_hidden_Val = v
}

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

func (x *PredefinedWrappedInt64RuleProto3) ClearVal() {
	x.xxx_hidden_Val = nil
}

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

	Val *wrapperspb.Int64Value
}

func (b0 PredefinedWrappedInt64RuleProto3_builder) Build() *PredefinedWrappedInt64RuleProto3 {
	m0 := &PredefinedWrappedInt64RuleProto3{}
	b, x := &b0, m0
	_, _ = b, x
	x.xxx_hidden_Val = b.Val
	return m0
}

type PredefinedWrappedUInt32RuleProto3 struct {
	state          protoimpl.MessageState  `protogen:"opaque.v1"`
	xxx_hidden_Val *wrapperspb.UInt32Value `protobuf:"bytes,1,opt,name=val,proto3"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*PredefinedWrappedUInt32RuleProto3) ProtoMessage() {}

func (x *PredefinedWrappedUInt32RuleProto3) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto3_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 *PredefinedWrappedUInt32RuleProto3) GetVal() *wrapperspb.UInt32Value {
	if x != nil {
		return x.xxx_hidden_Val
	}
	return nil
}

func (x *PredefinedWrappedUInt32RuleProto3) SetVal(v *wrapperspb.UInt32Value) {
	x.xxx_hidden_Val = v
}

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

func (x *PredefinedWrappedUInt32RuleProto3) ClearVal() {
	x.xxx_hidden_Val = nil
}

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

	Val *wrapperspb.UInt32Value
}

func (b0 PredefinedWrappedUInt32RuleProto3_builder) Build() *PredefinedWrappedUInt32RuleProto3 {
	m0 := &PredefinedWrappedUInt32RuleProto3{}
	b, x := &b0, m0
	_, _ = b, x
	x.xxx_hidden_Val = b.Val
	return m0
}

type PredefinedWrappedUInt64RuleProto3 struct {
	state          protoimpl.MessageState  `protogen:"opaque.v1"`
	xxx_hidden_Val *wrapperspb.UInt64Value `protobuf:"bytes,1,opt,name=val,proto3"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*PredefinedWrappedUInt64RuleProto3) ProtoMessage() {}

func (x *PredefinedWrappedUInt64RuleProto3) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto3_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 *PredefinedWrappedUInt64RuleProto3) GetVal() *wrapperspb.UInt64Value {
	if x != nil {
		return x.xxx_hidden_Val
	}
	return nil
}

func (x *PredefinedWrappedUInt64RuleProto3) SetVal(v *wrapperspb.UInt64Value) {
	x.xxx_hidden_Val = v
}

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

func (x *PredefinedWrappedUInt64RuleProto3) ClearVal() {
	x.xxx_hidden_Val = nil
}

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

	Val *wrapperspb.UInt64Value
}

func (b0 PredefinedWrappedUInt64RuleProto3_builder) Build() *PredefinedWrappedUInt64RuleProto3 {
	m0 := &PredefinedWrappedUInt64RuleProto3{}
	b, x := &b0, m0
	_, _ = b, x
	x.xxx_hidden_Val = b.Val
	return m0
}

type PredefinedWrappedBoolRuleProto3 struct {
	state          protoimpl.MessageState `protogen:"opaque.v1"`
	xxx_hidden_Val *wrapperspb.BoolValue  `protobuf:"bytes,1,opt,name=val,proto3"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*PredefinedWrappedBoolRuleProto3) ProtoMessage() {}

func (x *PredefinedWrappedBoolRuleProto3) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto3_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 *PredefinedWrappedBoolRuleProto3) GetVal() *wrapperspb.BoolValue {
	if x != nil {
		return x.xxx_hidden_Val
	}
	return nil
}

func (x *PredefinedWrappedBoolRuleProto3) SetVal(v *wrapperspb.BoolValue) {
	x.xxx_hidden_Val = v
}

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

func (x *PredefinedWrappedBoolRuleProto3) ClearVal() {
	x.xxx_hidden_Val = nil
}

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

	Val *wrapperspb.BoolValue
}

func (b0 PredefinedWrappedBoolRuleProto3_builder) Build() *PredefinedWrappedBoolRuleProto3 {
	m0 := &PredefinedWrappedBoolRuleProto3{}
	b, x := &b0, m0
	_, _ = b, x
	x.xxx_hidden_Val = b.Val
	return m0
}

type PredefinedWrappedStringRuleProto3 struct {
	state          protoimpl.MessageState  `protogen:"opaque.v1"`
	xxx_hidden_Val *wrapperspb.StringValue `protobuf:"bytes,1,opt,name=val,proto3"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*PredefinedWrappedStringRuleProto3) ProtoMessage() {}

func (x *PredefinedWrappedStringRuleProto3) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto3_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 *PredefinedWrappedStringRuleProto3) GetVal() *wrapperspb.StringValue {
	if x != nil {
		return x.xxx_hidden_Val
	}
	return nil
}

func (x *PredefinedWrappedStringRuleProto3) SetVal(v *wrapperspb.StringValue) {
	x.xxx_hidden_Val = v
}

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

func (x *PredefinedWrappedStringRuleProto3) ClearVal() {
	x.xxx_hidden_Val = nil
}

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

	Val *wrapperspb.StringValue
}

func (b0 PredefinedWrappedStringRuleProto3_builder) Build() *PredefinedWrappedStringRuleProto3 {
	m0 := &PredefinedWrappedStringRuleProto3{}
	b, x := &b0, m0
	_, _ = b, x
	x.xxx_hidden_Val = b.Val
	return m0
}

type PredefinedWrappedBytesRuleProto3 struct {
	state          protoimpl.MessageState `protogen:"opaque.v1"`
	xxx_hidden_Val *wrapperspb.BytesValue `protobuf:"bytes,1,opt,name=val,proto3"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*PredefinedWrappedBytesRuleProto3) ProtoMessage() {}

func (x *PredefinedWrappedBytesRuleProto3) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto3_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 *PredefinedWrappedBytesRuleProto3) GetVal() *wrapperspb.BytesValue {
	if x != nil {
		return x.xxx_hidden_Val
	}
	return nil
}

func (x *PredefinedWrappedBytesRuleProto3) SetVal(v *wrapperspb.BytesValue) {
	x.xxx_hidden_Val = v
}

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

func (x *PredefinedWrappedBytesRuleProto3) ClearVal() {
	x.xxx_hidden_Val = nil
}

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

	Val *wrapperspb.BytesValue
}

func (b0 PredefinedWrappedBytesRuleProto3_builder) Build() *PredefinedWrappedBytesRuleProto3 {
	m0 := &PredefinedWrappedBytesRuleProto3{}
	b, x := &b0, m0
	_, _ = b, x
	x.xxx_hidden_Val = b.Val
	return m0
}

type PredefinedRepeatedWrappedFloatRuleProto3 struct {
	state          protoimpl.MessageState    `protogen:"opaque.v1"`
	xxx_hidden_Val *[]*wrapperspb.FloatValue `protobuf:"bytes,1,rep,name=val,proto3"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*PredefinedRepeatedWrappedFloatRuleProto3) ProtoMessage() {}

func (x *PredefinedRepeatedWrappedFloatRuleProto3) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto3_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 *PredefinedRepeatedWrappedFloatRuleProto3) GetVal() []*wrapperspb.FloatValue {
	if x != nil {
		if x.xxx_hidden_Val != nil {
			return *x.xxx_hidden_Val
		}
	}
	return nil
}

func (x *PredefinedRepeatedWrappedFloatRuleProto3) SetVal(v []*wrapperspb.FloatValue) {
	x.xxx_hidden_Val = &v
}

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

	Val []*wrapperspb.FloatValue
}

func (b0 PredefinedRepeatedWrappedFloatRuleProto3_builder) Build() *PredefinedRepeatedWrappedFloatRuleProto3 {
	m0 := &PredefinedRepeatedWrappedFloatRuleProto3{}
	b, x := &b0, m0
	_, _ = b, x
	x.xxx_hidden_Val = &b.Val
	return m0
}

type PredefinedRepeatedWrappedDoubleRuleProto3 struct {
	state          protoimpl.MessageState     `protogen:"opaque.v1"`
	xxx_hidden_Val *[]*wrapperspb.DoubleValue `protobuf:"bytes,1,rep,name=val,proto3"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*PredefinedRepeatedWrappedDoubleRuleProto3) ProtoMessage() {}

func (x *PredefinedRepeatedWrappedDoubleRuleProto3) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto3_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 *PredefinedRepeatedWrappedDoubleRuleProto3) GetVal() []*wrapperspb.DoubleValue {
	if x != nil {
		if x.xxx_hidden_Val != nil {
			return *x.xxx_hidden_Val
		}
	}
	return nil
}

func (x *PredefinedRepeatedWrappedDoubleRuleProto3) SetVal(v []*wrapperspb.DoubleValue) {
	x.xxx_hidden_Val = &v
}

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

	Val []*wrapperspb.DoubleValue
}

func (b0 PredefinedRepeatedWrappedDoubleRuleProto3_builder) Build() *PredefinedRepeatedWrappedDoubleRuleProto3 {
	m0 := &PredefinedRepeatedWrappedDoubleRuleProto3{}
	b, x := &b0, m0
	_, _ = b, x
	x.xxx_hidden_Val = &b.Val
	return m0
}

type PredefinedRepeatedWrappedInt32RuleProto3 struct {
	state          protoimpl.MessageState    `protogen:"opaque.v1"`
	xxx_hidden_Val *[]*wrapperspb.Int32Value `protobuf:"bytes,1,rep,name=val,proto3"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*PredefinedRepeatedWrappedInt32RuleProto3) ProtoMessage() {}

func (x *PredefinedRepeatedWrappedInt32RuleProto3) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto3_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 *PredefinedRepeatedWrappedInt32RuleProto3) GetVal() []*wrapperspb.Int32Value {
	if x != nil {
		if x.xxx_hidden_Val != nil {
			return *x.xxx_hidden_Val
		}
	}
	return nil
}

func (x *PredefinedRepeatedWrappedInt32RuleProto3) SetVal(v []*wrapperspb.Int32Value) {
	x.xxx_hidden_Val = &v
}

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

	Val []*wrapperspb.Int32Value
}

func (b0 PredefinedRepeatedWrappedInt32RuleProto3_builder) Build() *PredefinedRepeatedWrappedInt32RuleProto3 {
	m0 := &PredefinedRepeatedWrappedInt32RuleProto3{}
	b, x := &b0, m0
	_, _ = b, x
	x.xxx_hidden_Val = &b.Val
	return m0
}

type PredefinedRepeatedWrappedInt64RuleProto3 struct {
	state          protoimpl.MessageState    `protogen:"opaque.v1"`
	xxx_hidden_Val *[]*wrapperspb.Int64Value `protobuf:"bytes,1,rep,name=val,proto3"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*PredefinedRepeatedWrappedInt64RuleProto3) ProtoMessage() {}

func (x *PredefinedRepeatedWrappedInt64RuleProto3) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto3_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 *PredefinedRepeatedWrappedInt64RuleProto3) GetVal() []*wrapperspb.Int64Value {
	if x != nil {
		if x.xxx_hidden_Val != nil {
			return *x.xxx_hidden_Val
		}
	}
	return nil
}

func (x *PredefinedRepeatedWrappedInt64RuleProto3) SetVal(v []*wrapperspb.Int64Value) {
	x.xxx_hidden_Val = &v
}

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

	Val []*wrapperspb.Int64Value
}

func (b0 PredefinedRepeatedWrappedInt64RuleProto3_builder) Build() *PredefinedRepeatedWrappedInt64RuleProto3 {
	m0 := &PredefinedRepeatedWrappedInt64RuleProto3{}
	b, x := &b0, m0
	_, _ = b, x
	x.xxx_hidden_Val = &b.Val
	return m0
}

type PredefinedRepeatedWrappedUInt32RuleProto3 struct {
	state          protoimpl.MessageState     `protogen:"opaque.v1"`
	xxx_hidden_Val *[]*wrapperspb.UInt32Value `protobuf:"bytes,1,rep,name=val,proto3"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*PredefinedRepeatedWrappedUInt32RuleProto3) ProtoMessage() {}

func (x *PredefinedRepeatedWrappedUInt32RuleProto3) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto3_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 *PredefinedRepeatedWrappedUInt32RuleProto3) GetVal() []*wrapperspb.UInt32Value {
	if x != nil {
		if x.xxx_hidden_Val != nil {
			return *x.xxx_hidden_Val
		}
	}
	return nil
}

func (x *PredefinedRepeatedWrappedUInt32RuleProto3) SetVal(v []*wrapperspb.UInt32Value) {
	x.xxx_hidden_Val = &v
}

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

	Val []*wrapperspb.UInt32Value
}

func (b0 PredefinedRepeatedWrappedUInt32RuleProto3_builder) Build() *PredefinedRepeatedWrappedUInt32RuleProto3 {
	m0 := &PredefinedRepeatedWrappedUInt32RuleProto3{}
	b, x := &b0, m0
	_, _ = b, x
	x.xxx_hidden_Val = &b.Val
	return m0
}

type PredefinedRepeatedWrappedUInt64RuleProto3 struct {
	state          protoimpl.MessageState     `protogen:"opaque.v1"`
	xxx_hidden_Val *[]*wrapperspb.UInt64Value `protobuf:"bytes,1,rep,name=val,proto3"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*PredefinedRepeatedWrappedUInt64RuleProto3) ProtoMessage() {}

func (x *PredefinedRepeatedWrappedUInt64RuleProto3) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto3_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 *PredefinedRepeatedWrappedUInt64RuleProto3) GetVal() []*wrapperspb.UInt64Value {
	if x != nil {
		if x.xxx_hidden_Val != nil {
			return *x.xxx_hidden_Val
		}
	}
	return nil
}

func (x *PredefinedRepeatedWrappedUInt64RuleProto3) SetVal(v []*wrapperspb.UInt64Value) {
	x.xxx_hidden_Val = &v
}

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

	Val []*wrapperspb.UInt64Value
}

func (b0 PredefinedRepeatedWrappedUInt64RuleProto3_builder) Build() *PredefinedRepeatedWrappedUInt64RuleProto3 {
	m0 := &PredefinedRepeatedWrappedUInt64RuleProto3{}
	b, x := &b0, m0
	_, _ = b, x
	x.xxx_hidden_Val = &b.Val
	return m0
}

type PredefinedRepeatedWrappedBoolRuleProto3 struct {
	state          protoimpl.MessageState   `protogen:"opaque.v1"`
	xxx_hidden_Val *[]*wrapperspb.BoolValue `protobuf:"bytes,1,rep,name=val,proto3"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*PredefinedRepeatedWrappedBoolRuleProto3) ProtoMessage() {}

func (x *PredefinedRepeatedWrappedBoolRuleProto3) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto3_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 *PredefinedRepeatedWrappedBoolRuleProto3) GetVal() []*wrapperspb.BoolValue {
	if x != nil {
		if x.xxx_hidden_Val != nil {
			return *x.xxx_hidden_Val
		}
	}
	return nil
}

func (x *PredefinedRepeatedWrappedBoolRuleProto3) SetVal(v []*wrapperspb.BoolValue) {
	x.xxx_hidden_Val = &v
}

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

	Val []*wrapperspb.BoolValue
}

func (b0 PredefinedRepeatedWrappedBoolRuleProto3_builder) Build() *PredefinedRepeatedWrappedBoolRuleProto3 {
	m0 := &PredefinedRepeatedWrappedBoolRuleProto3{}
	b, x := &b0, m0
	_, _ = b, x
	x.xxx_hidden_Val = &b.Val
	return m0
}

type PredefinedRepeatedWrappedStringRuleProto3 struct {
	state          protoimpl.MessageState     `protogen:"opaque.v1"`
	xxx_hidden_Val *[]*wrapperspb.StringValue `protobuf:"bytes,1,rep,name=val,proto3"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*PredefinedRepeatedWrappedStringRuleProto3) ProtoMessage() {}

func (x *PredefinedRepeatedWrappedStringRuleProto3) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto3_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 *PredefinedRepeatedWrappedStringRuleProto3) GetVal() []*wrapperspb.StringValue {
	if x != nil {
		if x.xxx_hidden_Val != nil {
			return *x.xxx_hidden_Val
		}
	}
	return nil
}

func (x *PredefinedRepeatedWrappedStringRuleProto3) SetVal(v []*wrapperspb.StringValue) {
	x.xxx_hidden_Val = &v
}

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

	Val []*wrapperspb.StringValue
}

func (b0 PredefinedRepeatedWrappedStringRuleProto3_builder) Build() *PredefinedRepeatedWrappedStringRuleProto3 {
	m0 := &PredefinedRepeatedWrappedStringRuleProto3{}
	b, x := &b0, m0
	_, _ = b, x
	x.xxx_hidden_Val = &b.Val
	return m0
}

type PredefinedRepeatedWrappedBytesRuleProto3 struct {
	state          protoimpl.MessageState    `protogen:"opaque.v1"`
	xxx_hidden_Val *[]*wrapperspb.BytesValue `protobuf:"bytes,1,rep,name=val,proto3"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*PredefinedRepeatedWrappedBytesRuleProto3) ProtoMessage() {}

func (x *PredefinedRepeatedWrappedBytesRuleProto3) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto3_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 *PredefinedRepeatedWrappedBytesRuleProto3) GetVal() []*wrapperspb.BytesValue {
	if x != nil {
		if x.xxx_hidden_Val != nil {
			return *x.xxx_hidden_Val
		}
	}
	return nil
}

func (x *PredefinedRepeatedWrappedBytesRuleProto3) SetVal(v []*wrapperspb.BytesValue) {
	x.xxx_hidden_Val = &v
}

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

	Val []*wrapperspb.BytesValue
}

func (b0 PredefinedRepeatedWrappedBytesRuleProto3_builder) Build() *PredefinedRepeatedWrappedBytesRuleProto3 {
	m0 := &PredefinedRepeatedWrappedBytesRuleProto3{}
	b, x := &b0, m0
	_, _ = b, x
	x.xxx_hidden_Val = &b.Val
	return m0
}

type PredefinedAndCustomRuleProto3 struct {
	state         protoimpl.MessageState                `protogen:"opaque.v1"`
	xxx_hidden_A  int32                                 `protobuf:"zigzag32,1,opt,name=a,proto3"`
	xxx_hidden_B  *PredefinedAndCustomRuleProto3_Nested `protobuf:"bytes,2,opt,name=b,proto3,oneof"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*PredefinedAndCustomRuleProto3) ProtoMessage() {}

func (x *PredefinedAndCustomRuleProto3) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto3_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 *PredefinedAndCustomRuleProto3) GetA() int32 {
	if x != nil {
		return x.xxx_hidden_A
	}
	return 0
}

func (x *PredefinedAndCustomRuleProto3) GetB() *PredefinedAndCustomRuleProto3_Nested {
	if x != nil {
		return x.xxx_hidden_B
	}
	return nil
}

func (x *PredefinedAndCustomRuleProto3) SetA(v int32) {
	x.xxx_hidden_A = v
}

func (x *PredefinedAndCustomRuleProto3) SetB(v *PredefinedAndCustomRuleProto3_Nested) {
	x.xxx_hidden_B = v
}

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

func (x *PredefinedAndCustomRuleProto3) ClearB() {
	x.xxx_hidden_B = nil
}

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

	A int32
	B *PredefinedAndCustomRuleProto3_Nested
}

func (b0 PredefinedAndCustomRuleProto3_builder) Build() *PredefinedAndCustomRuleProto3 {
	m0 := &PredefinedAndCustomRuleProto3{}
	b, x := &b0, m0
	_, _ = b, x
	x.xxx_hidden_A = b.A
	x.xxx_hidden_B = b.B
	return m0
}

type StandardPredefinedAndCustomRuleProto3 struct {
	state         protoimpl.MessageState `protogen:"opaque.v1"`
	xxx_hidden_A  int32                  `protobuf:"zigzag32,1,opt,name=a,proto3"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*StandardPredefinedAndCustomRuleProto3) ProtoMessage() {}

func (x *StandardPredefinedAndCustomRuleProto3) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto3_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 *StandardPredefinedAndCustomRuleProto3) GetA() int32 {
	if x != nil {
		return x.xxx_hidden_A
	}
	return 0
}

func (x *StandardPredefinedAndCustomRuleProto3) SetA(v int32) {
	x.xxx_hidden_A = v
}

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

	A int32
}

func (b0 StandardPredefinedAndCustomRuleProto3_builder) Build() *StandardPredefinedAndCustomRuleProto3 {
	m0 := &StandardPredefinedAndCustomRuleProto3{}
	b, x := &b0, m0
	_, _ = b, x
	x.xxx_hidden_A = b.A
	return m0
}

// This is a workaround for https://github.com/bufbuild/buf/issues/3306.
// TODO(jchadwick-buf): Remove this when bufbuild/buf#3306 is fixed.
type PredefinedRulesProto3UnusedImportBugWorkaround struct {
	state              protoimpl.MessageState                      `protogen:"opaque.v1"`
	xxx_hidden_Dummy_1 *StandardPredefinedAndCustomRuleProto2      `protobuf:"bytes,1,opt,name=dummy_1,json=dummy1,proto3"`
	xxx_hidden_Dummy_2 *StandardPredefinedAndCustomRuleEdition2023 `protobuf:"bytes,2,opt,name=dummy_2,json=dummy2,proto3"`
	unknownFields      protoimpl.UnknownFields
	sizeCache          protoimpl.SizeCache
}

func (x *PredefinedRulesProto3UnusedImportBugWorkaround) Reset() {
	*x = PredefinedRulesProto3UnusedImportBugWorkaround{}
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto3_proto_msgTypes[40]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*PredefinedRulesProto3UnusedImportBugWorkaround) ProtoMessage() {}

func (x *PredefinedRulesProto3UnusedImportBugWorkaround) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto3_proto_msgTypes[40]
	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 *PredefinedRulesProto3UnusedImportBugWorkaround) GetDummy_1() *StandardPredefinedAndCustomRuleProto2 {
	if x != nil {
		return x.xxx_hidden_Dummy_1
	}
	return nil
}

func (x *PredefinedRulesProto3UnusedImportBugWorkaround) GetDummy_2() *StandardPredefinedAndCustomRuleEdition2023 {
	if x != nil {
		return x.xxx_hidden_Dummy_2
	}
	return nil
}

func (x *PredefinedRulesProto3UnusedImportBugWorkaround) SetDummy_1(v *StandardPredefinedAndCustomRuleProto2) {
	x.xxx_hidden_Dummy_1 = v
}

func (x *PredefinedRulesProto3UnusedImportBugWorkaround) SetDummy_2(v *StandardPredefinedAndCustomRuleEdition2023) {
	x.xxx_hidden_Dummy_2 = v
}

func (x *PredefinedRulesProto3UnusedImportBugWorkaround) HasDummy_1() bool {
	if x == nil {
		return false
	}
	return x.xxx_hidden_Dummy_1 != nil
}

func (x *PredefinedRulesProto3UnusedImportBugWorkaround) HasDummy_2() bool {
	if x == nil {
		return false
	}
	return x.xxx_hidden_Dummy_2 != nil
}

func (x *PredefinedRulesProto3UnusedImportBugWorkaround) ClearDummy_1() {
	x.xxx_hidden_Dummy_1 = nil
}

func (x *PredefinedRulesProto3UnusedImportBugWorkaround) ClearDummy_2() {
	x.xxx_hidden_Dummy_2 = nil
}

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

	Dummy_1 *StandardPredefinedAndCustomRuleProto2
	Dummy_2 *StandardPredefinedAndCustomRuleEdition2023
}

func (b0 PredefinedRulesProto3UnusedImportBugWorkaround_builder) Build() *PredefinedRulesProto3UnusedImportBugWorkaround {
	m0 := &PredefinedRulesProto3UnusedImportBugWorkaround{}
	b, x := &b0, m0
	_, _ = b, x
	x.xxx_hidden_Dummy_1 = b.Dummy_1
	x.xxx_hidden_Dummy_2 = b.Dummy_2
	return m0
}

type PredefinedAndCustomRuleProto3_Nested struct {
	state         protoimpl.MessageState `protogen:"opaque.v1"`
	xxx_hidden_C  int32                  `protobuf:"zigzag32,1,opt,name=c,proto3"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PredefinedAndCustomRuleProto3_Nested) Reset() {
	*x = PredefinedAndCustomRuleProto3_Nested{}
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto3_proto_msgTypes[42]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*PredefinedAndCustomRuleProto3_Nested) ProtoMessage() {}

func (x *PredefinedAndCustomRuleProto3_Nested) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_predefined_rules_proto3_proto_msgTypes[42]
	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 *PredefinedAndCustomRuleProto3_Nested) GetC() int32 {
	if x != nil {
		return x.xxx_hidden_C
	}
	return 0
}

func (x *PredefinedAndCustomRuleProto3_Nested) SetC(v int32) {
	x.xxx_hidden_C = v
}

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

	C int32
}

func (b0 PredefinedAndCustomRuleProto3_Nested_builder) Build() *PredefinedAndCustomRuleProto3_Nested {
	m0 := &PredefinedAndCustomRuleProto3_Nested{}
	b, x := &b0, m0
	_, _ = b, x
	x.xxx_hidden_C = b.C
	return m0
}

var File_buf_validate_conformance_cases_predefined_rules_proto3_proto protoreflect.FileDescriptor

const file_buf_validate_conformance_cases_predefined_rules_proto3_proto_rawDesc = "" +
	"\n" +
	"<buf/validate/conformance/cases/predefined_rules_proto3.proto\x12\x1ebuf.validate.conformance.cases\x1a<buf/validate/conformance/cases/predefined_rules_proto2.proto\x1aDbuf/validate/conformance/cases/predefined_rules_proto_editions.proto\x1a\x1bbuf/validate/validate.proto\x1a\x1egoogle/protobuf/duration.proto\x1a\x1fgoogle/protobuf/timestamp.proto\x1a\x1egoogle/protobuf/wrappers.proto\":\n" +
	"\x19PredefinedFloatRuleProto3\x12\x1d\n" +
	"\x03val\x18\x01 \x01(\x02B\v\xbaH\b\n" +
	"\x06\xcdH\x00\x00\x80?R\x03val\"?\n" +
	"\x1aPredefinedDoubleRuleProto3\x12!\n" +
	"\x03val\x18\x01 \x01(\x01B\x0f\xbaH\f\x12\n" +
	"\xc9H\x00\x00\x00\x00\x00\x00\xf0?R\x03val\"@\n" +
	"\x19PredefinedInt32RuleProto3\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" +
	"\x19PredefinedInt64RuleProto3\x12%\n" +
	"\x03val\x18\x01 \x01(\x03B\x13\xbaH\x10\"\x0e\xd2H\v\b\xfe\xff\xff\xff\xff\xff\xff\xff\xff\x01R\x03val\"8\n" +
	"\x1aPredefinedUInt32RuleProto3\x12\x1a\n" +
	"\x03val\x18\x01 \x01(\rB\b\xbaH\x05*\x03\xc8H\x01R\x03val\"8\n" +
	"\x1aPredefinedUInt64RuleProto3\x12\x1a\n" +
	"\x03val\x18\x01 \x01(\x04B\b\xbaH\x052\x03\xc8H\x01R\x03val\"8\n" +
	"\x1aPredefinedSInt32RuleProto3\x12\x1a\n" +
	"\x03val\x18\x01 \x01(\x11B\b\xbaH\x05:\x03\xc8H\x01R\x03val\"8\n" +
	"\x1aPredefinedSInt64RuleProto3\x12\x1a\n" +
	"\x03val\x18\x01 \x01(\x12B\b\xbaH\x05B\x03\xc8H\x01R\x03val\"9\n" +
	"\x1bPredefinedFixed32RuleProto3\x12\x1a\n" +
	"\x03val\x18\x01 \x01(\aB\b\xbaH\x05J\x03\xc8H\x01R\x03val\"9\n" +
	"\x1bPredefinedFixed64RuleProto3\x12\x1a\n" +
	"\x03val\x18\x01 \x01(\x06B\b\xbaH\x05R\x03\xc8H\x01R\x03val\":\n" +
	"\x1cPredefinedSFixed32RuleProto3\x12\x1a\n" +
	"\x03val\x18\x01 \x01(\x0fB\b\xbaH\x05Z\x03\xc8H\x01R\x03val\":\n" +
	"\x1cPredefinedSFixed64RuleProto3\x12\x1a\n" +
	"\x03val\x18\x01 \x01(\x10B\b\xbaH\x05b\x03\xc8H\x01R\x03val\"6\n" +
	"\x18PredefinedBoolRuleProto3\x12\x1a\n" +
	"\x03val\x18\x01 \x01(\bB\b\xbaH\x05j\x03\xc8H\x01R\x03val\"8\n" +
	"\x1aPredefinedStringRuleProto3\x12\x1a\n" +
	"\x03val\x18\x01 \x01(\tB\b\xbaH\x05r\x03\xc8H\x01R\x03val\"7\n" +
	"\x19PredefinedBytesRuleProto3\x12\x1a\n" +
	"\x03val\x18\x01 \x01(\fB\b\xbaH\x05z\x03\xc8H\x01R\x03val\"\xc1\x01\n" +
	"\x18PredefinedEnumRuleProto3\x12`\n" +
	"\x03val\x18\x01 \x01(\x0e2C.buf.validate.conformance.cases.PredefinedEnumRuleProto3.EnumProto3B\t\xbaH\x06\x82\x01\x03\xc8H\x01R\x03val\"C\n" +
	"\n" +
	"EnumProto3\x12 \n" +
	"\x1cENUM_PROTO3_ZERO_UNSPECIFIED\x10\x00\x12\x13\n" +
	"\x0fENUM_PROTO3_ONE\x10\x01\"\xb0\x01\n" +
	"\x17PredefinedMapRuleProto3\x12]\n" +
	"\x03val\x18\x01 \x03(\v2@.buf.validate.conformance.cases.PredefinedMapRuleProto3.ValEntryB\t\xbaH\x06\x9a\x01\x03\xd0H\x01R\x03val\x1a6\n" +
	"\bValEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\x04R\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\x04R\x05value:\x028\x01\";\n" +
	"\x1cPredefinedRepeatedRuleProto3\x12\x1b\n" +
	"\x03val\x18\x01 \x03(\x04B\t\xbaH\x06\x92\x01\x03\xc8H\x01R\x03val\"V\n" +
	"\x1cPredefinedDurationRuleProto3\x126\n" +
	"\x03val\x18\x01 \x01(\v2\x19.google.protobuf.DurationB\t\xbaH\x06\xaa\x01\x03\xc8H\x01R\x03val\"X\n" +
	"\x1dPredefinedTimestampRuleProto3\x127\n" +
	"\x03val\x18\x01 \x01(\v2\x1a.google.protobuf.TimestampB\t\xbaH\x06\xb2\x01\x03\xc8H\x01R\x03val\"^\n" +
	" PredefinedWrappedFloatRuleProto3\x12:\n" +
	"\x03val\x18\x01 \x01(\v2\x1b.google.protobuf.FloatValueB\v\xbaH\b\n" +
	"\x06\xcdH\x00\x00\x80?R\x03val\"d\n" +
	"!PredefinedWrappedDoubleRuleProto3\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" +
	" PredefinedWrappedInt32RuleProto3\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" +
	" PredefinedWrappedInt64RuleProto3\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" +
	"!PredefinedWrappedUInt32RuleProto3\x128\n" +
	"\x03val\x18\x01 \x01(\v2\x1c.google.protobuf.UInt32ValueB\b\xbaH\x05*\x03\xc8H\x01R\x03val\"]\n" +
	"!PredefinedWrappedUInt64RuleProto3\x128\n" +
	"\x03val\x18\x01 \x01(\v2\x1c.google.protobuf.UInt64ValueB\b\xbaH\x052\x03\xc8H\x01R\x03val\"Y\n" +
	"\x1fPredefinedWrappedBoolRuleProto3\x126\n" +
	"\x03val\x18\x01 \x01(\v2\x1a.google.protobuf.BoolValueB\b\xbaH\x05j\x03\xc8H\x01R\x03val\"]\n" +
	"!PredefinedWrappedStringRuleProto3\x128\n" +
	"\x03val\x18\x01 \x01(\v2\x1c.google.protobuf.StringValueB\b\xbaH\x05r\x03\xc8H\x01R\x03val\"[\n" +
	" PredefinedWrappedBytesRuleProto3\x127\n" +
	"\x03val\x18\x01 \x01(\v2\x1b.google.protobuf.BytesValueB\b\xbaH\x05z\x03\xc8H\x01R\x03val\"k\n" +
	"(PredefinedRepeatedWrappedFloatRuleProto3\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" +
	")PredefinedRepeatedWrappedDoubleRuleProto3\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" +
	"(PredefinedRepeatedWrappedInt32RuleProto3\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" +
	"(PredefinedRepeatedWrappedInt64RuleProto3\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" +
	")PredefinedRepeatedWrappedUInt32RuleProto3\x12=\n" +
	"\x03val\x18\x01 \x03(\v2\x1c.google.protobuf.UInt32ValueB\r\xbaH\n" +
	"\x92\x01\a\"\x05*\x03\xc8H\x01R\x03val\"j\n" +
	")PredefinedRepeatedWrappedUInt64RuleProto3\x12=\n" +
	"\x03val\x18\x01 \x03(\v2\x1c.google.protobuf.UInt64ValueB\r\xbaH\n" +
	"\x92\x01\a\"\x052\x03\xc8H\x01R\x03val\"f\n" +
	"'PredefinedRepeatedWrappedBoolRuleProto3\x12;\n" +
	"\x03val\x18\x01 \x03(\v2\x1a.google.protobuf.BoolValueB\r\xbaH\n" +
	"\x92\x01\a\"\x05j\x03\xc8H\x01R\x03val\"j\n" +
	")PredefinedRepeatedWrappedStringRuleProto3\x12=\n" +
	"\x03val\x18\x01 \x03(\v2\x1c.google.protobuf.StringValueB\r\xbaH\n" +
	"\x92\x01\a\"\x05r\x03\xc8H\x01R\x03val\"h\n" +
	"(PredefinedRepeatedWrappedBytesRuleProto3\x12<\n" +
	"\x03val\x18\x01 \x03(\v2\x1b.google.protobuf.BytesValueB\r\xbaH\n" +
	"\x92\x01\a\"\x05z\x03\xc8H\x01R\x03val\"\xc9\x03\n" +
	"\x1dPredefinedAndCustomRuleProto3\x12q\n" +
	"\x01a\x18\x01 \x01(\x11Bc\xbaH`\xba\x01X\n" +
	"(predefined_and_custom_rule_scalar_proto3\x1a,this > 24 ? '' : 'a must be greater than 24':\x03\xd0H\x01R\x01a\x12\xb9\x01\n" +
	"\x01b\x18\x02 \x01(\v2D.buf.validate.conformance.cases.PredefinedAndCustomRuleProto3.NestedB`\xbaH]\xba\x01Z\n" +
	"*predefined_and_custom_rule_embedded_proto3\x12\x1bb.c must be a multiple of 3\x1a\x0fthis.c % 3 == 0H\x00R\x01b\x88\x01\x01\x1as\n" +
	"\x06Nested\x12i\n" +
	"\x01c\x18\x01 \x01(\x11B[\xbaHX\xba\x01P\n" +
	"(predefined_and_custom_rule_nested_proto3\x1a$this > 0 ? '' : 'c must be positive':\x03\xd0H\x01R\x01cB\x04\n" +
	"\x02_b\"\xa5\x01\n" +
	"%StandardPredefinedAndCustomRuleProto3\x12|\n" +
	"\x01a\x18\x01 \x01(\x11Bn\xbaHk\xba\x01a\n" +
	"1standard_predefined_and_custom_rule_scalar_proto3\x1a,this > 24 ? '' : 'a must be greater than 24':\x05\xc8H\x01\x108R\x01a\"\xf5\x01\n" +
	".PredefinedRulesProto3UnusedImportBugWorkaround\x12^\n" +
	"\adummy_1\x18\x01 \x01(\v2E.buf.validate.conformance.cases.StandardPredefinedAndCustomRuleProto2R\x06dummy1\x12c\n" +
	"\adummy_2\x18\x02 \x01(\v2J.buf.validate.conformance.cases.StandardPredefinedAndCustomRuleEdition2023R\x06dummy2B\xa4\x02\n" +
	"\"com.buf.validate.conformance.casesB\x1aPredefinedRulesProto3ProtoP\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::Casesb\x06proto3"

var file_buf_validate_conformance_cases_predefined_rules_proto3_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
var file_buf_validate_conformance_cases_predefined_rules_proto3_proto_msgTypes = make([]protoimpl.MessageInfo, 43)
var file_buf_validate_conformance_cases_predefined_rules_proto3_proto_goTypes = []any{
	(PredefinedEnumRuleProto3_EnumProto3)(0),               // 0: buf.validate.conformance.cases.PredefinedEnumRuleProto3.EnumProto3
	(*PredefinedFloatRuleProto3)(nil),                      // 1: buf.validate.conformance.cases.PredefinedFloatRuleProto3
	(*PredefinedDoubleRuleProto3)(nil),                     // 2: buf.validate.conformance.cases.PredefinedDoubleRuleProto3
	(*PredefinedInt32RuleProto3)(nil),                      // 3: buf.validate.conformance.cases.PredefinedInt32RuleProto3
	(*PredefinedInt64RuleProto3)(nil),                      // 4: buf.validate.conformance.cases.PredefinedInt64RuleProto3
	(*PredefinedUInt32RuleProto3)(nil),                     // 5: buf.validate.conformance.cases.PredefinedUInt32RuleProto3
	(*PredefinedUInt64RuleProto3)(nil),                     // 6: buf.validate.conformance.cases.PredefinedUInt64RuleProto3
	(*PredefinedSInt32RuleProto3)(nil),                     // 7: buf.validate.conformance.cases.PredefinedSInt32RuleProto3
	(*PredefinedSInt64RuleProto3)(nil),                     // 8: buf.validate.conformance.cases.PredefinedSInt64RuleProto3
	(*PredefinedFixed32RuleProto3)(nil),                    // 9: buf.validate.conformance.cases.PredefinedFixed32RuleProto3
	(*PredefinedFixed64RuleProto3)(nil),                    // 10: buf.validate.conformance.cases.PredefinedFixed64RuleProto3
	(*PredefinedSFixed32RuleProto3)(nil),                   // 11: buf.validate.conformance.cases.PredefinedSFixed32RuleProto3
	(*PredefinedSFixed64RuleProto3)(nil),                   // 12: buf.validate.conformance.cases.PredefinedSFixed64RuleProto3
	(*PredefinedBoolRuleProto3)(nil),                       // 13: buf.validate.conformance.cases.PredefinedBoolRuleProto3
	(*PredefinedStringRuleProto3)(nil),                     // 14: buf.validate.conformance.cases.PredefinedStringRuleProto3
	(*PredefinedBytesRuleProto3)(nil),                      // 15: buf.validate.conformance.cases.PredefinedBytesRuleProto3
	(*PredefinedEnumRuleProto3)(nil),                       // 16: buf.validate.conformance.cases.PredefinedEnumRuleProto3
	(*PredefinedMapRuleProto3)(nil),                        // 17: buf.validate.conformance.cases.PredefinedMapRuleProto3
	(*PredefinedRepeatedRuleProto3)(nil),                   // 18: buf.validate.conformance.cases.PredefinedRepeatedRuleProto3
	(*PredefinedDurationRuleProto3)(nil),                   // 19: buf.validate.conformance.cases.PredefinedDurationRuleProto3
	(*PredefinedTimestampRuleProto3)(nil),                  // 20: buf.validate.conformance.cases.PredefinedTimestampRuleProto3
	(*PredefinedWrappedFloatRuleProto3)(nil),               // 21: buf.validate.conformance.cases.PredefinedWrappedFloatRuleProto3
	(*PredefinedWrappedDoubleRuleProto3)(nil),              // 22: buf.validate.conformance.cases.PredefinedWrappedDoubleRuleProto3
	(*PredefinedWrappedInt32RuleProto3)(nil),               // 23: buf.validate.conformance.cases.PredefinedWrappedInt32RuleProto3
	(*PredefinedWrappedInt64RuleProto3)(nil),               // 24: buf.validate.conformance.cases.PredefinedWrappedInt64RuleProto3
	(*PredefinedWrappedUInt32RuleProto3)(nil),              // 25: buf.validate.conformance.cases.PredefinedWrappedUInt32RuleProto3
	(*PredefinedWrappedUInt64RuleProto3)(nil),              // 26: buf.validate.conformance.cases.PredefinedWrappedUInt64RuleProto3
	(*PredefinedWrappedBoolRuleProto3)(nil),                // 27: buf.validate.conformance.cases.PredefinedWrappedBoolRuleProto3
	(*PredefinedWrappedStringRuleProto3)(nil),              // 28: buf.validate.conformance.cases.PredefinedWrappedStringRuleProto3
	(*PredefinedWrappedBytesRuleProto3)(nil),               // 29: buf.validate.conformance.cases.PredefinedWrappedBytesRuleProto3
	(*PredefinedRepeatedWrappedFloatRuleProto3)(nil),       // 30: buf.validate.conformance.cases.PredefinedRepeatedWrappedFloatRuleProto3
	(*PredefinedRepeatedWrappedDoubleRuleProto3)(nil),      // 31: buf.validate.conformance.cases.PredefinedRepeatedWrappedDoubleRuleProto3
	(*PredefinedRepeatedWrappedInt32RuleProto3)(nil),       // 32: buf.validate.conformance.cases.PredefinedRepeatedWrappedInt32RuleProto3
	(*PredefinedRepeatedWrappedInt64RuleProto3)(nil),       // 33: buf.validate.conformance.cases.PredefinedRepeatedWrappedInt64RuleProto3
	(*PredefinedRepeatedWrappedUInt32RuleProto3)(nil),      // 34: buf.validate.conformance.cases.PredefinedRepeatedWrappedUInt32RuleProto3
	(*PredefinedRepeatedWrappedUInt64RuleProto3)(nil),      // 35: buf.validate.conformance.cases.PredefinedRepeatedWrappedUInt64RuleProto3
	(*PredefinedRepeatedWrappedBoolRuleProto3)(nil),        // 36: buf.validate.conformance.cases.PredefinedRepeatedWrappedBoolRuleProto3
	(*PredefinedRepeatedWrappedStringRuleProto3)(nil),      // 37: buf.validate.conformance.cases.PredefinedRepeatedWrappedStringRuleProto3
	(*PredefinedRepeatedWrappedBytesRuleProto3)(nil),       // 38: buf.validate.conformance.cases.PredefinedRepeatedWrappedBytesRuleProto3
	(*PredefinedAndCustomRuleProto3)(nil),                  // 39: buf.validate.conformance.cases.PredefinedAndCustomRuleProto3
	(*StandardPredefinedAndCustomRuleProto3)(nil),          // 40: buf.validate.conformance.cases.StandardPredefinedAndCustomRuleProto3
	(*PredefinedRulesProto3UnusedImportBugWorkaround)(nil), // 41: buf.validate.conformance.cases.PredefinedRulesProto3UnusedImportBugWorkaround
	nil, // 42: buf.validate.conformance.cases.PredefinedMapRuleProto3.ValEntry
	(*PredefinedAndCustomRuleProto3_Nested)(nil),       // 43: buf.validate.conformance.cases.PredefinedAndCustomRuleProto3.Nested
	(*durationpb.Duration)(nil),                        // 44: google.protobuf.Duration
	(*timestamppb.Timestamp)(nil),                      // 45: google.protobuf.Timestamp
	(*wrapperspb.FloatValue)(nil),                      // 46: google.protobuf.FloatValue
	(*wrapperspb.DoubleValue)(nil),                     // 47: google.protobuf.DoubleValue
	(*wrapperspb.Int32Value)(nil),                      // 48: google.protobuf.Int32Value
	(*wrapperspb.Int64Value)(nil),                      // 49: google.protobuf.Int64Value
	(*wrapperspb.UInt32Value)(nil),                     // 50: google.protobuf.UInt32Value
	(*wrapperspb.UInt64Value)(nil),                     // 51: google.protobuf.UInt64Value
	(*wrapperspb.BoolValue)(nil),                       // 52: google.protobuf.BoolValue
	(*wrapperspb.StringValue)(nil),                     // 53: google.protobuf.StringValue
	(*wrapperspb.BytesValue)(nil),                      // 54: google.protobuf.BytesValue
	(*StandardPredefinedAndCustomRuleProto2)(nil),      // 55: buf.validate.conformance.cases.StandardPredefinedAndCustomRuleProto2
	(*StandardPredefinedAndCustomRuleEdition2023)(nil), // 56: buf.validate.conformance.cases.StandardPredefinedAndCustomRuleEdition2023
}
var file_buf_validate_conformance_cases_predefined_rules_proto3_proto_depIdxs = []int32{
	0,  // 0: buf.validate.conformance.cases.PredefinedEnumRuleProto3.val:type_name -> buf.validate.conformance.cases.PredefinedEnumRuleProto3.EnumProto3
	42, // 1: buf.validate.conformance.cases.PredefinedMapRuleProto3.val:type_name -> buf.validate.conformance.cases.PredefinedMapRuleProto3.ValEntry
	44, // 2: buf.validate.conformance.cases.PredefinedDurationRuleProto3.val:type_name -> google.protobuf.Duration
	45, // 3: buf.validate.conformance.cases.PredefinedTimestampRuleProto3.val:type_name -> google.protobuf.Timestamp
	46, // 4: buf.validate.conformance.cases.PredefinedWrappedFloatRuleProto3.val:type_name -> google.protobuf.FloatValue
	47, // 5: buf.validate.conformance.cases.PredefinedWrappedDoubleRuleProto3.val:type_name -> google.protobuf.DoubleValue
	48, // 6: buf.validate.conformance.cases.PredefinedWrappedInt32RuleProto3.val:type_name -> google.protobuf.Int32Value
	49, // 7: buf.validate.conformance.cases.PredefinedWrappedInt64RuleProto3.val:type_name -> google.protobuf.Int64Value
	50, // 8: buf.validate.conformance.cases.PredefinedWrappedUInt32RuleProto3.val:type_name -> google.protobuf.UInt32Value
	51, // 9: buf.validate.conformance.cases.PredefinedWrappedUInt64RuleProto3.val:type_name -> google.protobuf.UInt64Value
	52, // 10: buf.validate.conformance.cases.PredefinedWrappedBoolRuleProto3.val:type_name -> google.protobuf.BoolValue
	53, // 11: buf.validate.conformance.cases.PredefinedWrappedStringRuleProto3.val:type_name -> google.protobuf.StringValue
	54, // 12: buf.validate.conformance.cases.PredefinedWrappedBytesRuleProto3.val:type_name -> google.protobuf.BytesValue
	46, // 13: buf.validate.conformance.cases.PredefinedRepeatedWrappedFloatRuleProto3.val:type_name -> google.protobuf.FloatValue
	47, // 14: buf.validate.conformance.cases.PredefinedRepeatedWrappedDoubleRuleProto3.val:type_name -> google.protobuf.DoubleValue
	48, // 15: buf.validate.conformance.cases.PredefinedRepeatedWrappedInt32RuleProto3.val:type_name -> google.protobuf.Int32Value
	49, // 16: buf.validate.conformance.cases.PredefinedRepeatedWrappedInt64RuleProto3.val:type_name -> google.protobuf.Int64Value
	50, // 17: buf.validate.conformance.cases.PredefinedRepeatedWrappedUInt32RuleProto3.val:type_name -> google.protobuf.UInt32Value
	51, // 18: buf.validate.conformance.cases.PredefinedRepeatedWrappedUInt64RuleProto3.val:type_name -> google.protobuf.UInt64Value
	52, // 19: buf.validate.conformance.cases.PredefinedRepeatedWrappedBoolRuleProto3.val:type_name -> google.protobuf.BoolValue
	53, // 20: buf.validate.conformance.cases.PredefinedRepeatedWrappedStringRuleProto3.val:type_name -> google.protobuf.StringValue
	54, // 21: buf.validate.conformance.cases.PredefinedRepeatedWrappedBytesRuleProto3.val:type_name -> google.protobuf.BytesValue
	43, // 22: buf.validate.conformance.cases.PredefinedAndCustomRuleProto3.b:type_name -> buf.validate.conformance.cases.PredefinedAndCustomRuleProto3.Nested
	55, // 23: buf.validate.conformance.cases.PredefinedRulesProto3UnusedImportBugWorkaround.dummy_1:type_name -> buf.validate.conformance.cases.StandardPredefinedAndCustomRuleProto2
	56, // 24: buf.validate.conformance.cases.PredefinedRulesProto3UnusedImportBugWorkaround.dummy_2:type_name -> buf.validate.conformance.cases.StandardPredefinedAndCustomRuleEdition2023
	25, // [25:25] is the sub-list for method output_type
	25, // [25:25] is the sub-list for method input_type
	25, // [25:25] is the sub-list for extension type_name
	25, // [25:25] is the sub-list for extension extendee
	0,  // [0:25] is the sub-list for field type_name
}

func init() { file_buf_validate_conformance_cases_predefined_rules_proto3_proto_init() }
func file_buf_validate_conformance_cases_predefined_rules_proto3_proto_init() {
	if File_buf_validate_conformance_cases_predefined_rules_proto3_proto != nil {
		return
	}
	file_buf_validate_conformance_cases_predefined_rules_proto2_proto_init()
	file_buf_validate_conformance_cases_predefined_rules_proto_editions_proto_init()
	file_buf_validate_conformance_cases_predefined_rules_proto3_proto_msgTypes[38].OneofWrappers = []any{}
	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_proto3_proto_rawDesc), len(file_buf_validate_conformance_cases_predefined_rules_proto3_proto_rawDesc)),
			NumEnums:      1,
			NumMessages:   43,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_buf_validate_conformance_cases_predefined_rules_proto3_proto_goTypes,
		DependencyIndexes: file_buf_validate_conformance_cases_predefined_rules_proto3_proto_depIdxs,
		EnumInfos:         file_buf_validate_conformance_cases_predefined_rules_proto3_proto_enumTypes,
		MessageInfos:      file_buf_validate_conformance_cases_predefined_rules_proto3_proto_msgTypes,
	}.Build()
	File_buf_validate_conformance_cases_predefined_rules_proto3_proto = out.File
	file_buf_validate_conformance_cases_predefined_rules_proto3_proto_goTypes = nil
	file_buf_validate_conformance_cases_predefined_rules_proto3_proto_depIdxs = nil
}
