// Copyright 2024 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Test Protobuf definitions with proto2 syntax.

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: internal/testprotos/textpbeditions/textpbeditions_hybrid/test2.hybrid.proto

//go:build !protoopaque

package textpbeditions_hybrid

import (
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	_ "google.golang.org/protobuf/types/gofeaturespb"
	anypb "google.golang.org/protobuf/types/known/anypb"
	durationpb "google.golang.org/protobuf/types/known/durationpb"
	emptypb "google.golang.org/protobuf/types/known/emptypb"
	fieldmaskpb "google.golang.org/protobuf/types/known/fieldmaskpb"
	structpb "google.golang.org/protobuf/types/known/structpb"
	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
	wrapperspb "google.golang.org/protobuf/types/known/wrapperspb"
	reflect "reflect"
	unsafe "unsafe"
)

type Enum int32

const (
	Enum_ONE Enum = 1
	Enum_TWO Enum = 2
	Enum_TEN Enum = 10
)

// Enum value maps for Enum.
var (
	Enum_name = map[int32]string{
		1:  "ONE",
		2:  "TWO",
		10: "TEN",
	}
	Enum_value = map[string]int32{
		"ONE": 1,
		"TWO": 2,
		"TEN": 10,
	}
)

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

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

func (Enum) Descriptor() protoreflect.EnumDescriptor {
	return file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_proto_enumTypes[0].Descriptor()
}

func (Enum) Type() protoreflect.EnumType {
	return &file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_proto_enumTypes[0]
}

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

type OpenEnum int32

const (
	OpenEnum_UNKNOWN OpenEnum = 0
	OpenEnum_EINS    OpenEnum = 1
	OpenEnum_ZWEI    OpenEnum = 2
	OpenEnum_ZEHN    OpenEnum = 10
)

// Enum value maps for OpenEnum.
var (
	OpenEnum_name = map[int32]string{
		0:  "UNKNOWN",
		1:  "EINS",
		2:  "ZWEI",
		10: "ZEHN",
	}
	OpenEnum_value = map[string]int32{
		"UNKNOWN": 0,
		"EINS":    1,
		"ZWEI":    2,
		"ZEHN":    10,
	}
)

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

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

func (OpenEnum) Descriptor() protoreflect.EnumDescriptor {
	return file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_proto_enumTypes[1].Descriptor()
}

func (OpenEnum) Type() protoreflect.EnumType {
	return &file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_proto_enumTypes[1]
}

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

type Enums_NestedEnum int32

const (
	Enums_UNO  Enums_NestedEnum = 1
	Enums_DOS  Enums_NestedEnum = 2
	Enums_DIEZ Enums_NestedEnum = 10
)

// Enum value maps for Enums_NestedEnum.
var (
	Enums_NestedEnum_name = map[int32]string{
		1:  "UNO",
		2:  "DOS",
		10: "DIEZ",
	}
	Enums_NestedEnum_value = map[string]int32{
		"UNO":  1,
		"DOS":  2,
		"DIEZ": 10,
	}
)

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

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

func (Enums_NestedEnum) Descriptor() protoreflect.EnumDescriptor {
	return file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_proto_enumTypes[2].Descriptor()
}

func (Enums_NestedEnum) Type() protoreflect.EnumType {
	return &file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_proto_enumTypes[2]
}

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

type Enums_NestedOpenEnum int32

const (
	Enums_UNKNOWN Enums_NestedOpenEnum = 0
	Enums_EINS    Enums_NestedOpenEnum = 1
	Enums_ZWEI    Enums_NestedOpenEnum = 2
	Enums_ZEHN    Enums_NestedOpenEnum = 10
)

// Enum value maps for Enums_NestedOpenEnum.
var (
	Enums_NestedOpenEnum_name = map[int32]string{
		0:  "UNKNOWN",
		1:  "EINS",
		2:  "ZWEI",
		10: "ZEHN",
	}
	Enums_NestedOpenEnum_value = map[string]int32{
		"UNKNOWN": 0,
		"EINS":    1,
		"ZWEI":    2,
		"ZEHN":    10,
	}
)

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

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

func (Enums_NestedOpenEnum) Descriptor() protoreflect.EnumDescriptor {
	return file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_proto_enumTypes[3].Descriptor()
}

func (Enums_NestedOpenEnum) Type() protoreflect.EnumType {
	return &file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_proto_enumTypes[3]
}

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

// Scalars contains scalar fields.
type Scalars struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	OptBool       *bool                  `protobuf:"varint,1,opt,name=opt_bool,json=optBool" json:"opt_bool,omitempty"`
	OptInt32      *int32                 `protobuf:"varint,2,opt,name=opt_int32,json=optInt32" json:"opt_int32,omitempty"`
	OptInt64      *int64                 `protobuf:"varint,3,opt,name=opt_int64,json=optInt64" json:"opt_int64,omitempty"`
	OptUint32     *uint32                `protobuf:"varint,4,opt,name=opt_uint32,json=optUint32" json:"opt_uint32,omitempty"`
	OptUint64     *uint64                `protobuf:"varint,5,opt,name=opt_uint64,json=optUint64" json:"opt_uint64,omitempty"`
	OptSint32     *int32                 `protobuf:"zigzag32,6,opt,name=opt_sint32,json=optSint32" json:"opt_sint32,omitempty"`
	OptSint64     *int64                 `protobuf:"zigzag64,7,opt,name=opt_sint64,json=optSint64" json:"opt_sint64,omitempty"`
	OptFixed32    *uint32                `protobuf:"fixed32,8,opt,name=opt_fixed32,json=optFixed32" json:"opt_fixed32,omitempty"`
	OptFixed64    *uint64                `protobuf:"fixed64,9,opt,name=opt_fixed64,json=optFixed64" json:"opt_fixed64,omitempty"`
	OptSfixed32   *int32                 `protobuf:"fixed32,10,opt,name=opt_sfixed32,json=optSfixed32" json:"opt_sfixed32,omitempty"`
	OptSfixed64   *int64                 `protobuf:"fixed64,11,opt,name=opt_sfixed64,json=optSfixed64" json:"opt_sfixed64,omitempty"`
	OptFloat      *float32               `protobuf:"fixed32,20,opt,name=opt_float,json=optFloat" json:"opt_float,omitempty"`
	OptDouble     *float64               `protobuf:"fixed64,21,opt,name=opt_double,json=optDouble" json:"opt_double,omitempty"`
	OptBytes      []byte                 `protobuf:"bytes,14,opt,name=opt_bytes,json=optBytes" json:"opt_bytes,omitempty"`
	OptString     *string                `protobuf:"bytes,13,opt,name=opt_string,json=optString" json:"opt_string,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Scalars) ProtoMessage() {}

func (x *Scalars) ProtoReflect() protoreflect.Message {
	mi := &file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_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 *Scalars) GetOptBool() bool {
	if x != nil && x.OptBool != nil {
		return *x.OptBool
	}
	return false
}

func (x *Scalars) GetOptInt32() int32 {
	if x != nil && x.OptInt32 != nil {
		return *x.OptInt32
	}
	return 0
}

func (x *Scalars) GetOptInt64() int64 {
	if x != nil && x.OptInt64 != nil {
		return *x.OptInt64
	}
	return 0
}

func (x *Scalars) GetOptUint32() uint32 {
	if x != nil && x.OptUint32 != nil {
		return *x.OptUint32
	}
	return 0
}

func (x *Scalars) GetOptUint64() uint64 {
	if x != nil && x.OptUint64 != nil {
		return *x.OptUint64
	}
	return 0
}

func (x *Scalars) GetOptSint32() int32 {
	if x != nil && x.OptSint32 != nil {
		return *x.OptSint32
	}
	return 0
}

func (x *Scalars) GetOptSint64() int64 {
	if x != nil && x.OptSint64 != nil {
		return *x.OptSint64
	}
	return 0
}

func (x *Scalars) GetOptFixed32() uint32 {
	if x != nil && x.OptFixed32 != nil {
		return *x.OptFixed32
	}
	return 0
}

func (x *Scalars) GetOptFixed64() uint64 {
	if x != nil && x.OptFixed64 != nil {
		return *x.OptFixed64
	}
	return 0
}

func (x *Scalars) GetOptSfixed32() int32 {
	if x != nil && x.OptSfixed32 != nil {
		return *x.OptSfixed32
	}
	return 0
}

func (x *Scalars) GetOptSfixed64() int64 {
	if x != nil && x.OptSfixed64 != nil {
		return *x.OptSfixed64
	}
	return 0
}

func (x *Scalars) GetOptFloat() float32 {
	if x != nil && x.OptFloat != nil {
		return *x.OptFloat
	}
	return 0
}

func (x *Scalars) GetOptDouble() float64 {
	if x != nil && x.OptDouble != nil {
		return *x.OptDouble
	}
	return 0
}

func (x *Scalars) GetOptBytes() []byte {
	if x != nil {
		return x.OptBytes
	}
	return nil
}

func (x *Scalars) GetOptString() string {
	if x != nil && x.OptString != nil {
		return *x.OptString
	}
	return ""
}

func (x *Scalars) SetOptBool(v bool) {
	x.OptBool = &v
}

func (x *Scalars) SetOptInt32(v int32) {
	x.OptInt32 = &v
}

func (x *Scalars) SetOptInt64(v int64) {
	x.OptInt64 = &v
}

func (x *Scalars) SetOptUint32(v uint32) {
	x.OptUint32 = &v
}

func (x *Scalars) SetOptUint64(v uint64) {
	x.OptUint64 = &v
}

func (x *Scalars) SetOptSint32(v int32) {
	x.OptSint32 = &v
}

func (x *Scalars) SetOptSint64(v int64) {
	x.OptSint64 = &v
}

func (x *Scalars) SetOptFixed32(v uint32) {
	x.OptFixed32 = &v
}

func (x *Scalars) SetOptFixed64(v uint64) {
	x.OptFixed64 = &v
}

func (x *Scalars) SetOptSfixed32(v int32) {
	x.OptSfixed32 = &v
}

func (x *Scalars) SetOptSfixed64(v int64) {
	x.OptSfixed64 = &v
}

func (x *Scalars) SetOptFloat(v float32) {
	x.OptFloat = &v
}

func (x *Scalars) SetOptDouble(v float64) {
	x.OptDouble = &v
}

func (x *Scalars) SetOptBytes(v []byte) {
	if v == nil {
		v = []byte{}
	}
	x.OptBytes = v
}

func (x *Scalars) SetOptString(v string) {
	x.OptString = &v
}

func (x *Scalars) HasOptBool() bool {
	if x == nil {
		return false
	}
	return x.OptBool != nil
}

func (x *Scalars) HasOptInt32() bool {
	if x == nil {
		return false
	}
	return x.OptInt32 != nil
}

func (x *Scalars) HasOptInt64() bool {
	if x == nil {
		return false
	}
	return x.OptInt64 != nil
}

func (x *Scalars) HasOptUint32() bool {
	if x == nil {
		return false
	}
	return x.OptUint32 != nil
}

func (x *Scalars) HasOptUint64() bool {
	if x == nil {
		return false
	}
	return x.OptUint64 != nil
}

func (x *Scalars) HasOptSint32() bool {
	if x == nil {
		return false
	}
	return x.OptSint32 != nil
}

func (x *Scalars) HasOptSint64() bool {
	if x == nil {
		return false
	}
	return x.OptSint64 != nil
}

func (x *Scalars) HasOptFixed32() bool {
	if x == nil {
		return false
	}
	return x.OptFixed32 != nil
}

func (x *Scalars) HasOptFixed64() bool {
	if x == nil {
		return false
	}
	return x.OptFixed64 != nil
}

func (x *Scalars) HasOptSfixed32() bool {
	if x == nil {
		return false
	}
	return x.OptSfixed32 != nil
}

func (x *Scalars) HasOptSfixed64() bool {
	if x == nil {
		return false
	}
	return x.OptSfixed64 != nil
}

func (x *Scalars) HasOptFloat() bool {
	if x == nil {
		return false
	}
	return x.OptFloat != nil
}

func (x *Scalars) HasOptDouble() bool {
	if x == nil {
		return false
	}
	return x.OptDouble != nil
}

func (x *Scalars) HasOptBytes() bool {
	if x == nil {
		return false
	}
	return x.OptBytes != nil
}

func (x *Scalars) HasOptString() bool {
	if x == nil {
		return false
	}
	return x.OptString != nil
}

func (x *Scalars) ClearOptBool() {
	x.OptBool = nil
}

func (x *Scalars) ClearOptInt32() {
	x.OptInt32 = nil
}

func (x *Scalars) ClearOptInt64() {
	x.OptInt64 = nil
}

func (x *Scalars) ClearOptUint32() {
	x.OptUint32 = nil
}

func (x *Scalars) ClearOptUint64() {
	x.OptUint64 = nil
}

func (x *Scalars) ClearOptSint32() {
	x.OptSint32 = nil
}

func (x *Scalars) ClearOptSint64() {
	x.OptSint64 = nil
}

func (x *Scalars) ClearOptFixed32() {
	x.OptFixed32 = nil
}

func (x *Scalars) ClearOptFixed64() {
	x.OptFixed64 = nil
}

func (x *Scalars) ClearOptSfixed32() {
	x.OptSfixed32 = nil
}

func (x *Scalars) ClearOptSfixed64() {
	x.OptSfixed64 = nil
}

func (x *Scalars) ClearOptFloat() {
	x.OptFloat = nil
}

func (x *Scalars) ClearOptDouble() {
	x.OptDouble = nil
}

func (x *Scalars) ClearOptBytes() {
	x.OptBytes = nil
}

func (x *Scalars) ClearOptString() {
	x.OptString = nil
}

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

	OptBool     *bool
	OptInt32    *int32
	OptInt64    *int64
	OptUint32   *uint32
	OptUint64   *uint64
	OptSint32   *int32
	OptSint64   *int64
	OptFixed32  *uint32
	OptFixed64  *uint64
	OptSfixed32 *int32
	OptSfixed64 *int64
	OptFloat    *float32
	OptDouble   *float64
	OptBytes    []byte
	OptString   *string
}

func (b0 Scalars_builder) Build() *Scalars {
	m0 := &Scalars{}
	b, x := &b0, m0
	_, _ = b, x
	x.OptBool = b.OptBool
	x.OptInt32 = b.OptInt32
	x.OptInt64 = b.OptInt64
	x.OptUint32 = b.OptUint32
	x.OptUint64 = b.OptUint64
	x.OptSint32 = b.OptSint32
	x.OptSint64 = b.OptSint64
	x.OptFixed32 = b.OptFixed32
	x.OptFixed64 = b.OptFixed64
	x.OptSfixed32 = b.OptSfixed32
	x.OptSfixed64 = b.OptSfixed64
	x.OptFloat = b.OptFloat
	x.OptDouble = b.OptDouble
	x.OptBytes = b.OptBytes
	x.OptString = b.OptString
	return m0
}

// ImplicitScalars contains scalar field types with implicit field_presence
type ImplicitScalars struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	SBool         bool                   `protobuf:"varint,1,opt,name=s_bool,json=sBool" json:"s_bool,omitempty"`
	SInt32        int32                  `protobuf:"varint,2,opt,name=s_int32,json=sInt32" json:"s_int32,omitempty"`
	SInt64        int64                  `protobuf:"varint,3,opt,name=s_int64,json=sInt64" json:"s_int64,omitempty"`
	SUint32       uint32                 `protobuf:"varint,4,opt,name=s_uint32,json=sUint32" json:"s_uint32,omitempty"`
	SUint64       uint64                 `protobuf:"varint,5,opt,name=s_uint64,json=sUint64" json:"s_uint64,omitempty"`
	SSint32       int32                  `protobuf:"zigzag32,6,opt,name=s_sint32,json=sSint32" json:"s_sint32,omitempty"`
	SSint64       int64                  `protobuf:"zigzag64,7,opt,name=s_sint64,json=sSint64" json:"s_sint64,omitempty"`
	SFixed32      uint32                 `protobuf:"fixed32,8,opt,name=s_fixed32,json=sFixed32" json:"s_fixed32,omitempty"`
	SFixed64      uint64                 `protobuf:"fixed64,9,opt,name=s_fixed64,json=sFixed64" json:"s_fixed64,omitempty"`
	SSfixed32     int32                  `protobuf:"fixed32,10,opt,name=s_sfixed32,json=sSfixed32" json:"s_sfixed32,omitempty"`
	SSfixed64     int64                  `protobuf:"fixed64,11,opt,name=s_sfixed64,json=sSfixed64" json:"s_sfixed64,omitempty"`
	SFloat        float32                `protobuf:"fixed32,20,opt,name=s_float,json=sFloat" json:"s_float,omitempty"`
	SDouble       float64                `protobuf:"fixed64,21,opt,name=s_double,json=sDouble" json:"s_double,omitempty"`
	SBytes        []byte                 `protobuf:"bytes,14,opt,name=s_bytes,json=sBytes" json:"s_bytes,omitempty"`
	SString       string                 `protobuf:"bytes,13,opt,name=s_string,json=sString" json:"s_string,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ImplicitScalars) ProtoMessage() {}

func (x *ImplicitScalars) ProtoReflect() protoreflect.Message {
	mi := &file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_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 *ImplicitScalars) GetSBool() bool {
	if x != nil {
		return x.SBool
	}
	return false
}

func (x *ImplicitScalars) GetSInt32() int32 {
	if x != nil {
		return x.SInt32
	}
	return 0
}

func (x *ImplicitScalars) GetSInt64() int64 {
	if x != nil {
		return x.SInt64
	}
	return 0
}

func (x *ImplicitScalars) GetSUint32() uint32 {
	if x != nil {
		return x.SUint32
	}
	return 0
}

func (x *ImplicitScalars) GetSUint64() uint64 {
	if x != nil {
		return x.SUint64
	}
	return 0
}

func (x *ImplicitScalars) GetSSint32() int32 {
	if x != nil {
		return x.SSint32
	}
	return 0
}

func (x *ImplicitScalars) GetSSint64() int64 {
	if x != nil {
		return x.SSint64
	}
	return 0
}

func (x *ImplicitScalars) GetSFixed32() uint32 {
	if x != nil {
		return x.SFixed32
	}
	return 0
}

func (x *ImplicitScalars) GetSFixed64() uint64 {
	if x != nil {
		return x.SFixed64
	}
	return 0
}

func (x *ImplicitScalars) GetSSfixed32() int32 {
	if x != nil {
		return x.SSfixed32
	}
	return 0
}

func (x *ImplicitScalars) GetSSfixed64() int64 {
	if x != nil {
		return x.SSfixed64
	}
	return 0
}

func (x *ImplicitScalars) GetSFloat() float32 {
	if x != nil {
		return x.SFloat
	}
	return 0
}

func (x *ImplicitScalars) GetSDouble() float64 {
	if x != nil {
		return x.SDouble
	}
	return 0
}

func (x *ImplicitScalars) GetSBytes() []byte {
	if x != nil {
		return x.SBytes
	}
	return nil
}

func (x *ImplicitScalars) GetSString() string {
	if x != nil {
		return x.SString
	}
	return ""
}

func (x *ImplicitScalars) SetSBool(v bool) {
	x.SBool = v
}

func (x *ImplicitScalars) SetSInt32(v int32) {
	x.SInt32 = v
}

func (x *ImplicitScalars) SetSInt64(v int64) {
	x.SInt64 = v
}

func (x *ImplicitScalars) SetSUint32(v uint32) {
	x.SUint32 = v
}

func (x *ImplicitScalars) SetSUint64(v uint64) {
	x.SUint64 = v
}

func (x *ImplicitScalars) SetSSint32(v int32) {
	x.SSint32 = v
}

func (x *ImplicitScalars) SetSSint64(v int64) {
	x.SSint64 = v
}

func (x *ImplicitScalars) SetSFixed32(v uint32) {
	x.SFixed32 = v
}

func (x *ImplicitScalars) SetSFixed64(v uint64) {
	x.SFixed64 = v
}

func (x *ImplicitScalars) SetSSfixed32(v int32) {
	x.SSfixed32 = v
}

func (x *ImplicitScalars) SetSSfixed64(v int64) {
	x.SSfixed64 = v
}

func (x *ImplicitScalars) SetSFloat(v float32) {
	x.SFloat = v
}

func (x *ImplicitScalars) SetSDouble(v float64) {
	x.SDouble = v
}

func (x *ImplicitScalars) SetSBytes(v []byte) {
	if v == nil {
		v = []byte{}
	}
	x.SBytes = v
}

func (x *ImplicitScalars) SetSString(v string) {
	x.SString = v
}

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

	SBool     bool
	SInt32    int32
	SInt64    int64
	SUint32   uint32
	SUint64   uint64
	SSint32   int32
	SSint64   int64
	SFixed32  uint32
	SFixed64  uint64
	SSfixed32 int32
	SSfixed64 int64
	SFloat    float32
	SDouble   float64
	SBytes    []byte
	SString   string
}

func (b0 ImplicitScalars_builder) Build() *ImplicitScalars {
	m0 := &ImplicitScalars{}
	b, x := &b0, m0
	_, _ = b, x
	x.SBool = b.SBool
	x.SInt32 = b.SInt32
	x.SInt64 = b.SInt64
	x.SUint32 = b.SUint32
	x.SUint64 = b.SUint64
	x.SSint32 = b.SSint32
	x.SSint64 = b.SSint64
	x.SFixed32 = b.SFixed32
	x.SFixed64 = b.SFixed64
	x.SSfixed32 = b.SSfixed32
	x.SSfixed64 = b.SSfixed64
	x.SFloat = b.SFloat
	x.SDouble = b.SDouble
	x.SBytes = b.SBytes
	x.SString = b.SString
	return m0
}

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

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

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

func (*UTF8Validated) ProtoMessage() {}

func (x *UTF8Validated) ProtoReflect() protoreflect.Message {
	mi := &file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_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 *UTF8Validated) GetValidatedString() string {
	if x != nil {
		return x.ValidatedString
	}
	return ""
}

func (x *UTF8Validated) SetValidatedString(v string) {
	x.ValidatedString = v
}

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

	ValidatedString string
}

func (b0 UTF8Validated_builder) Build() *UTF8Validated {
	m0 := &UTF8Validated{}
	b, x := &b0, m0
	_, _ = b, x
	x.ValidatedString = b.ValidatedString
	return m0
}

type NestsUTF8Validated struct {
	state            protoimpl.MessageState `protogen:"hybrid.v1"`
	ValidatedMessage *UTF8Validated         `protobuf:"bytes,1,opt,name=validated_message,json=validatedMessage" json:"validated_message,omitempty"`
	unknownFields    protoimpl.UnknownFields
	sizeCache        protoimpl.SizeCache
}

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

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

func (*NestsUTF8Validated) ProtoMessage() {}

func (x *NestsUTF8Validated) ProtoReflect() protoreflect.Message {
	mi := &file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_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 *NestsUTF8Validated) GetValidatedMessage() *UTF8Validated {
	if x != nil {
		return x.ValidatedMessage
	}
	return nil
}

func (x *NestsUTF8Validated) SetValidatedMessage(v *UTF8Validated) {
	x.ValidatedMessage = v
}

func (x *NestsUTF8Validated) HasValidatedMessage() bool {
	if x == nil {
		return false
	}
	return x.ValidatedMessage != nil
}

func (x *NestsUTF8Validated) ClearValidatedMessage() {
	x.ValidatedMessage = nil
}

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

	ValidatedMessage *UTF8Validated
}

func (b0 NestsUTF8Validated_builder) Build() *NestsUTF8Validated {
	m0 := &NestsUTF8Validated{}
	b, x := &b0, m0
	_, _ = b, x
	x.ValidatedMessage = b.ValidatedMessage
	return m0
}

// Message contains enum fields.
type Enums struct {
	state              protoimpl.MessageState `protogen:"hybrid.v1"`
	OptEnum            *Enum                  `protobuf:"varint,1,opt,name=opt_enum,json=optEnum,enum=hybrid.pbeditions.Enum" json:"opt_enum,omitempty"`
	RptEnum            []Enum                 `protobuf:"varint,2,rep,packed,name=rpt_enum,json=rptEnum,enum=hybrid.pbeditions.Enum" json:"rpt_enum,omitempty"`
	ImplicitEnum       OpenEnum               `protobuf:"varint,5,opt,name=implicit_enum,json=implicitEnum,enum=hybrid.pbeditions.OpenEnum" json:"implicit_enum,omitempty"`
	OptNestedEnum      *Enums_NestedEnum      `protobuf:"varint,3,opt,name=opt_nested_enum,json=optNestedEnum,enum=hybrid.pbeditions.Enums_NestedEnum" json:"opt_nested_enum,omitempty"`
	RptNestedEnum      []Enums_NestedEnum     `protobuf:"varint,4,rep,packed,name=rpt_nested_enum,json=rptNestedEnum,enum=hybrid.pbeditions.Enums_NestedEnum" json:"rpt_nested_enum,omitempty"`
	ImplicitNestedEnum Enums_NestedOpenEnum   `protobuf:"varint,6,opt,name=implicit_nested_enum,json=implicitNestedEnum,enum=hybrid.pbeditions.Enums_NestedOpenEnum" json:"implicit_nested_enum,omitempty"`
	unknownFields      protoimpl.UnknownFields
	sizeCache          protoimpl.SizeCache
}

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

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

func (*Enums) ProtoMessage() {}

func (x *Enums) ProtoReflect() protoreflect.Message {
	mi := &file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_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 *Enums) GetOptEnum() Enum {
	if x != nil && x.OptEnum != nil {
		return *x.OptEnum
	}
	return Enum_ONE
}

func (x *Enums) GetRptEnum() []Enum {
	if x != nil {
		return x.RptEnum
	}
	return nil
}

func (x *Enums) GetImplicitEnum() OpenEnum {
	if x != nil {
		return x.ImplicitEnum
	}
	return OpenEnum_UNKNOWN
}

func (x *Enums) GetOptNestedEnum() Enums_NestedEnum {
	if x != nil && x.OptNestedEnum != nil {
		return *x.OptNestedEnum
	}
	return Enums_UNO
}

func (x *Enums) GetRptNestedEnum() []Enums_NestedEnum {
	if x != nil {
		return x.RptNestedEnum
	}
	return nil
}

func (x *Enums) GetImplicitNestedEnum() Enums_NestedOpenEnum {
	if x != nil {
		return x.ImplicitNestedEnum
	}
	return Enums_UNKNOWN
}

func (x *Enums) SetOptEnum(v Enum) {
	x.OptEnum = &v
}

func (x *Enums) SetRptEnum(v []Enum) {
	x.RptEnum = v
}

func (x *Enums) SetImplicitEnum(v OpenEnum) {
	x.ImplicitEnum = v
}

func (x *Enums) SetOptNestedEnum(v Enums_NestedEnum) {
	x.OptNestedEnum = &v
}

func (x *Enums) SetRptNestedEnum(v []Enums_NestedEnum) {
	x.RptNestedEnum = v
}

func (x *Enums) SetImplicitNestedEnum(v Enums_NestedOpenEnum) {
	x.ImplicitNestedEnum = v
}

func (x *Enums) HasOptEnum() bool {
	if x == nil {
		return false
	}
	return x.OptEnum != nil
}

func (x *Enums) HasOptNestedEnum() bool {
	if x == nil {
		return false
	}
	return x.OptNestedEnum != nil
}

func (x *Enums) ClearOptEnum() {
	x.OptEnum = nil
}

func (x *Enums) ClearOptNestedEnum() {
	x.OptNestedEnum = nil
}

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

	OptEnum            *Enum
	RptEnum            []Enum
	ImplicitEnum       OpenEnum
	OptNestedEnum      *Enums_NestedEnum
	RptNestedEnum      []Enums_NestedEnum
	ImplicitNestedEnum Enums_NestedOpenEnum
}

func (b0 Enums_builder) Build() *Enums {
	m0 := &Enums{}
	b, x := &b0, m0
	_, _ = b, x
	x.OptEnum = b.OptEnum
	x.RptEnum = b.RptEnum
	x.ImplicitEnum = b.ImplicitEnum
	x.OptNestedEnum = b.OptNestedEnum
	x.RptNestedEnum = b.RptNestedEnum
	x.ImplicitNestedEnum = b.ImplicitNestedEnum
	return m0
}

// Message contains repeated fields.
type Repeats struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	RptBool       []bool                 `protobuf:"varint,1,rep,packed,name=rpt_bool,json=rptBool" json:"rpt_bool,omitempty"`
	RptInt32      []int32                `protobuf:"varint,2,rep,packed,name=rpt_int32,json=rptInt32" json:"rpt_int32,omitempty"`
	RptInt64      []int64                `protobuf:"varint,3,rep,packed,name=rpt_int64,json=rptInt64" json:"rpt_int64,omitempty"`
	RptUint32     []uint32               `protobuf:"varint,4,rep,packed,name=rpt_uint32,json=rptUint32" json:"rpt_uint32,omitempty"`
	RptUint64     []uint64               `protobuf:"varint,5,rep,packed,name=rpt_uint64,json=rptUint64" json:"rpt_uint64,omitempty"`
	RptFloat      []float32              `protobuf:"fixed32,6,rep,packed,name=rpt_float,json=rptFloat" json:"rpt_float,omitempty"`
	RptDouble     []float64              `protobuf:"fixed64,7,rep,packed,name=rpt_double,json=rptDouble" json:"rpt_double,omitempty"`
	RptString     []string               `protobuf:"bytes,8,rep,name=rpt_string,json=rptString" json:"rpt_string,omitempty"`
	RptBytes      [][]byte               `protobuf:"bytes,9,rep,name=rpt_bytes,json=rptBytes" json:"rpt_bytes,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Repeats) ProtoMessage() {}

func (x *Repeats) ProtoReflect() protoreflect.Message {
	mi := &file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_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 *Repeats) GetRptBool() []bool {
	if x != nil {
		return x.RptBool
	}
	return nil
}

func (x *Repeats) GetRptInt32() []int32 {
	if x != nil {
		return x.RptInt32
	}
	return nil
}

func (x *Repeats) GetRptInt64() []int64 {
	if x != nil {
		return x.RptInt64
	}
	return nil
}

func (x *Repeats) GetRptUint32() []uint32 {
	if x != nil {
		return x.RptUint32
	}
	return nil
}

func (x *Repeats) GetRptUint64() []uint64 {
	if x != nil {
		return x.RptUint64
	}
	return nil
}

func (x *Repeats) GetRptFloat() []float32 {
	if x != nil {
		return x.RptFloat
	}
	return nil
}

func (x *Repeats) GetRptDouble() []float64 {
	if x != nil {
		return x.RptDouble
	}
	return nil
}

func (x *Repeats) GetRptString() []string {
	if x != nil {
		return x.RptString
	}
	return nil
}

func (x *Repeats) GetRptBytes() [][]byte {
	if x != nil {
		return x.RptBytes
	}
	return nil
}

func (x *Repeats) SetRptBool(v []bool) {
	x.RptBool = v
}

func (x *Repeats) SetRptInt32(v []int32) {
	x.RptInt32 = v
}

func (x *Repeats) SetRptInt64(v []int64) {
	x.RptInt64 = v
}

func (x *Repeats) SetRptUint32(v []uint32) {
	x.RptUint32 = v
}

func (x *Repeats) SetRptUint64(v []uint64) {
	x.RptUint64 = v
}

func (x *Repeats) SetRptFloat(v []float32) {
	x.RptFloat = v
}

func (x *Repeats) SetRptDouble(v []float64) {
	x.RptDouble = v
}

func (x *Repeats) SetRptString(v []string) {
	x.RptString = v
}

func (x *Repeats) SetRptBytes(v [][]byte) {
	x.RptBytes = v
}

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

	RptBool   []bool
	RptInt32  []int32
	RptInt64  []int64
	RptUint32 []uint32
	RptUint64 []uint64
	RptFloat  []float32
	RptDouble []float64
	RptString []string
	RptBytes  [][]byte
}

func (b0 Repeats_builder) Build() *Repeats {
	m0 := &Repeats{}
	b, x := &b0, m0
	_, _ = b, x
	x.RptBool = b.RptBool
	x.RptInt32 = b.RptInt32
	x.RptInt64 = b.RptInt64
	x.RptUint32 = b.RptUint32
	x.RptUint64 = b.RptUint64
	x.RptFloat = b.RptFloat
	x.RptDouble = b.RptDouble
	x.RptString = b.RptString
	x.RptBytes = b.RptBytes
	return m0
}

// Message contains map fields.
type Maps struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Int32ToStr    map[int32]string       `protobuf:"bytes,1,rep,name=int32_to_str,json=int32ToStr" json:"int32_to_str,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	StrToNested   map[string]*Nested     `protobuf:"bytes,4,rep,name=str_to_nested,json=strToNested" json:"str_to_nested,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Maps) ProtoMessage() {}

func (x *Maps) ProtoReflect() protoreflect.Message {
	mi := &file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_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 *Maps) GetInt32ToStr() map[int32]string {
	if x != nil {
		return x.Int32ToStr
	}
	return nil
}

func (x *Maps) GetStrToNested() map[string]*Nested {
	if x != nil {
		return x.StrToNested
	}
	return nil
}

func (x *Maps) SetInt32ToStr(v map[int32]string) {
	x.Int32ToStr = v
}

func (x *Maps) SetStrToNested(v map[string]*Nested) {
	x.StrToNested = v
}

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

	Int32ToStr  map[int32]string
	StrToNested map[string]*Nested
}

func (b0 Maps_builder) Build() *Maps {
	m0 := &Maps{}
	b, x := &b0, m0
	_, _ = b, x
	x.Int32ToStr = b.Int32ToStr
	x.StrToNested = b.StrToNested
	return m0
}

// Message type used as submessage.
type Nested struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	OptString     *string                `protobuf:"bytes,1,opt,name=opt_string,json=optString" json:"opt_string,omitempty"`
	OptNested     *Nested                `protobuf:"bytes,2,opt,name=opt_nested,json=optNested" json:"opt_nested,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Nested) ProtoMessage() {}

func (x *Nested) ProtoReflect() protoreflect.Message {
	mi := &file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_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 *Nested) GetOptString() string {
	if x != nil && x.OptString != nil {
		return *x.OptString
	}
	return ""
}

func (x *Nested) GetOptNested() *Nested {
	if x != nil {
		return x.OptNested
	}
	return nil
}

func (x *Nested) SetOptString(v string) {
	x.OptString = &v
}

func (x *Nested) SetOptNested(v *Nested) {
	x.OptNested = v
}

func (x *Nested) HasOptString() bool {
	if x == nil {
		return false
	}
	return x.OptString != nil
}

func (x *Nested) HasOptNested() bool {
	if x == nil {
		return false
	}
	return x.OptNested != nil
}

func (x *Nested) ClearOptString() {
	x.OptString = nil
}

func (x *Nested) ClearOptNested() {
	x.OptNested = nil
}

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

	OptString *string
	OptNested *Nested
}

func (b0 Nested_builder) Build() *Nested {
	m0 := &Nested{}
	b, x := &b0, m0
	_, _ = b, x
	x.OptString = b.OptString
	x.OptNested = b.OptNested
	return m0
}

// Message contains message and group fields.
type Nests struct {
	state          protoimpl.MessageState `protogen:"hybrid.v1"`
	OptNested      *Nested                `protobuf:"bytes,1,opt,name=opt_nested,json=optNested" json:"opt_nested,omitempty"`
	Optgroup       *Nests_OptGroup        `protobuf:"group,2,opt,name=OptGroup,json=optgroup" json:"optgroup,omitempty"`
	DelimitedField *Nests_OptGroup        `protobuf:"group,3,opt,name=OptGroup,json=delimitedField" json:"delimited_field,omitempty"`
	RptNested      []*Nested              `protobuf:"bytes,4,rep,name=rpt_nested,json=rptNested" json:"rpt_nested,omitempty"`
	Rptgroup       []*Nests_RptGroup      `protobuf:"group,5,rep,name=RptGroup,json=rptgroup" json:"rptgroup,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*Nests) ProtoMessage() {}

func (x *Nests) ProtoReflect() protoreflect.Message {
	mi := &file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_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 *Nests) GetOptNested() *Nested {
	if x != nil {
		return x.OptNested
	}
	return nil
}

func (x *Nests) GetOptgroup() *Nests_OptGroup {
	if x != nil {
		return x.Optgroup
	}
	return nil
}

func (x *Nests) GetDelimitedField() *Nests_OptGroup {
	if x != nil {
		return x.DelimitedField
	}
	return nil
}

func (x *Nests) GetRptNested() []*Nested {
	if x != nil {
		return x.RptNested
	}
	return nil
}

func (x *Nests) GetRptgroup() []*Nests_RptGroup {
	if x != nil {
		return x.Rptgroup
	}
	return nil
}

func (x *Nests) SetOptNested(v *Nested) {
	x.OptNested = v
}

func (x *Nests) SetOptgroup(v *Nests_OptGroup) {
	x.Optgroup = v
}

func (x *Nests) SetDelimitedField(v *Nests_OptGroup) {
	x.DelimitedField = v
}

func (x *Nests) SetRptNested(v []*Nested) {
	x.RptNested = v
}

func (x *Nests) SetRptgroup(v []*Nests_RptGroup) {
	x.Rptgroup = v
}

func (x *Nests) HasOptNested() bool {
	if x == nil {
		return false
	}
	return x.OptNested != nil
}

func (x *Nests) HasOptgroup() bool {
	if x == nil {
		return false
	}
	return x.Optgroup != nil
}

func (x *Nests) HasDelimitedField() bool {
	if x == nil {
		return false
	}
	return x.DelimitedField != nil
}

func (x *Nests) ClearOptNested() {
	x.OptNested = nil
}

func (x *Nests) ClearOptgroup() {
	x.Optgroup = nil
}

func (x *Nests) ClearDelimitedField() {
	x.DelimitedField = nil
}

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

	OptNested      *Nested
	Optgroup       *Nests_OptGroup
	DelimitedField *Nests_OptGroup
	RptNested      []*Nested
	Rptgroup       []*Nests_RptGroup
}

func (b0 Nests_builder) Build() *Nests {
	m0 := &Nests{}
	b, x := &b0, m0
	_, _ = b, x
	x.OptNested = b.OptNested
	x.Optgroup = b.Optgroup
	x.DelimitedField = b.DelimitedField
	x.RptNested = b.RptNested
	x.Rptgroup = b.Rptgroup
	return m0
}

// Message contains required fields.
type Requireds struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	ReqBool       *bool                  `protobuf:"varint,1,req,name=req_bool,json=reqBool" json:"req_bool,omitempty"`
	ReqSfixed64   *int64                 `protobuf:"fixed64,2,req,name=req_sfixed64,json=reqSfixed64" json:"req_sfixed64,omitempty"`
	ReqDouble     *float64               `protobuf:"fixed64,3,req,name=req_double,json=reqDouble" json:"req_double,omitempty"`
	ReqString     *string                `protobuf:"bytes,4,req,name=req_string,json=reqString" json:"req_string,omitempty"`
	ReqEnum       *Enum                  `protobuf:"varint,5,req,name=req_enum,json=reqEnum,enum=hybrid.pbeditions.Enum" json:"req_enum,omitempty"`
	ReqNested     *Nested                `protobuf:"bytes,6,req,name=req_nested,json=reqNested" json:"req_nested,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Requireds) ProtoMessage() {}

func (x *Requireds) ProtoReflect() protoreflect.Message {
	mi := &file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_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 *Requireds) GetReqBool() bool {
	if x != nil && x.ReqBool != nil {
		return *x.ReqBool
	}
	return false
}

func (x *Requireds) GetReqSfixed64() int64 {
	if x != nil && x.ReqSfixed64 != nil {
		return *x.ReqSfixed64
	}
	return 0
}

func (x *Requireds) GetReqDouble() float64 {
	if x != nil && x.ReqDouble != nil {
		return *x.ReqDouble
	}
	return 0
}

func (x *Requireds) GetReqString() string {
	if x != nil && x.ReqString != nil {
		return *x.ReqString
	}
	return ""
}

func (x *Requireds) GetReqEnum() Enum {
	if x != nil && x.ReqEnum != nil {
		return *x.ReqEnum
	}
	return Enum_ONE
}

func (x *Requireds) GetReqNested() *Nested {
	if x != nil {
		return x.ReqNested
	}
	return nil
}

func (x *Requireds) SetReqBool(v bool) {
	x.ReqBool = &v
}

func (x *Requireds) SetReqSfixed64(v int64) {
	x.ReqSfixed64 = &v
}

func (x *Requireds) SetReqDouble(v float64) {
	x.ReqDouble = &v
}

func (x *Requireds) SetReqString(v string) {
	x.ReqString = &v
}

func (x *Requireds) SetReqEnum(v Enum) {
	x.ReqEnum = &v
}

func (x *Requireds) SetReqNested(v *Nested) {
	x.ReqNested = v
}

func (x *Requireds) HasReqBool() bool {
	if x == nil {
		return false
	}
	return x.ReqBool != nil
}

func (x *Requireds) HasReqSfixed64() bool {
	if x == nil {
		return false
	}
	return x.ReqSfixed64 != nil
}

func (x *Requireds) HasReqDouble() bool {
	if x == nil {
		return false
	}
	return x.ReqDouble != nil
}

func (x *Requireds) HasReqString() bool {
	if x == nil {
		return false
	}
	return x.ReqString != nil
}

func (x *Requireds) HasReqEnum() bool {
	if x == nil {
		return false
	}
	return x.ReqEnum != nil
}

func (x *Requireds) HasReqNested() bool {
	if x == nil {
		return false
	}
	return x.ReqNested != nil
}

func (x *Requireds) ClearReqBool() {
	x.ReqBool = nil
}

func (x *Requireds) ClearReqSfixed64() {
	x.ReqSfixed64 = nil
}

func (x *Requireds) ClearReqDouble() {
	x.ReqDouble = nil
}

func (x *Requireds) ClearReqString() {
	x.ReqString = nil
}

func (x *Requireds) ClearReqEnum() {
	x.ReqEnum = nil
}

func (x *Requireds) ClearReqNested() {
	x.ReqNested = nil
}

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

	ReqBool     *bool
	ReqSfixed64 *int64
	ReqDouble   *float64
	ReqString   *string
	ReqEnum     *Enum
	ReqNested   *Nested
}

func (b0 Requireds_builder) Build() *Requireds {
	m0 := &Requireds{}
	b, x := &b0, m0
	_, _ = b, x
	x.ReqBool = b.ReqBool
	x.ReqSfixed64 = b.ReqSfixed64
	x.ReqDouble = b.ReqDouble
	x.ReqString = b.ReqString
	x.ReqEnum = b.ReqEnum
	x.ReqNested = b.ReqNested
	return m0
}

// Message contains both required and optional fields.
type PartialRequired struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	ReqString     *string                `protobuf:"bytes,1,req,name=req_string,json=reqString" json:"req_string,omitempty"`
	OptString     *string                `protobuf:"bytes,2,opt,name=opt_string,json=optString" json:"opt_string,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*PartialRequired) ProtoMessage() {}

func (x *PartialRequired) ProtoReflect() protoreflect.Message {
	mi := &file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_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 *PartialRequired) GetReqString() string {
	if x != nil && x.ReqString != nil {
		return *x.ReqString
	}
	return ""
}

func (x *PartialRequired) GetOptString() string {
	if x != nil && x.OptString != nil {
		return *x.OptString
	}
	return ""
}

func (x *PartialRequired) SetReqString(v string) {
	x.ReqString = &v
}

func (x *PartialRequired) SetOptString(v string) {
	x.OptString = &v
}

func (x *PartialRequired) HasReqString() bool {
	if x == nil {
		return false
	}
	return x.ReqString != nil
}

func (x *PartialRequired) HasOptString() bool {
	if x == nil {
		return false
	}
	return x.OptString != nil
}

func (x *PartialRequired) ClearReqString() {
	x.ReqString = nil
}

func (x *PartialRequired) ClearOptString() {
	x.OptString = nil
}

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

	ReqString *string
	OptString *string
}

func (b0 PartialRequired_builder) Build() *PartialRequired {
	m0 := &PartialRequired{}
	b, x := &b0, m0
	_, _ = b, x
	x.ReqString = b.ReqString
	x.OptString = b.OptString
	return m0
}

type NestedWithRequired struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	ReqString     *string                `protobuf:"bytes,1,req,name=req_string,json=reqString" json:"req_string,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*NestedWithRequired) ProtoMessage() {}

func (x *NestedWithRequired) ProtoReflect() protoreflect.Message {
	mi := &file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_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 *NestedWithRequired) GetReqString() string {
	if x != nil && x.ReqString != nil {
		return *x.ReqString
	}
	return ""
}

func (x *NestedWithRequired) SetReqString(v string) {
	x.ReqString = &v
}

func (x *NestedWithRequired) HasReqString() bool {
	if x == nil {
		return false
	}
	return x.ReqString != nil
}

func (x *NestedWithRequired) ClearReqString() {
	x.ReqString = nil
}

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

	ReqString *string
}

func (b0 NestedWithRequired_builder) Build() *NestedWithRequired {
	m0 := &NestedWithRequired{}
	b, x := &b0, m0
	_, _ = b, x
	x.ReqString = b.ReqString
	return m0
}

type IndirectRequired struct {
	state       protoimpl.MessageState         `protogen:"hybrid.v1"`
	OptNested   *NestedWithRequired            `protobuf:"bytes,1,opt,name=opt_nested,json=optNested" json:"opt_nested,omitempty"`
	RptNested   []*NestedWithRequired          `protobuf:"bytes,2,rep,name=rpt_nested,json=rptNested" json:"rpt_nested,omitempty"`
	StrToNested map[string]*NestedWithRequired `protobuf:"bytes,3,rep,name=str_to_nested,json=strToNested" json:"str_to_nested,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	// Types that are valid to be assigned to Union:
	//
	//	*IndirectRequired_OneofNested
	Union         isIndirectRequired_Union `protobuf_oneof:"union"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*IndirectRequired) ProtoMessage() {}

func (x *IndirectRequired) ProtoReflect() protoreflect.Message {
	mi := &file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_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 *IndirectRequired) GetOptNested() *NestedWithRequired {
	if x != nil {
		return x.OptNested
	}
	return nil
}

func (x *IndirectRequired) GetRptNested() []*NestedWithRequired {
	if x != nil {
		return x.RptNested
	}
	return nil
}

func (x *IndirectRequired) GetStrToNested() map[string]*NestedWithRequired {
	if x != nil {
		return x.StrToNested
	}
	return nil
}

func (x *IndirectRequired) GetUnion() isIndirectRequired_Union {
	if x != nil {
		return x.Union
	}
	return nil
}

func (x *IndirectRequired) GetOneofNested() *NestedWithRequired {
	if x != nil {
		if x, ok := x.Union.(*IndirectRequired_OneofNested); ok {
			return x.OneofNested
		}
	}
	return nil
}

func (x *IndirectRequired) SetOptNested(v *NestedWithRequired) {
	x.OptNested = v
}

func (x *IndirectRequired) SetRptNested(v []*NestedWithRequired) {
	x.RptNested = v
}

func (x *IndirectRequired) SetStrToNested(v map[string]*NestedWithRequired) {
	x.StrToNested = v
}

func (x *IndirectRequired) SetOneofNested(v *NestedWithRequired) {
	if v == nil {
		x.Union = nil
		return
	}
	x.Union = &IndirectRequired_OneofNested{v}
}

func (x *IndirectRequired) HasOptNested() bool {
	if x == nil {
		return false
	}
	return x.OptNested != nil
}

func (x *IndirectRequired) HasUnion() bool {
	if x == nil {
		return false
	}
	return x.Union != nil
}

func (x *IndirectRequired) HasOneofNested() bool {
	if x == nil {
		return false
	}
	_, ok := x.Union.(*IndirectRequired_OneofNested)
	return ok
}

func (x *IndirectRequired) ClearOptNested() {
	x.OptNested = nil
}

func (x *IndirectRequired) ClearUnion() {
	x.Union = nil
}

func (x *IndirectRequired) ClearOneofNested() {
	if _, ok := x.Union.(*IndirectRequired_OneofNested); ok {
		x.Union = nil
	}
}

const IndirectRequired_Union_not_set_case case_IndirectRequired_Union = 0
const IndirectRequired_OneofNested_case case_IndirectRequired_Union = 4

func (x *IndirectRequired) WhichUnion() case_IndirectRequired_Union {
	if x == nil {
		return IndirectRequired_Union_not_set_case
	}
	switch x.Union.(type) {
	case *IndirectRequired_OneofNested:
		return IndirectRequired_OneofNested_case
	default:
		return IndirectRequired_Union_not_set_case
	}
}

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

	OptNested   *NestedWithRequired
	RptNested   []*NestedWithRequired
	StrToNested map[string]*NestedWithRequired
	// Fields of oneof Union:
	OneofNested *NestedWithRequired
	// -- end of Union
}

func (b0 IndirectRequired_builder) Build() *IndirectRequired {
	m0 := &IndirectRequired{}
	b, x := &b0, m0
	_, _ = b, x
	x.OptNested = b.OptNested
	x.RptNested = b.RptNested
	x.StrToNested = b.StrToNested
	if b.OneofNested != nil {
		x.Union = &IndirectRequired_OneofNested{b.OneofNested}
	}
	return m0
}

type case_IndirectRequired_Union protoreflect.FieldNumber

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

type isIndirectRequired_Union interface {
	isIndirectRequired_Union()
}

type IndirectRequired_OneofNested struct {
	OneofNested *NestedWithRequired `protobuf:"bytes,4,opt,name=oneof_nested,json=oneofNested,oneof"`
}

func (*IndirectRequired_OneofNested) isIndirectRequired_Union() {}

type Extensions struct {
	state           protoimpl.MessageState `protogen:"hybrid.v1"`
	OptString       *string                `protobuf:"bytes,1,opt,name=opt_string,json=optString" json:"opt_string,omitempty"`
	OptBool         *bool                  `protobuf:"varint,101,opt,name=opt_bool,json=optBool" json:"opt_bool,omitempty"`
	OptInt32        *int32                 `protobuf:"varint,2,opt,name=opt_int32,json=optInt32" json:"opt_int32,omitempty"`
	extensionFields protoimpl.ExtensionFields
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

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

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

func (*Extensions) ProtoMessage() {}

func (x *Extensions) ProtoReflect() protoreflect.Message {
	mi := &file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_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 *Extensions) GetOptString() string {
	if x != nil && x.OptString != nil {
		return *x.OptString
	}
	return ""
}

func (x *Extensions) GetOptBool() bool {
	if x != nil && x.OptBool != nil {
		return *x.OptBool
	}
	return false
}

func (x *Extensions) GetOptInt32() int32 {
	if x != nil && x.OptInt32 != nil {
		return *x.OptInt32
	}
	return 0
}

func (x *Extensions) SetOptString(v string) {
	x.OptString = &v
}

func (x *Extensions) SetOptBool(v bool) {
	x.OptBool = &v
}

func (x *Extensions) SetOptInt32(v int32) {
	x.OptInt32 = &v
}

func (x *Extensions) HasOptString() bool {
	if x == nil {
		return false
	}
	return x.OptString != nil
}

func (x *Extensions) HasOptBool() bool {
	if x == nil {
		return false
	}
	return x.OptBool != nil
}

func (x *Extensions) HasOptInt32() bool {
	if x == nil {
		return false
	}
	return x.OptInt32 != nil
}

func (x *Extensions) ClearOptString() {
	x.OptString = nil
}

func (x *Extensions) ClearOptBool() {
	x.OptBool = nil
}

func (x *Extensions) ClearOptInt32() {
	x.OptInt32 = nil
}

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

	OptString *string
	OptBool   *bool
	OptInt32  *int32
}

func (b0 Extensions_builder) Build() *Extensions {
	m0 := &Extensions{}
	b, x := &b0, m0
	_, _ = b, x
	x.OptString = b.OptString
	x.OptBool = b.OptBool
	x.OptInt32 = b.OptInt32
	return m0
}

type ExtensionsContainer struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ExtensionsContainer) ProtoMessage() {}

func (x *ExtensionsContainer) ProtoReflect() protoreflect.Message {
	mi := &file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_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)
}

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

}

func (b0 ExtensionsContainer_builder) Build() *ExtensionsContainer {
	m0 := &ExtensionsContainer{}
	b, x := &b0, m0
	_, _ = b, x
	return m0
}

type MessageSet struct {
	state           protoimpl.MessageState `protogen:"hybrid.v1"`
	extensionFields protoimpl.ExtensionFields
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

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

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

func (*MessageSet) ProtoMessage() {}

func (x *MessageSet) ProtoReflect() protoreflect.Message {
	mi := &file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_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)
}

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

}

func (b0 MessageSet_builder) Build() *MessageSet {
	m0 := &MessageSet{}
	b, x := &b0, m0
	_, _ = b, x
	return m0
}

type MessageSetExtension struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	OptString     *string                `protobuf:"bytes,1,opt,name=opt_string,json=optString" json:"opt_string,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*MessageSetExtension) ProtoMessage() {}

func (x *MessageSetExtension) ProtoReflect() protoreflect.Message {
	mi := &file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_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 *MessageSetExtension) GetOptString() string {
	if x != nil && x.OptString != nil {
		return *x.OptString
	}
	return ""
}

func (x *MessageSetExtension) SetOptString(v string) {
	x.OptString = &v
}

func (x *MessageSetExtension) HasOptString() bool {
	if x == nil {
		return false
	}
	return x.OptString != nil
}

func (x *MessageSetExtension) ClearOptString() {
	x.OptString = nil
}

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

	OptString *string
}

func (b0 MessageSetExtension_builder) Build() *MessageSetExtension {
	m0 := &MessageSetExtension{}
	b, x := &b0, m0
	_, _ = b, x
	x.OptString = b.OptString
	return m0
}

type FakeMessageSet struct {
	state           protoimpl.MessageState `protogen:"hybrid.v1"`
	extensionFields protoimpl.ExtensionFields
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

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

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

func (*FakeMessageSet) ProtoMessage() {}

func (x *FakeMessageSet) ProtoReflect() protoreflect.Message {
	mi := &file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_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)
}

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

}

func (b0 FakeMessageSet_builder) Build() *FakeMessageSet {
	m0 := &FakeMessageSet{}
	b, x := &b0, m0
	_, _ = b, x
	return m0
}

type FakeMessageSetExtension struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	OptString     *string                `protobuf:"bytes,1,opt,name=opt_string,json=optString" json:"opt_string,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*FakeMessageSetExtension) ProtoMessage() {}

func (x *FakeMessageSetExtension) ProtoReflect() protoreflect.Message {
	mi := &file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_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 *FakeMessageSetExtension) GetOptString() string {
	if x != nil && x.OptString != nil {
		return *x.OptString
	}
	return ""
}

func (x *FakeMessageSetExtension) SetOptString(v string) {
	x.OptString = &v
}

func (x *FakeMessageSetExtension) HasOptString() bool {
	if x == nil {
		return false
	}
	return x.OptString != nil
}

func (x *FakeMessageSetExtension) ClearOptString() {
	x.OptString = nil
}

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

	OptString *string
}

func (b0 FakeMessageSetExtension_builder) Build() *FakeMessageSetExtension {
	m0 := &FakeMessageSetExtension{}
	b, x := &b0, m0
	_, _ = b, x
	x.OptString = b.OptString
	return m0
}

// Message contains well-known type fields.
type KnownTypes struct {
	state         protoimpl.MessageState  `protogen:"hybrid.v1"`
	OptBool       *wrapperspb.BoolValue   `protobuf:"bytes,1,opt,name=opt_bool,json=optBool" json:"opt_bool,omitempty"`
	OptInt32      *wrapperspb.Int32Value  `protobuf:"bytes,2,opt,name=opt_int32,json=optInt32" json:"opt_int32,omitempty"`
	OptInt64      *wrapperspb.Int64Value  `protobuf:"bytes,3,opt,name=opt_int64,json=optInt64" json:"opt_int64,omitempty"`
	OptUint32     *wrapperspb.UInt32Value `protobuf:"bytes,4,opt,name=opt_uint32,json=optUint32" json:"opt_uint32,omitempty"`
	OptUint64     *wrapperspb.UInt64Value `protobuf:"bytes,5,opt,name=opt_uint64,json=optUint64" json:"opt_uint64,omitempty"`
	OptFloat      *wrapperspb.FloatValue  `protobuf:"bytes,6,opt,name=opt_float,json=optFloat" json:"opt_float,omitempty"`
	OptDouble     *wrapperspb.DoubleValue `protobuf:"bytes,7,opt,name=opt_double,json=optDouble" json:"opt_double,omitempty"`
	OptString     *wrapperspb.StringValue `protobuf:"bytes,8,opt,name=opt_string,json=optString" json:"opt_string,omitempty"`
	OptBytes      *wrapperspb.BytesValue  `protobuf:"bytes,9,opt,name=opt_bytes,json=optBytes" json:"opt_bytes,omitempty"`
	OptDuration   *durationpb.Duration    `protobuf:"bytes,20,opt,name=opt_duration,json=optDuration" json:"opt_duration,omitempty"`
	OptTimestamp  *timestamppb.Timestamp  `protobuf:"bytes,21,opt,name=opt_timestamp,json=optTimestamp" json:"opt_timestamp,omitempty"`
	OptStruct     *structpb.Struct        `protobuf:"bytes,25,opt,name=opt_struct,json=optStruct" json:"opt_struct,omitempty"`
	OptList       *structpb.ListValue     `protobuf:"bytes,26,opt,name=opt_list,json=optList" json:"opt_list,omitempty"`
	OptValue      *structpb.Value         `protobuf:"bytes,27,opt,name=opt_value,json=optValue" json:"opt_value,omitempty"`
	OptNull       *structpb.NullValue     `protobuf:"varint,28,opt,name=opt_null,json=optNull,enum=google.protobuf.NullValue" json:"opt_null,omitempty"`
	OptEmpty      *emptypb.Empty          `protobuf:"bytes,30,opt,name=opt_empty,json=optEmpty" json:"opt_empty,omitempty"`
	OptAny        *anypb.Any              `protobuf:"bytes,32,opt,name=opt_any,json=optAny" json:"opt_any,omitempty"`
	OptFieldmask  *fieldmaskpb.FieldMask  `protobuf:"bytes,40,opt,name=opt_fieldmask,json=optFieldmask" json:"opt_fieldmask,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*KnownTypes) ProtoMessage() {}

func (x *KnownTypes) ProtoReflect() protoreflect.Message {
	mi := &file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_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 *KnownTypes) GetOptBool() *wrapperspb.BoolValue {
	if x != nil {
		return x.OptBool
	}
	return nil
}

func (x *KnownTypes) GetOptInt32() *wrapperspb.Int32Value {
	if x != nil {
		return x.OptInt32
	}
	return nil
}

func (x *KnownTypes) GetOptInt64() *wrapperspb.Int64Value {
	if x != nil {
		return x.OptInt64
	}
	return nil
}

func (x *KnownTypes) GetOptUint32() *wrapperspb.UInt32Value {
	if x != nil {
		return x.OptUint32
	}
	return nil
}

func (x *KnownTypes) GetOptUint64() *wrapperspb.UInt64Value {
	if x != nil {
		return x.OptUint64
	}
	return nil
}

func (x *KnownTypes) GetOptFloat() *wrapperspb.FloatValue {
	if x != nil {
		return x.OptFloat
	}
	return nil
}

func (x *KnownTypes) GetOptDouble() *wrapperspb.DoubleValue {
	if x != nil {
		return x.OptDouble
	}
	return nil
}

func (x *KnownTypes) GetOptString() *wrapperspb.StringValue {
	if x != nil {
		return x.OptString
	}
	return nil
}

func (x *KnownTypes) GetOptBytes() *wrapperspb.BytesValue {
	if x != nil {
		return x.OptBytes
	}
	return nil
}

func (x *KnownTypes) GetOptDuration() *durationpb.Duration {
	if x != nil {
		return x.OptDuration
	}
	return nil
}

func (x *KnownTypes) GetOptTimestamp() *timestamppb.Timestamp {
	if x != nil {
		return x.OptTimestamp
	}
	return nil
}

func (x *KnownTypes) GetOptStruct() *structpb.Struct {
	if x != nil {
		return x.OptStruct
	}
	return nil
}

func (x *KnownTypes) GetOptList() *structpb.ListValue {
	if x != nil {
		return x.OptList
	}
	return nil
}

func (x *KnownTypes) GetOptValue() *structpb.Value {
	if x != nil {
		return x.OptValue
	}
	return nil
}

func (x *KnownTypes) GetOptNull() structpb.NullValue {
	if x != nil && x.OptNull != nil {
		return *x.OptNull
	}
	return structpb.NullValue(0)
}

func (x *KnownTypes) GetOptEmpty() *emptypb.Empty {
	if x != nil {
		return x.OptEmpty
	}
	return nil
}

func (x *KnownTypes) GetOptAny() *anypb.Any {
	if x != nil {
		return x.OptAny
	}
	return nil
}

func (x *KnownTypes) GetOptFieldmask() *fieldmaskpb.FieldMask {
	if x != nil {
		return x.OptFieldmask
	}
	return nil
}

func (x *KnownTypes) SetOptBool(v *wrapperspb.BoolValue) {
	x.OptBool = v
}

func (x *KnownTypes) SetOptInt32(v *wrapperspb.Int32Value) {
	x.OptInt32 = v
}

func (x *KnownTypes) SetOptInt64(v *wrapperspb.Int64Value) {
	x.OptInt64 = v
}

func (x *KnownTypes) SetOptUint32(v *wrapperspb.UInt32Value) {
	x.OptUint32 = v
}

func (x *KnownTypes) SetOptUint64(v *wrapperspb.UInt64Value) {
	x.OptUint64 = v
}

func (x *KnownTypes) SetOptFloat(v *wrapperspb.FloatValue) {
	x.OptFloat = v
}

func (x *KnownTypes) SetOptDouble(v *wrapperspb.DoubleValue) {
	x.OptDouble = v
}

func (x *KnownTypes) SetOptString(v *wrapperspb.StringValue) {
	x.OptString = v
}

func (x *KnownTypes) SetOptBytes(v *wrapperspb.BytesValue) {
	x.OptBytes = v
}

func (x *KnownTypes) SetOptDuration(v *durationpb.Duration) {
	x.OptDuration = v
}

func (x *KnownTypes) SetOptTimestamp(v *timestamppb.Timestamp) {
	x.OptTimestamp = v
}

func (x *KnownTypes) SetOptStruct(v *structpb.Struct) {
	x.OptStruct = v
}

func (x *KnownTypes) SetOptList(v *structpb.ListValue) {
	x.OptList = v
}

func (x *KnownTypes) SetOptValue(v *structpb.Value) {
	x.OptValue = v
}

func (x *KnownTypes) SetOptNull(v structpb.NullValue) {
	x.OptNull = &v
}

func (x *KnownTypes) SetOptEmpty(v *emptypb.Empty) {
	x.OptEmpty = v
}

func (x *KnownTypes) SetOptAny(v *anypb.Any) {
	x.OptAny = v
}

func (x *KnownTypes) SetOptFieldmask(v *fieldmaskpb.FieldMask) {
	x.OptFieldmask = v
}

func (x *KnownTypes) HasOptBool() bool {
	if x == nil {
		return false
	}
	return x.OptBool != nil
}

func (x *KnownTypes) HasOptInt32() bool {
	if x == nil {
		return false
	}
	return x.OptInt32 != nil
}

func (x *KnownTypes) HasOptInt64() bool {
	if x == nil {
		return false
	}
	return x.OptInt64 != nil
}

func (x *KnownTypes) HasOptUint32() bool {
	if x == nil {
		return false
	}
	return x.OptUint32 != nil
}

func (x *KnownTypes) HasOptUint64() bool {
	if x == nil {
		return false
	}
	return x.OptUint64 != nil
}

func (x *KnownTypes) HasOptFloat() bool {
	if x == nil {
		return false
	}
	return x.OptFloat != nil
}

func (x *KnownTypes) HasOptDouble() bool {
	if x == nil {
		return false
	}
	return x.OptDouble != nil
}

func (x *KnownTypes) HasOptString() bool {
	if x == nil {
		return false
	}
	return x.OptString != nil
}

func (x *KnownTypes) HasOptBytes() bool {
	if x == nil {
		return false
	}
	return x.OptBytes != nil
}

func (x *KnownTypes) HasOptDuration() bool {
	if x == nil {
		return false
	}
	return x.OptDuration != nil
}

func (x *KnownTypes) HasOptTimestamp() bool {
	if x == nil {
		return false
	}
	return x.OptTimestamp != nil
}

func (x *KnownTypes) HasOptStruct() bool {
	if x == nil {
		return false
	}
	return x.OptStruct != nil
}

func (x *KnownTypes) HasOptList() bool {
	if x == nil {
		return false
	}
	return x.OptList != nil
}

func (x *KnownTypes) HasOptValue() bool {
	if x == nil {
		return false
	}
	return x.OptValue != nil
}

func (x *KnownTypes) HasOptNull() bool {
	if x == nil {
		return false
	}
	return x.OptNull != nil
}

func (x *KnownTypes) HasOptEmpty() bool {
	if x == nil {
		return false
	}
	return x.OptEmpty != nil
}

func (x *KnownTypes) HasOptAny() bool {
	if x == nil {
		return false
	}
	return x.OptAny != nil
}

func (x *KnownTypes) HasOptFieldmask() bool {
	if x == nil {
		return false
	}
	return x.OptFieldmask != nil
}

func (x *KnownTypes) ClearOptBool() {
	x.OptBool = nil
}

func (x *KnownTypes) ClearOptInt32() {
	x.OptInt32 = nil
}

func (x *KnownTypes) ClearOptInt64() {
	x.OptInt64 = nil
}

func (x *KnownTypes) ClearOptUint32() {
	x.OptUint32 = nil
}

func (x *KnownTypes) ClearOptUint64() {
	x.OptUint64 = nil
}

func (x *KnownTypes) ClearOptFloat() {
	x.OptFloat = nil
}

func (x *KnownTypes) ClearOptDouble() {
	x.OptDouble = nil
}

func (x *KnownTypes) ClearOptString() {
	x.OptString = nil
}

func (x *KnownTypes) ClearOptBytes() {
	x.OptBytes = nil
}

func (x *KnownTypes) ClearOptDuration() {
	x.OptDuration = nil
}

func (x *KnownTypes) ClearOptTimestamp() {
	x.OptTimestamp = nil
}

func (x *KnownTypes) ClearOptStruct() {
	x.OptStruct = nil
}

func (x *KnownTypes) ClearOptList() {
	x.OptList = nil
}

func (x *KnownTypes) ClearOptValue() {
	x.OptValue = nil
}

func (x *KnownTypes) ClearOptNull() {
	x.OptNull = nil
}

func (x *KnownTypes) ClearOptEmpty() {
	x.OptEmpty = nil
}

func (x *KnownTypes) ClearOptAny() {
	x.OptAny = nil
}

func (x *KnownTypes) ClearOptFieldmask() {
	x.OptFieldmask = nil
}

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

	OptBool      *wrapperspb.BoolValue
	OptInt32     *wrapperspb.Int32Value
	OptInt64     *wrapperspb.Int64Value
	OptUint32    *wrapperspb.UInt32Value
	OptUint64    *wrapperspb.UInt64Value
	OptFloat     *wrapperspb.FloatValue
	OptDouble    *wrapperspb.DoubleValue
	OptString    *wrapperspb.StringValue
	OptBytes     *wrapperspb.BytesValue
	OptDuration  *durationpb.Duration
	OptTimestamp *timestamppb.Timestamp
	OptStruct    *structpb.Struct
	OptList      *structpb.ListValue
	OptValue     *structpb.Value
	OptNull      *structpb.NullValue
	OptEmpty     *emptypb.Empty
	OptAny       *anypb.Any
	OptFieldmask *fieldmaskpb.FieldMask
}

func (b0 KnownTypes_builder) Build() *KnownTypes {
	m0 := &KnownTypes{}
	b, x := &b0, m0
	_, _ = b, x
	x.OptBool = b.OptBool
	x.OptInt32 = b.OptInt32
	x.OptInt64 = b.OptInt64
	x.OptUint32 = b.OptUint32
	x.OptUint64 = b.OptUint64
	x.OptFloat = b.OptFloat
	x.OptDouble = b.OptDouble
	x.OptString = b.OptString
	x.OptBytes = b.OptBytes
	x.OptDuration = b.OptDuration
	x.OptTimestamp = b.OptTimestamp
	x.OptStruct = b.OptStruct
	x.OptList = b.OptList
	x.OptValue = b.OptValue
	x.OptNull = b.OptNull
	x.OptEmpty = b.OptEmpty
	x.OptAny = b.OptAny
	x.OptFieldmask = b.OptFieldmask
	return m0
}

type Nests_OptGroup struct {
	state                protoimpl.MessageState         `protogen:"hybrid.v1"`
	OptString            *string                        `protobuf:"bytes,1,opt,name=opt_string,json=optString" json:"opt_string,omitempty"`
	OptNested            *Nested                        `protobuf:"bytes,2,opt,name=opt_nested,json=optNested" json:"opt_nested,omitempty"`
	Optnestedgroup       *Nests_OptGroup_OptNestedGroup `protobuf:"group,3,opt,name=OptNestedGroup,json=optnestedgroup" json:"optnestedgroup,omitempty"`
	NestedDelimitedField *Nests_OptGroup_OptNestedGroup `protobuf:"group,4,opt,name=OptNestedGroup,json=nestedDelimitedField" json:"nested_delimited_field,omitempty"`
	unknownFields        protoimpl.UnknownFields
	sizeCache            protoimpl.SizeCache
}

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

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

func (*Nests_OptGroup) ProtoMessage() {}

func (x *Nests_OptGroup) ProtoReflect() protoreflect.Message {
	mi := &file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_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 *Nests_OptGroup) GetOptString() string {
	if x != nil && x.OptString != nil {
		return *x.OptString
	}
	return ""
}

func (x *Nests_OptGroup) GetOptNested() *Nested {
	if x != nil {
		return x.OptNested
	}
	return nil
}

func (x *Nests_OptGroup) GetOptnestedgroup() *Nests_OptGroup_OptNestedGroup {
	if x != nil {
		return x.Optnestedgroup
	}
	return nil
}

func (x *Nests_OptGroup) GetNestedDelimitedField() *Nests_OptGroup_OptNestedGroup {
	if x != nil {
		return x.NestedDelimitedField
	}
	return nil
}

func (x *Nests_OptGroup) SetOptString(v string) {
	x.OptString = &v
}

func (x *Nests_OptGroup) SetOptNested(v *Nested) {
	x.OptNested = v
}

func (x *Nests_OptGroup) SetOptnestedgroup(v *Nests_OptGroup_OptNestedGroup) {
	x.Optnestedgroup = v
}

func (x *Nests_OptGroup) SetNestedDelimitedField(v *Nests_OptGroup_OptNestedGroup) {
	x.NestedDelimitedField = v
}

func (x *Nests_OptGroup) HasOptString() bool {
	if x == nil {
		return false
	}
	return x.OptString != nil
}

func (x *Nests_OptGroup) HasOptNested() bool {
	if x == nil {
		return false
	}
	return x.OptNested != nil
}

func (x *Nests_OptGroup) HasOptnestedgroup() bool {
	if x == nil {
		return false
	}
	return x.Optnestedgroup != nil
}

func (x *Nests_OptGroup) HasNestedDelimitedField() bool {
	if x == nil {
		return false
	}
	return x.NestedDelimitedField != nil
}

func (x *Nests_OptGroup) ClearOptString() {
	x.OptString = nil
}

func (x *Nests_OptGroup) ClearOptNested() {
	x.OptNested = nil
}

func (x *Nests_OptGroup) ClearOptnestedgroup() {
	x.Optnestedgroup = nil
}

func (x *Nests_OptGroup) ClearNestedDelimitedField() {
	x.NestedDelimitedField = nil
}

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

	OptString            *string
	OptNested            *Nested
	Optnestedgroup       *Nests_OptGroup_OptNestedGroup
	NestedDelimitedField *Nests_OptGroup_OptNestedGroup
}

func (b0 Nests_OptGroup_builder) Build() *Nests_OptGroup {
	m0 := &Nests_OptGroup{}
	b, x := &b0, m0
	_, _ = b, x
	x.OptString = b.OptString
	x.OptNested = b.OptNested
	x.Optnestedgroup = b.Optnestedgroup
	x.NestedDelimitedField = b.NestedDelimitedField
	return m0
}

type Nests_RptGroup struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	RptString     []string               `protobuf:"bytes,1,rep,name=rpt_string,json=rptString" json:"rpt_string,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Nests_RptGroup) ProtoMessage() {}

func (x *Nests_RptGroup) ProtoReflect() protoreflect.Message {
	mi := &file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_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 *Nests_RptGroup) GetRptString() []string {
	if x != nil {
		return x.RptString
	}
	return nil
}

func (x *Nests_RptGroup) SetRptString(v []string) {
	x.RptString = v
}

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

	RptString []string
}

func (b0 Nests_RptGroup_builder) Build() *Nests_RptGroup {
	m0 := &Nests_RptGroup{}
	b, x := &b0, m0
	_, _ = b, x
	x.RptString = b.RptString
	return m0
}

type Nests_OptGroup_OptNestedGroup struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	OptFixed32    *uint32                `protobuf:"fixed32,1,opt,name=opt_fixed32,json=optFixed32" json:"opt_fixed32,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Nests_OptGroup_OptNestedGroup) ProtoMessage() {}

func (x *Nests_OptGroup_OptNestedGroup) ProtoReflect() protoreflect.Message {
	mi := &file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_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 *Nests_OptGroup_OptNestedGroup) GetOptFixed32() uint32 {
	if x != nil && x.OptFixed32 != nil {
		return *x.OptFixed32
	}
	return 0
}

func (x *Nests_OptGroup_OptNestedGroup) SetOptFixed32(v uint32) {
	x.OptFixed32 = &v
}

func (x *Nests_OptGroup_OptNestedGroup) HasOptFixed32() bool {
	if x == nil {
		return false
	}
	return x.OptFixed32 != nil
}

func (x *Nests_OptGroup_OptNestedGroup) ClearOptFixed32() {
	x.OptFixed32 = nil
}

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

	OptFixed32 *uint32
}

func (b0 Nests_OptGroup_OptNestedGroup_builder) Build() *Nests_OptGroup_OptNestedGroup {
	m0 := &Nests_OptGroup_OptNestedGroup{}
	b, x := &b0, m0
	_, _ = b, x
	x.OptFixed32 = b.OptFixed32
	return m0
}

var file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_proto_extTypes = []protoimpl.ExtensionInfo{
	{
		ExtendedType:  (*Extensions)(nil),
		ExtensionType: (*bool)(nil),
		Field:         21,
		Name:          "hybrid.pbeditions.opt_ext_bool",
		Tag:           "varint,21,opt,name=opt_ext_bool",
		Filename:      "internal/testprotos/textpbeditions/textpbeditions_hybrid/test2.hybrid.proto",
	},
	{
		ExtendedType:  (*Extensions)(nil),
		ExtensionType: (*string)(nil),
		Field:         22,
		Name:          "hybrid.pbeditions.opt_ext_string",
		Tag:           "bytes,22,opt,name=opt_ext_string",
		Filename:      "internal/testprotos/textpbeditions/textpbeditions_hybrid/test2.hybrid.proto",
	},
	{
		ExtendedType:  (*Extensions)(nil),
		ExtensionType: (*Enum)(nil),
		Field:         23,
		Name:          "hybrid.pbeditions.opt_ext_enum",
		Tag:           "varint,23,opt,name=opt_ext_enum,enum=hybrid.pbeditions.Enum",
		Filename:      "internal/testprotos/textpbeditions/textpbeditions_hybrid/test2.hybrid.proto",
	},
	{
		ExtendedType:  (*Extensions)(nil),
		ExtensionType: (*Nested)(nil),
		Field:         24,
		Name:          "hybrid.pbeditions.opt_ext_nested",
		Tag:           "bytes,24,opt,name=opt_ext_nested",
		Filename:      "internal/testprotos/textpbeditions/textpbeditions_hybrid/test2.hybrid.proto",
	},
	{
		ExtendedType:  (*Extensions)(nil),
		ExtensionType: (*PartialRequired)(nil),
		Field:         25,
		Name:          "hybrid.pbeditions.opt_ext_partial",
		Tag:           "bytes,25,opt,name=opt_ext_partial",
		Filename:      "internal/testprotos/textpbeditions/textpbeditions_hybrid/test2.hybrid.proto",
	},
	{
		ExtendedType:  (*Extensions)(nil),
		ExtensionType: ([]uint32)(nil),
		Field:         31,
		Name:          "hybrid.pbeditions.rpt_ext_fixed32",
		Tag:           "fixed32,31,rep,packed,name=rpt_ext_fixed32",
		Filename:      "internal/testprotos/textpbeditions/textpbeditions_hybrid/test2.hybrid.proto",
	},
	{
		ExtendedType:  (*Extensions)(nil),
		ExtensionType: ([]Enum)(nil),
		Field:         32,
		Name:          "hybrid.pbeditions.rpt_ext_enum",
		Tag:           "varint,32,rep,packed,name=rpt_ext_enum,enum=hybrid.pbeditions.Enum",
		Filename:      "internal/testprotos/textpbeditions/textpbeditions_hybrid/test2.hybrid.proto",
	},
	{
		ExtendedType:  (*Extensions)(nil),
		ExtensionType: ([]*Nested)(nil),
		Field:         33,
		Name:          "hybrid.pbeditions.rpt_ext_nested",
		Tag:           "bytes,33,rep,name=rpt_ext_nested",
		Filename:      "internal/testprotos/textpbeditions/textpbeditions_hybrid/test2.hybrid.proto",
	},
	{
		ExtendedType:  (*MessageSet)(nil),
		ExtensionType: (*FakeMessageSetExtension)(nil),
		Field:         50,
		Name:          "hybrid.pbeditions.message_set_extension",
		Tag:           "bytes,50,opt,name=message_set_extension",
		Filename:      "internal/testprotos/textpbeditions/textpbeditions_hybrid/test2.hybrid.proto",
	},
	{
		ExtendedType:  (*Extensions)(nil),
		ExtensionType: (*bool)(nil),
		Field:         51,
		Name:          "hybrid.pbeditions.ExtensionsContainer.opt_ext_bool",
		Tag:           "varint,51,opt,name=opt_ext_bool",
		Filename:      "internal/testprotos/textpbeditions/textpbeditions_hybrid/test2.hybrid.proto",
	},
	{
		ExtendedType:  (*Extensions)(nil),
		ExtensionType: (*string)(nil),
		Field:         52,
		Name:          "hybrid.pbeditions.ExtensionsContainer.opt_ext_string",
		Tag:           "bytes,52,opt,name=opt_ext_string",
		Filename:      "internal/testprotos/textpbeditions/textpbeditions_hybrid/test2.hybrid.proto",
	},
	{
		ExtendedType:  (*Extensions)(nil),
		ExtensionType: (*Enum)(nil),
		Field:         53,
		Name:          "hybrid.pbeditions.ExtensionsContainer.opt_ext_enum",
		Tag:           "varint,53,opt,name=opt_ext_enum,enum=hybrid.pbeditions.Enum",
		Filename:      "internal/testprotos/textpbeditions/textpbeditions_hybrid/test2.hybrid.proto",
	},
	{
		ExtendedType:  (*Extensions)(nil),
		ExtensionType: (*Nested)(nil),
		Field:         54,
		Name:          "hybrid.pbeditions.ExtensionsContainer.opt_ext_nested",
		Tag:           "bytes,54,opt,name=opt_ext_nested",
		Filename:      "internal/testprotos/textpbeditions/textpbeditions_hybrid/test2.hybrid.proto",
	},
	{
		ExtendedType:  (*Extensions)(nil),
		ExtensionType: (*PartialRequired)(nil),
		Field:         55,
		Name:          "hybrid.pbeditions.ExtensionsContainer.opt_ext_partial",
		Tag:           "bytes,55,opt,name=opt_ext_partial",
		Filename:      "internal/testprotos/textpbeditions/textpbeditions_hybrid/test2.hybrid.proto",
	},
	{
		ExtendedType:  (*Extensions)(nil),
		ExtensionType: ([]string)(nil),
		Field:         61,
		Name:          "hybrid.pbeditions.ExtensionsContainer.rpt_ext_string",
		Tag:           "bytes,61,rep,name=rpt_ext_string",
		Filename:      "internal/testprotos/textpbeditions/textpbeditions_hybrid/test2.hybrid.proto",
	},
	{
		ExtendedType:  (*Extensions)(nil),
		ExtensionType: ([]Enum)(nil),
		Field:         62,
		Name:          "hybrid.pbeditions.ExtensionsContainer.rpt_ext_enum",
		Tag:           "varint,62,rep,packed,name=rpt_ext_enum,enum=hybrid.pbeditions.Enum",
		Filename:      "internal/testprotos/textpbeditions/textpbeditions_hybrid/test2.hybrid.proto",
	},
	{
		ExtendedType:  (*Extensions)(nil),
		ExtensionType: ([]*Nested)(nil),
		Field:         63,
		Name:          "hybrid.pbeditions.ExtensionsContainer.rpt_ext_nested",
		Tag:           "bytes,63,rep,name=rpt_ext_nested",
		Filename:      "internal/testprotos/textpbeditions/textpbeditions_hybrid/test2.hybrid.proto",
	},
	{
		ExtendedType:  (*MessageSet)(nil),
		ExtensionType: (*MessageSetExtension)(nil),
		Field:         10,
		Name:          "hybrid.pbeditions.MessageSetExtension.message_set_extension",
		Tag:           "bytes,10,opt,name=message_set_extension",
		Filename:      "internal/testprotos/textpbeditions/textpbeditions_hybrid/test2.hybrid.proto",
	},
	{
		ExtendedType:  (*MessageSet)(nil),
		ExtensionType: (*MessageSetExtension)(nil),
		Field:         20,
		Name:          "hybrid.pbeditions.MessageSetExtension.not_message_set_extension",
		Tag:           "bytes,20,opt,name=not_message_set_extension",
		Filename:      "internal/testprotos/textpbeditions/textpbeditions_hybrid/test2.hybrid.proto",
	},
	{
		ExtendedType:  (*MessageSet)(nil),
		ExtensionType: (*Nested)(nil),
		Field:         30,
		Name:          "hybrid.pbeditions.MessageSetExtension.ext_nested",
		Tag:           "bytes,30,opt,name=ext_nested",
		Filename:      "internal/testprotos/textpbeditions/textpbeditions_hybrid/test2.hybrid.proto",
	},
	{
		ExtendedType:  (*FakeMessageSet)(nil),
		ExtensionType: (*FakeMessageSetExtension)(nil),
		Field:         10,
		Name:          "hybrid.pbeditions.FakeMessageSetExtension.message_set_extension",
		Tag:           "bytes,10,opt,name=message_set_extension",
		Filename:      "internal/testprotos/textpbeditions/textpbeditions_hybrid/test2.hybrid.proto",
	},
}

// Extension fields to Extensions.
var (
	// optional bool opt_ext_bool = 21;
	E_OptExtBool = &file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_proto_extTypes[0]
	// optional string opt_ext_string = 22;
	E_OptExtString = &file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_proto_extTypes[1]
	// optional hybrid.pbeditions.Enum opt_ext_enum = 23;
	E_OptExtEnum = &file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_proto_extTypes[2]
	// optional hybrid.pbeditions.Nested opt_ext_nested = 24;
	E_OptExtNested = &file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_proto_extTypes[3]
	// optional hybrid.pbeditions.PartialRequired opt_ext_partial = 25;
	E_OptExtPartial = &file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_proto_extTypes[4]
	// repeated fixed32 rpt_ext_fixed32 = 31;
	E_RptExtFixed32 = &file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_proto_extTypes[5]
	// repeated hybrid.pbeditions.Enum rpt_ext_enum = 32;
	E_RptExtEnum = &file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_proto_extTypes[6]
	// repeated hybrid.pbeditions.Nested rpt_ext_nested = 33;
	E_RptExtNested = &file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_proto_extTypes[7]
	// optional bool opt_ext_bool = 51;
	E_ExtensionsContainer_OptExtBool = &file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_proto_extTypes[9]
	// optional string opt_ext_string = 52;
	E_ExtensionsContainer_OptExtString = &file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_proto_extTypes[10]
	// optional hybrid.pbeditions.Enum opt_ext_enum = 53;
	E_ExtensionsContainer_OptExtEnum = &file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_proto_extTypes[11]
	// optional hybrid.pbeditions.Nested opt_ext_nested = 54;
	E_ExtensionsContainer_OptExtNested = &file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_proto_extTypes[12]
	// optional hybrid.pbeditions.PartialRequired opt_ext_partial = 55;
	E_ExtensionsContainer_OptExtPartial = &file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_proto_extTypes[13]
	// repeated string rpt_ext_string = 61;
	E_ExtensionsContainer_RptExtString = &file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_proto_extTypes[14]
	// repeated hybrid.pbeditions.Enum rpt_ext_enum = 62;
	E_ExtensionsContainer_RptExtEnum = &file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_proto_extTypes[15]
	// repeated hybrid.pbeditions.Nested rpt_ext_nested = 63;
	E_ExtensionsContainer_RptExtNested = &file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_proto_extTypes[16]
)

// Extension fields to MessageSet.
var (
	// optional hybrid.pbeditions.FakeMessageSetExtension message_set_extension = 50;
	E_MessageSetExtension = &file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_proto_extTypes[8]
	// optional hybrid.pbeditions.MessageSetExtension message_set_extension = 10;
	E_MessageSetExtension_MessageSetExtension = &file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_proto_extTypes[17]
	// optional hybrid.pbeditions.MessageSetExtension not_message_set_extension = 20;
	E_MessageSetExtension_NotMessageSetExtension = &file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_proto_extTypes[18]
	// optional hybrid.pbeditions.Nested ext_nested = 30;
	E_MessageSetExtension_ExtNested = &file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_proto_extTypes[19]
)

// Extension fields to FakeMessageSet.
var (
	// optional hybrid.pbeditions.FakeMessageSetExtension message_set_extension = 10;
	E_FakeMessageSetExtension_MessageSetExtension = &file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_proto_extTypes[20]
)

var File_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_proto protoreflect.FileDescriptor

const file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_proto_rawDesc = "" +
	"\n" +
	"Kinternal/testprotos/textpbeditions/textpbeditions_hybrid/test2.hybrid.proto\x12\x11hybrid.pbeditions\x1a\x19google/protobuf/any.proto\x1a\x1egoogle/protobuf/duration.proto\x1a\x1bgoogle/protobuf/empty.proto\x1a google/protobuf/field_mask.proto\x1a\x1cgoogle/protobuf/struct.proto\x1a\x1fgoogle/protobuf/timestamp.proto\x1a\x1egoogle/protobuf/wrappers.proto\x1a!google/protobuf/go_features.proto\"\xda\x03\n" +
	"\aScalars\x12\x19\n" +
	"\bopt_bool\x18\x01 \x01(\bR\aoptBool\x12\x1b\n" +
	"\topt_int32\x18\x02 \x01(\x05R\boptInt32\x12\x1b\n" +
	"\topt_int64\x18\x03 \x01(\x03R\boptInt64\x12\x1d\n" +
	"\n" +
	"opt_uint32\x18\x04 \x01(\rR\toptUint32\x12\x1d\n" +
	"\n" +
	"opt_uint64\x18\x05 \x01(\x04R\toptUint64\x12\x1d\n" +
	"\n" +
	"opt_sint32\x18\x06 \x01(\x11R\toptSint32\x12\x1d\n" +
	"\n" +
	"opt_sint64\x18\a \x01(\x12R\toptSint64\x12\x1f\n" +
	"\vopt_fixed32\x18\b \x01(\aR\n" +
	"optFixed32\x12\x1f\n" +
	"\vopt_fixed64\x18\t \x01(\x06R\n" +
	"optFixed64\x12!\n" +
	"\fopt_sfixed32\x18\n" +
	" \x01(\x0fR\voptSfixed32\x12!\n" +
	"\fopt_sfixed64\x18\v \x01(\x10R\voptSfixed64\x12\x1b\n" +
	"\topt_float\x18\x14 \x01(\x02R\boptFloat\x12\x1d\n" +
	"\n" +
	"opt_double\x18\x15 \x01(\x01R\toptDouble\x12\x1b\n" +
	"\topt_bytes\x18\x0e \x01(\fR\boptBytes\x12\x1d\n" +
	"\n" +
	"opt_string\x18\r \x01(\tR\toptString\"\x8f\x04\n" +
	"\x0fImplicitScalars\x12\x1c\n" +
	"\x06s_bool\x18\x01 \x01(\bB\x05\xaa\x01\x02\b\x02R\x05sBool\x12\x1e\n" +
	"\as_int32\x18\x02 \x01(\x05B\x05\xaa\x01\x02\b\x02R\x06sInt32\x12\x1e\n" +
	"\as_int64\x18\x03 \x01(\x03B\x05\xaa\x01\x02\b\x02R\x06sInt64\x12 \n" +
	"\bs_uint32\x18\x04 \x01(\rB\x05\xaa\x01\x02\b\x02R\asUint32\x12 \n" +
	"\bs_uint64\x18\x05 \x01(\x04B\x05\xaa\x01\x02\b\x02R\asUint64\x12 \n" +
	"\bs_sint32\x18\x06 \x01(\x11B\x05\xaa\x01\x02\b\x02R\asSint32\x12 \n" +
	"\bs_sint64\x18\a \x01(\x12B\x05\xaa\x01\x02\b\x02R\asSint64\x12\"\n" +
	"\ts_fixed32\x18\b \x01(\aB\x05\xaa\x01\x02\b\x02R\bsFixed32\x12\"\n" +
	"\ts_fixed64\x18\t \x01(\x06B\x05\xaa\x01\x02\b\x02R\bsFixed64\x12$\n" +
	"\n" +
	"s_sfixed32\x18\n" +
	" \x01(\x0fB\x05\xaa\x01\x02\b\x02R\tsSfixed32\x12$\n" +
	"\n" +
	"s_sfixed64\x18\v \x01(\x10B\x05\xaa\x01\x02\b\x02R\tsSfixed64\x12\x1e\n" +
	"\as_float\x18\x14 \x01(\x02B\x05\xaa\x01\x02\b\x02R\x06sFloat\x12 \n" +
	"\bs_double\x18\x15 \x01(\x01B\x05\xaa\x01\x02\b\x02R\asDouble\x12\x1e\n" +
	"\as_bytes\x18\x0e \x01(\fB\x05\xaa\x01\x02\b\x02R\x06sBytes\x12 \n" +
	"\bs_string\x18\r \x01(\tB\x05\xaa\x01\x02\b\x02R\asString\"C\n" +
	"\rUTF8Validated\x122\n" +
	"\x10validated_string\x18\x01 \x01(\tB\a\xaa\x01\x04\b\x02 \x02R\x0fvalidatedString\"c\n" +
	"\x12NestsUTF8Validated\x12M\n" +
	"\x11validated_message\x18\x01 \x01(\v2 .hybrid.pbeditions.UTF8ValidatedR\x10validatedMessage\"\xa1\x04\n" +
	"\x05Enums\x122\n" +
	"\bopt_enum\x18\x01 \x01(\x0e2\x17.hybrid.pbeditions.EnumR\aoptEnum\x122\n" +
	"\brpt_enum\x18\x02 \x03(\x0e2\x17.hybrid.pbeditions.EnumR\arptEnum\x12G\n" +
	"\rimplicit_enum\x18\x05 \x01(\x0e2\x1b.hybrid.pbeditions.OpenEnumB\x05\xaa\x01\x02\b\x02R\fimplicitEnum\x12K\n" +
	"\x0fopt_nested_enum\x18\x03 \x01(\x0e2#.hybrid.pbeditions.Enums.NestedEnumR\roptNestedEnum\x12K\n" +
	"\x0frpt_nested_enum\x18\x04 \x03(\x0e2#.hybrid.pbeditions.Enums.NestedEnumR\rrptNestedEnum\x12`\n" +
	"\x14implicit_nested_enum\x18\x06 \x01(\x0e2'.hybrid.pbeditions.Enums.NestedOpenEnumB\x05\xaa\x01\x02\b\x02R\x12implicitNestedEnum\"(\n" +
	"\n" +
	"NestedEnum\x12\a\n" +
	"\x03UNO\x10\x01\x12\a\n" +
	"\x03DOS\x10\x02\x12\b\n" +
	"\x04DIEZ\x10\n" +
	"\"A\n" +
	"\x0eNestedOpenEnum\x12\v\n" +
	"\aUNKNOWN\x10\x00\x12\b\n" +
	"\x04EINS\x10\x01\x12\b\n" +
	"\x04ZWEI\x10\x02\x12\b\n" +
	"\x04ZEHN\x10\n" +
	"\x1a\x04:\x02\x10\x01\"\x94\x02\n" +
	"\aRepeats\x12\x19\n" +
	"\brpt_bool\x18\x01 \x03(\bR\arptBool\x12\x1b\n" +
	"\trpt_int32\x18\x02 \x03(\x05R\brptInt32\x12\x1b\n" +
	"\trpt_int64\x18\x03 \x03(\x03R\brptInt64\x12\x1d\n" +
	"\n" +
	"rpt_uint32\x18\x04 \x03(\rR\trptUint32\x12\x1d\n" +
	"\n" +
	"rpt_uint64\x18\x05 \x03(\x04R\trptUint64\x12\x1b\n" +
	"\trpt_float\x18\x06 \x03(\x02R\brptFloat\x12\x1d\n" +
	"\n" +
	"rpt_double\x18\a \x03(\x01R\trptDouble\x12\x1d\n" +
	"\n" +
	"rpt_string\x18\b \x03(\tR\trptString\x12\x1b\n" +
	"\trpt_bytes\x18\t \x03(\fR\brptBytes\"\xb9\x02\n" +
	"\x04Maps\x12I\n" +
	"\fint32_to_str\x18\x01 \x03(\v2'.hybrid.pbeditions.Maps.Int32ToStrEntryR\n" +
	"int32ToStr\x12L\n" +
	"\rstr_to_nested\x18\x04 \x03(\v2(.hybrid.pbeditions.Maps.StrToNestedEntryR\vstrToNested\x1a=\n" +
	"\x0fInt32ToStrEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\x05R\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\x1aY\n" +
	"\x10StrToNestedEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12/\n" +
	"\x05value\x18\x02 \x01(\v2\x19.hybrid.pbeditions.NestedR\x05value:\x028\x01\"a\n" +
	"\x06Nested\x12\x1d\n" +
	"\n" +
	"opt_string\x18\x01 \x01(\tR\toptString\x128\n" +
	"\n" +
	"opt_nested\x18\x02 \x01(\v2\x19.hybrid.pbeditions.NestedR\toptNested\"\x80\x06\n" +
	"\x05Nests\x128\n" +
	"\n" +
	"opt_nested\x18\x01 \x01(\v2\x19.hybrid.pbeditions.NestedR\toptNested\x12D\n" +
	"\boptgroup\x18\x02 \x01(\v2!.hybrid.pbeditions.Nests.OptGroupB\x05\xaa\x01\x02(\x02R\boptgroup\x12Q\n" +
	"\x0fdelimited_field\x18\x03 \x01(\v2!.hybrid.pbeditions.Nests.OptGroupB\x05\xaa\x01\x02(\x02R\x0edelimitedField\x128\n" +
	"\n" +
	"rpt_nested\x18\x04 \x03(\v2\x19.hybrid.pbeditions.NestedR\trptNested\x12F\n" +
	"\brptgroup\x18\x05 \x03(\v2!.hybrid.pbeditions.Nests.RptGroupB\a\xaa\x01\x04\x18\x02(\x02R\brptgroup\x1a\xe6\x02\n" +
	"\bOptGroup\x12\x1d\n" +
	"\n" +
	"opt_string\x18\x01 \x01(\tR\toptString\x128\n" +
	"\n" +
	"opt_nested\x18\x02 \x01(\v2\x19.hybrid.pbeditions.NestedR\toptNested\x12_\n" +
	"\x0eoptnestedgroup\x18\x03 \x01(\v20.hybrid.pbeditions.Nests.OptGroup.OptNestedGroupB\x05\xaa\x01\x02(\x02R\x0eoptnestedgroup\x12m\n" +
	"\x16nested_delimited_field\x18\x04 \x01(\v20.hybrid.pbeditions.Nests.OptGroup.OptNestedGroupB\x05\xaa\x01\x02(\x02R\x14nestedDelimitedField\x1a1\n" +
	"\x0eOptNestedGroup\x12\x1f\n" +
	"\vopt_fixed32\x18\x01 \x01(\aR\n" +
	"optFixed32\x1a)\n" +
	"\bRptGroup\x12\x1d\n" +
	"\n" +
	"rpt_string\x18\x01 \x03(\tR\trptStringR\x0ereserved_field\"\x9f\x02\n" +
	"\tRequireds\x12 \n" +
	"\breq_bool\x18\x01 \x01(\bB\x05\xaa\x01\x02\b\x03R\areqBool\x12(\n" +
	"\freq_sfixed64\x18\x02 \x01(\x10B\x05\xaa\x01\x02\b\x03R\vreqSfixed64\x12$\n" +
	"\n" +
	"req_double\x18\x03 \x01(\x01B\x05\xaa\x01\x02\b\x03R\treqDouble\x12$\n" +
	"\n" +
	"req_string\x18\x04 \x01(\tB\x05\xaa\x01\x02\b\x03R\treqString\x129\n" +
	"\breq_enum\x18\x05 \x01(\x0e2\x17.hybrid.pbeditions.EnumB\x05\xaa\x01\x02\b\x03R\areqEnum\x12?\n" +
	"\n" +
	"req_nested\x18\x06 \x01(\v2\x19.hybrid.pbeditions.NestedB\x05\xaa\x01\x02\b\x03R\treqNested\"V\n" +
	"\x0fPartialRequired\x12$\n" +
	"\n" +
	"req_string\x18\x01 \x01(\tB\x05\xaa\x01\x02\b\x03R\treqString\x12\x1d\n" +
	"\n" +
	"opt_string\x18\x02 \x01(\tR\toptString\":\n" +
	"\x12NestedWithRequired\x12$\n" +
	"\n" +
	"req_string\x18\x01 \x01(\tB\x05\xaa\x01\x02\b\x03R\treqString\"\xb4\x03\n" +
	"\x10IndirectRequired\x12D\n" +
	"\n" +
	"opt_nested\x18\x01 \x01(\v2%.hybrid.pbeditions.NestedWithRequiredR\toptNested\x12D\n" +
	"\n" +
	"rpt_nested\x18\x02 \x03(\v2%.hybrid.pbeditions.NestedWithRequiredR\trptNested\x12X\n" +
	"\rstr_to_nested\x18\x03 \x03(\v24.hybrid.pbeditions.IndirectRequired.StrToNestedEntryR\vstrToNested\x12J\n" +
	"\foneof_nested\x18\x04 \x01(\v2%.hybrid.pbeditions.NestedWithRequiredH\x00R\voneofNested\x1ae\n" +
	"\x10StrToNestedEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12;\n" +
	"\x05value\x18\x02 \x01(\v2%.hybrid.pbeditions.NestedWithRequiredR\x05value:\x028\x01B\a\n" +
	"\x05union\"i\n" +
	"\n" +
	"Extensions\x12\x1d\n" +
	"\n" +
	"opt_string\x18\x01 \x01(\tR\toptString\x12\x19\n" +
	"\bopt_bool\x18e \x01(\bR\aoptBool\x12\x1b\n" +
	"\topt_int32\x18\x02 \x01(\x05R\boptInt32*\x04\b\x14\x10e\"\xbf\x05\n" +
	"\x13ExtensionsContainer2?\n" +
	"\fopt_ext_bool\x12\x1d.hybrid.pbeditions.Extensions\x183 \x01(\bR\n" +
	"optExtBool2C\n" +
	"\x0eopt_ext_string\x12\x1d.hybrid.pbeditions.Extensions\x184 \x01(\tR\foptExtString2X\n" +
	"\fopt_ext_enum\x12\x1d.hybrid.pbeditions.Extensions\x185 \x01(\x0e2\x17.hybrid.pbeditions.EnumR\n" +
	"optExtEnum2^\n" +
	"\x0eopt_ext_nested\x12\x1d.hybrid.pbeditions.Extensions\x186 \x01(\v2\x19.hybrid.pbeditions.NestedR\foptExtNested2i\n" +
	"\x0fopt_ext_partial\x12\x1d.hybrid.pbeditions.Extensions\x187 \x01(\v2\".hybrid.pbeditions.PartialRequiredR\roptExtPartial2C\n" +
	"\x0erpt_ext_string\x12\x1d.hybrid.pbeditions.Extensions\x18= \x03(\tR\frptExtString2X\n" +
	"\frpt_ext_enum\x12\x1d.hybrid.pbeditions.Extensions\x18> \x03(\x0e2\x17.hybrid.pbeditions.EnumR\n" +
	"rptExtEnum2^\n" +
	"\x0erpt_ext_nested\x12\x1d.hybrid.pbeditions.Extensions\x18? \x03(\v2\x19.hybrid.pbeditions.NestedR\frptExtNested\"\x1a\n" +
	"\n" +
	"MessageSet*\b\b\x04\x10\xff\xff\xff\xff\a:\x02\b\x01\"\x8b\x03\n" +
	"\x13MessageSetExtension\x12\x1d\n" +
	"\n" +
	"opt_string\x18\x01 \x01(\tR\toptString2y\n" +
	"\x15message_set_extension\x12\x1d.hybrid.pbeditions.MessageSet\x18\n" +
	" \x01(\v2&.hybrid.pbeditions.MessageSetExtensionR\x13messageSetExtension2\x80\x01\n" +
	"\x19not_message_set_extension\x12\x1d.hybrid.pbeditions.MessageSet\x18\x14 \x01(\v2&.hybrid.pbeditions.MessageSetExtensionR\x16notMessageSetExtension2W\n" +
	"\n" +
	"ext_nested\x12\x1d.hybrid.pbeditions.MessageSet\x18\x1e \x01(\v2\x19.hybrid.pbeditions.NestedR\textNested\"\x1a\n" +
	"\x0eFakeMessageSet*\b\b\x04\x10\x80\x80\x80\x80\x02\"\xbc\x01\n" +
	"\x17FakeMessageSetExtension\x12\x1d\n" +
	"\n" +
	"opt_string\x18\x01 \x01(\tR\toptString2\x81\x01\n" +
	"\x15message_set_extension\x12!.hybrid.pbeditions.FakeMessageSet\x18\n" +
	" \x01(\v2*.hybrid.pbeditions.FakeMessageSetExtensionR\x13messageSetExtension\"\x9e\b\n" +
	"\n" +
	"KnownTypes\x125\n" +
	"\bopt_bool\x18\x01 \x01(\v2\x1a.google.protobuf.BoolValueR\aoptBool\x128\n" +
	"\topt_int32\x18\x02 \x01(\v2\x1b.google.protobuf.Int32ValueR\boptInt32\x128\n" +
	"\topt_int64\x18\x03 \x01(\v2\x1b.google.protobuf.Int64ValueR\boptInt64\x12;\n" +
	"\n" +
	"opt_uint32\x18\x04 \x01(\v2\x1c.google.protobuf.UInt32ValueR\toptUint32\x12;\n" +
	"\n" +
	"opt_uint64\x18\x05 \x01(\v2\x1c.google.protobuf.UInt64ValueR\toptUint64\x128\n" +
	"\topt_float\x18\x06 \x01(\v2\x1b.google.protobuf.FloatValueR\boptFloat\x12;\n" +
	"\n" +
	"opt_double\x18\a \x01(\v2\x1c.google.protobuf.DoubleValueR\toptDouble\x12;\n" +
	"\n" +
	"opt_string\x18\b \x01(\v2\x1c.google.protobuf.StringValueR\toptString\x128\n" +
	"\topt_bytes\x18\t \x01(\v2\x1b.google.protobuf.BytesValueR\boptBytes\x12<\n" +
	"\fopt_duration\x18\x14 \x01(\v2\x19.google.protobuf.DurationR\voptDuration\x12?\n" +
	"\ropt_timestamp\x18\x15 \x01(\v2\x1a.google.protobuf.TimestampR\foptTimestamp\x126\n" +
	"\n" +
	"opt_struct\x18\x19 \x01(\v2\x17.google.protobuf.StructR\toptStruct\x125\n" +
	"\bopt_list\x18\x1a \x01(\v2\x1a.google.protobuf.ListValueR\aoptList\x123\n" +
	"\topt_value\x18\x1b \x01(\v2\x16.google.protobuf.ValueR\boptValue\x125\n" +
	"\bopt_null\x18\x1c \x01(\x0e2\x1a.google.protobuf.NullValueR\aoptNull\x123\n" +
	"\topt_empty\x18\x1e \x01(\v2\x16.google.protobuf.EmptyR\boptEmpty\x12-\n" +
	"\aopt_any\x18  \x01(\v2\x14.google.protobuf.AnyR\x06optAny\x12?\n" +
	"\ropt_fieldmask\x18( \x01(\v2\x1a.google.protobuf.FieldMaskR\foptFieldmask*!\n" +
	"\x04Enum\x12\a\n" +
	"\x03ONE\x10\x01\x12\a\n" +
	"\x03TWO\x10\x02\x12\a\n" +
	"\x03TEN\x10\n" +
	"*;\n" +
	"\bOpenEnum\x12\v\n" +
	"\aUNKNOWN\x10\x00\x12\b\n" +
	"\x04EINS\x10\x01\x12\b\n" +
	"\x04ZWEI\x10\x02\x12\b\n" +
	"\x04ZEHN\x10\n" +
	"\x1a\x04:\x02\x10\x01:?\n" +
	"\fopt_ext_bool\x12\x1d.hybrid.pbeditions.Extensions\x18\x15 \x01(\bR\n" +
	"optExtBool:C\n" +
	"\x0eopt_ext_string\x12\x1d.hybrid.pbeditions.Extensions\x18\x16 \x01(\tR\foptExtString:X\n" +
	"\fopt_ext_enum\x12\x1d.hybrid.pbeditions.Extensions\x18\x17 \x01(\x0e2\x17.hybrid.pbeditions.EnumR\n" +
	"optExtEnum:^\n" +
	"\x0eopt_ext_nested\x12\x1d.hybrid.pbeditions.Extensions\x18\x18 \x01(\v2\x19.hybrid.pbeditions.NestedR\foptExtNested:i\n" +
	"\x0fopt_ext_partial\x12\x1d.hybrid.pbeditions.Extensions\x18\x19 \x01(\v2\".hybrid.pbeditions.PartialRequiredR\roptExtPartial:E\n" +
	"\x0frpt_ext_fixed32\x12\x1d.hybrid.pbeditions.Extensions\x18\x1f \x03(\aR\rrptExtFixed32:X\n" +
	"\frpt_ext_enum\x12\x1d.hybrid.pbeditions.Extensions\x18  \x03(\x0e2\x17.hybrid.pbeditions.EnumR\n" +
	"rptExtEnum:^\n" +
	"\x0erpt_ext_nested\x12\x1d.hybrid.pbeditions.Extensions\x18! \x03(\v2\x19.hybrid.pbeditions.NestedR\frptExtNested:}\n" +
	"\x15message_set_extension\x12\x1d.hybrid.pbeditions.MessageSet\x182 \x01(\v2*.hybrid.pbeditions.FakeMessageSetExtensionR\x13messageSetExtensionBaZSgoogle.golang.org/protobuf/internal/testprotos/textpbeditions/textpbeditions_hybrid\x92\x03\t\xd2>\x02\x10\x02\x10\x02 \x03b\beditionsp\xe8\a"

var file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_proto_enumTypes = make([]protoimpl.EnumInfo, 4)
var file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_proto_msgTypes = make([]protoimpl.MessageInfo, 26)
var file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_proto_goTypes = []any{
	(Enum)(0),                             // 0: hybrid.pbeditions.Enum
	(OpenEnum)(0),                         // 1: hybrid.pbeditions.OpenEnum
	(Enums_NestedEnum)(0),                 // 2: hybrid.pbeditions.Enums.NestedEnum
	(Enums_NestedOpenEnum)(0),             // 3: hybrid.pbeditions.Enums.NestedOpenEnum
	(*Scalars)(nil),                       // 4: hybrid.pbeditions.Scalars
	(*ImplicitScalars)(nil),               // 5: hybrid.pbeditions.ImplicitScalars
	(*UTF8Validated)(nil),                 // 6: hybrid.pbeditions.UTF8Validated
	(*NestsUTF8Validated)(nil),            // 7: hybrid.pbeditions.NestsUTF8Validated
	(*Enums)(nil),                         // 8: hybrid.pbeditions.Enums
	(*Repeats)(nil),                       // 9: hybrid.pbeditions.Repeats
	(*Maps)(nil),                          // 10: hybrid.pbeditions.Maps
	(*Nested)(nil),                        // 11: hybrid.pbeditions.Nested
	(*Nests)(nil),                         // 12: hybrid.pbeditions.Nests
	(*Requireds)(nil),                     // 13: hybrid.pbeditions.Requireds
	(*PartialRequired)(nil),               // 14: hybrid.pbeditions.PartialRequired
	(*NestedWithRequired)(nil),            // 15: hybrid.pbeditions.NestedWithRequired
	(*IndirectRequired)(nil),              // 16: hybrid.pbeditions.IndirectRequired
	(*Extensions)(nil),                    // 17: hybrid.pbeditions.Extensions
	(*ExtensionsContainer)(nil),           // 18: hybrid.pbeditions.ExtensionsContainer
	(*MessageSet)(nil),                    // 19: hybrid.pbeditions.MessageSet
	(*MessageSetExtension)(nil),           // 20: hybrid.pbeditions.MessageSetExtension
	(*FakeMessageSet)(nil),                // 21: hybrid.pbeditions.FakeMessageSet
	(*FakeMessageSetExtension)(nil),       // 22: hybrid.pbeditions.FakeMessageSetExtension
	(*KnownTypes)(nil),                    // 23: hybrid.pbeditions.KnownTypes
	nil,                                   // 24: hybrid.pbeditions.Maps.Int32ToStrEntry
	nil,                                   // 25: hybrid.pbeditions.Maps.StrToNestedEntry
	(*Nests_OptGroup)(nil),                // 26: hybrid.pbeditions.Nests.OptGroup
	(*Nests_RptGroup)(nil),                // 27: hybrid.pbeditions.Nests.RptGroup
	(*Nests_OptGroup_OptNestedGroup)(nil), // 28: hybrid.pbeditions.Nests.OptGroup.OptNestedGroup
	nil,                                   // 29: hybrid.pbeditions.IndirectRequired.StrToNestedEntry
	(*wrapperspb.BoolValue)(nil),          // 30: google.protobuf.BoolValue
	(*wrapperspb.Int32Value)(nil),         // 31: google.protobuf.Int32Value
	(*wrapperspb.Int64Value)(nil),         // 32: google.protobuf.Int64Value
	(*wrapperspb.UInt32Value)(nil),        // 33: google.protobuf.UInt32Value
	(*wrapperspb.UInt64Value)(nil),        // 34: google.protobuf.UInt64Value
	(*wrapperspb.FloatValue)(nil),         // 35: google.protobuf.FloatValue
	(*wrapperspb.DoubleValue)(nil),        // 36: google.protobuf.DoubleValue
	(*wrapperspb.StringValue)(nil),        // 37: google.protobuf.StringValue
	(*wrapperspb.BytesValue)(nil),         // 38: google.protobuf.BytesValue
	(*durationpb.Duration)(nil),           // 39: google.protobuf.Duration
	(*timestamppb.Timestamp)(nil),         // 40: google.protobuf.Timestamp
	(*structpb.Struct)(nil),               // 41: google.protobuf.Struct
	(*structpb.ListValue)(nil),            // 42: google.protobuf.ListValue
	(*structpb.Value)(nil),                // 43: google.protobuf.Value
	(structpb.NullValue)(0),               // 44: google.protobuf.NullValue
	(*emptypb.Empty)(nil),                 // 45: google.protobuf.Empty
	(*anypb.Any)(nil),                     // 46: google.protobuf.Any
	(*fieldmaskpb.FieldMask)(nil),         // 47: google.protobuf.FieldMask
}
var file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_proto_depIdxs = []int32{
	6,  // 0: hybrid.pbeditions.NestsUTF8Validated.validated_message:type_name -> hybrid.pbeditions.UTF8Validated
	0,  // 1: hybrid.pbeditions.Enums.opt_enum:type_name -> hybrid.pbeditions.Enum
	0,  // 2: hybrid.pbeditions.Enums.rpt_enum:type_name -> hybrid.pbeditions.Enum
	1,  // 3: hybrid.pbeditions.Enums.implicit_enum:type_name -> hybrid.pbeditions.OpenEnum
	2,  // 4: hybrid.pbeditions.Enums.opt_nested_enum:type_name -> hybrid.pbeditions.Enums.NestedEnum
	2,  // 5: hybrid.pbeditions.Enums.rpt_nested_enum:type_name -> hybrid.pbeditions.Enums.NestedEnum
	3,  // 6: hybrid.pbeditions.Enums.implicit_nested_enum:type_name -> hybrid.pbeditions.Enums.NestedOpenEnum
	24, // 7: hybrid.pbeditions.Maps.int32_to_str:type_name -> hybrid.pbeditions.Maps.Int32ToStrEntry
	25, // 8: hybrid.pbeditions.Maps.str_to_nested:type_name -> hybrid.pbeditions.Maps.StrToNestedEntry
	11, // 9: hybrid.pbeditions.Nested.opt_nested:type_name -> hybrid.pbeditions.Nested
	11, // 10: hybrid.pbeditions.Nests.opt_nested:type_name -> hybrid.pbeditions.Nested
	26, // 11: hybrid.pbeditions.Nests.optgroup:type_name -> hybrid.pbeditions.Nests.OptGroup
	26, // 12: hybrid.pbeditions.Nests.delimited_field:type_name -> hybrid.pbeditions.Nests.OptGroup
	11, // 13: hybrid.pbeditions.Nests.rpt_nested:type_name -> hybrid.pbeditions.Nested
	27, // 14: hybrid.pbeditions.Nests.rptgroup:type_name -> hybrid.pbeditions.Nests.RptGroup
	0,  // 15: hybrid.pbeditions.Requireds.req_enum:type_name -> hybrid.pbeditions.Enum
	11, // 16: hybrid.pbeditions.Requireds.req_nested:type_name -> hybrid.pbeditions.Nested
	15, // 17: hybrid.pbeditions.IndirectRequired.opt_nested:type_name -> hybrid.pbeditions.NestedWithRequired
	15, // 18: hybrid.pbeditions.IndirectRequired.rpt_nested:type_name -> hybrid.pbeditions.NestedWithRequired
	29, // 19: hybrid.pbeditions.IndirectRequired.str_to_nested:type_name -> hybrid.pbeditions.IndirectRequired.StrToNestedEntry
	15, // 20: hybrid.pbeditions.IndirectRequired.oneof_nested:type_name -> hybrid.pbeditions.NestedWithRequired
	30, // 21: hybrid.pbeditions.KnownTypes.opt_bool:type_name -> google.protobuf.BoolValue
	31, // 22: hybrid.pbeditions.KnownTypes.opt_int32:type_name -> google.protobuf.Int32Value
	32, // 23: hybrid.pbeditions.KnownTypes.opt_int64:type_name -> google.protobuf.Int64Value
	33, // 24: hybrid.pbeditions.KnownTypes.opt_uint32:type_name -> google.protobuf.UInt32Value
	34, // 25: hybrid.pbeditions.KnownTypes.opt_uint64:type_name -> google.protobuf.UInt64Value
	35, // 26: hybrid.pbeditions.KnownTypes.opt_float:type_name -> google.protobuf.FloatValue
	36, // 27: hybrid.pbeditions.KnownTypes.opt_double:type_name -> google.protobuf.DoubleValue
	37, // 28: hybrid.pbeditions.KnownTypes.opt_string:type_name -> google.protobuf.StringValue
	38, // 29: hybrid.pbeditions.KnownTypes.opt_bytes:type_name -> google.protobuf.BytesValue
	39, // 30: hybrid.pbeditions.KnownTypes.opt_duration:type_name -> google.protobuf.Duration
	40, // 31: hybrid.pbeditions.KnownTypes.opt_timestamp:type_name -> google.protobuf.Timestamp
	41, // 32: hybrid.pbeditions.KnownTypes.opt_struct:type_name -> google.protobuf.Struct
	42, // 33: hybrid.pbeditions.KnownTypes.opt_list:type_name -> google.protobuf.ListValue
	43, // 34: hybrid.pbeditions.KnownTypes.opt_value:type_name -> google.protobuf.Value
	44, // 35: hybrid.pbeditions.KnownTypes.opt_null:type_name -> google.protobuf.NullValue
	45, // 36: hybrid.pbeditions.KnownTypes.opt_empty:type_name -> google.protobuf.Empty
	46, // 37: hybrid.pbeditions.KnownTypes.opt_any:type_name -> google.protobuf.Any
	47, // 38: hybrid.pbeditions.KnownTypes.opt_fieldmask:type_name -> google.protobuf.FieldMask
	11, // 39: hybrid.pbeditions.Maps.StrToNestedEntry.value:type_name -> hybrid.pbeditions.Nested
	11, // 40: hybrid.pbeditions.Nests.OptGroup.opt_nested:type_name -> hybrid.pbeditions.Nested
	28, // 41: hybrid.pbeditions.Nests.OptGroup.optnestedgroup:type_name -> hybrid.pbeditions.Nests.OptGroup.OptNestedGroup
	28, // 42: hybrid.pbeditions.Nests.OptGroup.nested_delimited_field:type_name -> hybrid.pbeditions.Nests.OptGroup.OptNestedGroup
	15, // 43: hybrid.pbeditions.IndirectRequired.StrToNestedEntry.value:type_name -> hybrid.pbeditions.NestedWithRequired
	17, // 44: hybrid.pbeditions.opt_ext_bool:extendee -> hybrid.pbeditions.Extensions
	17, // 45: hybrid.pbeditions.opt_ext_string:extendee -> hybrid.pbeditions.Extensions
	17, // 46: hybrid.pbeditions.opt_ext_enum:extendee -> hybrid.pbeditions.Extensions
	17, // 47: hybrid.pbeditions.opt_ext_nested:extendee -> hybrid.pbeditions.Extensions
	17, // 48: hybrid.pbeditions.opt_ext_partial:extendee -> hybrid.pbeditions.Extensions
	17, // 49: hybrid.pbeditions.rpt_ext_fixed32:extendee -> hybrid.pbeditions.Extensions
	17, // 50: hybrid.pbeditions.rpt_ext_enum:extendee -> hybrid.pbeditions.Extensions
	17, // 51: hybrid.pbeditions.rpt_ext_nested:extendee -> hybrid.pbeditions.Extensions
	19, // 52: hybrid.pbeditions.message_set_extension:extendee -> hybrid.pbeditions.MessageSet
	17, // 53: hybrid.pbeditions.ExtensionsContainer.opt_ext_bool:extendee -> hybrid.pbeditions.Extensions
	17, // 54: hybrid.pbeditions.ExtensionsContainer.opt_ext_string:extendee -> hybrid.pbeditions.Extensions
	17, // 55: hybrid.pbeditions.ExtensionsContainer.opt_ext_enum:extendee -> hybrid.pbeditions.Extensions
	17, // 56: hybrid.pbeditions.ExtensionsContainer.opt_ext_nested:extendee -> hybrid.pbeditions.Extensions
	17, // 57: hybrid.pbeditions.ExtensionsContainer.opt_ext_partial:extendee -> hybrid.pbeditions.Extensions
	17, // 58: hybrid.pbeditions.ExtensionsContainer.rpt_ext_string:extendee -> hybrid.pbeditions.Extensions
	17, // 59: hybrid.pbeditions.ExtensionsContainer.rpt_ext_enum:extendee -> hybrid.pbeditions.Extensions
	17, // 60: hybrid.pbeditions.ExtensionsContainer.rpt_ext_nested:extendee -> hybrid.pbeditions.Extensions
	19, // 61: hybrid.pbeditions.MessageSetExtension.message_set_extension:extendee -> hybrid.pbeditions.MessageSet
	19, // 62: hybrid.pbeditions.MessageSetExtension.not_message_set_extension:extendee -> hybrid.pbeditions.MessageSet
	19, // 63: hybrid.pbeditions.MessageSetExtension.ext_nested:extendee -> hybrid.pbeditions.MessageSet
	21, // 64: hybrid.pbeditions.FakeMessageSetExtension.message_set_extension:extendee -> hybrid.pbeditions.FakeMessageSet
	0,  // 65: hybrid.pbeditions.opt_ext_enum:type_name -> hybrid.pbeditions.Enum
	11, // 66: hybrid.pbeditions.opt_ext_nested:type_name -> hybrid.pbeditions.Nested
	14, // 67: hybrid.pbeditions.opt_ext_partial:type_name -> hybrid.pbeditions.PartialRequired
	0,  // 68: hybrid.pbeditions.rpt_ext_enum:type_name -> hybrid.pbeditions.Enum
	11, // 69: hybrid.pbeditions.rpt_ext_nested:type_name -> hybrid.pbeditions.Nested
	22, // 70: hybrid.pbeditions.message_set_extension:type_name -> hybrid.pbeditions.FakeMessageSetExtension
	0,  // 71: hybrid.pbeditions.ExtensionsContainer.opt_ext_enum:type_name -> hybrid.pbeditions.Enum
	11, // 72: hybrid.pbeditions.ExtensionsContainer.opt_ext_nested:type_name -> hybrid.pbeditions.Nested
	14, // 73: hybrid.pbeditions.ExtensionsContainer.opt_ext_partial:type_name -> hybrid.pbeditions.PartialRequired
	0,  // 74: hybrid.pbeditions.ExtensionsContainer.rpt_ext_enum:type_name -> hybrid.pbeditions.Enum
	11, // 75: hybrid.pbeditions.ExtensionsContainer.rpt_ext_nested:type_name -> hybrid.pbeditions.Nested
	20, // 76: hybrid.pbeditions.MessageSetExtension.message_set_extension:type_name -> hybrid.pbeditions.MessageSetExtension
	20, // 77: hybrid.pbeditions.MessageSetExtension.not_message_set_extension:type_name -> hybrid.pbeditions.MessageSetExtension
	11, // 78: hybrid.pbeditions.MessageSetExtension.ext_nested:type_name -> hybrid.pbeditions.Nested
	22, // 79: hybrid.pbeditions.FakeMessageSetExtension.message_set_extension:type_name -> hybrid.pbeditions.FakeMessageSetExtension
	80, // [80:80] is the sub-list for method output_type
	80, // [80:80] is the sub-list for method input_type
	65, // [65:80] is the sub-list for extension type_name
	44, // [44:65] is the sub-list for extension extendee
	0,  // [0:44] is the sub-list for field type_name
}

func init() { file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_proto_init() }
func file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_proto_init() {
	if File_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_proto != nil {
		return
	}
	file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_proto_msgTypes[12].OneofWrappers = []any{
		(*IndirectRequired_OneofNested)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_proto_rawDesc), len(file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_proto_rawDesc)),
			NumEnums:      4,
			NumMessages:   26,
			NumExtensions: 21,
			NumServices:   0,
		},
		GoTypes:           file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_proto_goTypes,
		DependencyIndexes: file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_proto_depIdxs,
		EnumInfos:         file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_proto_enumTypes,
		MessageInfos:      file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_proto_msgTypes,
		ExtensionInfos:    file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_proto_extTypes,
	}.Build()
	File_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_proto = out.File
	file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_proto_goTypes = nil
	file_internal_testprotos_textpbeditions_textpbeditions_hybrid_test2_hybrid_proto_depIdxs = nil
}
