bpmn

type ActionTransformer func(sequenceFlowId *schema.IdRef, action IAction) IAction

type ActiveBoundaryTrace struct {
	Start bool
	Node  schema.FlowNodeInterface
}

type ActiveListeningTrace struct {
	Node *schema.CatchEvent
}

type Activity interface {
	IFlowNode
	Type() ActivityType
	// Cancel initiates a cancellation of activity and returns a channel
	// that will signal a boolean (`true` if cancellation was successful,
	// `false` otherwise)
	Cancel() <-chan bool
}

type ActivityType string

type CancellationFlowNodeTrace struct {
	Node schema.FlowNodeInterface
}

type CancellationFlowTrace struct {
	FlowId id.Id
}

type CatchEvent struct {
	*Wiring
	// contains filtered or unexported fields
}

type CeaseFlowTrace struct {
	Process schema.Element
}

type CompleteAction struct{}

type CompletionTrace struct {
	Node schema.FlowNodeInterface
}

type Constructor = func(*Wiring) (node Activity, err error)

type DeterminationMadeTrace struct {
	Node schema.FlowNodeInterface
}

type DoOption func(*DoResponse)

type DoResponse struct {
	Context     context.Context
	DataObjects map[string]any
	Results     map[string]any
	Err         error
	HandlerCh   <-chan ErrHandler
}

type EndEvent struct {
	*Wiring
	// contains filtered or unexported fields
}

type ErrHandleMode int

type ErrHandler struct {
	Mode    ErrHandleMode
	Retries int32
}

type ErrorTrace struct {
	Error error
}

type EventBasedGateway struct {
	*Wiring
	// contains filtered or unexported fields
}

type EventObservedTrace struct {
	Node  *schema.CatchEvent
	Event event.IEvent
}

type ExclusiveGateway struct {
	*Wiring
	// contains filtered or unexported fields
}

type ExclusiveNoEffectiveSequenceFlows struct {
	*schema.ExclusiveGateway
}

type Flow interface {
	// Id returns flow's unique identifier
	Id() id.Id
	// SequenceFlow returns an inbound sequence flow this flow
	// is currently at.
	SequenceFlow() *SequenceFlow
}

type FlowAction struct {
	Response *FlowActionResponse

	SequenceFlows []*SequenceFlow
	// Index of sequence flows that should flow without
	// conditionExpression being evaluated
	UnconditionalFlows []int
	// The actions produced by the targets should be produced by
	// this function
	ActionTransformer ActionTransformer
	// If a supplied channel sends a function that returns true, the flow action
	// is to be terminated if it wasn't already
	Terminate Terminate
}

type FlowActionResponse struct {
	DataObjects map[string]data.IItem
	Variables   map[string]data.IItem
	Err         error
	Handler     <-chan ErrHandler
}

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

type FlowTrace struct {
	Source schema.FlowNodeInterface
	Flows  []Snapshot
}

type Harness struct {
	*Wiring
	// contains filtered or unexported fields
}

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

type IFlowNode interface {
	IOutgoing
	Element() schema.FlowNodeInterface
}

type IOutgoing interface {
	NextAction(flow Flow) chan IAction
}

type InclusiveGateway struct {
	*Wiring
	// contains filtered or unexported fields
}

type InclusiveNoEffectiveSequenceFlows struct {
	*schema.InclusiveGateway
}

type IncomingFlowProcessedTrace struct {
	Node *schema.ParallelGateway
	Flow Flow
}

type Instance struct {
	*Options
	// contains filtered or unexported fields
}

type InstanceTrace struct {
	InstanceId id.Id
	Trace      tracing.ITrace
}

type InstantiationTrace struct {
	InstanceId id.Id
}

type LeaveTrace struct {
	Node schema.FlowNodeInterface
}

type NewFlowNodeTrace struct {
	Node schema.FlowNodeInterface
}

type NewFlowTrace struct {
	FlowId id.Id
}

type NoAction struct{}

type Option func(*Options)

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

type ParallelGateway struct {
	*Wiring
	// contains filtered or unexported fields
}

type ProbeAction struct {
	SequenceFlows []*SequenceFlow
	// ProbeReport is a function that needs to be called
	// wth sequence flow indices that have successful
	// condition expressions (or none)
	ProbeReport func([]int)
}

type Process struct {
	*Options

	Element     *schema.Process
	Definitions *schema.Definitions
	// contains filtered or unexported fields
}

type ProcessLandMarkTrace struct {
	Node schema.FlowNodeInterface
}

type ProcessTrace struct {
	Process *schema.Process
	Trace   tracing.ITrace
}

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

type SequenceFlow struct {
	*schema.SequenceFlow
	// contains filtered or unexported fields
}

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

type StartEvent struct {
	*Wiring
	// contains filtered or unexported fields
}

type SubProcess struct {
	*Wiring
	// contains filtered or unexported fields
}

type Task struct {
	*Wiring
	// contains filtered or unexported fields
}

type TaskTrace interface {
	Element() any
	Context() context.Context
	GetActivity() Activity
	GetDataObjects() map[string]any
	GetHeaders() map[string]string
	GetProperties() map[string]any
	Do(options ...DoOption)
}

type Terminate func(sequenceFlowId *schema.IdRef) chan bool

type TerminationTrace struct {
	FlowId id.Id
	Source schema.FlowNodeInterface
}

type VisitTrace struct {
	Node schema.FlowNodeInterface
}

type Wiring struct {
	ProcessInstanceId              id.Id
	FlowNodeId                     schema.Id
	Definitions                    *schema.Definitions
	Incoming                       []SequenceFlow
	Outgoing                       []SequenceFlow
	EventIngress                   event.IConsumer
	EventEgress                    event.ISource
	Tracer                         tracing.ITracer
	Process                        schema.Element
	FlowNodeMapping                *FlowNodeMapping
	FlowWaitGroup                  *sync.WaitGroup
	EventDefinitionInstanceBuilder event.IDefinitionInstanceBuilder
	Locator                        data.IFlowDataLocator
}