sysmledgraph 0.7.0

package/lsp/node_modules/sysml-v2-lsp/sysml.library/Kernel Libraries/Kernel Semantic Library/KerML.kerml

@@ -0,0 +1,483 @@
+standard library package KerML {
+	doc 
+	/*
+	 * This package contains a reflective KerML model of the KerML abstract syntax.
+	 */
+	 
+	private import ScalarValues::*;
+	public import Kernel::*;
+	
+	package Root {
+		metaclass AnnotatingElement specializes Element {
+			derived var feature annotatedElement : Element[1..*] ordered redefines annotatedElement;
+			derived composite var feature ownedAnnotatingRelationship : Annotation[0..*] ordered subsets annotation, ownedRelationship;
+			derived var feature owningAnnotatingRelationship : Annotation[0..1] subsets owningRelationship, annotation;
+			derived var feature annotation : Annotation[0..*] ordered;
+		}		
+		
+		metaclass Annotation specializes Relationship {
+			var feature annotatedElement : Element[1..1] redefines target, annotatedElement;
+			derived var feature annotatingElement : AnnotatingElement[1..1] redefines source;
+			derived var feature owningAnnotatedElement : Element[0..1] subsets annotatedElement, owningRelatedElement;
+			derived var feature owningAnnotatingElement : AnnotatingElement[0..1] subsets annotatingElement, owningRelatedElement;
+			derived composite var feature ownedAnnotatingElement : AnnotatingElement[0..1] subsets annotatingElement, ownedRelatedElement;
+		}		
+		
+		metaclass Comment specializes AnnotatingElement {
+			var feature 'locale' : String[0..1];
+			var feature body : String[1..1];
+		}		
+		
+		metaclass Dependency specializes Relationship {
+			var feature client : Element[1..*] ordered redefines source;
+			var feature supplier : Element[1..*] ordered redefines target;
+		}		
+		
+		metaclass Documentation specializes Comment {
+			derived var feature documentedElement : Element[1..1] subsets owner redefines annotatedElement;
+		}		
+		
+		abstract metaclass Element {
+			var feature elementId : String[1..1];
+			var feature aliasIds : String[0..*] ordered;
+			var feature declaredShortName : String[0..1];
+			var feature declaredName : String[0..1];
+			var feature isImpliedIncluded : Boolean[1..1];
+			derived var feature shortName : String[0..1];
+			derived var feature name : String[0..1];
+			derived var feature qualifiedName : String[0..1];
+			derived var feature isLibraryElement : Boolean[1..1];
+			
+			var feature owningRelationship : Relationship[0..1];
+			composite var feature ownedRelationship : Relationship[0..*] ordered;
+			derived var feature owningMembership : OwningMembership[0..1] subsets owningRelationship;
+			derived var feature owningNamespace : Namespace[0..1];
+			derived var feature owner : Element[0..1];
+			derived var feature ownedElement : Element[0..*] ordered;
+			derived var feature documentation : Documentation[0..*] ordered subsets ownedElement;
+			derived composite var feature ownedAnnotation : Annotation[0..*] ordered subsets ownedRelationship;
+			derived var feature textualRepresentation : TextualRepresentation[0..*] ordered subsets ownedElement;
+		}		
+		
+		abstract metaclass Import specializes Relationship {
+			var feature visibility : VisibilityKind[1..1];
+			var feature isRecursive : Boolean[1..1];
+			var feature isImportAll : Boolean[1..1];
+			
+			derived var feature importOwningNamespace : Namespace[1..1] subsets owningRelatedElement redefines source;
+			derived var feature importedElement : Element[1..1];
+		}		
+		
+		metaclass Membership specializes Relationship {
+			var feature memberShortName : String[0..1];
+			var feature memberName : String[0..1];
+			var feature visibility : VisibilityKind[1..1];
+			derived var feature memberElementId : String[1..1];
+			
+			var feature memberElement : Element[1..1] redefines target;
+			derived var feature membershipOwningNamespace : Namespace[1..1] subsets owningRelatedElement redefines source;
+		}		
+		
+		metaclass MembershipImport specializes Import {
+			var feature importedMembership : Membership[1..1] redefines target;
+		}		
+		
+		metaclass Namespace specializes Element {
+			derived abstract var feature membership : Membership[0..*] ordered;
+			derived composite var feature ownedImport : Import[0..*] ordered subsets ownedRelationship;
+			derived var feature 'member' : Element[0..*] ordered;
+			derived var feature ownedMember : Element[0..*] ordered subsets 'member';
+			derived composite var feature ownedMembership : Membership[0..*] ordered subsets membership, ownedRelationship;
+			derived var feature importedMembership : Membership[0..*] ordered subsets membership;
+		}		
+		
+		metaclass NamespaceImport specializes Import {
+			var feature importedNamespace : Namespace[1..1] redefines target;
+		}		
+		
+		metaclass OwningMembership specializes Membership {
+			derived var feature ownedMemberElementId : String[1..1] redefines memberElementId;
+			derived var feature ownedMemberShortName : String[0..1] redefines memberShortName;
+			derived var feature ownedMemberName : String[0..1] redefines memberName;
+			
+			derived composite var feature ownedMemberElement : Element[1..1] subsets ownedRelatedElement redefines memberElement;
+		}		
+		
+		abstract metaclass Relationship specializes Element {
+			var feature isImplied : Boolean[1..1];
+			
+			var feature target : Element[0..*] ordered subsets relatedElement;
+			var feature source : Element[0..*] ordered subsets relatedElement;
+			var feature owningRelatedElement : Element[0..1] subsets relatedElement;
+			composite var feature ownedRelatedElement : Element[0..*] ordered subsets relatedElement;
+			derived var feature relatedElement : Element[0..*] ordered nonunique;
+		}		
+		
+		metaclass TextualRepresentation specializes AnnotatingElement {
+			var feature 'language' : String[1..1];
+			var feature body : String[1..1];
+			
+			derived var feature representedElement : Element[1..1] subsets owner redefines annotatedElement;
+		}		
+		
+		datatype VisibilityKind {
+			member feature 'private' : VisibilityKind[1];
+			member feature 'protected' : VisibilityKind[1];
+			member feature 'public' : VisibilityKind[1];
+		}
+		
+	}
+	
+	package Core {
+		public import Root::*;
+		
+		metaclass Classifier specializes Type {
+			derived composite var feature ownedSubclassification : Subclassification[0..*] subsets ownedSpecialization;
+		}		
+		
+		metaclass Conjugation specializes Relationship {
+			var feature originalType : Type[1..1] redefines target;
+			var feature conjugatedType : Type[1..1] redefines source;
+			derived var feature owningType : Type[0..1] subsets conjugatedType, owningRelatedElement;
+		}		
+		
+		metaclass CrossSubsetting specializes Subsetting {
+			var feature crossedFeature : Feature[1..1] redefines subsettedFeature;
+			derived var feature crossingFeature : Feature[1..1] redefines owningFeature, subsettingFeature;
+		}		
+		
+		metaclass Differencing specializes Relationship {
+			var feature differencingType : Type[1..1] redefines target;
+			derived var feature typeDifferenced : Type[1..1] subsets owningRelatedElement redefines source;
+		}		
+		
+		metaclass Disjoining specializes Relationship {
+			var feature typeDisjoined : Type[1..1] redefines source;
+			var feature disjoiningType : Type[1..1] redefines target;
+			derived var feature owningType : Type[0..1] subsets owningRelatedElement, typeDisjoined;
+		}		
+		
+		metaclass EndFeatureMembership specializes FeatureMembership {
+			derived composite var feature ownedMemberFeature : Feature[1..1] redefines ownedMemberFeature;
+		}		
+		
+		metaclass Feature specializes Type {
+			var feature isUnique : Boolean[1..1];
+			var feature isOrdered : Boolean[1..1];
+			var feature isComposite : Boolean[1..1];
+			var feature isEnd : Boolean[1..1];
+			var feature isDerived : Boolean[1..1];
+			var feature isPortion : Boolean[1..1];
+			var feature isVariable : Boolean[1..1];
+			var feature isConstant : Boolean[1..1];
+			var feature direction : FeatureDirectionKind[0..1];
+			
+			derived var feature owningType : Type[0..1] subsets owningNamespace, featuringType;
+			derived var feature 'type' : Type[0..*] ordered;
+			derived composite var feature ownedRedefinition : Redefinition[0..*] subsets ownedSubsetting;
+			derived composite var feature ownedSubsetting : Subsetting[0..*] subsets ownedSpecialization;
+			derived var feature owningFeatureMembership : FeatureMembership[0..1] subsets owningMembership;
+			derived var feature endOwningType : Type[0..1] subsets owningType;
+			derived composite var feature ownedTyping : FeatureTyping[0..*] ordered subsets ownedSpecialization;
+			derived var feature featuringType : Type[0..*] ordered;
+			derived composite var feature ownedTypeFeaturing : TypeFeaturing[0..*] ordered subsets ownedRelationship;
+			derived var feature chainingFeature : Feature[0..*] ordered nonunique;
+			derived composite var feature ownedFeatureInverting : FeatureInverting[0..*] subsets ownedRelationship;
+			derived composite var feature ownedFeatureChaining : FeatureChaining[0..*] ordered subsets ownedRelationship;
+			derived composite var feature ownedReferenceSubsetting : ReferenceSubsetting[0..1] subsets ownedSubsetting;
+			derived var feature featureTarget : Feature[1..1];
+			derived var feature crossFeature : Feature[0..1];
+			derived composite var feature ownedCrossSubsetting : CrossSubsetting[0..1] subsets ownedSubsetting;
+		}		
+		
+		metaclass FeatureChaining specializes Relationship {
+			var feature chainingFeature : Feature[1..1] redefines target;
+			derived var feature featureChained : Feature[1..1] subsets owningRelatedElement redefines source;
+		}		
+		
+		datatype FeatureDirectionKind {
+			member feature 'in' : FeatureDirectionKind[1];
+			member feature 'inout' : FeatureDirectionKind[1];
+			member feature 'out' : FeatureDirectionKind[1];
+		}
+		
+		metaclass FeatureInverting specializes Relationship {
+			var feature featureInverted : Feature[1..1] redefines source;
+			var feature invertingFeature : Feature[1..1] redefines target;
+			derived var feature owningFeature : Feature[0..1] subsets featureInverted, owningRelatedElement;
+		}		
+		
+		metaclass FeatureMembership specializes OwningMembership {
+			derived var feature owningType : Type[1..1] redefines membershipOwningNamespace;
+			derived composite var feature ownedMemberFeature : Feature[1..1] redefines ownedMemberElement;
+		}		
+		
+		metaclass FeatureTyping specializes Specialization {
+			var feature typedFeature : Feature[1..1] redefines specific;
+			var feature 'type' : Type[1..1] redefines general;
+			derived var feature owningFeature : Feature[0..1] subsets typedFeature redefines owningType;
+		}		
+		
+		metaclass Intersecting specializes Relationship {
+			var feature intersectingType : Type[1..1] redefines target;
+			derived var feature typeIntersected : Type[1..1] subsets owningRelatedElement redefines source;
+		}		
+		
+		metaclass Multiplicity specializes Feature;		
+		
+		metaclass Redefinition specializes Subsetting {
+			var feature redefiningFeature : Feature[1..1] redefines subsettingFeature;
+			var feature redefinedFeature : Feature[1..1] redefines subsettedFeature;
+		}		
+		
+		metaclass ReferenceSubsetting specializes Subsetting {
+			var feature referencedFeature : Feature[1..1] redefines subsettedFeature;
+			derived var feature referencingFeature : Feature[1..1] redefines owningFeature, subsettingFeature;
+		}		
+		
+		metaclass Specialization specializes Relationship {
+			var feature general : Type[1..1] redefines target;
+			var feature specific : Type[1..1] redefines source;
+			derived var feature owningType : Type[0..1] subsets owningRelatedElement, specific;
+		}		
+		
+		metaclass Subclassification specializes Specialization {
+			var feature superclassifier : Classifier[1..1] redefines general;
+			var feature 'subclassifier' : Classifier[1..1] redefines specific;
+			derived var feature owningClassifier : Classifier[0..1] redefines owningType;
+		}		
+		
+		metaclass Subsetting specializes Specialization {
+			var feature subsettedFeature : Feature[1..1] redefines general;
+			var feature subsettingFeature : Feature[1..1] redefines specific;
+			derived var feature owningFeature : Feature[0..1] subsets subsettingFeature redefines owningType;
+		}		
+		
+		metaclass Type specializes Namespace {
+			var feature isAbstract : Boolean[1..1];
+			var feature isSufficient : Boolean[1..1];
+			derived var feature isConjugated : Boolean[1..1];
+			
+			derived composite var feature ownedSpecialization : Specialization[0..*] ordered subsets ownedRelationship;
+			derived composite var feature ownedFeatureMembership : FeatureMembership[0..*] ordered subsets ownedMembership, featureMembership;
+			derived var feature 'feature' : Feature[0..*] ordered subsets 'member';
+			derived var feature ownedFeature : Feature[0..*] ordered subsets ownedMember;
+			derived var feature input : Feature[0..*] ordered subsets directedFeature;
+			derived var feature output : Feature[0..*] ordered subsets directedFeature;
+			derived var feature inheritedMembership : Membership[0..*] ordered subsets membership;
+			derived var feature endFeature : Feature[0..*] ordered subsets 'feature';
+			derived var feature ownedEndFeature : Feature[0..*] ordered subsets endFeature, ownedFeature;
+			derived composite var feature ownedConjugator : Conjugation[0..1] subsets ownedRelationship;
+			derived var feature inheritedFeature : Feature[0..*] ordered subsets 'feature';
+			derived var feature 'multiplicity' : Multiplicity[0..1] subsets ownedMember;
+			derived var feature unioningType : Type[0..*] ordered;
+			derived composite var feature ownedIntersecting : Intersecting[0..*] ordered subsets ownedRelationship;
+			derived var feature intersectingType : Type[0..*] ordered;
+			derived composite var feature ownedUnioning : Unioning[0..*] ordered subsets ownedRelationship;
+			derived composite var feature ownedDisjoining : Disjoining[0..*] subsets ownedRelationship;
+			derived var feature featureMembership : FeatureMembership[0..*] ordered;
+			derived var feature differencingType : Type[0..*] ordered;
+			derived composite var feature ownedDifferencing : Differencing[0..*] ordered subsets ownedRelationship;
+			derived var feature directedFeature : Feature[0..*] ordered subsets 'feature';
+		}		
+		
+		metaclass TypeFeaturing specializes Relationship {
+			var feature featureOfType : Feature[1..1] redefines source;
+			var feature featuringType : Type[1..1] redefines target;
+			derived var feature owningFeatureOfType : Feature[0..1] subsets owningRelatedElement, featureOfType;
+		}		
+		
+		metaclass Unioning specializes Relationship {
+			var feature unioningType : Type[1..1] redefines target;
+			derived var feature typeUnioned : Type[1..1] subsets owningRelatedElement redefines source;
+		}		
+		
+	}
+	
+	package Kernel {
+		public import Core::*;
+		
+		metaclass Association specializes Classifier, Relationship {
+			derived var feature relatedType : Type[0..*] ordered nonunique redefines relatedElement;
+			derived var feature sourceType : Type[0..1] subsets relatedType redefines source;
+			derived var feature targetType : Type[0..*] subsets relatedType redefines target;
+			derived var feature associationEnd : Feature[0..*] redefines endFeature;
+		}		
+		
+		metaclass AssociationStructure specializes Association, Structure;		
+		
+		metaclass Behavior specializes Class {
+			derived var feature 'step' : Step[0..*] subsets 'feature';
+			derived var feature parameter : Feature[0..*] ordered redefines directedFeature;
+		}		
+		
+		metaclass BindingConnector specializes Connector;		
+		
+		metaclass BooleanExpression specializes Expression {
+			derived var feature 'predicate' : Predicate[0..1] redefines 'function';
+		}		
+		
+		metaclass Class specializes Classifier;		
+		
+		metaclass CollectExpression specializes OperatorExpression {
+			var feature operator : String[1..1] redefines operator;
+		}		
+		
+		metaclass Connector specializes Feature, Relationship {
+			derived var feature relatedFeature : Feature[0..*] ordered nonunique redefines relatedElement;
+			derived var feature association : Association[0..*] ordered redefines 'type';
+			derived var feature connectorEnd : Feature[0..*] ordered redefines endFeature;
+			derived var feature sourceFeature : Feature[0..1] ordered subsets relatedFeature redefines source;
+			derived var feature targetFeature : Feature[0..*] ordered subsets relatedFeature redefines target;
+			derived var feature defaultFeaturingType : Type[0..1];
+		}		
+		
+		metaclass ConstructorExpression specializes InstantiationExpression;		
+		
+		metaclass DataType specializes Classifier;		
+		
+		metaclass ElementFilterMembership specializes OwningMembership {
+			derived composite var feature condition : Expression[1..1] redefines ownedMemberElement;
+		}		
+		
+		metaclass Expression specializes Step {
+			derived var feature isModelLevelEvaluable : Boolean[1..1];
+			
+			derived var feature 'function' : Function[0..1] redefines 'behavior';
+			derived var feature result : Feature[1..1] subsets output, parameter;
+		}		
+		
+		metaclass FeatureChainExpression specializes OperatorExpression {
+			var feature operator : String[1..1] redefines operator;
+			
+			derived var feature targetFeature : Feature[1..1] subsets 'member';
+		}		
+		
+		metaclass FeatureReferenceExpression specializes Expression {
+			derived var feature referent : Feature[1..1] subsets 'member';
+		}		
+		
+		metaclass FeatureValue specializes OwningMembership {
+			var feature isInitial : Boolean[1..1];
+			var feature isDefault : Boolean[1..1];
+			
+			derived var feature featureWithValue : Feature[1..1] subsets membershipOwningNamespace;
+			derived composite var feature value : Expression[1..1] redefines ownedMemberElement;
+		}		
+		
+		metaclass Flow specializes Connector, Step {
+			derived var feature payloadType : Classifier[0..*] ordered nonunique;
+			derived var feature targetInputFeature : Feature[0..1] ordered nonunique;
+			derived var feature sourceOutputFeature : Feature[0..1] ordered nonunique;
+			derived var feature flowEnd : FlowEnd[0..2] ordered subsets connectorEnd;
+			derived var feature payloadFeature : PayloadFeature[0..1] subsets ownedFeature;
+			derived var feature 'interaction' : Interaction[0..*] ordered redefines association, 'behavior';
+		}		
+		
+		metaclass FlowEnd specializes Feature;		
+		
+		metaclass Function specializes Behavior {
+			derived var feature isModelLevelEvaluable : Boolean[1..1];
+			
+			derived var feature expression : Expression[0..*] subsets 'step';
+			derived var feature result : Feature[1..1] subsets output, parameter;
+		}		
+		
+		metaclass IndexExpression specializes OperatorExpression {
+			var feature operator : String[1..1] redefines operator;
+		}		
+		
+		abstract metaclass InstantiationExpression specializes Expression {
+			derived var feature argument : Expression[0..*] ordered;
+			derived var feature instantiatedType : Type[1..1] subsets 'member';
+		}		
+		
+		metaclass Interaction specializes Association, Behavior;		
+		
+		metaclass Invariant specializes BooleanExpression {
+			var feature isNegated : Boolean[1..1];
+		}		
+		
+		metaclass InvocationExpression specializes InstantiationExpression;		
+		
+		metaclass LibraryPackage specializes Package {
+			var feature isStandard : Boolean[1..1];
+		}		
+		
+		metaclass LiteralBoolean specializes LiteralExpression {
+			var feature value : Boolean[1..1];
+		}		
+		
+		metaclass LiteralExpression specializes Expression;		
+		
+		metaclass LiteralInfinity specializes LiteralExpression;		
+		
+		metaclass LiteralInteger specializes LiteralExpression {
+			var feature value : Integer[1..1];
+		}		
+		
+		metaclass LiteralRational specializes LiteralExpression {
+			var feature value : Rational[1..1];
+		}		
+		
+		metaclass LiteralString specializes LiteralExpression {
+			var feature value : String[1..1];
+		}		
+		
+		metaclass Metaclass specializes Structure;		
+		
+		metaclass MetadataAccessExpression specializes Expression {
+			derived var feature referencedElement : Element[1..1] subsets 'member';
+		}		
+		
+		metaclass MetadataFeature specializes AnnotatingElement, Feature {
+			derived var feature 'metaclass' : Metaclass[0..1] subsets 'type';
+		}		
+		
+		metaclass MultiplicityRange specializes Multiplicity {
+			derived var feature lowerBound : Expression[0..1] subsets bound;
+			derived var feature upperBound : Expression[1..1] subsets bound;
+			derived var feature bound : Expression[1..2] ordered subsets ownedMember;
+		}		
+		
+		metaclass NullExpression specializes Expression;		
+		
+		metaclass OperatorExpression specializes InvocationExpression {
+			var feature operator : String[1..1];
+		}		
+		
+		metaclass Package specializes Namespace {
+			derived var feature filterCondition : Expression[0..*] ordered subsets ownedMember;
+		}		
+		
+		metaclass ParameterMembership specializes FeatureMembership {
+			derived composite var feature ownedMemberParameter : Feature[1..1] redefines ownedMemberFeature;
+		}		
+		
+		metaclass PayloadFeature specializes Feature;		
+		
+		metaclass Predicate specializes Function;		
+		
+		metaclass ResultExpressionMembership specializes FeatureMembership {
+			derived composite var feature ownedResultExpression : Expression[1..1] redefines ownedMemberFeature;
+		}		
+		
+		metaclass ReturnParameterMembership specializes ParameterMembership;		
+		
+		metaclass SelectExpression specializes OperatorExpression {
+			var feature operator : String[1..1] redefines operator;
+		}		
+		
+		metaclass Step specializes Feature {
+			derived var feature 'behavior' : Behavior[0..*] ordered subsets 'type';
+			derived var feature parameter : Feature[0..*] ordered redefines directedFeature;
+		}		
+		
+		metaclass Structure specializes Class;		
+		
+		metaclass Succession specializes Connector;		
+		
+		metaclass SuccessionFlow specializes Succession, Flow;		
+		
+	}
+}

package/lsp/node_modules/sysml-v2-lsp/sysml.library/Kernel Libraries/Kernel Semantic Library/Links.kerml

@@ -0,0 +1,67 @@
+standard library package Links {
+    doc
+    /*
+     * This package defines associations and features that are related to the typing of links.
+     */
+
+    private import Base::Anything;
+    private import Base::things;
+    
+    abstract assoc Link specializes Anything {
+        doc
+        /*
+         * Link is the most general association between two or more things.
+         */
+
+        feature participant: Anything[2..*] nonunique ordered;
+    }
+    
+    assoc all BinaryLink specializes Link {
+        doc
+        /*
+         * BinaryLink is the most general binary association between exactly two things, 
+         * nominally directed from source to target.
+         */
+         
+        feature participant: Anything[2] nonunique ordered redefines Link::participant;
+        
+        end feature source: Anything[1] subsets participant;
+        end feature target: Anything[1] subsets participant;
+    }
+    
+    assoc all SelfLink specializes BinaryLink {
+        doc
+        /*
+         * SelfLink is a binary association in which the things at the two ends are asserted
+         * to be the same.
+         */
+        
+        end feature thisThing: Anything redefines source subsets sameThing crosses sameThing.self;
+        end self2 [1] feature sameThing: Anything redefines target subsets thisThing;
+    }
+        
+    abstract feature links: Link[0..*] nonunique subsets things {
+        doc
+        /*
+         * links is the most general feature of links between individuals.
+         */
+    }
+    
+    abstract feature binaryLinks: BinaryLink[0..*] nonunique subsets links {
+        doc
+        /*
+         * binaryLinks is a specialization of links restricted to type BinaryLink.
+         */
+    }
+    
+    abstract feature selfLinks: SelfLink[0..*] nonunique subsets binaryLinks {
+        doc
+        /*
+         * selfLinks is a specialization of binaryLinks restricted to type SelfLink.
+         */
+
+        end feature thisThing: Anything redefines SelfLink::thisThing, binaryLinks::source;
+        end feature sameThing: Anything redefines SelfLink::sameThing, binaryLinks::target;
+    }
+
+}

package/lsp/node_modules/sysml-v2-lsp/sysml.library/Kernel Libraries/Kernel Semantic Library/Metaobjects.kerml

@@ -0,0 +1,58 @@
+standard library package Metaobjects {
+	doc
+	/*
+	 * This package defines Metaclasses and Features that are related to the typing of syntactic and semantic metadata.
+	 */
+
+	private import Objects::Object;
+	private import Objects::objects;
+	private import KerML::Element;
+	private import KerML::Type;
+	
+	abstract metaclass Metaobject specializes Object {
+		doc
+		/*
+		 * A Metaobject contains syntactic or semantic information about one or more annotatedElements. 
+		 * It is the most general Metaclass. All other Metaclasses must subclassify it directly or indirectly.
+		 */
+
+		feature redefines self : Metaobject;
+		
+		abstract feature annotatedElement : Element[1..*] {
+			doc
+			/*
+			 * The Elements annotated by this Metaobject. This is set automatically when a Metaobject is
+			 * instantiated as the value of a MetadataFeature.
+			 */
+		}
+	}
+	
+	abstract metaclass SemanticMetadata specializes Metaobject {
+		doc
+		/*
+		 * SemanticMetadata is a Metaobject that requires its single annotatedType to directly or indirectly specialize 
+		 * a baseType that models the semantics for the annotatedType.
+		 */
+		
+		abstract feature redefines annotatedElement : Type[1] {
+			doc
+			/*
+			 * The single annotatedElement of this SemanticMetadata, which must be a Type.
+			 */
+		}
+		
+		feature baseType : Type[1] {
+			doc
+			/*
+			 * The required base Type for the annotatedType.
+			 */
+		}
+	}
+	
+	feature metaobjects : Metaobject[0..*] :> objects {
+		/*
+		 * metaobjects is a specialization of objects restricted to type Metadata. It is the most general 
+		 * MetadataFeature. All other MetadataFeatures must subset it directly or indirectly.
+		 */
+	}
+}