flow

type ApprovalPauseErr struct {
	StepID string
}

type ContinueAsNewErr struct {
	// StartFromStepIdx is the index to resume from. In the legacy conductor path
	// this is a step index; in the execute-flow signal path this is a group position.
	StartFromStepIdx int
}

type EagerStepGroupsResult struct {
	Workflow      *app.Workflow
	QueueSignalID string
}

type FlowStoppedErr struct {
	StepID           string
	Reason           string // "denied", "skipped-dependents"
	RetriesExhausted bool
}

type RerunInput struct {
	FlowID          string         `json:"flow_id" validate:"required"`
	StepID          string         `json:"step_id" validate:"required"`
	Operation       RerunOperation `json:"operation" validate:"required"`
	StalePlan       bool           `json:"stale_plan"`
	RePlanStepID    string         `json:"replan_step_id"`
	ContinueFromIdx int            `json:"continue_from_idx"`

	// AdditionalSkipStepIDs are extra steps to mark as skipped alongside the primary StepID.
	// Used when skipping a plan step to also skip the corresponding apply step.
	AdditionalSkipStepIDs []string `json:"additional_skip_step_ids,omitempty"`
}

type RerunOperation string

type StepConfig struct {
	GroupQueueName  string
	QueueName       string
	TargetQueueName string
	OwnerID         string
	OwnerType       string
}

type WorkflowConductor[DomainSignal eventloop.Signal] struct {
	Cfg        *internal.Config
	MW         tmetrics.Writer
	V          *validator.Validate
	EVClient   teventloop.Client
	Generators map[app.WorkflowType]WorkflowStepGenerator

	// ExecFnLegacy is called to actually execute the signal handler for a step.
	//
	// TODO(sdboyer) THIS IS A TEMPORARY HACK. Dispatching should be done within
	// the conductor itself.  However, we absolutely can't do it until we allow
	// certain concurrent behaviors in event loops, as it would deadlock when we
	// signal the same event loop that's running this workflow. It'll also be a
	// bit of awkward coupling to do it without totally predictable event loop
	// workflow IDs, but that's not a hard blocker.
	ExecFnLegacy func(workflow.Context, eventloop.EventLoopRequest, DomainSignal, app.WorkflowStep) error

	// ExecFn is called to execute a queue-signal-based step. Unlike ExecFnLegacy, it does not
	// require a generic DomainSignal or an EventLoopRequest — it operates directly on the
	// QueueSignal stored on the workflow step.
	ExecFn func(workflow.Context, *signaldb.SignalData, app.WorkflowStep) error

	// StepChildWorkflow controls whether QueueSignal-based steps are executed via the
	// execute-workflow-step signal. When true, each step is dispatched through its own
	// signal execution. Only applies to steps where QueueSignal != nil.
	StepChildWorkflow bool

	// StepQueueName is the queue where the execute-workflow-step signal itself runs
	// (e.g. "install-workflow-steps"). When StepChildWorkflow is true, each step's
	// full lifecycle is dispatched to this queue.
	StepQueueName string
	// StepTargetQueueName is the queue where the inner signal (the actual step signal)
	// gets enqueued for execution (e.g. "install-signals").
	StepTargetQueueName string
	StepOwnerID         string
	StepOwnerType       string
}

type WorkflowStepGenerator func(ctx workflow.Context, uf *app.Workflow) (*app.GenerateStepsResult, error)