literals.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: flyteidl/core/literals.proto

package core // import "github.com/lyft/flyteidl/gen/pb-go/flyteidl/core"

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import duration "github.com/golang/protobuf/ptypes/duration"
import _struct "github.com/golang/protobuf/ptypes/struct"
import timestamp "github.com/golang/protobuf/ptypes/timestamp"

// 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

// Primitive Types
type Primitive struct {
	// Defines one of simple primitive types. These types will get translated into different programming languages as
	// described in https://developers.google.com/protocol-buffers/docs/proto#scalar.
	//
	// Types that are valid to be assigned to Value:
	//	*Primitive_Integer
	//	*Primitive_FloatValue
	//	*Primitive_StringValue
	//	*Primitive_Boolean
	//	*Primitive_Datetime
	//	*Primitive_Duration
	Value                isPrimitive_Value `protobuf_oneof:"value"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *Primitive) Reset()         { *m = Primitive{} }
func (m *Primitive) String() string { return proto.CompactTextString(m) }
func (*Primitive) ProtoMessage()    {}
func (*Primitive) Descriptor() ([]byte, []int) {
	return fileDescriptor_literals_08dbad4c489f7d4f, []int{0}
}
func (m *Primitive) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Primitive.Unmarshal(m, b)
}
func (m *Primitive) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Primitive.Marshal(b, m, deterministic)
}
func (dst *Primitive) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Primitive.Merge(dst, src)
}
func (m *Primitive) XXX_Size() int {
	return xxx_messageInfo_Primitive.Size(m)
}
func (m *Primitive) XXX_DiscardUnknown() {
	xxx_messageInfo_Primitive.DiscardUnknown(m)
}

var xxx_messageInfo_Primitive proto.InternalMessageInfo

type isPrimitive_Value interface {
	isPrimitive_Value()
}

type Primitive_Integer struct {
	Integer int64 `protobuf:"varint,1,opt,name=integer,proto3,oneof"`
}

type Primitive_FloatValue struct {
	FloatValue float64 `protobuf:"fixed64,2,opt,name=float_value,json=floatValue,proto3,oneof"`
}

type Primitive_StringValue struct {
	StringValue string `protobuf:"bytes,3,opt,name=string_value,json=stringValue,proto3,oneof"`
}

type Primitive_Boolean struct {
	Boolean bool `protobuf:"varint,4,opt,name=boolean,proto3,oneof"`
}

type Primitive_Datetime struct {
	Datetime *timestamp.Timestamp `protobuf:"bytes,5,opt,name=datetime,proto3,oneof"`
}

type Primitive_Duration struct {
	Duration *duration.Duration `protobuf:"bytes,6,opt,name=duration,proto3,oneof"`
}

func (*Primitive_Integer) isPrimitive_Value() {}

func (*Primitive_FloatValue) isPrimitive_Value() {}

func (*Primitive_StringValue) isPrimitive_Value() {}

func (*Primitive_Boolean) isPrimitive_Value() {}

func (*Primitive_Datetime) isPrimitive_Value() {}

func (*Primitive_Duration) isPrimitive_Value() {}

func (m *Primitive) GetValue() isPrimitive_Value {
	if m != nil {
		return m.Value
	}
	return nil
}

func (m *Primitive) GetInteger() int64 {
	if x, ok := m.GetValue().(*Primitive_Integer); ok {
		return x.Integer
	}
	return 0
}

func (m *Primitive) GetFloatValue() float64 {
	if x, ok := m.GetValue().(*Primitive_FloatValue); ok {
		return x.FloatValue
	}
	return 0
}

func (m *Primitive) GetStringValue() string {
	if x, ok := m.GetValue().(*Primitive_StringValue); ok {
		return x.StringValue
	}
	return ""
}

func (m *Primitive) GetBoolean() bool {
	if x, ok := m.GetValue().(*Primitive_Boolean); ok {
		return x.Boolean
	}
	return false
}

func (m *Primitive) GetDatetime() *timestamp.Timestamp {
	if x, ok := m.GetValue().(*Primitive_Datetime); ok {
		return x.Datetime
	}
	return nil
}

func (m *Primitive) GetDuration() *duration.Duration {
	if x, ok := m.GetValue().(*Primitive_Duration); ok {
		return x.Duration
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*Primitive) 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 _Primitive_OneofMarshaler, _Primitive_OneofUnmarshaler, _Primitive_OneofSizer, []interface{}{
		(*Primitive_Integer)(nil),
		(*Primitive_FloatValue)(nil),
		(*Primitive_StringValue)(nil),
		(*Primitive_Boolean)(nil),
		(*Primitive_Datetime)(nil),
		(*Primitive_Duration)(nil),
	}
}

func _Primitive_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*Primitive)
	// value
	switch x := m.Value.(type) {
	case *Primitive_Integer:
		b.EncodeVarint(1<<3 | proto.WireVarint)
		b.EncodeVarint(uint64(x.Integer))
	case *Primitive_FloatValue:
		b.EncodeVarint(2<<3 | proto.WireFixed64)
		b.EncodeFixed64(math.Float64bits(x.FloatValue))
	case *Primitive_StringValue:
		b.EncodeVarint(3<<3 | proto.WireBytes)
		b.EncodeStringBytes(x.StringValue)
	case *Primitive_Boolean:
		t := uint64(0)
		if x.Boolean {
			t = 1
		}
		b.EncodeVarint(4<<3 | proto.WireVarint)
		b.EncodeVarint(t)
	case *Primitive_Datetime:
		b.EncodeVarint(5<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Datetime); err != nil {
			return err
		}
	case *Primitive_Duration:
		b.EncodeVarint(6<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Duration); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("Primitive.Value has unexpected type %T", x)
	}
	return nil
}

func _Primitive_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*Primitive)
	switch tag {
	case 1: // value.integer
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.Value = &Primitive_Integer{int64(x)}
		return true, err
	case 2: // value.float_value
		if wire != proto.WireFixed64 {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeFixed64()
		m.Value = &Primitive_FloatValue{math.Float64frombits(x)}
		return true, err
	case 3: // value.string_value
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeStringBytes()
		m.Value = &Primitive_StringValue{x}
		return true, err
	case 4: // value.boolean
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.Value = &Primitive_Boolean{x != 0}
		return true, err
	case 5: // value.datetime
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(timestamp.Timestamp)
		err := b.DecodeMessage(msg)
		m.Value = &Primitive_Datetime{msg}
		return true, err
	case 6: // value.duration
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(duration.Duration)
		err := b.DecodeMessage(msg)
		m.Value = &Primitive_Duration{msg}
		return true, err
	default:
		return false, nil
	}
}

func _Primitive_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*Primitive)
	// value
	switch x := m.Value.(type) {
	case *Primitive_Integer:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(x.Integer))
	case *Primitive_FloatValue:
		n += 1 // tag and wire
		n += 8
	case *Primitive_StringValue:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(len(x.StringValue)))
		n += len(x.StringValue)
	case *Primitive_Boolean:
		n += 1 // tag and wire
		n += 1
	case *Primitive_Datetime:
		s := proto.Size(x.Datetime)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Primitive_Duration:
		s := proto.Size(x.Duration)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

// Used to denote a nil/null/None assignment to a scalar value. The underlying LiteralType for Void is intentionally
// undefined since it can be assigned to a scalar of any LiteralType.
type Void struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Void) Reset()         { *m = Void{} }
func (m *Void) String() string { return proto.CompactTextString(m) }
func (*Void) ProtoMessage()    {}
func (*Void) Descriptor() ([]byte, []int) {
	return fileDescriptor_literals_08dbad4c489f7d4f, []int{1}
}
func (m *Void) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Void.Unmarshal(m, b)
}
func (m *Void) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Void.Marshal(b, m, deterministic)
}
func (dst *Void) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Void.Merge(dst, src)
}
func (m *Void) XXX_Size() int {
	return xxx_messageInfo_Void.Size(m)
}
func (m *Void) XXX_DiscardUnknown() {
	xxx_messageInfo_Void.DiscardUnknown(m)
}

var xxx_messageInfo_Void proto.InternalMessageInfo

// Refers to an offloaded set of files. It encapsulates the type of the store and a unique uri for where the data is.
// There are no restrictions on how the uri is formatted since it will depend on how to interact with the store.
type Blob struct {
	Metadata             *BlobMetadata `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"`
	Uri                  string        `protobuf:"bytes,3,opt,name=uri,proto3" json:"uri,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

func (m *Blob) Reset()         { *m = Blob{} }
func (m *Blob) String() string { return proto.CompactTextString(m) }
func (*Blob) ProtoMessage()    {}
func (*Blob) Descriptor() ([]byte, []int) {
	return fileDescriptor_literals_08dbad4c489f7d4f, []int{2}
}
func (m *Blob) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Blob.Unmarshal(m, b)
}
func (m *Blob) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Blob.Marshal(b, m, deterministic)
}
func (dst *Blob) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Blob.Merge(dst, src)
}
func (m *Blob) XXX_Size() int {
	return xxx_messageInfo_Blob.Size(m)
}
func (m *Blob) XXX_DiscardUnknown() {
	xxx_messageInfo_Blob.DiscardUnknown(m)
}

var xxx_messageInfo_Blob proto.InternalMessageInfo

func (m *Blob) GetMetadata() *BlobMetadata {
	if m != nil {
		return m.Metadata
	}
	return nil
}

func (m *Blob) GetUri() string {
	if m != nil {
		return m.Uri
	}
	return ""
}

type BlobMetadata struct {
	Type                 *BlobType `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *BlobMetadata) Reset()         { *m = BlobMetadata{} }
func (m *BlobMetadata) String() string { return proto.CompactTextString(m) }
func (*BlobMetadata) ProtoMessage()    {}
func (*BlobMetadata) Descriptor() ([]byte, []int) {
	return fileDescriptor_literals_08dbad4c489f7d4f, []int{3}
}
func (m *BlobMetadata) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_BlobMetadata.Unmarshal(m, b)
}
func (m *BlobMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_BlobMetadata.Marshal(b, m, deterministic)
}
func (dst *BlobMetadata) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BlobMetadata.Merge(dst, src)
}
func (m *BlobMetadata) XXX_Size() int {
	return xxx_messageInfo_BlobMetadata.Size(m)
}
func (m *BlobMetadata) XXX_DiscardUnknown() {
	xxx_messageInfo_BlobMetadata.DiscardUnknown(m)
}

var xxx_messageInfo_BlobMetadata proto.InternalMessageInfo

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

// A simple byte array with a tag to help different parts of the system communicate about what is in the byte array.
// It's strongly advisable that consumers of this type define a unique tag and validate the tag before parsing the data.
type Binary struct {
	Value                []byte   `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
	Tag                  string   `protobuf:"bytes,2,opt,name=tag,proto3" json:"tag,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Binary) Reset()         { *m = Binary{} }
func (m *Binary) String() string { return proto.CompactTextString(m) }
func (*Binary) ProtoMessage()    {}
func (*Binary) Descriptor() ([]byte, []int) {
	return fileDescriptor_literals_08dbad4c489f7d4f, []int{4}
}
func (m *Binary) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Binary.Unmarshal(m, b)
}
func (m *Binary) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Binary.Marshal(b, m, deterministic)
}
func (dst *Binary) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Binary.Merge(dst, src)
}
func (m *Binary) XXX_Size() int {
	return xxx_messageInfo_Binary.Size(m)
}
func (m *Binary) XXX_DiscardUnknown() {
	xxx_messageInfo_Binary.DiscardUnknown(m)
}

var xxx_messageInfo_Binary proto.InternalMessageInfo

func (m *Binary) GetValue() []byte {
	if m != nil {
		return m.Value
	}
	return nil
}

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

// A strongly typed schema that defines the interface of data retrieved from the underlying storage medium.
type Schema struct {
	Uri                  string      `protobuf:"bytes,1,opt,name=uri,proto3" json:"uri,omitempty"`
	Type                 *SchemaType `protobuf:"bytes,3,opt,name=type,proto3" json:"type,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *Schema) Reset()         { *m = Schema{} }
func (m *Schema) String() string { return proto.CompactTextString(m) }
func (*Schema) ProtoMessage()    {}
func (*Schema) Descriptor() ([]byte, []int) {
	return fileDescriptor_literals_08dbad4c489f7d4f, []int{5}
}
func (m *Schema) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Schema.Unmarshal(m, b)
}
func (m *Schema) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Schema.Marshal(b, m, deterministic)
}
func (dst *Schema) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Schema.Merge(dst, src)
}
func (m *Schema) XXX_Size() int {
	return xxx_messageInfo_Schema.Size(m)
}
func (m *Schema) XXX_DiscardUnknown() {
	xxx_messageInfo_Schema.DiscardUnknown(m)
}

var xxx_messageInfo_Schema proto.InternalMessageInfo

func (m *Schema) GetUri() string {
	if m != nil {
		return m.Uri
	}
	return ""
}

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

type Scalar struct {
	// Types that are valid to be assigned to Value:
	//	*Scalar_Primitive
	//	*Scalar_Blob
	//	*Scalar_Binary
	//	*Scalar_Schema
	//	*Scalar_NoneType
	//	*Scalar_Error
	//	*Scalar_Generic
	Value                isScalar_Value `protobuf_oneof:"value"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (m *Scalar) Reset()         { *m = Scalar{} }
func (m *Scalar) String() string { return proto.CompactTextString(m) }
func (*Scalar) ProtoMessage()    {}
func (*Scalar) Descriptor() ([]byte, []int) {
	return fileDescriptor_literals_08dbad4c489f7d4f, []int{6}
}
func (m *Scalar) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Scalar.Unmarshal(m, b)
}
func (m *Scalar) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Scalar.Marshal(b, m, deterministic)
}
func (dst *Scalar) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Scalar.Merge(dst, src)
}
func (m *Scalar) XXX_Size() int {
	return xxx_messageInfo_Scalar.Size(m)
}
func (m *Scalar) XXX_DiscardUnknown() {
	xxx_messageInfo_Scalar.DiscardUnknown(m)
}

var xxx_messageInfo_Scalar proto.InternalMessageInfo

type isScalar_Value interface {
	isScalar_Value()
}

type Scalar_Primitive struct {
	Primitive *Primitive `protobuf:"bytes,1,opt,name=primitive,proto3,oneof"`
}

type Scalar_Blob struct {
	Blob *Blob `protobuf:"bytes,2,opt,name=blob,proto3,oneof"`
}

type Scalar_Binary struct {
	Binary *Binary `protobuf:"bytes,3,opt,name=binary,proto3,oneof"`
}

type Scalar_Schema struct {
	Schema *Schema `protobuf:"bytes,4,opt,name=schema,proto3,oneof"`
}

type Scalar_NoneType struct {
	NoneType *Void `protobuf:"bytes,5,opt,name=none_type,json=noneType,proto3,oneof"`
}

type Scalar_Error struct {
	Error *Error `protobuf:"bytes,6,opt,name=error,proto3,oneof"`
}

type Scalar_Generic struct {
	Generic *_struct.Struct `protobuf:"bytes,7,opt,name=generic,proto3,oneof"`
}

func (*Scalar_Primitive) isScalar_Value() {}

func (*Scalar_Blob) isScalar_Value() {}

func (*Scalar_Binary) isScalar_Value() {}

func (*Scalar_Schema) isScalar_Value() {}

func (*Scalar_NoneType) isScalar_Value() {}

func (*Scalar_Error) isScalar_Value() {}

func (*Scalar_Generic) isScalar_Value() {}

func (m *Scalar) GetValue() isScalar_Value {
	if m != nil {
		return m.Value
	}
	return nil
}

func (m *Scalar) GetPrimitive() *Primitive {
	if x, ok := m.GetValue().(*Scalar_Primitive); ok {
		return x.Primitive
	}
	return nil
}

func (m *Scalar) GetBlob() *Blob {
	if x, ok := m.GetValue().(*Scalar_Blob); ok {
		return x.Blob
	}
	return nil
}

func (m *Scalar) GetBinary() *Binary {
	if x, ok := m.GetValue().(*Scalar_Binary); ok {
		return x.Binary
	}
	return nil
}

func (m *Scalar) GetSchema() *Schema {
	if x, ok := m.GetValue().(*Scalar_Schema); ok {
		return x.Schema
	}
	return nil
}

func (m *Scalar) GetNoneType() *Void {
	if x, ok := m.GetValue().(*Scalar_NoneType); ok {
		return x.NoneType
	}
	return nil
}

func (m *Scalar) GetError() *Error {
	if x, ok := m.GetValue().(*Scalar_Error); ok {
		return x.Error
	}
	return nil
}

func (m *Scalar) GetGeneric() *_struct.Struct {
	if x, ok := m.GetValue().(*Scalar_Generic); ok {
		return x.Generic
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*Scalar) 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 _Scalar_OneofMarshaler, _Scalar_OneofUnmarshaler, _Scalar_OneofSizer, []interface{}{
		(*Scalar_Primitive)(nil),
		(*Scalar_Blob)(nil),
		(*Scalar_Binary)(nil),
		(*Scalar_Schema)(nil),
		(*Scalar_NoneType)(nil),
		(*Scalar_Error)(nil),
		(*Scalar_Generic)(nil),
	}
}

func _Scalar_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*Scalar)
	// value
	switch x := m.Value.(type) {
	case *Scalar_Primitive:
		b.EncodeVarint(1<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Primitive); err != nil {
			return err
		}
	case *Scalar_Blob:
		b.EncodeVarint(2<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Blob); err != nil {
			return err
		}
	case *Scalar_Binary:
		b.EncodeVarint(3<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Binary); err != nil {
			return err
		}
	case *Scalar_Schema:
		b.EncodeVarint(4<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Schema); err != nil {
			return err
		}
	case *Scalar_NoneType:
		b.EncodeVarint(5<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.NoneType); err != nil {
			return err
		}
	case *Scalar_Error:
		b.EncodeVarint(6<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Error); err != nil {
			return err
		}
	case *Scalar_Generic:
		b.EncodeVarint(7<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Generic); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("Scalar.Value has unexpected type %T", x)
	}
	return nil
}

func _Scalar_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*Scalar)
	switch tag {
	case 1: // value.primitive
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Primitive)
		err := b.DecodeMessage(msg)
		m.Value = &Scalar_Primitive{msg}
		return true, err
	case 2: // value.blob
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Blob)
		err := b.DecodeMessage(msg)
		m.Value = &Scalar_Blob{msg}
		return true, err
	case 3: // value.binary
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Binary)
		err := b.DecodeMessage(msg)
		m.Value = &Scalar_Binary{msg}
		return true, err
	case 4: // value.schema
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Schema)
		err := b.DecodeMessage(msg)
		m.Value = &Scalar_Schema{msg}
		return true, err
	case 5: // value.none_type
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Void)
		err := b.DecodeMessage(msg)
		m.Value = &Scalar_NoneType{msg}
		return true, err
	case 6: // value.error
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Error)
		err := b.DecodeMessage(msg)
		m.Value = &Scalar_Error{msg}
		return true, err
	case 7: // value.generic
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(_struct.Struct)
		err := b.DecodeMessage(msg)
		m.Value = &Scalar_Generic{msg}
		return true, err
	default:
		return false, nil
	}
}

func _Scalar_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*Scalar)
	// value
	switch x := m.Value.(type) {
	case *Scalar_Primitive:
		s := proto.Size(x.Primitive)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Scalar_Blob:
		s := proto.Size(x.Blob)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Scalar_Binary:
		s := proto.Size(x.Binary)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Scalar_Schema:
		s := proto.Size(x.Schema)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Scalar_NoneType:
		s := proto.Size(x.NoneType)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Scalar_Error:
		s := proto.Size(x.Error)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Scalar_Generic:
		s := proto.Size(x.Generic)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

// A simple value. This supports any level of nesting (e.g. array of array of array of Blobs) as well as simple primitives.
type Literal struct {
	// Types that are valid to be assigned to Value:
	//	*Literal_Scalar
	//	*Literal_Collection
	//	*Literal_Map
	Value                isLiteral_Value `protobuf_oneof:"value"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *Literal) Reset()         { *m = Literal{} }
func (m *Literal) String() string { return proto.CompactTextString(m) }
func (*Literal) ProtoMessage()    {}
func (*Literal) Descriptor() ([]byte, []int) {
	return fileDescriptor_literals_08dbad4c489f7d4f, []int{7}
}
func (m *Literal) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Literal.Unmarshal(m, b)
}
func (m *Literal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Literal.Marshal(b, m, deterministic)
}
func (dst *Literal) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Literal.Merge(dst, src)
}
func (m *Literal) XXX_Size() int {
	return xxx_messageInfo_Literal.Size(m)
}
func (m *Literal) XXX_DiscardUnknown() {
	xxx_messageInfo_Literal.DiscardUnknown(m)
}

var xxx_messageInfo_Literal proto.InternalMessageInfo

type isLiteral_Value interface {
	isLiteral_Value()
}

type Literal_Scalar struct {
	Scalar *Scalar `protobuf:"bytes,1,opt,name=scalar,proto3,oneof"`
}

type Literal_Collection struct {
	Collection *LiteralCollection `protobuf:"bytes,2,opt,name=collection,proto3,oneof"`
}

type Literal_Map struct {
	Map *LiteralMap `protobuf:"bytes,3,opt,name=map,proto3,oneof"`
}

func (*Literal_Scalar) isLiteral_Value() {}

func (*Literal_Collection) isLiteral_Value() {}

func (*Literal_Map) isLiteral_Value() {}

func (m *Literal) GetValue() isLiteral_Value {
	if m != nil {
		return m.Value
	}
	return nil
}

func (m *Literal) GetScalar() *Scalar {
	if x, ok := m.GetValue().(*Literal_Scalar); ok {
		return x.Scalar
	}
	return nil
}

func (m *Literal) GetCollection() *LiteralCollection {
	if x, ok := m.GetValue().(*Literal_Collection); ok {
		return x.Collection
	}
	return nil
}

func (m *Literal) GetMap() *LiteralMap {
	if x, ok := m.GetValue().(*Literal_Map); ok {
		return x.Map
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*Literal) 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 _Literal_OneofMarshaler, _Literal_OneofUnmarshaler, _Literal_OneofSizer, []interface{}{
		(*Literal_Scalar)(nil),
		(*Literal_Collection)(nil),
		(*Literal_Map)(nil),
	}
}

func _Literal_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*Literal)
	// value
	switch x := m.Value.(type) {
	case *Literal_Scalar:
		b.EncodeVarint(1<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Scalar); err != nil {
			return err
		}
	case *Literal_Collection:
		b.EncodeVarint(2<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Collection); err != nil {
			return err
		}
	case *Literal_Map:
		b.EncodeVarint(3<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Map); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("Literal.Value has unexpected type %T", x)
	}
	return nil
}

func _Literal_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*Literal)
	switch tag {
	case 1: // value.scalar
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Scalar)
		err := b.DecodeMessage(msg)
		m.Value = &Literal_Scalar{msg}
		return true, err
	case 2: // value.collection
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(LiteralCollection)
		err := b.DecodeMessage(msg)
		m.Value = &Literal_Collection{msg}
		return true, err
	case 3: // value.map
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(LiteralMap)
		err := b.DecodeMessage(msg)
		m.Value = &Literal_Map{msg}
		return true, err
	default:
		return false, nil
	}
}

func _Literal_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*Literal)
	// value
	switch x := m.Value.(type) {
	case *Literal_Scalar:
		s := proto.Size(x.Scalar)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Literal_Collection:
		s := proto.Size(x.Collection)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Literal_Map:
		s := proto.Size(x.Map)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

// A collection of literals. This is a workaround since oneofs in proto messages cannot contain a repeated field.
type LiteralCollection struct {
	Literals             []*Literal `protobuf:"bytes,1,rep,name=literals,proto3" json:"literals,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *LiteralCollection) Reset()         { *m = LiteralCollection{} }
func (m *LiteralCollection) String() string { return proto.CompactTextString(m) }
func (*LiteralCollection) ProtoMessage()    {}
func (*LiteralCollection) Descriptor() ([]byte, []int) {
	return fileDescriptor_literals_08dbad4c489f7d4f, []int{8}
}
func (m *LiteralCollection) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_LiteralCollection.Unmarshal(m, b)
}
func (m *LiteralCollection) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_LiteralCollection.Marshal(b, m, deterministic)
}
func (dst *LiteralCollection) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LiteralCollection.Merge(dst, src)
}
func (m *LiteralCollection) XXX_Size() int {
	return xxx_messageInfo_LiteralCollection.Size(m)
}
func (m *LiteralCollection) XXX_DiscardUnknown() {
	xxx_messageInfo_LiteralCollection.DiscardUnknown(m)
}

var xxx_messageInfo_LiteralCollection proto.InternalMessageInfo

func (m *LiteralCollection) GetLiterals() []*Literal {
	if m != nil {
		return m.Literals
	}
	return nil
}

// A map of literals. This is a workaround since oneofs in proto messages cannot contain a repeated field.
type LiteralMap struct {
	Literals             map[string]*Literal `protobuf:"bytes,1,rep,name=literals,proto3" json:"literals,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

func (m *LiteralMap) Reset()         { *m = LiteralMap{} }
func (m *LiteralMap) String() string { return proto.CompactTextString(m) }
func (*LiteralMap) ProtoMessage()    {}
func (*LiteralMap) Descriptor() ([]byte, []int) {
	return fileDescriptor_literals_08dbad4c489f7d4f, []int{9}
}
func (m *LiteralMap) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_LiteralMap.Unmarshal(m, b)
}
func (m *LiteralMap) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_LiteralMap.Marshal(b, m, deterministic)
}
func (dst *LiteralMap) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LiteralMap.Merge(dst, src)
}
func (m *LiteralMap) XXX_Size() int {
	return xxx_messageInfo_LiteralMap.Size(m)
}
func (m *LiteralMap) XXX_DiscardUnknown() {
	xxx_messageInfo_LiteralMap.DiscardUnknown(m)
}

var xxx_messageInfo_LiteralMap proto.InternalMessageInfo

func (m *LiteralMap) GetLiterals() map[string]*Literal {
	if m != nil {
		return m.Literals
	}
	return nil
}

// A collection of BindingData items.
type BindingDataCollection struct {
	Bindings             []*BindingData `protobuf:"bytes,1,rep,name=bindings,proto3" json:"bindings,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (m *BindingDataCollection) Reset()         { *m = BindingDataCollection{} }
func (m *BindingDataCollection) String() string { return proto.CompactTextString(m) }
func (*BindingDataCollection) ProtoMessage()    {}
func (*BindingDataCollection) Descriptor() ([]byte, []int) {
	return fileDescriptor_literals_08dbad4c489f7d4f, []int{10}
}
func (m *BindingDataCollection) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_BindingDataCollection.Unmarshal(m, b)
}
func (m *BindingDataCollection) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_BindingDataCollection.Marshal(b, m, deterministic)
}
func (dst *BindingDataCollection) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BindingDataCollection.Merge(dst, src)
}
func (m *BindingDataCollection) XXX_Size() int {
	return xxx_messageInfo_BindingDataCollection.Size(m)
}
func (m *BindingDataCollection) XXX_DiscardUnknown() {
	xxx_messageInfo_BindingDataCollection.DiscardUnknown(m)
}

var xxx_messageInfo_BindingDataCollection proto.InternalMessageInfo

func (m *BindingDataCollection) GetBindings() []*BindingData {
	if m != nil {
		return m.Bindings
	}
	return nil
}

// A map of BindingData items.
type BindingDataMap struct {
	Bindings             map[string]*BindingData `protobuf:"bytes,1,rep,name=bindings,proto3" json:"bindings,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

func (m *BindingDataMap) Reset()         { *m = BindingDataMap{} }
func (m *BindingDataMap) String() string { return proto.CompactTextString(m) }
func (*BindingDataMap) ProtoMessage()    {}
func (*BindingDataMap) Descriptor() ([]byte, []int) {
	return fileDescriptor_literals_08dbad4c489f7d4f, []int{11}
}
func (m *BindingDataMap) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_BindingDataMap.Unmarshal(m, b)
}
func (m *BindingDataMap) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_BindingDataMap.Marshal(b, m, deterministic)
}
func (dst *BindingDataMap) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BindingDataMap.Merge(dst, src)
}
func (m *BindingDataMap) XXX_Size() int {
	return xxx_messageInfo_BindingDataMap.Size(m)
}
func (m *BindingDataMap) XXX_DiscardUnknown() {
	xxx_messageInfo_BindingDataMap.DiscardUnknown(m)
}

var xxx_messageInfo_BindingDataMap proto.InternalMessageInfo

func (m *BindingDataMap) GetBindings() map[string]*BindingData {
	if m != nil {
		return m.Bindings
	}
	return nil
}

// Specifies either a simple value or a reference to another output.
type BindingData struct {
	// Types that are valid to be assigned to Value:
	//	*BindingData_Scalar
	//	*BindingData_Collection
	//	*BindingData_Promise
	//	*BindingData_Map
	Value                isBindingData_Value `protobuf_oneof:"value"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

func (m *BindingData) Reset()         { *m = BindingData{} }
func (m *BindingData) String() string { return proto.CompactTextString(m) }
func (*BindingData) ProtoMessage()    {}
func (*BindingData) Descriptor() ([]byte, []int) {
	return fileDescriptor_literals_08dbad4c489f7d4f, []int{12}
}
func (m *BindingData) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_BindingData.Unmarshal(m, b)
}
func (m *BindingData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_BindingData.Marshal(b, m, deterministic)
}
func (dst *BindingData) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BindingData.Merge(dst, src)
}
func (m *BindingData) XXX_Size() int {
	return xxx_messageInfo_BindingData.Size(m)
}
func (m *BindingData) XXX_DiscardUnknown() {
	xxx_messageInfo_BindingData.DiscardUnknown(m)
}

var xxx_messageInfo_BindingData proto.InternalMessageInfo

type isBindingData_Value interface {
	isBindingData_Value()
}

type BindingData_Scalar struct {
	Scalar *Scalar `protobuf:"bytes,1,opt,name=scalar,proto3,oneof"`
}

type BindingData_Collection struct {
	Collection *BindingDataCollection `protobuf:"bytes,2,opt,name=collection,proto3,oneof"`
}

type BindingData_Promise struct {
	Promise *OutputReference `protobuf:"bytes,3,opt,name=promise,proto3,oneof"`
}

type BindingData_Map struct {
	Map *BindingDataMap `protobuf:"bytes,4,opt,name=map,proto3,oneof"`
}

func (*BindingData_Scalar) isBindingData_Value() {}

func (*BindingData_Collection) isBindingData_Value() {}

func (*BindingData_Promise) isBindingData_Value() {}

func (*BindingData_Map) isBindingData_Value() {}

func (m *BindingData) GetValue() isBindingData_Value {
	if m != nil {
		return m.Value
	}
	return nil
}

func (m *BindingData) GetScalar() *Scalar {
	if x, ok := m.GetValue().(*BindingData_Scalar); ok {
		return x.Scalar
	}
	return nil
}

func (m *BindingData) GetCollection() *BindingDataCollection {
	if x, ok := m.GetValue().(*BindingData_Collection); ok {
		return x.Collection
	}
	return nil
}

func (m *BindingData) GetPromise() *OutputReference {
	if x, ok := m.GetValue().(*BindingData_Promise); ok {
		return x.Promise
	}
	return nil
}

func (m *BindingData) GetMap() *BindingDataMap {
	if x, ok := m.GetValue().(*BindingData_Map); ok {
		return x.Map
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*BindingData) 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 _BindingData_OneofMarshaler, _BindingData_OneofUnmarshaler, _BindingData_OneofSizer, []interface{}{
		(*BindingData_Scalar)(nil),
		(*BindingData_Collection)(nil),
		(*BindingData_Promise)(nil),
		(*BindingData_Map)(nil),
	}
}

func _BindingData_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*BindingData)
	// value
	switch x := m.Value.(type) {
	case *BindingData_Scalar:
		b.EncodeVarint(1<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Scalar); err != nil {
			return err
		}
	case *BindingData_Collection:
		b.EncodeVarint(2<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Collection); err != nil {
			return err
		}
	case *BindingData_Promise:
		b.EncodeVarint(3<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Promise); err != nil {
			return err
		}
	case *BindingData_Map:
		b.EncodeVarint(4<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Map); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("BindingData.Value has unexpected type %T", x)
	}
	return nil
}

func _BindingData_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*BindingData)
	switch tag {
	case 1: // value.scalar
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Scalar)
		err := b.DecodeMessage(msg)
		m.Value = &BindingData_Scalar{msg}
		return true, err
	case 2: // value.collection
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(BindingDataCollection)
		err := b.DecodeMessage(msg)
		m.Value = &BindingData_Collection{msg}
		return true, err
	case 3: // value.promise
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(OutputReference)
		err := b.DecodeMessage(msg)
		m.Value = &BindingData_Promise{msg}
		return true, err
	case 4: // value.map
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(BindingDataMap)
		err := b.DecodeMessage(msg)
		m.Value = &BindingData_Map{msg}
		return true, err
	default:
		return false, nil
	}
}

func _BindingData_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*BindingData)
	// value
	switch x := m.Value.(type) {
	case *BindingData_Scalar:
		s := proto.Size(x.Scalar)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BindingData_Collection:
		s := proto.Size(x.Collection)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BindingData_Promise:
		s := proto.Size(x.Promise)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BindingData_Map:
		s := proto.Size(x.Map)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

// An input/output binding of a variable to either static value or a node output.
type Binding struct {
	// Variable name must match an input/output variable of the node.
	Var string `protobuf:"bytes,1,opt,name=var,proto3" json:"var,omitempty"`
	// Data to use to bind this variable.
	Binding              *BindingData `protobuf:"bytes,2,opt,name=binding,proto3" json:"binding,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *Binding) Reset()         { *m = Binding{} }
func (m *Binding) String() string { return proto.CompactTextString(m) }
func (*Binding) ProtoMessage()    {}
func (*Binding) Descriptor() ([]byte, []int) {
	return fileDescriptor_literals_08dbad4c489f7d4f, []int{13}
}
func (m *Binding) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Binding.Unmarshal(m, b)
}
func (m *Binding) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Binding.Marshal(b, m, deterministic)
}
func (dst *Binding) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Binding.Merge(dst, src)
}
func (m *Binding) XXX_Size() int {
	return xxx_messageInfo_Binding.Size(m)
}
func (m *Binding) XXX_DiscardUnknown() {
	xxx_messageInfo_Binding.DiscardUnknown(m)
}

var xxx_messageInfo_Binding proto.InternalMessageInfo

func (m *Binding) GetVar() string {
	if m != nil {
		return m.Var
	}
	return ""
}

func (m *Binding) GetBinding() *BindingData {
	if m != nil {
		return m.Binding
	}
	return nil
}

// A generic key value pair.
type KeyValuePair struct {
	// required.
	Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	// +optional.
	Value                string   `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *KeyValuePair) Reset()         { *m = KeyValuePair{} }
func (m *KeyValuePair) String() string { return proto.CompactTextString(m) }
func (*KeyValuePair) ProtoMessage()    {}
func (*KeyValuePair) Descriptor() ([]byte, []int) {
	return fileDescriptor_literals_08dbad4c489f7d4f, []int{14}
}
func (m *KeyValuePair) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_KeyValuePair.Unmarshal(m, b)
}
func (m *KeyValuePair) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_KeyValuePair.Marshal(b, m, deterministic)
}
func (dst *KeyValuePair) XXX_Merge(src proto.Message) {
	xxx_messageInfo_KeyValuePair.Merge(dst, src)
}
func (m *KeyValuePair) XXX_Size() int {
	return xxx_messageInfo_KeyValuePair.Size(m)
}
func (m *KeyValuePair) XXX_DiscardUnknown() {
	xxx_messageInfo_KeyValuePair.DiscardUnknown(m)
}

var xxx_messageInfo_KeyValuePair proto.InternalMessageInfo

func (m *KeyValuePair) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

func (m *KeyValuePair) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

// Retry strategy associated with an executable unit.
type RetryStrategy struct {
	// Number of retries. Retries will be consumed when the job fails with a recoverable error.
	// The number of retries must be less than or equals to 10.
	Retries              uint32   `protobuf:"varint,5,opt,name=retries,proto3" json:"retries,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *RetryStrategy) Reset()         { *m = RetryStrategy{} }
func (m *RetryStrategy) String() string { return proto.CompactTextString(m) }
func (*RetryStrategy) ProtoMessage()    {}
func (*RetryStrategy) Descriptor() ([]byte, []int) {
	return fileDescriptor_literals_08dbad4c489f7d4f, []int{15}
}
func (m *RetryStrategy) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RetryStrategy.Unmarshal(m, b)
}
func (m *RetryStrategy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RetryStrategy.Marshal(b, m, deterministic)
}
func (dst *RetryStrategy) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RetryStrategy.Merge(dst, src)
}
func (m *RetryStrategy) XXX_Size() int {
	return xxx_messageInfo_RetryStrategy.Size(m)
}
func (m *RetryStrategy) XXX_DiscardUnknown() {
	xxx_messageInfo_RetryStrategy.DiscardUnknown(m)
}

var xxx_messageInfo_RetryStrategy proto.InternalMessageInfo

func (m *RetryStrategy) GetRetries() uint32 {
	if m != nil {
		return m.Retries
	}
	return 0
}

func init() {
	proto.RegisterType((*Primitive)(nil), "flyteidl.core.Primitive")
	proto.RegisterType((*Void)(nil), "flyteidl.core.Void")
	proto.RegisterType((*Blob)(nil), "flyteidl.core.Blob")
	proto.RegisterType((*BlobMetadata)(nil), "flyteidl.core.BlobMetadata")
	proto.RegisterType((*Binary)(nil), "flyteidl.core.Binary")
	proto.RegisterType((*Schema)(nil), "flyteidl.core.Schema")
	proto.RegisterType((*Scalar)(nil), "flyteidl.core.Scalar")
	proto.RegisterType((*Literal)(nil), "flyteidl.core.Literal")
	proto.RegisterType((*LiteralCollection)(nil), "flyteidl.core.LiteralCollection")
	proto.RegisterType((*LiteralMap)(nil), "flyteidl.core.LiteralMap")
	proto.RegisterMapType((map[string]*Literal)(nil), "flyteidl.core.LiteralMap.LiteralsEntry")
	proto.RegisterType((*BindingDataCollection)(nil), "flyteidl.core.BindingDataCollection")
	proto.RegisterType((*BindingDataMap)(nil), "flyteidl.core.BindingDataMap")
	proto.RegisterMapType((map[string]*BindingData)(nil), "flyteidl.core.BindingDataMap.BindingsEntry")
	proto.RegisterType((*BindingData)(nil), "flyteidl.core.BindingData")
	proto.RegisterType((*Binding)(nil), "flyteidl.core.Binding")
	proto.RegisterType((*KeyValuePair)(nil), "flyteidl.core.KeyValuePair")
	proto.RegisterType((*RetryStrategy)(nil), "flyteidl.core.RetryStrategy")
}

func init() {
	proto.RegisterFile("flyteidl/core/literals.proto", fileDescriptor_literals_08dbad4c489f7d4f)
}

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