---
title: Declarative Workflow Metamodel
...


```{.clafer}
//Declarative Workflow Metamodel

enum State = waiting | running | done | skipped | failed | canceled

abstract OrgUnit
    name : string 
    super -> OrgUnit ?
        [parent in this.sub]
    sub -> OrgUnit *
        [parent in this.super]
    role -> Role *
        [parent in this.orgUnit]

abstract BindingObject
    name : string 
    activity -> Activity *
        [parent in this.bindingObject]

abstract Role : BindingObject 
    orgUnit -> OrgUnit ?
        [parent in this.role]
    person -> Person *
        [parent in this.role]

abstract Person : BindingObject 
    role -> Role *
        [parent in this.person]

abstract DataObject
    classname : string 
    activity -> Activity ?
        [parent in this.dataObject]

abstract DataRead : DataObject 
    selection : string 

abstract DataCreate : DataObject 

abstract DataEdit : DataObject 
    selection : string 

abstract DataflowObject
    activity -> Activity 2..*
        [parent in this.dataflowObject]

abstract PatientData : DataflowObject 
    name : string 
    age : int 
    urgency : int 
    disease -> Disease 

abstract Disease
    name : string 

abstract FlowObject
    process -> Process ?
        [parent in this.flowObject]
    pred -> FlowObject *
        [parent in this.succ]
    succ -> FlowObject *
        [parent in this.pred]

abstract FlowOperator : FlowObject 

abstract AndOperator : FlowOperator 

abstract MergeOperator : FlowOperator 

abstract Discriminator : FlowOperator 

abstract Process
    name : string 
    flowObject -> FlowObject *
        [parent in this.process]

abstract CancelProcess : Process 

abstract ActivityGroup : FlowObject 
    name : string 
    before -> ActivityGroup *
        [parent in this.until]
    until -> ActivityGroup *
        [parent in this.before]
    guard -> Guard *
        [parent in this.option]

abstract Activity : ActivityGroup 
    state -> State 
    start : int 
    finish : int 
    dataObject -> DataObject *
        [parent in this.activity]
    dataflowObject -> DataflowObject *
        [parent in this.activity]
    iteration -> Iteration ?
        [parent in this.activity]
    multiInstance -> MultiInstance ?
        [parent in this.activity]
    group -> Group *
        [parent in this.activity]
    bindingObject -> BindingObject *
        [parent in this.activity]
    activities -> Activity *
	[this in pred]
    [all a:Activity|a in pred => a in activities]
    ops -> Group *
	[this in pred]
    [all g:Group| g in pred => g in ops]
    [state = running => ((all a:activities|a.state = done || a.state = skipped)&&(all a:ops.activity|a.state = done || a.state = skipped))]

abstract Cancel : Activity 

abstract Iteration : Activity 
    iterCount : int 
    iterMax : int 
    activity -> Activity *
        [parent in this.iteration]

abstract MultiInstance : Activity 
    noOfInst : int 
    activity -> Activity *
        [parent in this.multiInstance]

abstract MIWithoutSync : MultiInstance 

abstract MIWithSync : MultiInstance 

abstract MIRuntime : MultiInstance 

abstract MIRuntimeWithAdd : MultiInstance 

abstract Decision : Activity 
    guard_ -> Guard *
        [parent in this.decision]

abstract OrDecision : Decision 

abstract XorDecision : Decision 

abstract NandDecision : Decision 

abstract Timer
    ticks : int 
    seconds : int 

abstract Group : ActivityGroup 
    activity -> Activity +
        [parent in this.group]
    iterationGroup -> IterationGroup ?
        [parent in this.group]
    activities -> Activity *
	[this in pred]
    [all a:Activity|a in pred => a in activities]
    ops -> Group *
	[this in pred]
    [all g:Group| g in pred => g in ops]
    [(some a:activity|a.state = running) => ((all a:activities|a.state = done || a.state = skipped)&&(all a:ops.activity|a.state = done || a.state = skipped))]

abstract DeferredChoice : Group 

abstract InterleavedParallelRouting : Group 

abstract Parallel : Group 

abstract IterationGroup : Group 
    iterCount : int 
    iterMax : int 
    group -> Group *
        [parent in this.iterationGroup]

abstract MultiMerge : IterationGroup 

abstract Guard
    condition : string 
    selected ?
    decision -> Decision ?
        [parent in this.guard_]
    option -> ActivityGroup *
        [parent in this.guard]  

```

```{.clafer .summary}
```