func (*TestAllTypes) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _TestAllTypes_OneofMarshaler, _TestAllTypes_OneofUnmarshaler, _TestAllTypes_OneofSizer, []interface{}{
		(*TestAllTypes_OneofUint32)(nil),
		(*TestAllTypes_OneofNestedMessage)(nil),
		(*TestAllTypes_OneofString)(nil),
		(*TestAllTypes_OneofBytes)(nil),
		(*TestAllTypes_OneofImportedMessage)(nil),
	}
}
XXX_OneofFuncs is for the internal use of the proto package.
package types
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/johanbrandhorst/protobuf/proto"
import multi "github.com/johanbrandhorst/protobuf/test/server/proto/multi"
import (
	context "golang.org/x/net/context"
	grpc "google.golang.org/grpc"
)
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
const _ = proto.ProtoPackageIsVersion2  
type ForeignEnum int32
const (
	ForeignEnum_FOREIGN_UNSPECIFIED ForeignEnum = 0
	ForeignEnum_FOREIGN_FOO         ForeignEnum = 4
	ForeignEnum_FOREIGN_BAR         ForeignEnum = 5
	ForeignEnum_FOREIGN_BAZ         ForeignEnum = 6
)
var ForeignEnum_name = map[int32]string{
	0: "FOREIGN_UNSPECIFIED",
	4: "FOREIGN_FOO",
	5: "FOREIGN_BAR",
	6: "FOREIGN_BAZ",
}
var ForeignEnum_value = map[string]int32{
	"FOREIGN_UNSPECIFIED": 0,
	"FOREIGN_FOO":         4,
	"FOREIGN_BAR":         5,
	"FOREIGN_BAZ":         6,
}
func (x ForeignEnum) String() string {
	return proto.EnumName(ForeignEnum_name, int32(x))
}
func (ForeignEnum) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_types_70e44cff411bc46a, []int{0}
}
type MapEnum int32
const (
	MapEnum_MAP_ENUM_FOO MapEnum = 0
	MapEnum_MAP_ENUM_BAR MapEnum = 1
	MapEnum_MAP_ENUM_BAZ MapEnum = 2
)
var MapEnum_name = map[int32]string{
	0: "MAP_ENUM_FOO",
	1: "MAP_ENUM_BAR",
	2: "MAP_ENUM_BAZ",
}
var MapEnum_value = map[string]int32{
	"MAP_ENUM_FOO": 0,
	"MAP_ENUM_BAR": 1,
	"MAP_ENUM_BAZ": 2,
}
func (x MapEnum) String() string {
	return proto.EnumName(MapEnum_name, int32(x))
}
func (MapEnum) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_types_70e44cff411bc46a, []int{1}
}
type TestAllTypes_NestedEnum int32
const (
	TestAllTypes_NESTED_ENUM_UNSPECIFIED TestAllTypes_NestedEnum = 0
	TestAllTypes_FOO                     TestAllTypes_NestedEnum = 1
	TestAllTypes_BAR                     TestAllTypes_NestedEnum = 2
	TestAllTypes_BAZ                     TestAllTypes_NestedEnum = 3
	TestAllTypes_NEG                     TestAllTypes_NestedEnum = -1
)
var TestAllTypes_NestedEnum_name = map[int32]string{
	0:  "NESTED_ENUM_UNSPECIFIED",
	1:  "FOO",
	2:  "BAR",
	3:  "BAZ",
	-1: "NEG",
}
var TestAllTypes_NestedEnum_value = map[string]int32{
	"NESTED_ENUM_UNSPECIFIED": 0,
	"FOO": 1,
	"BAR": 2,
	"BAZ": 3,
	"NEG": -1,
}
func (x TestAllTypes_NestedEnum) String() string {
	return proto.EnumName(TestAllTypes_NestedEnum_name, int32(x))
}
func (TestAllTypes_NestedEnum) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_types_70e44cff411bc46a, []int{0, 0}
}
type TestAllTypes struct {
	SingleInt32           int32                       `protobuf:"varint,1,opt,name=single_int32,json=singleInt32" json:"single_int32,omitempty"`
	SingleInt64           int64                       `protobuf:"varint,2,opt,name=single_int64,json=singleInt64" json:"single_int64,omitempty"`
	SingleUint32          uint32                      `protobuf:"varint,3,opt,name=single_uint32,json=singleUint32" json:"single_uint32,omitempty"`
	SingleUint64          uint64                      `protobuf:"varint,4,opt,name=single_uint64,json=singleUint64" json:"single_uint64,omitempty"`
	SingleSint32          int32                       `protobuf:"zigzag32,5,opt,name=single_sint32,json=singleSint32" json:"single_sint32,omitempty"`
	SingleSint64          int64                       `protobuf:"zigzag64,6,opt,name=single_sint64,json=singleSint64" json:"single_sint64,omitempty"`
	SingleFixed32         uint32                      `protobuf:"fixed32,7,opt,name=single_fixed32,json=singleFixed32" json:"single_fixed32,omitempty"`
	SingleFixed64         uint64                      `protobuf:"fixed64,8,opt,name=single_fixed64,json=singleFixed64" json:"single_fixed64,omitempty"`
	SingleSfixed32        int32                       `protobuf:"fixed32,9,opt,name=single_sfixed32,json=singleSfixed32" json:"single_sfixed32,omitempty"`
	SingleSfixed64        int64                       `protobuf:"fixed64,10,opt,name=single_sfixed64,json=singleSfixed64" json:"single_sfixed64,omitempty"`
	SingleFloat           float32                     `protobuf:"fixed32,11,opt,name=single_float,json=singleFloat" json:"single_float,omitempty"`
	SingleDouble          float64                     `protobuf:"fixed64,12,opt,name=single_double,json=singleDouble" json:"single_double,omitempty"`
	SingleBool            bool                        `protobuf:"varint,13,opt,name=single_bool,json=singleBool" json:"single_bool,omitempty"`
	SingleString          string                      `protobuf:"bytes,14,opt,name=single_string,json=singleString" json:"single_string,omitempty"`
	SingleBytes           []byte                      `protobuf:"bytes,15,opt,name=single_bytes,json=singleBytes,proto3" json:"single_bytes,omitempty"`
	SingleImportedMessage *multi.Multi1               `protobuf:"bytes,16,opt,name=single_imported_message,json=singleImportedMessage" json:"single_imported_message,omitempty"`
	SingleNestedMessage   *TestAllTypes_NestedMessage `protobuf:"bytes,18,opt,name=single_nested_message,json=singleNestedMessage" json:"single_nested_message,omitempty"`
	SingleForeignMessage  *ForeignMessage             `protobuf:"bytes,19,opt,name=single_foreign_message,json=singleForeignMessage" json:"single_foreign_message,omitempty"`
	SingleNestedEnum      TestAllTypes_NestedEnum     `protobuf:"varint,21,opt,name=single_nested_enum,json=singleNestedEnum,enum=types.TestAllTypes_NestedEnum" json:"single_nested_enum,omitempty"`
	SingleForeignEnum     ForeignEnum                 `protobuf:"varint,22,opt,name=single_foreign_enum,json=singleForeignEnum,enum=types.ForeignEnum" json:"single_foreign_enum,omitempty"`
	RepeatedInt32           []int32                       `protobuf:"varint,31,rep,packed,name=repeated_int32,json=repeatedInt32" json:"repeated_int32,omitempty"`
	RepeatedInt64           []int64                       `protobuf:"varint,32,rep,packed,name=repeated_int64,json=repeatedInt64" json:"repeated_int64,omitempty"`
	RepeatedUint32          []uint32                      `protobuf:"varint,33,rep,packed,name=repeated_uint32,json=repeatedUint32" json:"repeated_uint32,omitempty"`
	RepeatedUint64          []uint64                      `protobuf:"varint,34,rep,packed,name=repeated_uint64,json=repeatedUint64" json:"repeated_uint64,omitempty"`
	RepeatedSint32          []int32                       `protobuf:"zigzag32,35,rep,packed,name=repeated_sint32,json=repeatedSint32" json:"repeated_sint32,omitempty"`
	RepeatedSint64          []int64                       `protobuf:"zigzag64,36,rep,packed,name=repeated_sint64,json=repeatedSint64" json:"repeated_sint64,omitempty"`
	RepeatedFixed32         []uint32                      `protobuf:"fixed32,37,rep,packed,name=repeated_fixed32,json=repeatedFixed32" json:"repeated_fixed32,omitempty"`
	RepeatedFixed64         []uint64                      `protobuf:"fixed64,38,rep,packed,name=repeated_fixed64,json=repeatedFixed64" json:"repeated_fixed64,omitempty"`
	RepeatedSfixed32        []int32                       `protobuf:"fixed32,39,rep,packed,name=repeated_sfixed32,json=repeatedSfixed32" json:"repeated_sfixed32,omitempty"`
	RepeatedSfixed64        []int64                       `protobuf:"fixed64,40,rep,packed,name=repeated_sfixed64,json=repeatedSfixed64" json:"repeated_sfixed64,omitempty"`
	RepeatedFloat           []float32                     `protobuf:"fixed32,41,rep,packed,name=repeated_float,json=repeatedFloat" json:"repeated_float,omitempty"`
	RepeatedDouble          []float64                     `protobuf:"fixed64,42,rep,packed,name=repeated_double,json=repeatedDouble" json:"repeated_double,omitempty"`
	RepeatedBool            []bool                        `protobuf:"varint,43,rep,packed,name=repeated_bool,json=repeatedBool" json:"repeated_bool,omitempty"`
	RepeatedString          []string                      `protobuf:"bytes,44,rep,name=repeated_string,json=repeatedString" json:"repeated_string,omitempty"`
	RepeatedBytes           [][]byte                      `protobuf:"bytes,45,rep,name=repeated_bytes,json=repeatedBytes,proto3" json:"repeated_bytes,omitempty"`
	RepeatedImportedMessage []*multi.Multi1               `protobuf:"bytes,46,rep,name=repeated_imported_message,json=repeatedImportedMessage" json:"repeated_imported_message,omitempty"`
	RepeatedNestedMessage   []*TestAllTypes_NestedMessage `protobuf:"bytes,48,rep,name=repeated_nested_message,json=repeatedNestedMessage" json:"repeated_nested_message,omitempty"`
	RepeatedForeignMessage  []*ForeignMessage             `protobuf:"bytes,49,rep,name=repeated_foreign_message,json=repeatedForeignMessage" json:"repeated_foreign_message,omitempty"`
	RepeatedNestedEnum      []TestAllTypes_NestedEnum     `protobuf:"varint,51,rep,packed,name=repeated_nested_enum,json=repeatedNestedEnum,enum=types.TestAllTypes_NestedEnum" json:"repeated_nested_enum,omitempty"`
	RepeatedForeignEnum     []ForeignEnum                 `protobuf:"varint,52,rep,packed,name=repeated_foreign_enum,json=repeatedForeignEnum,enum=types.ForeignEnum" json:"repeated_foreign_enum,omitempty"`
	OneofField           isTestAllTypes_OneofField `protobuf_oneof:"oneof_field"`
	XXX_NoUnkeyedLiteral struct{}                  `json:"-"`
	XXX_unrecognized     []byte                    `json:"-"`
	XXX_sizecache        int32                     `json:"-"`
}
func (m *TestAllTypes) Reset()         { *m = TestAllTypes{} }
func (m *TestAllTypes) String() string { return proto.CompactTextString(m) }
func (*TestAllTypes) ProtoMessage()    {}
func (*TestAllTypes) Descriptor() ([]byte, []int) {
	return fileDescriptor_types_70e44cff411bc46a, []int{0}
}
func (m *TestAllTypes) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TestAllTypes.Unmarshal(m, b)
}
func (m *TestAllTypes) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TestAllTypes.Marshal(b, m, deterministic)
}
func (dst *TestAllTypes) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TestAllTypes.Merge(dst, src)
}
func (m *TestAllTypes) XXX_Size() int {
	return xxx_messageInfo_TestAllTypes.Size(m)
}
func (m *TestAllTypes) XXX_DiscardUnknown() {
	xxx_messageInfo_TestAllTypes.DiscardUnknown(m)
}
var xxx_messageInfo_TestAllTypes proto.InternalMessageInfo
type isTestAllTypes_OneofField interface {
	isTestAllTypes_OneofField()
}
type TestAllTypes_OneofUint32 struct {
	OneofUint32 uint32 `protobuf:"varint,111,opt,name=oneof_uint32,json=oneofUint32,oneof"`
}
type TestAllTypes_OneofNestedMessage struct {
	OneofNestedMessage *TestAllTypes_NestedMessage `protobuf:"bytes,112,opt,name=oneof_nested_message,json=oneofNestedMessage,oneof"`
}
type TestAllTypes_OneofString struct {
	OneofString string `protobuf:"bytes,113,opt,name=oneof_string,json=oneofString,oneof"`
}
type TestAllTypes_OneofBytes struct {
	OneofBytes []byte `protobuf:"bytes,114,opt,name=oneof_bytes,json=oneofBytes,proto3,oneof"`
}
type TestAllTypes_OneofImportedMessage struct {
	OneofImportedMessage *multi.Multi1 `protobuf:"bytes,115,opt,name=oneof_imported_message,json=oneofImportedMessage,oneof"`
}
func (*TestAllTypes_OneofUint32) isTestAllTypes_OneofField()          {}
func (*TestAllTypes_OneofNestedMessage) isTestAllTypes_OneofField()   {}
func (*TestAllTypes_OneofString) isTestAllTypes_OneofField()          {}
func (*TestAllTypes_OneofBytes) isTestAllTypes_OneofField()           {}
func (*TestAllTypes_OneofImportedMessage) isTestAllTypes_OneofField() {}
func (m *TestAllTypes) GetOneofField() isTestAllTypes_OneofField {
	if m != nil {
		return m.OneofField
	}
	return nil
}
func (m *TestAllTypes) GetSingleInt32() int32 {
	if m != nil {
		return m.SingleInt32
	}
	return 0
}
func (m *TestAllTypes) GetSingleInt64() int64 {
	if m != nil {
		return m.SingleInt64
	}
	return 0
}
func (m *TestAllTypes) GetSingleUint32() uint32 {
	if m != nil {
		return m.SingleUint32
	}
	return 0
}
func (m *TestAllTypes) GetSingleUint64() uint64 {
	if m != nil {
		return m.SingleUint64
	}
	return 0
}
func (m *TestAllTypes) GetSingleSint32() int32 {
	if m != nil {
		return m.SingleSint32
	}
	return 0
}
func (m *TestAllTypes) GetSingleSint64() int64 {
	if m != nil {
		return m.SingleSint64
	}
	return 0
}
func (m *TestAllTypes) GetSingleFixed32() uint32 {
	if m != nil {
		return m.SingleFixed32
	}
	return 0
}
func (m *TestAllTypes) GetSingleFixed64() uint64 {
	if m != nil {
		return m.SingleFixed64
	}
	return 0
}
func (m *TestAllTypes) GetSingleSfixed32() int32 {
	if m != nil {
		return m.SingleSfixed32
	}
	return 0
}
func (m *TestAllTypes) GetSingleSfixed64() int64 {
	if m != nil {
		return m.SingleSfixed64
	}
	return 0
}
func (m *TestAllTypes) GetSingleFloat() float32 {
	if m != nil {
		return m.SingleFloat
	}
	return 0
}
func (m *TestAllTypes) GetSingleDouble() float64 {
	if m != nil {
		return m.SingleDouble
	}
	return 0
}
func (m *TestAllTypes) GetSingleBool() bool {
	if m != nil {
		return m.SingleBool
	}
	return false
}
func (m *TestAllTypes) GetSingleString() string {
	if m != nil {
		return m.SingleString
	}
	return ""
}
func (m *TestAllTypes) GetSingleBytes() []byte {
	if m != nil {
		return m.SingleBytes
	}
	return nil
}
func (m *TestAllTypes) GetSingleImportedMessage() *multi.Multi1 {
	if m != nil {
		return m.SingleImportedMessage
	}
	return nil
}
func (m *TestAllTypes) GetSingleNestedMessage() *TestAllTypes_NestedMessage {
	if m != nil {
		return m.SingleNestedMessage
	}
	return nil
}
func (m *TestAllTypes) GetSingleForeignMessage() *ForeignMessage {
	if m != nil {
		return m.SingleForeignMessage
	}
	return nil
}
func (m *TestAllTypes) GetSingleNestedEnum() TestAllTypes_NestedEnum {
	if m != nil {
		return m.SingleNestedEnum
	}
	return TestAllTypes_NESTED_ENUM_UNSPECIFIED
}
func (m *TestAllTypes) GetSingleForeignEnum() ForeignEnum {
	if m != nil {
		return m.SingleForeignEnum
	}
	return ForeignEnum_FOREIGN_UNSPECIFIED
}
func (m *TestAllTypes) GetRepeatedInt32() []int32 {
	if m != nil {
		return m.RepeatedInt32
	}
	return nil
}
func (m *TestAllTypes) GetRepeatedInt64() []int64 {
	if m != nil {
		return m.RepeatedInt64
	}
	return nil
}
func (m *TestAllTypes) GetRepeatedUint32() []uint32 {
	if m != nil {
		return m.RepeatedUint32
	}
	return nil
}
func (m *TestAllTypes) GetRepeatedUint64() []uint64 {
	if m != nil {
		return m.RepeatedUint64
	}
	return nil
}
func (m *TestAllTypes) GetRepeatedSint32() []int32 {
	if m != nil {
		return m.RepeatedSint32
	}
	return nil
}
func (m *TestAllTypes) GetRepeatedSint64() []int64 {
	if m != nil {
		return m.RepeatedSint64
	}
	return nil
}
func (m *TestAllTypes) GetRepeatedFixed32() []uint32 {
	if m != nil {
		return m.RepeatedFixed32
	}
	return nil
}
func (m *TestAllTypes) GetRepeatedFixed64() []uint64 {
	if m != nil {
		return m.RepeatedFixed64
	}
	return nil
}
func (m *TestAllTypes) GetRepeatedSfixed32() []int32 {
	if m != nil {
		return m.RepeatedSfixed32
	}
	return nil
}
func (m *TestAllTypes) GetRepeatedSfixed64() []int64 {
	if m != nil {
		return m.RepeatedSfixed64
	}
	return nil
}
func (m *TestAllTypes) GetRepeatedFloat() []float32 {
	if m != nil {
		return m.RepeatedFloat
	}
	return nil
}
func (m *TestAllTypes) GetRepeatedDouble() []float64 {
	if m != nil {
		return m.RepeatedDouble
	}
	return nil
}
func (m *TestAllTypes) GetRepeatedBool() []bool {
	if m != nil {
		return m.RepeatedBool
	}
	return nil
}
func (m *TestAllTypes) GetRepeatedString() []string {
	if m != nil {
		return m.RepeatedString
	}
	return nil
}
func (m *TestAllTypes) GetRepeatedBytes() [][]byte {
	if m != nil {
		return m.RepeatedBytes
	}
	return nil
}
func (m *TestAllTypes) GetRepeatedImportedMessage() []*multi.Multi1 {
	if m != nil {
		return m.RepeatedImportedMessage
	}
	return nil
}
func (m *TestAllTypes) GetRepeatedNestedMessage() []*TestAllTypes_NestedMessage {
	if m != nil {
		return m.RepeatedNestedMessage
	}
	return nil
}
func (m *TestAllTypes) GetRepeatedForeignMessage() []*ForeignMessage {
	if m != nil {
		return m.RepeatedForeignMessage
	}
	return nil
}
func (m *TestAllTypes) GetRepeatedNestedEnum() []TestAllTypes_NestedEnum {
	if m != nil {
		return m.RepeatedNestedEnum
	}
	return nil
}
func (m *TestAllTypes) GetRepeatedForeignEnum() []ForeignEnum {
	if m != nil {
		return m.RepeatedForeignEnum
	}
	return nil
}
func (m *TestAllTypes) GetOneofUint32() uint32 {
	if x, ok := m.GetOneofField().(*TestAllTypes_OneofUint32); ok {
		return x.OneofUint32
	}
	return 0
}
func (m *TestAllTypes) GetOneofNestedMessage() *TestAllTypes_NestedMessage {
	if x, ok := m.GetOneofField().(*TestAllTypes_OneofNestedMessage); ok {
		return x.OneofNestedMessage
	}
	return nil
}
func (m *TestAllTypes) GetOneofString() string {
	if x, ok := m.GetOneofField().(*TestAllTypes_OneofString); ok {
		return x.OneofString
	}
	return ""
}
func (m *TestAllTypes) GetOneofBytes() []byte {
	if x, ok := m.GetOneofField().(*TestAllTypes_OneofBytes); ok {
		return x.OneofBytes
	}
	return nil
}
func (m *TestAllTypes) GetOneofImportedMessage() *multi.Multi1 {
	if x, ok := m.GetOneofField().(*TestAllTypes_OneofImportedMessage); ok {
		return x.OneofImportedMessage
	}
	return nil
}