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

//go:build !protoopaque

package cases

import (
	_ "buf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go/buf/validate"
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	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 Proto3ScalarOptionalIgnoreUnspecified struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           *int32                 `protobuf:"varint,1,opt,name=val,proto3,oneof" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Proto3ScalarOptionalIgnoreUnspecified) ProtoMessage() {}

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

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

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

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

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

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

	Val *int32
}

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

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

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

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

func (*Proto3ScalarOptionalIgnoreEmpty) ProtoMessage() {}

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

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

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

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

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

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

	Val *int32
}

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

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

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

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

func (*Proto3ScalarOptionalIgnoreAlways) ProtoMessage() {}

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

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

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

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

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

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

	Val *int32
}

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

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

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

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

func (*Proto3ScalarIgnoreUnspecified) ProtoMessage() {}

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

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

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

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

	Val int32
}

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

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

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

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

func (*Proto3ScalarIgnoreEmpty) ProtoMessage() {}

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

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

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

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

	Val int32
}

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

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

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

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

func (*Proto3ScalarIgnoreAlways) ProtoMessage() {}

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

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

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

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

	Val int32
}

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

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

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

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

func (*Proto3MessageOptionalIgnoreUnspecified) ProtoMessage() {}

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

func (x *Proto3MessageOptionalIgnoreUnspecified) GetVal() *Proto3MessageOptionalIgnoreUnspecified_Msg {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *Proto3MessageOptionalIgnoreUnspecified) SetVal(v *Proto3MessageOptionalIgnoreUnspecified_Msg) {
	x.Val = v
}

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

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

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

	Val *Proto3MessageOptionalIgnoreUnspecified_Msg
}

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

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

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

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

func (*Proto3MessageOptionalIgnoreEmpty) ProtoMessage() {}

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

func (x *Proto3MessageOptionalIgnoreEmpty) GetVal() *Proto3MessageOptionalIgnoreEmpty_Msg {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *Proto3MessageOptionalIgnoreEmpty) SetVal(v *Proto3MessageOptionalIgnoreEmpty_Msg) {
	x.Val = v
}

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

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

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

	Val *Proto3MessageOptionalIgnoreEmpty_Msg
}

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

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

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

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

func (*Proto3MessageOptionalIgnoreAlways) ProtoMessage() {}

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

func (x *Proto3MessageOptionalIgnoreAlways) GetVal() *Proto3MessageOptionalIgnoreAlways_Msg {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *Proto3MessageOptionalIgnoreAlways) SetVal(v *Proto3MessageOptionalIgnoreAlways_Msg) {
	x.Val = v
}

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

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

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

	Val *Proto3MessageOptionalIgnoreAlways_Msg
}

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

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

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

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

func (*Proto3MessageIgnoreUnspecified) ProtoMessage() {}

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

func (x *Proto3MessageIgnoreUnspecified) GetVal() *Proto3MessageIgnoreUnspecified_Msg {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *Proto3MessageIgnoreUnspecified) SetVal(v *Proto3MessageIgnoreUnspecified_Msg) {
	x.Val = v
}

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

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

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

	Val *Proto3MessageIgnoreUnspecified_Msg
}

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

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

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

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

func (*Proto3MessageIgnoreEmpty) ProtoMessage() {}

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

func (x *Proto3MessageIgnoreEmpty) GetVal() *Proto3MessageIgnoreEmpty_Msg {
	if x != nil {
		return x.Val
	}
	return nil
}

func (x *Proto3MessageIgnoreEmpty) SetVal(v *Proto3MessageIgnoreEmpty_Msg) {
	x.Val = v
}

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

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

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

	Val *Proto3MessageIgnoreEmpty_Msg
}

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

type Proto3OneofIgnoreUnspecified struct {
	state protoimpl.MessageState `protogen:"hybrid.v1"`
	// Types that are valid to be assigned to O:
	//
	//	*Proto3OneofIgnoreUnspecified_Val
	O             isProto3OneofIgnoreUnspecified_O `protobuf_oneof:"o"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Proto3OneofIgnoreUnspecified) ProtoMessage() {}

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

func (x *Proto3OneofIgnoreUnspecified) GetO() isProto3OneofIgnoreUnspecified_O {
	if x != nil {
		return x.O
	}
	return nil
}

func (x *Proto3OneofIgnoreUnspecified) GetVal() int32 {
	if x != nil {
		if x, ok := x.O.(*Proto3OneofIgnoreUnspecified_Val); ok {
			return x.Val
		}
	}
	return 0
}

func (x *Proto3OneofIgnoreUnspecified) SetVal(v int32) {
	x.O = &Proto3OneofIgnoreUnspecified_Val{v}
}

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

func (x *Proto3OneofIgnoreUnspecified) HasVal() bool {
	if x == nil {
		return false
	}
	_, ok := x.O.(*Proto3OneofIgnoreUnspecified_Val)
	return ok
}

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

func (x *Proto3OneofIgnoreUnspecified) ClearVal() {
	if _, ok := x.O.(*Proto3OneofIgnoreUnspecified_Val); ok {
		x.O = nil
	}
}

const Proto3OneofIgnoreUnspecified_O_not_set_case case_Proto3OneofIgnoreUnspecified_O = 0
const Proto3OneofIgnoreUnspecified_Val_case case_Proto3OneofIgnoreUnspecified_O = 1

func (x *Proto3OneofIgnoreUnspecified) WhichO() case_Proto3OneofIgnoreUnspecified_O {
	if x == nil {
		return Proto3OneofIgnoreUnspecified_O_not_set_case
	}
	switch x.O.(type) {
	case *Proto3OneofIgnoreUnspecified_Val:
		return Proto3OneofIgnoreUnspecified_Val_case
	default:
		return Proto3OneofIgnoreUnspecified_O_not_set_case
	}
}

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

	// Fields of oneof O:
	Val *int32
	// -- end of O
}

func (b0 Proto3OneofIgnoreUnspecified_builder) Build() *Proto3OneofIgnoreUnspecified {
	m0 := &Proto3OneofIgnoreUnspecified{}
	b, x := &b0, m0
	_, _ = b, x
	if b.Val != nil {
		x.O = &Proto3OneofIgnoreUnspecified_Val{*b.Val}
	}
	return m0
}

type case_Proto3OneofIgnoreUnspecified_O protoreflect.FieldNumber

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

type isProto3OneofIgnoreUnspecified_O interface {
	isProto3OneofIgnoreUnspecified_O()
}

type Proto3OneofIgnoreUnspecified_Val struct {
	Val int32 `protobuf:"varint,1,opt,name=val,proto3,oneof"`
}

func (*Proto3OneofIgnoreUnspecified_Val) isProto3OneofIgnoreUnspecified_O() {}

type Proto3OneofIgnoreEmpty struct {
	state protoimpl.MessageState `protogen:"hybrid.v1"`
	// Types that are valid to be assigned to O:
	//
	//	*Proto3OneofIgnoreEmpty_Val
	O             isProto3OneofIgnoreEmpty_O `protobuf_oneof:"o"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Proto3OneofIgnoreEmpty) ProtoMessage() {}

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

func (x *Proto3OneofIgnoreEmpty) GetO() isProto3OneofIgnoreEmpty_O {
	if x != nil {
		return x.O
	}
	return nil
}

func (x *Proto3OneofIgnoreEmpty) GetVal() int32 {
	if x != nil {
		if x, ok := x.O.(*Proto3OneofIgnoreEmpty_Val); ok {
			return x.Val
		}
	}
	return 0
}

func (x *Proto3OneofIgnoreEmpty) SetVal(v int32) {
	x.O = &Proto3OneofIgnoreEmpty_Val{v}
}

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

func (x *Proto3OneofIgnoreEmpty) HasVal() bool {
	if x == nil {
		return false
	}
	_, ok := x.O.(*Proto3OneofIgnoreEmpty_Val)
	return ok
}

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

func (x *Proto3OneofIgnoreEmpty) ClearVal() {
	if _, ok := x.O.(*Proto3OneofIgnoreEmpty_Val); ok {
		x.O = nil
	}
}

const Proto3OneofIgnoreEmpty_O_not_set_case case_Proto3OneofIgnoreEmpty_O = 0
const Proto3OneofIgnoreEmpty_Val_case case_Proto3OneofIgnoreEmpty_O = 1

func (x *Proto3OneofIgnoreEmpty) WhichO() case_Proto3OneofIgnoreEmpty_O {
	if x == nil {
		return Proto3OneofIgnoreEmpty_O_not_set_case
	}
	switch x.O.(type) {
	case *Proto3OneofIgnoreEmpty_Val:
		return Proto3OneofIgnoreEmpty_Val_case
	default:
		return Proto3OneofIgnoreEmpty_O_not_set_case
	}
}

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

	// Fields of oneof O:
	Val *int32
	// -- end of O
}

func (b0 Proto3OneofIgnoreEmpty_builder) Build() *Proto3OneofIgnoreEmpty {
	m0 := &Proto3OneofIgnoreEmpty{}
	b, x := &b0, m0
	_, _ = b, x
	if b.Val != nil {
		x.O = &Proto3OneofIgnoreEmpty_Val{*b.Val}
	}
	return m0
}

type case_Proto3OneofIgnoreEmpty_O protoreflect.FieldNumber

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

type isProto3OneofIgnoreEmpty_O interface {
	isProto3OneofIgnoreEmpty_O()
}

type Proto3OneofIgnoreEmpty_Val struct {
	Val int32 `protobuf:"varint,1,opt,name=val,proto3,oneof"`
}

func (*Proto3OneofIgnoreEmpty_Val) isProto3OneofIgnoreEmpty_O() {}

type Proto3OneofIgnoreAlways struct {
	state protoimpl.MessageState `protogen:"hybrid.v1"`
	// Types that are valid to be assigned to O:
	//
	//	*Proto3OneofIgnoreAlways_Val
	O             isProto3OneofIgnoreAlways_O `protobuf_oneof:"o"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Proto3OneofIgnoreAlways) ProtoMessage() {}

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

func (x *Proto3OneofIgnoreAlways) GetO() isProto3OneofIgnoreAlways_O {
	if x != nil {
		return x.O
	}
	return nil
}

func (x *Proto3OneofIgnoreAlways) GetVal() int32 {
	if x != nil {
		if x, ok := x.O.(*Proto3OneofIgnoreAlways_Val); ok {
			return x.Val
		}
	}
	return 0
}

func (x *Proto3OneofIgnoreAlways) SetVal(v int32) {
	x.O = &Proto3OneofIgnoreAlways_Val{v}
}

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

func (x *Proto3OneofIgnoreAlways) HasVal() bool {
	if x == nil {
		return false
	}
	_, ok := x.O.(*Proto3OneofIgnoreAlways_Val)
	return ok
}

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

func (x *Proto3OneofIgnoreAlways) ClearVal() {
	if _, ok := x.O.(*Proto3OneofIgnoreAlways_Val); ok {
		x.O = nil
	}
}

const Proto3OneofIgnoreAlways_O_not_set_case case_Proto3OneofIgnoreAlways_O = 0
const Proto3OneofIgnoreAlways_Val_case case_Proto3OneofIgnoreAlways_O = 1

func (x *Proto3OneofIgnoreAlways) WhichO() case_Proto3OneofIgnoreAlways_O {
	if x == nil {
		return Proto3OneofIgnoreAlways_O_not_set_case
	}
	switch x.O.(type) {
	case *Proto3OneofIgnoreAlways_Val:
		return Proto3OneofIgnoreAlways_Val_case
	default:
		return Proto3OneofIgnoreAlways_O_not_set_case
	}
}

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

	// Fields of oneof O:
	Val *int32
	// -- end of O
}

func (b0 Proto3OneofIgnoreAlways_builder) Build() *Proto3OneofIgnoreAlways {
	m0 := &Proto3OneofIgnoreAlways{}
	b, x := &b0, m0
	_, _ = b, x
	if b.Val != nil {
		x.O = &Proto3OneofIgnoreAlways_Val{*b.Val}
	}
	return m0
}

type case_Proto3OneofIgnoreAlways_O protoreflect.FieldNumber

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

type isProto3OneofIgnoreAlways_O interface {
	isProto3OneofIgnoreAlways_O()
}

type Proto3OneofIgnoreAlways_Val struct {
	Val int32 `protobuf:"varint,1,opt,name=val,proto3,oneof"`
}

func (*Proto3OneofIgnoreAlways_Val) isProto3OneofIgnoreAlways_O() {}

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

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

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

func (*Proto3RepeatedIgnoreUnspecified) ProtoMessage() {}

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

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

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

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

	Val []int32
}

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

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

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

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

func (*Proto3RepeatedIgnoreEmpty) ProtoMessage() {}

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

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

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

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

	Val []int32
}

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

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

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

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

func (*Proto3RepeatedIgnoreAlways) ProtoMessage() {}

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

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

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

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

	Val []int32
}

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

type Proto3MapIgnoreUnspecified struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           map[int32]int32        `protobuf:"bytes,1,rep,name=val,proto3" json:"val,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Proto3MapIgnoreUnspecified) ProtoMessage() {}

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

func (x *Proto3MapIgnoreUnspecified) GetVal() map[int32]int32 {
	if x != nil {
		return x.Val
	}
	return nil
}

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

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

	Val map[int32]int32
}

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

type Proto3MapIgnoreEmpty struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           map[int32]int32        `protobuf:"bytes,1,rep,name=val,proto3" json:"val,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Proto3MapIgnoreEmpty) ProtoMessage() {}

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

func (x *Proto3MapIgnoreEmpty) GetVal() map[int32]int32 {
	if x != nil {
		return x.Val
	}
	return nil
}

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

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

	Val map[int32]int32
}

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

type Proto3MapIgnoreAlways struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           map[int32]int32        `protobuf:"bytes,1,rep,name=val,proto3" json:"val,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Proto3MapIgnoreAlways) ProtoMessage() {}

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

func (x *Proto3MapIgnoreAlways) GetVal() map[int32]int32 {
	if x != nil {
		return x.Val
	}
	return nil
}

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

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

	Val map[int32]int32
}

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

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

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

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

func (*Proto3RepeatedItemIgnoreUnspecified) ProtoMessage() {}

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

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

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

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

	Val []int32
}

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

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

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

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

func (*Proto3RepeatedItemIgnoreEmpty) ProtoMessage() {}

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

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

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

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

	Val []int32
}

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

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

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

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

func (*Proto3RepeatedItemIgnoreAlways) ProtoMessage() {}

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

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

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

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

	Val []int32
}

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

type Proto3MapKeyIgnoreUnspecified struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           map[int32]int32        `protobuf:"bytes,1,rep,name=val,proto3" json:"val,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Proto3MapKeyIgnoreUnspecified) ProtoMessage() {}

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

func (x *Proto3MapKeyIgnoreUnspecified) GetVal() map[int32]int32 {
	if x != nil {
		return x.Val
	}
	return nil
}

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

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

	Val map[int32]int32
}

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

type Proto3MapKeyIgnoreEmpty struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           map[int32]int32        `protobuf:"bytes,1,rep,name=val,proto3" json:"val,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Proto3MapKeyIgnoreEmpty) ProtoMessage() {}

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

func (x *Proto3MapKeyIgnoreEmpty) GetVal() map[int32]int32 {
	if x != nil {
		return x.Val
	}
	return nil
}

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

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

	Val map[int32]int32
}

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

type Proto3MapKeyIgnoreAlways struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           map[int32]int32        `protobuf:"bytes,1,rep,name=val,proto3" json:"val,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Proto3MapKeyIgnoreAlways) ProtoMessage() {}

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

func (x *Proto3MapKeyIgnoreAlways) GetVal() map[int32]int32 {
	if x != nil {
		return x.Val
	}
	return nil
}

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

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

	Val map[int32]int32
}

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

type Proto3MapValueIgnoreUnspecified struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           map[int32]int32        `protobuf:"bytes,1,rep,name=val,proto3" json:"val,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Proto3MapValueIgnoreUnspecified) ProtoMessage() {}

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

func (x *Proto3MapValueIgnoreUnspecified) GetVal() map[int32]int32 {
	if x != nil {
		return x.Val
	}
	return nil
}

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

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

	Val map[int32]int32
}

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

type Proto3MapValueIgnoreEmpty struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           map[int32]int32        `protobuf:"bytes,1,rep,name=val,proto3" json:"val,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Proto3MapValueIgnoreEmpty) ProtoMessage() {}

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

func (x *Proto3MapValueIgnoreEmpty) GetVal() map[int32]int32 {
	if x != nil {
		return x.Val
	}
	return nil
}

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

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

	Val map[int32]int32
}

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

type Proto3MapValueIgnoreAlways struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           map[int32]int32        `protobuf:"bytes,1,rep,name=val,proto3" json:"val,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Proto3MapValueIgnoreAlways) ProtoMessage() {}

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

func (x *Proto3MapValueIgnoreAlways) GetVal() map[int32]int32 {
	if x != nil {
		return x.Val
	}
	return nil
}

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

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

	Val map[int32]int32
}

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

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

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

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

func (*Proto3MessageOptionalIgnoreUnspecified_Msg) ProtoMessage() {}

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

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

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

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

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

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

	Val *string
}

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

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

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

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

func (*Proto3MessageOptionalIgnoreEmpty_Msg) ProtoMessage() {}

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

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

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

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

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

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

	Val *string
}

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

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

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

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

func (*Proto3MessageOptionalIgnoreAlways_Msg) ProtoMessage() {}

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

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

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

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

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

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

	Val *string
}

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

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

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

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

func (*Proto3MessageIgnoreUnspecified_Msg) ProtoMessage() {}

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

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

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

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

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

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

	Val *string
}

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

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

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

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

func (*Proto3MessageIgnoreEmpty_Msg) ProtoMessage() {}

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

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

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

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

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

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

	Val *string
}

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

var File_buf_validate_conformance_cases_ignore_proto3_proto protoreflect.FileDescriptor

const file_buf_validate_conformance_cases_ignore_proto3_proto_rawDesc = "" +
	"\n" +
	"2buf/validate/conformance/cases/ignore_proto3.proto\x12\x1ebuf.validate.conformance.cases\x1a\x1bbuf/validate/validate.proto\"O\n" +
	"%Proto3ScalarOptionalIgnoreUnspecified\x12\x1e\n" +
	"\x03val\x18\x01 \x01(\x05B\a\xbaH\x04\x1a\x02 \x00H\x00R\x03val\x88\x01\x01B\x06\n" +
	"\x04_val\"L\n" +
	"\x1fProto3ScalarOptionalIgnoreEmpty\x12!\n" +
	"\x03val\x18\x01 \x01(\x05B\n" +
	"\xbaH\a\xd8\x01\x01\x1a\x02 \x00H\x00R\x03val\x88\x01\x01B\x06\n" +
	"\x04_val\"M\n" +
	" Proto3ScalarOptionalIgnoreAlways\x12!\n" +
	"\x03val\x18\x01 \x01(\x05B\n" +
	"\xbaH\a\xd8\x01\x03\x1a\x02 \x00H\x00R\x03val\x88\x01\x01B\x06\n" +
	"\x04_val\":\n" +
	"\x1dProto3ScalarIgnoreUnspecified\x12\x19\n" +
	"\x03val\x18\x01 \x01(\x05B\a\xbaH\x04\x1a\x02 \x00R\x03val\"7\n" +
	"\x17Proto3ScalarIgnoreEmpty\x12\x1c\n" +
	"\x03val\x18\x01 \x01(\x05B\n" +
	"\xbaH\a\xd8\x01\x01\x1a\x02 \x00R\x03val\"8\n" +
	"\x18Proto3ScalarIgnoreAlways\x12\x1c\n" +
	"\x03val\x18\x01 \x01(\x05B\n" +
	"\xbaH\a\xd8\x01\x03\x1a\x02 \x00R\x03val\"\xfa\x01\n" +
	"&Proto3MessageOptionalIgnoreUnspecified\x12\xa1\x01\n" +
	"\x03val\x18\x01 \x01(\v2J.buf.validate.conformance.cases.Proto3MessageOptionalIgnoreUnspecified.MsgB>\xbaH;\xba\x018\n" +
	"\x1bproto3.message.ignore.empty\x12\x06foobar\x1a\x11this.val == 'foo'H\x00R\x03val\x88\x01\x01\x1a$\n" +
	"\x03Msg\x12\x15\n" +
	"\x03val\x18\x01 \x01(\tH\x00R\x03val\x88\x01\x01B\x06\n" +
	"\x04_valB\x06\n" +
	"\x04_val\"\xf1\x01\n" +
	" Proto3MessageOptionalIgnoreEmpty\x12\x9e\x01\n" +
	"\x03val\x18\x01 \x01(\v2D.buf.validate.conformance.cases.Proto3MessageOptionalIgnoreEmpty.MsgBA\xbaH>\xba\x018\n" +
	"\x1bproto3.message.ignore.empty\x12\x06foobar\x1a\x11this.val == 'foo'\xd8\x01\x01H\x00R\x03val\x88\x01\x01\x1a$\n" +
	"\x03Msg\x12\x15\n" +
	"\x03val\x18\x01 \x01(\tH\x00R\x03val\x88\x01\x01B\x06\n" +
	"\x04_valB\x06\n" +
	"\x04_val\"\xf4\x01\n" +
	"!Proto3MessageOptionalIgnoreAlways\x12\xa0\x01\n" +
	"\x03val\x18\x01 \x01(\v2E.buf.validate.conformance.cases.Proto3MessageOptionalIgnoreAlways.MsgBB\xbaH?\xba\x019\n" +
	"\x1cproto3.message.ignore.always\x12\x06foobar\x1a\x11this.val == 'foo'\xd8\x01\x03H\x00R\x03val\x88\x01\x01\x1a$\n" +
	"\x03Msg\x12\x15\n" +
	"\x03val\x18\x01 \x01(\tH\x00R\x03val\x88\x01\x01B\x06\n" +
	"\x04_valB\x06\n" +
	"\x04_val\"\xdd\x01\n" +
	"\x1eProto3MessageIgnoreUnspecified\x12\x94\x01\n" +
	"\x03val\x18\x01 \x01(\v2B.buf.validate.conformance.cases.Proto3MessageIgnoreUnspecified.MsgB>\xbaH;\xba\x018\n" +
	"\x1bproto3.message.ignore.empty\x12\x06foobar\x1a\x11this.val == 'foo'R\x03val\x1a$\n" +
	"\x03Msg\x12\x15\n" +
	"\x03val\x18\x01 \x01(\tH\x00R\x03val\x88\x01\x01B\x06\n" +
	"\x04_val\"\xd4\x01\n" +
	"\x18Proto3MessageIgnoreEmpty\x12\x91\x01\n" +
	"\x03val\x18\x01 \x01(\v2<.buf.validate.conformance.cases.Proto3MessageIgnoreEmpty.MsgBA\xbaH>\xba\x018\n" +
	"\x1bproto3.message.ignore.empty\x12\x06foobar\x1a\x11this.val == 'foo'\xd8\x01\x01R\x03val\x1a$\n" +
	"\x03Msg\x12\x15\n" +
	"\x03val\x18\x01 \x01(\tH\x00R\x03val\x88\x01\x01B\x06\n" +
	"\x04_val\"@\n" +
	"\x1cProto3OneofIgnoreUnspecified\x12\x1b\n" +
	"\x03val\x18\x01 \x01(\x05B\a\xbaH\x04\x1a\x02 \x00H\x00R\x03valB\x03\n" +
	"\x01o\"=\n" +
	"\x16Proto3OneofIgnoreEmpty\x12\x1e\n" +
	"\x03val\x18\x01 \x01(\x05B\n" +
	"\xbaH\a\xd8\x01\x01\x1a\x02 \x00H\x00R\x03valB\x03\n" +
	"\x01o\">\n" +
	"\x17Proto3OneofIgnoreAlways\x12\x1e\n" +
	"\x03val\x18\x01 \x01(\x05B\n" +
	"\xbaH\a\xd8\x01\x03\x1a\x02 \x00H\x00R\x03valB\x03\n" +
	"\x01o\"=\n" +
	"\x1fProto3RepeatedIgnoreUnspecified\x12\x1a\n" +
	"\x03val\x18\x01 \x03(\x05B\b\xbaH\x05\x92\x01\x02\b\x03R\x03val\":\n" +
	"\x19Proto3RepeatedIgnoreEmpty\x12\x1d\n" +
	"\x03val\x18\x01 \x03(\x05B\v\xbaH\b\xd8\x01\x01\x92\x01\x02\b\x03R\x03val\";\n" +
	"\x1aProto3RepeatedIgnoreAlways\x12\x1d\n" +
	"\x03val\x18\x01 \x03(\x05B\v\xbaH\b\xd8\x01\x03\x92\x01\x02\b\x03R\x03val\"\xb5\x01\n" +
	"\x1aProto3MapIgnoreUnspecified\x12_\n" +
	"\x03val\x18\x01 \x03(\v2C.buf.validate.conformance.cases.Proto3MapIgnoreUnspecified.ValEntryB\b\xbaH\x05\x9a\x01\x02\b\x03R\x03val\x1a6\n" +
	"\bValEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\x05R\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\x05R\x05value:\x028\x01\"\xac\x01\n" +
	"\x14Proto3MapIgnoreEmpty\x12\\\n" +
	"\x03val\x18\x01 \x03(\v2=.buf.validate.conformance.cases.Proto3MapIgnoreEmpty.ValEntryB\v\xbaH\b\xd8\x01\x01\x9a\x01\x02\b\x03R\x03val\x1a6\n" +
	"\bValEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\x05R\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\x05R\x05value:\x028\x01\"\xae\x01\n" +
	"\x15Proto3MapIgnoreAlways\x12]\n" +
	"\x03val\x18\x01 \x03(\v2>.buf.validate.conformance.cases.Proto3MapIgnoreAlways.ValEntryB\v\xbaH\b\xd8\x01\x03\x9a\x01\x02\b\x03R\x03val\x1a6\n" +
	"\bValEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\x05R\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\x05R\x05value:\x028\x01\"E\n" +
	"#Proto3RepeatedItemIgnoreUnspecified\x12\x1e\n" +
	"\x03val\x18\x01 \x03(\x05B\f\xbaH\t\x92\x01\x06\"\x04\x1a\x02 \x00R\x03val\"B\n" +
	"\x1dProto3RepeatedItemIgnoreEmpty\x12!\n" +
	"\x03val\x18\x01 \x03(\x05B\x0f\xbaH\f\x92\x01\t\"\a\xd8\x01\x01\x1a\x02 \x00R\x03val\"C\n" +
	"\x1eProto3RepeatedItemIgnoreAlways\x12!\n" +
	"\x03val\x18\x01 \x03(\x05B\x0f\xbaH\f\x92\x01\t\"\a\xd8\x01\x03\x1a\x02 \x00R\x03val\"\xbf\x01\n" +
	"\x1dProto3MapKeyIgnoreUnspecified\x12f\n" +
	"\x03val\x18\x01 \x03(\v2F.buf.validate.conformance.cases.Proto3MapKeyIgnoreUnspecified.ValEntryB\f\xbaH\t\x9a\x01\x06\"\x04\x1a\x02 \x00R\x03val\x1a6\n" +
	"\bValEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\x05R\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\x05R\x05value:\x028\x01\"\xb6\x01\n" +
	"\x17Proto3MapKeyIgnoreEmpty\x12c\n" +
	"\x03val\x18\x01 \x03(\v2@.buf.validate.conformance.cases.Proto3MapKeyIgnoreEmpty.ValEntryB\x0f\xbaH\f\x9a\x01\t\"\a\xd8\x01\x01\x1a\x02 \x00R\x03val\x1a6\n" +
	"\bValEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\x05R\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\x05R\x05value:\x028\x01\"\xb8\x01\n" +
	"\x18Proto3MapKeyIgnoreAlways\x12d\n" +
	"\x03val\x18\x01 \x03(\v2A.buf.validate.conformance.cases.Proto3MapKeyIgnoreAlways.ValEntryB\x0f\xbaH\f\x9a\x01\t\"\a\xd8\x01\x03\x1a\x02 \x00R\x03val\x1a6\n" +
	"\bValEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\x05R\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\x05R\x05value:\x028\x01\"\xc3\x01\n" +
	"\x1fProto3MapValueIgnoreUnspecified\x12h\n" +
	"\x03val\x18\x01 \x03(\v2H.buf.validate.conformance.cases.Proto3MapValueIgnoreUnspecified.ValEntryB\f\xbaH\t\x9a\x01\x06*\x04\x1a\x02 \x00R\x03val\x1a6\n" +
	"\bValEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\x05R\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\x05R\x05value:\x028\x01\"\xba\x01\n" +
	"\x19Proto3MapValueIgnoreEmpty\x12e\n" +
	"\x03val\x18\x01 \x03(\v2B.buf.validate.conformance.cases.Proto3MapValueIgnoreEmpty.ValEntryB\x0f\xbaH\f\x9a\x01\t*\a\xd8\x01\x01\x1a\x02 \x00R\x03val\x1a6\n" +
	"\bValEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\x05R\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\x05R\x05value:\x028\x01\"\xbc\x01\n" +
	"\x1aProto3MapValueIgnoreAlways\x12f\n" +
	"\x03val\x18\x01 \x03(\v2C.buf.validate.conformance.cases.Proto3MapValueIgnoreAlways.ValEntryB\x0f\xbaH\f\x9a\x01\t*\a\xd8\x01\x03\x1a\x02 \x00R\x03val\x1a6\n" +
	"\bValEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\x05R\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\x05R\x05value:\x028\x01B\x9b\x02\n" +
	"\"com.buf.validate.conformance.casesB\x11IgnoreProto3ProtoP\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_ignore_proto3_proto_msgTypes = make([]protoimpl.MessageInfo, 43)
var file_buf_validate_conformance_cases_ignore_proto3_proto_goTypes = []any{
	(*Proto3ScalarOptionalIgnoreUnspecified)(nil),      // 0: buf.validate.conformance.cases.Proto3ScalarOptionalIgnoreUnspecified
	(*Proto3ScalarOptionalIgnoreEmpty)(nil),            // 1: buf.validate.conformance.cases.Proto3ScalarOptionalIgnoreEmpty
	(*Proto3ScalarOptionalIgnoreAlways)(nil),           // 2: buf.validate.conformance.cases.Proto3ScalarOptionalIgnoreAlways
	(*Proto3ScalarIgnoreUnspecified)(nil),              // 3: buf.validate.conformance.cases.Proto3ScalarIgnoreUnspecified
	(*Proto3ScalarIgnoreEmpty)(nil),                    // 4: buf.validate.conformance.cases.Proto3ScalarIgnoreEmpty
	(*Proto3ScalarIgnoreAlways)(nil),                   // 5: buf.validate.conformance.cases.Proto3ScalarIgnoreAlways
	(*Proto3MessageOptionalIgnoreUnspecified)(nil),     // 6: buf.validate.conformance.cases.Proto3MessageOptionalIgnoreUnspecified
	(*Proto3MessageOptionalIgnoreEmpty)(nil),           // 7: buf.validate.conformance.cases.Proto3MessageOptionalIgnoreEmpty
	(*Proto3MessageOptionalIgnoreAlways)(nil),          // 8: buf.validate.conformance.cases.Proto3MessageOptionalIgnoreAlways
	(*Proto3MessageIgnoreUnspecified)(nil),             // 9: buf.validate.conformance.cases.Proto3MessageIgnoreUnspecified
	(*Proto3MessageIgnoreEmpty)(nil),                   // 10: buf.validate.conformance.cases.Proto3MessageIgnoreEmpty
	(*Proto3OneofIgnoreUnspecified)(nil),               // 11: buf.validate.conformance.cases.Proto3OneofIgnoreUnspecified
	(*Proto3OneofIgnoreEmpty)(nil),                     // 12: buf.validate.conformance.cases.Proto3OneofIgnoreEmpty
	(*Proto3OneofIgnoreAlways)(nil),                    // 13: buf.validate.conformance.cases.Proto3OneofIgnoreAlways
	(*Proto3RepeatedIgnoreUnspecified)(nil),            // 14: buf.validate.conformance.cases.Proto3RepeatedIgnoreUnspecified
	(*Proto3RepeatedIgnoreEmpty)(nil),                  // 15: buf.validate.conformance.cases.Proto3RepeatedIgnoreEmpty
	(*Proto3RepeatedIgnoreAlways)(nil),                 // 16: buf.validate.conformance.cases.Proto3RepeatedIgnoreAlways
	(*Proto3MapIgnoreUnspecified)(nil),                 // 17: buf.validate.conformance.cases.Proto3MapIgnoreUnspecified
	(*Proto3MapIgnoreEmpty)(nil),                       // 18: buf.validate.conformance.cases.Proto3MapIgnoreEmpty
	(*Proto3MapIgnoreAlways)(nil),                      // 19: buf.validate.conformance.cases.Proto3MapIgnoreAlways
	(*Proto3RepeatedItemIgnoreUnspecified)(nil),        // 20: buf.validate.conformance.cases.Proto3RepeatedItemIgnoreUnspecified
	(*Proto3RepeatedItemIgnoreEmpty)(nil),              // 21: buf.validate.conformance.cases.Proto3RepeatedItemIgnoreEmpty
	(*Proto3RepeatedItemIgnoreAlways)(nil),             // 22: buf.validate.conformance.cases.Proto3RepeatedItemIgnoreAlways
	(*Proto3MapKeyIgnoreUnspecified)(nil),              // 23: buf.validate.conformance.cases.Proto3MapKeyIgnoreUnspecified
	(*Proto3MapKeyIgnoreEmpty)(nil),                    // 24: buf.validate.conformance.cases.Proto3MapKeyIgnoreEmpty
	(*Proto3MapKeyIgnoreAlways)(nil),                   // 25: buf.validate.conformance.cases.Proto3MapKeyIgnoreAlways
	(*Proto3MapValueIgnoreUnspecified)(nil),            // 26: buf.validate.conformance.cases.Proto3MapValueIgnoreUnspecified
	(*Proto3MapValueIgnoreEmpty)(nil),                  // 27: buf.validate.conformance.cases.Proto3MapValueIgnoreEmpty
	(*Proto3MapValueIgnoreAlways)(nil),                 // 28: buf.validate.conformance.cases.Proto3MapValueIgnoreAlways
	(*Proto3MessageOptionalIgnoreUnspecified_Msg)(nil), // 29: buf.validate.conformance.cases.Proto3MessageOptionalIgnoreUnspecified.Msg
	(*Proto3MessageOptionalIgnoreEmpty_Msg)(nil),       // 30: buf.validate.conformance.cases.Proto3MessageOptionalIgnoreEmpty.Msg
	(*Proto3MessageOptionalIgnoreAlways_Msg)(nil),      // 31: buf.validate.conformance.cases.Proto3MessageOptionalIgnoreAlways.Msg
	(*Proto3MessageIgnoreUnspecified_Msg)(nil),         // 32: buf.validate.conformance.cases.Proto3MessageIgnoreUnspecified.Msg
	(*Proto3MessageIgnoreEmpty_Msg)(nil),               // 33: buf.validate.conformance.cases.Proto3MessageIgnoreEmpty.Msg
	nil,                                                // 34: buf.validate.conformance.cases.Proto3MapIgnoreUnspecified.ValEntry
	nil,                                                // 35: buf.validate.conformance.cases.Proto3MapIgnoreEmpty.ValEntry
	nil,                                                // 36: buf.validate.conformance.cases.Proto3MapIgnoreAlways.ValEntry
	nil,                                                // 37: buf.validate.conformance.cases.Proto3MapKeyIgnoreUnspecified.ValEntry
	nil,                                                // 38: buf.validate.conformance.cases.Proto3MapKeyIgnoreEmpty.ValEntry
	nil,                                                // 39: buf.validate.conformance.cases.Proto3MapKeyIgnoreAlways.ValEntry
	nil,                                                // 40: buf.validate.conformance.cases.Proto3MapValueIgnoreUnspecified.ValEntry
	nil,                                                // 41: buf.validate.conformance.cases.Proto3MapValueIgnoreEmpty.ValEntry
	nil,                                                // 42: buf.validate.conformance.cases.Proto3MapValueIgnoreAlways.ValEntry
}
var file_buf_validate_conformance_cases_ignore_proto3_proto_depIdxs = []int32{
	29, // 0: buf.validate.conformance.cases.Proto3MessageOptionalIgnoreUnspecified.val:type_name -> buf.validate.conformance.cases.Proto3MessageOptionalIgnoreUnspecified.Msg
	30, // 1: buf.validate.conformance.cases.Proto3MessageOptionalIgnoreEmpty.val:type_name -> buf.validate.conformance.cases.Proto3MessageOptionalIgnoreEmpty.Msg
	31, // 2: buf.validate.conformance.cases.Proto3MessageOptionalIgnoreAlways.val:type_name -> buf.validate.conformance.cases.Proto3MessageOptionalIgnoreAlways.Msg
	32, // 3: buf.validate.conformance.cases.Proto3MessageIgnoreUnspecified.val:type_name -> buf.validate.conformance.cases.Proto3MessageIgnoreUnspecified.Msg
	33, // 4: buf.validate.conformance.cases.Proto3MessageIgnoreEmpty.val:type_name -> buf.validate.conformance.cases.Proto3MessageIgnoreEmpty.Msg
	34, // 5: buf.validate.conformance.cases.Proto3MapIgnoreUnspecified.val:type_name -> buf.validate.conformance.cases.Proto3MapIgnoreUnspecified.ValEntry
	35, // 6: buf.validate.conformance.cases.Proto3MapIgnoreEmpty.val:type_name -> buf.validate.conformance.cases.Proto3MapIgnoreEmpty.ValEntry
	36, // 7: buf.validate.conformance.cases.Proto3MapIgnoreAlways.val:type_name -> buf.validate.conformance.cases.Proto3MapIgnoreAlways.ValEntry
	37, // 8: buf.validate.conformance.cases.Proto3MapKeyIgnoreUnspecified.val:type_name -> buf.validate.conformance.cases.Proto3MapKeyIgnoreUnspecified.ValEntry
	38, // 9: buf.validate.conformance.cases.Proto3MapKeyIgnoreEmpty.val:type_name -> buf.validate.conformance.cases.Proto3MapKeyIgnoreEmpty.ValEntry
	39, // 10: buf.validate.conformance.cases.Proto3MapKeyIgnoreAlways.val:type_name -> buf.validate.conformance.cases.Proto3MapKeyIgnoreAlways.ValEntry
	40, // 11: buf.validate.conformance.cases.Proto3MapValueIgnoreUnspecified.val:type_name -> buf.validate.conformance.cases.Proto3MapValueIgnoreUnspecified.ValEntry
	41, // 12: buf.validate.conformance.cases.Proto3MapValueIgnoreEmpty.val:type_name -> buf.validate.conformance.cases.Proto3MapValueIgnoreEmpty.ValEntry
	42, // 13: buf.validate.conformance.cases.Proto3MapValueIgnoreAlways.val:type_name -> buf.validate.conformance.cases.Proto3MapValueIgnoreAlways.ValEntry
	14, // [14:14] is the sub-list for method output_type
	14, // [14:14] is the sub-list for method input_type
	14, // [14:14] is the sub-list for extension type_name
	14, // [14:14] is the sub-list for extension extendee
	0,  // [0:14] is the sub-list for field type_name
}

func init() { file_buf_validate_conformance_cases_ignore_proto3_proto_init() }
func file_buf_validate_conformance_cases_ignore_proto3_proto_init() {
	if File_buf_validate_conformance_cases_ignore_proto3_proto != nil {
		return
	}
	file_buf_validate_conformance_cases_ignore_proto3_proto_msgTypes[0].OneofWrappers = []any{}
	file_buf_validate_conformance_cases_ignore_proto3_proto_msgTypes[1].OneofWrappers = []any{}
	file_buf_validate_conformance_cases_ignore_proto3_proto_msgTypes[2].OneofWrappers = []any{}
	file_buf_validate_conformance_cases_ignore_proto3_proto_msgTypes[6].OneofWrappers = []any{}
	file_buf_validate_conformance_cases_ignore_proto3_proto_msgTypes[7].OneofWrappers = []any{}
	file_buf_validate_conformance_cases_ignore_proto3_proto_msgTypes[8].OneofWrappers = []any{}
	file_buf_validate_conformance_cases_ignore_proto3_proto_msgTypes[11].OneofWrappers = []any{
		(*Proto3OneofIgnoreUnspecified_Val)(nil),
	}
	file_buf_validate_conformance_cases_ignore_proto3_proto_msgTypes[12].OneofWrappers = []any{
		(*Proto3OneofIgnoreEmpty_Val)(nil),
	}
	file_buf_validate_conformance_cases_ignore_proto3_proto_msgTypes[13].OneofWrappers = []any{
		(*Proto3OneofIgnoreAlways_Val)(nil),
	}
	file_buf_validate_conformance_cases_ignore_proto3_proto_msgTypes[29].OneofWrappers = []any{}
	file_buf_validate_conformance_cases_ignore_proto3_proto_msgTypes[30].OneofWrappers = []any{}
	file_buf_validate_conformance_cases_ignore_proto3_proto_msgTypes[31].OneofWrappers = []any{}
	file_buf_validate_conformance_cases_ignore_proto3_proto_msgTypes[32].OneofWrappers = []any{}
	file_buf_validate_conformance_cases_ignore_proto3_proto_msgTypes[33].OneofWrappers = []any{}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_buf_validate_conformance_cases_ignore_proto3_proto_rawDesc), len(file_buf_validate_conformance_cases_ignore_proto3_proto_rawDesc)),
			NumEnums:      0,
			NumMessages:   43,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_buf_validate_conformance_cases_ignore_proto3_proto_goTypes,
		DependencyIndexes: file_buf_validate_conformance_cases_ignore_proto3_proto_depIdxs,
		MessageInfos:      file_buf_validate_conformance_cases_ignore_proto3_proto_msgTypes,
	}.Build()
	File_buf_validate_conformance_cases_ignore_proto3_proto = out.File
	file_buf_validate_conformance_cases_ignore_proto3_proto_goTypes = nil
	file_buf_validate_conformance_cases_ignore_proto3_proto_depIdxs = nil
}
