@memoarchitect/tools 0.4.5 → 0.6.0

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

@@ -1,5 +1,5 @@
 /******************************************************************************
- * This file was generated by langium-cli 3.5.2.
+ * This file was generated by langium-cli 4.3.0.
  * DO NOT EDIT MANUALLY!
  ******************************************************************************/
 /* eslint-disable */
@@ -10,952 +10,1883 @@ export const MemoSysMLTerminals = {
     ML_COMMENT: /\/\*[\s\S]*?\*\//,
     DOC_COMMENT: /doc\s+\/\*[\s\S]*?\*\//,
     ID: /[a-zA-Z_][a-zA-Z0-9_]*/,
+    UNRESTRICTED_NAME: /'(?:[^'\\]|\\.)*'/,
     STRING: /"(?:[^"\\]|\\.)*"/,
     REAL: /[0-9]+\.[0-9]+/,
     INT: /[0-9]+/,
 };
-export const ActionDefBodyMember = 'ActionDefBodyMember';
+export const ActionDefBodyMember = {
+    $type: 'ActionDefBodyMember'
+};
 export function isActionDefBodyMember(item) {
-    return reflection.isInstance(item, ActionDefBodyMember);
-}
-export const ActionUsageBodyMember = 'ActionUsageBodyMember';
-export function isActionUsageBodyMember(item) {
-    return reflection.isInstance(item, ActionUsageBodyMember);
-}
-export const AttributeValue = 'AttributeValue';
-export function isAttributeValue(item) {
-    return reflection.isInstance(item, AttributeValue);
-}
-export const ConnectionBodyMember = 'ConnectionBodyMember';
-export function isConnectionBodyMember(item) {
-    return reflection.isInstance(item, ConnectionBodyMember);
-}
-export const ConstraintExpr = 'ConstraintExpr';
-export function isConstraintExpr(item) {
-    return reflection.isInstance(item, ConstraintExpr);
-}
-export const DefinitionBodyMember = 'DefinitionBodyMember';
-export function isDefinitionBodyMember(item) {
-    return reflection.isInstance(item, DefinitionBodyMember);
-}
-export const DefinitionMember = 'DefinitionMember';
-export function isDefinitionMember(item) {
-    return reflection.isInstance(item, DefinitionMember);
-}
-export function isDottedName(item) {
-    return typeof item === 'string';
-}
-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' || (typeof item === 'string' && (/[a-zA-Z_][a-zA-Z0-9_]*/.test(item)));
-}
-export function isExposePath(item) {
-    return typeof item === 'string';
-}
-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' || (typeof item === 'string' && (/[a-zA-Z_][a-zA-Z0-9_]*/.test(item)));
-}
-export function isImportPath(item) {
-    return typeof item === 'string';
-}
-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' || (typeof item === 'string' && (/[a-zA-Z_][a-zA-Z0-9_]*/.test(item)));
-}
-export const NamespaceMember = 'NamespaceMember';
-export function isNamespaceMember(item) {
-    return reflection.isInstance(item, NamespaceMember);
-}
-export const PackageMember = 'PackageMember';
-export function isPackageMember(item) {
-    return reflection.isInstance(item, PackageMember);
-}
-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)));
-}
-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';
-}
-export function isReferenceName(item) {
-    return typeof item === 'string';
-}
-export function isSuccessionRef(item) {
-    return item === 'start' || item === 'done' || (typeof item === 'string' && (/[a-zA-Z_][a-zA-Z0-9_]*/.test(item)));
-}
-export const UsageBodyMember = 'UsageBodyMember';
-export function isUsageBodyMember(item) {
-    return reflection.isInstance(item, UsageBodyMember);
-}
-export const UsageMember = 'UsageMember';
-export function isUsageMember(item) {
-    return reflection.isInstance(item, UsageMember);
-}
-export const ViewBodyMember = 'ViewBodyMember';
-export function isViewBodyMember(item) {
-    return reflection.isInstance(item, ViewBodyMember);
-}
-export const ActionDefinition = 'ActionDefinition';
+    return reflection.isInstance(item, ActionDefBodyMember.$type);
+}
+export const ActionDefinition = {
+    $type: 'ActionDefinition',
+    additionalSpecializations: 'additionalSpecializations',
+    behaviorKind: 'behaviorKind',
+    body: 'body',
+    isAbstract: 'isAbstract',
+    name: 'name',
+    specialization: 'specialization'
+};
 export function isActionDefinition(item) {
-    return reflection.isInstance(item, ActionDefinition);
+    return reflection.isInstance(item, ActionDefinition.$type);
 }
-export const ActionParameterMember = 'ActionParameterMember';
+export const ActionParameterMember = {
+    $type: 'ActionParameterMember',
+    direction: 'direction',
+    name: 'name',
+    type: 'type'
+};
 export function isActionParameterMember(item) {
-    return reflection.isInstance(item, ActionParameterMember);
-}
-export const ActionUsage = 'ActionUsage';
+    return reflection.isInstance(item, ActionParameterMember.$type);
+}
+export const ActionUsage = {
+    $type: 'ActionUsage',
+    behaviorKind: 'behaviorKind',
+    body: 'body',
+    name: 'name',
+    type: 'type'
+};
 export function isActionUsage(item) {
-    return reflection.isInstance(item, ActionUsage);
+    return reflection.isInstance(item, ActionUsage.$type);
+}
+export const ActionUsageBodyMember = {
+    $type: 'ActionUsageBodyMember'
+};
+export function isActionUsageBodyMember(item) {
+    return reflection.isInstance(item, ActionUsageBodyMember.$type);
 }
-export const AliasDeclaration = 'AliasDeclaration';
+export const AliasDeclaration = {
+    $type: 'AliasDeclaration',
+    name: 'name',
+    target: 'target'
+};
 export function isAliasDeclaration(item) {
-    return reflection.isInstance(item, AliasDeclaration);
+    return reflection.isInstance(item, AliasDeclaration.$type);
 }
-export const AllocateUsage = 'AllocateUsage';
-export function isAllocateUsage(item) {
-    return reflection.isInstance(item, AllocateUsage);
+export function isAliasName(item) {
+    return item === 'verification' || (typeof item === 'string' && (/[a-zA-Z_][a-zA-Z0-9_]*/.test(item)));
 }
-export const AttributeDefinition = 'AttributeDefinition';
+export const AllocateUsage = {
+    $type: 'AllocateUsage',
+    source: 'source',
+    target: 'target'
+};
+export function isAllocateUsage(item) {
+    return reflection.isInstance(item, AllocateUsage.$type);
+}
+export const AttributeDefinition = {
+    $type: 'AttributeDefinition',
+    additionalSpecializations: 'additionalSpecializations',
+    body: 'body',
+    isAbstract: 'isAbstract',
+    name: 'name',
+    specialization: 'specialization'
+};
 export function isAttributeDefinition(item) {
-    return reflection.isInstance(item, AttributeDefinition);
-}
-export const AttributeMember = 'AttributeMember';
+    return reflection.isInstance(item, AttributeDefinition.$type);
+}
+export const AttributeMember = {
+    $type: 'AttributeMember',
+    body: 'body',
+    multiplicity: 'multiplicity',
+    name: 'name',
+    redefines: 'redefines',
+    type: 'type',
+    value: 'value'
+};
 export function isAttributeMember(item) {
-    return reflection.isInstance(item, AttributeMember);
+    return reflection.isInstance(item, AttributeMember.$type);
+}
+export const AttributeValue = {
+    $type: 'AttributeValue'
+};
+export function isAttributeValue(item) {
+    return reflection.isInstance(item, AttributeValue.$type);
 }
-export const BinaryExpr = 'BinaryExpr';
+export const BinaryExpr = {
+    $type: 'BinaryExpr',
+    left: 'left',
+    op: 'op',
+    right: 'right'
+};
 export function isBinaryExpr(item) {
-    return reflection.isInstance(item, BinaryExpr);
+    return reflection.isInstance(item, BinaryExpr.$type);
 }
-export const BooleanValue = 'BooleanValue';
+export const BooleanValue = {
+    $type: 'BooleanValue',
+    value: 'value'
+};
 export function isBooleanValue(item) {
-    return reflection.isInstance(item, BooleanValue);
+    return reflection.isInstance(item, BooleanValue.$type);
 }
-export const CollectionOp = 'CollectionOp';
+export const CollectionOp = {
+    $type: 'CollectionOp',
+    argument: 'argument',
+    op: 'op',
+    target: 'target'
+};
 export function isCollectionOp(item) {
-    return reflection.isInstance(item, CollectionOp);
+    return reflection.isInstance(item, CollectionOp.$type);
 }
-export const ConnectionDefinition = 'ConnectionDefinition';
+export const ConnectionBodyMember = {
+    $type: 'ConnectionBodyMember'
+};
+export function isConnectionBodyMember(item) {
+    return reflection.isInstance(item, ConnectionBodyMember.$type);
+}
+export const ConnectionDefinition = {
+    $type: 'ConnectionDefinition',
+    additionalSpecializations: 'additionalSpecializations',
+    body: 'body',
+    isAbstract: 'isAbstract',
+    name: 'name',
+    specialization: 'specialization'
+};
 export function isConnectionDefinition(item) {
-    return reflection.isInstance(item, ConnectionDefinition);
+    return reflection.isInstance(item, ConnectionDefinition.$type);
 }
-export const ConnectionEnd = 'ConnectionEnd';
+export const ConnectionEnd = {
+    $type: 'ConnectionEnd',
+    endName: 'endName',
+    ref: 'ref'
+};
 export function isConnectionEnd(item) {
-    return reflection.isInstance(item, ConnectionEnd);
-}
-export const ConnectionUsage = 'ConnectionUsage';
+    return reflection.isInstance(item, ConnectionEnd.$type);
+}
+export const ConnectionUsage = {
+    $type: 'ConnectionUsage',
+    body: 'body',
+    name: 'name',
+    source: 'source',
+    target: 'target',
+    type: 'type'
+};
 export function isConnectionUsage(item) {
-    return reflection.isInstance(item, ConnectionUsage);
-}
-export const ConstraintDefinition = 'ConstraintDefinition';
+    return reflection.isInstance(item, ConnectionUsage.$type);
+}
+export const ConstraintDefinition = {
+    $type: 'ConstraintDefinition',
+    additionalSpecializations: 'additionalSpecializations',
+    body: 'body',
+    isAbstract: 'isAbstract',
+    name: 'name',
+    specialization: 'specialization'
+};
 export function isConstraintDefinition(item) {
-    return reflection.isInstance(item, ConstraintDefinition);
+    return reflection.isInstance(item, ConstraintDefinition.$type);
+}
+export const ConstraintExpr = {
+    $type: 'ConstraintExpr'
+};
+export function isConstraintExpr(item) {
+    return reflection.isInstance(item, ConstraintExpr.$type);
 }
-export const ControlNodeUsage = 'ControlNodeUsage';
+export const ControlNodeUsage = {
+    $type: 'ControlNodeUsage',
+    controlKind: 'controlKind',
+    name: 'name'
+};
 export function isControlNodeUsage(item) {
-    return reflection.isInstance(item, ControlNodeUsage);
+    return reflection.isInstance(item, ControlNodeUsage.$type);
+}
+export const DefinitionBodyMember = {
+    $type: 'DefinitionBodyMember'
+};
+export function isDefinitionBodyMember(item) {
+    return reflection.isInstance(item, DefinitionBodyMember.$type);
 }
-export const DocComment = 'DocComment';
+export const DefinitionMember = {
+    $type: 'DefinitionMember'
+};
+export function isDefinitionMember(item) {
+    return reflection.isInstance(item, DefinitionMember.$type);
+}
+export const DocComment = {
+    $type: 'DocComment',
+    content: 'content'
+};
 export function isDocComment(item) {
-    return reflection.isInstance(item, DocComment);
+    return reflection.isInstance(item, DocComment.$type);
+}
+export function isDottedName(item) {
+    return typeof item === 'string';
 }
-export const EndDeclaration = 'EndDeclaration';
+export const EndDeclaration = {
+    $type: 'EndDeclaration',
+    isConjugated: 'isConjugated',
+    multiplicity: 'multiplicity',
+    name: 'name',
+    type: 'type'
+};
 export function isEndDeclaration(item) {
-    return reflection.isInstance(item, EndDeclaration);
+    return reflection.isInstance(item, EndDeclaration.$type);
 }
-export const EnumDefinition = 'EnumDefinition';
+export const EnumDefinition = {
+    $type: 'EnumDefinition',
+    literals: 'literals',
+    name: 'name'
+};
 export function isEnumDefinition(item) {
-    return reflection.isInstance(item, EnumDefinition);
+    return reflection.isInstance(item, EnumDefinition.$type);
 }
-export const EnumLiteral = 'EnumLiteral';
+export const EnumLiteral = {
+    $type: 'EnumLiteral',
+    name: 'name'
+};
 export function isEnumLiteral(item) {
-    return reflection.isInstance(item, EnumLiteral);
+    return reflection.isInstance(item, EnumLiteral.$type);
 }
-export const EnumValue = 'EnumValue';
+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)));
+}
+export const EnumValue = {
+    $type: 'EnumValue',
+    enumRef: 'enumRef'
+};
 export function isEnumValue(item) {
-    return reflection.isInstance(item, EnumValue);
+    return reflection.isInstance(item, EnumValue.$type);
 }
-export const ExposeMember = 'ExposeMember';
+export const ExposeMember = {
+    $type: 'ExposeMember',
+    path: 'path'
+};
 export function isExposeMember(item) {
-    return reflection.isInstance(item, ExposeMember);
+    return reflection.isInstance(item, ExposeMember.$type);
+}
+export function isExposePath(item) {
+    return typeof item === 'string';
 }
-export const FeatureChain = 'FeatureChain';
+export const FeatureChain = {
+    $type: 'FeatureChain',
+    segments: 'segments'
+};
 export function isFeatureChain(item) {
-    return reflection.isInstance(item, FeatureChain);
+    return reflection.isInstance(item, FeatureChain.$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)));
 }
-export const FlowConnectionUsage = 'FlowConnectionUsage';
+export const FlowConnectionUsage = {
+    $type: 'FlowConnectionUsage',
+    itemType: 'itemType',
+    source: 'source',
+    target: 'target'
+};
 export function isFlowConnectionUsage(item) {
-    return reflection.isInstance(item, FlowConnectionUsage);
+    return reflection.isInstance(item, FlowConnectionUsage.$type);
 }
-export const FlowEnd = 'FlowEnd';
+export const FlowEnd = {
+    $type: 'FlowEnd',
+    ref: 'ref'
+};
 export function isFlowEnd(item) {
-    return reflection.isInstance(item, FlowEnd);
+    return reflection.isInstance(item, FlowEnd.$type);
 }
-export const ImportDeclaration = 'ImportDeclaration';
+export const ImportDeclaration = {
+    $type: 'ImportDeclaration',
+    path: 'path',
+    visibility: 'visibility'
+};
 export function isImportDeclaration(item) {
-    return reflection.isInstance(item, ImportDeclaration);
+    return reflection.isInstance(item, ImportDeclaration.$type);
+}
+export function isImportPath(item) {
+    return typeof item === 'string';
 }
-export const InterfaceDefinition = 'InterfaceDefinition';
+export const InterfaceDefinition = {
+    $type: 'InterfaceDefinition',
+    additionalSpecializations: 'additionalSpecializations',
+    body: 'body',
+    isAbstract: 'isAbstract',
+    name: 'name',
+    specialization: 'specialization'
+};
 export function isInterfaceDefinition(item) {
-    return reflection.isInstance(item, InterfaceDefinition);
+    return reflection.isInstance(item, InterfaceDefinition.$type);
 }
-export const IntValue = 'IntValue';
-export function isIntValue(item) {
-    return reflection.isInstance(item, IntValue);
+export const InterfaceUsage = {
+    $type: 'InterfaceUsage',
+    body: 'body',
+    name: 'name',
+    type: 'type'
+};
+export function isInterfaceUsage(item) {
+    return reflection.isInstance(item, InterfaceUsage.$type);
 }
-export const ItemDefinition = 'ItemDefinition';
+export const IntValue = {
+    $type: 'IntValue',
+    value: 'value'
+};
+export function isIntValue(item) {
+    return reflection.isInstance(item, IntValue.$type);
+}
+export const ItemDefinition = {
+    $type: 'ItemDefinition',
+    additionalSpecializations: 'additionalSpecializations',
+    body: 'body',
+    isAbstract: 'isAbstract',
+    name: 'name',
+    specialization: 'specialization'
+};
 export function isItemDefinition(item) {
-    return reflection.isInstance(item, ItemDefinition);
-}
-export const LiteralExpr = 'LiteralExpr';
+    return reflection.isInstance(item, ItemDefinition.$type);
+}
+export const ItemUsage = {
+    $type: 'ItemUsage',
+    body: 'body',
+    boundRef: 'boundRef',
+    direction: 'direction',
+    multiplicity: 'multiplicity',
+    name: 'name',
+    type: 'type'
+};
+export function isItemUsage(item) {
+    return reflection.isInstance(item, ItemUsage.$type);
+}
+export const LiteralExpr = {
+    $type: 'LiteralExpr',
+    boolValue: 'boolValue',
+    intValue: 'intValue',
+    strValue: 'strValue'
+};
 export function isLiteralExpr(item) {
-    return reflection.isInstance(item, LiteralExpr);
+    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)));
 }
-export const MetadataApplication = 'MetadataApplication';
+export const MetadataApplication = {
+    $type: 'MetadataApplication',
+    body: 'body',
+    type: 'type'
+};
 export function isMetadataApplication(item) {
-    return reflection.isInstance(item, MetadataApplication);
+    return reflection.isInstance(item, MetadataApplication.$type);
 }
-export const MetadataDefinition = 'MetadataDefinition';
+export const MetadataDefinition = {
+    $type: 'MetadataDefinition',
+    body: 'body',
+    name: 'name',
+    specialization: 'specialization'
+};
 export function isMetadataDefinition(item) {
-    return reflection.isInstance(item, MetadataDefinition);
+    return reflection.isInstance(item, MetadataDefinition.$type);
 }
-export const Model = 'Model';
+export const Model = {
+    $type: 'Model',
+    members: 'members'
+};
 export function isModel(item) {
-    return reflection.isInstance(item, Model);
-}
-export const Multiplicity = 'Multiplicity';
+    return reflection.isInstance(item, Model.$type);
+}
+export const Multiplicity = {
+    $type: 'Multiplicity',
+    exact: 'exact',
+    lower: 'lower',
+    unbounded: 'unbounded',
+    upper: 'upper'
+};
 export function isMultiplicity(item) {
-    return reflection.isInstance(item, Multiplicity);
+    return reflection.isInstance(item, Multiplicity.$type);
+}
+export const NamespaceMember = {
+    $type: 'NamespaceMember'
+};
+export function isNamespaceMember(item) {
+    return reflection.isInstance(item, NamespaceMember.$type);
 }
-export const PackageDeclaration = 'PackageDeclaration';
+export const PackageDeclaration = {
+    $type: 'PackageDeclaration',
+    isLibrary: 'isLibrary',
+    members: 'members',
+    name: 'name'
+};
 export function isPackageDeclaration(item) {
-    return reflection.isInstance(item, PackageDeclaration);
+    return reflection.isInstance(item, PackageDeclaration.$type);
 }
-export const PartDefinition = 'PartDefinition';
+export const PackageMember = {
+    $type: 'PackageMember'
+};
+export function isPackageMember(item) {
+    return reflection.isInstance(item, PackageMember.$type);
+}
+export const PartDefinition = {
+    $type: 'PartDefinition',
+    additionalSpecializations: 'additionalSpecializations',
+    body: 'body',
+    isAbstract: 'isAbstract',
+    name: 'name',
+    specialization: 'specialization'
+};
 export function isPartDefinition(item) {
-    return reflection.isInstance(item, PartDefinition);
-}
-export const PartMember = 'PartMember';
+    return reflection.isInstance(item, PartDefinition.$type);
+}
+export const PartMember = {
+    $type: 'PartMember',
+    bindingOp: 'bindingOp',
+    body: 'body',
+    boundRef: 'boundRef',
+    multiplicity: 'multiplicity',
+    name: 'name',
+    type: 'type'
+};
 export function isPartMember(item) {
-    return reflection.isInstance(item, PartMember);
+    return reflection.isInstance(item, PartMember.$type);
 }
-export const PartUsage = 'PartUsage';
+export const PartUsage = {
+    $type: 'PartUsage',
+    body: 'body',
+    name: 'name',
+    type: 'type'
+};
 export function isPartUsage(item) {
-    return reflection.isInstance(item, PartUsage);
-}
-export const PortDefinition = 'PortDefinition';
+    return reflection.isInstance(item, PartUsage.$type);
+}
+export const PortDefinition = {
+    $type: 'PortDefinition',
+    additionalSpecializations: 'additionalSpecializations',
+    body: 'body',
+    isAbstract: 'isAbstract',
+    name: 'name',
+    specialization: 'specialization'
+};
 export function isPortDefinition(item) {
-    return reflection.isInstance(item, PortDefinition);
-}
-export const PortUsage = 'PortUsage';
+    return reflection.isInstance(item, PortDefinition.$type);
+}
+export const PortUsage = {
+    $type: 'PortUsage',
+    body: 'body',
+    direction: 'direction',
+    isConjugated: 'isConjugated',
+    name: 'name',
+    type: 'type'
+};
 export function isPortUsage(item) {
-    return reflection.isInstance(item, PortUsage);
+    return reflection.isInstance(item, PortUsage.$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)));
+}
+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)));
 }
-export const RealValue = 'RealValue';
+export const RealValue = {
+    $type: 'RealValue',
+    value: 'value'
+};
 export function isRealValue(item) {
-    return reflection.isInstance(item, RealValue);
+    return reflection.isInstance(item, RealValue.$type);
+}
+export function isReferenceName(item) {
+    return typeof item === 'string';
 }
-export const RefMember = 'RefMember';
+export const RefMember = {
+    $type: 'RefMember',
+    isConjugated: 'isConjugated',
+    isItem: 'isItem',
+    multiplicity: 'multiplicity',
+    name: 'name',
+    redefines: 'redefines',
+    type: 'type',
+    value: 'value'
+};
 export function isRefMember(item) {
-    return reflection.isInstance(item, RefMember);
+    return reflection.isInstance(item, RefMember.$type);
 }
-export const RequireConstraintMember = 'RequireConstraintMember';
+export const RequireConstraintMember = {
+    $type: 'RequireConstraintMember',
+    expression: 'expression',
+    kind: 'kind'
+};
 export function isRequireConstraintMember(item) {
-    return reflection.isInstance(item, RequireConstraintMember);
-}
-export const RequirementDefinition = 'RequirementDefinition';
+    return reflection.isInstance(item, RequireConstraintMember.$type);
+}
+export const RequirementDefinition = {
+    $type: 'RequirementDefinition',
+    additionalSpecializations: 'additionalSpecializations',
+    body: 'body',
+    isAbstract: 'isAbstract',
+    name: 'name',
+    specialization: 'specialization'
+};
 export function isRequirementDefinition(item) {
-    return reflection.isInstance(item, RequirementDefinition);
+    return reflection.isInstance(item, RequirementDefinition.$type);
 }
-export const RequirementUsage = 'RequirementUsage';
+export const RequirementUsage = {
+    $type: 'RequirementUsage',
+    body: 'body',
+    name: 'name',
+    type: 'type'
+};
 export function isRequirementUsage(item) {
-    return reflection.isInstance(item, RequirementUsage);
+    return reflection.isInstance(item, RequirementUsage.$type);
 }
-export const SetElement = 'SetElement';
+export const SetElement = {
+    $type: 'SetElement',
+    stringValue: 'stringValue',
+    value: 'value'
+};
 export function isSetElement(item) {
-    return reflection.isInstance(item, SetElement);
+    return reflection.isInstance(item, SetElement.$type);
 }
-export const SetLiteral = 'SetLiteral';
+export const SetLiteral = {
+    $type: 'SetLiteral',
+    elements: 'elements'
+};
 export function isSetLiteral(item) {
-    return reflection.isInstance(item, SetLiteral);
+    return reflection.isInstance(item, SetLiteral.$type);
 }
-export const Specialization = 'Specialization';
+export const Specialization = {
+    $type: 'Specialization',
+    superType: 'superType'
+};
 export function isSpecialization(item) {
-    return reflection.isInstance(item, Specialization);
+    return reflection.isInstance(item, Specialization.$type);
+}
+export const StateDefinition = {
+    $type: 'StateDefinition',
+    additionalSpecializations: 'additionalSpecializations',
+    body: 'body',
+    isAbstract: 'isAbstract',
+    name: 'name',
+    specialization: 'specialization'
+};
+export function isStateDefinition(item) {
+    return reflection.isInstance(item, StateDefinition.$type);
+}
+export const StateUsage = {
+    $type: 'StateUsage',
+    body: 'body',
+    name: 'name',
+    type: 'type'
+};
+export function isStateUsage(item) {
+    return reflection.isInstance(item, StateUsage.$type);
 }
-export const StringValue = 'StringValue';
+export const StringValue = {
+    $type: 'StringValue',
+    value: 'value'
+};
 export function isStringValue(item) {
-    return reflection.isInstance(item, StringValue);
+    return reflection.isInstance(item, StringValue.$type);
 }
-export const SuccessionStep = 'SuccessionStep';
+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',
+    ref: 'ref'
+};
 export function isSuccessionStep(item) {
-    return reflection.isInstance(item, SuccessionStep);
+    return reflection.isInstance(item, SuccessionStep.$type);
 }
-export const SuccessionUsage = 'SuccessionUsage';
+export const SuccessionUsage = {
+    $type: 'SuccessionUsage',
+    steps: 'steps'
+};
 export function isSuccessionUsage(item) {
-    return reflection.isInstance(item, SuccessionUsage);
+    return reflection.isInstance(item, SuccessionUsage.$type);
 }
-export const UnaryExpr = 'UnaryExpr';
+export const UnaryExpr = {
+    $type: 'UnaryExpr',
+    op: 'op',
+    operand: 'operand'
+};
 export function isUnaryExpr(item) {
-    return reflection.isInstance(item, UnaryExpr);
+    return reflection.isInstance(item, UnaryExpr.$type);
 }
-export const ViewDefinition = 'ViewDefinition';
-export function isViewDefinition(item) {
-    return reflection.isInstance(item, ViewDefinition);
+export const UsageBodyMember = {
+    $type: 'UsageBodyMember'
+};
+export function isUsageBodyMember(item) {
+    return reflection.isInstance(item, UsageBodyMember.$type);
 }
-export const ViewpointDefinition = 'ViewpointDefinition';
+export const UsageMember = {
+    $type: 'UsageMember'
+};
+export function isUsageMember(item) {
+    return reflection.isInstance(item, UsageMember.$type);
+}
+export const UseCaseDeclaration = {
+    $type: 'UseCaseDeclaration',
+    additionalSpecializations: 'additionalSpecializations',
+    body: 'body',
+    isAbstract: 'isAbstract',
+    isDefinition: 'isDefinition',
+    name: 'name',
+    specialization: 'specialization',
+    type: 'type',
+    usageBody: 'usageBody'
+};
+export function isUseCaseDeclaration(item) {
+    return reflection.isInstance(item, UseCaseDeclaration.$type);
+}
+export const VerificationDefinition = {
+    $type: 'VerificationDefinition',
+    additionalSpecializations: 'additionalSpecializations',
+    body: 'body',
+    isAbstract: 'isAbstract',
+    name: 'name',
+    specialization: 'specialization'
+};
+export function isVerificationDefinition(item) {
+    return reflection.isInstance(item, VerificationDefinition.$type);
+}
+export const VerificationUsage = {
+    $type: 'VerificationUsage',
+    body: 'body',
+    name: 'name',
+    type: 'type'
+};
+export function isVerificationUsage(item) {
+    return reflection.isInstance(item, VerificationUsage.$type);
+}
+export const ViewBodyMember = {
+    $type: 'ViewBodyMember'
+};
+export function isViewBodyMember(item) {
+    return reflection.isInstance(item, ViewBodyMember.$type);
+}
+export const ViewDefinition = {
+    $type: 'ViewDefinition',
+    additionalSpecializations: 'additionalSpecializations',
+    body: 'body',
+    isAbstract: 'isAbstract',
+    name: 'name',
+    specialization: 'specialization'
+};
+export function isViewDefinition(item) {
+    return reflection.isInstance(item, ViewDefinition.$type);
+}
+export const ViewpointDefinition = {
+    $type: 'ViewpointDefinition',
+    additionalSpecializations: 'additionalSpecializations',
+    body: 'body',
+    isAbstract: 'isAbstract',
+    name: 'name',
+    specialization: 'specialization'
+};
 export function isViewpointDefinition(item) {
-    return reflection.isInstance(item, ViewpointDefinition);
+    return reflection.isInstance(item, ViewpointDefinition.$type);
 }
-export const ViewUsage = 'ViewUsage';
+export const ViewUsage = {
+    $type: 'ViewUsage',
+    body: 'body',
+    name: 'name',
+    type: 'type'
+};
 export function isViewUsage(item) {
-    return reflection.isInstance(item, ViewUsage);
+    return reflection.isInstance(item, ViewUsage.$type);
 }
 export class MemoSysMLAstReflection extends langium.AbstractAstReflection {
-    getAllTypes() {
-        return [ActionDefBodyMember, ActionDefinition, ActionParameterMember, ActionUsage, ActionUsageBodyMember, AliasDeclaration, AllocateUsage, AttributeDefinition, AttributeMember, AttributeValue, BinaryExpr, BooleanValue, CollectionOp, ConnectionBodyMember, ConnectionDefinition, ConnectionEnd, ConnectionUsage, ConstraintDefinition, ConstraintExpr, ControlNodeUsage, DefinitionBodyMember, DefinitionMember, DocComment, EndDeclaration, EnumDefinition, EnumLiteral, EnumValue, ExposeMember, FeatureChain, FlowConnectionUsage, FlowEnd, ImportDeclaration, IntValue, InterfaceDefinition, ItemDefinition, LiteralExpr, MetadataApplication, MetadataDefinition, Model, Multiplicity, NamespaceMember, PackageDeclaration, PackageMember, PartDefinition, PartMember, PartUsage, PortDefinition, PortUsage, RealValue, RefMember, RequireConstraintMember, RequirementDefinition, RequirementUsage, SetElement, SetLiteral, Specialization, StringValue, SuccessionStep, SuccessionUsage, UnaryExpr, UsageBodyMember, UsageMember, ViewBodyMember, ViewDefinition, ViewUsage, ViewpointDefinition];
-    }
-    computeIsSubtype(subtype, supertype) {
-        switch (subtype) {
-            case ActionDefinition:
-            case AttributeDefinition:
-            case ConnectionDefinition:
-            case ConstraintDefinition:
-            case EnumDefinition:
-            case InterfaceDefinition:
-            case ItemDefinition:
-            case MetadataDefinition:
-            case PartDefinition:
-            case PortDefinition:
-            case RequirementDefinition:
-            case ViewDefinition:
-            case ViewpointDefinition: {
-                return this.isSubtype(DefinitionMember, supertype);
-            }
-            case ActionParameterMember: {
-                return this.isSubtype(ActionDefBodyMember, supertype);
-            }
-            case ActionUsage: {
-                return this.isSubtype(ActionUsageBodyMember, supertype) || this.isSubtype(UsageMember, supertype);
-            }
-            case AliasDeclaration:
-            case AllocateUsage:
-            case ConnectionUsage:
-            case DefinitionMember:
-            case UsageMember: {
-                return this.isSubtype(PackageMember, supertype);
-            }
-            case AttributeMember:
-            case PartMember: {
-                return this.isSubtype(DefinitionBodyMember, supertype) || this.isSubtype(UsageBodyMember, supertype);
-            }
-            case BinaryExpr:
-            case CollectionOp:
-            case FeatureChain:
-            case LiteralExpr:
-            case UnaryExpr: {
-                return this.isSubtype(ConstraintExpr, supertype);
-            }
-            case BooleanValue:
-            case EnumValue:
-            case IntValue:
-            case RealValue:
-            case SetLiteral:
-            case StringValue: {
-                return this.isSubtype(AttributeValue, supertype);
-            }
-            case ControlNodeUsage:
-            case FlowConnectionUsage:
-            case SuccessionUsage: {
-                return this.isSubtype(ActionUsageBodyMember, supertype);
-            }
-            case DefinitionBodyMember: {
-                return this.isSubtype(ActionDefBodyMember, supertype) || this.isSubtype(ConnectionBodyMember, supertype);
-            }
-            case DocComment:
-            case MetadataApplication: {
-                return this.isSubtype(DefinitionBodyMember, supertype) || this.isSubtype(PackageMember, supertype) || this.isSubtype(UsageBodyMember, supertype);
-            }
-            case EndDeclaration: {
-                return this.isSubtype(ConnectionBodyMember, supertype);
-            }
-            case ExposeMember: {
-                return this.isSubtype(ViewBodyMember, supertype);
-            }
-            case ImportDeclaration:
-            case PackageDeclaration: {
-                return this.isSubtype(NamespaceMember, supertype) || this.isSubtype(PackageMember, supertype);
-            }
-            case PartUsage:
-            case RequirementUsage: {
-                return this.isSubtype(UsageMember, supertype);
-            }
-            case PortUsage:
-            case ViewUsage: {
-                return this.isSubtype(DefinitionBodyMember, supertype) || this.isSubtype(UsageBodyMember, supertype) || this.isSubtype(UsageMember, supertype);
-            }
-            case RefMember:
-            case RequireConstraintMember: {
-                return this.isSubtype(DefinitionBodyMember, supertype);
-            }
-            case UsageBodyMember: {
-                return this.isSubtype(ActionUsageBodyMember, supertype) || this.isSubtype(ViewBodyMember, supertype);
-            }
-            default: {
-                return false;
-            }
-        }
-    }
-    getReferenceType(refInfo) {
-        const referenceId = `${refInfo.container.$type}:${refInfo.property}`;
-        switch (referenceId) {
-            default: {
-                throw new Error(`${referenceId} is not a valid reference id.`);
-            }
-        }
-    }
-    getTypeMetaData(type) {
-        switch (type) {
-            case ActionDefinition: {
-                return {
-                    name: ActionDefinition,
-                    properties: [
-                        { name: 'additionalSpecializations', defaultValue: [] },
-                        { name: 'behaviorKind' },
-                        { name: 'body', defaultValue: [] },
-                        { name: 'isAbstract', defaultValue: false },
-                        { name: 'name' },
-                        { name: 'specialization' }
-                    ]
-                };
-            }
-            case ActionParameterMember: {
-                return {
-                    name: ActionParameterMember,
-                    properties: [
-                        { name: 'direction' },
-                        { name: 'name' },
-                        { name: 'type' }
-                    ]
-                };
-            }
-            case ActionUsage: {
-                return {
-                    name: ActionUsage,
-                    properties: [
-                        { name: 'behaviorKind' },
-                        { name: 'body', defaultValue: [] },
-                        { name: 'name' },
-                        { name: 'type' }
-                    ]
-                };
-            }
-            case AliasDeclaration: {
-                return {
-                    name: AliasDeclaration,
-                    properties: [
-                        { name: 'name' },
-                        { name: 'target' }
-                    ]
-                };
-            }
-            case AllocateUsage: {
-                return {
-                    name: AllocateUsage,
-                    properties: [
-                        { name: 'source' },
-                        { name: 'target' }
-                    ]
-                };
-            }
-            case AttributeDefinition: {
-                return {
-                    name: AttributeDefinition,
-                    properties: [
-                        { name: 'additionalSpecializations', defaultValue: [] },
-                        { name: 'body', defaultValue: [] },
-                        { name: 'isAbstract', defaultValue: false },
-                        { name: 'name' },
-                        { name: 'specialization' }
-                    ]
-                };
-            }
-            case AttributeMember: {
-                return {
-                    name: AttributeMember,
-                    properties: [
-                        { name: 'multiplicity' },
-                        { name: 'name' },
-                        { name: 'redefines', defaultValue: false },
-                        { name: 'type' },
-                        { name: 'value' }
-                    ]
-                };
-            }
-            case BinaryExpr: {
-                return {
-                    name: BinaryExpr,
-                    properties: [
-                        { name: 'left' },
-                        { name: 'op' },
-                        { name: 'right' }
-                    ]
-                };
-            }
-            case BooleanValue: {
-                return {
-                    name: BooleanValue,
-                    properties: [
-                        { name: 'value' }
-                    ]
-                };
-            }
-            case CollectionOp: {
-                return {
-                    name: CollectionOp,
-                    properties: [
-                        { name: 'argument' },
-                        { name: 'op' },
-                        { name: 'target' }
-                    ]
-                };
-            }
-            case ConnectionDefinition: {
-                return {
-                    name: ConnectionDefinition,
-                    properties: [
-                        { name: 'additionalSpecializations', defaultValue: [] },
-                        { name: 'body', defaultValue: [] },
-                        { name: 'isAbstract', defaultValue: false },
-                        { name: 'name' },
-                        { name: 'specialization' }
-                    ]
-                };
-            }
-            case ConnectionEnd: {
-                return {
-                    name: ConnectionEnd,
-                    properties: [
-                        { name: 'endName' },
-                        { name: 'ref' }
-                    ]
-                };
-            }
-            case ConnectionUsage: {
-                return {
-                    name: ConnectionUsage,
-                    properties: [
-                        { name: 'source' },
-                        { name: 'target' },
-                        { name: 'type' }
-                    ]
-                };
-            }
-            case ConstraintDefinition: {
-                return {
-                    name: ConstraintDefinition,
-                    properties: [
-                        { name: 'additionalSpecializations', defaultValue: [] },
-                        { name: 'body', defaultValue: [] },
-                        { name: 'isAbstract', defaultValue: false },
-                        { name: 'name' },
-                        { name: 'specialization' }
-                    ]
-                };
-            }
-            case ControlNodeUsage: {
-                return {
-                    name: ControlNodeUsage,
-                    properties: [
-                        { name: 'controlKind' },
-                        { name: 'name' }
-                    ]
-                };
-            }
-            case DocComment: {
-                return {
-                    name: DocComment,
-                    properties: [
-                        { name: 'content' }
-                    ]
-                };
-            }
-            case EndDeclaration: {
-                return {
-                    name: EndDeclaration,
-                    properties: [
-                        { name: 'multiplicity' },
-                        { name: 'name' },
-                        { name: 'type' }
-                    ]
-                };
-            }
-            case EnumDefinition: {
-                return {
-                    name: EnumDefinition,
-                    properties: [
-                        { name: 'literals', defaultValue: [] },
-                        { name: 'name' }
-                    ]
-                };
-            }
-            case EnumLiteral: {
-                return {
-                    name: EnumLiteral,
-                    properties: [
-                        { name: 'name' }
-                    ]
-                };
-            }
-            case EnumValue: {
-                return {
-                    name: EnumValue,
-                    properties: [
-                        { name: 'enumRef' }
-                    ]
-                };
-            }
-            case ExposeMember: {
-                return {
-                    name: ExposeMember,
-                    properties: [
-                        { name: 'path' }
-                    ]
-                };
-            }
-            case FeatureChain: {
-                return {
-                    name: FeatureChain,
-                    properties: [
-                        { name: 'segments', defaultValue: [] }
-                    ]
-                };
-            }
-            case FlowConnectionUsage: {
-                return {
-                    name: FlowConnectionUsage,
-                    properties: [
-                        { name: 'itemType' },
-                        { name: 'source' },
-                        { name: 'target' }
-                    ]
-                };
-            }
-            case FlowEnd: {
-                return {
-                    name: FlowEnd,
-                    properties: [
-                        { name: 'ref' }
-                    ]
-                };
-            }
-            case ImportDeclaration: {
-                return {
-                    name: ImportDeclaration,
-                    properties: [
-                        { name: 'path' },
-                        { name: 'visibility' }
-                    ]
-                };
-            }
-            case InterfaceDefinition: {
-                return {
-                    name: InterfaceDefinition,
-                    properties: [
-                        { name: 'additionalSpecializations', defaultValue: [] },
-                        { name: 'body', defaultValue: [] },
-                        { name: 'isAbstract', defaultValue: false },
-                        { name: 'name' },
-                        { name: 'specialization' }
-                    ]
-                };
-            }
-            case IntValue: {
-                return {
-                    name: IntValue,
-                    properties: [
-                        { name: 'value' }
-                    ]
-                };
-            }
-            case ItemDefinition: {
-                return {
-                    name: ItemDefinition,
-                    properties: [
-                        { name: 'additionalSpecializations', defaultValue: [] },
-                        { name: 'body', defaultValue: [] },
-                        { name: 'isAbstract', defaultValue: false },
-                        { name: 'name' },
-                        { name: 'specialization' }
-                    ]
-                };
-            }
-            case LiteralExpr: {
-                return {
-                    name: LiteralExpr,
-                    properties: [
-                        { name: 'boolValue' },
-                        { name: 'intValue' },
-                        { name: 'strValue' }
-                    ]
-                };
-            }
-            case MetadataApplication: {
-                return {
-                    name: MetadataApplication,
-                    properties: [
-                        { name: 'body', defaultValue: [] },
-                        { name: 'type' }
-                    ]
-                };
-            }
-            case MetadataDefinition: {
-                return {
-                    name: MetadataDefinition,
-                    properties: [
-                        { name: 'body', defaultValue: [] },
-                        { name: 'name' },
-                        { name: 'specialization' }
-                    ]
-                };
-            }
-            case Model: {
-                return {
-                    name: Model,
-                    properties: [
-                        { name: 'members', defaultValue: [] }
-                    ]
-                };
-            }
-            case Multiplicity: {
-                return {
-                    name: Multiplicity,
-                    properties: [
-                        { name: 'exact' },
-                        { name: 'lower' },
-                        { name: 'unbounded', defaultValue: false },
-                        { name: 'upper' }
-                    ]
-                };
-            }
-            case PackageDeclaration: {
-                return {
-                    name: PackageDeclaration,
-                    properties: [
-                        { name: 'isLibrary', defaultValue: false },
-                        { name: 'members', defaultValue: [] },
-                        { name: 'name' }
-                    ]
-                };
-            }
-            case PartDefinition: {
-                return {
-                    name: PartDefinition,
-                    properties: [
-                        { name: 'additionalSpecializations', defaultValue: [] },
-                        { name: 'body', defaultValue: [] },
-                        { name: 'isAbstract', defaultValue: false },
-                        { name: 'name' },
-                        { name: 'specialization' }
-                    ]
-                };
-            }
-            case PartMember: {
-                return {
-                    name: PartMember,
-                    properties: [
-                        { name: 'bindingOp' },
-                        { name: 'body', defaultValue: [] },
-                        { name: 'boundRef' },
-                        { name: 'multiplicity' },
-                        { name: 'name' },
-                        { name: 'type' }
-                    ]
-                };
-            }
-            case PartUsage: {
-                return {
-                    name: PartUsage,
-                    properties: [
-                        { name: 'body', defaultValue: [] },
-                        { name: 'name' },
-                        { name: 'type' }
-                    ]
-                };
-            }
-            case PortDefinition: {
-                return {
-                    name: PortDefinition,
-                    properties: [
-                        { name: 'additionalSpecializations', defaultValue: [] },
-                        { name: 'body', defaultValue: [] },
-                        { name: 'isAbstract', defaultValue: false },
-                        { name: 'name' },
-                        { name: 'specialization' }
-                    ]
-                };
-            }
-            case PortUsage: {
-                return {
-                    name: PortUsage,
-                    properties: [
-                        { name: 'body', defaultValue: [] },
-                        { name: 'direction' },
-                        { name: 'isConjugated', defaultValue: false },
-                        { name: 'name' },
-                        { name: 'type' }
-                    ]
-                };
-            }
-            case RealValue: {
-                return {
-                    name: RealValue,
-                    properties: [
-                        { name: 'value' }
-                    ]
-                };
-            }
-            case RefMember: {
-                return {
-                    name: RefMember,
-                    properties: [
-                        { name: 'multiplicity' },
-                        { name: 'name' },
-                        { name: 'type' }
-                    ]
-                };
-            }
-            case RequireConstraintMember: {
-                return {
-                    name: RequireConstraintMember,
-                    properties: [
-                        { name: 'expression' },
-                        { name: 'kind' }
-                    ]
-                };
-            }
-            case RequirementDefinition: {
-                return {
-                    name: RequirementDefinition,
-                    properties: [
-                        { name: 'additionalSpecializations', defaultValue: [] },
-                        { name: 'body', defaultValue: [] },
-                        { name: 'isAbstract', defaultValue: false },
-                        { name: 'name' },
-                        { name: 'specialization' }
-                    ]
-                };
-            }
-            case RequirementUsage: {
-                return {
-                    name: RequirementUsage,
-                    properties: [
-                        { name: 'body', defaultValue: [] },
-                        { name: 'name' },
-                        { name: 'type' }
-                    ]
-                };
-            }
-            case SetElement: {
-                return {
-                    name: SetElement,
-                    properties: [
-                        { name: 'stringValue' },
-                        { name: 'value' }
-                    ]
-                };
-            }
-            case SetLiteral: {
-                return {
-                    name: SetLiteral,
-                    properties: [
-                        { name: 'elements', defaultValue: [] }
-                    ]
-                };
-            }
-            case Specialization: {
-                return {
-                    name: Specialization,
-                    properties: [
-                        { name: 'superType' }
-                    ]
-                };
-            }
-            case StringValue: {
-                return {
-                    name: StringValue,
-                    properties: [
-                        { name: 'value' }
-                    ]
-                };
-            }
-            case SuccessionStep: {
-                return {
-                    name: SuccessionStep,
-                    properties: [
-                        { name: 'ref' }
-                    ]
-                };
-            }
-            case SuccessionUsage: {
-                return {
-                    name: SuccessionUsage,
-                    properties: [
-                        { name: 'steps', defaultValue: [] }
-                    ]
-                };
-            }
-            case UnaryExpr: {
-                return {
-                    name: UnaryExpr,
-                    properties: [
-                        { name: 'op' },
-                        { name: 'operand' }
-                    ]
-                };
-            }
-            case ViewDefinition: {
-                return {
-                    name: ViewDefinition,
-                    properties: [
-                        { name: 'additionalSpecializations', defaultValue: [] },
-                        { name: 'body', defaultValue: [] },
-                        { name: 'isAbstract', defaultValue: false },
-                        { name: 'name' },
-                        { name: 'specialization' }
-                    ]
-                };
-            }
-            case ViewpointDefinition: {
-                return {
-                    name: ViewpointDefinition,
-                    properties: [
-                        { name: 'additionalSpecializations', defaultValue: [] },
-                        { name: 'body', defaultValue: [] },
-                        { name: 'isAbstract', defaultValue: false },
-                        { name: 'name' },
-                        { name: 'specialization' }
-                    ]
-                };
-            }
-            case ViewUsage: {
-                return {
-                    name: ViewUsage,
-                    properties: [
-                        { name: 'body', defaultValue: [] },
-                        { name: 'name' },
-                        { name: 'type' }
-                    ]
-                };
-            }
-            default: {
-                return {
-                    name: type,
-                    properties: []
-                };
-            }
+    types = {
+        ActionDefBodyMember: {
+            name: ActionDefBodyMember.$type,
+            properties: {},
+            superTypes: []
+        },
+        ActionDefinition: {
+            name: ActionDefinition.$type,
+            properties: {
+                additionalSpecializations: {
+                    name: ActionDefinition.additionalSpecializations,
+                    defaultValue: [],
+                    optional: true
+                },
+                behaviorKind: {
+                    name: ActionDefinition.behaviorKind
+                },
+                body: {
+                    name: ActionDefinition.body,
+                    defaultValue: [],
+                    optional: true
+                },
+                isAbstract: {
+                    name: ActionDefinition.isAbstract,
+                    defaultValue: false,
+                    optional: true
+                },
+                name: {
+                    name: ActionDefinition.name
+                },
+                specialization: {
+                    name: ActionDefinition.specialization,
+                    optional: true
+                }
+            },
+            superTypes: [DefinitionMember.$type]
+        },
+        ActionParameterMember: {
+            name: ActionParameterMember.$type,
+            properties: {
+                direction: {
+                    name: ActionParameterMember.direction
+                },
+                name: {
+                    name: ActionParameterMember.name
+                },
+                type: {
+                    name: ActionParameterMember.type
+                }
+            },
+            superTypes: [ActionDefBodyMember.$type]
+        },
+        ActionUsage: {
+            name: ActionUsage.$type,
+            properties: {
+                behaviorKind: {
+                    name: ActionUsage.behaviorKind
+                },
+                body: {
+                    name: ActionUsage.body,
+                    defaultValue: [],
+                    optional: true
+                },
+                name: {
+                    name: ActionUsage.name
+                },
+                type: {
+                    name: ActionUsage.type,
+                    optional: true
+                }
+            },
+            superTypes: [ActionUsageBodyMember.$type, UsageMember.$type]
+        },
+        ActionUsageBodyMember: {
+            name: ActionUsageBodyMember.$type,
+            properties: {},
+            superTypes: []
+        },
+        AliasDeclaration: {
+            name: AliasDeclaration.$type,
+            properties: {
+                name: {
+                    name: AliasDeclaration.name
+                },
+                target: {
+                    name: AliasDeclaration.target
+                }
+            },
+            superTypes: [PackageMember.$type]
+        },
+        AllocateUsage: {
+            name: AllocateUsage.$type,
+            properties: {
+                source: {
+                    name: AllocateUsage.source
+                },
+                target: {
+                    name: AllocateUsage.target
+                }
+            },
+            superTypes: [PackageMember.$type]
+        },
+        AttributeDefinition: {
+            name: AttributeDefinition.$type,
+            properties: {
+                additionalSpecializations: {
+                    name: AttributeDefinition.additionalSpecializations,
+                    defaultValue: [],
+                    optional: true
+                },
+                body: {
+                    name: AttributeDefinition.body,
+                    defaultValue: [],
+                    optional: true
+                },
+                isAbstract: {
+                    name: AttributeDefinition.isAbstract,
+                    defaultValue: false,
+                    optional: true
+                },
+                name: {
+                    name: AttributeDefinition.name
+                },
+                specialization: {
+                    name: AttributeDefinition.specialization,
+                    optional: true
+                }
+            },
+            superTypes: [DefinitionMember.$type]
+        },
+        AttributeMember: {
+            name: AttributeMember.$type,
+            properties: {
+                body: {
+                    name: AttributeMember.body,
+                    defaultValue: [],
+                    optional: true
+                },
+                multiplicity: {
+                    name: AttributeMember.multiplicity,
+                    optional: true
+                },
+                name: {
+                    name: AttributeMember.name
+                },
+                redefines: {
+                    name: AttributeMember.redefines,
+                    defaultValue: false,
+                    optional: true
+                },
+                type: {
+                    name: AttributeMember.type,
+                    optional: true
+                },
+                value: {
+                    name: AttributeMember.value,
+                    optional: true
+                }
+            },
+            superTypes: [DefinitionBodyMember.$type, PackageMember.$type, UsageBodyMember.$type]
+        },
+        AttributeValue: {
+            name: AttributeValue.$type,
+            properties: {},
+            superTypes: []
+        },
+        BinaryExpr: {
+            name: BinaryExpr.$type,
+            properties: {
+                left: {
+                    name: BinaryExpr.left
+                },
+                op: {
+                    name: BinaryExpr.op
+                },
+                right: {
+                    name: BinaryExpr.right
+                }
+            },
+            superTypes: [ConstraintExpr.$type]
+        },
+        BooleanValue: {
+            name: BooleanValue.$type,
+            properties: {
+                value: {
+                    name: BooleanValue.value
+                }
+            },
+            superTypes: [AttributeValue.$type]
+        },
+        CollectionOp: {
+            name: CollectionOp.$type,
+            properties: {
+                argument: {
+                    name: CollectionOp.argument,
+                    optional: true
+                },
+                op: {
+                    name: CollectionOp.op
+                },
+                target: {
+                    name: CollectionOp.target
+                }
+            },
+            superTypes: [ConstraintExpr.$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
+                },
+                name: {
+                    name: ConnectionDefinition.name
+                },
+                specialization: {
+                    name: ConnectionDefinition.specialization,
+                    optional: true
+                }
+            },
+            superTypes: [DefinitionMember.$type]
+        },
+        ConnectionEnd: {
+            name: ConnectionEnd.$type,
+            properties: {
+                endName: {
+                    name: ConnectionEnd.endName
+                },
+                ref: {
+                    name: ConnectionEnd.ref
+                }
+            },
+            superTypes: []
+        },
+        ConnectionUsage: {
+            name: ConnectionUsage.$type,
+            properties: {
+                body: {
+                    name: ConnectionUsage.body,
+                    defaultValue: [],
+                    optional: true
+                },
+                name: {
+                    name: ConnectionUsage.name,
+                    optional: true
+                },
+                source: {
+                    name: ConnectionUsage.source
+                },
+                target: {
+                    name: ConnectionUsage.target
+                },
+                type: {
+                    name: ConnectionUsage.type,
+                    optional: true
+                }
+            },
+            superTypes: [PackageMember.$type, UsageBodyMember.$type]
+        },
+        ConstraintDefinition: {
+            name: ConstraintDefinition.$type,
+            properties: {
+                additionalSpecializations: {
+                    name: ConstraintDefinition.additionalSpecializations,
+                    defaultValue: [],
+                    optional: true
+                },
+                body: {
+                    name: ConstraintDefinition.body,
+                    defaultValue: [],
+                    optional: true
+                },
+                isAbstract: {
+                    name: ConstraintDefinition.isAbstract,
+                    defaultValue: false,
+                    optional: true
+                },
+                name: {
+                    name: ConstraintDefinition.name
+                },
+                specialization: {
+                    name: ConstraintDefinition.specialization,
+                    optional: true
+                }
+            },
+            superTypes: [DefinitionMember.$type]
+        },
+        ConstraintExpr: {
+            name: ConstraintExpr.$type,
+            properties: {},
+            superTypes: []
+        },
+        ControlNodeUsage: {
+            name: ControlNodeUsage.$type,
+            properties: {
+                controlKind: {
+                    name: ControlNodeUsage.controlKind
+                },
+                name: {
+                    name: ControlNodeUsage.name
+                }
+            },
+            superTypes: [ActionUsageBodyMember.$type]
+        },
+        DefinitionBodyMember: {
+            name: DefinitionBodyMember.$type,
+            properties: {},
+            superTypes: [ActionDefBodyMember.$type, ConnectionBodyMember.$type]
+        },
+        DefinitionMember: {
+            name: DefinitionMember.$type,
+            properties: {},
+            superTypes: [PackageMember.$type]
+        },
+        DocComment: {
+            name: DocComment.$type,
+            properties: {
+                content: {
+                    name: DocComment.content
+                }
+            },
+            superTypes: [DefinitionBodyMember.$type, PackageMember.$type, UsageBodyMember.$type]
+        },
+        EndDeclaration: {
+            name: EndDeclaration.$type,
+            properties: {
+                isConjugated: {
+                    name: EndDeclaration.isConjugated,
+                    defaultValue: false,
+                    optional: true
+                },
+                multiplicity: {
+                    name: EndDeclaration.multiplicity,
+                    optional: true
+                },
+                name: {
+                    name: EndDeclaration.name
+                },
+                type: {
+                    name: EndDeclaration.type,
+                    optional: true
+                }
+            },
+            superTypes: [ConnectionBodyMember.$type]
+        },
+        EnumDefinition: {
+            name: EnumDefinition.$type,
+            properties: {
+                literals: {
+                    name: EnumDefinition.literals,
+                    defaultValue: [],
+                    optional: true
+                },
+                name: {
+                    name: EnumDefinition.name
+                }
+            },
+            superTypes: [DefinitionMember.$type]
+        },
+        EnumLiteral: {
+            name: EnumLiteral.$type,
+            properties: {
+                name: {
+                    name: EnumLiteral.name
+                }
+            },
+            superTypes: []
+        },
+        EnumValue: {
+            name: EnumValue.$type,
+            properties: {
+                enumRef: {
+                    name: EnumValue.enumRef
+                }
+            },
+            superTypes: [AttributeValue.$type]
+        },
+        ExposeMember: {
+            name: ExposeMember.$type,
+            properties: {
+                path: {
+                    name: ExposeMember.path
+                }
+            },
+            superTypes: [ViewBodyMember.$type]
+        },
+        FeatureChain: {
+            name: FeatureChain.$type,
+            properties: {
+                segments: {
+                    name: FeatureChain.segments,
+                    defaultValue: []
+                }
+            },
+            superTypes: [ConstraintExpr.$type]
+        },
+        FlowConnectionUsage: {
+            name: FlowConnectionUsage.$type,
+            properties: {
+                itemType: {
+                    name: FlowConnectionUsage.itemType
+                },
+                source: {
+                    name: FlowConnectionUsage.source
+                },
+                target: {
+                    name: FlowConnectionUsage.target
+                }
+            },
+            superTypes: [UsageBodyMember.$type]
+        },
+        FlowEnd: {
+            name: FlowEnd.$type,
+            properties: {
+                ref: {
+                    name: FlowEnd.ref
+                }
+            },
+            superTypes: []
+        },
+        ImportDeclaration: {
+            name: ImportDeclaration.$type,
+            properties: {
+                path: {
+                    name: ImportDeclaration.path
+                },
+                visibility: {
+                    name: ImportDeclaration.visibility,
+                    optional: true
+                }
+            },
+            superTypes: [NamespaceMember.$type, PackageMember.$type]
+        },
+        IntValue: {
+            name: IntValue.$type,
+            properties: {
+                value: {
+                    name: IntValue.value
+                }
+            },
+            superTypes: [AttributeValue.$type]
+        },
+        InterfaceDefinition: {
+            name: InterfaceDefinition.$type,
+            properties: {
+                additionalSpecializations: {
+                    name: InterfaceDefinition.additionalSpecializations,
+                    defaultValue: [],
+                    optional: true
+                },
+                body: {
+                    name: InterfaceDefinition.body,
+                    defaultValue: [],
+                    optional: true
+                },
+                isAbstract: {
+                    name: InterfaceDefinition.isAbstract,
+                    defaultValue: false,
+                    optional: true
+                },
+                name: {
+                    name: InterfaceDefinition.name
+                },
+                specialization: {
+                    name: InterfaceDefinition.specialization,
+                    optional: true
+                }
+            },
+            superTypes: [DefinitionMember.$type]
+        },
+        InterfaceUsage: {
+            name: InterfaceUsage.$type,
+            properties: {
+                body: {
+                    name: InterfaceUsage.body,
+                    defaultValue: [],
+                    optional: true
+                },
+                name: {
+                    name: InterfaceUsage.name
+                },
+                type: {
+                    name: InterfaceUsage.type
+                }
+            },
+            superTypes: [UsageMember.$type]
+        },
+        ItemDefinition: {
+            name: ItemDefinition.$type,
+            properties: {
+                additionalSpecializations: {
+                    name: ItemDefinition.additionalSpecializations,
+                    defaultValue: [],
+                    optional: true
+                },
+                body: {
+                    name: ItemDefinition.body,
+                    defaultValue: [],
+                    optional: true
+                },
+                isAbstract: {
+                    name: ItemDefinition.isAbstract,
+                    defaultValue: false,
+                    optional: true
+                },
+                name: {
+                    name: ItemDefinition.name
+                },
+                specialization: {
+                    name: ItemDefinition.specialization,
+                    optional: true
+                }
+            },
+            superTypes: [DefinitionMember.$type]
+        },
+        ItemUsage: {
+            name: ItemUsage.$type,
+            properties: {
+                body: {
+                    name: ItemUsage.body,
+                    defaultValue: [],
+                    optional: true
+                },
+                boundRef: {
+                    name: ItemUsage.boundRef,
+                    optional: true
+                },
+                direction: {
+                    name: ItemUsage.direction,
+                    optional: true
+                },
+                multiplicity: {
+                    name: ItemUsage.multiplicity,
+                    optional: true
+                },
+                name: {
+                    name: ItemUsage.name
+                },
+                type: {
+                    name: ItemUsage.type,
+                    optional: true
+                }
+            },
+            superTypes: [DefinitionBodyMember.$type, PackageMember.$type, UsageBodyMember.$type]
+        },
+        LiteralExpr: {
+            name: LiteralExpr.$type,
+            properties: {
+                boolValue: {
+                    name: LiteralExpr.boolValue,
+                    optional: true
+                },
+                intValue: {
+                    name: LiteralExpr.intValue,
+                    optional: true
+                },
+                strValue: {
+                    name: LiteralExpr.strValue,
+                    optional: true
+                }
+            },
+            superTypes: [ConstraintExpr.$type]
+        },
+        MetadataApplication: {
+            name: MetadataApplication.$type,
+            properties: {
+                body: {
+                    name: MetadataApplication.body,
+                    defaultValue: [],
+                    optional: true
+                },
+                type: {
+                    name: MetadataApplication.type
+                }
+            },
+            superTypes: [DefinitionBodyMember.$type, PackageMember.$type, UsageBodyMember.$type]
+        },
+        MetadataDefinition: {
+            name: MetadataDefinition.$type,
+            properties: {
+                body: {
+                    name: MetadataDefinition.body,
+                    defaultValue: [],
+                    optional: true
+                },
+                name: {
+                    name: MetadataDefinition.name
+                },
+                specialization: {
+                    name: MetadataDefinition.specialization,
+                    optional: true
+                }
+            },
+            superTypes: [DefinitionMember.$type]
+        },
+        Model: {
+            name: Model.$type,
+            properties: {
+                members: {
+                    name: Model.members,
+                    defaultValue: [],
+                    optional: true
+                }
+            },
+            superTypes: []
+        },
+        Multiplicity: {
+            name: Multiplicity.$type,
+            properties: {
+                exact: {
+                    name: Multiplicity.exact,
+                    optional: true
+                },
+                lower: {
+                    name: Multiplicity.lower,
+                    optional: true
+                },
+                unbounded: {
+                    name: Multiplicity.unbounded,
+                    defaultValue: false,
+                    optional: true
+                },
+                upper: {
+                    name: Multiplicity.upper,
+                    optional: true
+                }
+            },
+            superTypes: []
+        },
+        NamespaceMember: {
+            name: NamespaceMember.$type,
+            properties: {},
+            superTypes: []
+        },
+        PackageDeclaration: {
+            name: PackageDeclaration.$type,
+            properties: {
+                isLibrary: {
+                    name: PackageDeclaration.isLibrary,
+                    defaultValue: false,
+                    optional: true
+                },
+                members: {
+                    name: PackageDeclaration.members,
+                    defaultValue: [],
+                    optional: true
+                },
+                name: {
+                    name: PackageDeclaration.name
+                }
+            },
+            superTypes: [NamespaceMember.$type, PackageMember.$type]
+        },
+        PackageMember: {
+            name: PackageMember.$type,
+            properties: {},
+            superTypes: []
+        },
+        PartDefinition: {
+            name: PartDefinition.$type,
+            properties: {
+                additionalSpecializations: {
+                    name: PartDefinition.additionalSpecializations,
+                    defaultValue: [],
+                    optional: true
+                },
+                body: {
+                    name: PartDefinition.body,
+                    defaultValue: [],
+                    optional: true
+                },
+                isAbstract: {
+                    name: PartDefinition.isAbstract,
+                    defaultValue: false,
+                    optional: true
+                },
+                name: {
+                    name: PartDefinition.name
+                },
+                specialization: {
+                    name: PartDefinition.specialization,
+                    optional: true
+                }
+            },
+            superTypes: [DefinitionMember.$type]
+        },
+        PartMember: {
+            name: PartMember.$type,
+            properties: {
+                bindingOp: {
+                    name: PartMember.bindingOp
+                },
+                body: {
+                    name: PartMember.body,
+                    defaultValue: [],
+                    optional: true
+                },
+                boundRef: {
+                    name: PartMember.boundRef,
+                    optional: true
+                },
+                multiplicity: {
+                    name: PartMember.multiplicity,
+                    optional: true
+                },
+                name: {
+                    name: PartMember.name
+                },
+                type: {
+                    name: PartMember.type,
+                    optional: true
+                }
+            },
+            superTypes: [DefinitionBodyMember.$type, UsageBodyMember.$type]
+        },
+        PartUsage: {
+            name: PartUsage.$type,
+            properties: {
+                body: {
+                    name: PartUsage.body,
+                    defaultValue: [],
+                    optional: true
+                },
+                name: {
+                    name: PartUsage.name
+                },
+                type: {
+                    name: PartUsage.type,
+                    optional: true
+                }
+            },
+            superTypes: [UsageMember.$type]
+        },
+        PortDefinition: {
+            name: PortDefinition.$type,
+            properties: {
+                additionalSpecializations: {
+                    name: PortDefinition.additionalSpecializations,
+                    defaultValue: [],
+                    optional: true
+                },
+                body: {
+                    name: PortDefinition.body,
+                    defaultValue: [],
+                    optional: true
+                },
+                isAbstract: {
+                    name: PortDefinition.isAbstract,
+                    defaultValue: false,
+                    optional: true
+                },
+                name: {
+                    name: PortDefinition.name
+                },
+                specialization: {
+                    name: PortDefinition.specialization,
+                    optional: true
+                }
+            },
+            superTypes: [DefinitionMember.$type]
+        },
+        PortUsage: {
+            name: PortUsage.$type,
+            properties: {
+                body: {
+                    name: PortUsage.body,
+                    defaultValue: [],
+                    optional: true
+                },
+                direction: {
+                    name: PortUsage.direction,
+                    optional: true
+                },
+                isConjugated: {
+                    name: PortUsage.isConjugated,
+                    defaultValue: false,
+                    optional: true
+                },
+                name: {
+                    name: PortUsage.name
+                },
+                type: {
+                    name: PortUsage.type
+                }
+            },
+            superTypes: [DefinitionBodyMember.$type, UsageBodyMember.$type, UsageMember.$type]
+        },
+        RealValue: {
+            name: RealValue.$type,
+            properties: {
+                value: {
+                    name: RealValue.value
+                }
+            },
+            superTypes: [AttributeValue.$type]
+        },
+        RefMember: {
+            name: RefMember.$type,
+            properties: {
+                isConjugated: {
+                    name: RefMember.isConjugated,
+                    defaultValue: false,
+                    optional: true
+                },
+                isItem: {
+                    name: RefMember.isItem,
+                    defaultValue: false,
+                    optional: true
+                },
+                multiplicity: {
+                    name: RefMember.multiplicity,
+                    optional: true
+                },
+                name: {
+                    name: RefMember.name
+                },
+                redefines: {
+                    name: RefMember.redefines,
+                    defaultValue: false,
+                    optional: true
+                },
+                type: {
+                    name: RefMember.type,
+                    optional: true
+                },
+                value: {
+                    name: RefMember.value,
+                    optional: true
+                }
+            },
+            superTypes: [DefinitionBodyMember.$type, UsageBodyMember.$type]
+        },
+        RequireConstraintMember: {
+            name: RequireConstraintMember.$type,
+            properties: {
+                expression: {
+                    name: RequireConstraintMember.expression
+                },
+                kind: {
+                    name: RequireConstraintMember.kind,
+                    optional: true
+                }
+            },
+            superTypes: [DefinitionBodyMember.$type]
+        },
+        RequirementDefinition: {
+            name: RequirementDefinition.$type,
+            properties: {
+                additionalSpecializations: {
+                    name: RequirementDefinition.additionalSpecializations,
+                    defaultValue: [],
+                    optional: true
+                },
+                body: {
+                    name: RequirementDefinition.body,
+                    defaultValue: [],
+                    optional: true
+                },
+                isAbstract: {
+                    name: RequirementDefinition.isAbstract,
+                    defaultValue: false,
+                    optional: true
+                },
+                name: {
+                    name: RequirementDefinition.name
+                },
+                specialization: {
+                    name: RequirementDefinition.specialization,
+                    optional: true
+                }
+            },
+            superTypes: [DefinitionMember.$type]
+        },
+        RequirementUsage: {
+            name: RequirementUsage.$type,
+            properties: {
+                body: {
+                    name: RequirementUsage.body,
+                    defaultValue: [],
+                    optional: true
+                },
+                name: {
+                    name: RequirementUsage.name
+                },
+                type: {
+                    name: RequirementUsage.type
+                }
+            },
+            superTypes: [UsageMember.$type]
+        },
+        SetElement: {
+            name: SetElement.$type,
+            properties: {
+                stringValue: {
+                    name: SetElement.stringValue,
+                    optional: true
+                },
+                value: {
+                    name: SetElement.value,
+                    optional: true
+                }
+            },
+            superTypes: []
+        },
+        SetLiteral: {
+            name: SetLiteral.$type,
+            properties: {
+                elements: {
+                    name: SetLiteral.elements,
+                    defaultValue: []
+                }
+            },
+            superTypes: [AttributeValue.$type]
+        },
+        Specialization: {
+            name: Specialization.$type,
+            properties: {
+                superType: {
+                    name: Specialization.superType
+                }
+            },
+            superTypes: []
+        },
+        StateDefinition: {
+            name: StateDefinition.$type,
+            properties: {
+                additionalSpecializations: {
+                    name: StateDefinition.additionalSpecializations,
+                    defaultValue: [],
+                    optional: true
+                },
+                body: {
+                    name: StateDefinition.body,
+                    defaultValue: [],
+                    optional: true
+                },
+                isAbstract: {
+                    name: StateDefinition.isAbstract,
+                    defaultValue: false,
+                    optional: true
+                },
+                name: {
+                    name: StateDefinition.name
+                },
+                specialization: {
+                    name: StateDefinition.specialization,
+                    optional: true
+                }
+            },
+            superTypes: [DefinitionMember.$type]
+        },
+        StateUsage: {
+            name: StateUsage.$type,
+            properties: {
+                body: {
+                    name: StateUsage.body,
+                    defaultValue: [],
+                    optional: true
+                },
+                name: {
+                    name: StateUsage.name
+                },
+                type: {
+                    name: StateUsage.type
+                }
+            },
+            superTypes: [UsageMember.$type]
+        },
+        StringValue: {
+            name: StringValue.$type,
+            properties: {
+                value: {
+                    name: StringValue.value
+                }
+            },
+            superTypes: [AttributeValue.$type]
+        },
+        SuccessionStep: {
+            name: SuccessionStep.$type,
+            properties: {
+                ref: {
+                    name: SuccessionStep.ref
+                }
+            },
+            superTypes: []
+        },
+        SuccessionUsage: {
+            name: SuccessionUsage.$type,
+            properties: {
+                steps: {
+                    name: SuccessionUsage.steps,
+                    defaultValue: []
+                }
+            },
+            superTypes: [UsageBodyMember.$type]
+        },
+        UnaryExpr: {
+            name: UnaryExpr.$type,
+            properties: {
+                op: {
+                    name: UnaryExpr.op
+                },
+                operand: {
+                    name: UnaryExpr.operand
+                }
+            },
+            superTypes: [ConstraintExpr.$type]
+        },
+        UsageBodyMember: {
+            name: UsageBodyMember.$type,
+            properties: {},
+            superTypes: [ActionUsageBodyMember.$type, ViewBodyMember.$type]
+        },
+        UsageMember: {
+            name: UsageMember.$type,
+            properties: {},
+            superTypes: [PackageMember.$type]
+        },
+        UseCaseDeclaration: {
+            name: UseCaseDeclaration.$type,
+            properties: {
+                additionalSpecializations: {
+                    name: UseCaseDeclaration.additionalSpecializations,
+                    defaultValue: [],
+                    optional: true
+                },
+                body: {
+                    name: UseCaseDeclaration.body,
+                    defaultValue: [],
+                    optional: true
+                },
+                isAbstract: {
+                    name: UseCaseDeclaration.isAbstract,
+                    defaultValue: false,
+                    optional: true
+                },
+                isDefinition: {
+                    name: UseCaseDeclaration.isDefinition,
+                    defaultValue: false,
+                    optional: true
+                },
+                name: {
+                    name: UseCaseDeclaration.name
+                },
+                specialization: {
+                    name: UseCaseDeclaration.specialization,
+                    optional: true
+                },
+                type: {
+                    name: UseCaseDeclaration.type,
+                    optional: true
+                },
+                usageBody: {
+                    name: UseCaseDeclaration.usageBody,
+                    defaultValue: [],
+                    optional: true
+                }
+            },
+            superTypes: [PackageMember.$type]
+        },
+        VerificationDefinition: {
+            name: VerificationDefinition.$type,
+            properties: {
+                additionalSpecializations: {
+                    name: VerificationDefinition.additionalSpecializations,
+                    defaultValue: [],
+                    optional: true
+                },
+                body: {
+                    name: VerificationDefinition.body,
+                    defaultValue: [],
+                    optional: true
+                },
+                isAbstract: {
+                    name: VerificationDefinition.isAbstract,
+                    defaultValue: false,
+                    optional: true
+                },
+                name: {
+                    name: VerificationDefinition.name
+                },
+                specialization: {
+                    name: VerificationDefinition.specialization,
+                    optional: true
+                }
+            },
+            superTypes: [DefinitionMember.$type]
+        },
+        VerificationUsage: {
+            name: VerificationUsage.$type,
+            properties: {
+                body: {
+                    name: VerificationUsage.body,
+                    defaultValue: [],
+                    optional: true
+                },
+                name: {
+                    name: VerificationUsage.name
+                },
+                type: {
+                    name: VerificationUsage.type
+                }
+            },
+            superTypes: [UsageMember.$type]
+        },
+        ViewBodyMember: {
+            name: ViewBodyMember.$type,
+            properties: {},
+            superTypes: []
+        },
+        ViewDefinition: {
+            name: ViewDefinition.$type,
+            properties: {
+                additionalSpecializations: {
+                    name: ViewDefinition.additionalSpecializations,
+                    defaultValue: [],
+                    optional: true
+                },
+                body: {
+                    name: ViewDefinition.body,
+                    defaultValue: [],
+                    optional: true
+                },
+                isAbstract: {
+                    name: ViewDefinition.isAbstract,
+                    defaultValue: false,
+                    optional: true
+                },
+                name: {
+                    name: ViewDefinition.name
+                },
+                specialization: {
+                    name: ViewDefinition.specialization,
+                    optional: true
+                }
+            },
+            superTypes: [DefinitionMember.$type]
+        },
+        ViewUsage: {
+            name: ViewUsage.$type,
+            properties: {
+                body: {
+                    name: ViewUsage.body,
+                    defaultValue: [],
+                    optional: true
+                },
+                name: {
+                    name: ViewUsage.name
+                },
+                type: {
+                    name: ViewUsage.type,
+                    optional: true
+                }
+            },
+            superTypes: [DefinitionBodyMember.$type, UsageBodyMember.$type, UsageMember.$type]
+        },
+        ViewpointDefinition: {
+            name: ViewpointDefinition.$type,
+            properties: {
+                additionalSpecializations: {
+                    name: ViewpointDefinition.additionalSpecializations,
+                    defaultValue: [],
+                    optional: true
+                },
+                body: {
+                    name: ViewpointDefinition.body,
+                    defaultValue: [],
+                    optional: true
+                },
+                isAbstract: {
+                    name: ViewpointDefinition.isAbstract,
+                    defaultValue: false,
+                    optional: true
+                },
+                name: {
+                    name: ViewpointDefinition.name
+                },
+                specialization: {
+                    name: ViewpointDefinition.specialization,
+                    optional: true
+                }
+            },
+            superTypes: [DefinitionMember.$type]
         }
-    }
+    };
 }
 export const reflection = new MemoSysMLAstReflection();
 //# sourceMappingURL=ast.js.map