node_execution.pb.go

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

package admin

import (
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	duration "github.com/golang/protobuf/ptypes/duration"
	timestamp "github.com/golang/protobuf/ptypes/timestamp"
	core "github.com/lyft/flyteidl/gen/pb-go/flyteidl/core"
	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.ProtoPackageIsVersion3 // please upgrade the proto package

// A message used to fetch a single node execution entity.
type NodeExecutionGetRequest struct {
	// Uniquely identifies an individual node execution.
	Id                   *core.NodeExecutionIdentifier `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                      `json:"-"`
	XXX_unrecognized     []byte                        `json:"-"`
	XXX_sizecache        int32                         `json:"-"`
}

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

func (m *NodeExecutionGetRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_NodeExecutionGetRequest.Unmarshal(m, b)
}
func (m *NodeExecutionGetRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_NodeExecutionGetRequest.Marshal(b, m, deterministic)
}
func (m *NodeExecutionGetRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NodeExecutionGetRequest.Merge(m, src)
}
func (m *NodeExecutionGetRequest) XXX_Size() int {
	return xxx_messageInfo_NodeExecutionGetRequest.Size(m)
}
func (m *NodeExecutionGetRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_NodeExecutionGetRequest.DiscardUnknown(m)
}

var xxx_messageInfo_NodeExecutionGetRequest proto.InternalMessageInfo

func (m *NodeExecutionGetRequest) GetId() *core.NodeExecutionIdentifier {
	if m != nil {
		return m.Id
	}
	return nil
}

// Represents a request structure to retrieve a list of node execution entities.
type NodeExecutionListRequest struct {
	// Indicates the workflow execution to filter by.
	WorkflowExecutionId *core.WorkflowExecutionIdentifier `protobuf:"bytes,1,opt,name=workflow_execution_id,json=workflowExecutionId,proto3" json:"workflow_execution_id,omitempty"`
	// Indicates the number of resources to be returned.
	Limit uint32 `protobuf:"varint,2,opt,name=limit,proto3" json:"limit,omitempty"`
	// In the case of multiple pages of results, the, server-provided token can be used to fetch the next page
	// in a query.
	// +optional
	Token string `protobuf:"bytes,3,opt,name=token,proto3" json:"token,omitempty"`
	// Indicates a list of filters passed as string.
	// More info on constructing filters : <Link>
	// +optional
	Filters string `protobuf:"bytes,4,opt,name=filters,proto3" json:"filters,omitempty"`
	// Sort ordering.
	// +optional
	SortBy               *Sort    `protobuf:"bytes,5,opt,name=sort_by,json=sortBy,proto3" json:"sort_by,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

func (m *NodeExecutionListRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_NodeExecutionListRequest.Unmarshal(m, b)
}
func (m *NodeExecutionListRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_NodeExecutionListRequest.Marshal(b, m, deterministic)
}
func (m *NodeExecutionListRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NodeExecutionListRequest.Merge(m, src)
}
func (m *NodeExecutionListRequest) XXX_Size() int {
	return xxx_messageInfo_NodeExecutionListRequest.Size(m)
}
func (m *NodeExecutionListRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_NodeExecutionListRequest.DiscardUnknown(m)
}

var xxx_messageInfo_NodeExecutionListRequest proto.InternalMessageInfo

func (m *NodeExecutionListRequest) GetWorkflowExecutionId() *core.WorkflowExecutionIdentifier {
	if m != nil {
		return m.WorkflowExecutionId
	}
	return nil
}

func (m *NodeExecutionListRequest) GetLimit() uint32 {
	if m != nil {
		return m.Limit
	}
	return 0
}

func (m *NodeExecutionListRequest) GetToken() string {
	if m != nil {
		return m.Token
	}
	return ""
}

func (m *NodeExecutionListRequest) GetFilters() string {
	if m != nil {
		return m.Filters
	}
	return ""
}

func (m *NodeExecutionListRequest) GetSortBy() *Sort {
	if m != nil {
		return m.SortBy
	}
	return nil
}

// Represents a request structure to retrieve a list of node execution entities launched by a specific task.
type NodeExecutionForTaskListRequest struct {
	// Indicates the node execution to filter by.
	TaskExecutionId *core.TaskExecutionIdentifier `protobuf:"bytes,1,opt,name=task_execution_id,json=taskExecutionId,proto3" json:"task_execution_id,omitempty"`
	// Indicates the number of resources to be returned.
	Limit uint32 `protobuf:"varint,2,opt,name=limit,proto3" json:"limit,omitempty"`
	// In the case of multiple pages of results, the, server-provided token can be used to fetch the next page
	// in a query.
	// +optional
	Token string `protobuf:"bytes,3,opt,name=token,proto3" json:"token,omitempty"`
	// Indicates a list of filters passed as string.
	// More info on constructing filters : <Link>
	// +optional
	Filters string `protobuf:"bytes,4,opt,name=filters,proto3" json:"filters,omitempty"`
	// Sort ordering.
	// +optional
	SortBy               *Sort    `protobuf:"bytes,5,opt,name=sort_by,json=sortBy,proto3" json:"sort_by,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

func (m *NodeExecutionForTaskListRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_NodeExecutionForTaskListRequest.Unmarshal(m, b)
}
func (m *NodeExecutionForTaskListRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_NodeExecutionForTaskListRequest.Marshal(b, m, deterministic)
}
func (m *NodeExecutionForTaskListRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NodeExecutionForTaskListRequest.Merge(m, src)
}
func (m *NodeExecutionForTaskListRequest) XXX_Size() int {
	return xxx_messageInfo_NodeExecutionForTaskListRequest.Size(m)
}
func (m *NodeExecutionForTaskListRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_NodeExecutionForTaskListRequest.DiscardUnknown(m)
}

var xxx_messageInfo_NodeExecutionForTaskListRequest proto.InternalMessageInfo

func (m *NodeExecutionForTaskListRequest) GetTaskExecutionId() *core.TaskExecutionIdentifier {
	if m != nil {
		return m.TaskExecutionId
	}
	return nil
}

func (m *NodeExecutionForTaskListRequest) GetLimit() uint32 {
	if m != nil {
		return m.Limit
	}
	return 0
}

func (m *NodeExecutionForTaskListRequest) GetToken() string {
	if m != nil {
		return m.Token
	}
	return ""
}

func (m *NodeExecutionForTaskListRequest) GetFilters() string {
	if m != nil {
		return m.Filters
	}
	return ""
}

func (m *NodeExecutionForTaskListRequest) GetSortBy() *Sort {
	if m != nil {
		return m.SortBy
	}
	return nil
}

// Encapsulates all details for a single node execution entity.
// A node represents a component in the overall workflow graph. A node launch a task, multiple tasks, an entire nested
// sub-workflow, or even a separate child-workflow execution.
// The same task can be called repeatedly in a single workflow but each node is unique.
type NodeExecution struct {
	// Uniquely identifies an individual node execution.
	Id *core.NodeExecutionIdentifier `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// Path to remote data store where input blob is stored.
	InputUri string `protobuf:"bytes,2,opt,name=input_uri,json=inputUri,proto3" json:"input_uri,omitempty"`
	// Computed results associated with this node execution.
	Closure              *NodeExecutionClosure `protobuf:"bytes,3,opt,name=closure,proto3" json:"closure,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

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

func (m *NodeExecution) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_NodeExecution.Unmarshal(m, b)
}
func (m *NodeExecution) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_NodeExecution.Marshal(b, m, deterministic)
}
func (m *NodeExecution) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NodeExecution.Merge(m, src)
}
func (m *NodeExecution) XXX_Size() int {
	return xxx_messageInfo_NodeExecution.Size(m)
}
func (m *NodeExecution) XXX_DiscardUnknown() {
	xxx_messageInfo_NodeExecution.DiscardUnknown(m)
}

var xxx_messageInfo_NodeExecution proto.InternalMessageInfo

func (m *NodeExecution) GetId() *core.NodeExecutionIdentifier {
	if m != nil {
		return m.Id
	}
	return nil
}

func (m *NodeExecution) GetInputUri() string {
	if m != nil {
		return m.InputUri
	}
	return ""
}

func (m *NodeExecution) GetClosure() *NodeExecutionClosure {
	if m != nil {
		return m.Closure
	}
	return nil
}

// Request structure to retrieve a list of node execution entities.
type NodeExecutionList struct {
	NodeExecutions []*NodeExecution `protobuf:"bytes,1,rep,name=node_executions,json=nodeExecutions,proto3" json:"node_executions,omitempty"`
	// In the case of multiple pages of results, the server-provided token can be used to fetch the next page
	// in a query. If there are no more results, this value will be empty.
	Token                string   `protobuf:"bytes,2,opt,name=token,proto3" json:"token,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

func (m *NodeExecutionList) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_NodeExecutionList.Unmarshal(m, b)
}
func (m *NodeExecutionList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_NodeExecutionList.Marshal(b, m, deterministic)
}
func (m *NodeExecutionList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NodeExecutionList.Merge(m, src)
}
func (m *NodeExecutionList) XXX_Size() int {
	return xxx_messageInfo_NodeExecutionList.Size(m)
}
func (m *NodeExecutionList) XXX_DiscardUnknown() {
	xxx_messageInfo_NodeExecutionList.DiscardUnknown(m)
}

var xxx_messageInfo_NodeExecutionList proto.InternalMessageInfo

func (m *NodeExecutionList) GetNodeExecutions() []*NodeExecution {
	if m != nil {
		return m.NodeExecutions
	}
	return nil
}

func (m *NodeExecutionList) GetToken() string {
	if m != nil {
		return m.Token
	}
	return ""
}

// Container for node execution details and results.
type NodeExecutionClosure struct {
	// Only a node in a terminal state will have a non-empty output_result.
	//
	// Types that are valid to be assigned to OutputResult:
	//	*NodeExecutionClosure_OutputUri
	//	*NodeExecutionClosure_Error
	OutputResult isNodeExecutionClosure_OutputResult `protobuf_oneof:"output_result"`
	// The last recorded phase for this node execution.
	Phase core.NodeExecution_Phase `protobuf:"varint,3,opt,name=phase,proto3,enum=flyteidl.core.NodeExecution_Phase" json:"phase,omitempty"`
	// Time at which the node execution began running.
	StartedAt *timestamp.Timestamp `protobuf:"bytes,4,opt,name=started_at,json=startedAt,proto3" json:"started_at,omitempty"`
	// The amount of time the node execution spent running.
	Duration *duration.Duration `protobuf:"bytes,5,opt,name=duration,proto3" json:"duration,omitempty"`
	// Time at which the node execution was created.
	CreatedAt *timestamp.Timestamp `protobuf:"bytes,6,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	// Time at which the node execution was last updated.
	UpdatedAt *timestamp.Timestamp `protobuf:"bytes,7,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"`
	// Store metadata for what the node launched.
	// for ex: if this is a workflow node, we store information for the launched workflow.
	//
	// Types that are valid to be assigned to TargetMetadata:
	//	*NodeExecutionClosure_WorkflowNodeMetadata
	TargetMetadata       isNodeExecutionClosure_TargetMetadata `protobuf_oneof:"target_metadata"`
	XXX_NoUnkeyedLiteral struct{}                              `json:"-"`
	XXX_unrecognized     []byte                                `json:"-"`
	XXX_sizecache        int32                                 `json:"-"`
}

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

func (m *NodeExecutionClosure) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_NodeExecutionClosure.Unmarshal(m, b)
}
func (m *NodeExecutionClosure) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_NodeExecutionClosure.Marshal(b, m, deterministic)
}
func (m *NodeExecutionClosure) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NodeExecutionClosure.Merge(m, src)
}
func (m *NodeExecutionClosure) XXX_Size() int {
	return xxx_messageInfo_NodeExecutionClosure.Size(m)
}
func (m *NodeExecutionClosure) XXX_DiscardUnknown() {
	xxx_messageInfo_NodeExecutionClosure.DiscardUnknown(m)
}

var xxx_messageInfo_NodeExecutionClosure proto.InternalMessageInfo

type isNodeExecutionClosure_OutputResult interface {
	isNodeExecutionClosure_OutputResult()
}

type NodeExecutionClosure_OutputUri struct {
	OutputUri string `protobuf:"bytes,1,opt,name=output_uri,json=outputUri,proto3,oneof"`
}

type NodeExecutionClosure_Error struct {
	Error *core.ExecutionError `protobuf:"bytes,2,opt,name=error,proto3,oneof"`
}

func (*NodeExecutionClosure_OutputUri) isNodeExecutionClosure_OutputResult() {}

func (*NodeExecutionClosure_Error) isNodeExecutionClosure_OutputResult() {}

func (m *NodeExecutionClosure) GetOutputResult() isNodeExecutionClosure_OutputResult {
	if m != nil {
		return m.OutputResult
	}
	return nil
}

func (m *NodeExecutionClosure) GetOutputUri() string {
	if x, ok := m.GetOutputResult().(*NodeExecutionClosure_OutputUri); ok {
		return x.OutputUri
	}
	return ""
}

func (m *NodeExecutionClosure) GetError() *core.ExecutionError {
	if x, ok := m.GetOutputResult().(*NodeExecutionClosure_Error); ok {
		return x.Error
	}
	return nil
}

func (m *NodeExecutionClosure) GetPhase() core.NodeExecution_Phase {
	if m != nil {
		return m.Phase
	}
	return core.NodeExecution_UNDEFINED
}

func (m *NodeExecutionClosure) GetStartedAt() *timestamp.Timestamp {
	if m != nil {
		return m.StartedAt
	}
	return nil
}

func (m *NodeExecutionClosure) GetDuration() *duration.Duration {
	if m != nil {
		return m.Duration
	}
	return nil
}

func (m *NodeExecutionClosure) GetCreatedAt() *timestamp.Timestamp {
	if m != nil {
		return m.CreatedAt
	}
	return nil
}

func (m *NodeExecutionClosure) GetUpdatedAt() *timestamp.Timestamp {
	if m != nil {
		return m.UpdatedAt
	}
	return nil
}

type isNodeExecutionClosure_TargetMetadata interface {
	isNodeExecutionClosure_TargetMetadata()
}

type NodeExecutionClosure_WorkflowNodeMetadata struct {
	WorkflowNodeMetadata *WorkflowNodeMetadata `protobuf:"bytes,8,opt,name=workflow_node_metadata,json=workflowNodeMetadata,proto3,oneof"`
}

func (*NodeExecutionClosure_WorkflowNodeMetadata) isNodeExecutionClosure_TargetMetadata() {}

func (m *NodeExecutionClosure) GetTargetMetadata() isNodeExecutionClosure_TargetMetadata {
	if m != nil {
		return m.TargetMetadata
	}
	return nil
}

func (m *NodeExecutionClosure) GetWorkflowNodeMetadata() *WorkflowNodeMetadata {
	if x, ok := m.GetTargetMetadata().(*NodeExecutionClosure_WorkflowNodeMetadata); ok {
		return x.WorkflowNodeMetadata
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*NodeExecutionClosure) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*NodeExecutionClosure_OutputUri)(nil),
		(*NodeExecutionClosure_Error)(nil),
		(*NodeExecutionClosure_WorkflowNodeMetadata)(nil),
	}
}

// Metadata for a WorkflowNode
type WorkflowNodeMetadata struct {
	ExecutionId          *core.WorkflowExecutionIdentifier `protobuf:"bytes,1,opt,name=executionId,proto3" json:"executionId,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                          `json:"-"`
	XXX_unrecognized     []byte                            `json:"-"`
	XXX_sizecache        int32                             `json:"-"`
}

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

func (m *WorkflowNodeMetadata) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_WorkflowNodeMetadata.Unmarshal(m, b)
}
func (m *WorkflowNodeMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_WorkflowNodeMetadata.Marshal(b, m, deterministic)
}
func (m *WorkflowNodeMetadata) XXX_Merge(src proto.Message) {
	xxx_messageInfo_WorkflowNodeMetadata.Merge(m, src)
}
func (m *WorkflowNodeMetadata) XXX_Size() int {
	return xxx_messageInfo_WorkflowNodeMetadata.Size(m)
}
func (m *WorkflowNodeMetadata) XXX_DiscardUnknown() {
	xxx_messageInfo_WorkflowNodeMetadata.DiscardUnknown(m)
}

var xxx_messageInfo_WorkflowNodeMetadata proto.InternalMessageInfo

func (m *WorkflowNodeMetadata) GetExecutionId() *core.WorkflowExecutionIdentifier {
	if m != nil {
		return m.ExecutionId
	}
	return nil
}

// Request structure to fetch inputs and output urls for a node execution.
type NodeExecutionGetDataRequest struct {
	// The identifier of the node execution for which to fetch inputs and outputs.
	Id                   *core.NodeExecutionIdentifier `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                      `json:"-"`
	XXX_unrecognized     []byte                        `json:"-"`
	XXX_sizecache        int32                         `json:"-"`
}

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

func (m *NodeExecutionGetDataRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_NodeExecutionGetDataRequest.Unmarshal(m, b)
}
func (m *NodeExecutionGetDataRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_NodeExecutionGetDataRequest.Marshal(b, m, deterministic)
}
func (m *NodeExecutionGetDataRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NodeExecutionGetDataRequest.Merge(m, src)
}
func (m *NodeExecutionGetDataRequest) XXX_Size() int {
	return xxx_messageInfo_NodeExecutionGetDataRequest.Size(m)
}
func (m *NodeExecutionGetDataRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_NodeExecutionGetDataRequest.DiscardUnknown(m)
}

var xxx_messageInfo_NodeExecutionGetDataRequest proto.InternalMessageInfo

func (m *NodeExecutionGetDataRequest) GetId() *core.NodeExecutionIdentifier {
	if m != nil {
		return m.Id
	}
	return nil
}

// Response structure for NodeExecutionGetDataRequest which contains inputs and outputs for a node execution.
type NodeExecutionGetDataResponse struct {
	// Signed url to fetch a core.LiteralMap of node execution inputs.
	Inputs *UrlBlob `protobuf:"bytes,1,opt,name=inputs,proto3" json:"inputs,omitempty"`
	// Signed url to fetch a core.LiteralMap of node execution outputs.
	Outputs              *UrlBlob `protobuf:"bytes,2,opt,name=outputs,proto3" json:"outputs,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

func (m *NodeExecutionGetDataResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_NodeExecutionGetDataResponse.Unmarshal(m, b)
}
func (m *NodeExecutionGetDataResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_NodeExecutionGetDataResponse.Marshal(b, m, deterministic)
}
func (m *NodeExecutionGetDataResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NodeExecutionGetDataResponse.Merge(m, src)
}
func (m *NodeExecutionGetDataResponse) XXX_Size() int {
	return xxx_messageInfo_NodeExecutionGetDataResponse.Size(m)
}
func (m *NodeExecutionGetDataResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_NodeExecutionGetDataResponse.DiscardUnknown(m)
}

var xxx_messageInfo_NodeExecutionGetDataResponse proto.InternalMessageInfo

func (m *NodeExecutionGetDataResponse) GetInputs() *UrlBlob {
	if m != nil {
		return m.Inputs
	}
	return nil
}

func (m *NodeExecutionGetDataResponse) GetOutputs() *UrlBlob {
	if m != nil {
		return m.Outputs
	}
	return nil
}

func init() {
	proto.RegisterType((*NodeExecutionGetRequest)(nil), "flyteidl.admin.NodeExecutionGetRequest")
	proto.RegisterType((*NodeExecutionListRequest)(nil), "flyteidl.admin.NodeExecutionListRequest")
	proto.RegisterType((*NodeExecutionForTaskListRequest)(nil), "flyteidl.admin.NodeExecutionForTaskListRequest")
	proto.RegisterType((*NodeExecution)(nil), "flyteidl.admin.NodeExecution")
	proto.RegisterType((*NodeExecutionList)(nil), "flyteidl.admin.NodeExecutionList")
	proto.RegisterType((*NodeExecutionClosure)(nil), "flyteidl.admin.NodeExecutionClosure")
	proto.RegisterType((*WorkflowNodeMetadata)(nil), "flyteidl.admin.WorkflowNodeMetadata")
	proto.RegisterType((*NodeExecutionGetDataRequest)(nil), "flyteidl.admin.NodeExecutionGetDataRequest")
	proto.RegisterType((*NodeExecutionGetDataResponse)(nil), "flyteidl.admin.NodeExecutionGetDataResponse")
}

func init() {
	proto.RegisterFile("flyteidl/admin/node_execution.proto", fileDescriptor_f73b3eae493fd736)
}

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