// Copyright 2025 Buf Technologies, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.9
// 	protoc        (unknown)
// source: test/proto2.proto

// buf:lint:ignore PACKAGE_VERSION_SUFFIX
// buf:lint:ignore PACKAGE_DIRECTORY_MATCH

package test

import (
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	reflect "reflect"
	sync "sync"
	unsafe "unsafe"
)

const (
	// Verify that this generated code is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
	// Verify that runtime/protoimpl is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)

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

func (x *Extensions) Reset() {
	*x = Extensions{}
	mi := &file_test_proto2_proto_msgTypes[0]
	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_test_proto2_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)
}

// Deprecated: Use Extensions.ProtoReflect.Descriptor instead.
func (*Extensions) Descriptor() ([]byte, []int) {
	return file_test_proto2_proto_rawDescGZIP(), []int{0}
}

type Required struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// buf:lint:ignore FIELD_NOT_REQUIRED
	X *int32    `protobuf:"varint,1,req,name=x" json:"x,omitempty"`
	Y *Required `protobuf:"bytes,2,opt,name=y" json:"y,omitempty"`
	// buf:lint:ignore FIELD_NOT_REQUIRED
	Z             *Required_Empty `protobuf:"bytes,3,req,name=z" json:"z,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Required) ProtoMessage() {}

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

// Deprecated: Use Required.ProtoReflect.Descriptor instead.
func (*Required) Descriptor() ([]byte, []int) {
	return file_test_proto2_proto_rawDescGZIP(), []int{1}
}

func (x *Required) GetX() int32 {
	if x != nil && x.X != nil {
		return *x.X
	}
	return 0
}

func (x *Required) GetY() *Required {
	if x != nil {
		return x.Y
	}
	return nil
}

func (x *Required) GetZ() *Required_Empty {
	if x != nil {
		return x.Z
	}
	return nil
}

type DependsOnRequired struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	A             *Required              `protobuf:"bytes,1,opt,name=a" json:"a,omitempty"`
	B             []*Required            `protobuf:"bytes,2,rep,name=b" json:"b,omitempty"`
	C             map[int32]*Required    `protobuf:"bytes,3,rep,name=c" json:"c,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*DependsOnRequired) ProtoMessage() {}

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

// Deprecated: Use DependsOnRequired.ProtoReflect.Descriptor instead.
func (*DependsOnRequired) Descriptor() ([]byte, []int) {
	return file_test_proto2_proto_rawDescGZIP(), []int{2}
}

func (x *DependsOnRequired) GetA() *Required {
	if x != nil {
		return x.A
	}
	return nil
}

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

func (x *DependsOnRequired) GetC() map[int32]*Required {
	if x != nil {
		return x.C
	}
	return nil
}

type Groups struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Singular      *Groups_Singular       `protobuf:"group,1,opt,name=Singular,json=singular" json:"singular,omitempty"`
	Repeated      []*Groups_Repeated     `protobuf:"group,2,rep,name=Repeated,json=repeated" json:"repeated,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Groups) ProtoMessage() {}

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

// Deprecated: Use Groups.ProtoReflect.Descriptor instead.
func (*Groups) Descriptor() ([]byte, []int) {
	return file_test_proto2_proto_rawDescGZIP(), []int{3}
}

func (x *Groups) GetSingular() *Groups_Singular {
	if x != nil {
		return x.Singular
	}
	return nil
}

func (x *Groups) GetRepeated() []*Groups_Repeated {
	if x != nil {
		return x.Repeated
	}
	return nil
}

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

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

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

func (*Required_Empty) ProtoMessage() {}

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

// Deprecated: Use Required_Empty.ProtoReflect.Descriptor instead.
func (*Required_Empty) Descriptor() ([]byte, []int) {
	return file_test_proto2_proto_rawDescGZIP(), []int{1, 0}
}

type Groups_Singular struct {
	state         protoimpl.MessageState  `protogen:"open.v1"`
	A             *int32                  `protobuf:"varint,1,opt,name=a" json:"a,omitempty"`
	B             *int32                  `protobuf:"varint,2,opt,name=b" json:"b,omitempty"`
	G             *Groups                 `protobuf:"bytes,3,opt,name=g" json:"g,omitempty"`
	Nested        *Groups_Singular_Nested `protobuf:"group,4,opt,name=Nested,json=nested" json:"nested,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Groups_Singular) ProtoMessage() {}

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

// Deprecated: Use Groups_Singular.ProtoReflect.Descriptor instead.
func (*Groups_Singular) Descriptor() ([]byte, []int) {
	return file_test_proto2_proto_rawDescGZIP(), []int{3, 0}
}

func (x *Groups_Singular) GetA() int32 {
	if x != nil && x.A != nil {
		return *x.A
	}
	return 0
}

func (x *Groups_Singular) GetB() int32 {
	if x != nil && x.B != nil {
		return *x.B
	}
	return 0
}

func (x *Groups_Singular) GetG() *Groups {
	if x != nil {
		return x.G
	}
	return nil
}

func (x *Groups_Singular) GetNested() *Groups_Singular_Nested {
	if x != nil {
		return x.Nested
	}
	return nil
}

type Groups_Repeated struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	A             *int32                 `protobuf:"varint,1,opt,name=a" json:"a,omitempty"`
	B             *int32                 `protobuf:"varint,2,opt,name=b" json:"b,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Groups_Repeated) ProtoMessage() {}

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

// Deprecated: Use Groups_Repeated.ProtoReflect.Descriptor instead.
func (*Groups_Repeated) Descriptor() ([]byte, []int) {
	return file_test_proto2_proto_rawDescGZIP(), []int{3, 1}
}

func (x *Groups_Repeated) GetA() int32 {
	if x != nil && x.A != nil {
		return *x.A
	}
	return 0
}

func (x *Groups_Repeated) GetB() int32 {
	if x != nil && x.B != nil {
		return *x.B
	}
	return 0
}

type Groups_Singular_Nested struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	A             *int32                 `protobuf:"varint,1,opt,name=a" json:"a,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Groups_Singular_Nested) ProtoMessage() {}

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

// Deprecated: Use Groups_Singular_Nested.ProtoReflect.Descriptor instead.
func (*Groups_Singular_Nested) Descriptor() ([]byte, []int) {
	return file_test_proto2_proto_rawDescGZIP(), []int{3, 0, 0}
}

func (x *Groups_Singular_Nested) GetA() int32 {
	if x != nil && x.A != nil {
		return *x.A
	}
	return 0
}

var file_test_proto2_proto_extTypes = []protoimpl.ExtensionInfo{
	{
		ExtendedType:  (*Extensions)(nil),
		ExtensionType: (*int32)(nil),
		Field:         21,
		Name:          "hyperpb.test.b1",
		Tag:           "varint,21,opt,name=b1",
		Filename:      "test/proto2.proto",
	},
	{
		ExtendedType:  (*Extensions)(nil),
		ExtensionType: (*int64)(nil),
		Field:         22,
		Name:          "hyperpb.test.b2",
		Tag:           "varint,22,opt,name=b2",
		Filename:      "test/proto2.proto",
	},
	{
		ExtendedType:  (*Extensions)(nil),
		ExtensionType: (*uint32)(nil),
		Field:         23,
		Name:          "hyperpb.test.b3",
		Tag:           "varint,23,opt,name=b3",
		Filename:      "test/proto2.proto",
	},
	{
		ExtendedType:  (*Extensions)(nil),
		ExtensionType: (*uint64)(nil),
		Field:         24,
		Name:          "hyperpb.test.b4",
		Tag:           "varint,24,opt,name=b4",
		Filename:      "test/proto2.proto",
	},
	{
		ExtendedType:  (*Extensions)(nil),
		ExtensionType: (*int32)(nil),
		Field:         25,
		Name:          "hyperpb.test.b5",
		Tag:           "zigzag32,25,opt,name=b5",
		Filename:      "test/proto2.proto",
	},
	{
		ExtendedType:  (*Extensions)(nil),
		ExtensionType: (*int64)(nil),
		Field:         26,
		Name:          "hyperpb.test.b6",
		Tag:           "zigzag64,26,opt,name=b6",
		Filename:      "test/proto2.proto",
	},
	{
		ExtendedType:  (*Extensions)(nil),
		ExtensionType: (*uint32)(nil),
		Field:         27,
		Name:          "hyperpb.test.b7",
		Tag:           "fixed32,27,opt,name=b7",
		Filename:      "test/proto2.proto",
	},
	{
		ExtendedType:  (*Extensions)(nil),
		ExtensionType: (*uint64)(nil),
		Field:         28,
		Name:          "hyperpb.test.b8",
		Tag:           "fixed64,28,opt,name=b8",
		Filename:      "test/proto2.proto",
	},
	{
		ExtendedType:  (*Extensions)(nil),
		ExtensionType: (*int32)(nil),
		Field:         29,
		Name:          "hyperpb.test.b9",
		Tag:           "fixed32,29,opt,name=b9",
		Filename:      "test/proto2.proto",
	},
	{
		ExtendedType:  (*Extensions)(nil),
		ExtensionType: (*int64)(nil),
		Field:         30,
		Name:          "hyperpb.test.b10",
		Tag:           "fixed64,30,opt,name=b10",
		Filename:      "test/proto2.proto",
	},
	{
		ExtendedType:  (*Extensions)(nil),
		ExtensionType: (*float32)(nil),
		Field:         31,
		Name:          "hyperpb.test.b11",
		Tag:           "fixed32,31,opt,name=b11",
		Filename:      "test/proto2.proto",
	},
	{
		ExtendedType:  (*Extensions)(nil),
		ExtensionType: (*float64)(nil),
		Field:         32,
		Name:          "hyperpb.test.b12",
		Tag:           "fixed64,32,opt,name=b12",
		Filename:      "test/proto2.proto",
	},
	{
		ExtendedType:  (*Extensions)(nil),
		ExtensionType: (*bool)(nil),
		Field:         33,
		Name:          "hyperpb.test.b13",
		Tag:           "varint,33,opt,name=b13",
		Filename:      "test/proto2.proto",
	},
	{
		ExtendedType:  (*Extensions)(nil),
		ExtensionType: (*string)(nil),
		Field:         34,
		Name:          "hyperpb.test.b14",
		Tag:           "bytes,34,opt,name=b14",
		Filename:      "test/proto2.proto",
	},
	{
		ExtendedType:  (*Extensions)(nil),
		ExtensionType: ([]byte)(nil),
		Field:         35,
		Name:          "hyperpb.test.b15",
		Tag:           "bytes,35,opt,name=b15",
		Filename:      "test/proto2.proto",
	},
	{
		ExtendedType:  (*Extensions)(nil),
		ExtensionType: ([]*Extensions)(nil),
		Field:         50,
		Name:          "hyperpb.test.z",
		Tag:           "bytes,50,rep,name=z",
		Filename:      "test/proto2.proto",
	},
}

// Extension fields to Extensions.
var (
	// optional int32 b1 = 21;
	E_B1 = &file_test_proto2_proto_extTypes[0]
	// optional int64 b2 = 22;
	E_B2 = &file_test_proto2_proto_extTypes[1]
	// optional uint32 b3 = 23;
	E_B3 = &file_test_proto2_proto_extTypes[2]
	// optional uint64 b4 = 24;
	E_B4 = &file_test_proto2_proto_extTypes[3]
	// optional sint32 b5 = 25;
	E_B5 = &file_test_proto2_proto_extTypes[4]
	// optional sint64 b6 = 26;
	E_B6 = &file_test_proto2_proto_extTypes[5]
	// optional fixed32 b7 = 27;
	E_B7 = &file_test_proto2_proto_extTypes[6]
	// optional fixed64 b8 = 28;
	E_B8 = &file_test_proto2_proto_extTypes[7]
	// optional sfixed32 b9 = 29;
	E_B9 = &file_test_proto2_proto_extTypes[8]
	// optional sfixed64 b10 = 30;
	E_B10 = &file_test_proto2_proto_extTypes[9]
	// optional float b11 = 31;
	E_B11 = &file_test_proto2_proto_extTypes[10]
	// optional double b12 = 32;
	E_B12 = &file_test_proto2_proto_extTypes[11]
	// optional bool b13 = 33;
	E_B13 = &file_test_proto2_proto_extTypes[12]
	// optional string b14 = 34;
	E_B14 = &file_test_proto2_proto_extTypes[13]
	// optional bytes b15 = 35;
	E_B15 = &file_test_proto2_proto_extTypes[14]
	// repeated hyperpb.test.Extensions z = 50;
	E_Z = &file_test_proto2_proto_extTypes[15]
)

var File_test_proto2_proto protoreflect.FileDescriptor

const file_test_proto2_proto_rawDesc = "" +
	"\n" +
	"\x11test/proto2.proto\x12\fhyperpb.test\"\x16\n" +
	"\n" +
	"Extensions*\b\b\x01\x10\x80\x80\x80\x80\x02\"s\n" +
	"\bRequired\x12\f\n" +
	"\x01x\x18\x01 \x02(\x05R\x01x\x12$\n" +
	"\x01y\x18\x02 \x01(\v2\x16.hyperpb.test.RequiredR\x01y\x12*\n" +
	"\x01z\x18\x03 \x02(\v2\x1c.hyperpb.test.Required.EmptyR\x01z\x1a\a\n" +
	"\x05Empty\"\xe3\x01\n" +
	"\x11DependsOnRequired\x12$\n" +
	"\x01a\x18\x01 \x01(\v2\x16.hyperpb.test.RequiredR\x01a\x12$\n" +
	"\x01b\x18\x02 \x03(\v2\x16.hyperpb.test.RequiredR\x01b\x124\n" +
	"\x01c\x18\x03 \x03(\v2&.hyperpb.test.DependsOnRequired.CEntryR\x01c\x1aL\n" +
	"\x06CEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\x05R\x03key\x12,\n" +
	"\x05value\x18\x02 \x01(\v2\x16.hyperpb.test.RequiredR\x05value:\x028\x01\"\xc9\x02\n" +
	"\x06Groups\x129\n" +
	"\bsingular\x18\x01 \x01(\n" +
	"2\x1d.hyperpb.test.Groups.SingularR\bsingular\x129\n" +
	"\brepeated\x18\x02 \x03(\n" +
	"2\x1d.hyperpb.test.Groups.RepeatedR\brepeated\x1a\xa0\x01\n" +
	"\bSingular\x12\f\n" +
	"\x01a\x18\x01 \x01(\x05R\x01a\x12\f\n" +
	"\x01b\x18\x02 \x01(\x05R\x01b\x12\"\n" +
	"\x01g\x18\x03 \x01(\v2\x14.hyperpb.test.GroupsR\x01g\x12<\n" +
	"\x06nested\x18\x04 \x01(\n" +
	"2$.hyperpb.test.Groups.Singular.NestedR\x06nested\x1a\x16\n" +
	"\x06Nested\x12\f\n" +
	"\x01a\x18\x01 \x01(\x05R\x01a\x1a&\n" +
	"\bRepeated\x12\f\n" +
	"\x01a\x18\x01 \x01(\x05R\x01a\x12\f\n" +
	"\x01b\x18\x02 \x01(\x05R\x01b:(\n" +
	"\x02b1\x12\x18.hyperpb.test.Extensions\x18\x15 \x01(\x05R\x02b1:(\n" +
	"\x02b2\x12\x18.hyperpb.test.Extensions\x18\x16 \x01(\x03R\x02b2:(\n" +
	"\x02b3\x12\x18.hyperpb.test.Extensions\x18\x17 \x01(\rR\x02b3:(\n" +
	"\x02b4\x12\x18.hyperpb.test.Extensions\x18\x18 \x01(\x04R\x02b4:(\n" +
	"\x02b5\x12\x18.hyperpb.test.Extensions\x18\x19 \x01(\x11R\x02b5:(\n" +
	"\x02b6\x12\x18.hyperpb.test.Extensions\x18\x1a \x01(\x12R\x02b6:(\n" +
	"\x02b7\x12\x18.hyperpb.test.Extensions\x18\x1b \x01(\aR\x02b7:(\n" +
	"\x02b8\x12\x18.hyperpb.test.Extensions\x18\x1c \x01(\x06R\x02b8:(\n" +
	"\x02b9\x12\x18.hyperpb.test.Extensions\x18\x1d \x01(\x0fR\x02b9:*\n" +
	"\x03b10\x12\x18.hyperpb.test.Extensions\x18\x1e \x01(\x10R\x03b10:*\n" +
	"\x03b11\x12\x18.hyperpb.test.Extensions\x18\x1f \x01(\x02R\x03b11:*\n" +
	"\x03b12\x12\x18.hyperpb.test.Extensions\x18  \x01(\x01R\x03b12:*\n" +
	"\x03b13\x12\x18.hyperpb.test.Extensions\x18! \x01(\bR\x03b13:*\n" +
	"\x03b14\x12\x18.hyperpb.test.Extensions\x18\" \x01(\tR\x03b14:*\n" +
	"\x03b15\x12\x18.hyperpb.test.Extensions\x18# \x01(\fR\x03b15:@\n" +
	"\x01z\x12\x18.hyperpb.test.Extensions\x182 \x03(\v2\x18.hyperpb.test.ExtensionsR\x01zB\x98\x01\n" +
	"\x10com.hyperpb.testB\vProto2ProtoP\x01Z&buf.build/go/hyperpb/internal/gen/test\xa2\x02\x03HTX\xaa\x02\fHyperpb.Test\xca\x02\fHyperpb\\Test\xe2\x02\x18Hyperpb\\Test\\GPBMetadata\xea\x02\rHyperpb::Test"

var (
	file_test_proto2_proto_rawDescOnce sync.Once
	file_test_proto2_proto_rawDescData []byte
)

func file_test_proto2_proto_rawDescGZIP() []byte {
	file_test_proto2_proto_rawDescOnce.Do(func() {
		file_test_proto2_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_test_proto2_proto_rawDesc), len(file_test_proto2_proto_rawDesc)))
	})
	return file_test_proto2_proto_rawDescData
}

var file_test_proto2_proto_msgTypes = make([]protoimpl.MessageInfo, 9)
var file_test_proto2_proto_goTypes = []any{
	(*Extensions)(nil),             // 0: hyperpb.test.Extensions
	(*Required)(nil),               // 1: hyperpb.test.Required
	(*DependsOnRequired)(nil),      // 2: hyperpb.test.DependsOnRequired
	(*Groups)(nil),                 // 3: hyperpb.test.Groups
	(*Required_Empty)(nil),         // 4: hyperpb.test.Required.Empty
	nil,                            // 5: hyperpb.test.DependsOnRequired.CEntry
	(*Groups_Singular)(nil),        // 6: hyperpb.test.Groups.Singular
	(*Groups_Repeated)(nil),        // 7: hyperpb.test.Groups.Repeated
	(*Groups_Singular_Nested)(nil), // 8: hyperpb.test.Groups.Singular.Nested
}
var file_test_proto2_proto_depIdxs = []int32{
	1,  // 0: hyperpb.test.Required.y:type_name -> hyperpb.test.Required
	4,  // 1: hyperpb.test.Required.z:type_name -> hyperpb.test.Required.Empty
	1,  // 2: hyperpb.test.DependsOnRequired.a:type_name -> hyperpb.test.Required
	1,  // 3: hyperpb.test.DependsOnRequired.b:type_name -> hyperpb.test.Required
	5,  // 4: hyperpb.test.DependsOnRequired.c:type_name -> hyperpb.test.DependsOnRequired.CEntry
	6,  // 5: hyperpb.test.Groups.singular:type_name -> hyperpb.test.Groups.Singular
	7,  // 6: hyperpb.test.Groups.repeated:type_name -> hyperpb.test.Groups.Repeated
	1,  // 7: hyperpb.test.DependsOnRequired.CEntry.value:type_name -> hyperpb.test.Required
	3,  // 8: hyperpb.test.Groups.Singular.g:type_name -> hyperpb.test.Groups
	8,  // 9: hyperpb.test.Groups.Singular.nested:type_name -> hyperpb.test.Groups.Singular.Nested
	0,  // 10: hyperpb.test.b1:extendee -> hyperpb.test.Extensions
	0,  // 11: hyperpb.test.b2:extendee -> hyperpb.test.Extensions
	0,  // 12: hyperpb.test.b3:extendee -> hyperpb.test.Extensions
	0,  // 13: hyperpb.test.b4:extendee -> hyperpb.test.Extensions
	0,  // 14: hyperpb.test.b5:extendee -> hyperpb.test.Extensions
	0,  // 15: hyperpb.test.b6:extendee -> hyperpb.test.Extensions
	0,  // 16: hyperpb.test.b7:extendee -> hyperpb.test.Extensions
	0,  // 17: hyperpb.test.b8:extendee -> hyperpb.test.Extensions
	0,  // 18: hyperpb.test.b9:extendee -> hyperpb.test.Extensions
	0,  // 19: hyperpb.test.b10:extendee -> hyperpb.test.Extensions
	0,  // 20: hyperpb.test.b11:extendee -> hyperpb.test.Extensions
	0,  // 21: hyperpb.test.b12:extendee -> hyperpb.test.Extensions
	0,  // 22: hyperpb.test.b13:extendee -> hyperpb.test.Extensions
	0,  // 23: hyperpb.test.b14:extendee -> hyperpb.test.Extensions
	0,  // 24: hyperpb.test.b15:extendee -> hyperpb.test.Extensions
	0,  // 25: hyperpb.test.z:extendee -> hyperpb.test.Extensions
	0,  // 26: hyperpb.test.z:type_name -> hyperpb.test.Extensions
	27, // [27:27] is the sub-list for method output_type
	27, // [27:27] is the sub-list for method input_type
	26, // [26:27] is the sub-list for extension type_name
	10, // [10:26] is the sub-list for extension extendee
	0,  // [0:10] is the sub-list for field type_name
}

func init() { file_test_proto2_proto_init() }
func file_test_proto2_proto_init() {
	if File_test_proto2_proto != nil {
		return
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_test_proto2_proto_rawDesc), len(file_test_proto2_proto_rawDesc)),
			NumEnums:      0,
			NumMessages:   9,
			NumExtensions: 16,
			NumServices:   0,
		},
		GoTypes:           file_test_proto2_proto_goTypes,
		DependencyIndexes: file_test_proto2_proto_depIdxs,
		MessageInfos:      file_test_proto2_proto_msgTypes,
		ExtensionInfos:    file_test_proto2_proto_extTypes,
	}.Build()
	File_test_proto2_proto = out.File
	file_test_proto2_proto_goTypes = nil
	file_test_proto2_proto_depIdxs = nil
}
