func (m *TestAllTypes) GetRepeatedForeignMessage() (x []*ForeignMessage) {
	if m == nil {
		return x
	}
	return m.RepeatedForeignMessage
}
GetRepeatedForeignMessage gets the RepeatedForeignMessage of the TestAllTypes.
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
}