cueflow

type CacheDisabler interface {
	CacheDisabled() bool
}

type CanSkip interface {
	Skip() bool
}

type Checkpoint interface {
	AsCheckpoint() bool
}

type CueValueWrapper interface {
	CueValue() cue.Value
}

type Element[V any] struct {
	Key   string
	Value V
}

type FlowControl interface {
	FlowTask
	// contains filtered or unexported methods
}

type FlowControlImpl struct {
}

type FlowTask interface {
	// contains filtered or unexported methods
}

type OutputValuer interface {
	OutputValues() map[string]any
}

type ProcessReader interface {
	io.Reader

	Process(ctx context.Context) <-chan Progress
}

type ProcessWriter interface {
	io.Writer
	Process(ctx context.Context) <-chan Progress
}

type Progress struct {
	Current int64
	Total   int64
}

type ResultValuer interface {
	ResultValue() map[string]any
}

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

type Scope interface {
	Value() Value
	LookupPath(path cue.Path) Value
	FillPath(path cue.Path, value any) error
	Processed(path cue.Path) bool
	LookupResult(path cue.Path) (any, bool)
	RunTasks(ctx context.Context, optFns ...TaskOptionFunc) error
}

type StepRunner interface {
	Do(ctx context.Context) error
}

type Successor interface {
	Success() bool
}

type Task interface {
	Scope() Scope
	Name() string
	Path() cue.Path
	Deps() []cue.Path
	Value() Value
	Decode(inputs any) error
}

type TaskFactory interface {
	TaskRunnerResolver
	TaskImplRegister
	Sources(ctx context.Context) (filesystem.FileSystem, error)
}

type TaskFeedback interface {
	Done(err error)
}

type TaskImpl struct {
}

type TaskImplRegister interface {
	Register(t any)
}

type TaskOptionFunc = internal.OptionFunc

type TaskRunner interface {
	Path() cue.Path
	Underlying() any
	Run(ctx context.Context) error
}

type TaskRunnerFactory interface {
	New(task Task) (TaskRunner, error)
}

type TaskRunnerResolver interface {
	ResolveTaskRunner(task Task) (TaskRunner, error)
}

type TaskSetup interface {
	Setup() bool
}

type TaskUnmarshaler interface {
	UnmarshalTask(t Task) error
}

type Value interface {
	Path() cue.Path
	Pos() token.Pos

	Exists() bool
	LookupPath(p cue.Path) Value
	FillPath(p cue.Path, v any) Value

	Decode(target any) error
	Source(opts ...cue.Option) string
}

type WithScopeName interface {
	ScopeName(ctx context.Context) (string, error)
}