// 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/numbers.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 FloatNone struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           float32                `protobuf:"fixed32,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*FloatNone) ProtoMessage() {}

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

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

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

	Val float32
}

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

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

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

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

func (*FloatConst) ProtoMessage() {}

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

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

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

	Val float32
}

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

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

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

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

func (*FloatIn) ProtoMessage() {}

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

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

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

	Val float32
}

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

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

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

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

func (*FloatNotIn) ProtoMessage() {}

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

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

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

	Val float32
}

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

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

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

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

func (*FloatLT) ProtoMessage() {}

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

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

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

	Val float32
}

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

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

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

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

func (*FloatLTE) ProtoMessage() {}

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

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

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

	Val float32
}

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

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

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

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

func (*FloatGT) ProtoMessage() {}

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

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

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

	Val float32
}

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

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

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

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

func (*FloatGTE) ProtoMessage() {}

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

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

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

	Val float32
}

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

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

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

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

func (*FloatGTLT) ProtoMessage() {}

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

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

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

	Val float32
}

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

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

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

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

func (*FloatExLTGT) ProtoMessage() {}

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

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

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

	Val float32
}

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

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

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

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

func (*FloatGTELTE) ProtoMessage() {}

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

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

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

	Val float32
}

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

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

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

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

func (*FloatExGTELTE) ProtoMessage() {}

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

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

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

	Val float32
}

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

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

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

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

func (*FloatFinite) ProtoMessage() {}

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

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

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

	Val float32
}

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

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

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

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

func (*FloatNotFinite) ProtoMessage() {}

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

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

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

	Val float32
}

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

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

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

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

func (*FloatIgnore) ProtoMessage() {}

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

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

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

	Val float32
}

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

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

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

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

func (*FloatIncorrectType) ProtoMessage() {}

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

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

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

	Val float32
}

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

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

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

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

func (*FloatExample) ProtoMessage() {}

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

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

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

	Val float32
}

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

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

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

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

func (*DoubleNone) ProtoMessage() {}

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

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

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

	Val float64
}

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

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

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

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

func (*DoubleConst) ProtoMessage() {}

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

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

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

	Val float64
}

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

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

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

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

func (*DoubleIn) ProtoMessage() {}

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

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

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

	Val float64
}

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

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

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

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

func (*DoubleNotIn) ProtoMessage() {}

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

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

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

	Val float64
}

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

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

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

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

func (*DoubleLT) ProtoMessage() {}

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

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

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

	Val float64
}

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

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

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

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

func (*DoubleLTE) ProtoMessage() {}

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

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

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

	Val float64
}

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

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

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

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

func (*DoubleGT) ProtoMessage() {}

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

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

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

	Val float64
}

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

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

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

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

func (*DoubleGTE) ProtoMessage() {}

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

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

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

	Val float64
}

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

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

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

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

func (*DoubleGTLT) ProtoMessage() {}

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

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

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

	Val float64
}

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

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

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

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

func (*DoubleExLTGT) ProtoMessage() {}

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

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

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

	Val float64
}

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

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

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

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

func (*DoubleGTELTE) ProtoMessage() {}

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

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

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

	Val float64
}

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

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

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

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

func (*DoubleExGTELTE) ProtoMessage() {}

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

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

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

	Val float64
}

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

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

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

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

func (*DoubleFinite) ProtoMessage() {}

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

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

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

	Val float64
}

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

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

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

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

func (*DoubleNotFinite) ProtoMessage() {}

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

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

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

	Val float64
}

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

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

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

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

func (*DoubleIgnore) ProtoMessage() {}

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

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

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

	Val float64
}

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

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

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

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

func (*DoubleIncorrectType) ProtoMessage() {}

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

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

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

	Val float64
}

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

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

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

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

func (*DoubleExample) ProtoMessage() {}

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

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

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

	Val float64
}

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

type Int32None 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 *Int32None) Reset() {
	*x = Int32None{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[34]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Int32None) ProtoMessage() {}

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

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

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

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

	Val int32
}

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

type Int32Const 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 *Int32Const) Reset() {
	*x = Int32Const{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[35]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Int32Const) ProtoMessage() {}

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

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

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

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

	Val int32
}

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

type Int32In 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 *Int32In) Reset() {
	*x = Int32In{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[36]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Int32In) ProtoMessage() {}

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

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

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

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

	Val int32
}

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

type Int32NotIn 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 *Int32NotIn) Reset() {
	*x = Int32NotIn{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[37]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Int32NotIn) ProtoMessage() {}

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

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

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

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

	Val int32
}

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

type Int32LT 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 *Int32LT) Reset() {
	*x = Int32LT{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[38]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Int32LT) ProtoMessage() {}

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

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

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

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

	Val int32
}

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

type Int32LTE 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 *Int32LTE) Reset() {
	*x = Int32LTE{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[39]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Int32LTE) ProtoMessage() {}

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

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

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

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

	Val int32
}

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

type Int32GT 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 *Int32GT) Reset() {
	*x = Int32GT{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[40]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Int32GT) ProtoMessage() {}

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

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

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

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

	Val int32
}

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

type Int32GTE 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 *Int32GTE) Reset() {
	*x = Int32GTE{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[41]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Int32GTE) ProtoMessage() {}

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

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

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

	Val int32
}

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

type Int32GTLT 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 *Int32GTLT) Reset() {
	*x = Int32GTLT{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[42]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Int32GTLT) ProtoMessage() {}

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

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

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

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

	Val int32
}

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

type Int32ExLTGT 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 *Int32ExLTGT) Reset() {
	*x = Int32ExLTGT{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[43]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Int32ExLTGT) ProtoMessage() {}

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

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

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

	Val int32
}

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

type Int32GTELTE 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 *Int32GTELTE) Reset() {
	*x = Int32GTELTE{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[44]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Int32GTELTE) ProtoMessage() {}

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

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

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

	Val int32
}

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

type Int32ExGTELTE 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 *Int32ExGTELTE) Reset() {
	*x = Int32ExGTELTE{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[45]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Int32ExGTELTE) ProtoMessage() {}

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

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

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

	Val int32
}

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

type Int32Ignore 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 *Int32Ignore) Reset() {
	*x = Int32Ignore{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[46]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Int32Ignore) ProtoMessage() {}

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

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

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

	Val int32
}

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

type Int32IncorrectType 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 *Int32IncorrectType) Reset() {
	*x = Int32IncorrectType{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[47]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Int32IncorrectType) ProtoMessage() {}

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

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

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

	Val int32
}

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

type Int32Example 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 *Int32Example) Reset() {
	*x = Int32Example{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[48]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Int32Example) ProtoMessage() {}

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

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

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

	Val int32
}

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

type Int64None 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 *Int64None) Reset() {
	*x = Int64None{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[49]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Int64None) ProtoMessage() {}

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

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

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

	Val int64
}

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

type Int64Const 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 *Int64Const) Reset() {
	*x = Int64Const{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[50]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Int64Const) ProtoMessage() {}

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

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

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

	Val int64
}

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

type Int64In 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 *Int64In) Reset() {
	*x = Int64In{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[51]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Int64In) ProtoMessage() {}

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

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

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

	Val int64
}

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

type Int64NotIn 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 *Int64NotIn) Reset() {
	*x = Int64NotIn{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[52]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Int64NotIn) ProtoMessage() {}

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

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

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

	Val int64
}

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

type Int64LT 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 *Int64LT) Reset() {
	*x = Int64LT{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[53]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Int64LT) ProtoMessage() {}

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

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

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

	Val int64
}

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

type Int64LTE 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 *Int64LTE) Reset() {
	*x = Int64LTE{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[54]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Int64LTE) ProtoMessage() {}

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

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

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

	Val int64
}

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

type Int64GT 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 *Int64GT) Reset() {
	*x = Int64GT{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[55]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Int64GT) ProtoMessage() {}

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

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

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

	Val int64
}

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

type Int64GTE 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 *Int64GTE) Reset() {
	*x = Int64GTE{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[56]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Int64GTE) ProtoMessage() {}

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

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

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

	Val int64
}

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

type Int64GTLT 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 *Int64GTLT) Reset() {
	*x = Int64GTLT{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[57]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Int64GTLT) ProtoMessage() {}

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

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

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

	Val int64
}

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

type Int64ExLTGT 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 *Int64ExLTGT) Reset() {
	*x = Int64ExLTGT{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[58]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Int64ExLTGT) ProtoMessage() {}

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

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

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

	Val int64
}

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

type Int64GTELTE 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 *Int64GTELTE) Reset() {
	*x = Int64GTELTE{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[59]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Int64GTELTE) ProtoMessage() {}

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

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

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

	Val int64
}

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

type Int64ExGTELTE 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 *Int64ExGTELTE) Reset() {
	*x = Int64ExGTELTE{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[60]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Int64ExGTELTE) ProtoMessage() {}

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

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

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

	Val int64
}

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

type Int64Ignore 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 *Int64Ignore) Reset() {
	*x = Int64Ignore{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[61]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Int64Ignore) ProtoMessage() {}

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

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

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

	Val int64
}

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

type Int64BigRules struct {
	state protoimpl.MessageState `protogen:"hybrid.v1"`
	// Intentionally choose limits that are outside the range of both signed and unsigned 32-bit integers.
	LtPos         int64 `protobuf:"varint,1,opt,name=lt_pos,json=ltPos,proto3" json:"lt_pos,omitempty"`
	LtNeg         int64 `protobuf:"varint,2,opt,name=lt_neg,json=ltNeg,proto3" json:"lt_neg,omitempty"`
	GtPos         int64 `protobuf:"varint,3,opt,name=gt_pos,json=gtPos,proto3" json:"gt_pos,omitempty"`
	GtNeg         int64 `protobuf:"varint,4,opt,name=gt_neg,json=gtNeg,proto3" json:"gt_neg,omitempty"`
	LtePos        int64 `protobuf:"varint,5,opt,name=lte_pos,json=ltePos,proto3" json:"lte_pos,omitempty"`
	LteNeg        int64 `protobuf:"varint,6,opt,name=lte_neg,json=lteNeg,proto3" json:"lte_neg,omitempty"`
	GtePos        int64 `protobuf:"varint,7,opt,name=gte_pos,json=gtePos,proto3" json:"gte_pos,omitempty"`
	GteNeg        int64 `protobuf:"varint,8,opt,name=gte_neg,json=gteNeg,proto3" json:"gte_neg,omitempty"`
	ConstantPos   int64 `protobuf:"varint,9,opt,name=constant_pos,json=constantPos,proto3" json:"constant_pos,omitempty"`
	ConstantNeg   int64 `protobuf:"varint,10,opt,name=constant_neg,json=constantNeg,proto3" json:"constant_neg,omitempty"`
	In            int64 `protobuf:"varint,11,opt,name=in,proto3" json:"in,omitempty"`
	Notin         int64 `protobuf:"varint,12,opt,name=notin,proto3" json:"notin,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Int64BigRules) Reset() {
	*x = Int64BigRules{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[62]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Int64BigRules) ProtoMessage() {}

func (x *Int64BigRules) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[62]
	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 *Int64BigRules) GetLtPos() int64 {
	if x != nil {
		return x.LtPos
	}
	return 0
}

func (x *Int64BigRules) GetLtNeg() int64 {
	if x != nil {
		return x.LtNeg
	}
	return 0
}

func (x *Int64BigRules) GetGtPos() int64 {
	if x != nil {
		return x.GtPos
	}
	return 0
}

func (x *Int64BigRules) GetGtNeg() int64 {
	if x != nil {
		return x.GtNeg
	}
	return 0
}

func (x *Int64BigRules) GetLtePos() int64 {
	if x != nil {
		return x.LtePos
	}
	return 0
}

func (x *Int64BigRules) GetLteNeg() int64 {
	if x != nil {
		return x.LteNeg
	}
	return 0
}

func (x *Int64BigRules) GetGtePos() int64 {
	if x != nil {
		return x.GtePos
	}
	return 0
}

func (x *Int64BigRules) GetGteNeg() int64 {
	if x != nil {
		return x.GteNeg
	}
	return 0
}

func (x *Int64BigRules) GetConstantPos() int64 {
	if x != nil {
		return x.ConstantPos
	}
	return 0
}

func (x *Int64BigRules) GetConstantNeg() int64 {
	if x != nil {
		return x.ConstantNeg
	}
	return 0
}

func (x *Int64BigRules) GetIn() int64 {
	if x != nil {
		return x.In
	}
	return 0
}

func (x *Int64BigRules) GetNotin() int64 {
	if x != nil {
		return x.Notin
	}
	return 0
}

func (x *Int64BigRules) SetLtPos(v int64) {
	x.LtPos = v
}

func (x *Int64BigRules) SetLtNeg(v int64) {
	x.LtNeg = v
}

func (x *Int64BigRules) SetGtPos(v int64) {
	x.GtPos = v
}

func (x *Int64BigRules) SetGtNeg(v int64) {
	x.GtNeg = v
}

func (x *Int64BigRules) SetLtePos(v int64) {
	x.LtePos = v
}

func (x *Int64BigRules) SetLteNeg(v int64) {
	x.LteNeg = v
}

func (x *Int64BigRules) SetGtePos(v int64) {
	x.GtePos = v
}

func (x *Int64BigRules) SetGteNeg(v int64) {
	x.GteNeg = v
}

func (x *Int64BigRules) SetConstantPos(v int64) {
	x.ConstantPos = v
}

func (x *Int64BigRules) SetConstantNeg(v int64) {
	x.ConstantNeg = v
}

func (x *Int64BigRules) SetIn(v int64) {
	x.In = v
}

func (x *Int64BigRules) SetNotin(v int64) {
	x.Notin = v
}

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

	// Intentionally choose limits that are outside the range of both signed and unsigned 32-bit integers.
	LtPos       int64
	LtNeg       int64
	GtPos       int64
	GtNeg       int64
	LtePos      int64
	LteNeg      int64
	GtePos      int64
	GteNeg      int64
	ConstantPos int64
	ConstantNeg int64
	In          int64
	Notin       int64
}

func (b0 Int64BigRules_builder) Build() *Int64BigRules {
	m0 := &Int64BigRules{}
	b, x := &b0, m0
	_, _ = b, x
	x.LtPos = b.LtPos
	x.LtNeg = b.LtNeg
	x.GtPos = b.GtPos
	x.GtNeg = b.GtNeg
	x.LtePos = b.LtePos
	x.LteNeg = b.LteNeg
	x.GtePos = b.GtePos
	x.GteNeg = b.GteNeg
	x.ConstantPos = b.ConstantPos
	x.ConstantNeg = b.ConstantNeg
	x.In = b.In
	x.Notin = b.Notin
	return m0
}

type Int64IncorrectType 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 *Int64IncorrectType) Reset() {
	*x = Int64IncorrectType{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[63]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Int64IncorrectType) ProtoMessage() {}

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

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

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

	Val int64
}

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

type Int64Example 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 *Int64Example) Reset() {
	*x = Int64Example{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[64]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Int64Example) ProtoMessage() {}

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

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

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

	Val int64
}

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

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

func (x *UInt32None) Reset() {
	*x = UInt32None{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[65]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*UInt32None) ProtoMessage() {}

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

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

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

	Val uint32
}

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

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

func (x *UInt32Const) Reset() {
	*x = UInt32Const{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[66]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*UInt32Const) ProtoMessage() {}

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

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

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

	Val uint32
}

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

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

func (x *UInt32In) Reset() {
	*x = UInt32In{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[67]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*UInt32In) ProtoMessage() {}

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

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

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

	Val uint32
}

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

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

func (x *UInt32NotIn) Reset() {
	*x = UInt32NotIn{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[68]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*UInt32NotIn) ProtoMessage() {}

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

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

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

	Val uint32
}

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

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

func (x *UInt32LT) Reset() {
	*x = UInt32LT{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[69]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*UInt32LT) ProtoMessage() {}

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

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

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

	Val uint32
}

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

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

func (x *UInt32LTE) Reset() {
	*x = UInt32LTE{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[70]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*UInt32LTE) ProtoMessage() {}

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

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

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

	Val uint32
}

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

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

func (x *UInt32GT) Reset() {
	*x = UInt32GT{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[71]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*UInt32GT) ProtoMessage() {}

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

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

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

	Val uint32
}

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

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

func (x *UInt32GTE) Reset() {
	*x = UInt32GTE{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[72]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*UInt32GTE) ProtoMessage() {}

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

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

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

	Val uint32
}

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

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

func (x *UInt32GTLT) Reset() {
	*x = UInt32GTLT{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[73]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*UInt32GTLT) ProtoMessage() {}

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

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

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

	Val uint32
}

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

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

func (x *UInt32ExLTGT) Reset() {
	*x = UInt32ExLTGT{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[74]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*UInt32ExLTGT) ProtoMessage() {}

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

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

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

	Val uint32
}

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

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

func (x *UInt32GTELTE) Reset() {
	*x = UInt32GTELTE{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[75]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*UInt32GTELTE) ProtoMessage() {}

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

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

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

	Val uint32
}

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

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

func (x *UInt32ExGTELTE) Reset() {
	*x = UInt32ExGTELTE{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[76]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*UInt32ExGTELTE) ProtoMessage() {}

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

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

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

	Val uint32
}

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

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

func (x *UInt32Ignore) Reset() {
	*x = UInt32Ignore{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[77]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*UInt32Ignore) ProtoMessage() {}

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

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

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

	Val uint32
}

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

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

func (x *UInt32IncorrectType) Reset() {
	*x = UInt32IncorrectType{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[78]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*UInt32IncorrectType) ProtoMessage() {}

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

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

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

	Val uint32
}

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

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

func (x *UInt32Example) Reset() {
	*x = UInt32Example{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[79]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*UInt32Example) ProtoMessage() {}

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

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

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

	Val uint32
}

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

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

func (x *UInt64None) Reset() {
	*x = UInt64None{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[80]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*UInt64None) ProtoMessage() {}

func (x *UInt64None) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[80]
	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 *UInt64None) GetVal() uint64 {
	if x != nil {
		return x.Val
	}
	return 0
}

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

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

	Val uint64
}

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

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

func (x *UInt64Const) Reset() {
	*x = UInt64Const{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[81]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*UInt64Const) ProtoMessage() {}

func (x *UInt64Const) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[81]
	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 *UInt64Const) GetVal() uint64 {
	if x != nil {
		return x.Val
	}
	return 0
}

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

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

	Val uint64
}

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

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

func (x *UInt64In) Reset() {
	*x = UInt64In{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[82]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*UInt64In) ProtoMessage() {}

func (x *UInt64In) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[82]
	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 *UInt64In) GetVal() uint64 {
	if x != nil {
		return x.Val
	}
	return 0
}

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

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

	Val uint64
}

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

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

func (x *UInt64NotIn) Reset() {
	*x = UInt64NotIn{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[83]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*UInt64NotIn) ProtoMessage() {}

func (x *UInt64NotIn) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[83]
	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 *UInt64NotIn) GetVal() uint64 {
	if x != nil {
		return x.Val
	}
	return 0
}

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

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

	Val uint64
}

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

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

func (x *UInt64LT) Reset() {
	*x = UInt64LT{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[84]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*UInt64LT) ProtoMessage() {}

func (x *UInt64LT) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[84]
	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 *UInt64LT) GetVal() uint64 {
	if x != nil {
		return x.Val
	}
	return 0
}

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

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

	Val uint64
}

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

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

func (x *UInt64LTE) Reset() {
	*x = UInt64LTE{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[85]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*UInt64LTE) ProtoMessage() {}

func (x *UInt64LTE) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[85]
	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 *UInt64LTE) GetVal() uint64 {
	if x != nil {
		return x.Val
	}
	return 0
}

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

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

	Val uint64
}

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

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

func (x *UInt64GT) Reset() {
	*x = UInt64GT{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[86]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*UInt64GT) ProtoMessage() {}

func (x *UInt64GT) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[86]
	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 *UInt64GT) GetVal() uint64 {
	if x != nil {
		return x.Val
	}
	return 0
}

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

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

	Val uint64
}

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

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

func (x *UInt64GTE) Reset() {
	*x = UInt64GTE{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[87]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*UInt64GTE) ProtoMessage() {}

func (x *UInt64GTE) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[87]
	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 *UInt64GTE) GetVal() uint64 {
	if x != nil {
		return x.Val
	}
	return 0
}

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

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

	Val uint64
}

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

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

func (x *UInt64GTLT) Reset() {
	*x = UInt64GTLT{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[88]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*UInt64GTLT) ProtoMessage() {}

func (x *UInt64GTLT) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[88]
	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 *UInt64GTLT) GetVal() uint64 {
	if x != nil {
		return x.Val
	}
	return 0
}

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

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

	Val uint64
}

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

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

func (x *UInt64ExLTGT) Reset() {
	*x = UInt64ExLTGT{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[89]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*UInt64ExLTGT) ProtoMessage() {}

func (x *UInt64ExLTGT) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[89]
	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 *UInt64ExLTGT) GetVal() uint64 {
	if x != nil {
		return x.Val
	}
	return 0
}

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

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

	Val uint64
}

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

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

func (x *UInt64GTELTE) Reset() {
	*x = UInt64GTELTE{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[90]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*UInt64GTELTE) ProtoMessage() {}

func (x *UInt64GTELTE) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[90]
	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 *UInt64GTELTE) GetVal() uint64 {
	if x != nil {
		return x.Val
	}
	return 0
}

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

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

	Val uint64
}

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

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

func (x *UInt64ExGTELTE) Reset() {
	*x = UInt64ExGTELTE{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[91]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*UInt64ExGTELTE) ProtoMessage() {}

func (x *UInt64ExGTELTE) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[91]
	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 *UInt64ExGTELTE) GetVal() uint64 {
	if x != nil {
		return x.Val
	}
	return 0
}

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

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

	Val uint64
}

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

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

func (x *UInt64Ignore) Reset() {
	*x = UInt64Ignore{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[92]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*UInt64Ignore) ProtoMessage() {}

func (x *UInt64Ignore) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[92]
	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 *UInt64Ignore) GetVal() uint64 {
	if x != nil {
		return x.Val
	}
	return 0
}

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

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

	Val uint64
}

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

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

func (x *UInt64IncorrectType) Reset() {
	*x = UInt64IncorrectType{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[93]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*UInt64IncorrectType) ProtoMessage() {}

func (x *UInt64IncorrectType) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[93]
	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 *UInt64IncorrectType) GetVal() uint64 {
	if x != nil {
		return x.Val
	}
	return 0
}

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

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

	Val uint64
}

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

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

func (x *UInt64Example) Reset() {
	*x = UInt64Example{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[94]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*UInt64Example) ProtoMessage() {}

func (x *UInt64Example) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[94]
	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 *UInt64Example) GetVal() uint64 {
	if x != nil {
		return x.Val
	}
	return 0
}

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

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

	Val uint64
}

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

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

func (x *SInt32None) Reset() {
	*x = SInt32None{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[95]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SInt32None) ProtoMessage() {}

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

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

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

	Val int32
}

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

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

func (x *SInt32Const) Reset() {
	*x = SInt32Const{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[96]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SInt32Const) ProtoMessage() {}

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

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

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

	Val int32
}

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

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

func (x *SInt32In) Reset() {
	*x = SInt32In{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[97]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SInt32In) ProtoMessage() {}

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

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

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

	Val int32
}

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

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

func (x *SInt32NotIn) Reset() {
	*x = SInt32NotIn{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[98]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SInt32NotIn) ProtoMessage() {}

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

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

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

	Val int32
}

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

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

func (x *SInt32LT) Reset() {
	*x = SInt32LT{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[99]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SInt32LT) ProtoMessage() {}

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

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

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

	Val int32
}

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

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

func (x *SInt32LTE) Reset() {
	*x = SInt32LTE{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[100]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SInt32LTE) ProtoMessage() {}

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

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

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

	Val int32
}

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

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

func (x *SInt32GT) Reset() {
	*x = SInt32GT{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[101]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SInt32GT) ProtoMessage() {}

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

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

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

	Val int32
}

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

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

func (x *SInt32GTE) Reset() {
	*x = SInt32GTE{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[102]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SInt32GTE) ProtoMessage() {}

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

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

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

	Val int32
}

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

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

func (x *SInt32GTLT) Reset() {
	*x = SInt32GTLT{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[103]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SInt32GTLT) ProtoMessage() {}

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

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

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

	Val int32
}

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

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

func (x *SInt32ExLTGT) Reset() {
	*x = SInt32ExLTGT{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[104]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SInt32ExLTGT) ProtoMessage() {}

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

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

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

	Val int32
}

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

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

func (x *SInt32GTELTE) Reset() {
	*x = SInt32GTELTE{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[105]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SInt32GTELTE) ProtoMessage() {}

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

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

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

	Val int32
}

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

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

func (x *SInt32ExGTELTE) Reset() {
	*x = SInt32ExGTELTE{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[106]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SInt32ExGTELTE) ProtoMessage() {}

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

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

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

	Val int32
}

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

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

func (x *SInt32Ignore) Reset() {
	*x = SInt32Ignore{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[107]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SInt32Ignore) ProtoMessage() {}

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

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

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

	Val int32
}

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

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

func (x *SInt32IncorrectType) Reset() {
	*x = SInt32IncorrectType{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[108]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SInt32IncorrectType) ProtoMessage() {}

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

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

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

	Val int32
}

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

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

func (x *SInt32Example) Reset() {
	*x = SInt32Example{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[109]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SInt32Example) ProtoMessage() {}

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

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

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

	Val int32
}

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

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

func (x *SInt64None) Reset() {
	*x = SInt64None{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[110]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SInt64None) ProtoMessage() {}

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

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

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

	Val int64
}

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

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

func (x *SInt64Const) Reset() {
	*x = SInt64Const{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[111]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SInt64Const) ProtoMessage() {}

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

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

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

	Val int64
}

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

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

func (x *SInt64In) Reset() {
	*x = SInt64In{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[112]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SInt64In) ProtoMessage() {}

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

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

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

	Val int64
}

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

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

func (x *SInt64NotIn) Reset() {
	*x = SInt64NotIn{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[113]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SInt64NotIn) ProtoMessage() {}

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

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

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

	Val int64
}

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

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

func (x *SInt64LT) Reset() {
	*x = SInt64LT{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[114]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SInt64LT) ProtoMessage() {}

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

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

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

	Val int64
}

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

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

func (x *SInt64LTE) Reset() {
	*x = SInt64LTE{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[115]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SInt64LTE) ProtoMessage() {}

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

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

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

	Val int64
}

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

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

func (x *SInt64GT) Reset() {
	*x = SInt64GT{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[116]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SInt64GT) ProtoMessage() {}

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

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

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

	Val int64
}

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

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

func (x *SInt64GTE) Reset() {
	*x = SInt64GTE{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[117]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SInt64GTE) ProtoMessage() {}

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

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

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

	Val int64
}

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

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

func (x *SInt64GTLT) Reset() {
	*x = SInt64GTLT{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[118]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SInt64GTLT) ProtoMessage() {}

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

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

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

	Val int64
}

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

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

func (x *SInt64ExLTGT) Reset() {
	*x = SInt64ExLTGT{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[119]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SInt64ExLTGT) ProtoMessage() {}

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

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

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

	Val int64
}

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

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

func (x *SInt64GTELTE) Reset() {
	*x = SInt64GTELTE{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[120]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SInt64GTELTE) ProtoMessage() {}

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

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

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

	Val int64
}

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

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

func (x *SInt64ExGTELTE) Reset() {
	*x = SInt64ExGTELTE{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[121]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SInt64ExGTELTE) ProtoMessage() {}

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

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

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

	Val int64
}

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

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

func (x *SInt64Ignore) Reset() {
	*x = SInt64Ignore{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[122]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SInt64Ignore) ProtoMessage() {}

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

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

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

	Val int64
}

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

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

func (x *SInt64IncorrectType) Reset() {
	*x = SInt64IncorrectType{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[123]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SInt64IncorrectType) ProtoMessage() {}

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

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

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

	Val int64
}

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

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

func (x *SInt64Example) Reset() {
	*x = SInt64Example{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[124]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SInt64Example) ProtoMessage() {}

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

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

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

	Val int64
}

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

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

func (x *Fixed32None) Reset() {
	*x = Fixed32None{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[125]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Fixed32None) ProtoMessage() {}

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

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

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

	Val uint32
}

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

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

func (x *Fixed32Const) Reset() {
	*x = Fixed32Const{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[126]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Fixed32Const) ProtoMessage() {}

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

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

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

	Val uint32
}

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

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

func (x *Fixed32In) Reset() {
	*x = Fixed32In{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[127]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Fixed32In) ProtoMessage() {}

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

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

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

	Val uint32
}

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

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

func (x *Fixed32NotIn) Reset() {
	*x = Fixed32NotIn{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[128]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Fixed32NotIn) ProtoMessage() {}

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

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

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

	Val uint32
}

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

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

func (x *Fixed32LT) Reset() {
	*x = Fixed32LT{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[129]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Fixed32LT) ProtoMessage() {}

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

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

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

	Val uint32
}

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

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

func (x *Fixed32LTE) Reset() {
	*x = Fixed32LTE{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[130]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Fixed32LTE) ProtoMessage() {}

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

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

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

	Val uint32
}

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

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

func (x *Fixed32GT) Reset() {
	*x = Fixed32GT{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[131]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Fixed32GT) ProtoMessage() {}

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

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

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

	Val uint32
}

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

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

func (x *Fixed32GTE) Reset() {
	*x = Fixed32GTE{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[132]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Fixed32GTE) ProtoMessage() {}

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

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

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

	Val uint32
}

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

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

func (x *Fixed32GTLT) Reset() {
	*x = Fixed32GTLT{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[133]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Fixed32GTLT) ProtoMessage() {}

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

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

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

	Val uint32
}

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

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

func (x *Fixed32ExLTGT) Reset() {
	*x = Fixed32ExLTGT{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[134]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Fixed32ExLTGT) ProtoMessage() {}

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

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

type Fixed32ExLTGT_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val uint32
}

func (b0 Fixed32ExLTGT_builder) Build() *Fixed32ExLTGT {
	m0 := &Fixed32ExLTGT{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type Fixed32GTELTE struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           uint32                 `protobuf:"fixed32,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Fixed32GTELTE) Reset() {
	*x = Fixed32GTELTE{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[135]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Fixed32GTELTE) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Fixed32GTELTE) ProtoMessage() {}

func (x *Fixed32GTELTE) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[135]
	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 *Fixed32GTELTE) GetVal() uint32 {
	if x != nil {
		return x.Val
	}
	return 0
}

func (x *Fixed32GTELTE) SetVal(v uint32) {
	x.Val = v
}

type Fixed32GTELTE_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val uint32
}

func (b0 Fixed32GTELTE_builder) Build() *Fixed32GTELTE {
	m0 := &Fixed32GTELTE{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type Fixed32ExGTELTE struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           uint32                 `protobuf:"fixed32,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Fixed32ExGTELTE) Reset() {
	*x = Fixed32ExGTELTE{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[136]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Fixed32ExGTELTE) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Fixed32ExGTELTE) ProtoMessage() {}

func (x *Fixed32ExGTELTE) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[136]
	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 *Fixed32ExGTELTE) GetVal() uint32 {
	if x != nil {
		return x.Val
	}
	return 0
}

func (x *Fixed32ExGTELTE) SetVal(v uint32) {
	x.Val = v
}

type Fixed32ExGTELTE_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val uint32
}

func (b0 Fixed32ExGTELTE_builder) Build() *Fixed32ExGTELTE {
	m0 := &Fixed32ExGTELTE{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type Fixed32Ignore struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           uint32                 `protobuf:"fixed32,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Fixed32Ignore) Reset() {
	*x = Fixed32Ignore{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[137]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Fixed32Ignore) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Fixed32Ignore) ProtoMessage() {}

func (x *Fixed32Ignore) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[137]
	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 *Fixed32Ignore) GetVal() uint32 {
	if x != nil {
		return x.Val
	}
	return 0
}

func (x *Fixed32Ignore) SetVal(v uint32) {
	x.Val = v
}

type Fixed32Ignore_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val uint32
}

func (b0 Fixed32Ignore_builder) Build() *Fixed32Ignore {
	m0 := &Fixed32Ignore{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type Fixed32IncorrectType struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           uint32                 `protobuf:"fixed32,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Fixed32IncorrectType) Reset() {
	*x = Fixed32IncorrectType{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[138]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Fixed32IncorrectType) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Fixed32IncorrectType) ProtoMessage() {}

func (x *Fixed32IncorrectType) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[138]
	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 *Fixed32IncorrectType) GetVal() uint32 {
	if x != nil {
		return x.Val
	}
	return 0
}

func (x *Fixed32IncorrectType) SetVal(v uint32) {
	x.Val = v
}

type Fixed32IncorrectType_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val uint32
}

func (b0 Fixed32IncorrectType_builder) Build() *Fixed32IncorrectType {
	m0 := &Fixed32IncorrectType{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type Fixed32Example struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           uint32                 `protobuf:"fixed32,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Fixed32Example) Reset() {
	*x = Fixed32Example{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[139]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Fixed32Example) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Fixed32Example) ProtoMessage() {}

func (x *Fixed32Example) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[139]
	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 *Fixed32Example) GetVal() uint32 {
	if x != nil {
		return x.Val
	}
	return 0
}

func (x *Fixed32Example) SetVal(v uint32) {
	x.Val = v
}

type Fixed32Example_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val uint32
}

func (b0 Fixed32Example_builder) Build() *Fixed32Example {
	m0 := &Fixed32Example{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type Fixed64None struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           uint64                 `protobuf:"fixed64,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Fixed64None) Reset() {
	*x = Fixed64None{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[140]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Fixed64None) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Fixed64None) ProtoMessage() {}

func (x *Fixed64None) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[140]
	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 *Fixed64None) GetVal() uint64 {
	if x != nil {
		return x.Val
	}
	return 0
}

func (x *Fixed64None) SetVal(v uint64) {
	x.Val = v
}

type Fixed64None_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val uint64
}

func (b0 Fixed64None_builder) Build() *Fixed64None {
	m0 := &Fixed64None{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type Fixed64Const struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           uint64                 `protobuf:"fixed64,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Fixed64Const) Reset() {
	*x = Fixed64Const{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[141]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Fixed64Const) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Fixed64Const) ProtoMessage() {}

func (x *Fixed64Const) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[141]
	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 *Fixed64Const) GetVal() uint64 {
	if x != nil {
		return x.Val
	}
	return 0
}

func (x *Fixed64Const) SetVal(v uint64) {
	x.Val = v
}

type Fixed64Const_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val uint64
}

func (b0 Fixed64Const_builder) Build() *Fixed64Const {
	m0 := &Fixed64Const{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type Fixed64In struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           uint64                 `protobuf:"fixed64,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Fixed64In) Reset() {
	*x = Fixed64In{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[142]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Fixed64In) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Fixed64In) ProtoMessage() {}

func (x *Fixed64In) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[142]
	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 *Fixed64In) GetVal() uint64 {
	if x != nil {
		return x.Val
	}
	return 0
}

func (x *Fixed64In) SetVal(v uint64) {
	x.Val = v
}

type Fixed64In_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val uint64
}

func (b0 Fixed64In_builder) Build() *Fixed64In {
	m0 := &Fixed64In{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type Fixed64NotIn struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           uint64                 `protobuf:"fixed64,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Fixed64NotIn) Reset() {
	*x = Fixed64NotIn{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[143]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Fixed64NotIn) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Fixed64NotIn) ProtoMessage() {}

func (x *Fixed64NotIn) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[143]
	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 *Fixed64NotIn) GetVal() uint64 {
	if x != nil {
		return x.Val
	}
	return 0
}

func (x *Fixed64NotIn) SetVal(v uint64) {
	x.Val = v
}

type Fixed64NotIn_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val uint64
}

func (b0 Fixed64NotIn_builder) Build() *Fixed64NotIn {
	m0 := &Fixed64NotIn{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type Fixed64LT struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           uint64                 `protobuf:"fixed64,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Fixed64LT) Reset() {
	*x = Fixed64LT{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[144]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Fixed64LT) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Fixed64LT) ProtoMessage() {}

func (x *Fixed64LT) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[144]
	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 *Fixed64LT) GetVal() uint64 {
	if x != nil {
		return x.Val
	}
	return 0
}

func (x *Fixed64LT) SetVal(v uint64) {
	x.Val = v
}

type Fixed64LT_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val uint64
}

func (b0 Fixed64LT_builder) Build() *Fixed64LT {
	m0 := &Fixed64LT{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type Fixed64LTE struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           uint64                 `protobuf:"fixed64,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Fixed64LTE) Reset() {
	*x = Fixed64LTE{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[145]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Fixed64LTE) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Fixed64LTE) ProtoMessage() {}

func (x *Fixed64LTE) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[145]
	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 *Fixed64LTE) GetVal() uint64 {
	if x != nil {
		return x.Val
	}
	return 0
}

func (x *Fixed64LTE) SetVal(v uint64) {
	x.Val = v
}

type Fixed64LTE_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val uint64
}

func (b0 Fixed64LTE_builder) Build() *Fixed64LTE {
	m0 := &Fixed64LTE{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type Fixed64GT struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           uint64                 `protobuf:"fixed64,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Fixed64GT) Reset() {
	*x = Fixed64GT{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[146]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Fixed64GT) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Fixed64GT) ProtoMessage() {}

func (x *Fixed64GT) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[146]
	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 *Fixed64GT) GetVal() uint64 {
	if x != nil {
		return x.Val
	}
	return 0
}

func (x *Fixed64GT) SetVal(v uint64) {
	x.Val = v
}

type Fixed64GT_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val uint64
}

func (b0 Fixed64GT_builder) Build() *Fixed64GT {
	m0 := &Fixed64GT{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type Fixed64GTE struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           uint64                 `protobuf:"fixed64,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Fixed64GTE) Reset() {
	*x = Fixed64GTE{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[147]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Fixed64GTE) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Fixed64GTE) ProtoMessage() {}

func (x *Fixed64GTE) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[147]
	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 *Fixed64GTE) GetVal() uint64 {
	if x != nil {
		return x.Val
	}
	return 0
}

func (x *Fixed64GTE) SetVal(v uint64) {
	x.Val = v
}

type Fixed64GTE_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val uint64
}

func (b0 Fixed64GTE_builder) Build() *Fixed64GTE {
	m0 := &Fixed64GTE{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type Fixed64GTLT struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           uint64                 `protobuf:"fixed64,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Fixed64GTLT) Reset() {
	*x = Fixed64GTLT{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[148]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Fixed64GTLT) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Fixed64GTLT) ProtoMessage() {}

func (x *Fixed64GTLT) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[148]
	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 *Fixed64GTLT) GetVal() uint64 {
	if x != nil {
		return x.Val
	}
	return 0
}

func (x *Fixed64GTLT) SetVal(v uint64) {
	x.Val = v
}

type Fixed64GTLT_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val uint64
}

func (b0 Fixed64GTLT_builder) Build() *Fixed64GTLT {
	m0 := &Fixed64GTLT{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type Fixed64ExLTGT struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           uint64                 `protobuf:"fixed64,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Fixed64ExLTGT) Reset() {
	*x = Fixed64ExLTGT{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[149]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Fixed64ExLTGT) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Fixed64ExLTGT) ProtoMessage() {}

func (x *Fixed64ExLTGT) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[149]
	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 *Fixed64ExLTGT) GetVal() uint64 {
	if x != nil {
		return x.Val
	}
	return 0
}

func (x *Fixed64ExLTGT) SetVal(v uint64) {
	x.Val = v
}

type Fixed64ExLTGT_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val uint64
}

func (b0 Fixed64ExLTGT_builder) Build() *Fixed64ExLTGT {
	m0 := &Fixed64ExLTGT{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type Fixed64GTELTE struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           uint64                 `protobuf:"fixed64,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Fixed64GTELTE) Reset() {
	*x = Fixed64GTELTE{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[150]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Fixed64GTELTE) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Fixed64GTELTE) ProtoMessage() {}

func (x *Fixed64GTELTE) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[150]
	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 *Fixed64GTELTE) GetVal() uint64 {
	if x != nil {
		return x.Val
	}
	return 0
}

func (x *Fixed64GTELTE) SetVal(v uint64) {
	x.Val = v
}

type Fixed64GTELTE_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val uint64
}

func (b0 Fixed64GTELTE_builder) Build() *Fixed64GTELTE {
	m0 := &Fixed64GTELTE{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type Fixed64ExGTELTE struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           uint64                 `protobuf:"fixed64,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Fixed64ExGTELTE) Reset() {
	*x = Fixed64ExGTELTE{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[151]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Fixed64ExGTELTE) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Fixed64ExGTELTE) ProtoMessage() {}

func (x *Fixed64ExGTELTE) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[151]
	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 *Fixed64ExGTELTE) GetVal() uint64 {
	if x != nil {
		return x.Val
	}
	return 0
}

func (x *Fixed64ExGTELTE) SetVal(v uint64) {
	x.Val = v
}

type Fixed64ExGTELTE_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val uint64
}

func (b0 Fixed64ExGTELTE_builder) Build() *Fixed64ExGTELTE {
	m0 := &Fixed64ExGTELTE{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type Fixed64Ignore struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           uint64                 `protobuf:"fixed64,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Fixed64Ignore) Reset() {
	*x = Fixed64Ignore{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[152]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Fixed64Ignore) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Fixed64Ignore) ProtoMessage() {}

func (x *Fixed64Ignore) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[152]
	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 *Fixed64Ignore) GetVal() uint64 {
	if x != nil {
		return x.Val
	}
	return 0
}

func (x *Fixed64Ignore) SetVal(v uint64) {
	x.Val = v
}

type Fixed64Ignore_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val uint64
}

func (b0 Fixed64Ignore_builder) Build() *Fixed64Ignore {
	m0 := &Fixed64Ignore{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type Fixed64IncorrectType struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           uint64                 `protobuf:"fixed64,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Fixed64IncorrectType) Reset() {
	*x = Fixed64IncorrectType{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[153]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Fixed64IncorrectType) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Fixed64IncorrectType) ProtoMessage() {}

func (x *Fixed64IncorrectType) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[153]
	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 *Fixed64IncorrectType) GetVal() uint64 {
	if x != nil {
		return x.Val
	}
	return 0
}

func (x *Fixed64IncorrectType) SetVal(v uint64) {
	x.Val = v
}

type Fixed64IncorrectType_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val uint64
}

func (b0 Fixed64IncorrectType_builder) Build() *Fixed64IncorrectType {
	m0 := &Fixed64IncorrectType{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type Fixed64Example struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           uint64                 `protobuf:"fixed64,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Fixed64Example) Reset() {
	*x = Fixed64Example{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[154]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Fixed64Example) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Fixed64Example) ProtoMessage() {}

func (x *Fixed64Example) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[154]
	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 *Fixed64Example) GetVal() uint64 {
	if x != nil {
		return x.Val
	}
	return 0
}

func (x *Fixed64Example) SetVal(v uint64) {
	x.Val = v
}

type Fixed64Example_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val uint64
}

func (b0 Fixed64Example_builder) Build() *Fixed64Example {
	m0 := &Fixed64Example{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type SFixed32None struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           int32                  `protobuf:"fixed32,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SFixed32None) Reset() {
	*x = SFixed32None{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[155]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *SFixed32None) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*SFixed32None) ProtoMessage() {}

func (x *SFixed32None) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[155]
	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 *SFixed32None) GetVal() int32 {
	if x != nil {
		return x.Val
	}
	return 0
}

func (x *SFixed32None) SetVal(v int32) {
	x.Val = v
}

type SFixed32None_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val int32
}

func (b0 SFixed32None_builder) Build() *SFixed32None {
	m0 := &SFixed32None{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type SFixed32Const struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           int32                  `protobuf:"fixed32,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SFixed32Const) Reset() {
	*x = SFixed32Const{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[156]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *SFixed32Const) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*SFixed32Const) ProtoMessage() {}

func (x *SFixed32Const) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[156]
	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 *SFixed32Const) GetVal() int32 {
	if x != nil {
		return x.Val
	}
	return 0
}

func (x *SFixed32Const) SetVal(v int32) {
	x.Val = v
}

type SFixed32Const_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val int32
}

func (b0 SFixed32Const_builder) Build() *SFixed32Const {
	m0 := &SFixed32Const{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type SFixed32In struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           int32                  `protobuf:"fixed32,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SFixed32In) Reset() {
	*x = SFixed32In{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[157]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *SFixed32In) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*SFixed32In) ProtoMessage() {}

func (x *SFixed32In) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[157]
	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 *SFixed32In) GetVal() int32 {
	if x != nil {
		return x.Val
	}
	return 0
}

func (x *SFixed32In) SetVal(v int32) {
	x.Val = v
}

type SFixed32In_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val int32
}

func (b0 SFixed32In_builder) Build() *SFixed32In {
	m0 := &SFixed32In{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type SFixed32NotIn struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           int32                  `protobuf:"fixed32,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SFixed32NotIn) Reset() {
	*x = SFixed32NotIn{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[158]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *SFixed32NotIn) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*SFixed32NotIn) ProtoMessage() {}

func (x *SFixed32NotIn) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[158]
	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 *SFixed32NotIn) GetVal() int32 {
	if x != nil {
		return x.Val
	}
	return 0
}

func (x *SFixed32NotIn) SetVal(v int32) {
	x.Val = v
}

type SFixed32NotIn_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val int32
}

func (b0 SFixed32NotIn_builder) Build() *SFixed32NotIn {
	m0 := &SFixed32NotIn{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type SFixed32LT struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           int32                  `protobuf:"fixed32,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SFixed32LT) Reset() {
	*x = SFixed32LT{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[159]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *SFixed32LT) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*SFixed32LT) ProtoMessage() {}

func (x *SFixed32LT) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[159]
	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 *SFixed32LT) GetVal() int32 {
	if x != nil {
		return x.Val
	}
	return 0
}

func (x *SFixed32LT) SetVal(v int32) {
	x.Val = v
}

type SFixed32LT_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val int32
}

func (b0 SFixed32LT_builder) Build() *SFixed32LT {
	m0 := &SFixed32LT{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type SFixed32LTE struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           int32                  `protobuf:"fixed32,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SFixed32LTE) Reset() {
	*x = SFixed32LTE{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[160]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *SFixed32LTE) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*SFixed32LTE) ProtoMessage() {}

func (x *SFixed32LTE) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[160]
	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 *SFixed32LTE) GetVal() int32 {
	if x != nil {
		return x.Val
	}
	return 0
}

func (x *SFixed32LTE) SetVal(v int32) {
	x.Val = v
}

type SFixed32LTE_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val int32
}

func (b0 SFixed32LTE_builder) Build() *SFixed32LTE {
	m0 := &SFixed32LTE{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type SFixed32GT struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           int32                  `protobuf:"fixed32,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SFixed32GT) Reset() {
	*x = SFixed32GT{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[161]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *SFixed32GT) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*SFixed32GT) ProtoMessage() {}

func (x *SFixed32GT) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[161]
	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 *SFixed32GT) GetVal() int32 {
	if x != nil {
		return x.Val
	}
	return 0
}

func (x *SFixed32GT) SetVal(v int32) {
	x.Val = v
}

type SFixed32GT_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val int32
}

func (b0 SFixed32GT_builder) Build() *SFixed32GT {
	m0 := &SFixed32GT{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type SFixed32GTE struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           int32                  `protobuf:"fixed32,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SFixed32GTE) Reset() {
	*x = SFixed32GTE{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[162]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *SFixed32GTE) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*SFixed32GTE) ProtoMessage() {}

func (x *SFixed32GTE) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[162]
	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 *SFixed32GTE) GetVal() int32 {
	if x != nil {
		return x.Val
	}
	return 0
}

func (x *SFixed32GTE) SetVal(v int32) {
	x.Val = v
}

type SFixed32GTE_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val int32
}

func (b0 SFixed32GTE_builder) Build() *SFixed32GTE {
	m0 := &SFixed32GTE{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type SFixed32GTLT struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           int32                  `protobuf:"fixed32,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SFixed32GTLT) Reset() {
	*x = SFixed32GTLT{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[163]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *SFixed32GTLT) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*SFixed32GTLT) ProtoMessage() {}

func (x *SFixed32GTLT) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[163]
	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 *SFixed32GTLT) GetVal() int32 {
	if x != nil {
		return x.Val
	}
	return 0
}

func (x *SFixed32GTLT) SetVal(v int32) {
	x.Val = v
}

type SFixed32GTLT_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val int32
}

func (b0 SFixed32GTLT_builder) Build() *SFixed32GTLT {
	m0 := &SFixed32GTLT{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type SFixed32ExLTGT struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           int32                  `protobuf:"fixed32,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SFixed32ExLTGT) Reset() {
	*x = SFixed32ExLTGT{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[164]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *SFixed32ExLTGT) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*SFixed32ExLTGT) ProtoMessage() {}

func (x *SFixed32ExLTGT) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[164]
	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 *SFixed32ExLTGT) GetVal() int32 {
	if x != nil {
		return x.Val
	}
	return 0
}

func (x *SFixed32ExLTGT) SetVal(v int32) {
	x.Val = v
}

type SFixed32ExLTGT_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val int32
}

func (b0 SFixed32ExLTGT_builder) Build() *SFixed32ExLTGT {
	m0 := &SFixed32ExLTGT{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type SFixed32GTELTE struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           int32                  `protobuf:"fixed32,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SFixed32GTELTE) Reset() {
	*x = SFixed32GTELTE{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[165]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *SFixed32GTELTE) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*SFixed32GTELTE) ProtoMessage() {}

func (x *SFixed32GTELTE) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[165]
	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 *SFixed32GTELTE) GetVal() int32 {
	if x != nil {
		return x.Val
	}
	return 0
}

func (x *SFixed32GTELTE) SetVal(v int32) {
	x.Val = v
}

type SFixed32GTELTE_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val int32
}

func (b0 SFixed32GTELTE_builder) Build() *SFixed32GTELTE {
	m0 := &SFixed32GTELTE{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type SFixed32ExGTELTE struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           int32                  `protobuf:"fixed32,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SFixed32ExGTELTE) Reset() {
	*x = SFixed32ExGTELTE{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[166]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *SFixed32ExGTELTE) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*SFixed32ExGTELTE) ProtoMessage() {}

func (x *SFixed32ExGTELTE) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[166]
	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 *SFixed32ExGTELTE) GetVal() int32 {
	if x != nil {
		return x.Val
	}
	return 0
}

func (x *SFixed32ExGTELTE) SetVal(v int32) {
	x.Val = v
}

type SFixed32ExGTELTE_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val int32
}

func (b0 SFixed32ExGTELTE_builder) Build() *SFixed32ExGTELTE {
	m0 := &SFixed32ExGTELTE{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type SFixed32Ignore struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           int32                  `protobuf:"fixed32,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SFixed32Ignore) Reset() {
	*x = SFixed32Ignore{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[167]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *SFixed32Ignore) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*SFixed32Ignore) ProtoMessage() {}

func (x *SFixed32Ignore) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[167]
	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 *SFixed32Ignore) GetVal() int32 {
	if x != nil {
		return x.Val
	}
	return 0
}

func (x *SFixed32Ignore) SetVal(v int32) {
	x.Val = v
}

type SFixed32Ignore_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val int32
}

func (b0 SFixed32Ignore_builder) Build() *SFixed32Ignore {
	m0 := &SFixed32Ignore{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type SFixed32IncorrectType struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           int32                  `protobuf:"fixed32,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SFixed32IncorrectType) Reset() {
	*x = SFixed32IncorrectType{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[168]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *SFixed32IncorrectType) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*SFixed32IncorrectType) ProtoMessage() {}

func (x *SFixed32IncorrectType) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[168]
	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 *SFixed32IncorrectType) GetVal() int32 {
	if x != nil {
		return x.Val
	}
	return 0
}

func (x *SFixed32IncorrectType) SetVal(v int32) {
	x.Val = v
}

type SFixed32IncorrectType_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val int32
}

func (b0 SFixed32IncorrectType_builder) Build() *SFixed32IncorrectType {
	m0 := &SFixed32IncorrectType{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type SFixed32Example struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           int32                  `protobuf:"fixed32,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SFixed32Example) Reset() {
	*x = SFixed32Example{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[169]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *SFixed32Example) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*SFixed32Example) ProtoMessage() {}

func (x *SFixed32Example) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[169]
	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 *SFixed32Example) GetVal() int32 {
	if x != nil {
		return x.Val
	}
	return 0
}

func (x *SFixed32Example) SetVal(v int32) {
	x.Val = v
}

type SFixed32Example_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val int32
}

func (b0 SFixed32Example_builder) Build() *SFixed32Example {
	m0 := &SFixed32Example{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type SFixed64None struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           int64                  `protobuf:"fixed64,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SFixed64None) Reset() {
	*x = SFixed64None{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[170]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *SFixed64None) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*SFixed64None) ProtoMessage() {}

func (x *SFixed64None) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[170]
	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 *SFixed64None) GetVal() int64 {
	if x != nil {
		return x.Val
	}
	return 0
}

func (x *SFixed64None) SetVal(v int64) {
	x.Val = v
}

type SFixed64None_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val int64
}

func (b0 SFixed64None_builder) Build() *SFixed64None {
	m0 := &SFixed64None{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type SFixed64Const struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           int64                  `protobuf:"fixed64,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SFixed64Const) Reset() {
	*x = SFixed64Const{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[171]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *SFixed64Const) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*SFixed64Const) ProtoMessage() {}

func (x *SFixed64Const) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[171]
	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 *SFixed64Const) GetVal() int64 {
	if x != nil {
		return x.Val
	}
	return 0
}

func (x *SFixed64Const) SetVal(v int64) {
	x.Val = v
}

type SFixed64Const_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val int64
}

func (b0 SFixed64Const_builder) Build() *SFixed64Const {
	m0 := &SFixed64Const{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type SFixed64In struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           int64                  `protobuf:"fixed64,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SFixed64In) Reset() {
	*x = SFixed64In{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[172]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *SFixed64In) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*SFixed64In) ProtoMessage() {}

func (x *SFixed64In) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[172]
	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 *SFixed64In) GetVal() int64 {
	if x != nil {
		return x.Val
	}
	return 0
}

func (x *SFixed64In) SetVal(v int64) {
	x.Val = v
}

type SFixed64In_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val int64
}

func (b0 SFixed64In_builder) Build() *SFixed64In {
	m0 := &SFixed64In{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type SFixed64NotIn struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           int64                  `protobuf:"fixed64,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SFixed64NotIn) Reset() {
	*x = SFixed64NotIn{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[173]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *SFixed64NotIn) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*SFixed64NotIn) ProtoMessage() {}

func (x *SFixed64NotIn) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[173]
	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 *SFixed64NotIn) GetVal() int64 {
	if x != nil {
		return x.Val
	}
	return 0
}

func (x *SFixed64NotIn) SetVal(v int64) {
	x.Val = v
}

type SFixed64NotIn_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val int64
}

func (b0 SFixed64NotIn_builder) Build() *SFixed64NotIn {
	m0 := &SFixed64NotIn{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type SFixed64LT struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           int64                  `protobuf:"fixed64,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SFixed64LT) Reset() {
	*x = SFixed64LT{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[174]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *SFixed64LT) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*SFixed64LT) ProtoMessage() {}

func (x *SFixed64LT) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[174]
	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 *SFixed64LT) GetVal() int64 {
	if x != nil {
		return x.Val
	}
	return 0
}

func (x *SFixed64LT) SetVal(v int64) {
	x.Val = v
}

type SFixed64LT_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val int64
}

func (b0 SFixed64LT_builder) Build() *SFixed64LT {
	m0 := &SFixed64LT{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type SFixed64LTE struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           int64                  `protobuf:"fixed64,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SFixed64LTE) Reset() {
	*x = SFixed64LTE{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[175]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *SFixed64LTE) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*SFixed64LTE) ProtoMessage() {}

func (x *SFixed64LTE) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[175]
	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 *SFixed64LTE) GetVal() int64 {
	if x != nil {
		return x.Val
	}
	return 0
}

func (x *SFixed64LTE) SetVal(v int64) {
	x.Val = v
}

type SFixed64LTE_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val int64
}

func (b0 SFixed64LTE_builder) Build() *SFixed64LTE {
	m0 := &SFixed64LTE{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type SFixed64GT struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           int64                  `protobuf:"fixed64,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SFixed64GT) Reset() {
	*x = SFixed64GT{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[176]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *SFixed64GT) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*SFixed64GT) ProtoMessage() {}

func (x *SFixed64GT) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[176]
	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 *SFixed64GT) GetVal() int64 {
	if x != nil {
		return x.Val
	}
	return 0
}

func (x *SFixed64GT) SetVal(v int64) {
	x.Val = v
}

type SFixed64GT_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val int64
}

func (b0 SFixed64GT_builder) Build() *SFixed64GT {
	m0 := &SFixed64GT{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type SFixed64GTE struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           int64                  `protobuf:"fixed64,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SFixed64GTE) Reset() {
	*x = SFixed64GTE{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[177]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *SFixed64GTE) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*SFixed64GTE) ProtoMessage() {}

func (x *SFixed64GTE) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[177]
	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 *SFixed64GTE) GetVal() int64 {
	if x != nil {
		return x.Val
	}
	return 0
}

func (x *SFixed64GTE) SetVal(v int64) {
	x.Val = v
}

type SFixed64GTE_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val int64
}

func (b0 SFixed64GTE_builder) Build() *SFixed64GTE {
	m0 := &SFixed64GTE{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type SFixed64GTLT struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           int64                  `protobuf:"fixed64,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SFixed64GTLT) Reset() {
	*x = SFixed64GTLT{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[178]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *SFixed64GTLT) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*SFixed64GTLT) ProtoMessage() {}

func (x *SFixed64GTLT) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[178]
	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 *SFixed64GTLT) GetVal() int64 {
	if x != nil {
		return x.Val
	}
	return 0
}

func (x *SFixed64GTLT) SetVal(v int64) {
	x.Val = v
}

type SFixed64GTLT_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val int64
}

func (b0 SFixed64GTLT_builder) Build() *SFixed64GTLT {
	m0 := &SFixed64GTLT{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type SFixed64ExLTGT struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           int64                  `protobuf:"fixed64,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SFixed64ExLTGT) Reset() {
	*x = SFixed64ExLTGT{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[179]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *SFixed64ExLTGT) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*SFixed64ExLTGT) ProtoMessage() {}

func (x *SFixed64ExLTGT) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[179]
	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 *SFixed64ExLTGT) GetVal() int64 {
	if x != nil {
		return x.Val
	}
	return 0
}

func (x *SFixed64ExLTGT) SetVal(v int64) {
	x.Val = v
}

type SFixed64ExLTGT_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val int64
}

func (b0 SFixed64ExLTGT_builder) Build() *SFixed64ExLTGT {
	m0 := &SFixed64ExLTGT{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type SFixed64GTELTE struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           int64                  `protobuf:"fixed64,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SFixed64GTELTE) Reset() {
	*x = SFixed64GTELTE{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[180]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *SFixed64GTELTE) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*SFixed64GTELTE) ProtoMessage() {}

func (x *SFixed64GTELTE) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[180]
	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 *SFixed64GTELTE) GetVal() int64 {
	if x != nil {
		return x.Val
	}
	return 0
}

func (x *SFixed64GTELTE) SetVal(v int64) {
	x.Val = v
}

type SFixed64GTELTE_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val int64
}

func (b0 SFixed64GTELTE_builder) Build() *SFixed64GTELTE {
	m0 := &SFixed64GTELTE{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type SFixed64ExGTELTE struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           int64                  `protobuf:"fixed64,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SFixed64ExGTELTE) Reset() {
	*x = SFixed64ExGTELTE{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[181]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *SFixed64ExGTELTE) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*SFixed64ExGTELTE) ProtoMessage() {}

func (x *SFixed64ExGTELTE) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[181]
	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 *SFixed64ExGTELTE) GetVal() int64 {
	if x != nil {
		return x.Val
	}
	return 0
}

func (x *SFixed64ExGTELTE) SetVal(v int64) {
	x.Val = v
}

type SFixed64ExGTELTE_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val int64
}

func (b0 SFixed64ExGTELTE_builder) Build() *SFixed64ExGTELTE {
	m0 := &SFixed64ExGTELTE{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type SFixed64Ignore struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           int64                  `protobuf:"fixed64,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SFixed64Ignore) Reset() {
	*x = SFixed64Ignore{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[182]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *SFixed64Ignore) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*SFixed64Ignore) ProtoMessage() {}

func (x *SFixed64Ignore) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[182]
	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 *SFixed64Ignore) GetVal() int64 {
	if x != nil {
		return x.Val
	}
	return 0
}

func (x *SFixed64Ignore) SetVal(v int64) {
	x.Val = v
}

type SFixed64Ignore_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val int64
}

func (b0 SFixed64Ignore_builder) Build() *SFixed64Ignore {
	m0 := &SFixed64Ignore{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type SFixed64IncorrectType struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           int64                  `protobuf:"fixed64,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SFixed64IncorrectType) Reset() {
	*x = SFixed64IncorrectType{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[183]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *SFixed64IncorrectType) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*SFixed64IncorrectType) ProtoMessage() {}

func (x *SFixed64IncorrectType) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[183]
	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 *SFixed64IncorrectType) GetVal() int64 {
	if x != nil {
		return x.Val
	}
	return 0
}

func (x *SFixed64IncorrectType) SetVal(v int64) {
	x.Val = v
}

type SFixed64IncorrectType_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val int64
}

func (b0 SFixed64IncorrectType_builder) Build() *SFixed64IncorrectType {
	m0 := &SFixed64IncorrectType{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type SFixed64Example struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           int64                  `protobuf:"fixed64,1,opt,name=val,proto3" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SFixed64Example) Reset() {
	*x = SFixed64Example{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[184]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *SFixed64Example) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*SFixed64Example) ProtoMessage() {}

func (x *SFixed64Example) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[184]
	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 *SFixed64Example) GetVal() int64 {
	if x != nil {
		return x.Val
	}
	return 0
}

func (x *SFixed64Example) SetVal(v int64) {
	x.Val = v
}

type SFixed64Example_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val int64
}

func (b0 SFixed64Example_builder) Build() *SFixed64Example {
	m0 := &SFixed64Example{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

type Int64LTEOptional struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Val           *int64                 `protobuf:"varint,1,opt,name=val,proto3,oneof" json:"val,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Int64LTEOptional) Reset() {
	*x = Int64LTEOptional{}
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[185]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Int64LTEOptional) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Int64LTEOptional) ProtoMessage() {}

func (x *Int64LTEOptional) ProtoReflect() protoreflect.Message {
	mi := &file_buf_validate_conformance_cases_numbers_proto_msgTypes[185]
	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 *Int64LTEOptional) GetVal() int64 {
	if x != nil && x.Val != nil {
		return *x.Val
	}
	return 0
}

func (x *Int64LTEOptional) SetVal(v int64) {
	x.Val = &v
}

func (x *Int64LTEOptional) HasVal() bool {
	if x == nil {
		return false
	}
	return x.Val != nil
}

func (x *Int64LTEOptional) ClearVal() {
	x.Val = nil
}

type Int64LTEOptional_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Val *int64
}

func (b0 Int64LTEOptional_builder) Build() *Int64LTEOptional {
	m0 := &Int64LTEOptional{}
	b, x := &b0, m0
	_, _ = b, x
	x.Val = b.Val
	return m0
}

var File_buf_validate_conformance_cases_numbers_proto protoreflect.FileDescriptor

const file_buf_validate_conformance_cases_numbers_proto_rawDesc = "" +
	"\n" +
	",buf/validate/conformance/cases/numbers.proto\x12\x1ebuf.validate.conformance.cases\x1a\x1bbuf/validate/validate.proto\"\x1d\n" +
	"\tFloatNone\x12\x10\n" +
	"\x03val\x18\x01 \x01(\x02R\x03val\"*\n" +
	"\n" +
	"FloatConst\x12\x1c\n" +
	"\x03val\x18\x01 \x01(\x02B\n" +
	"\xbaH\a\n" +
	"\x05\r\xa4p\x9d?R\x03val\",\n" +
	"\aFloatIn\x12!\n" +
	"\x03val\x18\x01 \x01(\x02B\x0f\xbaH\f\n" +
	"\n" +
	"5\x85\xeb\x91@5\xe1z\xfc@R\x03val\"*\n" +
	"\n" +
	"FloatNotIn\x12\x1c\n" +
	"\x03val\x18\x01 \x01(\x02B\n" +
	"\xbaH\a\n" +
	"\x05=\x00\x00\x00\x00R\x03val\"'\n" +
	"\aFloatLT\x12\x1c\n" +
	"\x03val\x18\x01 \x01(\x02B\n" +
	"\xbaH\a\n" +
	"\x05\x15\x00\x00\x00\x00R\x03val\"(\n" +
	"\bFloatLTE\x12\x1c\n" +
	"\x03val\x18\x01 \x01(\x02B\n" +
	"\xbaH\a\n" +
	"\x05\x1d\x00\x00\x80BR\x03val\"'\n" +
	"\aFloatGT\x12\x1c\n" +
	"\x03val\x18\x01 \x01(\x02B\n" +
	"\xbaH\a\n" +
	"\x05%\x00\x00\x80AR\x03val\"(\n" +
	"\bFloatGTE\x12\x1c\n" +
	"\x03val\x18\x01 \x01(\x02B\n" +
	"\xbaH\a\n" +
	"\x05-\x00\x00\x00AR\x03val\".\n" +
	"\tFloatGTLT\x12!\n" +
	"\x03val\x18\x01 \x01(\x02B\x0f\xbaH\f\n" +
	"\n" +
	"\x15\x00\x00 A%\x00\x00\x00\x00R\x03val\"0\n" +
	"\vFloatExLTGT\x12!\n" +
	"\x03val\x18\x01 \x01(\x02B\x0f\xbaH\f\n" +
	"\n" +
	"\x15\x00\x00\x00\x00%\x00\x00 AR\x03val\"0\n" +
	"\vFloatGTELTE\x12!\n" +
	"\x03val\x18\x01 \x01(\x02B\x0f\xbaH\f\n" +
	"\n" +
	"\x1d\x00\x00\x80C-\x00\x00\x00CR\x03val\"2\n" +
	"\rFloatExGTELTE\x12!\n" +
	"\x03val\x18\x01 \x01(\x02B\x0f\xbaH\f\n" +
	"\n" +
	"\x1d\x00\x00\x00C-\x00\x00\x80CR\x03val\"(\n" +
	"\vFloatFinite\x12\x19\n" +
	"\x03val\x18\x01 \x01(\x02B\a\xbaH\x04\n" +
	"\x02@\x01R\x03val\"+\n" +
	"\x0eFloatNotFinite\x12\x19\n" +
	"\x03val\x18\x01 \x01(\x02B\a\xbaH\x04\n" +
	"\x02@\x00R\x03val\"3\n" +
	"\vFloatIgnore\x12$\n" +
	"\x03val\x18\x01 \x01(\x02B\x12\xbaH\x0f\xd8\x01\x01\n" +
	"\n" +
	"\x1d\x00\x00\x80C-\x00\x00\x00CR\x03val\"6\n" +
	"\x12FloatIncorrectType\x12 \n" +
	"\x03val\x18\x01 \x01(\x02B\x0e\xbaH\v\x12\t!\x00\x00\x00\x00\x00\x00\x00\x00R\x03val\",\n" +
	"\fFloatExample\x12\x1c\n" +
	"\x03val\x18\x01 \x01(\x02B\n" +
	"\xbaH\a\n" +
	"\x05M\x00\x00\x00AR\x03val\"\x1e\n" +
	"\n" +
	"DoubleNone\x12\x10\n" +
	"\x03val\x18\x01 \x01(\x01R\x03val\"/\n" +
	"\vDoubleConst\x12 \n" +
	"\x03val\x18\x01 \x01(\x01B\x0e\xbaH\v\x12\t\t\xaeG\xe1z\x14\xae\xf3?R\x03val\"5\n" +
	"\bDoubleIn\x12)\n" +
	"\x03val\x18\x01 \x01(\x01B\x17\xbaH\x14\x12\x121=\n" +
	"ףp=\x12@1\x8f\xc2\xf5(\\\x8f\x1f@R\x03val\"/\n" +
	"\vDoubleNotIn\x12 \n" +
	"\x03val\x18\x01 \x01(\x01B\x0e\xbaH\v\x12\t9\x00\x00\x00\x00\x00\x00\x00\x00R\x03val\",\n" +
	"\bDoubleLT\x12 \n" +
	"\x03val\x18\x01 \x01(\x01B\x0e\xbaH\v\x12\t\x11\x00\x00\x00\x00\x00\x00\x00\x00R\x03val\"-\n" +
	"\tDoubleLTE\x12 \n" +
	"\x03val\x18\x01 \x01(\x01B\x0e\xbaH\v\x12\t\x19\x00\x00\x00\x00\x00\x00P@R\x03val\",\n" +
	"\bDoubleGT\x12 \n" +
	"\x03val\x18\x01 \x01(\x01B\x0e\xbaH\v\x12\t!\x00\x00\x00\x00\x00\x000@R\x03val\"-\n" +
	"\tDoubleGTE\x12 \n" +
	"\x03val\x18\x01 \x01(\x01B\x0e\xbaH\v\x12\t)\x00\x00\x00\x00\x00\x00 @R\x03val\"7\n" +
	"\n" +
	"DoubleGTLT\x12)\n" +
	"\x03val\x18\x01 \x01(\x01B\x17\xbaH\x14\x12\x12\x11\x00\x00\x00\x00\x00\x00$@!\x00\x00\x00\x00\x00\x00\x00\x00R\x03val\"9\n" +
	"\fDoubleExLTGT\x12)\n" +
	"\x03val\x18\x01 \x01(\x01B\x17\xbaH\x14\x12\x12\x11\x00\x00\x00\x00\x00\x00\x00\x00!\x00\x00\x00\x00\x00\x00$@R\x03val\"9\n" +
	"\fDoubleGTELTE\x12)\n" +
	"\x03val\x18\x01 \x01(\x01B\x17\xbaH\x14\x12\x12\x19\x00\x00\x00\x00\x00\x00p@)\x00\x00\x00\x00\x00\x00`@R\x03val\";\n" +
	"\x0eDoubleExGTELTE\x12)\n" +
	"\x03val\x18\x01 \x01(\x01B\x17\xbaH\x14\x12\x12\x19\x00\x00\x00\x00\x00\x00`@)\x00\x00\x00\x00\x00\x00p@R\x03val\")\n" +
	"\fDoubleFinite\x12\x19\n" +
	"\x03val\x18\x01 \x01(\x01B\a\xbaH\x04\x12\x02@\x01R\x03val\",\n" +
	"\x0fDoubleNotFinite\x12\x19\n" +
	"\x03val\x18\x01 \x01(\x01B\a\xbaH\x04\x12\x02@\x00R\x03val\"<\n" +
	"\fDoubleIgnore\x12,\n" +
	"\x03val\x18\x01 \x01(\x01B\x1a\xbaH\x17\xd8\x01\x01\x12\x12\x19\x00\x00\x00\x00\x00\x00p@)\x00\x00\x00\x00\x00\x00`@R\x03val\"3\n" +
	"\x13DoubleIncorrectType\x12\x1c\n" +
	"\x03val\x18\x01 \x01(\x01B\n" +
	"\xbaH\a\n" +
	"\x05%\x00\x00\x00\x00R\x03val\"1\n" +
	"\rDoubleExample\x12 \n" +
	"\x03val\x18\x01 \x01(\x01B\x0e\xbaH\v\x12\tI\x00\x00\x00\x00\x00\x00\x00\x00R\x03val\"\x1d\n" +
	"\tInt32None\x12\x10\n" +
	"\x03val\x18\x01 \x01(\x05R\x03val\"'\n" +
	"\n" +
	"Int32Const\x12\x19\n" +
	"\x03val\x18\x01 \x01(\x05B\a\xbaH\x04\x1a\x02\b\x01R\x03val\"&\n" +
	"\aInt32In\x12\x1b\n" +
	"\x03val\x18\x01 \x01(\x05B\t\xbaH\x06\x1a\x040\x020\x03R\x03val\"'\n" +
	"\n" +
	"Int32NotIn\x12\x19\n" +
	"\x03val\x18\x01 \x01(\x05B\a\xbaH\x04\x1a\x028\x00R\x03val\"$\n" +
	"\aInt32LT\x12\x19\n" +
	"\x03val\x18\x01 \x01(\x05B\a\xbaH\x04\x1a\x02\x10\x00R\x03val\"%\n" +
	"\bInt32LTE\x12\x19\n" +
	"\x03val\x18\x01 \x01(\x05B\a\xbaH\x04\x1a\x02\x18@R\x03val\"$\n" +
	"\aInt32GT\x12\x19\n" +
	"\x03val\x18\x01 \x01(\x05B\a\xbaH\x04\x1a\x02 \x10R\x03val\"%\n" +
	"\bInt32GTE\x12\x19\n" +
	"\x03val\x18\x01 \x01(\x05B\a\xbaH\x04\x1a\x02(\bR\x03val\"(\n" +
	"\tInt32GTLT\x12\x1b\n" +
	"\x03val\x18\x01 \x01(\x05B\t\xbaH\x06\x1a\x04\x10\n" +
	" \x00R\x03val\"*\n" +
	"\vInt32ExLTGT\x12\x1b\n" +
	"\x03val\x18\x01 \x01(\x05B\t\xbaH\x06\x1a\x04\x10\x00 \n" +
	"R\x03val\",\n" +
	"\vInt32GTELTE\x12\x1d\n" +
	"\x03val\x18\x01 \x01(\x05B\v\xbaH\b\x1a\x06\x18\x80\x02(\x80\x01R\x03val\".\n" +
	"\rInt32ExGTELTE\x12\x1d\n" +
	"\x03val\x18\x01 \x01(\x05B\v\xbaH\b\x1a\x06\x18\x80\x01(\x80\x02R\x03val\"/\n" +
	"\vInt32Ignore\x12 \n" +
	"\x03val\x18\x01 \x01(\x05B\x0e\xbaH\v\xd8\x01\x01\x1a\x06\x18\x80\x02(\x80\x01R\x03val\"2\n" +
	"\x12Int32IncorrectType\x12\x1c\n" +
	"\x03val\x18\x01 \x01(\x05B\n" +
	"\xbaH\a\n" +
	"\x05%\x00\x00\x00\x00R\x03val\")\n" +
	"\fInt32Example\x12\x19\n" +
	"\x03val\x18\x01 \x01(\x05B\a\xbaH\x04\x1a\x02@\n" +
	"R\x03val\"\x1d\n" +
	"\tInt64None\x12\x10\n" +
	"\x03val\x18\x01 \x01(\x03R\x03val\"'\n" +
	"\n" +
	"Int64Const\x12\x19\n" +
	"\x03val\x18\x01 \x01(\x03B\a\xbaH\x04\"\x02\b\x01R\x03val\"&\n" +
	"\aInt64In\x12\x1b\n" +
	"\x03val\x18\x01 \x01(\x03B\t\xbaH\x06\"\x040\x020\x03R\x03val\"'\n" +
	"\n" +
	"Int64NotIn\x12\x19\n" +
	"\x03val\x18\x01 \x01(\x03B\a\xbaH\x04\"\x028\x00R\x03val\"$\n" +
	"\aInt64LT\x12\x19\n" +
	"\x03val\x18\x01 \x01(\x03B\a\xbaH\x04\"\x02\x10\x00R\x03val\"%\n" +
	"\bInt64LTE\x12\x19\n" +
	"\x03val\x18\x01 \x01(\x03B\a\xbaH\x04\"\x02\x18@R\x03val\"$\n" +
	"\aInt64GT\x12\x19\n" +
	"\x03val\x18\x01 \x01(\x03B\a\xbaH\x04\"\x02 \x10R\x03val\"%\n" +
	"\bInt64GTE\x12\x19\n" +
	"\x03val\x18\x01 \x01(\x03B\a\xbaH\x04\"\x02(\bR\x03val\"(\n" +
	"\tInt64GTLT\x12\x1b\n" +
	"\x03val\x18\x01 \x01(\x03B\t\xbaH\x06\"\x04\x10\n" +
	" \x00R\x03val\"*\n" +
	"\vInt64ExLTGT\x12\x1b\n" +
	"\x03val\x18\x01 \x01(\x03B\t\xbaH\x06\"\x04\x10\x00 \n" +
	"R\x03val\",\n" +
	"\vInt64GTELTE\x12\x1d\n" +
	"\x03val\x18\x01 \x01(\x03B\v\xbaH\b\"\x06\x18\x80\x02(\x80\x01R\x03val\".\n" +
	"\rInt64ExGTELTE\x12\x1d\n" +
	"\x03val\x18\x01 \x01(\x03B\v\xbaH\b\"\x06\x18\x80\x01(\x80\x02R\x03val\"/\n" +
	"\vInt64Ignore\x12 \n" +
	"\x03val\x18\x01 \x01(\x03B\x0e\xbaH\v\xd8\x01\x01\"\x06\x18\x80\x02(\x80\x01R\x03val\"\x86\x04\n" +
	"\rInt64BigRules\x12\"\n" +
	"\x06lt_pos\x18\x01 \x01(\x03B\v\xbaH\b\"\x06\x10\xa6݇\xa4\x14R\x05ltPos\x12'\n" +
	"\x06lt_neg\x18\x02 \x01(\x03B\x10\xbaH\r\"\v\x10ڢ\xf8\xdb\xeb\xff\xff\xff\xff\x01R\x05ltNeg\x12\"\n" +
	"\x06gt_pos\x18\x03 \x01(\x03B\v\xbaH\b\"\x06 \xa6݇\xa4\x14R\x05gtPos\x12'\n" +
	"\x06gt_neg\x18\x04 \x01(\x03B\x10\xbaH\r\"\v ڢ\xf8\xdb\xeb\xff\xff\xff\xff\x01R\x05gtNeg\x12$\n" +
	"\alte_pos\x18\x05 \x01(\x03B\v\xbaH\b\"\x06\x18\xa6݇\xa4\x14R\x06ltePos\x12)\n" +
	"\alte_neg\x18\x06 \x01(\x03B\x10\xbaH\r\"\v\x18ڢ\xf8\xdb\xeb\xff\xff\xff\xff\x01R\x06lteNeg\x12$\n" +
	"\agte_pos\x18\a \x01(\x03B\v\xbaH\b\"\x06(\xa6݇\xa4\x14R\x06gtePos\x12)\n" +
	"\agte_neg\x18\b \x01(\x03B\x10\xbaH\r\"\v(ڢ\xf8\xdb\xeb\xff\xff\xff\xff\x01R\x06gteNeg\x12.\n" +
	"\fconstant_pos\x18\t \x01(\x03B\v\xbaH\b\"\x06\b\xa6݇\xa4\x14R\vconstantPos\x123\n" +
	"\fconstant_neg\x18\n" +
	" \x01(\x03B\x10\xbaH\r\"\v\bڢ\xf8\xdb\xeb\xff\xff\xff\xff\x01R\vconstantNeg\x12&\n" +
	"\x02in\x18\v \x01(\x03B\x16\xbaH\x13\"\x110\xa6݇\xa4\x140ڢ\xf8\xdb\xeb\xff\xff\xff\xff\x01R\x02in\x12,\n" +
	"\x05notin\x18\f \x01(\x03B\x16\xbaH\x13\"\x118\xa6݇\xa4\x148ڢ\xf8\xdb\xeb\xff\xff\xff\xff\x01R\x05notin\"2\n" +
	"\x12Int64IncorrectType\x12\x1c\n" +
	"\x03val\x18\x01 \x01(\x03B\n" +
	"\xbaH\a\n" +
	"\x05%\x00\x00\x00\x00R\x03val\")\n" +
	"\fInt64Example\x12\x19\n" +
	"\x03val\x18\x01 \x01(\x03B\a\xbaH\x04\"\x02H\n" +
	"R\x03val\"\x1e\n" +
	"\n" +
	"UInt32None\x12\x10\n" +
	"\x03val\x18\x01 \x01(\rR\x03val\"(\n" +
	"\vUInt32Const\x12\x19\n" +
	"\x03val\x18\x01 \x01(\rB\a\xbaH\x04*\x02\b\x01R\x03val\"'\n" +
	"\bUInt32In\x12\x1b\n" +
	"\x03val\x18\x01 \x01(\rB\t\xbaH\x06*\x040\x020\x03R\x03val\"(\n" +
	"\vUInt32NotIn\x12\x19\n" +
	"\x03val\x18\x01 \x01(\rB\a\xbaH\x04*\x028\x00R\x03val\"%\n" +
	"\bUInt32LT\x12\x19\n" +
	"\x03val\x18\x01 \x01(\rB\a\xbaH\x04*\x02\x10\x05R\x03val\"&\n" +
	"\tUInt32LTE\x12\x19\n" +
	"\x03val\x18\x01 \x01(\rB\a\xbaH\x04*\x02\x18@R\x03val\"%\n" +
	"\bUInt32GT\x12\x19\n" +
	"\x03val\x18\x01 \x01(\rB\a\xbaH\x04*\x02 \x10R\x03val\"&\n" +
	"\tUInt32GTE\x12\x19\n" +
	"\x03val\x18\x01 \x01(\rB\a\xbaH\x04*\x02(\bR\x03val\")\n" +
	"\n" +
	"UInt32GTLT\x12\x1b\n" +
	"\x03val\x18\x01 \x01(\rB\t\xbaH\x06*\x04\x10\n" +
	" \x05R\x03val\"+\n" +
	"\fUInt32ExLTGT\x12\x1b\n" +
	"\x03val\x18\x01 \x01(\rB\t\xbaH\x06*\x04\x10\x05 \n" +
	"R\x03val\"-\n" +
	"\fUInt32GTELTE\x12\x1d\n" +
	"\x03val\x18\x01 \x01(\rB\v\xbaH\b*\x06\x18\x80\x02(\x80\x01R\x03val\"/\n" +
	"\x0eUInt32ExGTELTE\x12\x1d\n" +
	"\x03val\x18\x01 \x01(\rB\v\xbaH\b*\x06\x18\x80\x01(\x80\x02R\x03val\"0\n" +
	"\fUInt32Ignore\x12 \n" +
	"\x03val\x18\x01 \x01(\rB\x0e\xbaH\v\xd8\x01\x01*\x06\x18\x80\x02(\x80\x01R\x03val\"3\n" +
	"\x13UInt32IncorrectType\x12\x1c\n" +
	"\x03val\x18\x01 \x01(\rB\n" +
	"\xbaH\a\n" +
	"\x05%\x00\x00\x00\x00R\x03val\"*\n" +
	"\rUInt32Example\x12\x19\n" +
	"\x03val\x18\x01 \x01(\rB\a\xbaH\x04*\x02@\x00R\x03val\"\x1e\n" +
	"\n" +
	"UInt64None\x12\x10\n" +
	"\x03val\x18\x01 \x01(\x04R\x03val\"(\n" +
	"\vUInt64Const\x12\x19\n" +
	"\x03val\x18\x01 \x01(\x04B\a\xbaH\x042\x02\b\x01R\x03val\"'\n" +
	"\bUInt64In\x12\x1b\n" +
	"\x03val\x18\x01 \x01(\x04B\t\xbaH\x062\x040\x020\x03R\x03val\"(\n" +
	"\vUInt64NotIn\x12\x19\n" +
	"\x03val\x18\x01 \x01(\x04B\a\xbaH\x042\x028\x00R\x03val\"%\n" +
	"\bUInt64LT\x12\x19\n" +
	"\x03val\x18\x01 \x01(\x04B\a\xbaH\x042\x02\x10\x05R\x03val\"&\n" +
	"\tUInt64LTE\x12\x19\n" +
	"\x03val\x18\x01 \x01(\x04B\a\xbaH\x042\x02\x18@R\x03val\"%\n" +
	"\bUInt64GT\x12\x19\n" +
	"\x03val\x18\x01 \x01(\x04B\a\xbaH\x042\x02 \x10R\x03val\"&\n" +
	"\tUInt64GTE\x12\x19\n" +
	"\x03val\x18\x01 \x01(\x04B\a\xbaH\x042\x02(\bR\x03val\")\n" +
	"\n" +
	"UInt64GTLT\x12\x1b\n" +
	"\x03val\x18\x01 \x01(\x04B\t\xbaH\x062\x04\x10\n" +
	" \x05R\x03val\"+\n" +
	"\fUInt64ExLTGT\x12\x1b\n" +
	"\x03val\x18\x01 \x01(\x04B\t\xbaH\x062\x04\x10\x05 \n" +
	"R\x03val\"-\n" +
	"\fUInt64GTELTE\x12\x1d\n" +
	"\x03val\x18\x01 \x01(\x04B\v\xbaH\b2\x06\x18\x80\x02(\x80\x01R\x03val\"/\n" +
	"\x0eUInt64ExGTELTE\x12\x1d\n" +
	"\x03val\x18\x01 \x01(\x04B\v\xbaH\b2\x06\x18\x80\x01(\x80\x02R\x03val\"0\n" +
	"\fUInt64Ignore\x12 \n" +
	"\x03val\x18\x01 \x01(\x04B\x0e\xbaH\v\xd8\x01\x012\x06\x18\x80\x02(\x80\x01R\x03val\"3\n" +
	"\x13UInt64IncorrectType\x12\x1c\n" +
	"\x03val\x18\x01 \x01(\x04B\n" +
	"\xbaH\a\n" +
	"\x05%\x00\x00\x00\x00R\x03val\"*\n" +
	"\rUInt64Example\x12\x19\n" +
	"\x03val\x18\x01 \x01(\x04B\a\xbaH\x042\x02@\x00R\x03val\"\x1e\n" +
	"\n" +
	"SInt32None\x12\x10\n" +
	"\x03val\x18\x01 \x01(\x11R\x03val\"(\n" +
	"\vSInt32Const\x12\x19\n" +
	"\x03val\x18\x01 \x01(\x11B\a\xbaH\x04:\x02\b\x02R\x03val\"'\n" +
	"\bSInt32In\x12\x1b\n" +
	"\x03val\x18\x01 \x01(\x11B\t\xbaH\x06:\x040\x040\x06R\x03val\"(\n" +
	"\vSInt32NotIn\x12\x19\n" +
	"\x03val\x18\x01 \x01(\x11B\a\xbaH\x04:\x028\x00R\x03val\"%\n" +
	"\bSInt32LT\x12\x19\n" +
	"\x03val\x18\x01 \x01(\x11B\a\xbaH\x04:\x02\x10\x00R\x03val\"'\n" +
	"\tSInt32LTE\x12\x1a\n" +
	"\x03val\x18\x01 \x01(\x11B\b\xbaH\x05:\x03\x18\x80\x01R\x03val\"%\n" +
	"\bSInt32GT\x12\x19\n" +
	"\x03val\x18\x01 \x01(\x11B\a\xbaH\x04:\x02  R\x03val\"&\n" +
	"\tSInt32GTE\x12\x19\n" +
	"\x03val\x18\x01 \x01(\x11B\a\xbaH\x04:\x02(\x10R\x03val\")\n" +
	"\n" +
	"SInt32GTLT\x12\x1b\n" +
	"\x03val\x18\x01 \x01(\x11B\t\xbaH\x06:\x04\x10\x14 \x00R\x03val\"+\n" +
	"\fSInt32ExLTGT\x12\x1b\n" +
	"\x03val\x18\x01 \x01(\x11B\t\xbaH\x06:\x04\x10\x00 \x14R\x03val\"-\n" +
	"\fSInt32GTELTE\x12\x1d\n" +
	"\x03val\x18\x01 \x01(\x11B\v\xbaH\b:\x06\x18\x80\x04(\x80\x02R\x03val\"/\n" +
	"\x0eSInt32ExGTELTE\x12\x1d\n" +
	"\x03val\x18\x01 \x01(\x11B\v\xbaH\b:\x06\x18\x80\x02(\x80\x04R\x03val\"0\n" +
	"\fSInt32Ignore\x12 \n" +
	"\x03val\x18\x01 \x01(\x11B\x0e\xbaH\v\xd8\x01\x01:\x06\x18\x80\x04(\x80\x02R\x03val\"3\n" +
	"\x13SInt32IncorrectType\x12\x1c\n" +
	"\x03val\x18\x01 \x01(\x11B\n" +
	"\xbaH\a\n" +
	"\x05%\x00\x00\x00\x00R\x03val\"*\n" +
	"\rSInt32Example\x12\x19\n" +
	"\x03val\x18\x01 \x01(\x11B\a\xbaH\x04:\x02@\x00R\x03val\"\x1e\n" +
	"\n" +
	"SInt64None\x12\x10\n" +
	"\x03val\x18\x01 \x01(\x12R\x03val\"(\n" +
	"\vSInt64Const\x12\x19\n" +
	"\x03val\x18\x01 \x01(\x12B\a\xbaH\x04B\x02\b\x02R\x03val\"'\n" +
	"\bSInt64In\x12\x1b\n" +
	"\x03val\x18\x01 \x01(\x12B\t\xbaH\x06B\x040\x040\x06R\x03val\"(\n" +
	"\vSInt64NotIn\x12\x19\n" +
	"\x03val\x18\x01 \x01(\x12B\a\xbaH\x04B\x028\x00R\x03val\"%\n" +
	"\bSInt64LT\x12\x19\n" +
	"\x03val\x18\x01 \x01(\x12B\a\xbaH\x04B\x02\x10\x00R\x03val\"'\n" +
	"\tSInt64LTE\x12\x1a\n" +
	"\x03val\x18\x01 \x01(\x12B\b\xbaH\x05B\x03\x18\x80\x01R\x03val\"%\n" +
	"\bSInt64GT\x12\x19\n" +
	"\x03val\x18\x01 \x01(\x12B\a\xbaH\x04B\x02  R\x03val\"&\n" +
	"\tSInt64GTE\x12\x19\n" +
	"\x03val\x18\x01 \x01(\x12B\a\xbaH\x04B\x02(\x10R\x03val\")\n" +
	"\n" +
	"SInt64GTLT\x12\x1b\n" +
	"\x03val\x18\x01 \x01(\x12B\t\xbaH\x06B\x04\x10\x14 \x00R\x03val\"+\n" +
	"\fSInt64ExLTGT\x12\x1b\n" +
	"\x03val\x18\x01 \x01(\x12B\t\xbaH\x06B\x04\x10\x00 \x14R\x03val\"-\n" +
	"\fSInt64GTELTE\x12\x1d\n" +
	"\x03val\x18\x01 \x01(\x12B\v\xbaH\bB\x06\x18\x80\x04(\x80\x02R\x03val\"/\n" +
	"\x0eSInt64ExGTELTE\x12\x1d\n" +
	"\x03val\x18\x01 \x01(\x12B\v\xbaH\bB\x06\x18\x80\x02(\x80\x04R\x03val\"0\n" +
	"\fSInt64Ignore\x12 \n" +
	"\x03val\x18\x01 \x01(\x12B\x0e\xbaH\v\xd8\x01\x01B\x06\x18\x80\x04(\x80\x02R\x03val\"3\n" +
	"\x13SInt64IncorrectType\x12\x1c\n" +
	"\x03val\x18\x01 \x01(\x12B\n" +
	"\xbaH\a\n" +
	"\x05%\x00\x00\x00\x00R\x03val\"*\n" +
	"\rSInt64Example\x12\x19\n" +
	"\x03val\x18\x01 \x01(\x12B\a\xbaH\x04B\x02@\x00R\x03val\"\x1f\n" +
	"\vFixed32None\x12\x10\n" +
	"\x03val\x18\x01 \x01(\aR\x03val\",\n" +
	"\fFixed32Const\x12\x1c\n" +
	"\x03val\x18\x01 \x01(\aB\n" +
	"\xbaH\aJ\x05\r\x01\x00\x00\x00R\x03val\".\n" +
	"\tFixed32In\x12!\n" +
	"\x03val\x18\x01 \x01(\aB\x0f\xbaH\fJ\n" +
	"5\x02\x00\x00\x005\x03\x00\x00\x00R\x03val\",\n" +
	"\fFixed32NotIn\x12\x1c\n" +
	"\x03val\x18\x01 \x01(\aB\n" +
	"\xbaH\aJ\x05=\x00\x00\x00\x00R\x03val\")\n" +
	"\tFixed32LT\x12\x1c\n" +
	"\x03val\x18\x01 \x01(\aB\n" +
	"\xbaH\aJ\x05\x15\x05\x00\x00\x00R\x03val\"*\n" +
	"\n" +
	"Fixed32LTE\x12\x1c\n" +
	"\x03val\x18\x01 \x01(\aB\n" +
	"\xbaH\aJ\x05\x1d@\x00\x00\x00R\x03val\")\n" +
	"\tFixed32GT\x12\x1c\n" +
	"\x03val\x18\x01 \x01(\aB\n" +
	"\xbaH\aJ\x05%\x10\x00\x00\x00R\x03val\"*\n" +
	"\n" +
	"Fixed32GTE\x12\x1c\n" +
	"\x03val\x18\x01 \x01(\aB\n" +
	"\xbaH\aJ\x05-\b\x00\x00\x00R\x03val\"0\n" +
	"\vFixed32GTLT\x12!\n" +
	"\x03val\x18\x01 \x01(\aB\x0f\xbaH\fJ\n" +
	"\x15\n" +
	"\x00\x00\x00%\x05\x00\x00\x00R\x03val\"2\n" +
	"\rFixed32ExLTGT\x12!\n" +
	"\x03val\x18\x01 \x01(\aB\x0f\xbaH\fJ\n" +
	"\x15\x05\x00\x00\x00%\n" +
	"\x00\x00\x00R\x03val\"2\n" +
	"\rFixed32GTELTE\x12!\n" +
	"\x03val\x18\x01 \x01(\aB\x0f\xbaH\fJ\n" +
	"\x1d\x00\x01\x00\x00-\x80\x00\x00\x00R\x03val\"4\n" +
	"\x0fFixed32ExGTELTE\x12!\n" +
	"\x03val\x18\x01 \x01(\aB\x0f\xbaH\fJ\n" +
	"\x1d\x80\x00\x00\x00-\x00\x01\x00\x00R\x03val\"5\n" +
	"\rFixed32Ignore\x12$\n" +
	"\x03val\x18\x01 \x01(\aB\x12\xbaH\x0f\xd8\x01\x01J\n" +
	"\x1d\x00\x01\x00\x00-\x80\x00\x00\x00R\x03val\"4\n" +
	"\x14Fixed32IncorrectType\x12\x1c\n" +
	"\x03val\x18\x01 \x01(\aB\n" +
	"\xbaH\a\n" +
	"\x05%\x00\x00\x00\x00R\x03val\".\n" +
	"\x0eFixed32Example\x12\x1c\n" +
	"\x03val\x18\x01 \x01(\aB\n" +
	"\xbaH\aJ\x05E\x00\x00\x00\x00R\x03val\"\x1f\n" +
	"\vFixed64None\x12\x10\n" +
	"\x03val\x18\x01 \x01(\x06R\x03val\"0\n" +
	"\fFixed64Const\x12 \n" +
	"\x03val\x18\x01 \x01(\x06B\x0e\xbaH\vR\t\t\x01\x00\x00\x00\x00\x00\x00\x00R\x03val\"6\n" +
	"\tFixed64In\x12)\n" +
	"\x03val\x18\x01 \x01(\x06B\x17\xbaH\x14R\x121\x02\x00\x00\x00\x00\x00\x00\x001\x03\x00\x00\x00\x00\x00\x00\x00R\x03val\"0\n" +
	"\fFixed64NotIn\x12 \n" +
	"\x03val\x18\x01 \x01(\x06B\x0e\xbaH\vR\t9\x00\x00\x00\x00\x00\x00\x00\x00R\x03val\"-\n" +
	"\tFixed64LT\x12 \n" +
	"\x03val\x18\x01 \x01(\x06B\x0e\xbaH\vR\t\x11\x05\x00\x00\x00\x00\x00\x00\x00R\x03val\".\n" +
	"\n" +
	"Fixed64LTE\x12 \n" +
	"\x03val\x18\x01 \x01(\x06B\x0e\xbaH\vR\t\x19@\x00\x00\x00\x00\x00\x00\x00R\x03val\"-\n" +
	"\tFixed64GT\x12 \n" +
	"\x03val\x18\x01 \x01(\x06B\x0e\xbaH\vR\t!\x10\x00\x00\x00\x00\x00\x00\x00R\x03val\".\n" +
	"\n" +
	"Fixed64GTE\x12 \n" +
	"\x03val\x18\x01 \x01(\x06B\x0e\xbaH\vR\t)\b\x00\x00\x00\x00\x00\x00\x00R\x03val\"8\n" +
	"\vFixed64GTLT\x12)\n" +
	"\x03val\x18\x01 \x01(\x06B\x17\xbaH\x14R\x12\x11\n" +
	"\x00\x00\x00\x00\x00\x00\x00!\x05\x00\x00\x00\x00\x00\x00\x00R\x03val\":\n" +
	"\rFixed64ExLTGT\x12)\n" +
	"\x03val\x18\x01 \x01(\x06B\x17\xbaH\x14R\x12\x11\x05\x00\x00\x00\x00\x00\x00\x00!\n" +
	"\x00\x00\x00\x00\x00\x00\x00R\x03val\":\n" +
	"\rFixed64GTELTE\x12)\n" +
	"\x03val\x18\x01 \x01(\x06B\x17\xbaH\x14R\x12\x19\x00\x01\x00\x00\x00\x00\x00\x00)\x80\x00\x00\x00\x00\x00\x00\x00R\x03val\"<\n" +
	"\x0fFixed64ExGTELTE\x12)\n" +
	"\x03val\x18\x01 \x01(\x06B\x17\xbaH\x14R\x12\x19\x80\x00\x00\x00\x00\x00\x00\x00)\x00\x01\x00\x00\x00\x00\x00\x00R\x03val\"=\n" +
	"\rFixed64Ignore\x12,\n" +
	"\x03val\x18\x01 \x01(\x06B\x1a\xbaH\x17\xd8\x01\x01R\x12\x19\x00\x01\x00\x00\x00\x00\x00\x00)\x80\x00\x00\x00\x00\x00\x00\x00R\x03val\"4\n" +
	"\x14Fixed64IncorrectType\x12\x1c\n" +
	"\x03val\x18\x01 \x01(\x06B\n" +
	"\xbaH\a\n" +
	"\x05%\x00\x00\x00\x00R\x03val\"2\n" +
	"\x0eFixed64Example\x12 \n" +
	"\x03val\x18\x01 \x01(\x06B\x0e\xbaH\vR\tA\x00\x00\x00\x00\x00\x00\x00\x00R\x03val\" \n" +
	"\fSFixed32None\x12\x10\n" +
	"\x03val\x18\x01 \x01(\x0fR\x03val\"-\n" +
	"\rSFixed32Const\x12\x1c\n" +
	"\x03val\x18\x01 \x01(\x0fB\n" +
	"\xbaH\aZ\x05\r\x01\x00\x00\x00R\x03val\"/\n" +
	"\n" +
	"SFixed32In\x12!\n" +
	"\x03val\x18\x01 \x01(\x0fB\x0f\xbaH\fZ\n" +
	"5\x02\x00\x00\x005\x03\x00\x00\x00R\x03val\"-\n" +
	"\rSFixed32NotIn\x12\x1c\n" +
	"\x03val\x18\x01 \x01(\x0fB\n" +
	"\xbaH\aZ\x05=\x00\x00\x00\x00R\x03val\"*\n" +
	"\n" +
	"SFixed32LT\x12\x1c\n" +
	"\x03val\x18\x01 \x01(\x0fB\n" +
	"\xbaH\aZ\x05\x15\x00\x00\x00\x00R\x03val\"+\n" +
	"\vSFixed32LTE\x12\x1c\n" +
	"\x03val\x18\x01 \x01(\x0fB\n" +
	"\xbaH\aZ\x05\x1d@\x00\x00\x00R\x03val\"*\n" +
	"\n" +
	"SFixed32GT\x12\x1c\n" +
	"\x03val\x18\x01 \x01(\x0fB\n" +
	"\xbaH\aZ\x05%\x10\x00\x00\x00R\x03val\"+\n" +
	"\vSFixed32GTE\x12\x1c\n" +
	"\x03val\x18\x01 \x01(\x0fB\n" +
	"\xbaH\aZ\x05-\b\x00\x00\x00R\x03val\"1\n" +
	"\fSFixed32GTLT\x12!\n" +
	"\x03val\x18\x01 \x01(\x0fB\x0f\xbaH\fZ\n" +
	"\x15\n" +
	"\x00\x00\x00%\x00\x00\x00\x00R\x03val\"3\n" +
	"\x0eSFixed32ExLTGT\x12!\n" +
	"\x03val\x18\x01 \x01(\x0fB\x0f\xbaH\fZ\n" +
	"\x15\x00\x00\x00\x00%\n" +
	"\x00\x00\x00R\x03val\"3\n" +
	"\x0eSFixed32GTELTE\x12!\n" +
	"\x03val\x18\x01 \x01(\x0fB\x0f\xbaH\fZ\n" +
	"\x1d\x00\x01\x00\x00-\x80\x00\x00\x00R\x03val\"5\n" +
	"\x10SFixed32ExGTELTE\x12!\n" +
	"\x03val\x18\x01 \x01(\x0fB\x0f\xbaH\fZ\n" +
	"\x1d\x80\x00\x00\x00-\x00\x01\x00\x00R\x03val\"6\n" +
	"\x0eSFixed32Ignore\x12$\n" +
	"\x03val\x18\x01 \x01(\x0fB\x12\xbaH\x0f\xd8\x01\x01Z\n" +
	"\x1d\x00\x01\x00\x00-\x80\x00\x00\x00R\x03val\"5\n" +
	"\x15SFixed32IncorrectType\x12\x1c\n" +
	"\x03val\x18\x01 \x01(\x0fB\n" +
	"\xbaH\a\n" +
	"\x05%\x00\x00\x00\x00R\x03val\"/\n" +
	"\x0fSFixed32Example\x12\x1c\n" +
	"\x03val\x18\x01 \x01(\x0fB\n" +
	"\xbaH\aZ\x05E\x00\x00\x00\x00R\x03val\" \n" +
	"\fSFixed64None\x12\x10\n" +
	"\x03val\x18\x01 \x01(\x10R\x03val\"1\n" +
	"\rSFixed64Const\x12 \n" +
	"\x03val\x18\x01 \x01(\x10B\x0e\xbaH\vb\t\t\x01\x00\x00\x00\x00\x00\x00\x00R\x03val\"7\n" +
	"\n" +
	"SFixed64In\x12)\n" +
	"\x03val\x18\x01 \x01(\x10B\x17\xbaH\x14b\x121\x02\x00\x00\x00\x00\x00\x00\x001\x03\x00\x00\x00\x00\x00\x00\x00R\x03val\"1\n" +
	"\rSFixed64NotIn\x12 \n" +
	"\x03val\x18\x01 \x01(\x10B\x0e\xbaH\vb\t9\x00\x00\x00\x00\x00\x00\x00\x00R\x03val\".\n" +
	"\n" +
	"SFixed64LT\x12 \n" +
	"\x03val\x18\x01 \x01(\x10B\x0e\xbaH\vb\t\x11\x00\x00\x00\x00\x00\x00\x00\x00R\x03val\"/\n" +
	"\vSFixed64LTE\x12 \n" +
	"\x03val\x18\x01 \x01(\x10B\x0e\xbaH\vb\t\x19@\x00\x00\x00\x00\x00\x00\x00R\x03val\".\n" +
	"\n" +
	"SFixed64GT\x12 \n" +
	"\x03val\x18\x01 \x01(\x10B\x0e\xbaH\vb\t!\x10\x00\x00\x00\x00\x00\x00\x00R\x03val\"/\n" +
	"\vSFixed64GTE\x12 \n" +
	"\x03val\x18\x01 \x01(\x10B\x0e\xbaH\vb\t)\b\x00\x00\x00\x00\x00\x00\x00R\x03val\"9\n" +
	"\fSFixed64GTLT\x12)\n" +
	"\x03val\x18\x01 \x01(\x10B\x17\xbaH\x14b\x12\x11\n" +
	"\x00\x00\x00\x00\x00\x00\x00!\x00\x00\x00\x00\x00\x00\x00\x00R\x03val\";\n" +
	"\x0eSFixed64ExLTGT\x12)\n" +
	"\x03val\x18\x01 \x01(\x10B\x17\xbaH\x14b\x12\x11\x00\x00\x00\x00\x00\x00\x00\x00!\n" +
	"\x00\x00\x00\x00\x00\x00\x00R\x03val\";\n" +
	"\x0eSFixed64GTELTE\x12)\n" +
	"\x03val\x18\x01 \x01(\x10B\x17\xbaH\x14b\x12\x19\x00\x01\x00\x00\x00\x00\x00\x00)\x80\x00\x00\x00\x00\x00\x00\x00R\x03val\"=\n" +
	"\x10SFixed64ExGTELTE\x12)\n" +
	"\x03val\x18\x01 \x01(\x10B\x17\xbaH\x14b\x12\x19\x80\x00\x00\x00\x00\x00\x00\x00)\x00\x01\x00\x00\x00\x00\x00\x00R\x03val\">\n" +
	"\x0eSFixed64Ignore\x12,\n" +
	"\x03val\x18\x01 \x01(\x10B\x1a\xbaH\x17\xd8\x01\x01b\x12\x19\x00\x01\x00\x00\x00\x00\x00\x00)\x80\x00\x00\x00\x00\x00\x00\x00R\x03val\"5\n" +
	"\x15SFixed64IncorrectType\x12\x1c\n" +
	"\x03val\x18\x01 \x01(\x10B\n" +
	"\xbaH\a\n" +
	"\x05%\x00\x00\x00\x00R\x03val\"3\n" +
	"\x0fSFixed64Example\x12 \n" +
	"\x03val\x18\x01 \x01(\x10B\x0e\xbaH\vb\tA\x00\x00\x00\x00\x00\x00\x00\x00R\x03val\":\n" +
	"\x10Int64LTEOptional\x12\x1e\n" +
	"\x03val\x18\x01 \x01(\x03B\a\xbaH\x04\"\x02\x18@H\x00R\x03val\x88\x01\x01B\x06\n" +
	"\x04_valB\x96\x02\n" +
	"\"com.buf.validate.conformance.casesB\fNumbersProtoP\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_numbers_proto_msgTypes = make([]protoimpl.MessageInfo, 186)
var file_buf_validate_conformance_cases_numbers_proto_goTypes = []any{
	(*FloatNone)(nil),             // 0: buf.validate.conformance.cases.FloatNone
	(*FloatConst)(nil),            // 1: buf.validate.conformance.cases.FloatConst
	(*FloatIn)(nil),               // 2: buf.validate.conformance.cases.FloatIn
	(*FloatNotIn)(nil),            // 3: buf.validate.conformance.cases.FloatNotIn
	(*FloatLT)(nil),               // 4: buf.validate.conformance.cases.FloatLT
	(*FloatLTE)(nil),              // 5: buf.validate.conformance.cases.FloatLTE
	(*FloatGT)(nil),               // 6: buf.validate.conformance.cases.FloatGT
	(*FloatGTE)(nil),              // 7: buf.validate.conformance.cases.FloatGTE
	(*FloatGTLT)(nil),             // 8: buf.validate.conformance.cases.FloatGTLT
	(*FloatExLTGT)(nil),           // 9: buf.validate.conformance.cases.FloatExLTGT
	(*FloatGTELTE)(nil),           // 10: buf.validate.conformance.cases.FloatGTELTE
	(*FloatExGTELTE)(nil),         // 11: buf.validate.conformance.cases.FloatExGTELTE
	(*FloatFinite)(nil),           // 12: buf.validate.conformance.cases.FloatFinite
	(*FloatNotFinite)(nil),        // 13: buf.validate.conformance.cases.FloatNotFinite
	(*FloatIgnore)(nil),           // 14: buf.validate.conformance.cases.FloatIgnore
	(*FloatIncorrectType)(nil),    // 15: buf.validate.conformance.cases.FloatIncorrectType
	(*FloatExample)(nil),          // 16: buf.validate.conformance.cases.FloatExample
	(*DoubleNone)(nil),            // 17: buf.validate.conformance.cases.DoubleNone
	(*DoubleConst)(nil),           // 18: buf.validate.conformance.cases.DoubleConst
	(*DoubleIn)(nil),              // 19: buf.validate.conformance.cases.DoubleIn
	(*DoubleNotIn)(nil),           // 20: buf.validate.conformance.cases.DoubleNotIn
	(*DoubleLT)(nil),              // 21: buf.validate.conformance.cases.DoubleLT
	(*DoubleLTE)(nil),             // 22: buf.validate.conformance.cases.DoubleLTE
	(*DoubleGT)(nil),              // 23: buf.validate.conformance.cases.DoubleGT
	(*DoubleGTE)(nil),             // 24: buf.validate.conformance.cases.DoubleGTE
	(*DoubleGTLT)(nil),            // 25: buf.validate.conformance.cases.DoubleGTLT
	(*DoubleExLTGT)(nil),          // 26: buf.validate.conformance.cases.DoubleExLTGT
	(*DoubleGTELTE)(nil),          // 27: buf.validate.conformance.cases.DoubleGTELTE
	(*DoubleExGTELTE)(nil),        // 28: buf.validate.conformance.cases.DoubleExGTELTE
	(*DoubleFinite)(nil),          // 29: buf.validate.conformance.cases.DoubleFinite
	(*DoubleNotFinite)(nil),       // 30: buf.validate.conformance.cases.DoubleNotFinite
	(*DoubleIgnore)(nil),          // 31: buf.validate.conformance.cases.DoubleIgnore
	(*DoubleIncorrectType)(nil),   // 32: buf.validate.conformance.cases.DoubleIncorrectType
	(*DoubleExample)(nil),         // 33: buf.validate.conformance.cases.DoubleExample
	(*Int32None)(nil),             // 34: buf.validate.conformance.cases.Int32None
	(*Int32Const)(nil),            // 35: buf.validate.conformance.cases.Int32Const
	(*Int32In)(nil),               // 36: buf.validate.conformance.cases.Int32In
	(*Int32NotIn)(nil),            // 37: buf.validate.conformance.cases.Int32NotIn
	(*Int32LT)(nil),               // 38: buf.validate.conformance.cases.Int32LT
	(*Int32LTE)(nil),              // 39: buf.validate.conformance.cases.Int32LTE
	(*Int32GT)(nil),               // 40: buf.validate.conformance.cases.Int32GT
	(*Int32GTE)(nil),              // 41: buf.validate.conformance.cases.Int32GTE
	(*Int32GTLT)(nil),             // 42: buf.validate.conformance.cases.Int32GTLT
	(*Int32ExLTGT)(nil),           // 43: buf.validate.conformance.cases.Int32ExLTGT
	(*Int32GTELTE)(nil),           // 44: buf.validate.conformance.cases.Int32GTELTE
	(*Int32ExGTELTE)(nil),         // 45: buf.validate.conformance.cases.Int32ExGTELTE
	(*Int32Ignore)(nil),           // 46: buf.validate.conformance.cases.Int32Ignore
	(*Int32IncorrectType)(nil),    // 47: buf.validate.conformance.cases.Int32IncorrectType
	(*Int32Example)(nil),          // 48: buf.validate.conformance.cases.Int32Example
	(*Int64None)(nil),             // 49: buf.validate.conformance.cases.Int64None
	(*Int64Const)(nil),            // 50: buf.validate.conformance.cases.Int64Const
	(*Int64In)(nil),               // 51: buf.validate.conformance.cases.Int64In
	(*Int64NotIn)(nil),            // 52: buf.validate.conformance.cases.Int64NotIn
	(*Int64LT)(nil),               // 53: buf.validate.conformance.cases.Int64LT
	(*Int64LTE)(nil),              // 54: buf.validate.conformance.cases.Int64LTE
	(*Int64GT)(nil),               // 55: buf.validate.conformance.cases.Int64GT
	(*Int64GTE)(nil),              // 56: buf.validate.conformance.cases.Int64GTE
	(*Int64GTLT)(nil),             // 57: buf.validate.conformance.cases.Int64GTLT
	(*Int64ExLTGT)(nil),           // 58: buf.validate.conformance.cases.Int64ExLTGT
	(*Int64GTELTE)(nil),           // 59: buf.validate.conformance.cases.Int64GTELTE
	(*Int64ExGTELTE)(nil),         // 60: buf.validate.conformance.cases.Int64ExGTELTE
	(*Int64Ignore)(nil),           // 61: buf.validate.conformance.cases.Int64Ignore
	(*Int64BigRules)(nil),         // 62: buf.validate.conformance.cases.Int64BigRules
	(*Int64IncorrectType)(nil),    // 63: buf.validate.conformance.cases.Int64IncorrectType
	(*Int64Example)(nil),          // 64: buf.validate.conformance.cases.Int64Example
	(*UInt32None)(nil),            // 65: buf.validate.conformance.cases.UInt32None
	(*UInt32Const)(nil),           // 66: buf.validate.conformance.cases.UInt32Const
	(*UInt32In)(nil),              // 67: buf.validate.conformance.cases.UInt32In
	(*UInt32NotIn)(nil),           // 68: buf.validate.conformance.cases.UInt32NotIn
	(*UInt32LT)(nil),              // 69: buf.validate.conformance.cases.UInt32LT
	(*UInt32LTE)(nil),             // 70: buf.validate.conformance.cases.UInt32LTE
	(*UInt32GT)(nil),              // 71: buf.validate.conformance.cases.UInt32GT
	(*UInt32GTE)(nil),             // 72: buf.validate.conformance.cases.UInt32GTE
	(*UInt32GTLT)(nil),            // 73: buf.validate.conformance.cases.UInt32GTLT
	(*UInt32ExLTGT)(nil),          // 74: buf.validate.conformance.cases.UInt32ExLTGT
	(*UInt32GTELTE)(nil),          // 75: buf.validate.conformance.cases.UInt32GTELTE
	(*UInt32ExGTELTE)(nil),        // 76: buf.validate.conformance.cases.UInt32ExGTELTE
	(*UInt32Ignore)(nil),          // 77: buf.validate.conformance.cases.UInt32Ignore
	(*UInt32IncorrectType)(nil),   // 78: buf.validate.conformance.cases.UInt32IncorrectType
	(*UInt32Example)(nil),         // 79: buf.validate.conformance.cases.UInt32Example
	(*UInt64None)(nil),            // 80: buf.validate.conformance.cases.UInt64None
	(*UInt64Const)(nil),           // 81: buf.validate.conformance.cases.UInt64Const
	(*UInt64In)(nil),              // 82: buf.validate.conformance.cases.UInt64In
	(*UInt64NotIn)(nil),           // 83: buf.validate.conformance.cases.UInt64NotIn
	(*UInt64LT)(nil),              // 84: buf.validate.conformance.cases.UInt64LT
	(*UInt64LTE)(nil),             // 85: buf.validate.conformance.cases.UInt64LTE
	(*UInt64GT)(nil),              // 86: buf.validate.conformance.cases.UInt64GT
	(*UInt64GTE)(nil),             // 87: buf.validate.conformance.cases.UInt64GTE
	(*UInt64GTLT)(nil),            // 88: buf.validate.conformance.cases.UInt64GTLT
	(*UInt64ExLTGT)(nil),          // 89: buf.validate.conformance.cases.UInt64ExLTGT
	(*UInt64GTELTE)(nil),          // 90: buf.validate.conformance.cases.UInt64GTELTE
	(*UInt64ExGTELTE)(nil),        // 91: buf.validate.conformance.cases.UInt64ExGTELTE
	(*UInt64Ignore)(nil),          // 92: buf.validate.conformance.cases.UInt64Ignore
	(*UInt64IncorrectType)(nil),   // 93: buf.validate.conformance.cases.UInt64IncorrectType
	(*UInt64Example)(nil),         // 94: buf.validate.conformance.cases.UInt64Example
	(*SInt32None)(nil),            // 95: buf.validate.conformance.cases.SInt32None
	(*SInt32Const)(nil),           // 96: buf.validate.conformance.cases.SInt32Const
	(*SInt32In)(nil),              // 97: buf.validate.conformance.cases.SInt32In
	(*SInt32NotIn)(nil),           // 98: buf.validate.conformance.cases.SInt32NotIn
	(*SInt32LT)(nil),              // 99: buf.validate.conformance.cases.SInt32LT
	(*SInt32LTE)(nil),             // 100: buf.validate.conformance.cases.SInt32LTE
	(*SInt32GT)(nil),              // 101: buf.validate.conformance.cases.SInt32GT
	(*SInt32GTE)(nil),             // 102: buf.validate.conformance.cases.SInt32GTE
	(*SInt32GTLT)(nil),            // 103: buf.validate.conformance.cases.SInt32GTLT
	(*SInt32ExLTGT)(nil),          // 104: buf.validate.conformance.cases.SInt32ExLTGT
	(*SInt32GTELTE)(nil),          // 105: buf.validate.conformance.cases.SInt32GTELTE
	(*SInt32ExGTELTE)(nil),        // 106: buf.validate.conformance.cases.SInt32ExGTELTE
	(*SInt32Ignore)(nil),          // 107: buf.validate.conformance.cases.SInt32Ignore
	(*SInt32IncorrectType)(nil),   // 108: buf.validate.conformance.cases.SInt32IncorrectType
	(*SInt32Example)(nil),         // 109: buf.validate.conformance.cases.SInt32Example
	(*SInt64None)(nil),            // 110: buf.validate.conformance.cases.SInt64None
	(*SInt64Const)(nil),           // 111: buf.validate.conformance.cases.SInt64Const
	(*SInt64In)(nil),              // 112: buf.validate.conformance.cases.SInt64In
	(*SInt64NotIn)(nil),           // 113: buf.validate.conformance.cases.SInt64NotIn
	(*SInt64LT)(nil),              // 114: buf.validate.conformance.cases.SInt64LT
	(*SInt64LTE)(nil),             // 115: buf.validate.conformance.cases.SInt64LTE
	(*SInt64GT)(nil),              // 116: buf.validate.conformance.cases.SInt64GT
	(*SInt64GTE)(nil),             // 117: buf.validate.conformance.cases.SInt64GTE
	(*SInt64GTLT)(nil),            // 118: buf.validate.conformance.cases.SInt64GTLT
	(*SInt64ExLTGT)(nil),          // 119: buf.validate.conformance.cases.SInt64ExLTGT
	(*SInt64GTELTE)(nil),          // 120: buf.validate.conformance.cases.SInt64GTELTE
	(*SInt64ExGTELTE)(nil),        // 121: buf.validate.conformance.cases.SInt64ExGTELTE
	(*SInt64Ignore)(nil),          // 122: buf.validate.conformance.cases.SInt64Ignore
	(*SInt64IncorrectType)(nil),   // 123: buf.validate.conformance.cases.SInt64IncorrectType
	(*SInt64Example)(nil),         // 124: buf.validate.conformance.cases.SInt64Example
	(*Fixed32None)(nil),           // 125: buf.validate.conformance.cases.Fixed32None
	(*Fixed32Const)(nil),          // 126: buf.validate.conformance.cases.Fixed32Const
	(*Fixed32In)(nil),             // 127: buf.validate.conformance.cases.Fixed32In
	(*Fixed32NotIn)(nil),          // 128: buf.validate.conformance.cases.Fixed32NotIn
	(*Fixed32LT)(nil),             // 129: buf.validate.conformance.cases.Fixed32LT
	(*Fixed32LTE)(nil),            // 130: buf.validate.conformance.cases.Fixed32LTE
	(*Fixed32GT)(nil),             // 131: buf.validate.conformance.cases.Fixed32GT
	(*Fixed32GTE)(nil),            // 132: buf.validate.conformance.cases.Fixed32GTE
	(*Fixed32GTLT)(nil),           // 133: buf.validate.conformance.cases.Fixed32GTLT
	(*Fixed32ExLTGT)(nil),         // 134: buf.validate.conformance.cases.Fixed32ExLTGT
	(*Fixed32GTELTE)(nil),         // 135: buf.validate.conformance.cases.Fixed32GTELTE
	(*Fixed32ExGTELTE)(nil),       // 136: buf.validate.conformance.cases.Fixed32ExGTELTE
	(*Fixed32Ignore)(nil),         // 137: buf.validate.conformance.cases.Fixed32Ignore
	(*Fixed32IncorrectType)(nil),  // 138: buf.validate.conformance.cases.Fixed32IncorrectType
	(*Fixed32Example)(nil),        // 139: buf.validate.conformance.cases.Fixed32Example
	(*Fixed64None)(nil),           // 140: buf.validate.conformance.cases.Fixed64None
	(*Fixed64Const)(nil),          // 141: buf.validate.conformance.cases.Fixed64Const
	(*Fixed64In)(nil),             // 142: buf.validate.conformance.cases.Fixed64In
	(*Fixed64NotIn)(nil),          // 143: buf.validate.conformance.cases.Fixed64NotIn
	(*Fixed64LT)(nil),             // 144: buf.validate.conformance.cases.Fixed64LT
	(*Fixed64LTE)(nil),            // 145: buf.validate.conformance.cases.Fixed64LTE
	(*Fixed64GT)(nil),             // 146: buf.validate.conformance.cases.Fixed64GT
	(*Fixed64GTE)(nil),            // 147: buf.validate.conformance.cases.Fixed64GTE
	(*Fixed64GTLT)(nil),           // 148: buf.validate.conformance.cases.Fixed64GTLT
	(*Fixed64ExLTGT)(nil),         // 149: buf.validate.conformance.cases.Fixed64ExLTGT
	(*Fixed64GTELTE)(nil),         // 150: buf.validate.conformance.cases.Fixed64GTELTE
	(*Fixed64ExGTELTE)(nil),       // 151: buf.validate.conformance.cases.Fixed64ExGTELTE
	(*Fixed64Ignore)(nil),         // 152: buf.validate.conformance.cases.Fixed64Ignore
	(*Fixed64IncorrectType)(nil),  // 153: buf.validate.conformance.cases.Fixed64IncorrectType
	(*Fixed64Example)(nil),        // 154: buf.validate.conformance.cases.Fixed64Example
	(*SFixed32None)(nil),          // 155: buf.validate.conformance.cases.SFixed32None
	(*SFixed32Const)(nil),         // 156: buf.validate.conformance.cases.SFixed32Const
	(*SFixed32In)(nil),            // 157: buf.validate.conformance.cases.SFixed32In
	(*SFixed32NotIn)(nil),         // 158: buf.validate.conformance.cases.SFixed32NotIn
	(*SFixed32LT)(nil),            // 159: buf.validate.conformance.cases.SFixed32LT
	(*SFixed32LTE)(nil),           // 160: buf.validate.conformance.cases.SFixed32LTE
	(*SFixed32GT)(nil),            // 161: buf.validate.conformance.cases.SFixed32GT
	(*SFixed32GTE)(nil),           // 162: buf.validate.conformance.cases.SFixed32GTE
	(*SFixed32GTLT)(nil),          // 163: buf.validate.conformance.cases.SFixed32GTLT
	(*SFixed32ExLTGT)(nil),        // 164: buf.validate.conformance.cases.SFixed32ExLTGT
	(*SFixed32GTELTE)(nil),        // 165: buf.validate.conformance.cases.SFixed32GTELTE
	(*SFixed32ExGTELTE)(nil),      // 166: buf.validate.conformance.cases.SFixed32ExGTELTE
	(*SFixed32Ignore)(nil),        // 167: buf.validate.conformance.cases.SFixed32Ignore
	(*SFixed32IncorrectType)(nil), // 168: buf.validate.conformance.cases.SFixed32IncorrectType
	(*SFixed32Example)(nil),       // 169: buf.validate.conformance.cases.SFixed32Example
	(*SFixed64None)(nil),          // 170: buf.validate.conformance.cases.SFixed64None
	(*SFixed64Const)(nil),         // 171: buf.validate.conformance.cases.SFixed64Const
	(*SFixed64In)(nil),            // 172: buf.validate.conformance.cases.SFixed64In
	(*SFixed64NotIn)(nil),         // 173: buf.validate.conformance.cases.SFixed64NotIn
	(*SFixed64LT)(nil),            // 174: buf.validate.conformance.cases.SFixed64LT
	(*SFixed64LTE)(nil),           // 175: buf.validate.conformance.cases.SFixed64LTE
	(*SFixed64GT)(nil),            // 176: buf.validate.conformance.cases.SFixed64GT
	(*SFixed64GTE)(nil),           // 177: buf.validate.conformance.cases.SFixed64GTE
	(*SFixed64GTLT)(nil),          // 178: buf.validate.conformance.cases.SFixed64GTLT
	(*SFixed64ExLTGT)(nil),        // 179: buf.validate.conformance.cases.SFixed64ExLTGT
	(*SFixed64GTELTE)(nil),        // 180: buf.validate.conformance.cases.SFixed64GTELTE
	(*SFixed64ExGTELTE)(nil),      // 181: buf.validate.conformance.cases.SFixed64ExGTELTE
	(*SFixed64Ignore)(nil),        // 182: buf.validate.conformance.cases.SFixed64Ignore
	(*SFixed64IncorrectType)(nil), // 183: buf.validate.conformance.cases.SFixed64IncorrectType
	(*SFixed64Example)(nil),       // 184: buf.validate.conformance.cases.SFixed64Example
	(*Int64LTEOptional)(nil),      // 185: buf.validate.conformance.cases.Int64LTEOptional
}
var file_buf_validate_conformance_cases_numbers_proto_depIdxs = []int32{
	0, // [0:0] is the sub-list for method output_type
	0, // [0:0] is the sub-list for method input_type
	0, // [0:0] is the sub-list for extension type_name
	0, // [0:0] is the sub-list for extension extendee
	0, // [0:0] is the sub-list for field type_name
}

func init() { file_buf_validate_conformance_cases_numbers_proto_init() }
func file_buf_validate_conformance_cases_numbers_proto_init() {
	if File_buf_validate_conformance_cases_numbers_proto != nil {
		return
	}
	file_buf_validate_conformance_cases_numbers_proto_msgTypes[185].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_numbers_proto_rawDesc), len(file_buf_validate_conformance_cases_numbers_proto_rawDesc)),
			NumEnums:      0,
			NumMessages:   186,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_buf_validate_conformance_cases_numbers_proto_goTypes,
		DependencyIndexes: file_buf_validate_conformance_cases_numbers_proto_depIdxs,
		MessageInfos:      file_buf_validate_conformance_cases_numbers_proto_msgTypes,
	}.Build()
	File_buf_validate_conformance_cases_numbers_proto = out.File
	file_buf_validate_conformance_cases_numbers_proto_goTypes = nil
	file_buf_validate_conformance_cases_numbers_proto_depIdxs = nil
}
