package uml {
	class Collaboration extends GeneralizableElement, Namespace {
		reference representedOperation[0-1] : Operation;
		reference usedCollaboration[*] : Collaboration;
		reference constrainingElement[*] : ModelElement;
		reference interaction[*] container : Interaction oppositeOf context;
		reference representedClassifier[0-1] : Classifier;
		
	}

	class ClassifierRole extends Classifier {
		reference conformingInstance[*] : Instance;
		reference availableContents[*] : ModelElement;
		reference base[1-*] : Classifier;
		reference availableFeature[*] : Feature;
		reference multiplicity[0-1] container : Multiplicity;
		
	}

	class AssociationRole extends Association {
		reference conformingLink[*] : Link;
		reference base[0-1] : Association;
		reference message[*] : Message oppositeOf communicationConnection;
		reference multiplicity[0-1] container : Multiplicity;
		
	}

	class AssociationEndRole extends AssociationEnd {
		reference availableQualifier[*] : Attribute;
		reference base[0-1] : AssociationEnd;
		reference collaborationMultiplicity[0-1] container : Multiplicity;
		
	}

	class Message extends ModelElement {
		reference sender : ClassifierRole;
		reference action : Action;
		reference activator[0-1] : Message;
		reference communicationConnection[0-1] : AssociationRole oppositeOf message;
		reference conformingStimulus[*] : Stimulus;
		reference predecessor[*] : Message;
		reference receiver : ClassifierRole;
		reference interaction : Interaction oppositeOf message;
		
	}

	class Interaction extends ModelElement {
		reference context : Collaboration oppositeOf interaction;
		reference message[1-*] container : Message oppositeOf interaction;
		
	}

	class InteractionInstanceSet extends ModelElement {
		reference participatingStimulus[1-*] : Stimulus;
		reference context : CollaborationInstanceSet oppositeOf interactionInstanceSet;
		reference interaction[0-1] : Interaction;
		
	}

	class CollaborationInstanceSet extends ModelElement {
		reference collaboration[0-1] : Collaboration;
		reference participatingLink[*] : Link;
		reference participatingInstance[1-*] : Instance;
		reference constrainingElement[*] : ModelElement;
		reference interactionInstanceSet[*] container : InteractionInstanceSet oppositeOf context;
		
	}

	abstract class Instance extends ModelElement {
		reference ownedLink[*] container : Link;
		reference componentInstance[0-1] : ComponentInstance oppositeOf resident;
		reference linkEnd[*] : LinkEnd oppositeOf instance;
		reference classifier[1-*] : Classifier;
		reference slot[*] container : AttributeLink oppositeOf instance;
		reference ownedInstance[*] container : Instance;
		
	}

	class Signal extends Classifier {
		reference context[*] : BehavioralFeature;
		
	}

	abstract class Action extends ModelElement {
		reference actionSequence[0-1] : ActionSequence oppositeOf action;
		reference actualArgument[*] ordered container : Argument oppositeOf action;
		reference recurrence[0-1] container : IterationExpression;
		reference target[0-1] container : ObjectSetExpression;
		attribute isAsynchronous : Boolean;
		reference script[0-1] container : ActionExpression;
		
	}

	class CreateAction extends Action {
		reference instantiation : Classifier;
		
	}

	class DestroyAction extends Action {
		
	}

	class UninterpretedAction extends Action {
		
	}

	class AttributeLink extends ModelElement {
		reference linkEnd[0-1] : LinkEnd oppositeOf qualifiedValue;
		reference instance[0-1] : Instance oppositeOf slot;
		reference value : Instance;
		reference "attribute" : Attribute;
		
	}

	class Object extends Instance {
		
	}

	class Link extends ModelElement {
		reference connection[2-*] container : LinkEnd oppositeOf link;
		reference association : Association;
		
	}

	class LinkObject extends Object, Link {
		
	}

	class DataValue extends Instance {
		
	}

	class CallAction extends Action {
		reference "operation" : Operation;
		
	}

	class SendAction extends Action {
		reference signal : Signal;
		
	}

	class ActionSequence extends Action {
		reference action[*] ordered container : Action oppositeOf actionSequence;
		
	}

	class Argument extends ModelElement {
		reference action[0-1] : Action oppositeOf actualArgument;
		reference value container : Expression;
		
	}

	class Reception extends BehavioralFeature {
		reference signal : Signal;
		attribute specification[0-1] : String;
		attribute isRoot : Boolean;
		attribute isLeaf : Boolean;
		attribute isAbstract : Boolean;
		
	}

	class LinkEnd extends ModelElement {
		reference associationEnd : AssociationEnd;
		reference instance : Instance oppositeOf linkEnd;
		reference qualifiedValue[*] ordered container : AttributeLink oppositeOf linkEnd;
		reference link : Link oppositeOf connection;
		
	}

	class ReturnAction extends Action {
		
	}

	class TerminateAction extends Action {
		
	}

	class Stimulus extends ModelElement {
		reference receiver : Instance;
		reference dispatchAction : Action;
		reference sender : Instance;
		reference argument[*] ordered : Instance;
		reference communicationLink[0-1] : Link;
		
	}

	class Exception extends Signal {
		
	}

	class ComponentInstance extends Instance {
		reference nodeInstance[0-1] : NodeInstance oppositeOf resident;
		reference resident[*] : Instance oppositeOf componentInstance;
		
	}

	class NodeInstance extends Instance {
		reference resident[*] : ComponentInstance oppositeOf nodeInstance;
		
	}

	class SubsystemInstance extends Instance {
		
	}

	class Point {
		attribute x : Double;
		attribute y : Double;
		
	}

	class Dimension {
		attribute width : Double;
		attribute height : Double;
		
	}

	class BezierPoint {
		reference base container : Point;
		reference control1 container : Point;
		reference control2 container : Point;
		
	}

	abstract class DiagramElement {
		reference "container"[0-1] : GraphElement oppositeOf contained;
		reference "reference"[*] : Reference oppositeOf referenced;
		reference property[*] container : Property;
		attribute isVisible : Boolean;
		
	}

	abstract class GraphElement extends DiagramElement {
		reference semanticModel container : SemanticModelBridge oppositeOf graphElement;
		reference link[*] container : DiagramLink oppositeOf graphElement;
		reference anchorage[*] container : GraphConnector oppositeOf graphElement;
		reference contained[*] ordered container : DiagramElement oppositeOf "container";
		reference position container : Point;
		
	}

	abstract class SemanticModelBridge {
		reference graphElement : GraphElement oppositeOf semanticModel;
		reference diagram[0-1] : Diagram oppositeOf owner;
		attribute presentation : String;
		
	}

	class GraphEdge extends GraphElement {
		reference anchor[2-2] ordered : GraphConnector oppositeOf graphEdge;
		reference waypoints[2-*] ordered container : BezierPoint;
		
	}

	class GraphNode extends GraphElement {
		reference size[0-1] container : Dimension;
		
	}

	class GraphConnector {
		reference graphEdge[*] : GraphEdge oppositeOf anchor;
		reference graphElement : GraphElement oppositeOf anchorage;
		reference position container : Point;
		
	}

	abstract class LeafElement extends DiagramElement {
		
	}

	class Reference extends DiagramElement {
		reference referenced : DiagramElement oppositeOf "reference";
		attribute isIndividualPresentation : Boolean;
		
	}

	class TextElement extends LeafElement {
		attribute text : String;
		
	}

	abstract class GraphicPrimitive extends LeafElement {
		
	}

	class Polyline extends GraphicPrimitive {
		reference waypoints[2-*] ordered container : BezierPoint;
		attribute closed : Boolean;
		
	}

	class Ellipse extends GraphicPrimitive {
		reference center container : Point;
		attribute radiusX : Double;
		attribute radiusY : Double;
		attribute rotation : Double;
		attribute startAngle : Double;
		attribute endAngle : Double;
		
	}

	class Image extends LeafElement {
		attribute uri : String;
		attribute mimeType : String;
		
	}

	class Property {
		attribute key : String;
		attribute value : String;
		
	}

	class SimpleSemanticModelElement extends SemanticModelBridge {
		attribute typeInfo : String;
		
	}

	class Uml1SemanticModelBridge extends SemanticModelBridge {
		reference element : Element;
		
	}

	class CoreSemanticModelBridge extends SemanticModelBridge {
		
	}

	class DiagramLink {
		reference graphElement : GraphElement oppositeOf link;
		reference diagram : Diagram oppositeOf diagramLink;
		attribute zoom : Double;
		reference viewport container : Point;
		
	}

	class Diagram extends GraphNode {
		reference owner container : SemanticModelBridge oppositeOf diagram;
		reference diagramLink[*] : DiagramLink oppositeOf diagram;
		attribute name : String;
		attribute zoom : Double;
		reference viewport container : Point;
		
	}

	enumeration AggregationKind {
		literal ak_none;
		literal ak_aggregate;
		literal ak_composite;
	}

	enumeration CallConcurrencyKind {
		literal cck_sequential;
		literal cck_guarded;
		literal cck_concurrent;
	}

	enumeration ChangeableKind {
		literal ck_changeable;
		literal ck_frozen;
		literal ck_addOnly;
	}

	enumeration OrderingKind {
		literal ok_unordered;
		literal ok_ordered;
	}

	enumeration ParameterDirectionKind {
		literal pdk_in;
		literal pdk_inout;
		literal pdk_out;
		literal pdk_return;
	}

	enumeration ScopeKind {
		literal sk_instance;
		literal sk_classifier;
	}

	enumeration VisibilityKind {
		literal vk_public;
		literal vk_protected;
		literal vk_private;
		literal vk_package;
	}

	class Multiplicity {
		reference range[1-*] container : MultiplicityRange oppositeOf multiplicity;
		
	}

	class MultiplicityRange {
		reference multiplicity : Multiplicity oppositeOf range;
		attribute lower : Integer;
		attribute upper : Integer;
		
	}

	class Expression {
		attribute language[0-1] : String;
		attribute body : String;
		
	}

	class BooleanExpression extends Expression {
		
	}

	class TypeExpression extends Expression {
		
	}

	class MappingExpression extends Expression {
		
	}

	class ProcedureExpression extends Expression {
		
	}

	class ObjectSetExpression extends Expression {
		
	}

	class ActionExpression extends Expression {
		
	}

	class IterationExpression extends Expression {
		
	}

	class TimeExpression extends Expression {
		
	}

	class ArgListsExpression extends Expression {
		
	}

	enumeration PseudostateKind {
		literal pk_choice;
		literal pk_deepHistory;
		literal pk_fork;
		literal pk_initial;
		literal pk_join;
		literal pk_junction;
		literal pk_shallowHistory;
	}

	datatype Boolean;

	datatype Double;

	datatype Float;

	datatype Integer;

	datatype Long;

	datatype String;

	class StateMachine extends ModelElement {
		reference context[0-1] : ModelElement;
		reference submachineState[*] : SubmachineState oppositeOf submachine;
		reference top container : State oppositeOf stateMachine;
		reference transitions[*] container : Transition oppositeOf stateMachine;
		
	}

	abstract class Event extends ModelElement {
		reference parameter[*] ordered container : Parameter;
		
	}

	abstract class StateVertex extends ModelElement {
		reference outgoing[*] : Transition oppositeOf source;
		reference "container"[0-1] : CompositeState oppositeOf subvertex;
		reference incoming[*] : Transition oppositeOf target;
		
	}

	abstract class State extends StateVertex {
		reference deferrableEvent[*] : Event;
		reference exit[0-1] container : Action;
		reference entry[0-1] container : Action;
		reference doActivity[0-1] container : Action;
		reference stateMachine[0-1] : StateMachine oppositeOf top;
		reference internalTransition[*] container : Transition;
		
	}

	class TimeEvent extends Event {
		reference when container : TimeExpression;
		
	}

	class CallEvent extends Event {
		reference "operation" : Operation;
		
	}

	class SignalEvent extends Event {
		reference signal : Signal;
		
	}

	class Transition extends ModelElement {
		reference guard[0-1] container : Guard oppositeOf transition;
		reference trigger[0-1] : Event;
		reference target : StateVertex oppositeOf incoming;
		reference source : StateVertex oppositeOf outgoing;
		reference effect[0-1] container : Action;
		reference stateMachine[0-1] : StateMachine oppositeOf transitions;
		
	}

	class CompositeState extends State {
		reference subvertex[*] container : StateVertex oppositeOf "container";
		attribute isConcurrent : Boolean;
		
	}

	class ChangeEvent extends Event {
		reference changeExpression container : BooleanExpression;
		
	}

	class Guard extends ModelElement {
		reference transition : Transition oppositeOf guard;
		reference expression container : BooleanExpression;
		
	}

	class Pseudostate extends StateVertex {
		attribute kind : PseudostateKind;
		
	}

	class SimpleState extends State {
		
	}

	class SubmachineState extends CompositeState {
		reference submachine : StateMachine oppositeOf submachineState;
		
	}

	class SynchState extends StateVertex {
		attribute bound : Integer;
		
	}

	class StubState extends StateVertex {
		attribute referenceState : String;
		
	}

	class FinalState extends State {
		
	}

	class Package extends GeneralizableElement, Namespace {
		reference elementImport[*] container : ElementImport oppositeOf "package";
		
	}

	class Model extends Package {
		
	}

	class Subsystem extends Package, Classifier {
		attribute isInstantiable : Boolean;
		
	}

	class ElementImport {
		reference "package" : Package oppositeOf elementImport;
		reference importedElement : ModelElement;
		attribute visibility[0-1] : VisibilityKind;
		attribute alias[0-1] : String;
		attribute isSpecification : Boolean;
		
	}

	class ActivityGraph extends StateMachine {
		reference partition[*] container : Partition oppositeOf activityGraph;
		
	}

	class Partition extends ModelElement {
		reference contents[*] : ModelElement;
		reference activityGraph : ActivityGraph oppositeOf partition;
		
	}

	class SubactivityState extends SubmachineState {
		attribute isDynamic : Boolean;
		reference dynamicArguments[0-1] container : ArgListsExpression;
		reference dynamicMultiplicity[0-1] container : Multiplicity;
		
	}

	class ActionState extends SimpleState {
		attribute isDynamic : Boolean;
		reference dynamicArguments[0-1] container : ArgListsExpression;
		reference dynamicMultiplicity[0-1] container : Multiplicity;
		
	}

	class CallState extends ActionState {
		
	}

	class ObjectFlowState extends SimpleState {
		reference type : Classifier;
		reference parameter[*] : Parameter;
		attribute isSynch : Boolean;
		
	}

	class ClassifierInState extends Classifier {
		reference type : Classifier;
		reference inState[1-*] : State;
		
	}

	abstract class Element {
		
	}

	abstract class ModelElement extends Element {
		reference stereotype[*] : Stereotype;
		reference comment[*] : Comment oppositeOf annotatedElement;
		reference taggedValue[*] container : TaggedValue oppositeOf modelElement;
		reference templateParameter[*] ordered container : TemplateParameter oppositeOf template;
		reference namespace[0-1] : Namespace oppositeOf ownedElement;
		reference clientDependency[*] : Dependency oppositeOf client;
		reference targetFlow[*] : Flow oppositeOf target;
		reference constraint[*] : Constraint oppositeOf constrainedElement;
		reference sourceFlow[*] : Flow oppositeOf source;
		attribute name[0-1] : String;
		attribute visibility[0-1] : VisibilityKind;
		attribute isSpecification : Boolean;
		
	}

	abstract class GeneralizableElement extends ModelElement {
		reference generalization[*] : Generalization oppositeOf child;
		attribute isRoot : Boolean;
		attribute isLeaf : Boolean;
		attribute isAbstract : Boolean;
		
	}

	abstract class Namespace extends ModelElement {
		reference ownedElement[*] container : ModelElement oppositeOf namespace;
		
	}

	abstract class Classifier extends GeneralizableElement, Namespace {
		reference powertypeRange[*] : Generalization oppositeOf powertype;
		reference feature[*] ordered container : Feature oppositeOf owner;
		
	}

	class Class extends Classifier {
		attribute isActive : Boolean;
		
	}

	class DataType extends Classifier {
		
	}

	abstract class Feature extends ModelElement {
		reference owner[0-1] : Classifier oppositeOf feature;
		attribute ownerScope : ScopeKind;
		
	}

	abstract class StructuralFeature extends Feature {
		reference type : Classifier;
		reference multiplicity[0-1] container : Multiplicity;
		attribute changeability[0-1] : ChangeableKind;
		attribute targetScope[0-1] : ScopeKind;
		attribute ordering[0-1] : OrderingKind;
		
	}

	class AssociationEnd extends ModelElement {
		reference specification[*] : Classifier;
		reference participant : Classifier;
		reference qualifier[*] ordered container : Attribute oppositeOf associationEnd;
		reference association : Association oppositeOf connection;
		attribute isNavigable : Boolean;
		attribute ordering[0-1] : OrderingKind;
		attribute aggregation[0-1] : AggregationKind;
		attribute targetScope[0-1] : ScopeKind;
		reference multiplicity[0-1] container : Multiplicity;
		attribute changeability[0-1] : ChangeableKind;
		
	}

	class Interface extends Classifier {
		
	}

	class Constraint extends ModelElement {
		reference constrainedElement[*] ordered : ModelElement oppositeOf constraint;
		reference body[0-1] container : BooleanExpression;
		
	}

	abstract class Relationship extends ModelElement {
		
	}

	class Association extends GeneralizableElement, Relationship {
		reference connection[2-*] ordered container : AssociationEnd oppositeOf association;
		
	}

	class Attribute extends StructuralFeature {
		reference associationEnd[0-1] : AssociationEnd oppositeOf qualifier;
		reference initialValue[0-1] container : Expression;
		
	}

	abstract class BehavioralFeature extends Feature {
		reference parameter[*] ordered container : Parameter oppositeOf behavioralFeature;
		attribute isQuery : Boolean;
		
	}

	class Operation extends BehavioralFeature {
		attribute concurrency[0-1] : CallConcurrencyKind;
		attribute isRoot : Boolean;
		attribute isLeaf : Boolean;
		attribute isAbstract : Boolean;
		attribute specification[0-1] : String;
		
	}

	class Parameter extends ModelElement {
		reference behavioralFeature[0-1] : BehavioralFeature oppositeOf parameter;
		reference type : Classifier;
		reference defaultValue[0-1] container : Expression;
		attribute kind : ParameterDirectionKind;
		
	}

	class Method extends BehavioralFeature {
		reference specification : Operation;
		reference body container : ProcedureExpression;
		
	}

	class Generalization extends Relationship {
		reference child : GeneralizableElement oppositeOf generalization;
		reference powertype[0-1] : Classifier oppositeOf powertypeRange;
		reference parent : GeneralizableElement;
		attribute discriminator[0-1] : String;
		
	}

	class AssociationClass extends Association, Class {
		
	}

	class Dependency extends Relationship {
		reference client[1-*] : ModelElement oppositeOf clientDependency;
		reference supplier[1-*] : ModelElement;
		
	}

	class Abstraction extends Dependency {
		reference mapping[0-1] container : MappingExpression;
		
	}

	abstract class PresentationElement extends Element {
		reference subject[*] : ModelElement;
		
	}

	class Usage extends Dependency {
		
	}

	class Binding extends Dependency {
		reference argument[1-*] ordered container : TemplateArgument oppositeOf binding;
		
	}

	class Component extends Classifier {
		reference deploymentLocation[*] : Node oppositeOf deployedComponent;
		reference residentElement[*] container : ElementResidence oppositeOf "container";
		reference implementation[*] : Artifact;
		
	}

	class Node extends Classifier {
		reference deployedComponent[*] : Component oppositeOf deploymentLocation;
		
	}

	class Permission extends Dependency {
		
	}

	class Comment extends ModelElement {
		reference annotatedElement[*] : ModelElement oppositeOf comment;
		attribute body : String;
		
	}

	class Flow extends Relationship {
		reference source[*] : ModelElement oppositeOf sourceFlow;
		reference target[*] : ModelElement oppositeOf targetFlow;
		
	}

	class ElementResidence {
		reference "container" : Component oppositeOf residentElement;
		reference resident : ModelElement;
		attribute visibility[0-1] : VisibilityKind;
		
	}

	class TemplateParameter {
		reference template : ModelElement oppositeOf templateParameter;
		reference parameter container : ModelElement;
		reference defaultElement[0-1] : ModelElement;
		
	}

	class Primitive extends DataType {
		
	}

	class Enumeration extends DataType {
		reference "literal"[1-*] ordered container : EnumerationLiteral oppositeOf "enumeration";
		
	}

	class EnumerationLiteral extends ModelElement {
		reference "enumeration" : Enumeration oppositeOf "literal";
		
	}

	class Stereotype extends GeneralizableElement {
		reference definedTag[*] container : TagDefinition oppositeOf owner;
		reference stereotypeConstraint[*] container : Constraint;
		attribute icon[0-1] : String;
		attribute baseClass[1-*] : String;
		
	}

	class TagDefinition extends ModelElement {
		reference owner[0-1] : Stereotype oppositeOf definedTag;
		attribute tagType[0-1] : String;
		reference multiplicity[0-1] container : Multiplicity;
		
	}

	class TaggedValue extends ModelElement {
		reference type : TagDefinition;
		reference modelElement : ModelElement oppositeOf taggedValue;
		reference referenceValue[*] : ModelElement;
		attribute dataValue[*] : String;
		
	}

	class ProgrammingLanguageDataType extends DataType {
		reference expression container : TypeExpression;
		
	}

	class Artifact extends Classifier {
		
	}

	class TemplateArgument {
		reference modelElement : ModelElement;
		reference binding : Binding oppositeOf argument;
		
	}

	class UseCase extends Classifier {
		reference include[*] : Include oppositeOf base;
		reference extend[*] : Extend oppositeOf extension;
		reference extensionPoint[*] container : ExtensionPoint oppositeOf useCase;
		
	}

	class Actor extends Classifier {
		
	}

	class UseCaseInstance extends Instance {
		
	}

	class Extend extends Relationship {
		reference extension : UseCase oppositeOf extend;
		reference extensionPoint[1-*] ordered : ExtensionPoint;
		reference base : UseCase;
		reference condition container : BooleanExpression;
		
	}

	class Include extends Relationship {
		reference base : UseCase oppositeOf include;
		reference addition : UseCase;
		
	}

	class ExtensionPoint extends ModelElement {
		reference useCase : UseCase oppositeOf extensionPoint;
		attribute location : String;
		
	}

}