core

type Alias struct {

	// Must match one of the output variable names on a node.
	Var string `protobuf:"bytes,1,opt,name=var,proto3" json:"var,omitempty"`
	// A workflow-level unique alias that downstream nodes can refer to in their input.
	Alias string `protobuf:"bytes,2,opt,name=alias,proto3" json:"alias,omitempty"`
	// contains filtered or unexported fields
}

type ApproveCondition struct {

	// A unique identifier for the requested boolean signal.
	SignalId string `protobuf:"bytes,1,opt,name=signal_id,json=signalId,proto3" json:"signal_id,omitempty"`
	// contains filtered or unexported fields
}

type ArrayNode struct {

	// node is the sub-node that will be executed for each element in the array.
	Node *Node `protobuf:"bytes,1,opt,name=node,proto3" json:"node,omitempty"`
	// parallelism defines the minimum number of instances to bring up concurrently at any given
	// point. Note that this is an optimistic restriction and that, due to network partitioning or
	// other failures, the actual number of currently running instances might be more. This has to
	// be a positive number if assigned. Default value is size.
	Parallelism uint32 `protobuf:"varint,2,opt,name=parallelism,proto3" json:"parallelism,omitempty"`
	// Types that are assignable to SuccessCriteria:
	//
	//	*ArrayNode_MinSuccesses
	//	*ArrayNode_MinSuccessRatio
	SuccessCriteria isArrayNode_SuccessCriteria `protobuf_oneof:"success_criteria"`
	// contains filtered or unexported fields
}

type ArrayNode_MinSuccessRatio struct {
	// If the array job size is not known beforehand, the min_success_ratio can instead be used
	// to determine when an ArrayNode can be marked successful.
	MinSuccessRatio float32 `protobuf:"fixed32,4,opt,name=min_success_ratio,json=minSuccessRatio,proto3,oneof"`
}

type ArrayNode_MinSuccesses struct {
	// min_successes is an absolute number of the minimum number of successful completions of
	// sub-nodes. As soon as this criteria is met, the ArrayNode will be marked as successful
	// and outputs will be computed. This has to be a non-negative number if assigned. Default
	// value is size (if specified).
	MinSuccesses uint32 `protobuf:"varint,3,opt,name=min_successes,json=minSuccesses,proto3,oneof"`
}

type ArtifactBindingData struct {
	Index uint32 `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"`
	// These two fields are only relevant in the partition value case
	//
	// Types that are assignable to PartitionData:
	//
	//	*ArtifactBindingData_PartitionKey
	//	*ArtifactBindingData_BindToTimePartition
	PartitionData isArtifactBindingData_PartitionData `protobuf_oneof:"partition_data"`
	// This is only relevant in the time partition case
	Transform string `protobuf:"bytes,4,opt,name=transform,proto3" json:"transform,omitempty"`
	// contains filtered or unexported fields
}

type ArtifactBindingData_BindToTimePartition struct {
	BindToTimePartition bool `protobuf:"varint,3,opt,name=bind_to_time_partition,json=bindToTimePartition,proto3,oneof"`
}

type ArtifactBindingData_PartitionKey struct {
	PartitionKey string `protobuf:"bytes,2,opt,name=partition_key,json=partitionKey,proto3,oneof"`
}

type ArtifactID struct {
	ArtifactKey *ArtifactKey `protobuf:"bytes,1,opt,name=artifact_key,json=artifactKey,proto3" json:"artifact_key,omitempty"`
	Version     string       `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"`
	// Think of a partition as a tag on an Artifact, except it's a key-value pair.
	// Different partitions naturally have different versions (execution ids).
	Partitions *Partitions `protobuf:"bytes,3,opt,name=partitions,proto3" json:"partitions,omitempty"`
	// There is no such thing as an empty time partition - if it's not set, then there is no time partition.
	TimePartition *TimePartition `protobuf:"bytes,4,opt,name=time_partition,json=timePartition,proto3" json:"time_partition,omitempty"`
	// contains filtered or unexported fields
}

type ArtifactKey struct {

	// Project and domain and suffix needs to be unique across a given artifact store.
	Project string `protobuf:"bytes,1,opt,name=project,proto3" json:"project,omitempty"`
	Domain  string `protobuf:"bytes,2,opt,name=domain,proto3" json:"domain,omitempty"`
	Name    string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
	Org     string `protobuf:"bytes,4,opt,name=org,proto3" json:"org,omitempty"`
	// contains filtered or unexported fields
}

type ArtifactQuery struct {

	// Types that are assignable to Identifier:
	//
	//	*ArtifactQuery_ArtifactId
	//	*ArtifactQuery_ArtifactTag
	//	*ArtifactQuery_Uri
	//	*ArtifactQuery_Binding
	Identifier isArtifactQuery_Identifier `protobuf_oneof:"identifier"`
	// contains filtered or unexported fields
}

type ArtifactQuery_ArtifactId struct {
	ArtifactId *ArtifactID `protobuf:"bytes,1,opt,name=artifact_id,json=artifactId,proto3,oneof"`
}

type ArtifactQuery_ArtifactTag struct {
	ArtifactTag *ArtifactTag `protobuf:"bytes,2,opt,name=artifact_tag,json=artifactTag,proto3,oneof"`
}

type ArtifactQuery_Binding struct {
	// This is used in the trigger case, where a user specifies a value for an input that is one of the triggering
	// artifacts, or a partition value derived from a triggering artifact.
	Binding *ArtifactBindingData `protobuf:"bytes,4,opt,name=binding,proto3,oneof"`
}

type ArtifactQuery_Uri struct {
	Uri string `protobuf:"bytes,3,opt,name=uri,proto3,oneof"`
}

type ArtifactTag struct {
	ArtifactKey *ArtifactKey `protobuf:"bytes,1,opt,name=artifact_key,json=artifactKey,proto3" json:"artifact_key,omitempty"`
	Value       *LabelValue  `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	// contains filtered or unexported fields
}

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"`
	// contains filtered or unexported fields
}

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"`
	// contains filtered or unexported fields
}

type BindingData struct {

	// Types that are assignable to Value:
	//
	//	*BindingData_Scalar
	//	*BindingData_Collection
	//	*BindingData_Promise
	//	*BindingData_Map
	Value isBindingData_Value `protobuf_oneof:"value"`
	Union *UnionInfo          `protobuf:"bytes,5,opt,name=union,proto3" json:"union,omitempty"`
	// contains filtered or unexported fields
}

type BindingDataCollection struct {
	Bindings []*BindingData `protobuf:"bytes,1,rep,name=bindings,proto3" json:"bindings,omitempty"`
	// contains filtered or unexported fields
}

type BindingDataMap struct {
	Bindings map[string]*BindingData `` /* 157-byte string literal not displayed */
	// contains filtered or unexported fields
}

type BindingData_Collection struct {
	// A collection of binding data. This allows nesting of binding data to any number
	// of levels.
	Collection *BindingDataCollection `protobuf:"bytes,2,opt,name=collection,proto3,oneof"`
}

type BindingData_Map struct {
	// A map of bindings. The key is always a string.
	Map *BindingDataMap `protobuf:"bytes,4,opt,name=map,proto3,oneof"`
}

type BindingData_Promise struct {
	// References an output promised by another node.
	Promise *OutputReference `protobuf:"bytes,3,opt,name=promise,proto3,oneof"`
}

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

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"`
	// contains filtered or unexported fields
}

type BlobMetadata struct {
	Type *BlobType `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`
	// contains filtered or unexported fields
}

type BlobType struct {

	// Format can be a free form string understood by SDK/UI etc like
	// csv, parquet etc
	Format         string                      `protobuf:"bytes,1,opt,name=format,proto3" json:"format,omitempty"`
	Dimensionality BlobType_BlobDimensionality `` /* 129-byte string literal not displayed */
	// contains filtered or unexported fields
}

type BlobType_BlobDimensionality int32

type BooleanExpression struct {

	// Types that are assignable to Expr:
	//
	//	*BooleanExpression_Conjunction
	//	*BooleanExpression_Comparison
	Expr isBooleanExpression_Expr `protobuf_oneof:"expr"`
	// contains filtered or unexported fields
}

type BooleanExpression_Comparison struct {
	Comparison *ComparisonExpression `protobuf:"bytes,2,opt,name=comparison,proto3,oneof"`
}

type BooleanExpression_Conjunction struct {
	Conjunction *ConjunctionExpression `protobuf:"bytes,1,opt,name=conjunction,proto3,oneof"`
}

type BranchNode struct {

	// +required
	IfElse *IfElseBlock `protobuf:"bytes,1,opt,name=if_else,json=ifElse,proto3" json:"if_else,omitempty"`
	// contains filtered or unexported fields
}

type CatalogArtifactTag struct {

	// Artifact ID is generated name
	ArtifactId string `protobuf:"bytes,1,opt,name=artifact_id,json=artifactId,proto3" json:"artifact_id,omitempty"`
	// Kozmo computes the tag automatically, as the hash of the values
	Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	// contains filtered or unexported fields
}

type CatalogCacheStatus int32

type CatalogMetadata struct {

	// Dataset ID in the catalog
	DatasetId *Identifier `protobuf:"bytes,1,opt,name=dataset_id,json=datasetId,proto3" json:"dataset_id,omitempty"`
	// Artifact tag in the catalog
	ArtifactTag *CatalogArtifactTag `protobuf:"bytes,2,opt,name=artifact_tag,json=artifactTag,proto3" json:"artifact_tag,omitempty"`
	// Optional: Source Execution identifier, if this dataset was generated by another execution in Kozmo. This is a one-of field and will depend on the caching context
	//
	// Types that are assignable to SourceExecution:
	//
	//	*CatalogMetadata_SourceTaskExecution
	SourceExecution isCatalogMetadata_SourceExecution `protobuf_oneof:"source_execution"`
	// contains filtered or unexported fields
}

type CatalogMetadata_SourceTaskExecution struct {
	// Today we only support TaskExecutionIdentifier as a source, as catalog caching only works for task executions
	SourceTaskExecution *TaskExecutionIdentifier `protobuf:"bytes,3,opt,name=source_task_execution,json=sourceTaskExecution,proto3,oneof"`
}

type CatalogReservation struct {
	// contains filtered or unexported fields
}

type CatalogReservation_Status int32

type ComparisonExpression struct {
	Operator   ComparisonExpression_Operator `protobuf:"varint,1,opt,name=operator,proto3,enum=kozmoidl.core.ComparisonExpression_Operator" json:"operator,omitempty"`
	LeftValue  *Operand                      `protobuf:"bytes,2,opt,name=left_value,json=leftValue,proto3" json:"left_value,omitempty"`
	RightValue *Operand                      `protobuf:"bytes,3,opt,name=right_value,json=rightValue,proto3" json:"right_value,omitempty"`
	// contains filtered or unexported fields
}

type ComparisonExpression_Operator int32

type CompiledLaunchPlan struct {

	// Completely contained LaunchPlan Template
	Template *LaunchPlanTemplate `protobuf:"bytes,1,opt,name=template,proto3" json:"template,omitempty"`
	// contains filtered or unexported fields
}

type CompiledTask struct {

	// Completely contained TaskTemplate
	Template *TaskTemplate `protobuf:"bytes,1,opt,name=template,proto3" json:"template,omitempty"`
	// contains filtered or unexported fields
}

type CompiledWorkflow struct {

	// Completely contained Workflow Template
	Template *WorkflowTemplate `protobuf:"bytes,1,opt,name=template,proto3" json:"template,omitempty"`
	// For internal use only! This field is used by the system and must not be filled in. Any values set will be ignored.
	Connections *ConnectionSet `protobuf:"bytes,2,opt,name=connections,proto3" json:"connections,omitempty"`
	// contains filtered or unexported fields
}

type CompiledWorkflowClosure struct {

	// +required
	Primary *CompiledWorkflow `protobuf:"bytes,1,opt,name=primary,proto3" json:"primary,omitempty"`
	// Guaranteed that there will only exist one and only one workflow with a given id, i.e., every sub workflow has a
	// unique identifier. Also every enclosed subworkflow is used either by a primary workflow or by a subworkflow
	// as an inlined workflow
	// +optional
	SubWorkflows []*CompiledWorkflow `protobuf:"bytes,2,rep,name=sub_workflows,json=subWorkflows,proto3" json:"sub_workflows,omitempty"`
	// Guaranteed that there will only exist one and only one task with a given id, i.e., every task has a unique id
	// +required (at least 1)
	Tasks []*CompiledTask `protobuf:"bytes,3,rep,name=tasks,proto3" json:"tasks,omitempty"`
	// A collection of launch plans that are compiled. Guaranteed that there will only exist one and only one launch plan
	// with a given id, i.e., every launch plan has a unique id.
	LaunchPlans []*CompiledLaunchPlan `protobuf:"bytes,4,rep,name=launch_plans,json=launchPlans,proto3" json:"launch_plans,omitempty"`
	// contains filtered or unexported fields
}

type ConjunctionExpression struct {
	Operator        ConjunctionExpression_LogicalOperator `` /* 127-byte string literal not displayed */
	LeftExpression  *BooleanExpression                    `protobuf:"bytes,2,opt,name=left_expression,json=leftExpression,proto3" json:"left_expression,omitempty"`
	RightExpression *BooleanExpression                    `protobuf:"bytes,3,opt,name=right_expression,json=rightExpression,proto3" json:"right_expression,omitempty"`
	// contains filtered or unexported fields
}

type ConjunctionExpression_LogicalOperator int32

type ConnectionSet struct {

	// A list of all the node ids that are downstream from a given node id
	Downstream map[string]*ConnectionSet_IdList `` /* 161-byte string literal not displayed */
	// A list of all the node ids, that are upstream of this node id
	Upstream map[string]*ConnectionSet_IdList `` /* 157-byte string literal not displayed */
	// contains filtered or unexported fields
}

type ConnectionSet_IdList struct {
	Ids []string `protobuf:"bytes,1,rep,name=ids,proto3" json:"ids,omitempty"`
	// contains filtered or unexported fields
}

type Container struct {

	// Container image url. Eg: docker/redis:latest
	Image string `protobuf:"bytes,1,opt,name=image,proto3" json:"image,omitempty"`
	// Command to be executed, if not provided, the default entrypoint in the container image will be used.
	Command []string `protobuf:"bytes,2,rep,name=command,proto3" json:"command,omitempty"`
	// These will default to Kozmo given paths. If provided, the system will not append known paths. If the task still
	// needs kozmo's inputs and outputs path, add $(KOZMO_INPUT_FILE), $(KOZMO_OUTPUT_FILE) wherever makes sense and the
	// system will populate these before executing the container.
	Args []string `protobuf:"bytes,3,rep,name=args,proto3" json:"args,omitempty"`
	// Container resources requirement as specified by the container engine.
	Resources *Resources `protobuf:"bytes,4,opt,name=resources,proto3" json:"resources,omitempty"`
	// Environment variables will be set as the container is starting up.
	Env []*KeyValuePair `protobuf:"bytes,5,rep,name=env,proto3" json:"env,omitempty"`
	// Allows extra configs to be available for the container.
	// TODO: elaborate on how configs will become available.
	// Deprecated, please use TaskTemplate.config instead.
	//
	// Deprecated: Marked as deprecated in kozmoidl/core/tasks.proto.
	Config []*KeyValuePair `protobuf:"bytes,6,rep,name=config,proto3" json:"config,omitempty"`
	// Ports to open in the container. This feature is not supported by all execution engines. (e.g. supported on K8s but
	// not supported on AWS Batch)
	// Only K8s
	Ports []*ContainerPort `protobuf:"bytes,7,rep,name=ports,proto3" json:"ports,omitempty"`
	// BETA: Optional configuration for DataLoading. If not specified, then default values are used.
	// This makes it possible to to run a completely portable container, that uses inputs and outputs
	// only from the local file-system and without having any reference to kozmoidl. This is supported only on K8s at the moment.
	// If data loading is enabled, then data will be mounted in accompanying directories specified in the DataLoadingConfig. If the directories
	// are not specified, inputs will be mounted onto and outputs will be uploaded from a pre-determined file-system path. Refer to the documentation
	// to understand the default paths.
	// Only K8s
	DataConfig   *DataLoadingConfig     `protobuf:"bytes,9,opt,name=data_config,json=dataConfig,proto3" json:"data_config,omitempty"`
	Architecture Container_Architecture `protobuf:"varint,10,opt,name=architecture,proto3,enum=kozmoidl.core.Container_Architecture" json:"architecture,omitempty"`
	// contains filtered or unexported fields
}

type ContainerError struct {

	// A simplified code for errors, so that we can provide a glossary of all possible errors.
	Code string `protobuf:"bytes,1,opt,name=code,proto3" json:"code,omitempty"`
	// A detailed error message.
	Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	// An abstract error kind for this error. Defaults to Non_Recoverable if not specified.
	Kind ContainerError_Kind `protobuf:"varint,3,opt,name=kind,proto3,enum=kozmoidl.core.ContainerError_Kind" json:"kind,omitempty"`
	// Defines the origin of the error (system, user, unknown).
	Origin ExecutionError_ErrorKind `protobuf:"varint,4,opt,name=origin,proto3,enum=kozmoidl.core.ExecutionError_ErrorKind" json:"origin,omitempty"`
	// contains filtered or unexported fields
}

type ContainerError_Kind int32

type ContainerPort struct {

	// Number of port to expose on the pod's IP address.
	// This must be a valid port number, 0 < x < 65536.
	ContainerPort uint32 `protobuf:"varint,1,opt,name=container_port,json=containerPort,proto3" json:"container_port,omitempty"`
	// contains filtered or unexported fields
}

type Container_Architecture int32

type DataLoadingConfig struct {

	// Flag enables DataLoading Config. If this is not set, data loading will not be used!
	Enabled bool `protobuf:"varint,1,opt,name=enabled,proto3" json:"enabled,omitempty"`
	// File system path (start at root). This folder will contain all the inputs exploded to a separate file.
	// Example, if the input interface needs (x: int, y: blob, z: multipart_blob) and the input path is '/var/kozmo/inputs', then the file system will look like
	// /var/kozmo/inputs/inputs.<metadata format dependent -> .pb .json .yaml> -> Format as defined previously. The Blob and Multipart blob will reference local filesystem instead of remote locations
	// /var/kozmo/inputs/x -> X is a file that contains the value of x (integer) in string format
	// /var/kozmo/inputs/y -> Y is a file in Binary format
	// /var/kozmo/inputs/z/... -> Note Z itself is a directory
	// More information about the protocol - refer to docs #TODO reference docs here
	InputPath string `protobuf:"bytes,2,opt,name=input_path,json=inputPath,proto3" json:"input_path,omitempty"`
	// File system path (start at root). This folder should contain all the outputs for the task as individual files and/or an error text file
	OutputPath string `protobuf:"bytes,3,opt,name=output_path,json=outputPath,proto3" json:"output_path,omitempty"`
	// In the inputs folder, there will be an additional summary/metadata file that contains references to all files or inlined primitive values.
	// This format decides the actual encoding for the data. Refer to the encoding to understand the specifics of the contents and the encoding
	Format     DataLoadingConfig_LiteralMapFormat `protobuf:"varint,4,opt,name=format,proto3,enum=kozmoidl.core.DataLoadingConfig_LiteralMapFormat" json:"format,omitempty"`
	IoStrategy *IOStrategy                        `protobuf:"bytes,5,opt,name=io_strategy,json=ioStrategy,proto3" json:"io_strategy,omitempty"`
	// contains filtered or unexported fields
}

type DataLoadingConfig_LiteralMapFormat int32

type DynamicJobSpec struct {

	// A collection of nodes to execute.
	Nodes []*Node `protobuf:"bytes,1,rep,name=nodes,proto3" json:"nodes,omitempty"`
	// An absolute number of successful completions of nodes required to mark this job as succeeded. As soon as this
	// criteria is met, the dynamic job will be marked as successful and outputs will be computed. If this number
	// becomes impossible to reach (e.g. number of currently running tasks + number of already succeeded tasks <
	// min_successes) the task will be aborted immediately and marked as failed. The default value of this field, if not
	// specified, is the count of nodes repeated field.
	MinSuccesses int64 `protobuf:"varint,2,opt,name=min_successes,json=minSuccesses,proto3" json:"min_successes,omitempty"`
	// Describes how to bind the final output of the dynamic job from the outputs of executed nodes. The referenced ids
	// in bindings should have the generated id for the subtask.
	Outputs []*Binding `protobuf:"bytes,3,rep,name=outputs,proto3" json:"outputs,omitempty"`
	// [Optional] A complete list of task specs referenced in nodes.
	Tasks []*TaskTemplate `protobuf:"bytes,4,rep,name=tasks,proto3" json:"tasks,omitempty"`
	// [Optional] A complete list of task specs referenced in nodes.
	Subworkflows []*WorkflowTemplate `protobuf:"bytes,5,rep,name=subworkflows,proto3" json:"subworkflows,omitempty"`
	// contains filtered or unexported fields
}

type EnumType struct {

	// Predefined set of enum values.
	Values []string `protobuf:"bytes,1,rep,name=values,proto3" json:"values,omitempty"`
	// contains filtered or unexported fields
}

type Error struct {

	// The node id that threw the error.
	FailedNodeId string `protobuf:"bytes,1,opt,name=failed_node_id,json=failedNodeId,proto3" json:"failed_node_id,omitempty"`
	// Error message thrown.
	Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	// contains filtered or unexported fields
}