// Code generated by protoc-gen-go. DO NOT EDIT.
// source: v1.proto

/*
Package v1 is a generated protocol buffer package.

It is generated from these files:
	v1.proto

It has these top-level messages:
	Type
	FullType
	UserFn
	DynFn
	Fn
	WindowFn
	CustomCoder
	MultiEdge
	InjectPayload
	TransformPayload
*/
package v1

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package

// Kind is mostly identical to reflect.TypeKind, expect we handle certain
// types specially, such as "error".
type Type_Kind int32

const (
	Type_INVALID Type_Kind = 0
	// Primitive.
	Type_BOOL    Type_Kind = 1
	Type_INT     Type_Kind = 2
	Type_INT8    Type_Kind = 3
	Type_INT16   Type_Kind = 4
	Type_INT32   Type_Kind = 5
	Type_INT64   Type_Kind = 6
	Type_UINT    Type_Kind = 7
	Type_UINT8   Type_Kind = 8
	Type_UINT16  Type_Kind = 9
	Type_UINT32  Type_Kind = 10
	Type_UINT64  Type_Kind = 11
	Type_STRING  Type_Kind = 12
	Type_FLOAT32 Type_Kind = 13
	Type_FLOAT64 Type_Kind = 14
	// Non-primitive types.
	Type_SLICE    Type_Kind = 20
	Type_STRUCT   Type_Kind = 21
	Type_FUNC     Type_Kind = 22
	Type_CHAN     Type_Kind = 23
	Type_PTR      Type_Kind = 24
	Type_SPECIAL  Type_Kind = 25
	Type_EXTERNAL Type_Kind = 26
)

var Type_Kind_name = map[int32]string{
	0:  "INVALID",
	1:  "BOOL",
	2:  "INT",
	3:  "INT8",
	4:  "INT16",
	5:  "INT32",
	6:  "INT64",
	7:  "UINT",
	8:  "UINT8",
	9:  "UINT16",
	10: "UINT32",
	11: "UINT64",
	12: "STRING",
	13: "FLOAT32",
	14: "FLOAT64",
	20: "SLICE",
	21: "STRUCT",
	22: "FUNC",
	23: "CHAN",
	24: "PTR",
	25: "SPECIAL",
	26: "EXTERNAL",
}
var Type_Kind_value = map[string]int32{
	"INVALID":  0,
	"BOOL":     1,
	"INT":      2,
	"INT8":     3,
	"INT16":    4,
	"INT32":    5,
	"INT64":    6,
	"UINT":     7,
	"UINT8":    8,
	"UINT16":   9,
	"UINT32":   10,
	"UINT64":   11,
	"STRING":   12,
	"FLOAT32":  13,
	"FLOAT64":  14,
	"SLICE":    20,
	"STRUCT":   21,
	"FUNC":     22,
	"CHAN":     23,
	"PTR":      24,
	"SPECIAL":  25,
	"EXTERNAL": 26,
}

func (x Type_Kind) String() string {
	return proto.EnumName(Type_Kind_name, int32(x))
}
func (Type_Kind) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0, 0} }

// ChanDir matches reflect.ChanDir.
type Type_ChanDir int32

const (
	Type_RECV Type_ChanDir = 0
	Type_SEND Type_ChanDir = 1
	Type_BOTH Type_ChanDir = 2
)

var Type_ChanDir_name = map[int32]string{
	0: "RECV",
	1: "SEND",
	2: "BOTH",
}
var Type_ChanDir_value = map[string]int32{
	"RECV": 0,
	"SEND": 1,
	"BOTH": 2,
}

func (x Type_ChanDir) String() string {
	return proto.EnumName(Type_ChanDir_name, int32(x))
}
func (Type_ChanDir) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0, 1} }

type Type_Special int32

const (
	Type_ILLEGAL Type_Special = 0
	// Go
	Type_ERROR   Type_Special = 1
	Type_CONTEXT Type_Special = 2
	Type_TYPE    Type_Special = 3
	// Beam
	Type_EVENTTIME     Type_Special = 10
	Type_WINDOW        Type_Special = 22
	Type_KV            Type_Special = 11
	Type_COGBK         Type_Special = 13
	Type_WINDOWEDVALUE Type_Special = 14
	Type_T             Type_Special = 15
	Type_U             Type_Special = 16
	Type_V             Type_Special = 17
	Type_W             Type_Special = 18
	Type_X             Type_Special = 19
	Type_Y             Type_Special = 20
	Type_Z             Type_Special = 21
)

var Type_Special_name = map[int32]string{
	0:  "ILLEGAL",
	1:  "ERROR",
	2:  "CONTEXT",
	3:  "TYPE",
	10: "EVENTTIME",
	22: "WINDOW",
	11: "KV",
	13: "COGBK",
	14: "WINDOWEDVALUE",
	15: "T",
	16: "U",
	17: "V",
	18: "W",
	19: "X",
	20: "Y",
	21: "Z",
}
var Type_Special_value = map[string]int32{
	"ILLEGAL":       0,
	"ERROR":         1,
	"CONTEXT":       2,
	"TYPE":          3,
	"EVENTTIME":     10,
	"WINDOW":        22,
	"KV":            11,
	"COGBK":         13,
	"WINDOWEDVALUE": 14,
	"T":             15,
	"U":             16,
	"V":             17,
	"W":             18,
	"X":             19,
	"Y":             20,
	"Z":             21,
}

func (x Type_Special) String() string {
	return proto.EnumName(Type_Special_name, int32(x))
}
func (Type_Special) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0, 2} }

type MultiEdge_Inbound_InputKind int32

const (
	MultiEdge_Inbound_INVALID   MultiEdge_Inbound_InputKind = 0
	MultiEdge_Inbound_MAIN      MultiEdge_Inbound_InputKind = 1
	MultiEdge_Inbound_SINGLETON MultiEdge_Inbound_InputKind = 2
	MultiEdge_Inbound_SLICE     MultiEdge_Inbound_InputKind = 3
	MultiEdge_Inbound_MAP       MultiEdge_Inbound_InputKind = 4
	MultiEdge_Inbound_MULTIMAP  MultiEdge_Inbound_InputKind = 5
	MultiEdge_Inbound_ITER      MultiEdge_Inbound_InputKind = 6
	MultiEdge_Inbound_REITER    MultiEdge_Inbound_InputKind = 7
)

var MultiEdge_Inbound_InputKind_name = map[int32]string{
	0: "INVALID",
	1: "MAIN",
	2: "SINGLETON",
	3: "SLICE",
	4: "MAP",
	5: "MULTIMAP",
	6: "ITER",
	7: "REITER",
}
var MultiEdge_Inbound_InputKind_value = map[string]int32{
	"INVALID":   0,
	"MAIN":      1,
	"SINGLETON": 2,
	"SLICE":     3,
	"MAP":       4,
	"MULTIMAP":  5,
	"ITER":      6,
	"REITER":    7,
}

func (x MultiEdge_Inbound_InputKind) String() string {
	return proto.EnumName(MultiEdge_Inbound_InputKind_name, int32(x))
}
func (MultiEdge_Inbound_InputKind) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor0, []int{7, 0, 0}
}

// Type represents a serializable reflect.Type.
type Type struct {
	// (Required) Type kind.
	Kind Type_Kind `protobuf:"varint,1,opt,name=kind,enum=v1.Type_Kind" json:"kind,omitempty"`
	// (Optional) Element type (if SLICE, PTR or CHAN)
	Element *Type `protobuf:"bytes,2,opt,name=element" json:"element,omitempty"`
	// (Optional) Fields (if STRUCT).
	Fields []*Type_StructField `protobuf:"bytes,3,rep,name=fields" json:"fields,omitempty"`
	// (Optional) Parameter types (if FUNC).
	ParameterTypes []*Type `protobuf:"bytes,4,rep,name=parameter_types,json=parameterTypes" json:"parameter_types,omitempty"`
	// (Optional) Return types (if FUNC).
	ReturnTypes []*Type `protobuf:"bytes,5,rep,name=return_types,json=returnTypes" json:"return_types,omitempty"`
	// (Optional) Is variadic (if FUNC).
	IsVariadic bool `protobuf:"varint,6,opt,name=is_variadic,json=isVariadic" json:"is_variadic,omitempty"`
	// (Optional) Channel direction (if CHAN).
	ChanDir Type_ChanDir `protobuf:"varint,7,opt,name=chan_dir,json=chanDir,enum=v1.Type_ChanDir" json:"chan_dir,omitempty"`
	// (Optional) Special type (if SPECIAL)
	Special Type_Special `protobuf:"varint,8,opt,name=special,enum=v1.Type_Special" json:"special,omitempty"`
	// (Optional) Key for external types.
	// External types are types that are not directly serialized using
	// the types above, but rather indirectly serialized.  The wire format
	// holds a lookup key into a registry to reify the types in a worker from a
	// registry. The main usage of external serialization is to preserve
	// methods attached to types.
	ExternalKey string `protobuf:"bytes,9,opt,name=external_key,json=externalKey" json:"external_key,omitempty"`
}

func (m *Type) Reset()                    { *m = Type{} }
func (m *Type) String() string            { return proto.CompactTextString(m) }
func (*Type) ProtoMessage()               {}
func (*Type) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }

func (m *Type) GetKind() Type_Kind {
	if m != nil {
		return m.Kind
	}
	return Type_INVALID
}

func (m *Type) GetElement() *Type {
	if m != nil {
		return m.Element
	}
	return nil
}

func (m *Type) GetFields() []*Type_StructField {
	if m != nil {
		return m.Fields
	}
	return nil
}

func (m *Type) GetParameterTypes() []*Type {
	if m != nil {
		return m.ParameterTypes
	}
	return nil
}

func (m *Type) GetReturnTypes() []*Type {
	if m != nil {
		return m.ReturnTypes
	}
	return nil
}

func (m *Type) GetIsVariadic() bool {
	if m != nil {
		return m.IsVariadic
	}
	return false
}

func (m *Type) GetChanDir() Type_ChanDir {
	if m != nil {
		return m.ChanDir
	}
	return Type_RECV
}

func (m *Type) GetSpecial() Type_Special {
	if m != nil {
		return m.Special
	}
	return Type_ILLEGAL
}

func (m *Type) GetExternalKey() string {
	if m != nil {
		return m.ExternalKey
	}
	return ""
}

// StructField matches reflect.StructField.
type Type_StructField struct {
	Name      string  `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
	PkgPath   string  `protobuf:"bytes,2,opt,name=pkg_path,json=pkgPath" json:"pkg_path,omitempty"`
	Type      *Type   `protobuf:"bytes,3,opt,name=type" json:"type,omitempty"`
	Tag       string  `protobuf:"bytes,4,opt,name=tag" json:"tag,omitempty"`
	Offset    int64   `protobuf:"varint,5,opt,name=offset" json:"offset,omitempty"`
	Index     []int32 `protobuf:"varint,6,rep,packed,name=index" json:"index,omitempty"`
	Anonymous bool    `protobuf:"varint,7,opt,name=anonymous" json:"anonymous,omitempty"`
}

func (m *Type_StructField) Reset()                    { *m = Type_StructField{} }
func (m *Type_StructField) String() string            { return proto.CompactTextString(m) }
func (*Type_StructField) ProtoMessage()               {}
func (*Type_StructField) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0, 0} }

func (m *Type_StructField) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *Type_StructField) GetPkgPath() string {
	if m != nil {
		return m.PkgPath
	}
	return ""
}

func (m *Type_StructField) GetType() *Type {
	if m != nil {
		return m.Type
	}
	return nil
}

func (m *Type_StructField) GetTag() string {
	if m != nil {
		return m.Tag
	}
	return ""
}

func (m *Type_StructField) GetOffset() int64 {
	if m != nil {
		return m.Offset
	}
	return 0
}

func (m *Type_StructField) GetIndex() []int32 {
	if m != nil {
		return m.Index
	}
	return nil
}

func (m *Type_StructField) GetAnonymous() bool {
	if m != nil {
		return m.Anonymous
	}
	return false
}

// FullType represents a serialized typex.FullType
type FullType struct {
	Type       *Type       `protobuf:"bytes,1,opt,name=type" json:"type,omitempty"`
	Components []*FullType `protobuf:"bytes,2,rep,name=components" json:"components,omitempty"`
}

func (m *FullType) Reset()                    { *m = FullType{} }
func (m *FullType) String() string            { return proto.CompactTextString(m) }
func (*FullType) ProtoMessage()               {}
func (*FullType) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }

func (m *FullType) GetType() *Type {
	if m != nil {
		return m.Type
	}
	return nil
}

func (m *FullType) GetComponents() []*FullType {
	if m != nil {
		return m.Components
	}
	return nil
}

// UserFn represents a serialized function reference. The
// implementation is notably not serialized and must be present (and
// somehow discoverable from the symbol name) on the decoding side.
type UserFn struct {
	// (Required) Symbol name of function.
	Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
	// (Required) Function type.
	Type *Type `protobuf:"bytes,2,opt,name=type" json:"type,omitempty"`
}

func (m *UserFn) Reset()                    { *m = UserFn{} }
func (m *UserFn) String() string            { return proto.CompactTextString(m) }
func (*UserFn) ProtoMessage()               {}
func (*UserFn) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }

func (m *UserFn) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *UserFn) GetType() *Type {
	if m != nil {
		return m.Type
	}
	return nil
}

// DynFn represents a serialized function generator.
type DynFn struct {
	// (Required) Name of the generated function.
	Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
	// (Required) Type of the generated function.
	Type *Type `protobuf:"bytes,2,opt,name=type" json:"type,omitempty"`
	// (Required) Input to generator.
	Data []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
	// (Required) Symbol name of generator (of type []byte ->
	// []reflect.Value -> []reflect.Value).
	Gen string `protobuf:"bytes,4,opt,name=gen" json:"gen,omitempty"`
}

func (m *DynFn) Reset()                    { *m = DynFn{} }
func (m *DynFn) String() string            { return proto.CompactTextString(m) }
func (*DynFn) ProtoMessage()               {}
func (*DynFn) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }

func (m *DynFn) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *DynFn) GetType() *Type {
	if m != nil {
		return m.Type
	}
	return nil
}

func (m *DynFn) GetData() []byte {
	if m != nil {
		return m.Data
	}
	return nil
}

func (m *DynFn) GetGen() string {
	if m != nil {
		return m.Gen
	}
	return ""
}

// Fn represents a serialized function reference or struct.
type Fn struct {
	// (Optional) Function reference.
	Fn *UserFn `protobuf:"bytes,1,opt,name=fn" json:"fn,omitempty"`
	// (Optional) Struct type.
	Type *Type `protobuf:"bytes,2,opt,name=type" json:"type,omitempty"`
	// (Optional) JSON-serialized value, if struct.
	Opt string `protobuf:"bytes,3,opt,name=opt" json:"opt,omitempty"`
	// (Optional) Function generator, if dynamic function.
	Dynfn *DynFn `protobuf:"bytes,4,opt,name=dynfn" json:"dynfn,omitempty"`
}

func (m *Fn) Reset()                    { *m = Fn{} }
func (m *Fn) String() string            { return proto.CompactTextString(m) }
func (*Fn) ProtoMessage()               {}
func (*Fn) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }

func (m *Fn) GetFn() *UserFn {
	if m != nil {
		return m.Fn
	}
	return nil
}

func (m *Fn) GetType() *Type {
	if m != nil {
		return m.Type
	}
	return nil
}

func (m *Fn) GetOpt() string {
	if m != nil {
		return m.Opt
	}
	return ""
}

func (m *Fn) GetDynfn() *DynFn {
	if m != nil {
		return m.Dynfn
	}
	return nil
}

// WindowFn represents a window fn.
type WindowFn struct {
	Kind     string `protobuf:"bytes,1,opt,name=kind" json:"kind,omitempty"`
	SizeMs   int64  `protobuf:"varint,2,opt,name=size_ms,json=sizeMs" json:"size_ms,omitempty"`
	PeriodMs int64  `protobuf:"varint,3,opt,name=period_ms,json=periodMs" json:"period_ms,omitempty"`
	GapMs    int64  `protobuf:"varint,4,opt,name=gap_ms,json=gapMs" json:"gap_ms,omitempty"`
}

func (m *WindowFn) Reset()                    { *m = WindowFn{} }
func (m *WindowFn) String() string            { return proto.CompactTextString(m) }
func (*WindowFn) ProtoMessage()               {}
func (*WindowFn) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }

func (m *WindowFn) GetKind() string {
	if m != nil {
		return m.Kind
	}
	return ""
}

func (m *WindowFn) GetSizeMs() int64 {
	if m != nil {
		return m.SizeMs
	}
	return 0
}

func (m *WindowFn) GetPeriodMs() int64 {
	if m != nil {
		return m.PeriodMs
	}
	return 0
}

func (m *WindowFn) GetGapMs() int64 {
	if m != nil {
		return m.GapMs
	}
	return 0
}

// CustomCoder
type CustomCoder struct {
	// (Required) Name of the coder. For informational purposes only.
	Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
	// (Required) Concrete type being coded.
	Type *Type `protobuf:"bytes,2,opt,name=type" json:"type,omitempty"`
	// (Required) Encoding function.
	Enc *UserFn `protobuf:"bytes,3,opt,name=enc" json:"enc,omitempty"`
	// (Required) Decoding function.
	Dec *UserFn `protobuf:"bytes,4,opt,name=dec" json:"dec,omitempty"`
}

func (m *CustomCoder) Reset()                    { *m = CustomCoder{} }
func (m *CustomCoder) String() string            { return proto.CompactTextString(m) }
func (*CustomCoder) ProtoMessage()               {}
func (*CustomCoder) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }

func (m *CustomCoder) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *CustomCoder) GetType() *Type {
	if m != nil {
		return m.Type
	}
	return nil
}

func (m *CustomCoder) GetEnc() *UserFn {
	if m != nil {
		return m.Enc
	}
	return nil
}

func (m *CustomCoder) GetDec() *UserFn {
	if m != nil {
		return m.Dec
	}
	return nil
}

// MultiEdge represents a partly-serialized MultiEdge. It does not include
// node information, because runners manipulate the graph structure.
type MultiEdge struct {
	Fn       *Fn                   `protobuf:"bytes,1,opt,name=fn" json:"fn,omitempty"`
	Opcode   string                `protobuf:"bytes,4,opt,name=opcode" json:"opcode,omitempty"`
	WindowFn *WindowFn             `protobuf:"bytes,5,opt,name=window_fn,json=windowFn" json:"window_fn,omitempty"`
	Inbound  []*MultiEdge_Inbound  `protobuf:"bytes,2,rep,name=inbound" json:"inbound,omitempty"`
	Outbound []*MultiEdge_Outbound `protobuf:"bytes,3,rep,name=outbound" json:"outbound,omitempty"`
}

func (m *MultiEdge) Reset()                    { *m = MultiEdge{} }
func (m *MultiEdge) String() string            { return proto.CompactTextString(m) }
func (*MultiEdge) ProtoMessage()               {}
func (*MultiEdge) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }

func (m *MultiEdge) GetFn() *Fn {
	if m != nil {
		return m.Fn
	}
	return nil
}

func (m *MultiEdge) GetOpcode() string {
	if m != nil {
		return m.Opcode
	}
	return ""
}

func (m *MultiEdge) GetWindowFn() *WindowFn {
	if m != nil {
		return m.WindowFn
	}
	return nil
}

func (m *MultiEdge) GetInbound() []*MultiEdge_Inbound {
	if m != nil {
		return m.Inbound
	}
	return nil
}

func (m *MultiEdge) GetOutbound() []*MultiEdge_Outbound {
	if m != nil {
		return m.Outbound
	}
	return nil
}

type MultiEdge_Inbound struct {
	Kind MultiEdge_Inbound_InputKind `protobuf:"varint,1,opt,name=kind,enum=v1.MultiEdge_Inbound_InputKind" json:"kind,omitempty"`
	Type *FullType                   `protobuf:"bytes,2,opt,name=type" json:"type,omitempty"`
}

func (m *MultiEdge_Inbound) Reset()                    { *m = MultiEdge_Inbound{} }
func (m *MultiEdge_Inbound) String() string            { return proto.CompactTextString(m) }
func (*MultiEdge_Inbound) ProtoMessage()               {}
func (*MultiEdge_Inbound) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7, 0} }

func (m *MultiEdge_Inbound) GetKind() MultiEdge_Inbound_InputKind {
	if m != nil {
		return m.Kind
	}
	return MultiEdge_Inbound_INVALID
}

func (m *MultiEdge_Inbound) GetType() *FullType {
	if m != nil {
		return m.Type
	}
	return nil
}

type MultiEdge_Outbound struct {
	Type *FullType `protobuf:"bytes,1,opt,name=type" json:"type,omitempty"`
}

func (m *MultiEdge_Outbound) Reset()                    { *m = MultiEdge_Outbound{} }
func (m *MultiEdge_Outbound) String() string            { return proto.CompactTextString(m) }
func (*MultiEdge_Outbound) ProtoMessage()               {}
func (*MultiEdge_Outbound) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7, 1} }

func (m *MultiEdge_Outbound) GetType() *FullType {
	if m != nil {
		return m.Type
	}
	return nil
}

// InjectPayload is the payload for the built-in Inject function.
type InjectPayload struct {
	N int32 `protobuf:"varint,1,opt,name=n" json:"n,omitempty"`
}

func (m *InjectPayload) Reset()                    { *m = InjectPayload{} }
func (m *InjectPayload) String() string            { return proto.CompactTextString(m) }
func (*InjectPayload) ProtoMessage()               {}
func (*InjectPayload) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} }

func (m *InjectPayload) GetN() int32 {
	if m != nil {
		return m.N
	}
	return 0
}

// TransformPayload represents the full payload for transforms, both
// user defined and built-in.
type TransformPayload struct {
	// urn is included here. It is also present in the model pipeline, but
	// not when submitting through Dataflow yet.
	Urn    string         `protobuf:"bytes,1,opt,name=urn" json:"urn,omitempty"`
	Edge   *MultiEdge     `protobuf:"bytes,2,opt,name=edge" json:"edge,omitempty"`
	Inject *InjectPayload `protobuf:"bytes,3,opt,name=inject" json:"inject,omitempty"`
}

func (m *TransformPayload) Reset()                    { *m = TransformPayload{} }
func (m *TransformPayload) String() string            { return proto.CompactTextString(m) }
func (*TransformPayload) ProtoMessage()               {}
func (*TransformPayload) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9} }

func (m *TransformPayload) GetUrn() string {
	if m != nil {
		return m.Urn
	}
	return ""
}

func (m *TransformPayload) GetEdge() *MultiEdge {
	if m != nil {
		return m.Edge
	}
	return nil
}

func (m *TransformPayload) GetInject() *InjectPayload {
	if m != nil {
		return m.Inject
	}
	return nil
}

func init() {
	proto.RegisterType((*Type)(nil), "v1.Type")
	proto.RegisterType((*Type_StructField)(nil), "v1.Type.StructField")
	proto.RegisterType((*FullType)(nil), "v1.FullType")
	proto.RegisterType((*UserFn)(nil), "v1.UserFn")
	proto.RegisterType((*DynFn)(nil), "v1.DynFn")
	proto.RegisterType((*Fn)(nil), "v1.Fn")
	proto.RegisterType((*WindowFn)(nil), "v1.WindowFn")
	proto.RegisterType((*CustomCoder)(nil), "v1.CustomCoder")
	proto.RegisterType((*MultiEdge)(nil), "v1.MultiEdge")
	proto.RegisterType((*MultiEdge_Inbound)(nil), "v1.MultiEdge.Inbound")
	proto.RegisterType((*MultiEdge_Outbound)(nil), "v1.MultiEdge.Outbound")
	proto.RegisterType((*InjectPayload)(nil), "v1.InjectPayload")
	proto.RegisterType((*TransformPayload)(nil), "v1.TransformPayload")
	proto.RegisterEnum("v1.Type_Kind", Type_Kind_name, Type_Kind_value)
	proto.RegisterEnum("v1.Type_ChanDir", Type_ChanDir_name, Type_ChanDir_value)
	proto.RegisterEnum("v1.Type_Special", Type_Special_name, Type_Special_value)
	proto.RegisterEnum("v1.MultiEdge_Inbound_InputKind", MultiEdge_Inbound_InputKind_name, MultiEdge_Inbound_InputKind_value)
}

func init() { proto.RegisterFile("v1.proto", fileDescriptor0) }

var fileDescriptor0 = []byte{
	// 1180 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x56, 0xdf, 0x72, 0xda, 0xc6,
	0x17, 0x8e, 0x10, 0xe8, 0xcf, 0x01, 0x9c, 0xcd, 0xfe, 0x6c, 0x47, 0xf1, 0x2f, 0x9d, 0x10, 0xdd,
	0x94, 0x34, 0x19, 0x77, 0x8c, 0x33, 0x9e, 0x4e, 0xef, 0x08, 0x96, 0x1d, 0x8d, 0x41, 0x30, 0x8b,
	0xc0, 0x49, 0x6f, 0x18, 0x05, 0x2d, 0x58, 0x35, 0xac, 0x54, 0x49, 0x38, 0xa1, 0x7d, 0x84, 0xbe,
	0x49, 0x9f, 0xa0, 0x6f, 0xd0, 0x8b, 0x3e, 0x54, 0x3b, 0xbb, 0x92, 0x88, 0x71, 0xdd, 0xe9, 0x4c,
	0xae, 0xf6, 0xec, 0xf9, 0xbe, 0xb3, 0x67, 0xf7, 0xdb, 0xb3, 0x47, 0x02, 0xed, 0xe6, 0xe8, 0x30,
	0x8a, 0xc3, 0x34, 0xc4, 0xa5, 0x9b, 0x23, 0xf3, 0x57, 0x0d, 0xca, 0xee, 0x3a, 0xa2, 0xf8, 0x39,
	0x94, 0xaf, 0x03, 0xe6, 0x1b, 0x52, 0x43, 0x6a, 0xee, 0xb4, 0xea, 0x87, 0x37, 0x47, 0x87, 0xdc,
	0x7f, 0x78, 0x11, 0x30, 0x9f, 0x08, 0x08, 0x9b, 0xa0, 0xd2, 0x05, 0x5d, 0x52, 0x96, 0x1a, 0xa5,
	0x86, 0xd4, 0xac, 0xb6, 0xb4, 0x82, 0x45, 0x0a, 0x00, 0xbf, 0x02, 0x65, 0x16, 0xd0, 0x85, 0x9f,
	0x18, 0x72, 0x43, 0x6e, 0x56, 0x5b, 0xbb, 0x9b, 0x85, 0x86, 0x69, 0xbc, 0x9a, 0xa6, 0x67, 0x1c,
	0x24, 0x39, 0x07, 0x1f, 0xc1, 0xc3, 0xc8, 0x8b, 0xbd, 0x25, 0x4d, 0x69, 0x3c, 0x49, 0xd7, 0x11,
	0x4d, 0x8c, 0xb2, 0x08, 0xfb, 0xbc, 0xf2, 0xce, 0x86, 0xc0, 0xa7, 0x09, 0x7e, 0x09, 0xb5, 0x98,
	0xa6, 0xab, 0x98, 0xe5, 0xfc, 0xca, 0x1d, 0x7e, 0x35, 0x43, 0x33, 0xf2, 0x33, 0xa8, 0x06, 0xc9,
	0xe4, 0xc6, 0x8b, 0x03, 0xcf, 0x0f, 0xa6, 0x86, 0xd2, 0x90, 0x9a, 0x1a, 0x81, 0x20, 0x19, 0xe7,
	0x1e, 0xfc, 0x12, 0xb4, 0xe9, 0x95, 0xc7, 0x26, 0x7e, 0x10, 0x1b, 0xaa, 0x38, 0x39, 0xda, 0x6c,
	0xb8, 0x73, 0xe5, 0xb1, 0xd3, 0x20, 0x26, 0xea, 0x34, 0x33, 0xf0, 0x37, 0xa0, 0x26, 0x11, 0x9d,
	0x06, 0xde, 0xc2, 0xd0, 0xee, 0x70, 0x87, 0x99, 0x9f, 0x14, 0x04, 0xfc, 0x1c, 0x6a, 0xf4, 0x53,
	0x4a, 0x63, 0xe6, 0x2d, 0x26, 0xd7, 0x74, 0x6d, 0xe8, 0x0d, 0xa9, 0xa9, 0x93, 0x6a, 0xe1, 0xbb,
	0xa0, 0xeb, 0x83, 0xdf, 0x25, 0xa8, 0xde, 0x12, 0x05, 0x63, 0x28, 0x33, 0x6f, 0x49, 0xc5, 0x0d,
	0xe8, 0x44, 0xd8, 0xf8, 0x09, 0x68, 0xd1, 0xf5, 0x7c, 0x12, 0x79, 0xe9, 0x95, 0xd0, 0x5c, 0x27,
	0x6a, 0x74, 0x3d, 0x1f, 0x78, 0xe9, 0x15, 0x7e, 0x0a, 0x65, 0xae, 0x80, 0x21, 0xdf, 0xb9, 0x0a,
	0xe1, 0xc5, 0x08, 0xe4, 0xd4, 0x9b, 0x1b, 0x65, 0x11, 0xc3, 0x4d, 0xbc, 0x0f, 0x4a, 0x38, 0x9b,
	0x25, 0x34, 0x35, 0x2a, 0x0d, 0xa9, 0x29, 0x93, 0x7c, 0x86, 0x77, 0xa1, 0x12, 0x30, 0x9f, 0x7e,
	0x32, 0x94, 0x86, 0xdc, 0xac, 0x90, 0x6c, 0x82, 0x9f, 0x82, 0xee, 0xb1, 0x90, 0xad, 0x97, 0xe1,
	0x2a, 0x11, 0xca, 0x68, 0xe4, 0xb3, 0xc3, 0xfc, 0x4b, 0x82, 0x32, 0x2f, 0x0c, 0x5c, 0x05, 0xd5,
	0x76, 0xc6, 0xed, 0xae, 0x7d, 0x8a, 0x1e, 0x60, 0x0d, 0xca, 0x6f, 0xfa, 0xfd, 0x2e, 0x92, 0xb0,
	0x0a, 0xb2, 0xed, 0xb8, 0xa8, 0xc4, 0x5d, 0xb6, 0xe3, 0x7e, 0x87, 0x64, 0xac, 0x43, 0xc5, 0x76,
	0xdc, 0xa3, 0x13, 0x54, 0xce, 0xcd, 0xe3, 0x16, 0xaa, 0xe4, 0xe6, 0xc9, 0x6b, 0xa4, 0x70, 0xea,
	0x88, 0x07, 0xa9, 0xdc, 0x39, 0x12, 0x51, 0x1a, 0x06, 0x50, 0x46, 0x59, 0x98, 0x5e, 0xd8, 0xc7,
	0x2d, 0x04, 0x85, 0x7d, 0xf2, 0x1a, 0x55, 0xb9, 0x3d, 0x74, 0x89, 0xed, 0x9c, 0xa3, 0x1a, 0xdf,
	0xcf, 0x59, 0xb7, 0xdf, 0xe6, 0xa4, 0xfa, 0x66, 0x72, 0xf2, 0x1a, 0xed, 0xf0, 0x45, 0x87, 0x5d,
	0xbb, 0x63, 0xa1, 0xdd, 0x3c, 0x60, 0xd4, 0x71, 0xd1, 0x1e, 0xcf, 0x7a, 0x36, 0x72, 0x3a, 0x68,
	0x9f, 0x5b, 0x9d, 0xb7, 0x6d, 0x07, 0x3d, 0xe6, 0xbb, 0x1f, 0xb8, 0x04, 0x19, 0x7c, 0x81, 0xe1,
	0xc0, 0xea, 0xd8, 0xed, 0x2e, 0x7a, 0x82, 0x6b, 0xa0, 0x59, 0xef, 0x5c, 0x8b, 0x38, 0xed, 0x2e,
	0x3a, 0x30, 0xbf, 0x06, 0x35, 0xaf, 0x0f, 0x1e, 0x48, 0xac, 0xce, 0x38, 0x13, 0x60, 0x68, 0x39,
	0xa7, 0x48, 0xca, 0xa4, 0x70, 0xdf, 0xa2, 0x92, 0xf9, 0x9b, 0x04, 0x6a, 0x5e, 0x1d, 0x42, 0xad,
	0x6e, 0xd7, 0x3a, 0x6f, 0x77, 0xd1, 0x03, 0xbe, 0x21, 0x8b, 0x90, 0x3e, 0x41, 0x12, 0xf7, 0x77,
	0xfa, 0x8e, 0x6b, 0xbd, 0xcb, 0x25, 0x73, 0xdf, 0x0f, 0x2c, 0x24, 0xe3, 0x3a, 0xe8, 0xd6, 0xd8,
	0x72, 0x5c, 0xd7, 0xee, 0x59, 0xd9, 0x99, 0x2f, 0x6d, 0xe7, 0xb4, 0x7f, 0x89, 0xf6, 0xb1, 0x02,
	0xa5, 0x8b, 0x31, 0xaa, 0xf2, 0x45, 0x3a, 0xfd, 0xf3, 0x37, 0x17, 0xa8, 0x8e, 0x1f, 0x41, 0x3d,
	0x83, 0xad, 0xd3, 0x71, 0xbb, 0x3b, 0xb2, 0xd0, 0x0e, 0xae, 0x80, 0xe4, 0xa2, 0x87, 0x7c, 0x18,
	0x21, 0xc4, 0x87, 0x31, 0x7a, 0xc4, 0x87, 0x4b, 0x84, 0xf9, 0xf0, 0x0e, 0xfd, 0x8f, 0x0f, 0xef,
	0xd1, 0x2e, 0x1f, 0x7e, 0x40, 0x7b, 0xe6, 0x18, 0xb4, 0xb3, 0xd5, 0x62, 0x21, 0x1a, 0x42, 0x51,
	0x5f, 0xd2, 0xbd, 0xf5, 0xf5, 0x0a, 0x60, 0x1a, 0x2e, 0xa3, 0x90, 0x51, 0x96, 0x26, 0x46, 0x49,
	0x3c, 0xc2, 0x1a, 0xe7, 0x14, 0xf1, 0xe4, 0x16, 0x6e, 0x7e, 0x0f, 0xca, 0x28, 0xa1, 0xf1, 0x19,
	0xbb, 0xb7, 0xc8, 0x8b, 0x4c, 0xa5, 0xfb, 0x32, 0x99, 0x13, 0xa8, 0x9c, 0xae, 0xd9, 0x97, 0x84,
	0xf2, 0x08, 0xdf, 0x4b, 0x3d, 0xf1, 0x44, 0x6a, 0x44, 0xd8, 0xfc, 0x61, 0xcc, 0x29, 0x2b, 0x1e,
	0xc6, 0x9c, 0x32, 0xf3, 0x27, 0x28, 0x9d, 0x31, 0x7c, 0x00, 0xa5, 0x19, 0xcb, 0x0f, 0x0b, 0x7c,
	0x9d, 0x6c, 0xc3, 0xa4, 0x34, 0x63, 0xff, 0x91, 0x05, 0x81, 0x1c, 0x46, 0xa9, 0x48, 0xa2, 0x13,
	0x6e, 0xe2, 0x67, 0x50, 0xf1, 0xd7, 0x6c, 0x96, 0x65, 0xa9, 0xb6, 0x74, 0x1e, 0x20, 0xce, 0x40,
	0x32, 0xbf, 0x79, 0x0d, 0xda, 0x65, 0xc0, 0xfc, 0xf0, 0x63, 0x76, 0xac, 0x4d, 0xe3, 0xd5, 0xf3,
	0x4e, 0xfb, 0x18, 0xd4, 0x24, 0xf8, 0x99, 0x4e, 0x96, 0x89, 0xc8, 0x29, 0x13, 0x85, 0x4f, 0x7b,
	0x09, 0xfe, 0x3f, 0xe8, 0x11, 0x8d, 0x83, 0xd0, 0xe7, 0x90, 0x2c, 0x20, 0x2d, 0x73, 0xf4, 0x12,
	0xbc, 0x07, 0xca, 0xdc, 0x8b, 0x38, 0x52, 0x16, 0x48, 0x65, 0xee, 0x45, 0xbd, 0xc4, 0xfc, 0x05,
	0xaa, 0x9d, 0x55, 0x92, 0x86, 0xcb, 0x4e, 0xe8, 0xd3, 0xf8, 0x0b, 0x64, 0x7c, 0x0a, 0x32, 0x65,
	0xd3, 0xbc, 0xd1, 0xdc, 0xd6, 0x86, 0xbb, 0x39, 0xea, 0xd3, 0x69, 0x7e, 0xd4, 0x2d, 0xd4, 0xa7,
	0x53, 0xf3, 0x0f, 0x19, 0xf4, 0xde, 0x6a, 0x91, 0x06, 0x96, 0x3f, 0xa7, 0x78, 0xff, 0x96, 0xc8,
	0x8a, 0xa8, 0x96, 0x4c, 0x60, 0xde, 0x9b, 0xa2, 0x69, 0xe8, 0xd3, 0xfc, 0x5e, 0xf2, 0x19, 0x7e,
	0x01, 0xfa, 0x47, 0xa1, 0xd3, 0x64, 0xc6, 0x44, 0xdb, 0xca, 0x8b, 0xac, 0x10, 0x8f, 0x68, 0x1f,
	0x0b, 0x19, 0xbf, 0x05, 0x35, 0x60, 0x1f, 0xc2, 0x15, 0xf3, 0xf3, 0x6a, 0xdc, 0xe3, 0xc4, 0x4d,
	0xea, 0x43, 0x3b, 0x03, 0x49, 0xc1, 0xc2, 0x2d, 0xd0, 0xc2, 0x55, 0x9a, 0x45, 0x64, 0xdf, 0xaa,
	0xfd, 0xed, 0x88, 0x7e, 0x8e, 0x92, 0x0d, 0xef, 0xe0, 0x4f, 0x09, 0xd4, 0x7c, 0x21, 0x7c, 0xbc,
	0xf5, 0xc1, 0x7c, 0x76, 0x6f, 0xb6, 0x43, 0x9b, 0x45, 0xab, 0xf4, 0xd6, 0x27, 0xb4, 0xb1, 0x25,
	0xf4, 0xf6, 0x83, 0xc9, 0xca, 0x3d, 0x00, 0x7d, 0x13, 0xf4, 0x8f, 0xf6, 0xda, 0x6b, 0xdb, 0x0e,
	0x92, 0x78, 0x63, 0x18, 0xda, 0xce, 0x79, 0xd7, 0x72, 0xfb, 0x0e, 0x2a, 0x7d, 0x6e, 0x6d, 0x32,
	0x6f, 0x5d, 0xbd, 0xf6, 0x00, 0x95, 0x79, 0xb7, 0xea, 0x8d, 0xba, 0xae, 0xcd, 0x67, 0x15, 0xd1,
	0x86, 0x5d, 0x8b, 0x20, 0x85, 0x37, 0x11, 0x62, 0x09, 0x5b, 0x3d, 0x78, 0x05, 0x5a, 0x71, 0xc6,
	0xcd, 0xc6, 0xa4, 0x7f, 0xdd, 0xd8, 0x57, 0x50, 0xb7, 0xd9, 0x8f, 0x74, 0x9a, 0x0e, 0xbc, 0xf5,
	0x22, 0xf4, 0x7c, 0x5c, 0x03, 0x29, 0xbb, 0xcb, 0x0a, 0x91, 0x98, 0x19, 0x03, 0x72, 0x63, 0x8f,
	0x25, 0xb3, 0x30, 0x5e, 0x16, 0x0c, 0x04, 0xf2, 0x2a, 0x66, 0x79, 0xa5, 0x71, 0x93, 0xff, 0x65,
	0x50, 0x7f, 0x5e, 0x9c, 0xbf, 0xbe, 0x25, 0x1a, 0x11, 0x10, 0x7e, 0x01, 0x4a, 0x20, 0xf2, 0xe4,
	0x05, 0xf7, 0x88, 0x93, 0xb6, 0x32, 0x93, 0x9c, 0xf0, 0x41, 0x11, 0xff, 0x31, 0xc7, 0x7f, 0x07,
	0x00, 0x00, 0xff, 0xff, 0xb5, 0x6b, 0xf5, 0xe3, 0xd3, 0x08, 0x00, 0x00,
}
