bpmn

type Activity struct {
	FlowNode
	Default           string `xml:"default,attr"`
	IsForCompensation bool   `xml:"isForCompensation,attr"`
}

type AssignmentDefinition struct {
	Assignee        string `xml:"assignee,attr"`
	CandidateGroups string `xml:"candidateGroups,attr"`
	CandidateUsers  string `xml:"candidateUsers,attr"`
}

type BaseElement struct {
	Id                  string              `xml:"id,attr"`
	Documentation       []Documentation     `xml:"documentation,omitempty"`
	ExtensionProperties ExtensionProperties `xml:"extensionElements>properties>property,omitempty"`
}

type BaseElementWithMixedContent struct {
	Id            string         `xml:"id,attr,omitempty"`
	Content       string         `xml:",innerxml"`
	Documentation *Documentation `xml:"documentation,omitempty"`
}

type BusinessRuleTask struct {
	Task
	TaskDefinition *TaskDefinition `xml:"extensionElements>taskDefinition,omitempty"`
	Inputs         []Input         `xml:"extensionElements>ioMapping>input,omitempty"`
	Outputs        []Output        `xml:"extensionElements>ioMapping>output,omitempty"`
	Headers        []Header        `xml:"extensionElements>taskHeaders>header,omitempty"`
	Script         *Script         `xml:"extensionElements>script"`
	CalledDecision *CalledDecision `xml:"extensionElements>calledDecision"`
}

type CallActivity struct {
	Activity
	CalledElement CalledElement `xml:"extensionElements>calledElement"`
	Inputs        []Input       `xml:"extensionElements>ioMapping>input,omitempty"`
	Outputs       []Output      `xml:"extensionElements>ioMapping>output,omitempty"`
}

type CalledDecision struct {
	DecisionId     string `xml:"decisionId,attr"`
	ResultVariable string `xml:"resultVariable,attr"`
}

type CalledElement struct {
	ProcessId                  string `xml:"processId,attr"`
	PropagateAllChildVariables bool   `xml:"propagateAllChildVariables,attr"`
}

type CatchEvent struct {
	Event
}

type ComplexGateway struct {
	Gateway
	ActivationCondition *Expression `xml:"activationCondition,attr,omitempty"`
	Default             string      `xml:"default,attr"`
}

type ConditionExpression struct {
	FormalExpression
	Type     string `xml:"type,attr"`
	Resource string `xml:"resource,attr"`
}

type Converter interface {
	// ConvertDecisionTable convert decision table to other grammar
	ConvertDecisionTable(decisionID string, table *dmn.DecisionTable) ([]string, error)
	// Match bool evaluate
	Match(rule string, input vars.Mapping) (bool, error)
	Eval(rule string, input vars.Mapping) (any, error)
}

type Definitions struct {
	BaseElement
	TargetNamespace    string    `xml:"targetNamespace,attr"`
	ExpressionLanguage string    `xml:"expressionLanguage,attr"`
	TypeLanguage       string    `xml:"typeLanguage,attr"`
	Exporter           string    `xml:"exporter,attr"`
	ExporterVersion    string    `xml:"exporterVersion,attr"`
	Process            []Process `json:"process,omitempty" xml:"process"`
	Messages           []Message `json:"message,omitempty" xml:"message"`
	Signals            []Signal  `json:"signal,omitempty" xml:"signal"`
}

type Documentation struct {
	Content    string `xml:",innerxml"`
	Id         string `xml:"id,attr"`
	TextFormat string `xml:"textFormat,attr"`
}

type Elementor interface {
	GetId() string
	GetOutgoing() []string
}

type EndEvent struct {
	ThrowEvent
}

type Event struct {
	FlowNode
}

type EventBasedGateway struct {
	Gateway
	Instantiate           bool                  `xml:"instantiate,attr"`
	EventBasedGatewayType EventBasedGatewayType `xml:"eventGatewayType,attr"`
}

type EventBasedGatewayType string

type EventDefinition struct {
	RootElement
}

type ExclusiveGateway struct {
	Gateway
}

type Expression struct {
	BaseElementWithMixedContent
}

type ExtensionProperties []ExtensionProperty

type ExtensionProperty struct {
	Name  string `xml:"name,attr"`
	Value string `xml:"value,attr"`
}

type FlowElement struct {
	BaseElement
	Name string `xml:"name,attr"`
}

type FlowNode struct {
	FlowElement
	Tag      string   `xml:"tag,attr"`
	Incoming []string `xml:"incoming"`
	Outgoing []string `xml:"outgoing"`
}

type FormDefinition struct {
	FormKey string `xml:"formKey,attr"`
}

type FormalExpression struct {
	Expression
	Language           string `xml:"language,omitempty,attr"`
	EvaluatesToTypeRef string `xml:"evaluatesToTypeRef,attr"`
}

type Gateway struct {
	FlowNode
	GatewayDirection GatewayDirection `xml:"gatewayDirection,attr"`
}

type GatewayDirection string

type Header struct {
	Key   string `xml:"key,attr"`
	Value string `xml:"value,attr"`
}

type InclusiveGateway struct {
	Gateway
	Default string `xml:"default,attr,omitempty"`
}

type Input struct {
	Source string `xml:"source,attr"`
	Target string `xml:"target,attr"`
}

type IntermediateCatchEvent struct {
	CatchEvent
	TimerEventDefinition   *TimerEventDefinition   `xml:"timerEventDefinition,omitempty"`
	MessageEventDefinition *MessageEventDefinition `xml:"messageEventDefinition,omitempty"`
	SignalEventDefinition  *SignalEventDefinition  `xml:"signalEventDefinition,omitempty"`
	Outputs                []Output                `xml:"extensionElements>ioMapping>output,omitempty"`
}

type LoopCharacteristics struct {
	InputCollection  string `xml:"inputCollection,attr"`
	InputElement     string `xml:"inputElement,attr"`
	OutputCollection string `xml:"outputCollection,attr"`
	OutputElement    string `xml:"outputElement,attr"`
}

type ManualTask struct {
	Task
}

type Message struct {
	RootElement
	Name         string        `xml:"name,attr"`
	Subscription *Subscription `xml:"extensionElements>subscription"`
}

type MessageEventDefinition struct {
	EventDefinition
	MessageRef string `xml:"messageRef,attr"`
}

type MultiInstanceLoopCharacteristics struct {
	IsSequential        bool                `xml:"isSequential,attr"`
	LoopCharacteristics LoopCharacteristics `xml:"extensionElements>loopCharacteristics"`
	CompletionCondition *FormalExpression   `xml:"completionCondition"`
}

type Output struct {
	Source string `xml:"source,attr" xml:"name,attr"`
	Target string `xml:"target,attr" xml:",innerxml"`
}

type ParallelGateway struct {
	Gateway
	// Camunda extensions
	Async     bool `xml:"async,attr"`
	Exclusive bool `xml:"exclusive,attr"`
}

type Process struct {
	BaseElement
	Name                         string                    `xml:"name,attr"`
	ProcessType                  ProcessType               `xml:"processType,attr"`
	IsClosed                     bool                      `xml:"isClosed,attr"`
	IsExecutable                 bool                      `xml:"isExecutable,attr"`
	DefinitionalCollaborationRef string                    `xml:"definitionalCollaborationRef,attr"`
	StartEvents                  []*StartEvent             `xml:"startEvent"`
	EndEvents                    []*EndEvent               `xml:"endEvent"`
	UserTasks                    []*UserTask               `xml:"userTask"`
	ServiceTasks                 []*ServiceTask            `xml:"serviceTask"`
	BusinessRules                []*BusinessRuleTask       `xml:"businessRuleTask"`
	SequenceFlows                []*SequenceFlow           `xml:"sequenceFlow"`
	CallActivities               []*CallActivity           `xml:"callActivity"`
	ExclusiveGateways            []*ExclusiveGateway       `xml:"exclusiveGateway"`
	InclusiveGateways            []*InclusiveGateway       `xml:"inclusiveGateway"`
	ParallelGateways             []*ParallelGateway        `xml:"parallelGateway"`
	EventBasedGateways           []*EventBasedGateway      `xml:"eventBasedGateway"`
	IntermediateCatchEvents      []*IntermediateCatchEvent `xml:"intermediateCatchEvent"`
	// camunda:properties
	VersionTag string `xml:"versionTag,attr"`
}

type ProcessType string

type ReceiveTask struct {
	Task
	MessageRef   string        `xml:"messageRef,attr"`
	Outputs      []Output      `xml:"extensionElements>ioMapping>output,omitempty"`
	Subscription *Subscription `xml:"extensionElements>subscription"`
}

type RootElement struct {
	BaseElement
}

type Script struct {
	Expression     string `xml:"expression,attr"`
	ResultVariable string `xml:"resultVariable,attr"`
}

type ScriptTask struct {
	Task
	TaskDefinition *TaskDefinition `xml:"extensionElements>taskDefinition,omitempty"`
	Inputs         []Input         `xml:"extensionElements>ioMapping>input,omitempty"`
	Outputs        []Output        `xml:"extensionElements>ioMapping>output,omitempty"`
	Headers        []Header        `xml:"extensionElements>taskHeaders>header,omitempty"`
	Script         *Script         `xml:"extensionElements>script,omitempty"`
}

type SendTask struct {
	Task
	TaskDefinition *TaskDefinition `xml:"extensionElements>taskDefinition,omitempty"`
	Inputs         []Input         `xml:"extensionElements>ioMapping>input,omitempty"`
	Outputs        []Output        `xml:"extensionElements>ioMapping>output,omitempty"`
	Headers        []Header        `xml:"extensionElements>taskHeaders>header,omitempty"`
}

type SequenceFlow struct {
	FlowElement
	ConditionExpression *ConditionExpression `xml:"conditionExpression"`
	SourceRef           string               `xml:"sourceRef,attr"`
	TargetRef           string               `xml:"targetRef,attr"`
	IsImmediate         bool                 `xml:"isImmediate,attr"`
}

type ServiceTask struct {
	Task
	TaskDefinition *TaskDefinition `xml:"extensionElements>taskDefinition,omitempty"`
	Inputs         []Input         `xml:"extensionElements>ioMapping>input,omitempty"`
	Outputs        []Output        `xml:"extensionElements>ioMapping>output,omitempty"`
	Headers        []Header        `xml:"extensionElements>taskHeaders>header,omitempty"`
}

type Signal struct {
	RootElement
	Name string `xml:"name,attr"`
}

type SignalEventDefinition struct {
	EventDefinition
	SignalRef string `xml:"signalRef,attr"`
}

type StartEvent struct {
	CatchEvent
	MessageEventDefinition *MessageEventDefinition `xml:"messageEventDefinition,omitempty"`
	IsInterrupting         bool                    `xml:"isInterrupting,attr"`
	Outputs                []Output                `xml:"extensionElements>ioMapping>output,omitempty"`
}

type Subscription struct {
	CorrelationKey string `xml:"correlationKey,attr"`
}

type Task struct {
	Activity
	// Camunda extensions
	Async bool `xml:"async,attr"`
}

type TaskDefinition struct {
	TypeName string `xml:"type,attr"`
	Retries  string `xml:"retries,attr"`
}

type ThrowEvent struct {
	Event
}

type TimerEventDefinition struct {
	EventDefinition
	TimeDate     *Expression `xml:"timeDate"`
	TimeDuration *Expression `xml:"timeDuration"`
	TimeCycle    *Expression `xml:"timeCycle"`
}

type UserTask struct {
	Task
	Form          *FormDefinition                   `xml:"extensionElements>formDefinition"`
	Assignment    *AssignmentDefinition             `xml:"extensionElements>assignmentDefinition"`
	Inputs        []Input                           `xml:"extensionElements>ioMapping>input,omitempty"`
	Outputs       []Output                          `xml:"extensionElements>ioMapping>output,omitempty"`
	Headers       []Header                          `xml:"extensionElements>taskHeaders>header,omitempty"`
	MultiInstance *MultiInstanceLoopCharacteristics `xml:"multiInstanceLoopCharacteristics"`
}