// 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: tests/example/v1/validations.proto

//go:build !protoopaque

package examplev1

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"
	anypb "google.golang.org/protobuf/types/known/anypb"
	apipb "google.golang.org/protobuf/types/known/apipb"
	fieldmaskpb "google.golang.org/protobuf/types/known/fieldmaskpb"
	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
	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 HasMsgExprs struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	X             int32                  `protobuf:"varint,1,opt,name=x,proto3" json:"x,omitempty"`
	Y             int32                  `protobuf:"varint,2,opt,name=y,proto3" json:"y,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*HasMsgExprs) ProtoMessage() {}

func (x *HasMsgExprs) ProtoReflect() protoreflect.Message {
	mi := &file_tests_example_v1_validations_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 *HasMsgExprs) GetX() int32 {
	if x != nil {
		return x.X
	}
	return 0
}

func (x *HasMsgExprs) GetY() int32 {
	if x != nil {
		return x.Y
	}
	return 0
}

func (x *HasMsgExprs) SetX(v int32) {
	x.X = v
}

func (x *HasMsgExprs) SetY(v int32) {
	x.Y = v
}

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

	X int32
	Y int32
}

func (b0 HasMsgExprs_builder) Build() *HasMsgExprs {
	m0 := &HasMsgExprs{}
	b, x := &b0, m0
	_, _ = b, x
	x.X = b.X
	x.Y = b.Y
	return m0
}

type SelfRecursive struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	X             int32                  `protobuf:"varint,1,opt,name=x,proto3" json:"x,omitempty"`
	Turtle        *SelfRecursive         `protobuf:"bytes,2,opt,name=turtle,proto3" json:"turtle,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*SelfRecursive) ProtoMessage() {}

func (x *SelfRecursive) ProtoReflect() protoreflect.Message {
	mi := &file_tests_example_v1_validations_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 *SelfRecursive) GetX() int32 {
	if x != nil {
		return x.X
	}
	return 0
}

func (x *SelfRecursive) GetTurtle() *SelfRecursive {
	if x != nil {
		return x.Turtle
	}
	return nil
}

func (x *SelfRecursive) SetX(v int32) {
	x.X = v
}

func (x *SelfRecursive) SetTurtle(v *SelfRecursive) {
	x.Turtle = v
}

func (x *SelfRecursive) HasTurtle() bool {
	if x == nil {
		return false
	}
	return x.Turtle != nil
}

func (x *SelfRecursive) ClearTurtle() {
	x.Turtle = nil
}

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

	X      int32
	Turtle *SelfRecursive
}

func (b0 SelfRecursive_builder) Build() *SelfRecursive {
	m0 := &SelfRecursive{}
	b, x := &b0, m0
	_, _ = b, x
	x.X = b.X
	x.Turtle = b.Turtle
	return m0
}

type LoopRecursiveA struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	B             *LoopRecursiveB        `protobuf:"bytes,1,opt,name=b,proto3" json:"b,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*LoopRecursiveA) ProtoMessage() {}

func (x *LoopRecursiveA) ProtoReflect() protoreflect.Message {
	mi := &file_tests_example_v1_validations_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 *LoopRecursiveA) GetB() *LoopRecursiveB {
	if x != nil {
		return x.B
	}
	return nil
}

func (x *LoopRecursiveA) SetB(v *LoopRecursiveB) {
	x.B = v
}

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

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

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

	B *LoopRecursiveB
}

func (b0 LoopRecursiveA_builder) Build() *LoopRecursiveA {
	m0 := &LoopRecursiveA{}
	b, x := &b0, m0
	_, _ = b, x
	x.B = b.B
	return m0
}

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

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

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

func (*LoopRecursiveB) ProtoMessage() {}

func (x *LoopRecursiveB) ProtoReflect() protoreflect.Message {
	mi := &file_tests_example_v1_validations_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 *LoopRecursiveB) GetA() *LoopRecursiveA {
	if x != nil {
		return x.A
	}
	return nil
}

func (x *LoopRecursiveB) SetA(v *LoopRecursiveA) {
	x.A = v
}

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

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

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

	A *LoopRecursiveA
}

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

type MsgHasOneof struct {
	state protoimpl.MessageState `protogen:"hybrid.v1"`
	// Types that are valid to be assigned to O:
	//
	//	*MsgHasOneof_X
	//	*MsgHasOneof_Y
	//	*MsgHasOneof_Msg
	O             isMsgHasOneof_O `protobuf_oneof:"o"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*MsgHasOneof) ProtoMessage() {}

func (x *MsgHasOneof) ProtoReflect() protoreflect.Message {
	mi := &file_tests_example_v1_validations_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 *MsgHasOneof) GetO() isMsgHasOneof_O {
	if x != nil {
		return x.O
	}
	return nil
}

func (x *MsgHasOneof) GetX() string {
	if x != nil {
		if x, ok := x.O.(*MsgHasOneof_X); ok {
			return x.X
		}
	}
	return ""
}

func (x *MsgHasOneof) GetY() int32 {
	if x != nil {
		if x, ok := x.O.(*MsgHasOneof_Y); ok {
			return x.Y
		}
	}
	return 0
}

func (x *MsgHasOneof) GetMsg() *HasMsgExprs {
	if x != nil {
		if x, ok := x.O.(*MsgHasOneof_Msg); ok {
			return x.Msg
		}
	}
	return nil
}

func (x *MsgHasOneof) SetX(v string) {
	x.O = &MsgHasOneof_X{v}
}

func (x *MsgHasOneof) SetY(v int32) {
	x.O = &MsgHasOneof_Y{v}
}

func (x *MsgHasOneof) SetMsg(v *HasMsgExprs) {
	if v == nil {
		x.O = nil
		return
	}
	x.O = &MsgHasOneof_Msg{v}
}

func (x *MsgHasOneof) HasO() bool {
	if x == nil {
		return false
	}
	return x.O != nil
}

func (x *MsgHasOneof) HasX() bool {
	if x == nil {
		return false
	}
	_, ok := x.O.(*MsgHasOneof_X)
	return ok
}

func (x *MsgHasOneof) HasY() bool {
	if x == nil {
		return false
	}
	_, ok := x.O.(*MsgHasOneof_Y)
	return ok
}

func (x *MsgHasOneof) HasMsg() bool {
	if x == nil {
		return false
	}
	_, ok := x.O.(*MsgHasOneof_Msg)
	return ok
}

func (x *MsgHasOneof) ClearO() {
	x.O = nil
}

func (x *MsgHasOneof) ClearX() {
	if _, ok := x.O.(*MsgHasOneof_X); ok {
		x.O = nil
	}
}

func (x *MsgHasOneof) ClearY() {
	if _, ok := x.O.(*MsgHasOneof_Y); ok {
		x.O = nil
	}
}

func (x *MsgHasOneof) ClearMsg() {
	if _, ok := x.O.(*MsgHasOneof_Msg); ok {
		x.O = nil
	}
}

const MsgHasOneof_O_not_set_case case_MsgHasOneof_O = 0
const MsgHasOneof_X_case case_MsgHasOneof_O = 1
const MsgHasOneof_Y_case case_MsgHasOneof_O = 2
const MsgHasOneof_Msg_case case_MsgHasOneof_O = 3

func (x *MsgHasOneof) WhichO() case_MsgHasOneof_O {
	if x == nil {
		return MsgHasOneof_O_not_set_case
	}
	switch x.O.(type) {
	case *MsgHasOneof_X:
		return MsgHasOneof_X_case
	case *MsgHasOneof_Y:
		return MsgHasOneof_Y_case
	case *MsgHasOneof_Msg:
		return MsgHasOneof_Msg_case
	default:
		return MsgHasOneof_O_not_set_case
	}
}

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

	// Fields of oneof O:
	X   *string
	Y   *int32
	Msg *HasMsgExprs
	// -- end of O
}

func (b0 MsgHasOneof_builder) Build() *MsgHasOneof {
	m0 := &MsgHasOneof{}
	b, x := &b0, m0
	_, _ = b, x
	if b.X != nil {
		x.O = &MsgHasOneof_X{*b.X}
	}
	if b.Y != nil {
		x.O = &MsgHasOneof_Y{*b.Y}
	}
	if b.Msg != nil {
		x.O = &MsgHasOneof_Msg{b.Msg}
	}
	return m0
}

type case_MsgHasOneof_O protoreflect.FieldNumber

func (x case_MsgHasOneof_O) String() string {
	md := file_tests_example_v1_validations_proto_msgTypes[4].Descriptor()
	if x == 0 {
		return "not set"
	}
	return protoimpl.X.MessageFieldStringOf(md, protoreflect.FieldNumber(x))
}

type isMsgHasOneof_O interface {
	isMsgHasOneof_O()
}

type MsgHasOneof_X struct {
	X string `protobuf:"bytes,1,opt,name=x,proto3,oneof"`
}

type MsgHasOneof_Y struct {
	Y int32 `protobuf:"varint,2,opt,name=y,proto3,oneof"`
}

type MsgHasOneof_Msg struct {
	Msg *HasMsgExprs `protobuf:"bytes,3,opt,name=msg,proto3,oneof"`
}

func (*MsgHasOneof_X) isMsgHasOneof_O() {}

func (*MsgHasOneof_Y) isMsgHasOneof_O() {}

func (*MsgHasOneof_Msg) isMsgHasOneof_O() {}

type MsgHasRepeated struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	X             []float32              `protobuf:"fixed32,1,rep,packed,name=x,proto3" json:"x,omitempty"`
	Y             []string               `protobuf:"bytes,2,rep,name=y,proto3" json:"y,omitempty"`
	Z             []*HasMsgExprs         `protobuf:"bytes,3,rep,name=z,proto3" json:"z,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*MsgHasRepeated) ProtoMessage() {}

func (x *MsgHasRepeated) ProtoReflect() protoreflect.Message {
	mi := &file_tests_example_v1_validations_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 *MsgHasRepeated) GetX() []float32 {
	if x != nil {
		return x.X
	}
	return nil
}

func (x *MsgHasRepeated) GetY() []string {
	if x != nil {
		return x.Y
	}
	return nil
}

func (x *MsgHasRepeated) GetZ() []*HasMsgExprs {
	if x != nil {
		return x.Z
	}
	return nil
}

func (x *MsgHasRepeated) SetX(v []float32) {
	x.X = v
}

func (x *MsgHasRepeated) SetY(v []string) {
	x.Y = v
}

func (x *MsgHasRepeated) SetZ(v []*HasMsgExprs) {
	x.Z = v
}

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

	X []float32
	Y []string
	Z []*HasMsgExprs
}

func (b0 MsgHasRepeated_builder) Build() *MsgHasRepeated {
	m0 := &MsgHasRepeated{}
	b, x := &b0, m0
	_, _ = b, x
	x.X = b.X
	x.Y = b.Y
	x.Z = b.Z
	return m0
}

type MsgHasMap struct {
	state         protoimpl.MessageState    `protogen:"hybrid.v1"`
	Int32Map      map[int32]int32           `protobuf:"bytes,1,rep,name=int32map,proto3" json:"int32map,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
	StringMap     map[string]string         `protobuf:"bytes,2,rep,name=string_map,json=stringMap,proto3" json:"string_map,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	MessageMap    map[int64]*LoopRecursiveA `protobuf:"bytes,3,rep,name=message_map,json=messageMap,proto3" json:"message_map,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*MsgHasMap) ProtoMessage() {}

func (x *MsgHasMap) ProtoReflect() protoreflect.Message {
	mi := &file_tests_example_v1_validations_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 *MsgHasMap) GetInt32Map() map[int32]int32 {
	if x != nil {
		return x.Int32Map
	}
	return nil
}

func (x *MsgHasMap) GetStringMap() map[string]string {
	if x != nil {
		return x.StringMap
	}
	return nil
}

func (x *MsgHasMap) GetMessageMap() map[int64]*LoopRecursiveA {
	if x != nil {
		return x.MessageMap
	}
	return nil
}

func (x *MsgHasMap) SetInt32Map(v map[int32]int32) {
	x.Int32Map = v
}

func (x *MsgHasMap) SetStringMap(v map[string]string) {
	x.StringMap = v
}

func (x *MsgHasMap) SetMessageMap(v map[int64]*LoopRecursiveA) {
	x.MessageMap = v
}

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

	Int32Map   map[int32]int32
	StringMap  map[string]string
	MessageMap map[int64]*LoopRecursiveA
}

func (b0 MsgHasMap_builder) Build() *MsgHasMap {
	m0 := &MsgHasMap{}
	b, x := &b0, m0
	_, _ = b, x
	x.Int32Map = b.Int32Map
	x.StringMap = b.StringMap
	x.MessageMap = b.MessageMap
	return m0
}

type TransitiveFieldRule struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Mask          *fieldmaskpb.FieldMask `protobuf:"bytes,1,opt,name=mask,proto3" json:"mask,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*TransitiveFieldRule) ProtoMessage() {}

func (x *TransitiveFieldRule) ProtoReflect() protoreflect.Message {
	mi := &file_tests_example_v1_validations_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 *TransitiveFieldRule) GetMask() *fieldmaskpb.FieldMask {
	if x != nil {
		return x.Mask
	}
	return nil
}

func (x *TransitiveFieldRule) SetMask(v *fieldmaskpb.FieldMask) {
	x.Mask = v
}

func (x *TransitiveFieldRule) HasMask() bool {
	if x == nil {
		return false
	}
	return x.Mask != nil
}

func (x *TransitiveFieldRule) ClearMask() {
	x.Mask = nil
}

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

	Mask *fieldmaskpb.FieldMask
}

func (b0 TransitiveFieldRule_builder) Build() *TransitiveFieldRule {
	m0 := &TransitiveFieldRule{}
	b, x := &b0, m0
	_, _ = b, x
	x.Mask = b.Mask
	return m0
}

type MultipleStepsTransitiveFieldRules struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Api           *apipb.Api             `protobuf:"bytes,1,opt,name=api,proto3" json:"api,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*MultipleStepsTransitiveFieldRules) ProtoMessage() {}

func (x *MultipleStepsTransitiveFieldRules) ProtoReflect() protoreflect.Message {
	mi := &file_tests_example_v1_validations_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 *MultipleStepsTransitiveFieldRules) GetApi() *apipb.Api {
	if x != nil {
		return x.Api
	}
	return nil
}

func (x *MultipleStepsTransitiveFieldRules) SetApi(v *apipb.Api) {
	x.Api = v
}

func (x *MultipleStepsTransitiveFieldRules) HasApi() bool {
	if x == nil {
		return false
	}
	return x.Api != nil
}

func (x *MultipleStepsTransitiveFieldRules) ClearApi() {
	x.Api = nil
}

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

	Api *apipb.Api
}

func (b0 MultipleStepsTransitiveFieldRules_builder) Build() *MultipleStepsTransitiveFieldRules {
	m0 := &MultipleStepsTransitiveFieldRules{}
	b, x := &b0, m0
	_, _ = b, x
	x.Api = b.Api
	return m0
}

type Simple struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	S             string                 `protobuf:"bytes,1,opt,name=s,proto3" json:"s,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Simple) ProtoMessage() {}

func (x *Simple) ProtoReflect() protoreflect.Message {
	mi := &file_tests_example_v1_validations_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 *Simple) GetS() string {
	if x != nil {
		return x.S
	}
	return ""
}

func (x *Simple) SetS(v string) {
	x.S = v
}

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

	S string
}

func (b0 Simple_builder) Build() *Simple {
	m0 := &Simple{}
	b, x := &b0, m0
	_, _ = b, x
	x.S = b.S
	return m0
}

type FieldOfTypeAny struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Any           *anypb.Any             `protobuf:"bytes,1,opt,name=any,proto3" json:"any,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*FieldOfTypeAny) ProtoMessage() {}

func (x *FieldOfTypeAny) ProtoReflect() protoreflect.Message {
	mi := &file_tests_example_v1_validations_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 *FieldOfTypeAny) GetAny() *anypb.Any {
	if x != nil {
		return x.Any
	}
	return nil
}

func (x *FieldOfTypeAny) SetAny(v *anypb.Any) {
	x.Any = v
}

func (x *FieldOfTypeAny) HasAny() bool {
	if x == nil {
		return false
	}
	return x.Any != nil
}

func (x *FieldOfTypeAny) ClearAny() {
	x.Any = nil
}

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

	Any *anypb.Any
}

func (b0 FieldOfTypeAny_builder) Build() *FieldOfTypeAny {
	m0 := &FieldOfTypeAny{}
	b, x := &b0, m0
	_, _ = b, x
	x.Any = b.Any
	return m0
}

// https://github.com/bufbuild/protovalidate/issues/92
type CelMapOnARepeated struct {
	state         protoimpl.MessageState     `protogen:"hybrid.v1"`
	Values        []*CelMapOnARepeated_Value `protobuf:"bytes,1,rep,name=values,proto3" json:"values,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*CelMapOnARepeated) ProtoMessage() {}

func (x *CelMapOnARepeated) ProtoReflect() protoreflect.Message {
	mi := &file_tests_example_v1_validations_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 *CelMapOnARepeated) GetValues() []*CelMapOnARepeated_Value {
	if x != nil {
		return x.Values
	}
	return nil
}

func (x *CelMapOnARepeated) SetValues(v []*CelMapOnARepeated_Value) {
	x.Values = v
}

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

	Values []*CelMapOnARepeated_Value
}

func (b0 CelMapOnARepeated_builder) Build() *CelMapOnARepeated {
	m0 := &CelMapOnARepeated{}
	b, x := &b0, m0
	_, _ = b, x
	x.Values = b.Values
	return m0
}

type RepeatedItemCel struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Paths         []string               `protobuf:"bytes,1,rep,name=paths,proto3" json:"paths,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*RepeatedItemCel) ProtoMessage() {}

func (x *RepeatedItemCel) ProtoReflect() protoreflect.Message {
	mi := &file_tests_example_v1_validations_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 *RepeatedItemCel) GetPaths() []string {
	if x != nil {
		return x.Paths
	}
	return nil
}

func (x *RepeatedItemCel) SetPaths(v []string) {
	x.Paths = v
}

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

	Paths []string
}

func (b0 RepeatedItemCel_builder) Build() *RepeatedItemCel {
	m0 := &RepeatedItemCel{}
	b, x := &b0, m0
	_, _ = b, x
	x.Paths = b.Paths
	return m0
}

type OneTwo struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Field1        *F1                    `protobuf:"bytes,1,opt,name=field1,proto3" json:"field1,omitempty"`
	Field2        *F2                    `protobuf:"bytes,2,opt,name=field2,proto3" json:"field2,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*OneTwo) ProtoMessage() {}

func (x *OneTwo) ProtoReflect() protoreflect.Message {
	mi := &file_tests_example_v1_validations_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 *OneTwo) GetField1() *F1 {
	if x != nil {
		return x.Field1
	}
	return nil
}

func (x *OneTwo) GetField2() *F2 {
	if x != nil {
		return x.Field2
	}
	return nil
}

func (x *OneTwo) SetField1(v *F1) {
	x.Field1 = v
}

func (x *OneTwo) SetField2(v *F2) {
	x.Field2 = v
}

func (x *OneTwo) HasField1() bool {
	if x == nil {
		return false
	}
	return x.Field1 != nil
}

func (x *OneTwo) HasField2() bool {
	if x == nil {
		return false
	}
	return x.Field2 != nil
}

func (x *OneTwo) ClearField1() {
	x.Field1 = nil
}

func (x *OneTwo) ClearField2() {
	x.Field2 = nil
}

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

	Field1 *F1
	Field2 *F2
}

func (b0 OneTwo_builder) Build() *OneTwo {
	m0 := &OneTwo{}
	b, x := &b0, m0
	_, _ = b, x
	x.Field1 = b.Field1
	x.Field2 = b.Field2
	return m0
}

type TwoOne struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Field2        *F2                    `protobuf:"bytes,1,opt,name=field2,proto3" json:"field2,omitempty"`
	Field1        *F1                    `protobuf:"bytes,2,opt,name=field1,proto3" json:"field1,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*TwoOne) ProtoMessage() {}

func (x *TwoOne) ProtoReflect() protoreflect.Message {
	mi := &file_tests_example_v1_validations_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 *TwoOne) GetField2() *F2 {
	if x != nil {
		return x.Field2
	}
	return nil
}

func (x *TwoOne) GetField1() *F1 {
	if x != nil {
		return x.Field1
	}
	return nil
}

func (x *TwoOne) SetField2(v *F2) {
	x.Field2 = v
}

func (x *TwoOne) SetField1(v *F1) {
	x.Field1 = v
}

func (x *TwoOne) HasField2() bool {
	if x == nil {
		return false
	}
	return x.Field2 != nil
}

func (x *TwoOne) HasField1() bool {
	if x == nil {
		return false
	}
	return x.Field1 != nil
}

func (x *TwoOne) ClearField2() {
	x.Field2 = nil
}

func (x *TwoOne) ClearField1() {
	x.Field1 = nil
}

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

	Field2 *F2
	Field1 *F1
}

func (b0 TwoOne_builder) Build() *TwoOne {
	m0 := &TwoOne{}
	b, x := &b0, m0
	_, _ = b, x
	x.Field2 = b.Field2
	x.Field1 = b.Field1
	return m0
}

type F1 struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	NeedThis      string                 `protobuf:"bytes,1,opt,name=need_this,json=needThis,proto3" json:"need_this,omitempty"`
	Field         *FieldWithIssue        `protobuf:"bytes,2,opt,name=field,proto3" json:"field,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*F1) ProtoMessage() {}

func (x *F1) ProtoReflect() protoreflect.Message {
	mi := &file_tests_example_v1_validations_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 *F1) GetNeedThis() string {
	if x != nil {
		return x.NeedThis
	}
	return ""
}

func (x *F1) GetField() *FieldWithIssue {
	if x != nil {
		return x.Field
	}
	return nil
}

func (x *F1) SetNeedThis(v string) {
	x.NeedThis = v
}

func (x *F1) SetField(v *FieldWithIssue) {
	x.Field = v
}

func (x *F1) HasField() bool {
	if x == nil {
		return false
	}
	return x.Field != nil
}

func (x *F1) ClearField() {
	x.Field = nil
}

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

	NeedThis string
	Field    *FieldWithIssue
}

func (b0 F1_builder) Build() *F1 {
	m0 := &F1{}
	b, x := &b0, m0
	_, _ = b, x
	x.NeedThis = b.NeedThis
	x.Field = b.Field
	return m0
}

type F2 struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Field         *FieldWithIssue        `protobuf:"bytes,1,opt,name=field,proto3" json:"field,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*F2) ProtoMessage() {}

func (x *F2) ProtoReflect() protoreflect.Message {
	mi := &file_tests_example_v1_validations_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 *F2) GetField() *FieldWithIssue {
	if x != nil {
		return x.Field
	}
	return nil
}

func (x *F2) SetField(v *FieldWithIssue) {
	x.Field = v
}

func (x *F2) HasField() bool {
	if x == nil {
		return false
	}
	return x.Field != nil
}

func (x *F2) ClearField() {
	x.Field = nil
}

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

	Field *FieldWithIssue
}

func (b0 F2_builder) Build() *F2 {
	m0 := &F2{}
	b, x := &b0, m0
	_, _ = b, x
	x.Field = b.Field
	return m0
}

type FieldWithIssue struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	F1            *F1                    `protobuf:"bytes,1,opt,name=f1,proto3" json:"f1,omitempty"`
	Name          string                 `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*FieldWithIssue) ProtoMessage() {}

func (x *FieldWithIssue) ProtoReflect() protoreflect.Message {
	mi := &file_tests_example_v1_validations_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 *FieldWithIssue) GetF1() *F1 {
	if x != nil {
		return x.F1
	}
	return nil
}

func (x *FieldWithIssue) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

func (x *FieldWithIssue) SetF1(v *F1) {
	x.F1 = v
}

func (x *FieldWithIssue) SetName(v string) {
	x.Name = v
}

func (x *FieldWithIssue) HasF1() bool {
	if x == nil {
		return false
	}
	return x.F1 != nil
}

func (x *FieldWithIssue) ClearF1() {
	x.F1 = nil
}

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

	F1   *F1
	Name string
}

func (b0 FieldWithIssue_builder) Build() *FieldWithIssue {
	m0 := &FieldWithIssue{}
	b, x := &b0, m0
	_, _ = b, x
	x.F1 = b.F1
	x.Name = b.Name
	return m0
}

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

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

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

func (*Issue211) ProtoMessage() {}

func (x *Issue211) ProtoReflect() protoreflect.Message {
	mi := &file_tests_example_v1_validations_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 *Issue211) GetValue() *timestamppb.Timestamp {
	if x != nil {
		return x.Value
	}
	return nil
}

func (x *Issue211) SetValue(v *timestamppb.Timestamp) {
	x.Value = v
}

func (x *Issue211) HasValue() bool {
	if x == nil {
		return false
	}
	return x.Value != nil
}

func (x *Issue211) ClearValue() {
	x.Value = nil
}

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

	Value *timestamppb.Timestamp
}

func (b0 Issue211_builder) Build() *Issue211 {
	m0 := &Issue211{}
	b, x := &b0, m0
	_, _ = b, x
	x.Value = b.Value
	return m0
}

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

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

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

func (*CelMapOnARepeated_Value) ProtoMessage() {}

func (x *CelMapOnARepeated_Value) ProtoReflect() protoreflect.Message {
	mi := &file_tests_example_v1_validations_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 *CelMapOnARepeated_Value) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

func (x *CelMapOnARepeated_Value) SetName(v string) {
	x.Name = v
}

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

	Name string
}

func (b0 CelMapOnARepeated_Value_builder) Build() *CelMapOnARepeated_Value {
	m0 := &CelMapOnARepeated_Value{}
	b, x := &b0, m0
	_, _ = b, x
	x.Name = b.Name
	return m0
}

var File_tests_example_v1_validations_proto protoreflect.FileDescriptor

const file_tests_example_v1_validations_proto_rawDesc = "" +
	"\n" +
	"\"tests/example/v1/validations.proto\x12\x10tests.example.v1\x1a\x1bbuf/validate/validate.proto\x1a\x19google/protobuf/any.proto\x1a\x19google/protobuf/api.proto\x1a google/protobuf/field_mask.proto\x1a\x1fgoogle/protobuf/timestamp.proto\"\x8d\x02\n" +
	"\vHasMsgExprs\x12\x7f\n" +
	"\x01x\x18\x01 \x01(\x05Bq\xbaHn\xba\x01'\n" +
	"\x06x_even\x12\x0ex must be even\x1a\rthis % 2 == 0\xba\x01A\n" +
	"\vx_coprime_3\x1a2this % 3 != 0 ? '': 'x must not be divisible by 3'R\x01x\x12\f\n" +
	"\x01y\x18\x02 \x01(\x05R\x01y:o\xbaHl\x1a0\n" +
	"\x06x_lt_y\x12\x15x must be less than y\x1a\x0fthis.x < this.y\x1a8\n" +
	"\ay_gt_42\x1a-this.y > 42 ? '': 'y must be greater than 42'\"\xfe\x01\n" +
	"\rSelfRecursive\x12\f\n" +
	"\x01x\x18\x01 \x01(\x05R\x01x\x12\x8d\x01\n" +
	"\x06turtle\x18\x02 \x01(\v2\x1f.tests.example.v1.SelfRecursiveBT\xbaHQ\xba\x01N\n" +
	"\x14non_zero_baby_turtle\x12*embedded turtle's x value must not be zero\x1a\n" +
	"this.x > 0R\x06turtle:O\xbaHL\x1aJ\n" +
	"\x0eunique_turtles\x12\x1fadjacent turtles must be unique\x1a\x17this.x != this.turtle.x\"@\n" +
	"\x0eLoopRecursiveA\x12.\n" +
	"\x01b\x18\x01 \x01(\v2 .tests.example.v1.LoopRecursiveBR\x01b\"@\n" +
	"\x0eLoopRecursiveB\x12.\n" +
	"\x01a\x18\x01 \x01(\v2 .tests.example.v1.LoopRecursiveAR\x01a\"\xfb\x01\n" +
	"\vMsgHasOneof\x12\x1a\n" +
	"\x01x\x18\x01 \x01(\tB\n" +
	"\xbaH\ar\x05:\x03fooH\x00R\x01x\x12\x17\n" +
	"\x01y\x18\x02 \x01(\x05B\a\xbaH\x04\x1a\x02 \x00H\x00R\x01y\x121\n" +
	"\x03msg\x18\x03 \x01(\v2\x1d.tests.example.v1.HasMsgExprsH\x00R\x03msg:x\xbaHu\x1a\\\n" +
	"\x06test x\x1aRthis.x == '' ? '' : \n" +
	"!this.x.startsWith('foo') ? 'does not have prefix `foo`' : ''\x1a\x15\n" +
	"\x06text y\x1a\vthis.y >= 0B\n" +
	"\n" +
	"\x01o\x12\x05\xbaH\x02\b\x01\"\xa0\x01\n" +
	"\x0eMsgHasRepeated\x12?\n" +
	"\x01x\x18\x01 \x03(\x02B1\xbaH.\x92\x01+\b\x01\x10\x03\x18\x01\"#\xba\x01\x19\x12\x11intentional false\x1a\x04true\n" +
	"\x05%\x00\x00\x00\x00R\x01x\x12\x16\n" +
	"\x01y\x18\x02 \x03(\tB\b\xbaH\x05\x92\x01\x02\x18\x01R\x01y\x125\n" +
	"\x01z\x18\x03 \x03(\v2\x1d.tests.example.v1.HasMsgExprsB\b\xbaH\x05\x92\x01\x02\x10\x02R\x01z\"\xf1\x03\n" +
	"\tMsgHasMap\x12[\n" +
	"\bint32map\x18\x01 \x03(\v2).tests.example.v1.MsgHasMap.Int32mapEntryB\x14\xbaH\x11\x9a\x01\x0e\b\x03\"\x04\x1a\x02 \x00*\x04\x1a\x02\x10\x00R\bint32map\x12S\n" +
	"\n" +
	"string_map\x18\x02 \x03(\v2*.tests.example.v1.MsgHasMap.StringMapEntryB\b\xbaH\x05\x9a\x01\x02\x10\x01R\tstringMap\x12V\n" +
	"\vmessage_map\x18\x03 \x03(\v2+.tests.example.v1.MsgHasMap.MessageMapEntryB\b\xbaH\x05\x9a\x01\x02\b\x02R\n" +
	"messageMap\x1a;\n" +
	"\rInt32mapEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\x05R\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\x05R\x05value:\x028\x01\x1a<\n" +
	"\x0eStringMapEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\x1a_\n" +
	"\x0fMessageMapEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\x03R\x03key\x126\n" +
	"\x05value\x18\x02 \x01(\v2 .tests.example.v1.LoopRecursiveAR\x05value:\x028\x01\"\x88\x01\n" +
	"\x13TransitiveFieldRule\x12q\n" +
	"\x04mask\x18\x01 \x01(\v2\x1a.google.protobuf.FieldMaskBA\xbaH>\xba\x01;\n" +
	"\n" +
	"mask.paths\x12\x1cmask.paths must not be empty\x1a\x0fhas(this.paths)R\x04mask\"\xc8\x01\n" +
	"!MultipleStepsTransitiveFieldRules\x12\xa2\x01\n" +
	"\x03api\x18\x01 \x01(\v2\x14.google.protobuf.ApiBz\xbaHw\xba\x01t\n" +
	"\x1capi.source_context.file_name\x120api's source context file name must not be empty\x1a\"has(this.source_context.file_name)R\x03api\"\x16\n" +
	"\x06Simple\x12\f\n" +
	"\x01s\x18\x01 \x01(\tR\x01s\"p\n" +
	"\x0eFieldOfTypeAny\x12^\n" +
	"\x03any\x18\x01 \x01(\v2\x14.google.protobuf.AnyB6\xbaH3\xba\x010\n" +
	"\bany_type\x12\x16this should never fail\x1a\fthis == thisR\x03any\"\xcf\x01\n" +
	"\x11CelMapOnARepeated\x12\x9c\x01\n" +
	"\x06values\x18\x01 \x03(\v2).tests.example.v1.CelMapOnARepeated.ValueBY\xbaHV\xba\x01S\n" +
	"\x0fenv.vars.unique\x1a@this.map(v, v.name).unique() ? '' : 'value names must be unique'R\x06values\x1a\x1b\n" +
	"\x05Value\x12\x12\n" +
	"\x04name\x18\x01 \x01(\tR\x04name\"[\n" +
	"\x0fRepeatedItemCel\x12H\n" +
	"\x05paths\x18\x01 \x03(\tB2\xbaH/\x92\x01,\"*\xba\x01'\n" +
	"\x0epaths.no_space\x1a\x15!this.startsWith(' ')R\x05paths\"d\n" +
	"\x06OneTwo\x12,\n" +
	"\x06field1\x18\x01 \x01(\v2\x14.tests.example.v1.F1R\x06field1\x12,\n" +
	"\x06field2\x18\x02 \x01(\v2\x14.tests.example.v1.F2R\x06field2\"d\n" +
	"\x06TwoOne\x12,\n" +
	"\x06field2\x18\x01 \x01(\v2\x14.tests.example.v1.F2R\x06field2\x12,\n" +
	"\x06field1\x18\x02 \x01(\v2\x14.tests.example.v1.F1R\x06field1\"Y\n" +
	"\x02F1\x12\x1b\n" +
	"\tneed_this\x18\x01 \x01(\tR\bneedThis\x126\n" +
	"\x05field\x18\x02 \x01(\v2 .tests.example.v1.FieldWithIssueR\x05field\"<\n" +
	"\x02F2\x126\n" +
	"\x05field\x18\x01 \x01(\v2 .tests.example.v1.FieldWithIssueR\x05field\"S\n" +
	"\x0eFieldWithIssue\x12$\n" +
	"\x02f1\x18\x01 \x01(\v2\x14.tests.example.v1.F1R\x02f1\x12\x1b\n" +
	"\x04name\x18\x02 \x01(\tB\a\xbaH\x04r\x02\x10\x01R\x04name\"F\n" +
	"\bIssue211\x12:\n" +
	"\x05value\x18\x01 \x01(\v2\x1a.google.protobuf.TimestampB\b\xbaH\x05\xb2\x01\x02@\x01R\x05valueB\xce\x01\n" +
	"\x14com.tests.example.v1B\x10ValidationsProtoP\x01ZBbuf.build/go/protovalidate/internal/gen/tests/example/v1;examplev1\xa2\x02\x03TEX\xaa\x02\x10Tests.Example.V1\xca\x02\x10Tests\\Example\\V1\xe2\x02\x1cTests\\Example\\V1\\GPBMetadata\xea\x02\x12Tests::Example::V1b\x06proto3"

var file_tests_example_v1_validations_proto_msgTypes = make([]protoimpl.MessageInfo, 23)
var file_tests_example_v1_validations_proto_goTypes = []any{
	(*HasMsgExprs)(nil),                       // 0: tests.example.v1.HasMsgExprs
	(*SelfRecursive)(nil),                     // 1: tests.example.v1.SelfRecursive
	(*LoopRecursiveA)(nil),                    // 2: tests.example.v1.LoopRecursiveA
	(*LoopRecursiveB)(nil),                    // 3: tests.example.v1.LoopRecursiveB
	(*MsgHasOneof)(nil),                       // 4: tests.example.v1.MsgHasOneof
	(*MsgHasRepeated)(nil),                    // 5: tests.example.v1.MsgHasRepeated
	(*MsgHasMap)(nil),                         // 6: tests.example.v1.MsgHasMap
	(*TransitiveFieldRule)(nil),               // 7: tests.example.v1.TransitiveFieldRule
	(*MultipleStepsTransitiveFieldRules)(nil), // 8: tests.example.v1.MultipleStepsTransitiveFieldRules
	(*Simple)(nil),                            // 9: tests.example.v1.Simple
	(*FieldOfTypeAny)(nil),                    // 10: tests.example.v1.FieldOfTypeAny
	(*CelMapOnARepeated)(nil),                 // 11: tests.example.v1.CelMapOnARepeated
	(*RepeatedItemCel)(nil),                   // 12: tests.example.v1.RepeatedItemCel
	(*OneTwo)(nil),                            // 13: tests.example.v1.OneTwo
	(*TwoOne)(nil),                            // 14: tests.example.v1.TwoOne
	(*F1)(nil),                                // 15: tests.example.v1.F1
	(*F2)(nil),                                // 16: tests.example.v1.F2
	(*FieldWithIssue)(nil),                    // 17: tests.example.v1.FieldWithIssue
	(*Issue211)(nil),                          // 18: tests.example.v1.Issue211
	nil,                                       // 19: tests.example.v1.MsgHasMap.Int32mapEntry
	nil,                                       // 20: tests.example.v1.MsgHasMap.StringMapEntry
	nil,                                       // 21: tests.example.v1.MsgHasMap.MessageMapEntry
	(*CelMapOnARepeated_Value)(nil),           // 22: tests.example.v1.CelMapOnARepeated.Value
	(*fieldmaskpb.FieldMask)(nil),             // 23: google.protobuf.FieldMask
	(*apipb.Api)(nil),                         // 24: google.protobuf.Api
	(*anypb.Any)(nil),                         // 25: google.protobuf.Any
	(*timestamppb.Timestamp)(nil),             // 26: google.protobuf.Timestamp
}
var file_tests_example_v1_validations_proto_depIdxs = []int32{
	1,  // 0: tests.example.v1.SelfRecursive.turtle:type_name -> tests.example.v1.SelfRecursive
	3,  // 1: tests.example.v1.LoopRecursiveA.b:type_name -> tests.example.v1.LoopRecursiveB
	2,  // 2: tests.example.v1.LoopRecursiveB.a:type_name -> tests.example.v1.LoopRecursiveA
	0,  // 3: tests.example.v1.MsgHasOneof.msg:type_name -> tests.example.v1.HasMsgExprs
	0,  // 4: tests.example.v1.MsgHasRepeated.z:type_name -> tests.example.v1.HasMsgExprs
	19, // 5: tests.example.v1.MsgHasMap.int32map:type_name -> tests.example.v1.MsgHasMap.Int32mapEntry
	20, // 6: tests.example.v1.MsgHasMap.string_map:type_name -> tests.example.v1.MsgHasMap.StringMapEntry
	21, // 7: tests.example.v1.MsgHasMap.message_map:type_name -> tests.example.v1.MsgHasMap.MessageMapEntry
	23, // 8: tests.example.v1.TransitiveFieldRule.mask:type_name -> google.protobuf.FieldMask
	24, // 9: tests.example.v1.MultipleStepsTransitiveFieldRules.api:type_name -> google.protobuf.Api
	25, // 10: tests.example.v1.FieldOfTypeAny.any:type_name -> google.protobuf.Any
	22, // 11: tests.example.v1.CelMapOnARepeated.values:type_name -> tests.example.v1.CelMapOnARepeated.Value
	15, // 12: tests.example.v1.OneTwo.field1:type_name -> tests.example.v1.F1
	16, // 13: tests.example.v1.OneTwo.field2:type_name -> tests.example.v1.F2
	16, // 14: tests.example.v1.TwoOne.field2:type_name -> tests.example.v1.F2
	15, // 15: tests.example.v1.TwoOne.field1:type_name -> tests.example.v1.F1
	17, // 16: tests.example.v1.F1.field:type_name -> tests.example.v1.FieldWithIssue
	17, // 17: tests.example.v1.F2.field:type_name -> tests.example.v1.FieldWithIssue
	15, // 18: tests.example.v1.FieldWithIssue.f1:type_name -> tests.example.v1.F1
	26, // 19: tests.example.v1.Issue211.value:type_name -> google.protobuf.Timestamp
	2,  // 20: tests.example.v1.MsgHasMap.MessageMapEntry.value:type_name -> tests.example.v1.LoopRecursiveA
	21, // [21:21] is the sub-list for method output_type
	21, // [21:21] is the sub-list for method input_type
	21, // [21:21] is the sub-list for extension type_name
	21, // [21:21] is the sub-list for extension extendee
	0,  // [0:21] is the sub-list for field type_name
}

func init() { file_tests_example_v1_validations_proto_init() }
func file_tests_example_v1_validations_proto_init() {
	if File_tests_example_v1_validations_proto != nil {
		return
	}
	file_tests_example_v1_validations_proto_msgTypes[4].OneofWrappers = []any{
		(*MsgHasOneof_X)(nil),
		(*MsgHasOneof_Y)(nil),
		(*MsgHasOneof_Msg)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_tests_example_v1_validations_proto_rawDesc), len(file_tests_example_v1_validations_proto_rawDesc)),
			NumEnums:      0,
			NumMessages:   23,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_tests_example_v1_validations_proto_goTypes,
		DependencyIndexes: file_tests_example_v1_validations_proto_depIdxs,
		MessageInfos:      file_tests_example_v1_validations_proto_msgTypes,
	}.Build()
	File_tests_example_v1_validations_proto = out.File
	file_tests_example_v1_validations_proto_goTypes = nil
	file_tests_example_v1_validations_proto_depIdxs = nil
}
