BPMN20

type BaseElement interface {
	GetId() string
	GetName() string
	GetIncomingAssociation() []string
	GetOutgoingAssociation() []string
	GetType() ElementType
}

type ElementType string

type GatewayDirection string

type GatewayElement interface {
	BaseElement
	IsParallel() bool
	IsExclusive() bool
	IsInclusive() bool
}

type ProcessElement interface {
	BaseElement
	GetStartEvents() []TStartEvent
	GetEndEvents() []TEndEvent
	GetSequenceFlows() []TSequenceFlow
	GetServiceTasks() []TServiceTask
	GetUserTasks() []TUserTask
	GetParallelGateway() []TParallelGateway
	GetExclusiveGateway() []TExclusiveGateway
	GetIntermediateCatchEvent() []TIntermediateCatchEvent
	GetIntermediateTrowEvent() []TIntermediateThrowEvent
	GetEventBasedGateway() []TEventBasedGateway
	GetSubProcess() []TSubProcess
	GetInclusiveGateway() []TInclusiveGateway
}

type TActivity struct {
	TFlowNode
	IsForCompensation  bool `xml:"isForCompensation,attr"`
	StartQuantity      int  `xml:"startQuantity,attr" default:"1"`
	CompletionQuantity int  `xml:"completionQuantity,attr"`
}

type TBaseElement struct {
	Id            string `xml:"id,attr"`
	Documentation string `xml:"documentation"`
}

type TCallableElement struct {
	TRootElement
	Name string `xml:"name,attr"`
}

type TCatchEvent struct {
	TEvent
}

type TDefinitions struct {
	Id                 string     `xml:"id,attr"`
	Name               string     `xml:"name,attr"`
	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            TProcess   `xml:"process"`
	Messages           []TMessage `xml:"message"`
}

type TEndEvent struct {
	TThrowEvent
}

type TEvent struct {
	TFlowNode
}

type TEventBasedGateway struct {
	TGateway
}

type TEventDefinition struct {
	TRootElement
}

type TExclusiveGateway struct {
	TGateway
}

type TExpression struct {
	Text string `xml:",innerxml"`
}

type TFlowElement struct {
	TBaseElement
	Name string `xml:"name,attr"`
}

type TFlowNode struct {
	TFlowElement
	IncomingAssociation []string `xml:"incoming"`
	OutgoingAssociation []string `xml:"outgoing"`
}

type TGateway struct {
	TFlowNode
	GatewayDirection GatewayDirection `xml:"gatewayDirection,attr"`
}

type TInclusiveGateway struct {
	TGateway
}

type TIntermediateCatchEvent struct {
	TCatchEvent
	MessageEventDefinition TMessageEventDefinition `xml:"messageEventDefinition"`
	TimerEventDefinition   TTimerEventDefinition   `xml:"timerEventDefinition"`
	LinkEventDefinition    TLinkEventDefinition    `xml:"linkEventDefinition"`
	ParallelMultiple       bool                    `xml:"parallelMultiple"`
	Output                 []extensions.TIoMapping `xml:"extensionElements>ioMapping>output"`
}

type TIntermediateThrowEvent struct {
	TThrowEvent
	LinkEventDefinition TLinkEventDefinition    `xml:"linkEventDefinition"`
	Output              []extensions.TIoMapping `xml:"extensionElements>ioMapping>output"`
}

type TLinkEventDefinition struct {
	TEventDefinition
	Name string `xml:"name,attr"`
}

type TMessage struct {
	TRootElement
	Name    string `xml:"name,attr"`
	ItemRef string `xml:"itemRef,attr"`
}

type TMessageEventDefinition struct {
	TEventDefinition
	MessageRef string `xml:"messageRef,attr"`
}

type TParallelGateway struct {
	TGateway
}

type TProcess struct {
	TCallableElement
	ProcessType                  string                    `xml:"processType,attr"`
	IsClosed                     bool                      `xml:"isClosed,attr"`
	IsExecutable                 bool                      `xml:"isExecutable,attr"`
	DefinitionalCollaborationRef string                    `xml:"definitionalCollaborationRef,attr"`
	StartEvents                  []TStartEvent             `xml:"startEvent"`
	EndEvents                    []TEndEvent               `xml:"endEvent"`
	SequenceFlows                []TSequenceFlow           `xml:"sequenceFlow"`
	ServiceTasks                 []TServiceTask            `xml:"serviceTask"`
	UserTasks                    []TUserTask               `xml:"userTask"`
	SubProcesses                 []TSubProcess             `xml:"subProcess"`
	ParallelGateway              []TParallelGateway        `xml:"parallelGateway"`
	ExclusiveGateway             []TExclusiveGateway       `xml:"exclusiveGateway"`
	IntermediateCatchEvent       []TIntermediateCatchEvent `xml:"intermediateCatchEvent"`
	IntermediateTrowEvent        []TIntermediateThrowEvent `xml:"intermediateThrowEvent"`
	EventBasedGateway            []TEventBasedGateway      `xml:"eventBasedGateway"`
	InclusiveGateway             []TInclusiveGateway       `xml:"inclusiveGateway"`
}

type TRootElement struct {
	TBaseElement
}

type TSequenceFlow struct {
	TFlowElement
	SourceRef           string        `xml:"sourceRef,attr"`
	TargetRef           string        `xml:"targetRef,attr"`
	ConditionExpression []TExpression `xml:"conditionExpression"`
}

type TServiceTask struct {
	TTask
	Default            string                     `xml:"default,attr"`
	CompletionQuantity int                        `xml:"completionQuantity,attr"`
	IsForCompensation  bool                       `xml:"isForCompensation,attr"`
	OperationRef       string                     `xml:"operationRef,attr"`
	Implementation     string                     `xml:"implementation,attr"`
	Input              []extensions.TIoMapping    `xml:"extensionElements>ioMapping>input"`
	Output             []extensions.TIoMapping    `xml:"extensionElements>ioMapping>output"`
	TaskDefinition     extensions.TTaskDefinition `xml:"extensionElements>taskDefinition"`
}

type TStartEvent struct {
	TCatchEvent
	IsInterrupting   bool `xml:"isInterrupting,attr"`
	ParallelMultiple bool `xml:"parallelMultiple,attr"`
}

type TSubProcess struct {
	TActivity
	TriggeredByEvent       bool                      `xml:"triggeredByEvent,attr"`
	StartEvents            []TStartEvent             `xml:"startEvent"`
	EndEvents              []TEndEvent               `xml:"endEvent"`
	SequenceFlows          []TSequenceFlow           `xml:"sequenceFlow"`
	ServiceTasks           []TServiceTask            `xml:"serviceTask"`
	UserTasks              []TUserTask               `xml:"userTask"`
	SubProcesses           []TSubProcess             `xml:"subProcess"`
	ParallelGateway        []TParallelGateway        `xml:"parallelGateway"`
	ExclusiveGateway       []TExclusiveGateway       `xml:"exclusiveGateway"`
	IntermediateCatchEvent []TIntermediateCatchEvent `xml:"intermediateCatchEvent"`
	IntermediateTrowEvent  []TIntermediateThrowEvent `xml:"intermediateThrowEvent"`
	EventBasedGateway      []TEventBasedGateway      `xml:"eventBasedGateway"`
	InclusiveGateway       []TInclusiveGateway       `xml:"inclusiveGateway"`
}

type TTask struct {
	TActivity
}

type TThrowEvent struct {
	TEvent
}

type TTimeDuration struct {
	XMLText string `xml:",innerxml"`
}

type TTimerEventDefinition struct {
	TEventDefinition
	TimeDuration TTimeDuration `xml:"timeDuration"`
}

type TUserTask struct {
	TTask
	Input                []extensions.TIoMapping          `xml:"extensionElements>ioMapping>input"`
	Output               []extensions.TIoMapping          `xml:"extensionElements>ioMapping>output"`
	AssignmentDefinition extensions.TAssignmentDefinition `xml:"extensionElements>assignmentDefinition"`
}

type TaskElement interface {
	BaseElement
	GetInputMapping() []extensions.TIoMapping
	GetOutputMapping() []extensions.TIoMapping
	GetTaskDefinitionType() string
	GetAssignmentAssignee() string
	GetAssignmentCandidateGroups() []string
}