func (m *TestAllTypes_NestedMessage) Marshal() []byte {
	writer := jspb.NewWriter()
	m.MarshalToWriter(writer)
	return writer.GetResult()
}
Marshal marshals TestAllTypes_NestedMessage to a slice of bytes.
package types
import jspb "github.com/johanbrandhorst/protobuf/jspb"
import multitest2 "github.com/johanbrandhorst/protobuf/protoc-gen-gopherjs/test/multi"
import (
	context "context"
	grpcweb "github.com/johanbrandhorst/protobuf/grpcweb"
)
const _ = jspb.JspbPackageIsVersion2
type ForeignEnum int
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[int]string{
	0: "FOREIGN_UNSPECIFIED",
	4: "FOREIGN_FOO",
	5: "FOREIGN_BAR",
	6: "FOREIGN_BAZ",
}
var ForeignEnum_value = map[string]int{
	"FOREIGN_UNSPECIFIED": 0,
	"FOREIGN_FOO":         4,
	"FOREIGN_BAR":         5,
	"FOREIGN_BAZ":         6,
}
func (x ForeignEnum) String() string {
	return ForeignEnum_name[int(x)]
}
type MapEnum int
const (
	MapEnum_MAP_ENUM_FOO MapEnum = 0
	MapEnum_MAP_ENUM_BAR MapEnum = 1
	MapEnum_MAP_ENUM_BAZ MapEnum = 2
)
var MapEnum_name = map[int]string{
	0: "MAP_ENUM_FOO",
	1: "MAP_ENUM_BAR",
	2: "MAP_ENUM_BAZ",
}
var MapEnum_value = map[string]int{
	"MAP_ENUM_FOO": 0,
	"MAP_ENUM_BAR": 1,
	"MAP_ENUM_BAZ": 2,
}
func (x MapEnum) String() string {
	return MapEnum_name[int(x)]
}
type TestAllTypes_NestedEnum int
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[int]string{
	0:  "NESTED_ENUM_UNSPECIFIED",
	1:  "FOO",
	2:  "BAR",
	3:  "BAZ",
	-1: "NEG",
}
var TestAllTypes_NestedEnum_value = map[string]int{
	"NESTED_ENUM_UNSPECIFIED": 0,
	"FOO": 1,
	"BAR": 2,
	"BAZ": 3,
	"NEG": -1,
}
func (x TestAllTypes_NestedEnum) String() string {
	return TestAllTypes_NestedEnum_name[int(x)]
}
type TestAllTypes struct {
	SingleInt32           int32
	SingleInt64           int64
	SingleUint32          uint32
	SingleUint64          uint64
	SingleSint32          int32
	SingleSint64          int64
	SingleFixed32         uint32
	SingleFixed64         uint64
	SingleSfixed32        int32
	SingleSfixed64        int64
	SingleFloat           float32
	SingleDouble          float64
	SingleBool            bool
	SingleString          string
	SingleBytes           []byte
	SingleImportedMessage *multitest2.Multi1
	SingleNestedMessage   *TestAllTypes_NestedMessage
	SingleForeignMessage  *ForeignMessage
	SingleNestedEnum      TestAllTypes_NestedEnum
	SingleForeignEnum     ForeignEnum
	RepeatedInt32           []int32
	RepeatedInt64           []int64
	RepeatedUint32          []uint32
	RepeatedUint64          []uint64
	RepeatedSint32          []int32
	RepeatedSint64          []int64
	RepeatedFixed32         []uint32
	RepeatedFixed64         []uint64
	RepeatedSfixed32        []int32
	RepeatedSfixed64        []int64
	RepeatedFloat           []float32
	RepeatedDouble          []float64
	RepeatedBool            []bool
	RepeatedString          []string
	RepeatedBytes           [][]byte
	RepeatedImportedMessage []*multitest2.Multi1
	RepeatedNestedMessage   []*TestAllTypes_NestedMessage
	RepeatedForeignMessage  []*ForeignMessage
	RepeatedNestedEnum      []TestAllTypes_NestedEnum
	RepeatedForeignEnum     []ForeignEnum
	OneofField isTestAllTypes_OneofField
}
type isTestAllTypes_OneofField interface{ isTestAllTypes_OneofField() }
type TestAllTypes_OneofUint32 struct {
	OneofUint32 uint32
}
type TestAllTypes_OneofNestedMessage struct {
	OneofNestedMessage *TestAllTypes_NestedMessage
}
type TestAllTypes_OneofString struct {
	OneofString string
}
type TestAllTypes_OneofBytes struct {
	OneofBytes []byte
}
type TestAllTypes_OneofImportedMessage struct {
	OneofImportedMessage *multitest2.Multi1
}
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() (x isTestAllTypes_OneofField) {
	if m == nil {
		return x
	}
	return m.OneofField
}
func (m *TestAllTypes) GetSingleInt32() (x int32) {
	if m == nil {
		return x
	}
	return m.SingleInt32
}
func (m *TestAllTypes) GetSingleInt64() (x int64) {
	if m == nil {
		return x
	}
	return m.SingleInt64
}
func (m *TestAllTypes) GetSingleUint32() (x uint32) {
	if m == nil {
		return x
	}
	return m.SingleUint32
}
func (m *TestAllTypes) GetSingleUint64() (x uint64) {
	if m == nil {
		return x
	}
	return m.SingleUint64
}
func (m *TestAllTypes) GetSingleSint32() (x int32) {
	if m == nil {
		return x
	}
	return m.SingleSint32
}
func (m *TestAllTypes) GetSingleSint64() (x int64) {
	if m == nil {
		return x
	}
	return m.SingleSint64
}
func (m *TestAllTypes) GetSingleFixed32() (x uint32) {
	if m == nil {
		return x
	}
	return m.SingleFixed32
}
func (m *TestAllTypes) GetSingleFixed64() (x uint64) {
	if m == nil {
		return x
	}
	return m.SingleFixed64
}
func (m *TestAllTypes) GetSingleSfixed32() (x int32) {
	if m == nil {
		return x
	}
	return m.SingleSfixed32
}
func (m *TestAllTypes) GetSingleSfixed64() (x int64) {
	if m == nil {
		return x
	}
	return m.SingleSfixed64
}
func (m *TestAllTypes) GetSingleFloat() (x float32) {
	if m == nil {
		return x
	}
	return m.SingleFloat
}
func (m *TestAllTypes) GetSingleDouble() (x float64) {
	if m == nil {
		return x
	}
	return m.SingleDouble
}
func (m *TestAllTypes) GetSingleBool() (x bool) {
	if m == nil {
		return x
	}
	return m.SingleBool
}
func (m *TestAllTypes) GetSingleString() (x string) {
	if m == nil {
		return x
	}
	return m.SingleString
}
func (m *TestAllTypes) GetSingleBytes() (x []byte) {
	if m == nil {
		return x
	}
	return m.SingleBytes
}
func (m *TestAllTypes) GetSingleImportedMessage() (x *multitest2.Multi1) {
	if m == nil {
		return x
	}
	return m.SingleImportedMessage
}
func (m *TestAllTypes) GetSingleNestedMessage() (x *TestAllTypes_NestedMessage) {
	if m == nil {
		return x
	}
	return m.SingleNestedMessage
}
func (m *TestAllTypes) GetSingleForeignMessage() (x *ForeignMessage) {
	if m == nil {
		return x
	}
	return m.SingleForeignMessage
}
func (m *TestAllTypes) GetSingleNestedEnum() (x TestAllTypes_NestedEnum) {
	if m == nil {
		return x
	}
	return m.SingleNestedEnum
}
func (m *TestAllTypes) GetSingleForeignEnum() (x ForeignEnum) {
	if m == nil {
		return x
	}
	return m.SingleForeignEnum
}
func (m *TestAllTypes) GetRepeatedInt32() (x []int32) {
	if m == nil {
		return x
	}
	return m.RepeatedInt32
}
func (m *TestAllTypes) GetRepeatedInt64() (x []int64) {
	if m == nil {
		return x
	}
	return m.RepeatedInt64
}
func (m *TestAllTypes) GetRepeatedUint32() (x []uint32) {
	if m == nil {
		return x
	}
	return m.RepeatedUint32
}
func (m *TestAllTypes) GetRepeatedUint64() (x []uint64) {
	if m == nil {
		return x
	}
	return m.RepeatedUint64
}
func (m *TestAllTypes) GetRepeatedSint32() (x []int32) {
	if m == nil {
		return x
	}
	return m.RepeatedSint32
}
func (m *TestAllTypes) GetRepeatedSint64() (x []int64) {
	if m == nil {
		return x
	}
	return m.RepeatedSint64
}
func (m *TestAllTypes) GetRepeatedFixed32() (x []uint32) {
	if m == nil {
		return x
	}
	return m.RepeatedFixed32
}
func (m *TestAllTypes) GetRepeatedFixed64() (x []uint64) {
	if m == nil {
		return x
	}
	return m.RepeatedFixed64
}
func (m *TestAllTypes) GetRepeatedSfixed32() (x []int32) {
	if m == nil {
		return x
	}
	return m.RepeatedSfixed32
}
func (m *TestAllTypes) GetRepeatedSfixed64() (x []int64) {
	if m == nil {
		return x
	}
	return m.RepeatedSfixed64
}
func (m *TestAllTypes) GetRepeatedFloat() (x []float32) {
	if m == nil {
		return x
	}
	return m.RepeatedFloat
}
func (m *TestAllTypes) GetRepeatedDouble() (x []float64) {
	if m == nil {
		return x
	}
	return m.RepeatedDouble
}
func (m *TestAllTypes) GetRepeatedBool() (x []bool) {
	if m == nil {
		return x
	}
	return m.RepeatedBool
}
func (m *TestAllTypes) GetRepeatedString() (x []string) {
	if m == nil {
		return x
	}
	return m.RepeatedString
}
func (m *TestAllTypes) GetRepeatedBytes() (x [][]byte) {
	if m == nil {
		return x
	}
	return m.RepeatedBytes
}
func (m *TestAllTypes) GetRepeatedImportedMessage() (x []*multitest2.Multi1) {
	if m == nil {
		return x
	}
	return m.RepeatedImportedMessage
}
func (m *TestAllTypes) GetRepeatedNestedMessage() (x []*TestAllTypes_NestedMessage) {
	if m == nil {
		return x
	}
	return m.RepeatedNestedMessage
}
func (m *TestAllTypes) GetRepeatedForeignMessage() (x []*ForeignMessage) {
	if m == nil {
		return x
	}
	return m.RepeatedForeignMessage
}
func (m *TestAllTypes) GetRepeatedNestedEnum() (x []TestAllTypes_NestedEnum) {
	if m == nil {
		return x
	}
	return m.RepeatedNestedEnum
}
func (m *TestAllTypes) GetRepeatedForeignEnum() (x []ForeignEnum) {
	if m == nil {
		return x
	}
	return m.RepeatedForeignEnum
}
func (m *TestAllTypes) GetOneofUint32() (x uint32) {
	if v, ok := m.GetOneofField().(*TestAllTypes_OneofUint32); ok {
		return v.OneofUint32
	}
	return x
}
func (m *TestAllTypes) GetOneofNestedMessage() (x *TestAllTypes_NestedMessage) {
	if v, ok := m.GetOneofField().(*TestAllTypes_OneofNestedMessage); ok {
		return v.OneofNestedMessage
	}
	return x
}
func (m *TestAllTypes) GetOneofString() (x string) {
	if v, ok := m.GetOneofField().(*TestAllTypes_OneofString); ok {
		return v.OneofString
	}
	return x
}
func (m *TestAllTypes) GetOneofBytes() (x []byte) {
	if v, ok := m.GetOneofField().(*TestAllTypes_OneofBytes); ok {
		return v.OneofBytes
	}
	return x
}
func (m *TestAllTypes) GetOneofImportedMessage() (x *multitest2.Multi1) {
	if v, ok := m.GetOneofField().(*TestAllTypes_OneofImportedMessage); ok {
		return v.OneofImportedMessage
	}
	return x
}
func (m *TestAllTypes) MarshalToWriter(writer jspb.Writer) {
	if m == nil {
		return
	}
	switch t := m.OneofField.(type) {
	case *TestAllTypes_OneofUint32:
		if t.OneofUint32 != 0 {
			writer.WriteUint32(111, t.OneofUint32)
		}
	case *TestAllTypes_OneofNestedMessage:
		if t.OneofNestedMessage != nil {
			writer.WriteMessage(112, func() {
				t.OneofNestedMessage.MarshalToWriter(writer)
			})
		}
	case *TestAllTypes_OneofString:
		if len(t.OneofString) > 0 {
			writer.WriteString(113, t.OneofString)
		}
	case *TestAllTypes_OneofBytes:
		if len(t.OneofBytes) > 0 {
			writer.WriteBytes(114, t.OneofBytes)
		}
	case *TestAllTypes_OneofImportedMessage:
		if t.OneofImportedMessage != nil {
			writer.WriteMessage(115, func() {
				t.OneofImportedMessage.MarshalToWriter(writer)
			})
		}
	}
	if m.SingleInt32 != 0 {
		writer.WriteInt32(1, m.SingleInt32)
	}
	if m.SingleInt64 != 0 {
		writer.WriteInt64(2, m.SingleInt64)
	}
	if m.SingleUint32 != 0 {
		writer.WriteUint32(3, m.SingleUint32)
	}
	if m.SingleUint64 != 0 {
		writer.WriteUint64(4, m.SingleUint64)
	}
	if m.SingleSint32 != 0 {
		writer.WriteSint32(5, m.SingleSint32)
	}
	if m.SingleSint64 != 0 {
		writer.WriteSint64(6, m.SingleSint64)
	}
	if m.SingleFixed32 != 0 {
		writer.WriteFixed32(7, m.SingleFixed32)
	}
	if m.SingleFixed64 != 0 {
		writer.WriteFixed64(8, m.SingleFixed64)
	}
	if m.SingleSfixed32 != 0 {
		writer.WriteSfixed32(9, m.SingleSfixed32)
	}
	if m.SingleSfixed64 != 0 {
		writer.WriteSfixed64(10, m.SingleSfixed64)
	}
	if m.SingleFloat != 0 {
		writer.WriteFloat32(11, m.SingleFloat)
	}
	if m.SingleDouble != 0 {
		writer.WriteFloat64(12, m.SingleDouble)
	}
	if m.SingleBool {
		writer.WriteBool(13, m.SingleBool)
	}
	if len(m.SingleString) > 0 {
		writer.WriteString(14, m.SingleString)
	}
	if len(m.SingleBytes) > 0 {
		writer.WriteBytes(15, m.SingleBytes)
	}
	if m.SingleImportedMessage != nil {
		writer.WriteMessage(16, func() {
			m.SingleImportedMessage.MarshalToWriter(writer)
		})
	}
	if m.SingleNestedMessage != nil {
		writer.WriteMessage(18, func() {
			m.SingleNestedMessage.MarshalToWriter(writer)
		})
	}
	if m.SingleForeignMessage != nil {
		writer.WriteMessage(19, func() {
			m.SingleForeignMessage.MarshalToWriter(writer)
		})
	}
	if int(m.SingleNestedEnum) != 0 {
		writer.WriteEnum(21, int(m.SingleNestedEnum))
	}
	if int(m.SingleForeignEnum) != 0 {
		writer.WriteEnum(22, int(m.SingleForeignEnum))
	}
	if len(m.RepeatedInt32) > 0 {
		writer.WriteInt32Slice(31, m.RepeatedInt32)
	}
	if len(m.RepeatedInt64) > 0 {
		writer.WriteInt64Slice(32, m.RepeatedInt64)
	}
	if len(m.RepeatedUint32) > 0 {
		writer.WriteUint32Slice(33, m.RepeatedUint32)
	}
	if len(m.RepeatedUint64) > 0 {
		writer.WriteUint64Slice(34, m.RepeatedUint64)
	}
	if len(m.RepeatedSint32) > 0 {
		writer.WriteSint32Slice(35, m.RepeatedSint32)
	}
	if len(m.RepeatedSint64) > 0 {
		writer.WriteSint64Slice(36, m.RepeatedSint64)
	}
	if len(m.RepeatedFixed32) > 0 {
		writer.WriteFixed32Slice(37, m.RepeatedFixed32)
	}
	if len(m.RepeatedFixed64) > 0 {
		writer.WriteFixed64Slice(38, m.RepeatedFixed64)
	}
	if len(m.RepeatedSfixed32) > 0 {
		writer.WriteSfixed32Slice(39, m.RepeatedSfixed32)
	}
	if len(m.RepeatedSfixed64) > 0 {
		writer.WriteSfixed64Slice(40, m.RepeatedSfixed64)
	}
	if len(m.RepeatedFloat) > 0 {
		writer.WriteFloat32Slice(41, m.RepeatedFloat)
	}
	if len(m.RepeatedDouble) > 0 {
		writer.WriteFloat64Slice(42, m.RepeatedDouble)
	}
	if len(m.RepeatedBool) > 0 {
		writer.WriteBoolSlice(43, m.RepeatedBool)
	}
	for _, val := range m.RepeatedString {
		writer.WriteString(44, val)
	}
	for _, val := range m.RepeatedBytes {
		writer.WriteBytes(45, val)
	}
	for _, msg := range m.RepeatedImportedMessage {
		writer.WriteMessage(46, func() {
			msg.MarshalToWriter(writer)
		})
	}
	for _, msg := range m.RepeatedNestedMessage {
		writer.WriteMessage(48, func() {
			msg.MarshalToWriter(writer)
		})
	}
	for _, msg := range m.RepeatedForeignMessage {
		writer.WriteMessage(49, func() {
			msg.MarshalToWriter(writer)
		})
	}
	if len(m.RepeatedNestedEnum) > 0 {
		var ints []int
		for _, enum := range m.RepeatedNestedEnum {
			ints = append(ints, int(enum))
		}
		writer.WriteEnumSlice(51, ints)
	}
	if len(m.RepeatedForeignEnum) > 0 {
		var ints []int
		for _, enum := range m.RepeatedForeignEnum {
			ints = append(ints, int(enum))
		}
		writer.WriteEnumSlice(52, ints)
	}
	return
}
func (m *TestAllTypes) Marshal() []byte {
	writer := jspb.NewWriter()
	m.MarshalToWriter(writer)
	return writer.GetResult()
}
func (m *TestAllTypes) UnmarshalFromReader(reader jspb.Reader) *TestAllTypes {
	for reader.Next() {
		if m == nil {
			m = &TestAllTypes{}
		}
		switch reader.GetFieldNumber() {
		case 1:
			m.SingleInt32 = reader.ReadInt32()
		case 2:
			m.SingleInt64 = reader.ReadInt64()
		case 3:
			m.SingleUint32 = reader.ReadUint32()
		case 4:
			m.SingleUint64 = reader.ReadUint64()
		case 5:
			m.SingleSint32 = reader.ReadSint32()
		case 6:
			m.SingleSint64 = reader.ReadSint64()
		case 7:
			m.SingleFixed32 = reader.ReadFixed32()
		case 8:
			m.SingleFixed64 = reader.ReadFixed64()
		case 9:
			m.SingleSfixed32 = reader.ReadSfixed32()
		case 10:
			m.SingleSfixed64 = reader.ReadSfixed64()
		case 11:
			m.SingleFloat = reader.ReadFloat32()
		case 12:
			m.SingleDouble = reader.ReadFloat64()
		case 13:
			m.SingleBool = reader.ReadBool()
		case 14:
			m.SingleString = reader.ReadString()
		case 15:
			m.SingleBytes = reader.ReadBytes()
		case 16:
			reader.ReadMessage(func() {
				m.SingleImportedMessage = m.SingleImportedMessage.UnmarshalFromReader(reader)
			})
		case 18:
			reader.ReadMessage(func() {
				m.SingleNestedMessage = m.SingleNestedMessage.UnmarshalFromReader(reader)
			})
		case 19:
			reader.ReadMessage(func() {
				m.SingleForeignMessage = m.SingleForeignMessage.UnmarshalFromReader(reader)
			})
		case 21:
			m.SingleNestedEnum = TestAllTypes_NestedEnum(reader.ReadEnum())
		case 22:
			m.SingleForeignEnum = ForeignEnum(reader.ReadEnum())
		case 31:
			m.RepeatedInt32 = reader.ReadInt32Slice()
		case 32:
			m.RepeatedInt64 = reader.ReadInt64Slice()
		case 33:
			m.RepeatedUint32 = reader.ReadUint32Slice()
		case 34:
			m.RepeatedUint64 = reader.ReadUint64Slice()
		case 35:
			m.RepeatedSint32 = reader.ReadSint32Slice()
		case 36:
			m.RepeatedSint64 = reader.ReadSint64Slice()
		case 37:
			m.RepeatedFixed32 = reader.ReadFixed32Slice()
		case 38:
			m.RepeatedFixed64 = reader.ReadFixed64Slice()
		case 39:
			m.RepeatedSfixed32 = reader.ReadSfixed32Slice()
		case 40:
			m.RepeatedSfixed64 = reader.ReadSfixed64Slice()
		case 41:
			m.RepeatedFloat = reader.ReadFloat32Slice()
		case 42:
			m.RepeatedDouble = reader.ReadFloat64Slice()
		case 43:
			m.RepeatedBool = reader.ReadBoolSlice()
		case 44:
			m.RepeatedString = append(m.RepeatedString, reader.ReadString())
		case 45:
			m.RepeatedBytes = append(m.RepeatedBytes, reader.ReadBytes())
		case 46:
			reader.ReadMessage(func() {
				m.RepeatedImportedMessage = append(m.RepeatedImportedMessage, new(multitest2.Multi1).UnmarshalFromReader(reader))
			})
		case 48:
			reader.ReadMessage(func() {
				m.RepeatedNestedMessage = append(m.RepeatedNestedMessage, new(TestAllTypes_NestedMessage).UnmarshalFromReader(reader))
			})
		case 49:
			reader.ReadMessage(func() {
				m.RepeatedForeignMessage = append(m.RepeatedForeignMessage, new(ForeignMessage).UnmarshalFromReader(reader))
			})
		case 51:
			values := reader.ReadEnumSlice()
			for _, enum := range values {
				m.RepeatedNestedEnum = append(m.RepeatedNestedEnum, TestAllTypes_NestedEnum(enum))
			}
		case 52:
			values := reader.ReadEnumSlice()
			for _, enum := range values {
				m.RepeatedForeignEnum = append(m.RepeatedForeignEnum, ForeignEnum(enum))
			}
		case 111:
			m.OneofField = &TestAllTypes_OneofUint32{
				OneofUint32: reader.ReadUint32(),
			}
		case 112:
			reader.ReadMessage(func() {
				m.OneofField = &TestAllTypes_OneofNestedMessage{
					OneofNestedMessage: new(TestAllTypes_NestedMessage).UnmarshalFromReader(reader),
				}
			})
		case 113:
			m.OneofField = &TestAllTypes_OneofString{
				OneofString: reader.ReadString(),
			}
		case 114:
			m.OneofField = &TestAllTypes_OneofBytes{
				OneofBytes: reader.ReadBytes(),
			}
		case 115:
			reader.ReadMessage(func() {
				m.OneofField = &TestAllTypes_OneofImportedMessage{
					OneofImportedMessage: new(multitest2.Multi1).UnmarshalFromReader(reader),
				}
			})
		default:
			reader.SkipField()
		}
	}
	return m
}
func (m *TestAllTypes) Unmarshal(rawBytes []byte) (*TestAllTypes, error) {
	reader := jspb.NewReader(rawBytes)
	m = m.UnmarshalFromReader(reader)
	if err := reader.Err(); err != nil {
		return nil, err
	}
	return m, nil
}
type TestAllTypes_NestedMessage struct {
	B int32
}
func (m *TestAllTypes_NestedMessage) GetB() (x int32) {
	if m == nil {
		return x
	}
	return m.B
}
func (m *TestAllTypes_NestedMessage) MarshalToWriter(writer jspb.Writer) {
	if m == nil {
		return
	}
	if m.B != 0 {
		writer.WriteInt32(1, m.B)
	}
	return
}