pnml

type AnnotationGraphics struct {
	XMLName xml.Name `xml:"graphics"`
	Offset  *Offset  `xml:"offset"`
	Fill    *Fill    `xml:"fill"` // optional
	Line    *Line    `xml:"line"` // optional
	Font    *Font    `xml:"font"` // optional
}

type Arc struct {
	XMLName       xml.Name         `xml:"arc"`
	ID            *string          `xml:"id,attr"`
	Source        *string          `xml:"source,attr"`
	Target        *string          `xml:"target,attr"`
	Name          *Name            `xml:"name"`          // optional
	Weight        *PTArcAnnotation `xml:"inscription"`   // label for pt nets only
	HLInscription *HLAnnotation    `xml:"hlinscription"` // label for hl nets only, optional
	Graphics      *EdgeGraphics    `xml:"graphics"`      // optional
	ToolSpecifics []ToolSpecific   `xml:"toolspecific"`  // optional

}

type BoolAnd struct {
	XMLName xml.Name    `xml:"and"`
	Terms   []HLSubterm `xml:"subterm"` // optional
}

type BoolConstant struct {
	XMLName xml.Name    `xml:"booleanconstant"`
	Value   *bool       `xml:"value,attr"`
	Terms   []HLSubterm `xml:"subterm"` // should not appear in a boolean constant, but allowed by the XML grammar
}

type BoolEquality struct {
	XMLName xml.Name    `xml:"equality"`
	Terms   []HLSubterm `xml:"subterm"`
}

type BoolImply struct {
	XMLName xml.Name    `xml:"imply"`
	Terms   []HLSubterm `xml:"subterm"` // optional
}

type BoolInequality struct {
	XMLName xml.Name    `xml:"inequality"`
	Terms   []HLSubterm `xml:"subterm"`
}

type BoolNot struct {
	XMLName xml.Name    `xml:"not"`
	Terms   []HLSubterm `xml:"subterm"` // optional
}

type BoolOr struct {
	XMLName xml.Name    `xml:"or"`
	Terms   []HLSubterm `xml:"subterm"` // optional
}

type BoolSort struct {
	XMLName xml.Name `xml:"bool"`
}

type CyclicEnumPredecessor struct {
	XMLName xml.Name    `xml:"predecessor"`
	Terms   []HLSubterm `xml:"subterm"` // optional
}

type CyclicEnumSort struct {
	XMLName   xml.Name     `xml:"cyclicenumeration"`
	Constants []FEConstant `xml:"feconstant"` // optional
}

type CyclicEnumSuccessor struct {
	XMLName xml.Name    `xml:"successor"`
	Terms   []HLSubterm `xml:"subterm"`
}

type Dimension struct {
	XMLName xml.Name `xml:"dimension"`
	X       *float32 `xml:"x,attr"` // between 0 and 999.9, 4 digits with 1 decimal digit
	Y       *float32 `xml:"y,attr"` // between 0 and 999.9, 4 digits with 1 decimal digit
}

type DotConstant struct {
	XMLName xml.Name `xml:"dotconstant"`
}

type DotSort struct {
	XMLName xml.Name `xml:"dot"`
}

type EdgeGraphics struct {
	XMLName   xml.Name   `xml:"graphics"`
	Positions []Position `xml:"position"` // optional
	Line      *Line      `xml:"line"`     // optional
}

type FEConstant struct {
	XMLName xml.Name `xml:"feconstant"`
	ID      *string  `xml:"id,attr"`
	Name    *string  `xml:"name,attr"`
}

type FESort struct {
	XMLName   xml.Name     `xml:"finiteenumeration"`
	Constants []FEConstant `xml:"feconstant"` // optional
}

type FIRConstant struct {
	XMLName xml.Name    `xml:"finiteintrangeconstant"`
	Value   *int        `xml:"value,attr"`
	FIRSort *FIRSort    `xml:"finiteintrange"`
	Terms   []HLSubterm `xml:"subterm"` // optional
}

type FIRGreaterThan struct {
	XMLName xml.Name    `xml:"greaterthan"`
	Terms   []HLSubterm `xml:"subterm"` // optional
}

type FIRGreaterThanOrEqual struct {
	XMLName xml.Name    `xml:"greaterthanorequal"`
	Terms   []HLSubterm `xml:"subterm"` // optional
}

type FIRLessThan struct {
	XMLName xml.Name    `xml:"lessthan"`
	Terms   []HLSubterm `xml:"subterm"` // optional
}

type FIRLessThanOrEqual struct {
	XMLName xml.Name    `xml:"lessthanorequal"`
	Terms   []HLSubterm `xml:"subterm"` // optional
}

type FIRSort struct {
	XMLName xml.Name `xml:"finiteintrange"`
	Start   *int     `xml:"start,attr"`
	End     *int     `xml:"end,attr"`
}

type Fill struct {
	XMLName          xml.Name `xml:"fill"`
	Color            *string  `xml:"color,attr"`             // optional
	GradientColor    *string  `xml:"gradient-color,attr"`    // optional
	GradientRotation *string  `xml:"gradient-rotation,attr"` // optional (must be vertical, horizontal, or diagonal)
	Image            *string  `xml:"image,attr"`             // optional
}

type Font struct {
	XMLName    xml.Name `xml:"font"`
	Family     *string  `xml:"family,attr"`     // optional
	Style      *string  `xml:"style,attr"`      // optional
	Weight     *string  `xml:"weight,attr"`     // optional
	Size       *string  `xml:"size,attr"`       // optional
	Decoration *string  `xml:"decoration,attr"` // optional (must be underline, overline, or line-through)
	Align      *string  `xml:"align,attr"`      // optional (must be left, center, or right)
	Rotation   *float32 `xml:"rotation,attr"`   // optional
}

type HLAnnotation struct {
	XMLName       xml.Name            `xml:"hlinscription"`
	Info          *string             `xml:"text"`         // optional
	Graphics      *AnnotationGraphics `xml:"graphics"`     // optional
	ToolSpecifics []ToolSpecific      `xml:"toolspecific"` // optional
	Structure     *HLTermStructure    `xml:"structure"`    // optional
}

type HLCondition struct {
	XMLName       xml.Name            `xml:"condition"`
	Info          *string             `xml:"text"`         // optional
	Graphics      *AnnotationGraphics `xml:"graphics"`     // optional
	ToolSpecifics []ToolSpecific      `xml:"toolspecific"` // optional
	Structure     *HLTermStructure    `xml:"structure"`    // optional
}

type HLDeclaration struct {
	XMLName                        xml.Name                   `xml:"declaration"`
	Info                           *string                    `xml:"text"`                                    // optional
	SortDeclarations               []HLSortDeclaration        `xml:"structure>declarations>namedsort"`        // optional
	PartitionSortDeclarations      []PartitionSortDeclaration `xml:"structure>declarations>partition"`        // optional
	VariableDeclarations           []HLVariableDeclaration    `xml:"structure>declarations>variabledecl"`     // optional
	OperatorDeclarations           []HLOperatorDeclaration    `xml:"structure>declarations>namedoperator"`    // optional
	PartitionOperatorsDeclarations []PartitionElement         `xml:"structure>declarations>partitionelement"` // optional
	FEConstantDeclarations         []FEConstant               `xml:"structure>declarations>feconstant"`       // optional
}

type HLMarking struct {
	XMLName       xml.Name            `xml:"hlinitialMarking"`
	Info          *string             `xml:"text"`         // optional
	Graphics      *AnnotationGraphics `xml:"graphics"`     // optional
	ToolSpecifics []ToolSpecific      `xml:"toolspecific"` // optional
	Structure     *HLTermStructure    `xml:"structure"`    // optional
}

type HLMultisetSort struct {
	XMLName xml.Name `xml:"multisetsort"`
	Sort    *HLSort  `xml:",any"`
}

type HLOperatorDeclaration struct {
	XMLName              xml.Name                `xml:"namedoperator"`
	ID                   *string                 `xml:"id,attr"`
	Name                 *string                 `xml:"name,attr"`
	VariableDeclarations []HLVariableDeclaration `xml:"parameter>variabledecl"` // optional
	Def                  *HLTermDef              `xml:"def"`
}

type HLProductSort struct {
	XMLName xml.Name `xml:"productsort"`
	Sorts   []HLSort `xml:",any"` // optional
}

type HLSort struct {
	Type  string `xml:"-"`
	Value interface{}
}

type HLSortDeclaration struct {
	XMLName xml.Name `xml:"namedsort"`
	ID      *string  `xml:"id,attr"`
	Name    *string  `xml:"name,attr"`
	Sort    *HLSort  `xml:",any"`
}

type HLSortStructure struct {
	XMLName xml.Name `xml:"structure"`
	Sort    *HLSort  `xml:",any"`
}

type HLSubterm struct {
	XMLName xml.Name `xml:"subterm"`
	Term    *HLTerm  `xml:",any"`
}

type HLTerm struct {
	Type  string `xml:"-"`
	Value interface{}
}

type HLTermDef struct {
	XMLName xml.Name `xml:"def"`
	Term    *HLTerm  `xml:",any"`
}

type HLTermStructure struct {
	XMLName xml.Name `xml:"structure"`
	Term    *HLTerm  `xml:",any"`
}

type HLTupleOperator struct {
	XMLName xml.Name    `xml:"tuple"`
	Terms   []HLSubterm `xml:"subterm"` // optional
}

type HLType struct {
	XMLName       xml.Name            `xml:"type"`
	Info          *string             `xml:"text"`         // optional
	Graphics      *AnnotationGraphics `xml:"graphics"`     // optional
	ToolSpecifics []ToolSpecific      `xml:"toolspecific"` // optional
	Structure     *HLSortStructure    `xml:"structure"`    // optional
}

type HLUserOperator struct {
	XMLName xml.Name    `xml:"useroperator"`
	ID      *string     `xml:"declaration,attr"` // data type="IDREF"
	Terms   []HLSubterm `xml:"subterm"`          // optional
}

type HLUserSort struct {
	XMLName xml.Name `xml:"usersort"`
	ID      *string  `xml:"declaration,attr"` // data type="IDREF"
}

type HLVariable struct {
	XMLName xml.Name `xml:"variable"`
	ID      *string  `xml:"refvariable,attr"` // data type="IDREF"
}

type HLVariableDeclaration struct {
	XMLName xml.Name `xml:"variabledecl"`
	ID      *string  `xml:"id,attr"`
	Name    *string  `xml:"name,attr"`
	Sort    *HLSort  `xml:",any"`
}

type IntAddition struct {
	XMLName xml.Name    `xml:"addition"`
	Terms   []HLSubterm `xml:"subterm"` // optional
}

type IntDivision struct {
	XMLName xml.Name    `xml:"div"`
	Terms   []HLSubterm `xml:"subterm"` // optional
}

type IntGreaterThan struct {
	XMLName xml.Name    `xml:"gt"`
	Terms   []HLSubterm `xml:"subterm"` // optional
}

type IntGreaterThanOrEqual struct {
	XMLName xml.Name    `xml:"geq"`
	Terms   []HLSubterm `xml:"subterm"` // optional
}

type IntInteger struct {
	XMLName xml.Name `xml:"integer"`
}

type IntLessThan struct {
	XMLName xml.Name    `xml:"lt"`
	Terms   []HLSubterm `xml:"subterm"` // optional
}

type IntLessThanOrEqual struct {
	XMLName xml.Name    `xml:"leq"`
	Terms   []HLSubterm `xml:"subterm"` // optional
}

type IntModulo struct {
	XMLName xml.Name    `xml:"mod"`
	Terms   []HLSubterm `xml:"subterm"` // optional
}

type IntMultiplication struct {
	XMLName xml.Name    `xml:"mult"`
	Terms   []HLSubterm `xml:"subterm"` // optional
}

type IntNatural struct {
	XMLName xml.Name `xml:"natural"`
}

type IntNumberConstant struct {
	XMLName xml.Name    `xml:"numberconstant"`
	Value   *int        `xml:"value,attr"`
	Terms   []HLSubterm `xml:"subterm"` // empty
	// choice
	IntNatural  *IntNatural  `xml:"natural"`
	IntPositive *IntPositive `xml:"positive"`
	IntInteger  *IntInteger  `xml:"integer"`
}

type IntPositive struct {
	XMLName xml.Name `xml:"positive"`
}

type IntSubtraction struct {
	XMLName xml.Name    `xml:"subtraction"`
	Terms   []HLSubterm `xml:"subterm"` // optional
}

type Line struct {
	XMLName xml.Name `xml:"line"`
	Shape   *string  `xml:"shape,attr"` // optional (must be line or curve)
	Color   *string  `xml:"color,attr"` // optional
	Width   *float32 `xml:"width,attr"` // optional (must be between 0 and 999.9, 4 digits with 1 decimal digit)
	Style   *string  `xml:"style,attr"` // optional (must be solid, dash, or dot)
}

type ListAppend struct {
	XMLName xml.Name    `xml:"listappend"`
	Terms   []HLSubterm `xml:"subterm"` // optional
}

type ListConcatenation struct {
	XMLName xml.Name    `xml:"listconcatenation"`
	Terms   []HLSubterm `xml:"subterm"`
}

type ListEmpty struct {
	XMLName xml.Name    `xml:"emptylist"`
	Sort    *HLSort     `xml:",any"`
	Terms   []HLSubterm `xml:"subterm"`
}

type ListLength struct {
	XMLName xml.Name    `xml:"listlength"`
	Terms   []HLSubterm `xml:"subterm"`
}

type ListMake struct {
	XMLName xml.Name    `xml:"makelist"`
	Sort    *HLSort     `xml:",any"`
	Terms   []HLSubterm `xml:"subterm"` // 1 or more? what about empty list?
}

type ListMemberAtIndex struct {
	XMLName xml.Name    `xml:"memberatindex"`
	Index   *uint       `xml:"index,attr"`
	Terms   []HLSubterm `xml:"subterm"` // optional
}

type ListSort struct {
	XMLName xml.Name `xml:"list"`
	Sort    *HLSort  `xml:",any"`
}

type ListSublist struct {
	XMLName xml.Name    `xml:"sublist"`
	Start   *uint       `xml:"start,attr"`
	Length  *uint       `xml:"length,attr"`
	Terms   []HLSubterm `xml:"subterm"` // optional
}

type MultisetAdd struct {
	XMLName xml.Name    `xml:"add"`
	Terms   []HLSubterm `xml:"subterm"`
}

type MultisetAll struct {
	XMLName xml.Name    `xml:"all"`
	Terms   []HLSubterm `xml:"subterm"`
	Sort    *HLSort     `xml:",any"`
}

type MultisetCardinality struct {
	XMLName xml.Name    `xml:"cardinality"`
	Terms   []HLSubterm `xml:"subterm"`
}

type MultisetCardinalityOf struct {
	XMLName xml.Name    `xml:"cardinalityof"`
	Terms   []HLSubterm `xml:"subterm"`
}

type MultisetContains struct {
	XMLName xml.Name    `xml:"contains"`
	Terms   []HLSubterm `xml:"subterm"`
}

type MultisetEmpty struct {
	XMLName xml.Name    `xml:"empty"`
	Terms   []HLSubterm `xml:"subterm"` // optional
	Sort    *HLSort     `xml:",any"`
}

type MultisetNumberOf struct {
	XMLName xml.Name    `xml:"numberof"`
	Terms   []HLSubterm `xml:"subterm"` // optional
}

type MultisetScalarProduct struct {
	XMLName xml.Name    `xml:"scalarproduct"`
	Terms   []HLSubterm `xml:"subterm"` // optional
}

type MultisetSubtract struct {
	XMLName xml.Name    `xml:"subtract"`
	Terms   []HLSubterm `xml:"subterm"` // optional
}

type Name struct {
	XMLName       xml.Name            `xml:"name"`
	Text          *string             `xml:"text"`         // optional
	Graphics      *AnnotationGraphics `xml:"graphics"`     // optional
	ToolSpecifics []ToolSpecific      `xml:"toolspecific"` // optional
}

type Net struct {
	XMLName        xml.Name        `xml:"net"`
	ID             *string         `xml:"id,attr"`
	Type           *string         `xml:"type,attr"`
	Name           *Name           `xml:"name"`         // optional
	HLDeclarations []HLDeclaration `xml:"declaration"`  // optional
	Pages          []Page          `xml:"page"`         // at least 1
	ToolSpecifics  []ToolSpecific  `xml:"toolspecific"` // optional

}

type NodeGraphics struct {
	XMLName   xml.Name   `xml:"graphics"`
	Position  *Position  `xml:"position"`
	Dimension *Dimension `xml:"dimension"` // optional
	Fill      *Fill      `xml:"fill"`      // optional
	Line      *Line      `xml:"line"`      // optional
}

type Offset struct {
	XMLName xml.Name `xml:"offset"`
	X       *float32 `xml:"x,attr"`
	Y       *float32 `xml:"y,attr"`
}

type PTArcAnnotation struct {
	XMLName       xml.Name            `xml:"inscription"`
	Value         *uint64             `xml:"text"`         // must be integer > 0
	Graphics      *AnnotationGraphics `xml:"graphics"`     // optional
	ToolSpecifics []ToolSpecific      `xml:"toolspecific"` // optional
}

type PTMarking struct {
	XMLName       xml.Name            `xml:"initialMarking"`
	Tokens        *uint64             `xml:"text"`         // must be integer >= 0
	Graphics      *AnnotationGraphics `xml:"graphics"`     // optional
	ToolSpecifics []ToolSpecific      `xml:"toolspecific"` // optional
}

type Page struct {
	XMLName        xml.Name        `xml:"page"`
	ID             *string         `xml:"id,attr"`
	Name           *Name           `xml:"name"`                // optional
	ToolSpecifics  []ToolSpecific  `xml:"toolspecific"`        // optional
	HLDeclarations []HLDeclaration `xml:"declaration"`         // optional
	Pages          []Page          `xml:"page"`                // optional
	Places         []Place         `xml:"place"`               // optional
	Transitions    []Transition    `xml:"transition"`          // optional
	RefPlaces      []RefPlace      `xml:"referencePlace"`      // optional
	RefTransitions []RefTransition `xml:"referenceTransition"` // optional
	Arcs           []Arc           `xml:"arc"`                 // optional
	Graphics       *PageGraphics   `xml:"graphics"`            // optional

}

type PageGraphics = NodeGraphics

type PartitionElement struct {
	XMLName xml.Name `xml:"partitionelement"`
	ID      *string  `xml:"id,attr"`
	Name    *string  `xml:"name,attr"`
	Terms   []HLTerm `xml:",any"`
}

type PartitionElementOf struct {
	XMLName xml.Name    `xml:"partitionelementof"`
	Ref     *string     `xml:"refpartition,attr"` // data of type IDREF
	Terms   []HLSubterm `xml:"subterm"`           // optional
}

type PartitionGreaterThan struct {
	XMLName xml.Name    `xml:"gtp"`
	Terms   []HLSubterm `xml:"subterm"` // optional
}

type PartitionLessThan struct {
	XMLName xml.Name    `xml:"ltp"`
	Terms   []HLSubterm `xml:"subterm"`
}

type PartitionSortDeclaration struct {
	XMLName           xml.Name           `xml:"partition"`
	ID                *string            `xml:"id,attr"`
	Name              *string            `xml:"name,attr"`
	Sort              *HLSort            `xml:",any"`
	PartitionElements []PartitionElement `xml:"partitionelement"` // one or more
}

type Place struct {
	XMLName          xml.Name       `xml:"place"`
	ID               *string        `xml:"id,attr"`
	Name             *Name          `xml:"name"`             // optional
	ToolSpecifics    []ToolSpecific `xml:"toolspecific"`     // optional
	InitialMarking   *PTMarking     `xml:"initialMarking"`   // label for pt nets only, optional
	Type             *HLType        `xml:"type"`             // label for hl nets only, optional
	HLInitialMarking *HLMarking     `xml:"hlinitialMarking"` // label for hl nets only, optional
	Graphics         *NodeGraphics  `xml:"graphics"`         // optional

}

type Pnml struct {
	XMLName xml.Name `xml:"http://www.pnml.org/version-2009/grammar/pnml pnml"`
	Nets    []Net    `xml:"net"` // at least 1
}

type Position struct {
	XMLName xml.Name `xml:"position"`
	X       *float32 `xml:"x,attr"`
	Y       *float32 `xml:"y,attr"`
}

type RefPlace struct {
	XMLName       xml.Name       `xml:"referencePlace"`
	ID            *string        `xml:"id,attr"`
	Reference     *string        `xml:"ref,attr"`
	Name          *Name          `xml:"name"`         // optional
	ToolSpecifics []ToolSpecific `xml:"toolspecific"` // optional
	Graphics      *NodeGraphics  `xml:"graphics"`     // optional
}

type RefTransition struct {
	XMLName       xml.Name       `xml:"referenceTransition"`
	ID            *string        `xml:"id,attr"`
	Reference     *string        `xml:"ref,attr"`
	Name          *Name          `xml:"name"`         // optional
	ToolSpecifics []ToolSpecific `xml:"toolspecific"` // optional
	Graphics      *NodeGraphics  `xml:"graphics"`     // optional
}

type StringAppend struct {
	XMLName xml.Name    `xml:"stringappend"`
	Terms   []HLSubterm `xml:"subterm"` // optional
}

type StringConcatenation struct {
	XMLName xml.Name    `xml:"stringconcatenation"`
	Terms   []HLSubterm `xml:"subterm"` // optional
}

type StringConstant struct {
	XMLName xml.Name    `xml:"stringconstant"`
	Value   *string     `xml:"value>text"`
	Terms   []HLSubterm `xml:"subterm"` // optional
}

type StringGreaterThan struct {
	XMLName xml.Name    `xml:"gts"`
	Terms   []HLSubterm `xml:"subterm"` // optional
}

type StringGreaterThanOrEqual struct {
	XMLName xml.Name    `xml:"geqs"`
	Terms   []HLSubterm `xml:"subterm"` // optional
}

type StringLength struct {
	XMLName xml.Name    `xml:"stringlength"`
	Terms   []HLSubterm `xml:"subterm"` // optional
}

type StringLessThan struct {
	XMLName xml.Name    `xml:"lts"`
	Terms   []HLSubterm `xml:"subterm"` // optional
}

type StringLessThanOrEqual struct {
	XMLName xml.Name    `xml:"leqs"`
	Terms   []HLSubterm `xml:"subterm"` // optional
}

type StringSort struct {
	XMLName xml.Name `xml:"string"`
}

type StringSubstring struct {
	XMLName xml.Name    `xml:"substring"`
	Start   *uint       `xml:"start,attr"`
	Length  *uint       `xml:"length,attr"`
	Terms   []HLSubterm `xml:"subterm"` // optional
}

type ToolSpecific struct {
	XMLName xml.Name `xml:"toolspecific"`
	Tool    *string  `xml:"tool,attr"`
	Version *string  `xml:"version,attr"`
}

type Transition struct {
	XMLName       xml.Name       `xml:"transition"`
	ID            *string        `xml:"id,attr"`
	Name          *Name          `xml:"name"`         // optional
	ToolSpecifics []ToolSpecific `xml:"toolspecific"` // optional
	Condition     *HLCondition   `xml:"condition"`    // label for hl nets only, optional
	Graphics      *NodeGraphics  `xml:"graphics"`     // optional

}