@memoarchitect/tools 0.6.7 → 0.8.7

package/packages/tools/lib/language/generated/ast.js

@@ -9,12 +9,32 @@ export const MemoSysMLTerminals = {
     SL_COMMENT: /\/\/[^\n\r]*/,
     ML_COMMENT: /\/\*[\s\S]*?\*\//,
     DOC_COMMENT: /doc\s+\/\*[\s\S]*?\*\//,
+    SHORT_NAME: /<[a-zA-Z_][a-zA-Z0-9_]*>/,
     ID: /[a-zA-Z_][a-zA-Z0-9_]*/,
     UNRESTRICTED_NAME: /'(?:[^'\\]|\\.)*'/,
     STRING: /"(?:[^"\\]|\\.)*"/,
     REAL: /[0-9]+\.[0-9]+/,
     INT: /[0-9]+/,
 };
+export const AbstractConnectionUsage = {
+    $type: 'AbstractConnectionUsage',
+    isAbstract: 'isAbstract',
+    multiplicity: 'multiplicity',
+    name: 'name',
+    type: 'type'
+};
+export function isAbstractConnectionUsage(item) {
+    return reflection.isInstance(item, AbstractConnectionUsage.$type);
+}
+export const AcceptActionUsage = {
+    $type: 'AcceptActionUsage',
+    name: 'name',
+    payloadName: 'payloadName',
+    payloadType: 'payloadType'
+};
+export function isAcceptActionUsage(item) {
+    return reflection.isInstance(item, AcceptActionUsage.$type);
+}
 export const ActionDefBodyMember = {
     $type: 'ActionDefBodyMember'
 };
@@ -33,6 +53,9 @@ export const ActionDefinition = {
 export function isActionDefinition(item) {
     return reflection.isInstance(item, ActionDefinition.$type);
 }
+export function isActionName(item) {
+    return item === 'accept' || item === 'send' || item === 'terminate' || (typeof item === 'string' && (/[a-zA-Z_][a-zA-Z0-9_]*/.test(item)));
+}
 export const ActionParameterMember = {
     $type: 'ActionParameterMember',
     direction: 'direction',
@@ -58,6 +81,18 @@ export const ActionUsageBodyMember = {
 export function isActionUsageBodyMember(item) {
     return reflection.isInstance(item, ActionUsageBodyMember.$type);
 }
+export const ActorMember = {
+    $type: 'ActorMember',
+    bindingOp: 'bindingOp',
+    body: 'body',
+    boundRef: 'boundRef',
+    multiplicity: 'multiplicity',
+    name: 'name',
+    type: 'type'
+};
+export function isActorMember(item) {
+    return reflection.isInstance(item, ActorMember.$type);
+}
 export const AliasDeclaration = {
     $type: 'AliasDeclaration',
     name: 'name',
@@ -71,17 +106,38 @@ export function isAliasName(item) {
 }
 export const AllocateUsage = {
     $type: 'AllocateUsage',
+    body: 'body',
+    name: 'name',
     source: 'source',
-    target: 'target'
+    target: 'target',
+    type: 'type'
 };
 export function isAllocateUsage(item) {
     return reflection.isInstance(item, AllocateUsage.$type);
 }
+export const AllocationDefinition = {
+    $type: 'AllocationDefinition',
+    additionalSpecializations: 'additionalSpecializations',
+    body: 'body',
+    isAbstract: 'isAbstract',
+    name: 'name',
+    specialization: 'specialization'
+};
+export function isAllocationDefinition(item) {
+    return reflection.isInstance(item, AllocationDefinition.$type);
+}
+export const ArcadiaMember = {
+    $type: 'ArcadiaMember'
+};
+export function isArcadiaMember(item) {
+    return reflection.isInstance(item, ArcadiaMember.$type);
+}
 export const AttributeDefinition = {
     $type: 'AttributeDefinition',
     additionalSpecializations: 'additionalSpecializations',
     body: 'body',
     isAbstract: 'isAbstract',
+    isVariation: 'isVariation',
     name: 'name',
     specialization: 'specialization'
 };
@@ -91,6 +147,8 @@ export function isAttributeDefinition(item) {
 export const AttributeMember = {
     $type: 'AttributeMember',
     body: 'body',
+    isDefault: 'isDefault',
+    isVariation: 'isVariation',
     multiplicity: 'multiplicity',
     name: 'name',
     redefines: 'redefines',
@@ -115,6 +173,14 @@ export const BinaryExpr = {
 export function isBinaryExpr(item) {
     return reflection.isInstance(item, BinaryExpr.$type);
 }
+export const BindingUsage = {
+    $type: 'BindingUsage',
+    source: 'source',
+    target: 'target'
+};
+export function isBindingUsage(item) {
+    return reflection.isInstance(item, BindingUsage.$type);
+}
 export const BooleanValue = {
     $type: 'BooleanValue',
     value: 'value'
@@ -131,6 +197,26 @@ export const CollectionOp = {
 export function isCollectionOp(item) {
     return reflection.isInstance(item, CollectionOp.$type);
 }
+export const ConcernDefinition = {
+    $type: 'ConcernDefinition',
+    additionalSpecializations: 'additionalSpecializations',
+    body: 'body',
+    isAbstract: 'isAbstract',
+    name: 'name',
+    specialization: 'specialization'
+};
+export function isConcernDefinition(item) {
+    return reflection.isInstance(item, ConcernDefinition.$type);
+}
+export const ConcernUsage = {
+    $type: 'ConcernUsage',
+    body: 'body',
+    name: 'name',
+    type: 'type'
+};
+export function isConcernUsage(item) {
+    return reflection.isInstance(item, ConcernUsage.$type);
+}
 export const ConnectionBodyMember = {
     $type: 'ConnectionBodyMember'
 };
@@ -204,6 +290,17 @@ export const DefinitionMember = {
 export function isDefinitionMember(item) {
     return reflection.isInstance(item, DefinitionMember.$type);
 }
+export const Dependency = {
+    $type: 'Dependency',
+    body: 'body',
+    clients: 'clients',
+    name: 'name',
+    prefixMetadata: 'prefixMetadata',
+    suppliers: 'suppliers'
+};
+export function isDependency(item) {
+    return reflection.isInstance(item, Dependency.$type);
+}
 export const DocComment = {
     $type: 'DocComment',
     content: 'content'
@@ -214,11 +311,16 @@ export function isDocComment(item) {
 export function isDottedName(item) {
     return typeof item === 'string';
 }
+export function isDottedNameSegment(item) {
+    return item === 'accept' || item === 'send' || item === 'terminate' || (typeof item === 'string' && (/[a-zA-Z_][a-zA-Z0-9_]*/.test(item)));
+}
 export const EndDeclaration = {
     $type: 'EndDeclaration',
     isConjugated: 'isConjugated',
     multiplicity: 'multiplicity',
     name: 'name',
+    redefinedEnd: 'redefinedEnd',
+    redefines: 'redefines',
     type: 'type'
 };
 export function isEndDeclaration(item) {
@@ -226,6 +328,7 @@ export function isEndDeclaration(item) {
 }
 export const EnumDefinition = {
     $type: 'EnumDefinition',
+    docs: 'docs',
     literals: 'literals',
     name: 'name'
 };
@@ -240,15 +343,28 @@ export function isEnumLiteral(item) {
     return reflection.isInstance(item, EnumLiteral.$type);
 }
 export function isEnumLiteralName(item) {
-    return item === 'in' || item === 'out' || item === 'inout' || item === 'part' || item === 'requirement' || item === 'action' || item === 'item' || item === 'port' || item === 'interface' || item === 'connection' || item === 'attribute' || item === 'constraint' || item === 'enum' || item === 'view' || item === 'viewpoint' || item === 'ref' || item === 'import' || item === 'package' || item === 'flow' || item === 'first' || item === 'allocate' || item === 'library' || item === 'private' || item === 'public' || item === 'state' || item === 'verification' || item === 'use' || item === 'fork' || item === 'join' || (typeof item === 'string' && (/[a-zA-Z_][a-zA-Z0-9_]*/.test(item) || /'(?:[^'\\]|\\.)*'/.test(item)));
+    return item === 'in' || item === 'out' || item === 'inout' || item === 'part' || item === 'requirement' || item === 'action' || item === 'item' || item === 'port' || item === 'interface' || item === 'connection' || item === 'attribute' || item === 'constraint' || item === 'enum' || item === 'view' || item === 'viewpoint' || item === 'ref' || item === 'import' || item === 'package' || item === 'flow' || item === 'first' || item === 'allocate' || item === 'library' || item === 'private' || item === 'public' || item === 'state' || item === 'verification' || item === 'satisfy' || item === 'verify' || item === 'use' || item === 'fork' || item === 'join' || (typeof item === 'string' && (/[a-zA-Z_][a-zA-Z0-9_]*/.test(item) || /'(?:[^'\\]|\\.)*'/.test(item)));
 }
 export const EnumValue = {
     $type: 'EnumValue',
-    enumRef: 'enumRef'
+    enumRef: 'enumRef',
+    metaclass: 'metaclass',
+    tail: 'tail'
 };
 export function isEnumValue(item) {
     return reflection.isInstance(item, EnumValue.$type);
 }
+export const ExhibitStateUsage = {
+    $type: 'ExhibitStateUsage',
+    body: 'body',
+    exhibited: 'exhibited',
+    isState: 'isState',
+    name: 'name',
+    type: 'type'
+};
+export function isExhibitStateUsage(item) {
+    return reflection.isInstance(item, ExhibitStateUsage.$type);
+}
 export const ExposeMember = {
     $type: 'ExposeMember',
     path: 'path'
@@ -266,12 +382,32 @@ export const FeatureChain = {
 export function isFeatureChain(item) {
     return reflection.isInstance(item, FeatureChain.$type);
 }
+export const FeatureMembershipMember = {
+    $type: 'FeatureMembershipMember',
+    feature: 'feature',
+    isRedefinition: 'isRedefinition',
+    multiplicity: 'multiplicity',
+    type: 'type',
+    value: 'value'
+};
+export function isFeatureMembershipMember(item) {
+    return reflection.isInstance(item, FeatureMembershipMember.$type);
+}
 export function isFeatureName(item) {
-    return item === 'part' || item === 'requirement' || item === 'action' || item === 'item' || item === 'port' || item === 'interface' || item === 'connection' || item === 'flow' || item === 'view' || item === 'viewpoint' || item === 'attribute' || item === 'constraint' || item === 'ref' || item === 'allocate' || item === 'end' || item === 'enum' || item === 'function' || item === 'operator' || item === 'state' || item === 'verification' || (typeof item === 'string' && (/[a-zA-Z_][a-zA-Z0-9_]*/.test(item)));
+    return item === 'part' || item === 'requirement' || item === 'action' || item === 'item' || item === 'port' || item === 'interface' || item === 'connection' || item === 'flow' || item === 'view' || item === 'viewpoint' || item === 'attribute' || item === 'constraint' || item === 'ref' || item === 'allocate' || item === 'end' || item === 'enum' || item === 'function' || item === 'operator' || item === 'state' || item === 'verification' || item === 'standard' || (typeof item === 'string' && (/[a-zA-Z_][a-zA-Z0-9_]*/.test(item)));
+}
+export const FeatureReference = {
+    $type: 'FeatureReference',
+    segments: 'segments'
+};
+export function isFeatureReference(item) {
+    return reflection.isInstance(item, FeatureReference.$type);
 }
 export const FlowConnectionUsage = {
     $type: 'FlowConnectionUsage',
+    body: 'body',
     itemType: 'itemType',
+    name: 'name',
     source: 'source',
     target: 'target'
 };
@@ -285,6 +421,17 @@ export const FlowEnd = {
 export function isFlowEnd(item) {
     return reflection.isInstance(item, FlowEnd.$type);
 }
+export const FramedConcernMember = {
+    $type: 'FramedConcernMember',
+    body: 'body',
+    framed: 'framed',
+    isConcern: 'isConcern',
+    name: 'name',
+    type: 'type'
+};
+export function isFramedConcernMember(item) {
+    return reflection.isInstance(item, FramedConcernMember.$type);
+}
 export const ImportDeclaration = {
     $type: 'ImportDeclaration',
     path: 'path',
@@ -296,6 +443,17 @@ export function isImportDeclaration(item) {
 export function isImportPath(item) {
     return typeof item === 'string';
 }
+export const IncludeUseCaseUsage = {
+    $type: 'IncludeUseCaseUsage',
+    body: 'body',
+    included: 'included',
+    isUseCase: 'isUseCase',
+    name: 'name',
+    type: 'type'
+};
+export function isIncludeUseCaseUsage(item) {
+    return reflection.isInstance(item, IncludeUseCaseUsage.$type);
+}
 export const InterfaceDefinition = {
     $type: 'InterfaceDefinition',
     additionalSpecializations: 'additionalSpecializations',
@@ -311,6 +469,8 @@ export const InterfaceUsage = {
     $type: 'InterfaceUsage',
     body: 'body',
     name: 'name',
+    source: 'source',
+    target: 'target',
     type: 'type'
 };
 export function isInterfaceUsage(item) {
@@ -328,6 +488,7 @@ export const ItemDefinition = {
     additionalSpecializations: 'additionalSpecializations',
     body: 'body',
     isAbstract: 'isAbstract',
+    isVariation: 'isVariation',
     name: 'name',
     specialization: 'specialization'
 };
@@ -341,6 +502,7 @@ export const ItemUsage = {
     direction: 'direction',
     multiplicity: 'multiplicity',
     name: 'name',
+    preMultiplicity: 'preMultiplicity',
     type: 'type'
 };
 export function isItemUsage(item) {
@@ -356,7 +518,18 @@ export function isLiteralExpr(item) {
     return reflection.isInstance(item, LiteralExpr.$type);
 }
 export function isMemberName(item) {
-    return item === 'requirement' || item === 'action' || item === 'item' || item === 'port' || item === 'interface' || item === 'connection' || item === 'attribute' || item === 'constraint' || item === 'view' || item === 'viewpoint' || item === 'ref' || item === 'part' || item === 'state' || item === 'verification' || (typeof item === 'string' && (/[a-zA-Z_][a-zA-Z0-9_]*/.test(item)));
+    return item === 'requirement' || item === 'action' || item === 'item' || item === 'port' || item === 'interface' || item === 'connection' || item === 'attribute' || item === 'constraint' || item === 'view' || item === 'viewpoint' || item === 'ref' || item === 'part' || item === 'state' || item === 'verification' || item === 'standard' || (typeof item === 'string' && (/[a-zA-Z_][a-zA-Z0-9_]*/.test(item)));
+}
+export const MessageUsage = {
+    $type: 'MessageUsage',
+    body: 'body',
+    itemType: 'itemType',
+    name: 'name',
+    source: 'source',
+    target: 'target'
+};
+export function isMessageUsage(item) {
+    return reflection.isInstance(item, MessageUsage.$type);
 }
 export const MetadataApplication = {
     $type: 'MetadataApplication',
@@ -366,15 +539,31 @@ export const MetadataApplication = {
 export function isMetadataApplication(item) {
     return reflection.isInstance(item, MetadataApplication.$type);
 }
+export const MetadataBodyMember = {
+    $type: 'MetadataBodyMember'
+};
+export function isMetadataBodyMember(item) {
+    return reflection.isInstance(item, MetadataBodyMember.$type);
+}
 export const MetadataDefinition = {
     $type: 'MetadataDefinition',
     body: 'body',
     name: 'name',
+    shortName: 'shortName',
     specialization: 'specialization'
 };
 export function isMetadataDefinition(item) {
     return reflection.isInstance(item, MetadataDefinition.$type);
 }
+export const MetadataFeatureMember = {
+    $type: 'MetadataFeatureMember',
+    name: 'name',
+    redefines: 'redefines',
+    value: 'value'
+};
+export function isMetadataFeatureMember(item) {
+    return reflection.isInstance(item, MetadataFeatureMember.$type);
+}
 export const Model = {
     $type: 'Model',
     members: 'members'
@@ -398,9 +587,19 @@ export const NamespaceMember = {
 export function isNamespaceMember(item) {
     return reflection.isInstance(item, NamespaceMember.$type);
 }
+export const ObjectiveMember = {
+    $type: 'ObjectiveMember',
+    body: 'body',
+    name: 'name',
+    type: 'type'
+};
+export function isObjectiveMember(item) {
+    return reflection.isInstance(item, ObjectiveMember.$type);
+}
 export const PackageDeclaration = {
     $type: 'PackageDeclaration',
     isLibrary: 'isLibrary',
+    isStandard: 'isStandard',
     members: 'members',
     name: 'name'
 };
@@ -418,6 +617,7 @@ export const PartDefinition = {
     additionalSpecializations: 'additionalSpecializations',
     body: 'body',
     isAbstract: 'isAbstract',
+    isVariation: 'isVariation',
     name: 'name',
     specialization: 'specialization'
 };
@@ -429,8 +629,10 @@ export const PartMember = {
     bindingOp: 'bindingOp',
     body: 'body',
     boundRef: 'boundRef',
+    isVariation: 'isVariation',
     multiplicity: 'multiplicity',
     name: 'name',
+    subsetValue: 'subsetValue',
     type: 'type'
 };
 export function isPartMember(item) {
@@ -439,12 +641,25 @@ export function isPartMember(item) {
 export const PartUsage = {
     $type: 'PartUsage',
     body: 'body',
+    isVariation: 'isVariation',
+    multiplicity: 'multiplicity',
     name: 'name',
     type: 'type'
 };
 export function isPartUsage(item) {
     return reflection.isInstance(item, PartUsage.$type);
 }
+export const PerformActionUsage = {
+    $type: 'PerformActionUsage',
+    body: 'body',
+    isAction: 'isAction',
+    name: 'name',
+    performed: 'performed',
+    type: 'type'
+};
+export function isPerformActionUsage(item) {
+    return reflection.isInstance(item, PerformActionUsage.$type);
+}
 export const PortDefinition = {
     $type: 'PortDefinition',
     additionalSpecializations: 'additionalSpecializations',
@@ -467,11 +682,18 @@ export const PortUsage = {
 export function isPortUsage(item) {
     return reflection.isInstance(item, PortUsage.$type);
 }
+export const PrefixMetadataAnnotation = {
+    $type: 'PrefixMetadataAnnotation',
+    type: 'type'
+};
+export function isPrefixMetadataAnnotation(item) {
+    return reflection.isInstance(item, PrefixMetadataAnnotation.$type);
+}
 export function isQualifiedName(item) {
     return typeof item === 'string';
 }
 export function isQualifiedNameSegment(item) {
-    return item === 'library' || (typeof item === 'string' && (/[a-zA-Z_][a-zA-Z0-9_]*/.test(item)));
+    return item === 'library' || item === 'standard' || (typeof item === 'string' && (/[a-zA-Z_][a-zA-Z0-9_]*/.test(item)));
 }
 export function isQualifiedNameTailSegment(item) {
     return isQualifiedNameSegment(item) || item === 'in' || item === 'out' || item === 'inout' || item === 'part' || item === 'requirement' || item === 'action' || item === 'item' || item === 'port' || item === 'interface' || item === 'connection' || item === 'attribute' || item === 'constraint' || item === 'enum' || item === 'view' || item === 'viewpoint' || item === 'ref' || item === 'import' || item === 'package' || item === 'flow' || item === 'first' || item === 'allocate' || item === 'private' || item === 'public' || item === 'state' || item === 'verification' || item === 'use' || item === 'fork' || item === 'join' || (typeof item === 'string' && (/'(?:[^'\\]|\\.)*'/.test(item)));
@@ -527,6 +749,35 @@ export const RequirementUsage = {
 export function isRequirementUsage(item) {
     return reflection.isInstance(item, RequirementUsage.$type);
 }
+export const RequirementVerificationMember = {
+    $type: 'RequirementVerificationMember',
+    body: 'body',
+    requirement: 'requirement'
+};
+export function isRequirementVerificationMember(item) {
+    return reflection.isInstance(item, RequirementVerificationMember.$type);
+}
+export const SatisfyRequirementUsage = {
+    $type: 'SatisfyRequirementUsage',
+    body: 'body',
+    isAsserted: 'isAsserted',
+    isNegated: 'isNegated',
+    requirement: 'requirement',
+    satisfyingFeature: 'satisfyingFeature'
+};
+export function isSatisfyRequirementUsage(item) {
+    return reflection.isInstance(item, SatisfyRequirementUsage.$type);
+}
+export const SendActionUsage = {
+    $type: 'SendActionUsage',
+    followsPrevious: 'followsPrevious',
+    name: 'name',
+    receiver: 'receiver',
+    target: 'target'
+};
+export function isSendActionUsage(item) {
+    return reflection.isInstance(item, SendActionUsage.$type);
+}
 export const SetElement = {
     $type: 'SetElement',
     stringValue: 'stringValue',
@@ -549,6 +800,18 @@ export const Specialization = {
 export function isSpecialization(item) {
     return reflection.isInstance(item, Specialization.$type);
 }
+export const StakeholderMember = {
+    $type: 'StakeholderMember',
+    bindingOp: 'bindingOp',
+    body: 'body',
+    boundRef: 'boundRef',
+    multiplicity: 'multiplicity',
+    name: 'name',
+    type: 'type'
+};
+export function isStakeholderMember(item) {
+    return reflection.isInstance(item, StakeholderMember.$type);
+}
 export const StateDefinition = {
     $type: 'StateDefinition',
     additionalSpecializations: 'additionalSpecializations',
@@ -576,11 +839,24 @@ export const StringValue = {
 export function isStringValue(item) {
     return reflection.isInstance(item, StringValue.$type);
 }
+export const SubjectMember = {
+    $type: 'SubjectMember',
+    bindingOp: 'bindingOp',
+    body: 'body',
+    boundRefs: 'boundRefs',
+    multiplicity: 'multiplicity',
+    name: 'name',
+    type: 'type'
+};
+export function isSubjectMember(item) {
+    return reflection.isInstance(item, SubjectMember.$type);
+}
 export function isSuccessionRef(item) {
     return item === 'start' || item === 'done' || (typeof item === 'string' && (/[a-zA-Z_][a-zA-Z0-9_]*/.test(item)));
 }
 export const SuccessionStep = {
     $type: 'SuccessionStep',
+    guard: 'guard',
     ref: 'ref'
 };
 export function isSuccessionStep(item) {
@@ -593,6 +869,28 @@ export const SuccessionUsage = {
 export function isSuccessionUsage(item) {
     return reflection.isInstance(item, SuccessionUsage.$type);
 }
+export const TerminateUsage = {
+    $type: 'TerminateUsage',
+    followsPrevious: 'followsPrevious',
+    name: 'name'
+};
+export function isTerminateUsage(item) {
+    return reflection.isInstance(item, TerminateUsage.$type);
+}
+export const TransitionUsage = {
+    $type: 'TransitionUsage',
+    body: 'body',
+    effect: 'effect',
+    guard: 'guard',
+    name: 'name',
+    source: 'source',
+    target: 'target',
+    trigger: 'trigger',
+    type: 'type'
+};
+export function isTransitionUsage(item) {
+    return reflection.isInstance(item, TransitionUsage.$type);
+}
 export const UnaryExpr = {
     $type: 'UnaryExpr',
     op: 'op',
@@ -627,6 +925,18 @@ export const UseCaseDeclaration = {
 export function isUseCaseDeclaration(item) {
     return reflection.isInstance(item, UseCaseDeclaration.$type);
 }
+export const VariantMember = {
+    $type: 'VariantMember',
+    body: 'body',
+    multiplicity: 'multiplicity',
+    name: 'name',
+    type: 'type',
+    usageKind: 'usageKind',
+    value: 'value'
+};
+export function isVariantMember(item) {
+    return reflection.isInstance(item, VariantMember.$type);
+}
 export const VerificationDefinition = {
     $type: 'VerificationDefinition',
     additionalSpecializations: 'additionalSpecializations',
@@ -686,6 +996,41 @@ export function isViewUsage(item) {
 }
 export class MemoSysMLAstReflection extends langium.AbstractAstReflection {
     types = {
+        AbstractConnectionUsage: {
+            name: AbstractConnectionUsage.$type,
+            properties: {
+                isAbstract: {
+                    name: AbstractConnectionUsage.isAbstract,
+                    defaultValue: false
+                },
+                multiplicity: {
+                    name: AbstractConnectionUsage.multiplicity,
+                    optional: true
+                },
+                name: {
+                    name: AbstractConnectionUsage.name
+                },
+                type: {
+                    name: AbstractConnectionUsage.type
+                }
+            },
+            superTypes: [PackageMember.$type]
+        },
+        AcceptActionUsage: {
+            name: AcceptActionUsage.$type,
+            properties: {
+                name: {
+                    name: AcceptActionUsage.name
+                },
+                payloadName: {
+                    name: AcceptActionUsage.payloadName
+                },
+                payloadType: {
+                    name: AcceptActionUsage.payloadType
+                }
+            },
+            superTypes: [ActionDefBodyMember.$type, ActionUsageBodyMember.$type]
+        },
         ActionDefBodyMember: {
             name: ActionDefBodyMember.$type,
             properties: {},
@@ -735,7 +1080,7 @@ export class MemoSysMLAstReflection extends langium.AbstractAstReflection {
                     name: ActionParameterMember.type
                 }
             },
-            superTypes: [ActionDefBodyMember.$type]
+            superTypes: [ActionDefBodyMember.$type, ActionUsageBodyMember.$type]
         },
         ActionUsage: {
             name: ActionUsage.$type,
@@ -756,13 +1101,43 @@ export class MemoSysMLAstReflection extends langium.AbstractAstReflection {
                     optional: true
                 }
             },
-            superTypes: [ActionUsageBodyMember.$type, UsageMember.$type]
+            superTypes: [ActionDefBodyMember.$type, ActionUsageBodyMember.$type, UsageMember.$type]
         },
         ActionUsageBodyMember: {
             name: ActionUsageBodyMember.$type,
             properties: {},
             superTypes: []
         },
+        ActorMember: {
+            name: ActorMember.$type,
+            properties: {
+                bindingOp: {
+                    name: ActorMember.bindingOp,
+                    optional: true
+                },
+                body: {
+                    name: ActorMember.body,
+                    defaultValue: [],
+                    optional: true
+                },
+                boundRef: {
+                    name: ActorMember.boundRef,
+                    optional: true
+                },
+                multiplicity: {
+                    name: ActorMember.multiplicity,
+                    optional: true
+                },
+                name: {
+                    name: ActorMember.name
+                },
+                type: {
+                    name: ActorMember.type,
+                    optional: true
+                }
+            },
+            superTypes: [ArcadiaMember.$type]
+        },
         AliasDeclaration: {
             name: AliasDeclaration.$type,
             properties: {
@@ -773,19 +1148,65 @@ export class MemoSysMLAstReflection extends langium.AbstractAstReflection {
                     name: AliasDeclaration.target
                 }
             },
-            superTypes: [PackageMember.$type]
+            superTypes: [NamespaceMember.$type, PackageMember.$type]
         },
         AllocateUsage: {
             name: AllocateUsage.$type,
             properties: {
+                body: {
+                    name: AllocateUsage.body,
+                    defaultValue: [],
+                    optional: true
+                },
+                name: {
+                    name: AllocateUsage.name,
+                    optional: true
+                },
                 source: {
                     name: AllocateUsage.source
                 },
                 target: {
                     name: AllocateUsage.target
+                },
+                type: {
+                    name: AllocateUsage.type,
+                    optional: true
                 }
             },
-            superTypes: [PackageMember.$type]
+            superTypes: [ArcadiaMember.$type]
+        },
+        AllocationDefinition: {
+            name: AllocationDefinition.$type,
+            properties: {
+                additionalSpecializations: {
+                    name: AllocationDefinition.additionalSpecializations,
+                    defaultValue: [],
+                    optional: true
+                },
+                body: {
+                    name: AllocationDefinition.body,
+                    defaultValue: [],
+                    optional: true
+                },
+                isAbstract: {
+                    name: AllocationDefinition.isAbstract,
+                    defaultValue: false,
+                    optional: true
+                },
+                name: {
+                    name: AllocationDefinition.name
+                },
+                specialization: {
+                    name: AllocationDefinition.specialization,
+                    optional: true
+                }
+            },
+            superTypes: [DefinitionMember.$type]
+        },
+        ArcadiaMember: {
+            name: ArcadiaMember.$type,
+            properties: {},
+            superTypes: [DefinitionBodyMember.$type, PackageMember.$type, UsageBodyMember.$type]
         },
         AttributeDefinition: {
             name: AttributeDefinition.$type,
@@ -805,6 +1226,11 @@ export class MemoSysMLAstReflection extends langium.AbstractAstReflection {
                     defaultValue: false,
                     optional: true
                 },
+                isVariation: {
+                    name: AttributeDefinition.isVariation,
+                    defaultValue: false,
+                    optional: true
+                },
                 name: {
                     name: AttributeDefinition.name
                 },
@@ -823,6 +1249,16 @@ export class MemoSysMLAstReflection extends langium.AbstractAstReflection {
                     defaultValue: [],
                     optional: true
                 },
+                isDefault: {
+                    name: AttributeMember.isDefault,
+                    defaultValue: false,
+                    optional: true
+                },
+                isVariation: {
+                    name: AttributeMember.isVariation,
+                    defaultValue: false,
+                    optional: true
+                },
                 multiplicity: {
                     name: AttributeMember.multiplicity,
                     optional: true
@@ -866,6 +1302,18 @@ export class MemoSysMLAstReflection extends langium.AbstractAstReflection {
             },
             superTypes: [ConstraintExpr.$type]
         },
+        BindingUsage: {
+            name: BindingUsage.$type,
+            properties: {
+                source: {
+                    name: BindingUsage.source
+                },
+                target: {
+                    name: BindingUsage.target
+                }
+            },
+            superTypes: [PackageMember.$type]
+        },
         BooleanValue: {
             name: BooleanValue.$type,
             properties: {
@@ -891,26 +1339,72 @@ export class MemoSysMLAstReflection extends langium.AbstractAstReflection {
             },
             superTypes: [ConstraintExpr.$type]
         },
-        ConnectionBodyMember: {
-            name: ConnectionBodyMember.$type,
-            properties: {},
-            superTypes: []
-        },
-        ConnectionDefinition: {
-            name: ConnectionDefinition.$type,
+        ConcernDefinition: {
+            name: ConcernDefinition.$type,
             properties: {
                 additionalSpecializations: {
-                    name: ConnectionDefinition.additionalSpecializations,
+                    name: ConcernDefinition.additionalSpecializations,
                     defaultValue: [],
                     optional: true
                 },
                 body: {
-                    name: ConnectionDefinition.body,
+                    name: ConcernDefinition.body,
                     defaultValue: [],
                     optional: true
                 },
                 isAbstract: {
-                    name: ConnectionDefinition.isAbstract,
+                    name: ConcernDefinition.isAbstract,
+                    defaultValue: false,
+                    optional: true
+                },
+                name: {
+                    name: ConcernDefinition.name
+                },
+                specialization: {
+                    name: ConcernDefinition.specialization,
+                    optional: true
+                }
+            },
+            superTypes: [DefinitionMember.$type]
+        },
+        ConcernUsage: {
+            name: ConcernUsage.$type,
+            properties: {
+                body: {
+                    name: ConcernUsage.body,
+                    defaultValue: [],
+                    optional: true
+                },
+                name: {
+                    name: ConcernUsage.name
+                },
+                type: {
+                    name: ConcernUsage.type,
+                    optional: true
+                }
+            },
+            superTypes: [ArcadiaMember.$type]
+        },
+        ConnectionBodyMember: {
+            name: ConnectionBodyMember.$type,
+            properties: {},
+            superTypes: []
+        },
+        ConnectionDefinition: {
+            name: ConnectionDefinition.$type,
+            properties: {
+                additionalSpecializations: {
+                    name: ConnectionDefinition.additionalSpecializations,
+                    defaultValue: [],
+                    optional: true
+                },
+                body: {
+                    name: ConnectionDefinition.body,
+                    defaultValue: [],
+                    optional: true
+                },
+                isAbstract: {
+                    name: ConnectionDefinition.isAbstract,
                     defaultValue: false,
                     optional: true
                 },
@@ -1004,17 +1498,45 @@ export class MemoSysMLAstReflection extends langium.AbstractAstReflection {
                     name: ControlNodeUsage.name
                 }
             },
-            superTypes: [ActionUsageBodyMember.$type]
+            superTypes: [ActionDefBodyMember.$type, ActionUsageBodyMember.$type]
         },
         DefinitionBodyMember: {
             name: DefinitionBodyMember.$type,
             properties: {},
-            superTypes: [ActionDefBodyMember.$type, ConnectionBodyMember.$type]
+            superTypes: [ConnectionBodyMember.$type]
         },
         DefinitionMember: {
             name: DefinitionMember.$type,
             properties: {},
-            superTypes: [PackageMember.$type]
+            superTypes: [NamespaceMember.$type, PackageMember.$type]
+        },
+        Dependency: {
+            name: Dependency.$type,
+            properties: {
+                body: {
+                    name: Dependency.body,
+                    defaultValue: [],
+                    optional: true
+                },
+                clients: {
+                    name: Dependency.clients,
+                    defaultValue: []
+                },
+                name: {
+                    name: Dependency.name,
+                    optional: true
+                },
+                prefixMetadata: {
+                    name: Dependency.prefixMetadata,
+                    defaultValue: [],
+                    optional: true
+                },
+                suppliers: {
+                    name: Dependency.suppliers,
+                    defaultValue: []
+                }
+            },
+            superTypes: [NamespaceMember.$type, PackageMember.$type, UsageBodyMember.$type]
         },
         DocComment: {
             name: DocComment.$type,
@@ -1023,7 +1545,7 @@ export class MemoSysMLAstReflection extends langium.AbstractAstReflection {
                     name: DocComment.content
                 }
             },
-            superTypes: [DefinitionBodyMember.$type, PackageMember.$type, UsageBodyMember.$type]
+            superTypes: [DefinitionBodyMember.$type, NamespaceMember.$type, PackageMember.$type, UsageBodyMember.$type]
         },
         EndDeclaration: {
             name: EndDeclaration.$type,
@@ -1040,6 +1562,15 @@ export class MemoSysMLAstReflection extends langium.AbstractAstReflection {
                 name: {
                     name: EndDeclaration.name
                 },
+                redefinedEnd: {
+                    name: EndDeclaration.redefinedEnd,
+                    optional: true
+                },
+                redefines: {
+                    name: EndDeclaration.redefines,
+                    defaultValue: false,
+                    optional: true
+                },
                 type: {
                     name: EndDeclaration.type,
                     optional: true
@@ -1050,6 +1581,11 @@ export class MemoSysMLAstReflection extends langium.AbstractAstReflection {
         EnumDefinition: {
             name: EnumDefinition.$type,
             properties: {
+                docs: {
+                    name: EnumDefinition.docs,
+                    defaultValue: [],
+                    optional: true
+                },
                 literals: {
                     name: EnumDefinition.literals,
                     defaultValue: [],
@@ -1075,10 +1611,47 @@ export class MemoSysMLAstReflection extends langium.AbstractAstReflection {
             properties: {
                 enumRef: {
                     name: EnumValue.enumRef
+                },
+                metaclass: {
+                    name: EnumValue.metaclass,
+                    optional: true
+                },
+                tail: {
+                    name: EnumValue.tail,
+                    defaultValue: [],
+                    optional: true
                 }
             },
             superTypes: [AttributeValue.$type]
         },
+        ExhibitStateUsage: {
+            name: ExhibitStateUsage.$type,
+            properties: {
+                body: {
+                    name: ExhibitStateUsage.body,
+                    defaultValue: [],
+                    optional: true
+                },
+                exhibited: {
+                    name: ExhibitStateUsage.exhibited,
+                    optional: true
+                },
+                isState: {
+                    name: ExhibitStateUsage.isState,
+                    defaultValue: false,
+                    optional: true
+                },
+                name: {
+                    name: ExhibitStateUsage.name,
+                    optional: true
+                },
+                type: {
+                    name: ExhibitStateUsage.type,
+                    optional: true
+                }
+            },
+            superTypes: [ArcadiaMember.$type]
+        },
         ExposeMember: {
             name: ExposeMember.$type,
             properties: {
@@ -1098,11 +1671,57 @@ export class MemoSysMLAstReflection extends langium.AbstractAstReflection {
             },
             superTypes: [ConstraintExpr.$type]
         },
+        FeatureMembershipMember: {
+            name: FeatureMembershipMember.$type,
+            properties: {
+                feature: {
+                    name: FeatureMembershipMember.feature
+                },
+                isRedefinition: {
+                    name: FeatureMembershipMember.isRedefinition,
+                    defaultValue: false,
+                    optional: true
+                },
+                multiplicity: {
+                    name: FeatureMembershipMember.multiplicity,
+                    optional: true
+                },
+                type: {
+                    name: FeatureMembershipMember.type,
+                    optional: true
+                },
+                value: {
+                    name: FeatureMembershipMember.value,
+                    optional: true
+                }
+            },
+            superTypes: [DefinitionBodyMember.$type]
+        },
+        FeatureReference: {
+            name: FeatureReference.$type,
+            properties: {
+                segments: {
+                    name: FeatureReference.segments,
+                    defaultValue: []
+                }
+            },
+            superTypes: []
+        },
         FlowConnectionUsage: {
             name: FlowConnectionUsage.$type,
             properties: {
+                body: {
+                    name: FlowConnectionUsage.body,
+                    defaultValue: [],
+                    optional: true
+                },
                 itemType: {
-                    name: FlowConnectionUsage.itemType
+                    name: FlowConnectionUsage.itemType,
+                    optional: true
+                },
+                name: {
+                    name: FlowConnectionUsage.name,
+                    optional: true
                 },
                 source: {
                     name: FlowConnectionUsage.source
@@ -1111,7 +1730,7 @@ export class MemoSysMLAstReflection extends langium.AbstractAstReflection {
                     name: FlowConnectionUsage.target
                 }
             },
-            superTypes: [UsageBodyMember.$type]
+            superTypes: [ConnectionBodyMember.$type, PackageMember.$type, UsageBodyMember.$type]
         },
         FlowEnd: {
             name: FlowEnd.$type,
@@ -1122,6 +1741,34 @@ export class MemoSysMLAstReflection extends langium.AbstractAstReflection {
             },
             superTypes: []
         },
+        FramedConcernMember: {
+            name: FramedConcernMember.$type,
+            properties: {
+                body: {
+                    name: FramedConcernMember.body,
+                    defaultValue: [],
+                    optional: true
+                },
+                framed: {
+                    name: FramedConcernMember.framed,
+                    optional: true
+                },
+                isConcern: {
+                    name: FramedConcernMember.isConcern,
+                    defaultValue: false,
+                    optional: true
+                },
+                name: {
+                    name: FramedConcernMember.name,
+                    optional: true
+                },
+                type: {
+                    name: FramedConcernMember.type,
+                    optional: true
+                }
+            },
+            superTypes: [ArcadiaMember.$type]
+        },
         ImportDeclaration: {
             name: ImportDeclaration.$type,
             properties: {
@@ -1135,6 +1782,34 @@ export class MemoSysMLAstReflection extends langium.AbstractAstReflection {
             },
             superTypes: [NamespaceMember.$type, PackageMember.$type]
         },
+        IncludeUseCaseUsage: {
+            name: IncludeUseCaseUsage.$type,
+            properties: {
+                body: {
+                    name: IncludeUseCaseUsage.body,
+                    defaultValue: [],
+                    optional: true
+                },
+                included: {
+                    name: IncludeUseCaseUsage.included,
+                    optional: true
+                },
+                isUseCase: {
+                    name: IncludeUseCaseUsage.isUseCase,
+                    defaultValue: false,
+                    optional: true
+                },
+                name: {
+                    name: IncludeUseCaseUsage.name,
+                    optional: true
+                },
+                type: {
+                    name: IncludeUseCaseUsage.type,
+                    optional: true
+                }
+            },
+            superTypes: [ArcadiaMember.$type]
+        },
         IntValue: {
             name: IntValue.$type,
             properties: {
@@ -1183,8 +1858,17 @@ export class MemoSysMLAstReflection extends langium.AbstractAstReflection {
                 name: {
                     name: InterfaceUsage.name
                 },
+                source: {
+                    name: InterfaceUsage.source,
+                    optional: true
+                },
+                target: {
+                    name: InterfaceUsage.target,
+                    optional: true
+                },
                 type: {
-                    name: InterfaceUsage.type
+                    name: InterfaceUsage.type,
+                    optional: true
                 }
             },
             superTypes: [UsageMember.$type]
@@ -1207,6 +1891,11 @@ export class MemoSysMLAstReflection extends langium.AbstractAstReflection {
                     defaultValue: false,
                     optional: true
                 },
+                isVariation: {
+                    name: ItemDefinition.isVariation,
+                    defaultValue: false,
+                    optional: true
+                },
                 name: {
                     name: ItemDefinition.name
                 },
@@ -1240,6 +1929,10 @@ export class MemoSysMLAstReflection extends langium.AbstractAstReflection {
                 name: {
                     name: ItemUsage.name
                 },
+                preMultiplicity: {
+                    name: ItemUsage.preMultiplicity,
+                    optional: true
+                },
                 type: {
                     name: ItemUsage.type,
                     optional: true
@@ -1265,6 +1958,30 @@ export class MemoSysMLAstReflection extends langium.AbstractAstReflection {
             },
             superTypes: [ConstraintExpr.$type]
         },
+        MessageUsage: {
+            name: MessageUsage.$type,
+            properties: {
+                body: {
+                    name: MessageUsage.body,
+                    defaultValue: [],
+                    optional: true
+                },
+                itemType: {
+                    name: MessageUsage.itemType
+                },
+                name: {
+                    name: MessageUsage.name,
+                    optional: true
+                },
+                source: {
+                    name: MessageUsage.source
+                },
+                target: {
+                    name: MessageUsage.target
+                }
+            },
+            superTypes: [UsageBodyMember.$type, UsageMember.$type]
+        },
         MetadataApplication: {
             name: MetadataApplication.$type,
             properties: {
@@ -1279,6 +1996,11 @@ export class MemoSysMLAstReflection extends langium.AbstractAstReflection {
             },
             superTypes: [DefinitionBodyMember.$type, PackageMember.$type, UsageBodyMember.$type]
         },
+        MetadataBodyMember: {
+            name: MetadataBodyMember.$type,
+            properties: {},
+            superTypes: []
+        },
         MetadataDefinition: {
             name: MetadataDefinition.$type,
             properties: {
@@ -1290,6 +2012,10 @@ export class MemoSysMLAstReflection extends langium.AbstractAstReflection {
                 name: {
                     name: MetadataDefinition.name
                 },
+                shortName: {
+                    name: MetadataDefinition.shortName,
+                    optional: true
+                },
                 specialization: {
                     name: MetadataDefinition.specialization,
                     optional: true
@@ -1297,6 +2023,22 @@ export class MemoSysMLAstReflection extends langium.AbstractAstReflection {
             },
             superTypes: [DefinitionMember.$type]
         },
+        MetadataFeatureMember: {
+            name: MetadataFeatureMember.$type,
+            properties: {
+                name: {
+                    name: MetadataFeatureMember.name
+                },
+                redefines: {
+                    name: MetadataFeatureMember.redefines,
+                    defaultValue: false
+                },
+                value: {
+                    name: MetadataFeatureMember.value
+                }
+            },
+            superTypes: [MetadataBodyMember.$type]
+        },
         Model: {
             name: Model.$type,
             properties: {
@@ -1336,6 +2078,25 @@ export class MemoSysMLAstReflection extends langium.AbstractAstReflection {
             properties: {},
             superTypes: []
         },
+        ObjectiveMember: {
+            name: ObjectiveMember.$type,
+            properties: {
+                body: {
+                    name: ObjectiveMember.body,
+                    defaultValue: [],
+                    optional: true
+                },
+                name: {
+                    name: ObjectiveMember.name,
+                    optional: true
+                },
+                type: {
+                    name: ObjectiveMember.type,
+                    optional: true
+                }
+            },
+            superTypes: [ArcadiaMember.$type]
+        },
         PackageDeclaration: {
             name: PackageDeclaration.$type,
             properties: {
@@ -1344,6 +2105,11 @@ export class MemoSysMLAstReflection extends langium.AbstractAstReflection {
                     defaultValue: false,
                     optional: true
                 },
+                isStandard: {
+                    name: PackageDeclaration.isStandard,
+                    defaultValue: false,
+                    optional: true
+                },
                 members: {
                     name: PackageDeclaration.members,
                     defaultValue: [],
@@ -1378,6 +2144,11 @@ export class MemoSysMLAstReflection extends langium.AbstractAstReflection {
                     defaultValue: false,
                     optional: true
                 },
+                isVariation: {
+                    name: PartDefinition.isVariation,
+                    defaultValue: false,
+                    optional: true
+                },
                 name: {
                     name: PartDefinition.name
                 },
@@ -1403,6 +2174,11 @@ export class MemoSysMLAstReflection extends langium.AbstractAstReflection {
                     name: PartMember.boundRef,
                     optional: true
                 },
+                isVariation: {
+                    name: PartMember.isVariation,
+                    defaultValue: false,
+                    optional: true
+                },
                 multiplicity: {
                     name: PartMember.multiplicity,
                     optional: true
@@ -1410,6 +2186,10 @@ export class MemoSysMLAstReflection extends langium.AbstractAstReflection {
                 name: {
                     name: PartMember.name
                 },
+                subsetValue: {
+                    name: PartMember.subsetValue,
+                    optional: true
+                },
                 type: {
                     name: PartMember.type,
                     optional: true
@@ -1425,6 +2205,15 @@ export class MemoSysMLAstReflection extends langium.AbstractAstReflection {
                     defaultValue: [],
                     optional: true
                 },
+                isVariation: {
+                    name: PartUsage.isVariation,
+                    defaultValue: false,
+                    optional: true
+                },
+                multiplicity: {
+                    name: PartUsage.multiplicity,
+                    optional: true
+                },
                 name: {
                     name: PartUsage.name
                 },
@@ -1435,6 +2224,33 @@ export class MemoSysMLAstReflection extends langium.AbstractAstReflection {
             },
             superTypes: [UsageMember.$type]
         },
+        PerformActionUsage: {
+            name: PerformActionUsage.$type,
+            properties: {
+                body: {
+                    name: PerformActionUsage.body,
+                    defaultValue: [],
+                    optional: true
+                },
+                isAction: {
+                    name: PerformActionUsage.isAction,
+                    defaultValue: false,
+                    optional: true
+                },
+                name: {
+                    name: PerformActionUsage.name,
+                    optional: true
+                },
+                performed: {
+                    name: PerformActionUsage.performed
+                },
+                type: {
+                    name: PerformActionUsage.type,
+                    optional: true
+                }
+            },
+            superTypes: [ArcadiaMember.$type]
+        },
         PortDefinition: {
             name: PortDefinition.$type,
             properties: {
@@ -1489,6 +2305,15 @@ export class MemoSysMLAstReflection extends langium.AbstractAstReflection {
             },
             superTypes: [DefinitionBodyMember.$type, UsageBodyMember.$type, UsageMember.$type]
         },
+        PrefixMetadataAnnotation: {
+            name: PrefixMetadataAnnotation.$type,
+            properties: {
+                type: {
+                    name: PrefixMetadataAnnotation.type
+                }
+            },
+            superTypes: []
+        },
         RealValue: {
             name: RealValue.$type,
             properties: {
@@ -1545,7 +2370,7 @@ export class MemoSysMLAstReflection extends langium.AbstractAstReflection {
                     optional: true
                 }
             },
-            superTypes: [DefinitionBodyMember.$type]
+            superTypes: [ActionDefBodyMember.$type, DefinitionBodyMember.$type]
         },
         RequirementDefinition: {
             name: RequirementDefinition.$type,
@@ -1592,6 +2417,68 @@ export class MemoSysMLAstReflection extends langium.AbstractAstReflection {
             },
             superTypes: [UsageMember.$type]
         },
+        RequirementVerificationMember: {
+            name: RequirementVerificationMember.$type,
+            properties: {
+                body: {
+                    name: RequirementVerificationMember.body,
+                    defaultValue: [],
+                    optional: true
+                },
+                requirement: {
+                    name: RequirementVerificationMember.requirement
+                }
+            },
+            superTypes: [DefinitionBodyMember.$type, UsageBodyMember.$type]
+        },
+        SatisfyRequirementUsage: {
+            name: SatisfyRequirementUsage.$type,
+            properties: {
+                body: {
+                    name: SatisfyRequirementUsage.body,
+                    defaultValue: [],
+                    optional: true
+                },
+                isAsserted: {
+                    name: SatisfyRequirementUsage.isAsserted,
+                    defaultValue: false,
+                    optional: true
+                },
+                isNegated: {
+                    name: SatisfyRequirementUsage.isNegated,
+                    defaultValue: false,
+                    optional: true
+                },
+                requirement: {
+                    name: SatisfyRequirementUsage.requirement
+                },
+                satisfyingFeature: {
+                    name: SatisfyRequirementUsage.satisfyingFeature,
+                    optional: true
+                }
+            },
+            superTypes: [PackageMember.$type, UsageBodyMember.$type]
+        },
+        SendActionUsage: {
+            name: SendActionUsage.$type,
+            properties: {
+                followsPrevious: {
+                    name: SendActionUsage.followsPrevious,
+                    defaultValue: false,
+                    optional: true
+                },
+                name: {
+                    name: SendActionUsage.name
+                },
+                receiver: {
+                    name: SendActionUsage.receiver
+                },
+                target: {
+                    name: SendActionUsage.target
+                }
+            },
+            superTypes: [ActionDefBodyMember.$type, ActionUsageBodyMember.$type]
+        },
         SetElement: {
             name: SetElement.$type,
             properties: {
@@ -1625,6 +2512,36 @@ export class MemoSysMLAstReflection extends langium.AbstractAstReflection {
             },
             superTypes: []
         },
+        StakeholderMember: {
+            name: StakeholderMember.$type,
+            properties: {
+                bindingOp: {
+                    name: StakeholderMember.bindingOp,
+                    optional: true
+                },
+                body: {
+                    name: StakeholderMember.body,
+                    defaultValue: [],
+                    optional: true
+                },
+                boundRef: {
+                    name: StakeholderMember.boundRef,
+                    optional: true
+                },
+                multiplicity: {
+                    name: StakeholderMember.multiplicity,
+                    optional: true
+                },
+                name: {
+                    name: StakeholderMember.name
+                },
+                type: {
+                    name: StakeholderMember.type,
+                    optional: true
+                }
+            },
+            superTypes: [ArcadiaMember.$type]
+        },
         StateDefinition: {
             name: StateDefinition.$type,
             properties: {
@@ -1668,7 +2585,7 @@ export class MemoSysMLAstReflection extends langium.AbstractAstReflection {
                     name: StateUsage.type
                 }
             },
-            superTypes: [UsageMember.$type]
+            superTypes: [UsageBodyMember.$type, UsageMember.$type]
         },
         StringValue: {
             name: StringValue.$type,
@@ -1679,9 +2596,44 @@ export class MemoSysMLAstReflection extends langium.AbstractAstReflection {
             },
             superTypes: [AttributeValue.$type]
         },
+        SubjectMember: {
+            name: SubjectMember.$type,
+            properties: {
+                bindingOp: {
+                    name: SubjectMember.bindingOp,
+                    optional: true
+                },
+                body: {
+                    name: SubjectMember.body,
+                    defaultValue: [],
+                    optional: true
+                },
+                boundRefs: {
+                    name: SubjectMember.boundRefs,
+                    defaultValue: [],
+                    optional: true
+                },
+                multiplicity: {
+                    name: SubjectMember.multiplicity,
+                    optional: true
+                },
+                name: {
+                    name: SubjectMember.name
+                },
+                type: {
+                    name: SubjectMember.type,
+                    optional: true
+                }
+            },
+            superTypes: [ArcadiaMember.$type]
+        },
         SuccessionStep: {
             name: SuccessionStep.$type,
             properties: {
+                guard: {
+                    name: SuccessionStep.guard,
+                    optional: true
+                },
                 ref: {
                     name: SuccessionStep.ref
                 }
@@ -1696,7 +2648,59 @@ export class MemoSysMLAstReflection extends langium.AbstractAstReflection {
                     defaultValue: []
                 }
             },
-            superTypes: [UsageBodyMember.$type]
+            superTypes: [PackageMember.$type, UsageBodyMember.$type]
+        },
+        TerminateUsage: {
+            name: TerminateUsage.$type,
+            properties: {
+                followsPrevious: {
+                    name: TerminateUsage.followsPrevious,
+                    defaultValue: false,
+                    optional: true
+                },
+                name: {
+                    name: TerminateUsage.name,
+                    optional: true
+                }
+            },
+            superTypes: [ActionDefBodyMember.$type, ActionUsageBodyMember.$type]
+        },
+        TransitionUsage: {
+            name: TransitionUsage.$type,
+            properties: {
+                body: {
+                    name: TransitionUsage.body,
+                    defaultValue: [],
+                    optional: true
+                },
+                effect: {
+                    name: TransitionUsage.effect,
+                    optional: true
+                },
+                guard: {
+                    name: TransitionUsage.guard,
+                    optional: true
+                },
+                name: {
+                    name: TransitionUsage.name,
+                    optional: true
+                },
+                source: {
+                    name: TransitionUsage.source
+                },
+                target: {
+                    name: TransitionUsage.target
+                },
+                trigger: {
+                    name: TransitionUsage.trigger,
+                    optional: true
+                },
+                type: {
+                    name: TransitionUsage.type,
+                    optional: true
+                }
+            },
+            superTypes: [ArcadiaMember.$type]
         },
         UnaryExpr: {
             name: UnaryExpr.$type,
@@ -1713,7 +2717,7 @@ export class MemoSysMLAstReflection extends langium.AbstractAstReflection {
         UsageBodyMember: {
             name: UsageBodyMember.$type,
             properties: {},
-            superTypes: [ActionUsageBodyMember.$type, ViewBodyMember.$type]
+            superTypes: [ActionDefBodyMember.$type, ActionUsageBodyMember.$type, MetadataBodyMember.$type, ViewBodyMember.$type]
         },
         UsageMember: {
             name: UsageMember.$type,
@@ -1760,7 +2764,37 @@ export class MemoSysMLAstReflection extends langium.AbstractAstReflection {
                     optional: true
                 }
             },
-            superTypes: [PackageMember.$type]
+            superTypes: [NamespaceMember.$type, PackageMember.$type]
+        },
+        VariantMember: {
+            name: VariantMember.$type,
+            properties: {
+                body: {
+                    name: VariantMember.body,
+                    defaultValue: [],
+                    optional: true
+                },
+                multiplicity: {
+                    name: VariantMember.multiplicity,
+                    optional: true
+                },
+                name: {
+                    name: VariantMember.name
+                },
+                type: {
+                    name: VariantMember.type,
+                    optional: true
+                },
+                usageKind: {
+                    name: VariantMember.usageKind,
+                    optional: true
+                },
+                value: {
+                    name: VariantMember.value,
+                    optional: true
+                }
+            },
+            superTypes: [ArcadiaMember.$type]
         },
         VerificationDefinition: {
             name: VerificationDefinition.$type,