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

//go:build !protoopaque

package cases

import (
	_ "buf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go/buf/validate"
	other_package "buf.build/go/protovalidate/internal/gen/buf/validate/conformance/cases/other_package"
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	anypb "google.golang.org/protobuf/types/known/anypb"
	durationpb "google.golang.org/protobuf/types/known/durationpb"
	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 AnEnum int32

const (
	AnEnum_AN_ENUM_UNSPECIFIED AnEnum = 0
	AnEnum_AN_ENUM_X           AnEnum = 1
	AnEnum_AN_ENUM_Y           AnEnum = 2
)

// Enum value maps for AnEnum.
var (
	AnEnum_name = map[int32]string{
		0: "AN_ENUM_UNSPECIFIED",
		1: "AN_ENUM_X",
		2: "AN_ENUM_Y",
	}
	AnEnum_value = map[string]int32{
		"AN_ENUM_UNSPECIFIED": 0,
		"AN_ENUM_X":           1,
		"AN_ENUM_Y":           2,
	}
)

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

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

func (AnEnum) Descriptor() protoreflect.EnumDescriptor {
	return file_buf_validate_conformance_cases_repeated_proto_enumTypes[0].Descriptor()
}

func (AnEnum) Type() protoreflect.EnumType {
	return &file_buf_validate_conformance_cases_repeated_proto_enumTypes[0]
}

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

type RepeatedEmbeddedEnumIn_AnotherInEnum int32

const (
	RepeatedEmbeddedEnumIn_ANOTHER_IN_ENUM_UNSPECIFIED RepeatedEmbeddedEnumIn_AnotherInEnum = 0
	RepeatedEmbeddedEnumIn_ANOTHER_IN_ENUM_A           RepeatedEmbeddedEnumIn_AnotherInEnum = 1
	RepeatedEmbeddedEnumIn_ANOTHER_IN_ENUM_B           RepeatedEmbeddedEnumIn_AnotherInEnum = 2
)

// Enum value maps for RepeatedEmbeddedEnumIn_AnotherInEnum.
var (
	RepeatedEmbeddedEnumIn_AnotherInEnum_name = map[int32]string{
		0: "ANOTHER_IN_ENUM_UNSPECIFIED",
		1: "ANOTHER_IN_ENUM_A",
		2: "ANOTHER_IN_ENUM_B",
	}
	RepeatedEmbeddedEnumIn_AnotherInEnum_value = map[string]int32{
		"ANOTHER_IN_ENUM_UNSPECIFIED": 0,
		"ANOTHER_IN_ENUM_A":           1,
		"ANOTHER_IN_ENUM_B":           2,
	}
)

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

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

func (RepeatedEmbeddedEnumIn_AnotherInEnum) Descriptor() protoreflect.EnumDescriptor {
	return file_buf_validate_conformance_cases_repeated_proto_enumTypes[1].Descriptor()
}

func (RepeatedEmbeddedEnumIn_AnotherInEnum) Type() protoreflect.EnumType {
	return &file_buf_validate_conformance_cases_repeated_proto_enumTypes[1]
}

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

type RepeatedEmbeddedEnumNotIn_AnotherNotInEnum int32

const (
	RepeatedEmbeddedEnumNotIn_ANOTHER_NOT_IN_ENUM_UNSPECIFIED RepeatedEmbeddedEnumNotIn_AnotherNotInEnum = 0
	RepeatedEmbeddedEnumNotIn_ANOTHER_NOT_IN_ENUM_A           RepeatedEmbeddedEnumNotIn_AnotherNotInEnum = 1
	RepeatedEmbeddedEnumNotIn_ANOTHER_NOT_IN_ENUM_B           RepeatedEmbeddedEnumNotIn_AnotherNotInEnum = 2
)

// Enum value maps for RepeatedEmbeddedEnumNotIn_AnotherNotInEnum.
var (
	RepeatedEmbeddedEnumNotIn_AnotherNotInEnum_name = map[int32]string{
		0: "ANOTHER_NOT_IN_ENUM_UNSPECIFIED",
		1: "ANOTHER_NOT_IN_ENUM_A",
		2: "ANOTHER_NOT_IN_ENUM_B",
	}
	RepeatedEmbeddedEnumNotIn_AnotherNotInEnum_value = map[string]int32{
		"ANOTHER_NOT_IN_ENUM_UNSPECIFIED": 0,
		"ANOTHER_NOT_IN_ENUM_A":           1,
		"ANOTHER_NOT_IN_ENUM_B":           2,
	}
)

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

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

func (RepeatedEmbeddedEnumNotIn_AnotherNotInEnum) Descriptor() protoreflect.EnumDescriptor {
	return file_buf_validate_conformance_cases_repeated_proto_enumTypes[2].Descriptor()
}

func (RepeatedEmbeddedEnumNotIn_AnotherNotInEnum) Type() protoreflect.EnumType {
	return &file_buf_validate_conformance_cases_repeated_proto_enumTypes[2]
}

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

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

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

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

func (*Embed) ProtoMessage() {}

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

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

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

	Val int64
}

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

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

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

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

func (*RepeatedNone) ProtoMessage() {}

func (x *RepeatedNone) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_repeated_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 *RepeatedNone) GetVal() []int64 {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *RepeatedNone) SetVal(v []int64) {
	x.Val = v
}

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

	Val []int64
}

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

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

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

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

func (*RepeatedEmbedNone) ProtoMessage() {}

func (x *RepeatedEmbedNone) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_repeated_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 *RepeatedEmbedNone) GetVal() []*Embed {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *RepeatedEmbedNone) SetVal(v []*Embed) {
	x.Val = v
}

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

	Val []*Embed
}

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

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

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

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

func (*RepeatedEmbedCrossPackageNone) ProtoMessage() {}

func (x *RepeatedEmbedCrossPackageNone) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_repeated_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 *RepeatedEmbedCrossPackageNone) GetVal() []*other_package.Embed {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *RepeatedEmbedCrossPackageNone) SetVal(v []*other_package.Embed) {
	x.Val = v
}

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

	Val []*other_package.Embed
}

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

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

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

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

func (*RepeatedMin) ProtoMessage() {}

func (x *RepeatedMin) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_repeated_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 *RepeatedMin) GetVal() []*Embed {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *RepeatedMin) SetVal(v []*Embed) {
	x.Val = v
}

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

	Val []*Embed
}

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

type RepeatedMax struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           []float64              `protobuf:"fixed64,1,rep,packed,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*RepeatedMax) ProtoMessage() {}

func (x *RepeatedMax) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_repeated_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 *RepeatedMax) GetVal() []float64 {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *RepeatedMax) SetVal(v []float64) {
	x.Val = v
}

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

	Val []float64
}

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

type RepeatedMinMax struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           []int32                `protobuf:"fixed32,1,rep,packed,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*RepeatedMinMax) ProtoMessage() {}

func (x *RepeatedMinMax) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_repeated_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 *RepeatedMinMax) GetVal() []int32 {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *RepeatedMinMax) SetVal(v []int32) {
	x.Val = v
}

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

	Val []int32
}

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

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

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

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

func (*RepeatedExact) ProtoMessage() {}

func (x *RepeatedExact) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_repeated_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 *RepeatedExact) GetVal() []uint32 {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *RepeatedExact) SetVal(v []uint32) {
	x.Val = v
}

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

	Val []uint32
}

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

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

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

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

func (*RepeatedUnique) ProtoMessage() {}

func (x *RepeatedUnique) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_repeated_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 *RepeatedUnique) GetVal() []string {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *RepeatedUnique) SetVal(v []string) {
	x.Val = v
}

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

	Val []string
}

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

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

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

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

func (*RepeatedNotUnique) ProtoMessage() {}

func (x *RepeatedNotUnique) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_repeated_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 *RepeatedNotUnique) GetVal() []string {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *RepeatedNotUnique) SetVal(v []string) {
	x.Val = v
}

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

	Val []string
}

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

type RepeatedMultipleUnique struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	A             []string               `protobuf:"bytes,1,rep,name=a,proto3" json:"a,omitempty"`
	B             []int32                `protobuf:"varint,2,rep,packed,name=b,proto3" json:"b,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*RepeatedMultipleUnique) ProtoMessage() {}

func (x *RepeatedMultipleUnique) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_repeated_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 *RepeatedMultipleUnique) GetA() []string {
	if x != nil {
		return x.A
	}
	return nil
}

func (x *RepeatedMultipleUnique) GetB() []int32 {
	if x != nil {
		return x.B
	}
	return nil
}

func (x *RepeatedMultipleUnique) SetA(v []string) {
	x.A = v
}

func (x *RepeatedMultipleUnique) SetB(v []int32) {
	x.B = v
}

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

	A []string
	B []int32
}

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

type RepeatedItemRule struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           []float32              `protobuf:"fixed32,1,rep,packed,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*RepeatedItemRule) ProtoMessage() {}

func (x *RepeatedItemRule) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_repeated_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 *RepeatedItemRule) GetVal() []float32 {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *RepeatedItemRule) SetVal(v []float32) {
	x.Val = v
}

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

	Val []float32
}

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

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

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

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

func (*RepeatedItemPattern) ProtoMessage() {}

func (x *RepeatedItemPattern) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_repeated_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 *RepeatedItemPattern) GetVal() []string {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *RepeatedItemPattern) SetVal(v []string) {
	x.Val = v
}

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

	Val []string
}

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

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

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

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

func (*RepeatedEmbedSkip) ProtoMessage() {}

func (x *RepeatedEmbedSkip) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_repeated_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 *RepeatedEmbedSkip) GetVal() []*Embed {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *RepeatedEmbedSkip) SetVal(v []*Embed) {
	x.Val = v
}

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

	Val []*Embed
}

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

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

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

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

func (*RepeatedItemIn) ProtoMessage() {}

func (x *RepeatedItemIn) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_repeated_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 *RepeatedItemIn) GetVal() []string {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *RepeatedItemIn) SetVal(v []string) {
	x.Val = v
}

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

	Val []string
}

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

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

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

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

func (*RepeatedItemNotIn) ProtoMessage() {}

func (x *RepeatedItemNotIn) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_repeated_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 *RepeatedItemNotIn) GetVal() []string {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *RepeatedItemNotIn) SetVal(v []string) {
	x.Val = v
}

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

	Val []string
}

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

type RepeatedEnumIn struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           []AnEnum               `protobuf:"varint,1,rep,packed,name=val,proto3,enum=buf.validate.conformance.cases.AnEnum" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*RepeatedEnumIn) ProtoMessage() {}

func (x *RepeatedEnumIn) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_repeated_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 *RepeatedEnumIn) GetVal() []AnEnum {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *RepeatedEnumIn) SetVal(v []AnEnum) {
	x.Val = v
}

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

	Val []AnEnum
}

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

type RepeatedEnumNotIn struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           []AnEnum               `protobuf:"varint,1,rep,packed,name=val,proto3,enum=buf.validate.conformance.cases.AnEnum" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*RepeatedEnumNotIn) ProtoMessage() {}

func (x *RepeatedEnumNotIn) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_repeated_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 *RepeatedEnumNotIn) GetVal() []AnEnum {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *RepeatedEnumNotIn) SetVal(v []AnEnum) {
	x.Val = v
}

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

	Val []AnEnum
}

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

type RepeatedEmbeddedEnumIn struct {
	state         protoimpl.MessageState                 `protogen:"hybrid.v1"`
	Val           []RepeatedEmbeddedEnumIn_AnotherInEnum `protobuf:"varint,1,rep,packed,name=val,proto3,enum=buf.validate.conformance.cases.RepeatedEmbeddedEnumIn_AnotherInEnum" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*RepeatedEmbeddedEnumIn) ProtoMessage() {}

func (x *RepeatedEmbeddedEnumIn) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_repeated_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 *RepeatedEmbeddedEnumIn) GetVal() []RepeatedEmbeddedEnumIn_AnotherInEnum {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *RepeatedEmbeddedEnumIn) SetVal(v []RepeatedEmbeddedEnumIn_AnotherInEnum) {
	x.Val = v
}

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

	Val []RepeatedEmbeddedEnumIn_AnotherInEnum
}

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

type RepeatedEmbeddedEnumNotIn struct {
	state         protoimpl.MessageState                       `protogen:"hybrid.v1"`
	Val           []RepeatedEmbeddedEnumNotIn_AnotherNotInEnum `protobuf:"varint,1,rep,packed,name=val,proto3,enum=buf.validate.conformance.cases.RepeatedEmbeddedEnumNotIn_AnotherNotInEnum" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*RepeatedEmbeddedEnumNotIn) ProtoMessage() {}

func (x *RepeatedEmbeddedEnumNotIn) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_repeated_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 *RepeatedEmbeddedEnumNotIn) GetVal() []RepeatedEmbeddedEnumNotIn_AnotherNotInEnum {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *RepeatedEmbeddedEnumNotIn) SetVal(v []RepeatedEmbeddedEnumNotIn_AnotherNotInEnum) {
	x.Val = v
}

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

	Val []RepeatedEmbeddedEnumNotIn_AnotherNotInEnum
}

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

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

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

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

func (*RepeatedAnyIn) ProtoMessage() {}

func (x *RepeatedAnyIn) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_repeated_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 *RepeatedAnyIn) GetVal() []*anypb.Any {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *RepeatedAnyIn) SetVal(v []*anypb.Any) {
	x.Val = v
}

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

	Val []*anypb.Any
}

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

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

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

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

func (*RepeatedAnyNotIn) ProtoMessage() {}

func (x *RepeatedAnyNotIn) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_repeated_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 *RepeatedAnyNotIn) GetVal() []*anypb.Any {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *RepeatedAnyNotIn) SetVal(v []*anypb.Any) {
	x.Val = v
}

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

	Val []*anypb.Any
}

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

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

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

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

func (*RepeatedMinAndItemLen) ProtoMessage() {}

func (x *RepeatedMinAndItemLen) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_repeated_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 *RepeatedMinAndItemLen) GetVal() []string {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *RepeatedMinAndItemLen) SetVal(v []string) {
	x.Val = v
}

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

	Val []string
}

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

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

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

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

func (*RepeatedMinAndMaxItemLen) ProtoMessage() {}

func (x *RepeatedMinAndMaxItemLen) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_repeated_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 *RepeatedMinAndMaxItemLen) GetVal() []string {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *RepeatedMinAndMaxItemLen) SetVal(v []string) {
	x.Val = v
}

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

	Val []string
}

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

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

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

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

func (*RepeatedDuration) ProtoMessage() {}

func (x *RepeatedDuration) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_repeated_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 *RepeatedDuration) GetVal() []*durationpb.Duration {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *RepeatedDuration) SetVal(v []*durationpb.Duration) {
	x.Val = v
}

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

	Val []*durationpb.Duration
}

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

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

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

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

func (*RepeatedExactIgnore) ProtoMessage() {}

func (x *RepeatedExactIgnore) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_repeated_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 *RepeatedExactIgnore) GetVal() []uint32 {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *RepeatedExactIgnore) SetVal(v []uint32) {
	x.Val = v
}

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

	Val []uint32
}

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

var File_buf_validate_conformance_cases_repeated_proto protoreflect.FileDescriptor

const file_buf_validate_conformance_cases_repeated_proto_rawDesc = "" +
	"\n" +
	"-buf/validate/conformance/cases/repeated.proto\x12\x1ebuf.validate.conformance.cases\x1a8buf/validate/conformance/cases/other_package/embed.proto\x1a\x1bbuf/validate/validate.proto\x1a\x19google/protobuf/any.proto\x1a\x1egoogle/protobuf/duration.proto\"\"\n" +
	"\x05Embed\x12\x19\n" +
	"\x03val\x18\x01 \x01(\x03B\a\xbaH\x04\"\x02 \x00R\x03val\" \n" +
	"\fRepeatedNone\x12\x10\n" +
	"\x03val\x18\x01 \x03(\x03R\x03val\"L\n" +
	"\x11RepeatedEmbedNone\x127\n" +
	"\x03val\x18\x01 \x03(\v2%.buf.validate.conformance.cases.EmbedR\x03val\"f\n" +
	"\x1dRepeatedEmbedCrossPackageNone\x12E\n" +
	"\x03val\x18\x01 \x03(\v23.buf.validate.conformance.cases.other_package.EmbedR\x03val\"P\n" +
	"\vRepeatedMin\x12A\n" +
	"\x03val\x18\x01 \x03(\v2%.buf.validate.conformance.cases.EmbedB\b\xbaH\x05\x92\x01\x02\b\x02R\x03val\")\n" +
	"\vRepeatedMax\x12\x1a\n" +
	"\x03val\x18\x01 \x03(\x01B\b\xbaH\x05\x92\x01\x02\x10\x03R\x03val\".\n" +
	"\x0eRepeatedMinMax\x12\x1c\n" +
	"\x03val\x18\x01 \x03(\x0fB\n" +
	"\xbaH\a\x92\x01\x04\b\x02\x10\x04R\x03val\"-\n" +
	"\rRepeatedExact\x12\x1c\n" +
	"\x03val\x18\x01 \x03(\rB\n" +
	"\xbaH\a\x92\x01\x04\b\x03\x10\x03R\x03val\",\n" +
	"\x0eRepeatedUnique\x12\x1a\n" +
	"\x03val\x18\x01 \x03(\tB\b\xbaH\x05\x92\x01\x02\x18\x01R\x03val\"/\n" +
	"\x11RepeatedNotUnique\x12\x1a\n" +
	"\x03val\x18\x01 \x03(\tB\b\xbaH\x05\x92\x01\x02\x18\x00R\x03val\"H\n" +
	"\x16RepeatedMultipleUnique\x12\x16\n" +
	"\x01a\x18\x01 \x03(\tB\b\xbaH\x05\x92\x01\x02\x18\x01R\x01a\x12\x16\n" +
	"\x01b\x18\x02 \x03(\x05B\b\xbaH\x05\x92\x01\x02\x18\x01R\x01b\"5\n" +
	"\x10RepeatedItemRule\x12!\n" +
	"\x03val\x18\x01 \x03(\x02B\x0f\xbaH\f\x92\x01\t\"\a\n" +
	"\x05%\x00\x00\x00\x00R\x03val\"D\n" +
	"\x13RepeatedItemPattern\x12-\n" +
	"\x03val\x18\x01 \x03(\tB\x1b\xbaH\x18\x92\x01\x15\"\x13r\x112\x0f(?i)^[a-z0-9]+$R\x03val\"Y\n" +
	"\x11RepeatedEmbedSkip\x12D\n" +
	"\x03val\x18\x01 \x03(\v2%.buf.validate.conformance.cases.EmbedB\v\xbaH\b\x92\x01\x05\"\x03\xd8\x01\x03R\x03val\"8\n" +
	"\x0eRepeatedItemIn\x12&\n" +
	"\x03val\x18\x01 \x03(\tB\x14\xbaH\x11\x92\x01\x0e\"\fr\n" +
	"R\x03fooR\x03barR\x03val\";\n" +
	"\x11RepeatedItemNotIn\x12&\n" +
	"\x03val\x18\x01 \x03(\tB\x14\xbaH\x11\x92\x01\x0e\"\fr\n" +
	"Z\x03fooZ\x03barR\x03val\"Y\n" +
	"\x0eRepeatedEnumIn\x12G\n" +
	"\x03val\x18\x01 \x03(\x0e2&.buf.validate.conformance.cases.AnEnumB\r\xbaH\n" +
	"\x92\x01\a\"\x05\x82\x01\x02\x18\x00R\x03val\"\\\n" +
	"\x11RepeatedEnumNotIn\x12G\n" +
	"\x03val\x18\x01 \x03(\x0e2&.buf.validate.conformance.cases.AnEnumB\r\xbaH\n" +
	"\x92\x01\a\"\x05\x82\x01\x02 \x00R\x03val\"\xdf\x01\n" +
	"\x16RepeatedEmbeddedEnumIn\x12e\n" +
	"\x03val\x18\x01 \x03(\x0e2D.buf.validate.conformance.cases.RepeatedEmbeddedEnumIn.AnotherInEnumB\r\xbaH\n" +
	"\x92\x01\a\"\x05\x82\x01\x02\x18\x00R\x03val\"^\n" +
	"\rAnotherInEnum\x12\x1f\n" +
	"\x1bANOTHER_IN_ENUM_UNSPECIFIED\x10\x00\x12\x15\n" +
	"\x11ANOTHER_IN_ENUM_A\x10\x01\x12\x15\n" +
	"\x11ANOTHER_IN_ENUM_B\x10\x02\"\xf7\x01\n" +
	"\x19RepeatedEmbeddedEnumNotIn\x12k\n" +
	"\x03val\x18\x01 \x03(\x0e2J.buf.validate.conformance.cases.RepeatedEmbeddedEnumNotIn.AnotherNotInEnumB\r\xbaH\n" +
	"\x92\x01\a\"\x05\x82\x01\x02 \x00R\x03val\"m\n" +
	"\x10AnotherNotInEnum\x12#\n" +
	"\x1fANOTHER_NOT_IN_ENUM_UNSPECIFIED\x10\x00\x12\x19\n" +
	"\x15ANOTHER_NOT_IN_ENUM_A\x10\x01\x12\x19\n" +
	"\x15ANOTHER_NOT_IN_ENUM_B\x10\x02\"r\n" +
	"\rRepeatedAnyIn\x12a\n" +
	"\x03val\x18\x01 \x03(\v2\x14.google.protobuf.AnyB9\xbaH6\x92\x013\"1\xa2\x01.\x12,type.googleapis.com/google.protobuf.DurationR\x03val\"v\n" +
	"\x10RepeatedAnyNotIn\x12b\n" +
	"\x03val\x18\x01 \x03(\v2\x14.google.protobuf.AnyB:\xbaH7\x92\x014\"2\xa2\x01/\x1a-type.googleapis.com/google.protobuf.TimestampR\x03val\":\n" +
	"\x15RepeatedMinAndItemLen\x12!\n" +
	"\x03val\x18\x01 \x03(\tB\x0f\xbaH\f\x92\x01\t\b\x01\"\x05r\x03\x98\x01\x03R\x03val\"8\n" +
	"\x18RepeatedMinAndMaxItemLen\x12\x1c\n" +
	"\x03val\x18\x01 \x03(\tB\n" +
	"\xbaH\a\x92\x01\x04\b\x01\x10\x03R\x03val\"R\n" +
	"\x10RepeatedDuration\x12>\n" +
	"\x03val\x18\x01 \x03(\v2\x19.google.protobuf.DurationB\x11\xbaH\x0e\x92\x01\v\"\t\xaa\x01\x062\x04\x10\xc0\x84=R\x03val\"6\n" +
	"\x13RepeatedExactIgnore\x12\x1f\n" +
	"\x03val\x18\x01 \x03(\rB\r\xbaH\n" +
	"\xd8\x01\x01\x92\x01\x04\b\x03\x10\x03R\x03val*?\n" +
	"\x06AnEnum\x12\x17\n" +
	"\x13AN_ENUM_UNSPECIFIED\x10\x00\x12\r\n" +
	"\tAN_ENUM_X\x10\x01\x12\r\n" +
	"\tAN_ENUM_Y\x10\x02B\x97\x02\n" +
	"\"com.buf.validate.conformance.casesB\rRepeatedProtoP\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_repeated_proto_enumTypes = make([]protoimpl.EnumInfo, 3)
var file_buf_validate_conformance_cases_repeated_proto_msgTypes = make([]protoimpl.MessageInfo, 26)
var file_buf_validate_conformance_cases_repeated_proto_goTypes = []any{
	(AnEnum)(0), // 0: buf.validate.conformance.cases.AnEnum
	(RepeatedEmbeddedEnumIn_AnotherInEnum)(0),       // 1: buf.validate.conformance.cases.RepeatedEmbeddedEnumIn.AnotherInEnum
	(RepeatedEmbeddedEnumNotIn_AnotherNotInEnum)(0), // 2: buf.validate.conformance.cases.RepeatedEmbeddedEnumNotIn.AnotherNotInEnum
	(*Embed)(nil),                         // 3: buf.validate.conformance.cases.Embed
	(*RepeatedNone)(nil),                  // 4: buf.validate.conformance.cases.RepeatedNone
	(*RepeatedEmbedNone)(nil),             // 5: buf.validate.conformance.cases.RepeatedEmbedNone
	(*RepeatedEmbedCrossPackageNone)(nil), // 6: buf.validate.conformance.cases.RepeatedEmbedCrossPackageNone
	(*RepeatedMin)(nil),                   // 7: buf.validate.conformance.cases.RepeatedMin
	(*RepeatedMax)(nil),                   // 8: buf.validate.conformance.cases.RepeatedMax
	(*RepeatedMinMax)(nil),                // 9: buf.validate.conformance.cases.RepeatedMinMax
	(*RepeatedExact)(nil),                 // 10: buf.validate.conformance.cases.RepeatedExact
	(*RepeatedUnique)(nil),                // 11: buf.validate.conformance.cases.RepeatedUnique
	(*RepeatedNotUnique)(nil),             // 12: buf.validate.conformance.cases.RepeatedNotUnique
	(*RepeatedMultipleUnique)(nil),        // 13: buf.validate.conformance.cases.RepeatedMultipleUnique
	(*RepeatedItemRule)(nil),              // 14: buf.validate.conformance.cases.RepeatedItemRule
	(*RepeatedItemPattern)(nil),           // 15: buf.validate.conformance.cases.RepeatedItemPattern
	(*RepeatedEmbedSkip)(nil),             // 16: buf.validate.conformance.cases.RepeatedEmbedSkip
	(*RepeatedItemIn)(nil),                // 17: buf.validate.conformance.cases.RepeatedItemIn
	(*RepeatedItemNotIn)(nil),             // 18: buf.validate.conformance.cases.RepeatedItemNotIn
	(*RepeatedEnumIn)(nil),                // 19: buf.validate.conformance.cases.RepeatedEnumIn
	(*RepeatedEnumNotIn)(nil),             // 20: buf.validate.conformance.cases.RepeatedEnumNotIn
	(*RepeatedEmbeddedEnumIn)(nil),        // 21: buf.validate.conformance.cases.RepeatedEmbeddedEnumIn
	(*RepeatedEmbeddedEnumNotIn)(nil),     // 22: buf.validate.conformance.cases.RepeatedEmbeddedEnumNotIn
	(*RepeatedAnyIn)(nil),                 // 23: buf.validate.conformance.cases.RepeatedAnyIn
	(*RepeatedAnyNotIn)(nil),              // 24: buf.validate.conformance.cases.RepeatedAnyNotIn
	(*RepeatedMinAndItemLen)(nil),         // 25: buf.validate.conformance.cases.RepeatedMinAndItemLen
	(*RepeatedMinAndMaxItemLen)(nil),      // 26: buf.validate.conformance.cases.RepeatedMinAndMaxItemLen
	(*RepeatedDuration)(nil),              // 27: buf.validate.conformance.cases.RepeatedDuration
	(*RepeatedExactIgnore)(nil),           // 28: buf.validate.conformance.cases.RepeatedExactIgnore
	(*other_package.Embed)(nil),           // 29: buf.validate.conformance.cases.other_package.Embed
	(*anypb.Any)(nil),                     // 30: google.protobuf.Any
	(*durationpb.Duration)(nil),           // 31: google.protobuf.Duration
}
var file_buf_validate_conformance_cases_repeated_proto_depIdxs = []int32{
	3,  // 0: buf.validate.conformance.cases.RepeatedEmbedNone.val:type_name -> buf.validate.conformance.cases.Embed
	29, // 1: buf.validate.conformance.cases.RepeatedEmbedCrossPackageNone.val:type_name -> buf.validate.conformance.cases.other_package.Embed
	3,  // 2: buf.validate.conformance.cases.RepeatedMin.val:type_name -> buf.validate.conformance.cases.Embed
	3,  // 3: buf.validate.conformance.cases.RepeatedEmbedSkip.val:type_name -> buf.validate.conformance.cases.Embed
	0,  // 4: buf.validate.conformance.cases.RepeatedEnumIn.val:type_name -> buf.validate.conformance.cases.AnEnum
	0,  // 5: buf.validate.conformance.cases.RepeatedEnumNotIn.val:type_name -> buf.validate.conformance.cases.AnEnum
	1,  // 6: buf.validate.conformance.cases.RepeatedEmbeddedEnumIn.val:type_name -> buf.validate.conformance.cases.RepeatedEmbeddedEnumIn.AnotherInEnum
	2,  // 7: buf.validate.conformance.cases.RepeatedEmbeddedEnumNotIn.val:type_name -> buf.validate.conformance.cases.RepeatedEmbeddedEnumNotIn.AnotherNotInEnum
	30, // 8: buf.validate.conformance.cases.RepeatedAnyIn.val:type_name -> google.protobuf.Any
	30, // 9: buf.validate.conformance.cases.RepeatedAnyNotIn.val:type_name -> google.protobuf.Any
	31, // 10: buf.validate.conformance.cases.RepeatedDuration.val:type_name -> google.protobuf.Duration
	11, // [11:11] is the sub-list for method output_type
	11, // [11:11] is the sub-list for method input_type
	11, // [11:11] is the sub-list for extension type_name
	11, // [11:11] is the sub-list for extension extendee
	0,  // [0:11] is the sub-list for field type_name
}

func init() { file_buf_validate_conformance_cases_repeated_proto_init() }
func file_buf_validate_conformance_cases_repeated_proto_init() {
	if File_buf_validate_conformance_cases_repeated_proto != nil {
		return
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_buf_validate_conformance_cases_repeated_proto_rawDesc), len(file_buf_validate_conformance_cases_repeated_proto_rawDesc)),
			NumEnums:      3,
			NumMessages:   26,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_buf_validate_conformance_cases_repeated_proto_goTypes,
		DependencyIndexes: file_buf_validate_conformance_cases_repeated_proto_depIdxs,
		EnumInfos:         file_buf_validate_conformance_cases_repeated_proto_enumTypes,
		MessageInfos:      file_buf_validate_conformance_cases_repeated_proto_msgTypes,
	}.Build()
	File_buf_validate_conformance_cases_repeated_proto = out.File
	file_buf_validate_conformance_cases_repeated_proto_goTypes = nil
	file_buf_validate_conformance_cases_repeated_proto_depIdxs = nil
}
