node_execution.pb.go

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

package admin

import (
	fmt "fmt"
	core "github.com/flyteorg/flyteidl/gen/pb-go/flyteidl/core"
	proto "github.com/golang/protobuf/proto"
	duration "github.com/golang/protobuf/ptypes/duration"
	timestamp "github.com/golang/protobuf/ptypes/timestamp"
	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.
// See :ref:`ref_flyteidl.admin.NodeExecution` for more details
type NodeExecutionGetRequest struct {
	// Uniquely identifies an individual node execution.
	// +required
	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.
// See :ref:`ref_flyteidl.admin.NodeExecution` for more details
type NodeExecutionListRequest struct {
	// Indicates the workflow execution to filter by.
	// +required
	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.
	// +required
	Limit uint32 `protobuf:"varint,2,opt,name=limit,proto3" json:"limit,omitempty"`
	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"`
	// Unique identifier of the parent node in the execution
	// +optional
	UniqueParentId       string   `protobuf:"bytes,6,opt,name=unique_parent_id,json=uniqueParentId,proto3" json:"unique_parent_id,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
}

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

// Represents a request structure to retrieve a list of node execution entities launched by a specific task.
// This can arise when a task yields a subworkflow.
type NodeExecutionForTaskListRequest struct {
	// Indicates the node execution to filter by.
	// +required
	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.
	// +required
	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"`
	// Metadata for Node Execution
	Metadata             *NodeExecutionMetaData `protobuf:"bytes,4,opt,name=metadata,proto3" json:"metadata,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
}

func (m *NodeExecution) GetMetadata() *NodeExecutionMetaData {
	if m != nil {
		return m.Metadata
	}
	return nil
}

// Represents additional attributes related to a Node Execution
type NodeExecutionMetaData struct {
	// Node executions are grouped depending on retries of the parent
	// Retry group is unique within the context of a parent node.
	RetryGroup string `protobuf:"bytes,1,opt,name=retry_group,json=retryGroup,proto3" json:"retry_group,omitempty"`
	// Boolean flag indicating if the node has child nodes under it
	// This can be true when a node contains a dynamic workflow which then produces
	// child nodes.
	IsParentNode bool `protobuf:"varint,2,opt,name=is_parent_node,json=isParentNode,proto3" json:"is_parent_node,omitempty"`
	// Node id of the node in the original workflow
	// This maps to value of WorkflowTemplate.nodes[X].id
	SpecNodeId string `protobuf:"bytes,3,opt,name=spec_node_id,json=specNodeId,proto3" json:"spec_node_id,omitempty"`
	// Boolean flag indicating if the node has contains a dynamic workflow which then produces child nodes.
	// This is to distinguish between subworkflows and dynamic workflows which can both have is_parent_node as true.
	IsDynamic            bool     `protobuf:"varint,4,opt,name=is_dynamic,json=isDynamic,proto3" json:"is_dynamic,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_NodeExecutionMetaData proto.InternalMessageInfo

func (m *NodeExecutionMetaData) GetRetryGroup() string {
	if m != nil {
		return m.RetryGroup
	}
	return ""
}

func (m *NodeExecutionMetaData) GetIsParentNode() bool {
	if m != nil {
		return m.IsParentNode
	}
	return false
}

func (m *NodeExecutionMetaData) GetSpecNodeId() string {
	if m != nil {
		return m.SpecNodeId
	}
	return ""
}

func (m *NodeExecutionMetaData) GetIsDynamic() bool {
	if m != nil {
		return m.IsDynamic
	}
	return false
}

// Request structure to retrieve a list of node execution entities.
// See :ref:`ref_flyteidl.admin.NodeExecution` for more details
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{5}
}

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
	//	*NodeExecutionClosure_OutputData
	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
	//	*NodeExecutionClosure_TaskNodeMetadata
	TargetMetadata isNodeExecutionClosure_TargetMetadata `protobuf_oneof:"target_metadata"`
	// String location uniquely identifying where the deck HTML file is.
	// NativeUrl specifies the url in the format of the configured storage provider (e.g. s3://my-bucket/randomstring/suffix.tar)
	DeckUri              string   `protobuf:"bytes,11,opt,name=deck_uri,json=deckUri,proto3" json:"deck_uri,omitempty"`
	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{6}
}

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"`
}

type NodeExecutionClosure_OutputData struct {
	OutputData *core.LiteralMap `protobuf:"bytes,10,opt,name=output_data,json=outputData,proto3,oneof"`
}

func (*NodeExecutionClosure_OutputUri) isNodeExecutionClosure_OutputResult() {}

func (*NodeExecutionClosure_Error) isNodeExecutionClosure_OutputResult() {}

func (*NodeExecutionClosure_OutputData) isNodeExecutionClosure_OutputResult() {}

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

// Deprecated: Do not use.
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
}

// Deprecated: Do not use.
func (m *NodeExecutionClosure) GetOutputData() *core.LiteralMap {
	if x, ok := m.GetOutputResult().(*NodeExecutionClosure_OutputData); ok {
		return x.OutputData
	}
	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"`
}

type NodeExecutionClosure_TaskNodeMetadata struct {
	TaskNodeMetadata *TaskNodeMetadata `protobuf:"bytes,9,opt,name=task_node_metadata,json=taskNodeMetadata,proto3,oneof"`
}

func (*NodeExecutionClosure_WorkflowNodeMetadata) isNodeExecutionClosure_TargetMetadata() {}

func (*NodeExecutionClosure_TaskNodeMetadata) 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
}

func (m *NodeExecutionClosure) GetTaskNodeMetadata() *TaskNodeMetadata {
	if x, ok := m.GetTargetMetadata().(*NodeExecutionClosure_TaskNodeMetadata); ok {
		return x.TaskNodeMetadata
	}
	return nil
}

func (m *NodeExecutionClosure) GetDeckUri() string {
	if m != nil {
		return m.DeckUri
	}
	return ""
}

// 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_OutputData)(nil),
		(*NodeExecutionClosure_WorkflowNodeMetadata)(nil),
		(*NodeExecutionClosure_TaskNodeMetadata)(nil),
	}
}

// Metadata for a WorkflowNode
type WorkflowNodeMetadata struct {
	// The identifier for a workflow execution launched by a node.
	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{7}
}

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
}

// Metadata for the case in which the node is a TaskNode
type TaskNodeMetadata struct {
	// Captures the status of caching for this execution.
	CacheStatus core.CatalogCacheStatus `protobuf:"varint,1,opt,name=cache_status,json=cacheStatus,proto3,enum=flyteidl.core.CatalogCacheStatus" json:"cache_status,omitempty"`
	// This structure carries the catalog artifact information
	CatalogKey *core.CatalogMetadata `protobuf:"bytes,2,opt,name=catalog_key,json=catalogKey,proto3" json:"catalog_key,omitempty"`
	// The latest checkpoint location
	CheckpointUri        string   `protobuf:"bytes,4,opt,name=checkpoint_uri,json=checkpointUri,proto3" json:"checkpoint_uri,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_TaskNodeMetadata proto.InternalMessageInfo

func (m *TaskNodeMetadata) GetCacheStatus() core.CatalogCacheStatus {
	if m != nil {
		return m.CacheStatus
	}
	return core.CatalogCacheStatus_CACHE_DISABLED
}

func (m *TaskNodeMetadata) GetCatalogKey() *core.CatalogMetadata {
	if m != nil {
		return m.CatalogKey
	}
	return nil
}

func (m *TaskNodeMetadata) GetCheckpointUri() string {
	if m != nil {
		return m.CheckpointUri
	}
	return ""
}

// For dynamic workflow nodes we capture information about the dynamic workflow definition that gets generated.
type DynamicWorkflowNodeMetadata struct {
	// id represents the unique identifier of the workflow.
	Id *core.Identifier `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// Represents the compiled representation of the embedded dynamic workflow.
	CompiledWorkflow     *core.CompiledWorkflowClosure `protobuf:"bytes,2,opt,name=compiled_workflow,json=compiledWorkflow,proto3" json:"compiled_workflow,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                      `json:"-"`
	XXX_unrecognized     []byte                        `json:"-"`
	XXX_sizecache        int32                         `json:"-"`
}

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

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

var xxx_messageInfo_DynamicWorkflowNodeMetadata proto.InternalMessageInfo

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

func (m *DynamicWorkflowNodeMetadata) GetCompiledWorkflow() *core.CompiledWorkflowClosure {
	if m != nil {
		return m.CompiledWorkflow
	}
	return nil
}

// Request structure to fetch inputs and output for a node execution.
// By default, these are not returned in :ref:`ref_flyteidl.admin.NodeExecutionGetRequest`
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{10}
}

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.
	// Deprecated: Please use full_inputs instead.
	Inputs *UrlBlob `protobuf:"bytes,1,opt,name=inputs,proto3" json:"inputs,omitempty"` // Deprecated: Do not use.
	// Signed url to fetch a core.LiteralMap of node execution outputs.
	// Deprecated: Please use full_outputs instead.
	Outputs *UrlBlob `protobuf:"bytes,2,opt,name=outputs,proto3" json:"outputs,omitempty"` // Deprecated: Do not use.
	// Full_inputs will only be populated if they are under a configured size threshold.
	FullInputs *core.LiteralMap `protobuf:"bytes,3,opt,name=full_inputs,json=fullInputs,proto3" json:"full_inputs,omitempty"`
	// Full_outputs will only be populated if they are under a configured size threshold.
	FullOutputs *core.LiteralMap `protobuf:"bytes,4,opt,name=full_outputs,json=fullOutputs,proto3" json:"full_outputs,omitempty"`
	// Optional Workflow closure for a dynamically generated workflow, in the case this node yields a dynamic workflow we return its structure here.
	DynamicWorkflow      *DynamicWorkflowNodeMetadata `protobuf:"bytes,16,opt,name=dynamic_workflow,json=dynamicWorkflow,proto3" json:"dynamic_workflow,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{11}
}

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

// Deprecated: Do not use.
func (m *NodeExecutionGetDataResponse) GetInputs() *UrlBlob {
	if m != nil {
		return m.Inputs
	}
	return nil
}

// Deprecated: Do not use.
func (m *NodeExecutionGetDataResponse) GetOutputs() *UrlBlob {
	if m != nil {
		return m.Outputs
	}
	return nil
}

func (m *NodeExecutionGetDataResponse) GetFullInputs() *core.LiteralMap {
	if m != nil {
		return m.FullInputs
	}
	return nil
}

func (m *NodeExecutionGetDataResponse) GetFullOutputs() *core.LiteralMap {
	if m != nil {
		return m.FullOutputs
	}
	return nil
}

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