// Copyright 2020 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.

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: cmd/protoc-gen-go/testdata/visibility/visibility.proto

package visibility

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

type DefaultEnum int32

const (
	DefaultEnum_DEFAULT_ZERO DefaultEnum = 0
)

// Enum value maps for DefaultEnum.
var (
	DefaultEnum_name = map[int32]string{
		0: "DEFAULT_ZERO",
	}
	DefaultEnum_value = map[string]int32{
		"DEFAULT_ZERO": 0,
	}
)

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

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

func (DefaultEnum) Descriptor() protoreflect.EnumDescriptor {
	return file_cmd_protoc_gen_go_testdata_visibility_visibility_proto_enumTypes[0].Descriptor()
}

func (DefaultEnum) Type() protoreflect.EnumType {
	return &file_cmd_protoc_gen_go_testdata_visibility_visibility_proto_enumTypes[0]
}

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

type ExportEnum int32

const (
	ExportEnum_EXPORT_ZERO ExportEnum = 0
)

// Enum value maps for ExportEnum.
var (
	ExportEnum_name = map[int32]string{
		0: "EXPORT_ZERO",
	}
	ExportEnum_value = map[string]int32{
		"EXPORT_ZERO": 0,
	}
)

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

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

func (ExportEnum) Descriptor() protoreflect.EnumDescriptor {
	return file_cmd_protoc_gen_go_testdata_visibility_visibility_proto_enumTypes[1].Descriptor()
}

func (ExportEnum) Type() protoreflect.EnumType {
	return &file_cmd_protoc_gen_go_testdata_visibility_visibility_proto_enumTypes[1]
}

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

type LocalEnum int32

const (
	LocalEnum_LOCAL_ZERO LocalEnum = 0
)

// Enum value maps for LocalEnum.
var (
	LocalEnum_name = map[int32]string{
		0: "LOCAL_ZERO",
	}
	LocalEnum_value = map[string]int32{
		"LOCAL_ZERO": 0,
	}
)

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

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

func (LocalEnum) Descriptor() protoreflect.EnumDescriptor {
	return file_cmd_protoc_gen_go_testdata_visibility_visibility_proto_enumTypes[2].Descriptor()
}

func (LocalEnum) Type() protoreflect.EnumType {
	return &file_cmd_protoc_gen_go_testdata_visibility_visibility_proto_enumTypes[2]
}

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

type DefaultMessage_NestedDefaultEnum int32

const (
	DefaultMessage_DEFAULT_ZERO DefaultMessage_NestedDefaultEnum = 0
)

// Enum value maps for DefaultMessage_NestedDefaultEnum.
var (
	DefaultMessage_NestedDefaultEnum_name = map[int32]string{
		0: "DEFAULT_ZERO",
	}
	DefaultMessage_NestedDefaultEnum_value = map[string]int32{
		"DEFAULT_ZERO": 0,
	}
)

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

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

func (DefaultMessage_NestedDefaultEnum) Descriptor() protoreflect.EnumDescriptor {
	return file_cmd_protoc_gen_go_testdata_visibility_visibility_proto_enumTypes[3].Descriptor()
}

func (DefaultMessage_NestedDefaultEnum) Type() protoreflect.EnumType {
	return &file_cmd_protoc_gen_go_testdata_visibility_visibility_proto_enumTypes[3]
}

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

type DefaultMessage_NestedExportEnum int32

const (
	DefaultMessage_EXPORT_ZERO DefaultMessage_NestedExportEnum = 0
)

// Enum value maps for DefaultMessage_NestedExportEnum.
var (
	DefaultMessage_NestedExportEnum_name = map[int32]string{
		0: "EXPORT_ZERO",
	}
	DefaultMessage_NestedExportEnum_value = map[string]int32{
		"EXPORT_ZERO": 0,
	}
)

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

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

func (DefaultMessage_NestedExportEnum) Descriptor() protoreflect.EnumDescriptor {
	return file_cmd_protoc_gen_go_testdata_visibility_visibility_proto_enumTypes[4].Descriptor()
}

func (DefaultMessage_NestedExportEnum) Type() protoreflect.EnumType {
	return &file_cmd_protoc_gen_go_testdata_visibility_visibility_proto_enumTypes[4]
}

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

type DefaultMessage_NestedLocalEnum int32

const (
	DefaultMessage_LOCAL_ZERO DefaultMessage_NestedLocalEnum = 0
)

// Enum value maps for DefaultMessage_NestedLocalEnum.
var (
	DefaultMessage_NestedLocalEnum_name = map[int32]string{
		0: "LOCAL_ZERO",
	}
	DefaultMessage_NestedLocalEnum_value = map[string]int32{
		"LOCAL_ZERO": 0,
	}
)

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

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

func (DefaultMessage_NestedLocalEnum) Descriptor() protoreflect.EnumDescriptor {
	return file_cmd_protoc_gen_go_testdata_visibility_visibility_proto_enumTypes[5].Descriptor()
}

func (DefaultMessage_NestedLocalEnum) Type() protoreflect.EnumType {
	return &file_cmd_protoc_gen_go_testdata_visibility_visibility_proto_enumTypes[5]
}

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

type ExportMessage_NestedDefaultEnum int32

const (
	ExportMessage_DEFAULT_ZERO ExportMessage_NestedDefaultEnum = 0
)

// Enum value maps for ExportMessage_NestedDefaultEnum.
var (
	ExportMessage_NestedDefaultEnum_name = map[int32]string{
		0: "DEFAULT_ZERO",
	}
	ExportMessage_NestedDefaultEnum_value = map[string]int32{
		"DEFAULT_ZERO": 0,
	}
)

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

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

func (ExportMessage_NestedDefaultEnum) Descriptor() protoreflect.EnumDescriptor {
	return file_cmd_protoc_gen_go_testdata_visibility_visibility_proto_enumTypes[6].Descriptor()
}

func (ExportMessage_NestedDefaultEnum) Type() protoreflect.EnumType {
	return &file_cmd_protoc_gen_go_testdata_visibility_visibility_proto_enumTypes[6]
}

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

type ExportMessage_NestedExportEnum int32

const (
	ExportMessage_EXPORT_ZERO ExportMessage_NestedExportEnum = 0
)

// Enum value maps for ExportMessage_NestedExportEnum.
var (
	ExportMessage_NestedExportEnum_name = map[int32]string{
		0: "EXPORT_ZERO",
	}
	ExportMessage_NestedExportEnum_value = map[string]int32{
		"EXPORT_ZERO": 0,
	}
)

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

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

func (ExportMessage_NestedExportEnum) Descriptor() protoreflect.EnumDescriptor {
	return file_cmd_protoc_gen_go_testdata_visibility_visibility_proto_enumTypes[7].Descriptor()
}

func (ExportMessage_NestedExportEnum) Type() protoreflect.EnumType {
	return &file_cmd_protoc_gen_go_testdata_visibility_visibility_proto_enumTypes[7]
}

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

type ExportMessage_NestedLocalEnum int32

const (
	ExportMessage_LOCAL_ZERO ExportMessage_NestedLocalEnum = 0
)

// Enum value maps for ExportMessage_NestedLocalEnum.
var (
	ExportMessage_NestedLocalEnum_name = map[int32]string{
		0: "LOCAL_ZERO",
	}
	ExportMessage_NestedLocalEnum_value = map[string]int32{
		"LOCAL_ZERO": 0,
	}
)

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

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

func (ExportMessage_NestedLocalEnum) Descriptor() protoreflect.EnumDescriptor {
	return file_cmd_protoc_gen_go_testdata_visibility_visibility_proto_enumTypes[8].Descriptor()
}

func (ExportMessage_NestedLocalEnum) Type() protoreflect.EnumType {
	return &file_cmd_protoc_gen_go_testdata_visibility_visibility_proto_enumTypes[8]
}

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

type LocalMessage_NestedDefaultEnum int32

const (
	LocalMessage_DEFAULT_ZERO LocalMessage_NestedDefaultEnum = 0
)

// Enum value maps for LocalMessage_NestedDefaultEnum.
var (
	LocalMessage_NestedDefaultEnum_name = map[int32]string{
		0: "DEFAULT_ZERO",
	}
	LocalMessage_NestedDefaultEnum_value = map[string]int32{
		"DEFAULT_ZERO": 0,
	}
)

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

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

func (LocalMessage_NestedDefaultEnum) Descriptor() protoreflect.EnumDescriptor {
	return file_cmd_protoc_gen_go_testdata_visibility_visibility_proto_enumTypes[9].Descriptor()
}

func (LocalMessage_NestedDefaultEnum) Type() protoreflect.EnumType {
	return &file_cmd_protoc_gen_go_testdata_visibility_visibility_proto_enumTypes[9]
}

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

type LocalMessage_NestedExportEnum int32

const (
	LocalMessage_EXPORT_ZERO LocalMessage_NestedExportEnum = 0
)

// Enum value maps for LocalMessage_NestedExportEnum.
var (
	LocalMessage_NestedExportEnum_name = map[int32]string{
		0: "EXPORT_ZERO",
	}
	LocalMessage_NestedExportEnum_value = map[string]int32{
		"EXPORT_ZERO": 0,
	}
)

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

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

func (LocalMessage_NestedExportEnum) Descriptor() protoreflect.EnumDescriptor {
	return file_cmd_protoc_gen_go_testdata_visibility_visibility_proto_enumTypes[10].Descriptor()
}

func (LocalMessage_NestedExportEnum) Type() protoreflect.EnumType {
	return &file_cmd_protoc_gen_go_testdata_visibility_visibility_proto_enumTypes[10]
}

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

type LocalMessage_NestedLocalEnum int32

const (
	LocalMessage_LOCAL_ZERO LocalMessage_NestedLocalEnum = 0
)

// Enum value maps for LocalMessage_NestedLocalEnum.
var (
	LocalMessage_NestedLocalEnum_name = map[int32]string{
		0: "LOCAL_ZERO",
	}
	LocalMessage_NestedLocalEnum_value = map[string]int32{
		"LOCAL_ZERO": 0,
	}
)

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

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

func (LocalMessage_NestedLocalEnum) Descriptor() protoreflect.EnumDescriptor {
	return file_cmd_protoc_gen_go_testdata_visibility_visibility_proto_enumTypes[11].Descriptor()
}

func (LocalMessage_NestedLocalEnum) Type() protoreflect.EnumType {
	return &file_cmd_protoc_gen_go_testdata_visibility_visibility_proto_enumTypes[11]
}

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

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

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

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

func (*DefaultMessage) ProtoMessage() {}

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

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

}

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

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

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

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

func (*ExportMessage) ProtoMessage() {}

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

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

}

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

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

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

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

func (*LocalMessage) ProtoMessage() {}

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

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

}

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

type DefaultMessage_NestedDefaultMessage struct {
	state                  protoimpl.MessageState `protogen:"opaque.v1"`
	xxx_hidden_Id          uint64                 `protobuf:"varint,1,opt,name=id"`
	XXX_raceDetectHookData protoimpl.RaceDetectHookData
	XXX_presence           [1]uint32
	unknownFields          protoimpl.UnknownFields
	sizeCache              protoimpl.SizeCache
}

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

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

func (*DefaultMessage_NestedDefaultMessage) ProtoMessage() {}

func (x *DefaultMessage_NestedDefaultMessage) ProtoReflect() protoreflect.Message {
	mi := &file_cmd_protoc_gen_go_testdata_visibility_visibility_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 *DefaultMessage_NestedDefaultMessage) GetId() uint64 {
	if x != nil {
		return x.xxx_hidden_Id
	}
	return 0
}

func (x *DefaultMessage_NestedDefaultMessage) SetId(v uint64) {
	x.xxx_hidden_Id = v
	protoimpl.X.SetPresent(&(x.XXX_presence[0]), 0, 1)
}

func (x *DefaultMessage_NestedDefaultMessage) HasId() bool {
	if x == nil {
		return false
	}
	return protoimpl.X.Present(&(x.XXX_presence[0]), 0)
}

func (x *DefaultMessage_NestedDefaultMessage) ClearId() {
	protoimpl.X.ClearPresent(&(x.XXX_presence[0]), 0)
	x.xxx_hidden_Id = 0
}

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

	Id *uint64
}

func (b0 DefaultMessage_NestedDefaultMessage_builder) Build() *DefaultMessage_NestedDefaultMessage {
	m0 := &DefaultMessage_NestedDefaultMessage{}
	b, x := &b0, m0
	_, _ = b, x
	if b.Id != nil {
		protoimpl.X.SetPresentNonAtomic(&(x.XXX_presence[0]), 0, 1)
		x.xxx_hidden_Id = *b.Id
	}
	return m0
}

type DefaultMessage_NestedExportMessage struct {
	state                  protoimpl.MessageState `protogen:"opaque.v1"`
	xxx_hidden_Name        *string                `protobuf:"bytes,1,opt,name=name"`
	XXX_raceDetectHookData protoimpl.RaceDetectHookData
	XXX_presence           [1]uint32
	unknownFields          protoimpl.UnknownFields
	sizeCache              protoimpl.SizeCache
}

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

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

func (*DefaultMessage_NestedExportMessage) ProtoMessage() {}

func (x *DefaultMessage_NestedExportMessage) ProtoReflect() protoreflect.Message {
	mi := &file_cmd_protoc_gen_go_testdata_visibility_visibility_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 *DefaultMessage_NestedExportMessage) GetName() string {
	if x != nil {
		if x.xxx_hidden_Name != nil {
			return *x.xxx_hidden_Name
		}
		return ""
	}
	return ""
}

func (x *DefaultMessage_NestedExportMessage) SetName(v string) {
	x.xxx_hidden_Name = &v
	protoimpl.X.SetPresent(&(x.XXX_presence[0]), 0, 1)
}

func (x *DefaultMessage_NestedExportMessage) HasName() bool {
	if x == nil {
		return false
	}
	return protoimpl.X.Present(&(x.XXX_presence[0]), 0)
}

func (x *DefaultMessage_NestedExportMessage) ClearName() {
	protoimpl.X.ClearPresent(&(x.XXX_presence[0]), 0)
	x.xxx_hidden_Name = nil
}

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

	Name *string
}

func (b0 DefaultMessage_NestedExportMessage_builder) Build() *DefaultMessage_NestedExportMessage {
	m0 := &DefaultMessage_NestedExportMessage{}
	b, x := &b0, m0
	_, _ = b, x
	if b.Name != nil {
		protoimpl.X.SetPresentNonAtomic(&(x.XXX_presence[0]), 0, 1)
		x.xxx_hidden_Name = b.Name
	}
	return m0
}

type DefaultMessage_NestedLocalMessage struct {
	state                  protoimpl.MessageState `protogen:"opaque.v1"`
	xxx_hidden_Uuid        []byte                 `protobuf:"bytes,1,opt,name=uuid"`
	XXX_raceDetectHookData protoimpl.RaceDetectHookData
	XXX_presence           [1]uint32
	unknownFields          protoimpl.UnknownFields
	sizeCache              protoimpl.SizeCache
}

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

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

func (*DefaultMessage_NestedLocalMessage) ProtoMessage() {}

func (x *DefaultMessage_NestedLocalMessage) ProtoReflect() protoreflect.Message {
	mi := &file_cmd_protoc_gen_go_testdata_visibility_visibility_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 *DefaultMessage_NestedLocalMessage) GetUuid() []byte {
	if x != nil {
		return x.xxx_hidden_Uuid
	}
	return nil
}

func (x *DefaultMessage_NestedLocalMessage) SetUuid(v []byte) {
	if v == nil {
		v = []byte{}
	}
	x.xxx_hidden_Uuid = v
	protoimpl.X.SetPresent(&(x.XXX_presence[0]), 0, 1)
}

func (x *DefaultMessage_NestedLocalMessage) HasUuid() bool {
	if x == nil {
		return false
	}
	return protoimpl.X.Present(&(x.XXX_presence[0]), 0)
}

func (x *DefaultMessage_NestedLocalMessage) ClearUuid() {
	protoimpl.X.ClearPresent(&(x.XXX_presence[0]), 0)
	x.xxx_hidden_Uuid = nil
}

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

	Uuid []byte
}

func (b0 DefaultMessage_NestedLocalMessage_builder) Build() *DefaultMessage_NestedLocalMessage {
	m0 := &DefaultMessage_NestedLocalMessage{}
	b, x := &b0, m0
	_, _ = b, x
	if b.Uuid != nil {
		protoimpl.X.SetPresentNonAtomic(&(x.XXX_presence[0]), 0, 1)
		x.xxx_hidden_Uuid = b.Uuid
	}
	return m0
}

type ExportMessage_NestedDefaultMessage struct {
	state                  protoimpl.MessageState `protogen:"opaque.v1"`
	xxx_hidden_Id          uint64                 `protobuf:"varint,1,opt,name=id"`
	XXX_raceDetectHookData protoimpl.RaceDetectHookData
	XXX_presence           [1]uint32
	unknownFields          protoimpl.UnknownFields
	sizeCache              protoimpl.SizeCache
}

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

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

func (*ExportMessage_NestedDefaultMessage) ProtoMessage() {}

func (x *ExportMessage_NestedDefaultMessage) ProtoReflect() protoreflect.Message {
	mi := &file_cmd_protoc_gen_go_testdata_visibility_visibility_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 *ExportMessage_NestedDefaultMessage) GetId() uint64 {
	if x != nil {
		return x.xxx_hidden_Id
	}
	return 0
}

func (x *ExportMessage_NestedDefaultMessage) SetId(v uint64) {
	x.xxx_hidden_Id = v
	protoimpl.X.SetPresent(&(x.XXX_presence[0]), 0, 1)
}

func (x *ExportMessage_NestedDefaultMessage) HasId() bool {
	if x == nil {
		return false
	}
	return protoimpl.X.Present(&(x.XXX_presence[0]), 0)
}

func (x *ExportMessage_NestedDefaultMessage) ClearId() {
	protoimpl.X.ClearPresent(&(x.XXX_presence[0]), 0)
	x.xxx_hidden_Id = 0
}

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

	Id *uint64
}

func (b0 ExportMessage_NestedDefaultMessage_builder) Build() *ExportMessage_NestedDefaultMessage {
	m0 := &ExportMessage_NestedDefaultMessage{}
	b, x := &b0, m0
	_, _ = b, x
	if b.Id != nil {
		protoimpl.X.SetPresentNonAtomic(&(x.XXX_presence[0]), 0, 1)
		x.xxx_hidden_Id = *b.Id
	}
	return m0
}

type ExportMessage_NestedExportMessage struct {
	state                  protoimpl.MessageState `protogen:"opaque.v1"`
	xxx_hidden_Name        *string                `protobuf:"bytes,1,opt,name=name"`
	XXX_raceDetectHookData protoimpl.RaceDetectHookData
	XXX_presence           [1]uint32
	unknownFields          protoimpl.UnknownFields
	sizeCache              protoimpl.SizeCache
}

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

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

func (*ExportMessage_NestedExportMessage) ProtoMessage() {}

func (x *ExportMessage_NestedExportMessage) ProtoReflect() protoreflect.Message {
	mi := &file_cmd_protoc_gen_go_testdata_visibility_visibility_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 *ExportMessage_NestedExportMessage) GetName() string {
	if x != nil {
		if x.xxx_hidden_Name != nil {
			return *x.xxx_hidden_Name
		}
		return ""
	}
	return ""
}

func (x *ExportMessage_NestedExportMessage) SetName(v string) {
	x.xxx_hidden_Name = &v
	protoimpl.X.SetPresent(&(x.XXX_presence[0]), 0, 1)
}

func (x *ExportMessage_NestedExportMessage) HasName() bool {
	if x == nil {
		return false
	}
	return protoimpl.X.Present(&(x.XXX_presence[0]), 0)
}

func (x *ExportMessage_NestedExportMessage) ClearName() {
	protoimpl.X.ClearPresent(&(x.XXX_presence[0]), 0)
	x.xxx_hidden_Name = nil
}

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

	Name *string
}

func (b0 ExportMessage_NestedExportMessage_builder) Build() *ExportMessage_NestedExportMessage {
	m0 := &ExportMessage_NestedExportMessage{}
	b, x := &b0, m0
	_, _ = b, x
	if b.Name != nil {
		protoimpl.X.SetPresentNonAtomic(&(x.XXX_presence[0]), 0, 1)
		x.xxx_hidden_Name = b.Name
	}
	return m0
}

type ExportMessage_NestedLocalMessage struct {
	state                  protoimpl.MessageState `protogen:"opaque.v1"`
	xxx_hidden_Uuid        []byte                 `protobuf:"bytes,1,opt,name=uuid"`
	XXX_raceDetectHookData protoimpl.RaceDetectHookData
	XXX_presence           [1]uint32
	unknownFields          protoimpl.UnknownFields
	sizeCache              protoimpl.SizeCache
}

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

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

func (*ExportMessage_NestedLocalMessage) ProtoMessage() {}

func (x *ExportMessage_NestedLocalMessage) ProtoReflect() protoreflect.Message {
	mi := &file_cmd_protoc_gen_go_testdata_visibility_visibility_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 *ExportMessage_NestedLocalMessage) GetUuid() []byte {
	if x != nil {
		return x.xxx_hidden_Uuid
	}
	return nil
}

func (x *ExportMessage_NestedLocalMessage) SetUuid(v []byte) {
	if v == nil {
		v = []byte{}
	}
	x.xxx_hidden_Uuid = v
	protoimpl.X.SetPresent(&(x.XXX_presence[0]), 0, 1)
}

func (x *ExportMessage_NestedLocalMessage) HasUuid() bool {
	if x == nil {
		return false
	}
	return protoimpl.X.Present(&(x.XXX_presence[0]), 0)
}

func (x *ExportMessage_NestedLocalMessage) ClearUuid() {
	protoimpl.X.ClearPresent(&(x.XXX_presence[0]), 0)
	x.xxx_hidden_Uuid = nil
}

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

	Uuid []byte
}

func (b0 ExportMessage_NestedLocalMessage_builder) Build() *ExportMessage_NestedLocalMessage {
	m0 := &ExportMessage_NestedLocalMessage{}
	b, x := &b0, m0
	_, _ = b, x
	if b.Uuid != nil {
		protoimpl.X.SetPresentNonAtomic(&(x.XXX_presence[0]), 0, 1)
		x.xxx_hidden_Uuid = b.Uuid
	}
	return m0
}

type LocalMessage_NestedDefaultMessage struct {
	state                  protoimpl.MessageState `protogen:"opaque.v1"`
	xxx_hidden_Id          uint64                 `protobuf:"varint,1,opt,name=id"`
	XXX_raceDetectHookData protoimpl.RaceDetectHookData
	XXX_presence           [1]uint32
	unknownFields          protoimpl.UnknownFields
	sizeCache              protoimpl.SizeCache
}

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

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

func (*LocalMessage_NestedDefaultMessage) ProtoMessage() {}

func (x *LocalMessage_NestedDefaultMessage) ProtoReflect() protoreflect.Message {
	mi := &file_cmd_protoc_gen_go_testdata_visibility_visibility_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 *LocalMessage_NestedDefaultMessage) GetId() uint64 {
	if x != nil {
		return x.xxx_hidden_Id
	}
	return 0
}

func (x *LocalMessage_NestedDefaultMessage) SetId(v uint64) {
	x.xxx_hidden_Id = v
	protoimpl.X.SetPresent(&(x.XXX_presence[0]), 0, 1)
}

func (x *LocalMessage_NestedDefaultMessage) HasId() bool {
	if x == nil {
		return false
	}
	return protoimpl.X.Present(&(x.XXX_presence[0]), 0)
}

func (x *LocalMessage_NestedDefaultMessage) ClearId() {
	protoimpl.X.ClearPresent(&(x.XXX_presence[0]), 0)
	x.xxx_hidden_Id = 0
}

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

	Id *uint64
}

func (b0 LocalMessage_NestedDefaultMessage_builder) Build() *LocalMessage_NestedDefaultMessage {
	m0 := &LocalMessage_NestedDefaultMessage{}
	b, x := &b0, m0
	_, _ = b, x
	if b.Id != nil {
		protoimpl.X.SetPresentNonAtomic(&(x.XXX_presence[0]), 0, 1)
		x.xxx_hidden_Id = *b.Id
	}
	return m0
}

type LocalMessage_NestedExportMessage struct {
	state                  protoimpl.MessageState `protogen:"opaque.v1"`
	xxx_hidden_Name        *string                `protobuf:"bytes,1,opt,name=name"`
	XXX_raceDetectHookData protoimpl.RaceDetectHookData
	XXX_presence           [1]uint32
	unknownFields          protoimpl.UnknownFields
	sizeCache              protoimpl.SizeCache
}

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

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

func (*LocalMessage_NestedExportMessage) ProtoMessage() {}

func (x *LocalMessage_NestedExportMessage) ProtoReflect() protoreflect.Message {
	mi := &file_cmd_protoc_gen_go_testdata_visibility_visibility_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 *LocalMessage_NestedExportMessage) GetName() string {
	if x != nil {
		if x.xxx_hidden_Name != nil {
			return *x.xxx_hidden_Name
		}
		return ""
	}
	return ""
}

func (x *LocalMessage_NestedExportMessage) SetName(v string) {
	x.xxx_hidden_Name = &v
	protoimpl.X.SetPresent(&(x.XXX_presence[0]), 0, 1)
}

func (x *LocalMessage_NestedExportMessage) HasName() bool {
	if x == nil {
		return false
	}
	return protoimpl.X.Present(&(x.XXX_presence[0]), 0)
}

func (x *LocalMessage_NestedExportMessage) ClearName() {
	protoimpl.X.ClearPresent(&(x.XXX_presence[0]), 0)
	x.xxx_hidden_Name = nil
}

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

	Name *string
}

func (b0 LocalMessage_NestedExportMessage_builder) Build() *LocalMessage_NestedExportMessage {
	m0 := &LocalMessage_NestedExportMessage{}
	b, x := &b0, m0
	_, _ = b, x
	if b.Name != nil {
		protoimpl.X.SetPresentNonAtomic(&(x.XXX_presence[0]), 0, 1)
		x.xxx_hidden_Name = b.Name
	}
	return m0
}

type LocalMessage_NestedLocalMessage struct {
	state                  protoimpl.MessageState `protogen:"opaque.v1"`
	xxx_hidden_Uuid        []byte                 `protobuf:"bytes,1,opt,name=uuid"`
	XXX_raceDetectHookData protoimpl.RaceDetectHookData
	XXX_presence           [1]uint32
	unknownFields          protoimpl.UnknownFields
	sizeCache              protoimpl.SizeCache
}

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

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

func (*LocalMessage_NestedLocalMessage) ProtoMessage() {}

func (x *LocalMessage_NestedLocalMessage) ProtoReflect() protoreflect.Message {
	mi := &file_cmd_protoc_gen_go_testdata_visibility_visibility_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 *LocalMessage_NestedLocalMessage) GetUuid() []byte {
	if x != nil {
		return x.xxx_hidden_Uuid
	}
	return nil
}

func (x *LocalMessage_NestedLocalMessage) SetUuid(v []byte) {
	if v == nil {
		v = []byte{}
	}
	x.xxx_hidden_Uuid = v
	protoimpl.X.SetPresent(&(x.XXX_presence[0]), 0, 1)
}

func (x *LocalMessage_NestedLocalMessage) HasUuid() bool {
	if x == nil {
		return false
	}
	return protoimpl.X.Present(&(x.XXX_presence[0]), 0)
}

func (x *LocalMessage_NestedLocalMessage) ClearUuid() {
	protoimpl.X.ClearPresent(&(x.XXX_presence[0]), 0)
	x.xxx_hidden_Uuid = nil
}

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

	Uuid []byte
}

func (b0 LocalMessage_NestedLocalMessage_builder) Build() *LocalMessage_NestedLocalMessage {
	m0 := &LocalMessage_NestedLocalMessage{}
	b, x := &b0, m0
	_, _ = b, x
	if b.Uuid != nil {
		protoimpl.X.SetPresentNonAtomic(&(x.XXX_presence[0]), 0, 1)
		x.xxx_hidden_Uuid = b.Uuid
	}
	return m0
}

var File_cmd_protoc_gen_go_testdata_visibility_visibility_proto protoreflect.FileDescriptor

const file_cmd_protoc_gen_go_testdata_visibility_visibility_proto_rawDesc = "" +
	"\n" +
	"6cmd/protoc-gen-go/testdata/visibility/visibility.proto\x12\x19goproto.protoc.visibility\"\x84\x02\n" +
	"\x0eDefaultMessage\x1a&\n" +
	"\x14NestedDefaultMessage\x12\x0e\n" +
	"\x02id\x18\x01 \x01(\x04R\x02id\x1a+\n" +
	"\x13NestedExportMessage\x12\x12\n" +
	"\x04name\x18\x01 \x01(\tR\x04nameX\x02\x1a*\n" +
	"\x12NestedLocalMessage\x12\x12\n" +
	"\x04uuid\x18\x01 \x01(\fR\x04uuidX\x01\"%\n" +
	"\x11NestedDefaultEnum\x12\x10\n" +
	"\fDEFAULT_ZERO\x10\x00\"%\n" +
	"\x10NestedExportEnum\x12\x0f\n" +
	"\vEXPORT_ZERO\x10\x000\x02\"#\n" +
	"\x0fNestedLocalEnum\x12\x0e\n" +
	"\n" +
	"LOCAL_ZERO\x10\x000\x01\"\x85\x02\n" +
	"\rExportMessage\x1a&\n" +
	"\x14NestedDefaultMessage\x12\x0e\n" +
	"\x02id\x18\x01 \x01(\x04R\x02id\x1a+\n" +
	"\x13NestedExportMessage\x12\x12\n" +
	"\x04name\x18\x01 \x01(\tR\x04nameX\x02\x1a*\n" +
	"\x12NestedLocalMessage\x12\x12\n" +
	"\x04uuid\x18\x01 \x01(\fR\x04uuidX\x01\"%\n" +
	"\x11NestedDefaultEnum\x12\x10\n" +
	"\fDEFAULT_ZERO\x10\x00\"%\n" +
	"\x10NestedExportEnum\x12\x0f\n" +
	"\vEXPORT_ZERO\x10\x000\x02\"#\n" +
	"\x0fNestedLocalEnum\x12\x0e\n" +
	"\n" +
	"LOCAL_ZERO\x10\x000\x01X\x02\"\x84\x02\n" +
	"\fLocalMessage\x1a&\n" +
	"\x14NestedDefaultMessage\x12\x0e\n" +
	"\x02id\x18\x01 \x01(\x04R\x02id\x1a+\n" +
	"\x13NestedExportMessage\x12\x12\n" +
	"\x04name\x18\x01 \x01(\tR\x04nameX\x02\x1a*\n" +
	"\x12NestedLocalMessage\x12\x12\n" +
	"\x04uuid\x18\x01 \x01(\fR\x04uuidX\x01\"%\n" +
	"\x11NestedDefaultEnum\x12\x10\n" +
	"\fDEFAULT_ZERO\x10\x00\"%\n" +
	"\x10NestedExportEnum\x12\x0f\n" +
	"\vEXPORT_ZERO\x10\x000\x02\"#\n" +
	"\x0fNestedLocalEnum\x12\x0e\n" +
	"\n" +
	"LOCAL_ZERO\x10\x000\x01X\x01*\x1f\n" +
	"\vDefaultEnum\x12\x10\n" +
	"\fDEFAULT_ZERO\x10\x00*\x1f\n" +
	"\n" +
	"ExportEnum\x12\x0f\n" +
	"\vEXPORT_ZERO\x10\x000\x02*\x1d\n" +
	"\tLocalEnum\x12\x0e\n" +
	"\n" +
	"LOCAL_ZERO\x10\x000\x01BEZ@google.golang.org/protobuf/cmd/protoc-gen-go/testdata/visibility\x92\x03\x00b\beditionsp\xe9\a"

var file_cmd_protoc_gen_go_testdata_visibility_visibility_proto_enumTypes = make([]protoimpl.EnumInfo, 12)
var file_cmd_protoc_gen_go_testdata_visibility_visibility_proto_msgTypes = make([]protoimpl.MessageInfo, 12)
var file_cmd_protoc_gen_go_testdata_visibility_visibility_proto_goTypes = []any{
	(DefaultEnum)(0),                            // 0: goproto.protoc.visibility.DefaultEnum
	(ExportEnum)(0),                             // 1: goproto.protoc.visibility.ExportEnum
	(LocalEnum)(0),                              // 2: goproto.protoc.visibility.LocalEnum
	(DefaultMessage_NestedDefaultEnum)(0),       // 3: goproto.protoc.visibility.DefaultMessage.NestedDefaultEnum
	(DefaultMessage_NestedExportEnum)(0),        // 4: goproto.protoc.visibility.DefaultMessage.NestedExportEnum
	(DefaultMessage_NestedLocalEnum)(0),         // 5: goproto.protoc.visibility.DefaultMessage.NestedLocalEnum
	(ExportMessage_NestedDefaultEnum)(0),        // 6: goproto.protoc.visibility.ExportMessage.NestedDefaultEnum
	(ExportMessage_NestedExportEnum)(0),         // 7: goproto.protoc.visibility.ExportMessage.NestedExportEnum
	(ExportMessage_NestedLocalEnum)(0),          // 8: goproto.protoc.visibility.ExportMessage.NestedLocalEnum
	(LocalMessage_NestedDefaultEnum)(0),         // 9: goproto.protoc.visibility.LocalMessage.NestedDefaultEnum
	(LocalMessage_NestedExportEnum)(0),          // 10: goproto.protoc.visibility.LocalMessage.NestedExportEnum
	(LocalMessage_NestedLocalEnum)(0),           // 11: goproto.protoc.visibility.LocalMessage.NestedLocalEnum
	(*DefaultMessage)(nil),                      // 12: goproto.protoc.visibility.DefaultMessage
	(*ExportMessage)(nil),                       // 13: goproto.protoc.visibility.ExportMessage
	(*LocalMessage)(nil),                        // 14: goproto.protoc.visibility.LocalMessage
	(*DefaultMessage_NestedDefaultMessage)(nil), // 15: goproto.protoc.visibility.DefaultMessage.NestedDefaultMessage
	(*DefaultMessage_NestedExportMessage)(nil),  // 16: goproto.protoc.visibility.DefaultMessage.NestedExportMessage
	(*DefaultMessage_NestedLocalMessage)(nil),   // 17: goproto.protoc.visibility.DefaultMessage.NestedLocalMessage
	(*ExportMessage_NestedDefaultMessage)(nil),  // 18: goproto.protoc.visibility.ExportMessage.NestedDefaultMessage
	(*ExportMessage_NestedExportMessage)(nil),   // 19: goproto.protoc.visibility.ExportMessage.NestedExportMessage
	(*ExportMessage_NestedLocalMessage)(nil),    // 20: goproto.protoc.visibility.ExportMessage.NestedLocalMessage
	(*LocalMessage_NestedDefaultMessage)(nil),   // 21: goproto.protoc.visibility.LocalMessage.NestedDefaultMessage
	(*LocalMessage_NestedExportMessage)(nil),    // 22: goproto.protoc.visibility.LocalMessage.NestedExportMessage
	(*LocalMessage_NestedLocalMessage)(nil),     // 23: goproto.protoc.visibility.LocalMessage.NestedLocalMessage
}
var file_cmd_protoc_gen_go_testdata_visibility_visibility_proto_depIdxs = []int32{
	0, // [0:0] is the sub-list for method output_type
	0, // [0:0] is the sub-list for method input_type
	0, // [0:0] is the sub-list for extension type_name
	0, // [0:0] is the sub-list for extension extendee
	0, // [0:0] is the sub-list for field type_name
}

func init() { file_cmd_protoc_gen_go_testdata_visibility_visibility_proto_init() }
func file_cmd_protoc_gen_go_testdata_visibility_visibility_proto_init() {
	if File_cmd_protoc_gen_go_testdata_visibility_visibility_proto != nil {
		return
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_cmd_protoc_gen_go_testdata_visibility_visibility_proto_rawDesc), len(file_cmd_protoc_gen_go_testdata_visibility_visibility_proto_rawDesc)),
			NumEnums:      12,
			NumMessages:   12,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_cmd_protoc_gen_go_testdata_visibility_visibility_proto_goTypes,
		DependencyIndexes: file_cmd_protoc_gen_go_testdata_visibility_visibility_proto_depIdxs,
		EnumInfos:         file_cmd_protoc_gen_go_testdata_visibility_visibility_proto_enumTypes,
		MessageInfos:      file_cmd_protoc_gen_go_testdata_visibility_visibility_proto_msgTypes,
	}.Build()
	File_cmd_protoc_gen_go_testdata_visibility_visibility_proto = out.File
	file_cmd_protoc_gen_go_testdata_visibility_visibility_proto_goTypes = nil
	file_cmd_protoc_gen_go_testdata_visibility_visibility_proto_depIdxs = nil
}
