@memoarchitect/tools 0.13.0 → 0.15.0

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

@@ -1,2975 +0,0 @@
-/******************************************************************************
- * This file was generated by langium-cli 4.3.0.
- * DO NOT EDIT MANUALLY!
- ******************************************************************************/
-/* eslint-disable */
-import * as langium from 'langium';
-export const MemoSysMLTerminals = {
-    WS: /\s+/,
-    SL_COMMENT: /\/\/[^\n\r]*/,
-    ML_COMMENT: /\/\*[\s\S]*?\*\//,
-    DOC_COMMENT: /doc\s+\/\*[\s\S]*?\*\//,
-    SHORT_NAME: /<[a-zA-Z_][a-zA-Z0-9_]*>/,
-    ID: /[a-zA-Z_][a-zA-Z0-9_]*/,
-    UNRESTRICTED_NAME: /'(?:[^'\\]|\\.)*'/,
-    STRING: /"(?:[^"\\]|\\.)*"/,
-    REAL: /[0-9]+\.[0-9]+/,
-    INT: /[0-9]+/,
-};
-export const AbstractConnectionUsage = {
-    $type: 'AbstractConnectionUsage',
-    isAbstract: 'isAbstract',
-    multiplicity: 'multiplicity',
-    name: 'name',
-    type: 'type'
-};
-export function isAbstractConnectionUsage(item) {
-    return reflection.isInstance(item, AbstractConnectionUsage.$type);
-}
-export const AcceptActionUsage = {
-    $type: 'AcceptActionUsage',
-    name: 'name',
-    payloadName: 'payloadName',
-    payloadType: 'payloadType'
-};
-export function isAcceptActionUsage(item) {
-    return reflection.isInstance(item, AcceptActionUsage.$type);
-}
-export const ActionDefBodyMember = {
-    $type: 'ActionDefBodyMember'
-};
-export function isActionDefBodyMember(item) {
-    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.$type);
-}
-export function isActionName(item) {
-    return item === 'accept' || item === 'send' || item === 'terminate' || (typeof item === 'string' && (/[a-zA-Z_][a-zA-Z0-9_]*/.test(item)));
-}
-export const ActionParameterMember = {
-    $type: 'ActionParameterMember',
-    direction: 'direction',
-    name: 'name',
-    type: 'type'
-};
-export function isActionParameterMember(item) {
-    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.$type);
-}
-export const ActionUsageBodyMember = {
-    $type: 'ActionUsageBodyMember'
-};
-export function isActionUsageBodyMember(item) {
-    return reflection.isInstance(item, ActionUsageBodyMember.$type);
-}
-export const ActorMember = {
-    $type: 'ActorMember',
-    bindingOp: 'bindingOp',
-    body: 'body',
-    boundRef: 'boundRef',
-    multiplicity: 'multiplicity',
-    name: 'name',
-    type: 'type'
-};
-export function isActorMember(item) {
-    return reflection.isInstance(item, ActorMember.$type);
-}
-export const AliasDeclaration = {
-    $type: 'AliasDeclaration',
-    name: 'name',
-    target: 'target'
-};
-export function isAliasDeclaration(item) {
-    return reflection.isInstance(item, AliasDeclaration.$type);
-}
-export function isAliasName(item) {
-    return item === 'verification' || (typeof item === 'string' && (/[a-zA-Z_][a-zA-Z0-9_]*/.test(item) || /'(?:[^'\\]|\\.)*'/.test(item)));
-}
-export const AllocateUsage = {
-    $type: 'AllocateUsage',
-    body: 'body',
-    name: 'name',
-    source: 'source',
-    target: 'target',
-    type: 'type'
-};
-export function isAllocateUsage(item) {
-    return reflection.isInstance(item, AllocateUsage.$type);
-}
-export const AllocationDefinition = {
-    $type: 'AllocationDefinition',
-    additionalSpecializations: 'additionalSpecializations',
-    body: 'body',
-    isAbstract: 'isAbstract',
-    name: 'name',
-    specialization: 'specialization'
-};
-export function isAllocationDefinition(item) {
-    return reflection.isInstance(item, AllocationDefinition.$type);
-}
-export const ArcadiaMember = {
-    $type: 'ArcadiaMember'
-};
-export function isArcadiaMember(item) {
-    return reflection.isInstance(item, ArcadiaMember.$type);
-}
-export const AttributeDefinition = {
-    $type: 'AttributeDefinition',
-    additionalSpecializations: 'additionalSpecializations',
-    body: 'body',
-    isAbstract: 'isAbstract',
-    isVariation: 'isVariation',
-    name: 'name',
-    specialization: 'specialization'
-};
-export function isAttributeDefinition(item) {
-    return reflection.isInstance(item, AttributeDefinition.$type);
-}
-export const AttributeMember = {
-    $type: 'AttributeMember',
-    body: 'body',
-    isDefault: 'isDefault',
-    isVariation: 'isVariation',
-    multiplicity: 'multiplicity',
-    name: 'name',
-    redefines: 'redefines',
-    type: 'type',
-    value: 'value'
-};
-export function isAttributeMember(item) {
-    return reflection.isInstance(item, AttributeMember.$type);
-}
-export const AttributeValue = {
-    $type: 'AttributeValue'
-};
-export function isAttributeValue(item) {
-    return reflection.isInstance(item, AttributeValue.$type);
-}
-export const BinaryExpr = {
-    $type: 'BinaryExpr',
-    left: 'left',
-    op: 'op',
-    right: 'right'
-};
-export function isBinaryExpr(item) {
-    return reflection.isInstance(item, BinaryExpr.$type);
-}
-export const BindingUsage = {
-    $type: 'BindingUsage',
-    source: 'source',
-    target: 'target'
-};
-export function isBindingUsage(item) {
-    return reflection.isInstance(item, BindingUsage.$type);
-}
-export const BooleanValue = {
-    $type: 'BooleanValue',
-    value: 'value'
-};
-export function isBooleanValue(item) {
-    return reflection.isInstance(item, BooleanValue.$type);
-}
-export const CollectionOp = {
-    $type: 'CollectionOp',
-    argument: 'argument',
-    op: 'op',
-    target: 'target'
-};
-export function isCollectionOp(item) {
-    return reflection.isInstance(item, CollectionOp.$type);
-}
-export const ConcernDefinition = {
-    $type: 'ConcernDefinition',
-    additionalSpecializations: 'additionalSpecializations',
-    body: 'body',
-    isAbstract: 'isAbstract',
-    name: 'name',
-    specialization: 'specialization'
-};
-export function isConcernDefinition(item) {
-    return reflection.isInstance(item, ConcernDefinition.$type);
-}
-export const ConcernUsage = {
-    $type: 'ConcernUsage',
-    body: 'body',
-    name: 'name',
-    type: 'type'
-};
-export function isConcernUsage(item) {
-    return reflection.isInstance(item, ConcernUsage.$type);
-}
-export const ConnectionBodyMember = {
-    $type: 'ConnectionBodyMember'
-};
-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.$type);
-}
-export const ConnectionEnd = {
-    $type: 'ConnectionEnd',
-    endName: 'endName',
-    ref: 'ref'
-};
-export function isConnectionEnd(item) {
-    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.$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.$type);
-}
-export const ConstraintExpr = {
-    $type: 'ConstraintExpr'
-};
-export function isConstraintExpr(item) {
-    return reflection.isInstance(item, ConstraintExpr.$type);
-}
-export const ControlNodeUsage = {
-    $type: 'ControlNodeUsage',
-    controlKind: 'controlKind',
-    name: 'name'
-};
-export function isControlNodeUsage(item) {
-    return reflection.isInstance(item, ControlNodeUsage.$type);
-}
-export const DefinitionBodyMember = {
-    $type: 'DefinitionBodyMember'
-};
-export function isDefinitionBodyMember(item) {
-    return reflection.isInstance(item, DefinitionBodyMember.$type);
-}
-export const DefinitionMember = {
-    $type: 'DefinitionMember'
-};
-export function isDefinitionMember(item) {
-    return reflection.isInstance(item, DefinitionMember.$type);
-}
-export const Dependency = {
-    $type: 'Dependency',
-    body: 'body',
-    clients: 'clients',
-    name: 'name',
-    prefixMetadata: 'prefixMetadata',
-    suppliers: 'suppliers'
-};
-export function isDependency(item) {
-    return reflection.isInstance(item, Dependency.$type);
-}
-export const DocComment = {
-    $type: 'DocComment',
-    content: 'content'
-};
-export function isDocComment(item) {
-    return reflection.isInstance(item, DocComment.$type);
-}
-export function isDottedName(item) {
-    return typeof item === 'string';
-}
-export function isDottedNameSegment(item) {
-    return item === 'accept' || item === 'send' || item === 'terminate' || (typeof item === 'string' && (/[a-zA-Z_][a-zA-Z0-9_]*/.test(item)));
-}
-export const EndDeclaration = {
-    $type: 'EndDeclaration',
-    isConjugated: 'isConjugated',
-    multiplicity: 'multiplicity',
-    name: 'name',
-    redefinedEnd: 'redefinedEnd',
-    redefines: 'redefines',
-    type: 'type'
-};
-export function isEndDeclaration(item) {
-    return reflection.isInstance(item, EndDeclaration.$type);
-}
-export const EnumDefinition = {
-    $type: 'EnumDefinition',
-    docs: 'docs',
-    literals: 'literals',
-    name: 'name'
-};
-export function isEnumDefinition(item) {
-    return reflection.isInstance(item, EnumDefinition.$type);
-}
-export const EnumLiteral = {
-    $type: 'EnumLiteral',
-    name: 'name'
-};
-export function isEnumLiteral(item) {
-    return reflection.isInstance(item, EnumLiteral.$type);
-}
-export function isEnumLiteralName(item) {
-    return item === 'in' || item === 'out' || item === 'inout' || item === 'part' || item === 'requirement' || item === 'action' || item === 'item' || item === 'port' || item === 'interface' || item === 'connection' || item === 'attribute' || item === 'constraint' || item === 'enum' || item === 'view' || item === 'viewpoint' || item === 'ref' || item === 'import' || item === 'package' || item === 'flow' || item === 'first' || item === 'allocate' || item === 'library' || item === 'private' || item === 'public' || item === 'state' || item === 'verification' || item === 'satisfy' || item === 'verify' || item === 'use' || item === 'fork' || item === 'join' || (typeof item === 'string' && (/[a-zA-Z_][a-zA-Z0-9_]*/.test(item) || /'(?:[^'\\]|\\.)*'/.test(item)));
-}
-export const EnumValue = {
-    $type: 'EnumValue',
-    enumRef: 'enumRef',
-    metaclass: 'metaclass',
-    tail: 'tail'
-};
-export function isEnumValue(item) {
-    return reflection.isInstance(item, EnumValue.$type);
-}
-export const ExhibitStateUsage = {
-    $type: 'ExhibitStateUsage',
-    body: 'body',
-    exhibited: 'exhibited',
-    isState: 'isState',
-    name: 'name',
-    type: 'type'
-};
-export function isExhibitStateUsage(item) {
-    return reflection.isInstance(item, ExhibitStateUsage.$type);
-}
-export const ExposeMember = {
-    $type: 'ExposeMember',
-    path: 'path'
-};
-export function isExposeMember(item) {
-    return reflection.isInstance(item, ExposeMember.$type);
-}
-export function isExposePath(item) {
-    return typeof item === 'string';
-}
-export const FeatureChain = {
-    $type: 'FeatureChain',
-    segments: 'segments'
-};
-export function isFeatureChain(item) {
-    return reflection.isInstance(item, FeatureChain.$type);
-}
-export const FeatureMembershipMember = {
-    $type: 'FeatureMembershipMember',
-    feature: 'feature',
-    isRedefinition: 'isRedefinition',
-    multiplicity: 'multiplicity',
-    type: 'type',
-    value: 'value'
-};
-export function isFeatureMembershipMember(item) {
-    return reflection.isInstance(item, FeatureMembershipMember.$type);
-}
-export function isFeatureName(item) {
-    return item === 'part' || item === 'requirement' || item === 'action' || item === 'item' || item === 'port' || item === 'interface' || item === 'connection' || item === 'flow' || item === 'view' || item === 'viewpoint' || item === 'attribute' || item === 'constraint' || item === 'ref' || item === 'allocate' || item === 'end' || item === 'enum' || item === 'function' || item === 'operator' || item === 'state' || item === 'verification' || item === 'standard' || (typeof item === 'string' && (/[a-zA-Z_][a-zA-Z0-9_]*/.test(item)));
-}
-export const FeatureReference = {
-    $type: 'FeatureReference',
-    segments: 'segments'
-};
-export function isFeatureReference(item) {
-    return reflection.isInstance(item, FeatureReference.$type);
-}
-export const FlowConnectionUsage = {
-    $type: 'FlowConnectionUsage',
-    body: 'body',
-    itemType: 'itemType',
-    name: 'name',
-    source: 'source',
-    target: 'target'
-};
-export function isFlowConnectionUsage(item) {
-    return reflection.isInstance(item, FlowConnectionUsage.$type);
-}
-export const FlowEnd = {
-    $type: 'FlowEnd',
-    ref: 'ref'
-};
-export function isFlowEnd(item) {
-    return reflection.isInstance(item, FlowEnd.$type);
-}
-export const FramedConcernMember = {
-    $type: 'FramedConcernMember',
-    body: 'body',
-    framed: 'framed',
-    isConcern: 'isConcern',
-    name: 'name',
-    type: 'type'
-};
-export function isFramedConcernMember(item) {
-    return reflection.isInstance(item, FramedConcernMember.$type);
-}
-export const ImportDeclaration = {
-    $type: 'ImportDeclaration',
-    path: 'path',
-    visibility: 'visibility'
-};
-export function isImportDeclaration(item) {
-    return reflection.isInstance(item, ImportDeclaration.$type);
-}
-export function isImportPath(item) {
-    return typeof item === 'string';
-}
-export const IncludeUseCaseUsage = {
-    $type: 'IncludeUseCaseUsage',
-    body: 'body',
-    included: 'included',
-    isUseCase: 'isUseCase',
-    name: 'name',
-    type: 'type'
-};
-export function isIncludeUseCaseUsage(item) {
-    return reflection.isInstance(item, IncludeUseCaseUsage.$type);
-}
-export const InterfaceDefinition = {
-    $type: 'InterfaceDefinition',
-    additionalSpecializations: 'additionalSpecializations',
-    body: 'body',
-    isAbstract: 'isAbstract',
-    name: 'name',
-    specialization: 'specialization'
-};
-export function isInterfaceDefinition(item) {
-    return reflection.isInstance(item, InterfaceDefinition.$type);
-}
-export const InterfaceUsage = {
-    $type: 'InterfaceUsage',
-    body: 'body',
-    name: 'name',
-    source: 'source',
-    target: 'target',
-    type: 'type'
-};
-export function isInterfaceUsage(item) {
-    return reflection.isInstance(item, InterfaceUsage.$type);
-}
-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',
-    isVariation: 'isVariation',
-    name: 'name',
-    specialization: 'specialization'
-};
-export function isItemDefinition(item) {
-    return reflection.isInstance(item, ItemDefinition.$type);
-}
-export const ItemUsage = {
-    $type: 'ItemUsage',
-    body: 'body',
-    boundRef: 'boundRef',
-    direction: 'direction',
-    multiplicity: 'multiplicity',
-    name: 'name',
-    preMultiplicity: 'preMultiplicity',
-    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.$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' || item === 'standard' || (typeof item === 'string' && (/[a-zA-Z_][a-zA-Z0-9_]*/.test(item)));
-}
-export const MessageUsage = {
-    $type: 'MessageUsage',
-    body: 'body',
-    itemType: 'itemType',
-    name: 'name',
-    source: 'source',
-    target: 'target'
-};
-export function isMessageUsage(item) {
-    return reflection.isInstance(item, MessageUsage.$type);
-}
-export const MetadataApplication = {
-    $type: 'MetadataApplication',
-    body: 'body',
-    type: 'type'
-};
-export function isMetadataApplication(item) {
-    return reflection.isInstance(item, MetadataApplication.$type);
-}
-export const MetadataBodyMember = {
-    $type: 'MetadataBodyMember'
-};
-export function isMetadataBodyMember(item) {
-    return reflection.isInstance(item, MetadataBodyMember.$type);
-}
-export const MetadataDefinition = {
-    $type: 'MetadataDefinition',
-    body: 'body',
-    name: 'name',
-    shortName: 'shortName',
-    specialization: 'specialization'
-};
-export function isMetadataDefinition(item) {
-    return reflection.isInstance(item, MetadataDefinition.$type);
-}
-export const MetadataFeatureMember = {
-    $type: 'MetadataFeatureMember',
-    name: 'name',
-    redefines: 'redefines',
-    value: 'value'
-};
-export function isMetadataFeatureMember(item) {
-    return reflection.isInstance(item, MetadataFeatureMember.$type);
-}
-export const Model = {
-    $type: 'Model',
-    members: 'members'
-};
-export function isModel(item) {
-    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.$type);
-}
-export const NamespaceMember = {
-    $type: 'NamespaceMember'
-};
-export function isNamespaceMember(item) {
-    return reflection.isInstance(item, NamespaceMember.$type);
-}
-export const ObjectiveMember = {
-    $type: 'ObjectiveMember',
-    body: 'body',
-    name: 'name',
-    type: 'type'
-};
-export function isObjectiveMember(item) {
-    return reflection.isInstance(item, ObjectiveMember.$type);
-}
-export const PackageDeclaration = {
-    $type: 'PackageDeclaration',
-    isLibrary: 'isLibrary',
-    isStandard: 'isStandard',
-    members: 'members',
-    name: 'name'
-};
-export function isPackageDeclaration(item) {
-    return reflection.isInstance(item, PackageDeclaration.$type);
-}
-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',
-    isVariation: 'isVariation',
-    name: 'name',
-    specialization: 'specialization'
-};
-export function isPartDefinition(item) {
-    return reflection.isInstance(item, PartDefinition.$type);
-}
-export const PartMember = {
-    $type: 'PartMember',
-    bindingOp: 'bindingOp',
-    body: 'body',
-    boundRef: 'boundRef',
-    isVariation: 'isVariation',
-    multiplicity: 'multiplicity',
-    name: 'name',
-    subsetValue: 'subsetValue',
-    type: 'type'
-};
-export function isPartMember(item) {
-    return reflection.isInstance(item, PartMember.$type);
-}
-export const PartUsage = {
-    $type: 'PartUsage',
-    body: 'body',
-    isVariation: 'isVariation',
-    multiplicity: 'multiplicity',
-    name: 'name',
-    type: 'type'
-};
-export function isPartUsage(item) {
-    return reflection.isInstance(item, PartUsage.$type);
-}
-export const PerformActionUsage = {
-    $type: 'PerformActionUsage',
-    body: 'body',
-    isAction: 'isAction',
-    name: 'name',
-    performed: 'performed',
-    type: 'type'
-};
-export function isPerformActionUsage(item) {
-    return reflection.isInstance(item, PerformActionUsage.$type);
-}
-export const PortDefinition = {
-    $type: 'PortDefinition',
-    additionalSpecializations: 'additionalSpecializations',
-    body: 'body',
-    isAbstract: 'isAbstract',
-    name: 'name',
-    specialization: 'specialization'
-};
-export function isPortDefinition(item) {
-    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.$type);
-}
-export const PrefixMetadataAnnotation = {
-    $type: 'PrefixMetadataAnnotation',
-    type: 'type'
-};
-export function isPrefixMetadataAnnotation(item) {
-    return reflection.isInstance(item, PrefixMetadataAnnotation.$type);
-}
-export function isQualifiedName(item) {
-    return typeof item === 'string';
-}
-export function isQualifiedNameSegment(item) {
-    return item === 'library' || item === 'standard' || (typeof item === 'string' && (/[a-zA-Z_][a-zA-Z0-9_]*/.test(item)));
-}
-export function isQualifiedNameTailSegment(item) {
-    return isQualifiedNameSegment(item) || item === 'in' || item === 'out' || item === 'inout' || item === 'part' || item === 'requirement' || item === 'action' || item === 'item' || item === 'port' || item === 'interface' || item === 'connection' || item === 'attribute' || item === 'constraint' || item === 'enum' || item === 'view' || item === 'viewpoint' || item === 'ref' || item === 'import' || item === 'package' || item === 'flow' || item === 'first' || item === 'allocate' || item === 'private' || item === 'public' || item === 'state' || item === 'verification' || item === 'use' || item === 'fork' || item === 'join' || (typeof item === 'string' && (/'(?:[^'\\]|\\.)*'/.test(item)));
-}
-export const RealValue = {
-    $type: 'RealValue',
-    value: 'value'
-};
-export function isRealValue(item) {
-    return reflection.isInstance(item, RealValue.$type);
-}
-export function isReferenceName(item) {
-    return typeof item === 'string';
-}
-export const RefMember = {
-    $type: 'RefMember',
-    bindingOp: 'bindingOp',
-    boundRef: 'boundRef',
-    isConjugated: 'isConjugated',
-    isItem: 'isItem',
-    multiplicity: 'multiplicity',
-    name: 'name',
-    redefines: 'redefines',
-    subsetValue: 'subsetValue',
-    type: 'type',
-    value: 'value'
-};
-export function isRefMember(item) {
-    return reflection.isInstance(item, RefMember.$type);
-}
-export const RequireConstraintMember = {
-    $type: 'RequireConstraintMember',
-    expression: 'expression',
-    kind: 'kind'
-};
-export function isRequireConstraintMember(item) {
-    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.$type);
-}
-export const RequirementUsage = {
-    $type: 'RequirementUsage',
-    body: 'body',
-    name: 'name',
-    type: 'type'
-};
-export function isRequirementUsage(item) {
-    return reflection.isInstance(item, RequirementUsage.$type);
-}
-export const RequirementVerificationMember = {
-    $type: 'RequirementVerificationMember',
-    body: 'body',
-    requirement: 'requirement'
-};
-export function isRequirementVerificationMember(item) {
-    return reflection.isInstance(item, RequirementVerificationMember.$type);
-}
-export const SatisfyRequirementUsage = {
-    $type: 'SatisfyRequirementUsage',
-    body: 'body',
-    isAsserted: 'isAsserted',
-    isNegated: 'isNegated',
-    requirement: 'requirement',
-    satisfyingFeature: 'satisfyingFeature'
-};
-export function isSatisfyRequirementUsage(item) {
-    return reflection.isInstance(item, SatisfyRequirementUsage.$type);
-}
-export const SendActionUsage = {
-    $type: 'SendActionUsage',
-    followsPrevious: 'followsPrevious',
-    name: 'name',
-    receiver: 'receiver',
-    target: 'target'
-};
-export function isSendActionUsage(item) {
-    return reflection.isInstance(item, SendActionUsage.$type);
-}
-export const SetElement = {
-    $type: 'SetElement',
-    stringValue: 'stringValue',
-    value: 'value'
-};
-export function isSetElement(item) {
-    return reflection.isInstance(item, SetElement.$type);
-}
-export const SetLiteral = {
-    $type: 'SetLiteral',
-    elements: 'elements'
-};
-export function isSetLiteral(item) {
-    return reflection.isInstance(item, SetLiteral.$type);
-}
-export const Specialization = {
-    $type: 'Specialization',
-    superType: 'superType'
-};
-export function isSpecialization(item) {
-    return reflection.isInstance(item, Specialization.$type);
-}
-export const StakeholderMember = {
-    $type: 'StakeholderMember',
-    bindingOp: 'bindingOp',
-    body: 'body',
-    boundRef: 'boundRef',
-    multiplicity: 'multiplicity',
-    name: 'name',
-    type: 'type'
-};
-export function isStakeholderMember(item) {
-    return reflection.isInstance(item, StakeholderMember.$type);
-}
-export const StateDefinition = {
-    $type: 'StateDefinition',
-    additionalSpecializations: 'additionalSpecializations',
-    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 = {
-    $type: 'StringValue',
-    value: 'value'
-};
-export function isStringValue(item) {
-    return reflection.isInstance(item, StringValue.$type);
-}
-export const SubjectMember = {
-    $type: 'SubjectMember',
-    bindingOp: 'bindingOp',
-    body: 'body',
-    boundRefs: 'boundRefs',
-    multiplicity: 'multiplicity',
-    name: 'name',
-    redefines: 'redefines',
-    type: 'type'
-};
-export function isSubjectMember(item) {
-    return reflection.isInstance(item, SubjectMember.$type);
-}
-export function isSuccessionRef(item) {
-    return item === 'start' || item === 'done' || (typeof item === 'string' && (/[a-zA-Z_][a-zA-Z0-9_]*/.test(item)));
-}
-export const SuccessionStep = {
-    $type: 'SuccessionStep',
-    guard: 'guard',
-    ref: 'ref'
-};
-export function isSuccessionStep(item) {
-    return reflection.isInstance(item, SuccessionStep.$type);
-}
-export const SuccessionUsage = {
-    $type: 'SuccessionUsage',
-    steps: 'steps'
-};
-export function isSuccessionUsage(item) {
-    return reflection.isInstance(item, SuccessionUsage.$type);
-}
-export const TerminateUsage = {
-    $type: 'TerminateUsage',
-    followsPrevious: 'followsPrevious',
-    name: 'name'
-};
-export function isTerminateUsage(item) {
-    return reflection.isInstance(item, TerminateUsage.$type);
-}
-export const TransitionUsage = {
-    $type: 'TransitionUsage',
-    body: 'body',
-    effect: 'effect',
-    guard: 'guard',
-    name: 'name',
-    source: 'source',
-    target: 'target',
-    trigger: 'trigger',
-    type: 'type'
-};
-export function isTransitionUsage(item) {
-    return reflection.isInstance(item, TransitionUsage.$type);
-}
-export const UnaryExpr = {
-    $type: 'UnaryExpr',
-    op: 'op',
-    operand: 'operand'
-};
-export function isUnaryExpr(item) {
-    return reflection.isInstance(item, UnaryExpr.$type);
-}
-export const UsageBodyMember = {
-    $type: 'UsageBodyMember'
-};
-export function isUsageBodyMember(item) {
-    return reflection.isInstance(item, UsageBodyMember.$type);
-}
-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 VariantMember = {
-    $type: 'VariantMember',
-    body: 'body',
-    multiplicity: 'multiplicity',
-    name: 'name',
-    type: 'type',
-    usageKind: 'usageKind',
-    value: 'value'
-};
-export function isVariantMember(item) {
-    return reflection.isInstance(item, VariantMember.$type);
-}
-export const VerificationDefinition = {
-    $type: 'VerificationDefinition',
-    additionalSpecializations: 'additionalSpecializations',
-    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.$type);
-}
-export const ViewpointUsage = {
-    $type: 'ViewpointUsage',
-    body: 'body',
-    name: 'name',
-    type: 'type'
-};
-export function isViewpointUsage(item) {
-    return reflection.isInstance(item, ViewpointUsage.$type);
-}
-export const ViewUsage = {
-    $type: 'ViewUsage',
-    body: 'body',
-    name: 'name',
-    type: 'type'
-};
-export function isViewUsage(item) {
-    return reflection.isInstance(item, ViewUsage.$type);
-}
-export class MemoSysMLAstReflection extends langium.AbstractAstReflection {
-    types = {
-        AbstractConnectionUsage: {
-            name: AbstractConnectionUsage.$type,
-            properties: {
-                isAbstract: {
-                    name: AbstractConnectionUsage.isAbstract,
-                    defaultValue: false
-                },
-                multiplicity: {
-                    name: AbstractConnectionUsage.multiplicity,
-                    optional: true
-                },
-                name: {
-                    name: AbstractConnectionUsage.name
-                },
-                type: {
-                    name: AbstractConnectionUsage.type
-                }
-            },
-            superTypes: [PackageMember.$type]
-        },
-        AcceptActionUsage: {
-            name: AcceptActionUsage.$type,
-            properties: {
-                name: {
-                    name: AcceptActionUsage.name
-                },
-                payloadName: {
-                    name: AcceptActionUsage.payloadName
-                },
-                payloadType: {
-                    name: AcceptActionUsage.payloadType
-                }
-            },
-            superTypes: [ActionDefBodyMember.$type, ActionUsageBodyMember.$type]
-        },
-        ActionDefBodyMember: {
-            name: ActionDefBodyMember.$type,
-            properties: {},
-            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, ActionUsageBodyMember.$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: [ActionDefBodyMember.$type, ActionUsageBodyMember.$type, UsageMember.$type]
-        },
-        ActionUsageBodyMember: {
-            name: ActionUsageBodyMember.$type,
-            properties: {},
-            superTypes: []
-        },
-        ActorMember: {
-            name: ActorMember.$type,
-            properties: {
-                bindingOp: {
-                    name: ActorMember.bindingOp,
-                    optional: true
-                },
-                body: {
-                    name: ActorMember.body,
-                    defaultValue: [],
-                    optional: true
-                },
-                boundRef: {
-                    name: ActorMember.boundRef,
-                    optional: true
-                },
-                multiplicity: {
-                    name: ActorMember.multiplicity,
-                    optional: true
-                },
-                name: {
-                    name: ActorMember.name
-                },
-                type: {
-                    name: ActorMember.type,
-                    optional: true
-                }
-            },
-            superTypes: [ArcadiaMember.$type]
-        },
-        AliasDeclaration: {
-            name: AliasDeclaration.$type,
-            properties: {
-                name: {
-                    name: AliasDeclaration.name
-                },
-                target: {
-                    name: AliasDeclaration.target
-                }
-            },
-            superTypes: [NamespaceMember.$type, PackageMember.$type]
-        },
-        AllocateUsage: {
-            name: AllocateUsage.$type,
-            properties: {
-                body: {
-                    name: AllocateUsage.body,
-                    defaultValue: [],
-                    optional: true
-                },
-                name: {
-                    name: AllocateUsage.name,
-                    optional: true
-                },
-                source: {
-                    name: AllocateUsage.source
-                },
-                target: {
-                    name: AllocateUsage.target
-                },
-                type: {
-                    name: AllocateUsage.type,
-                    optional: true
-                }
-            },
-            superTypes: [ArcadiaMember.$type]
-        },
-        AllocationDefinition: {
-            name: AllocationDefinition.$type,
-            properties: {
-                additionalSpecializations: {
-                    name: AllocationDefinition.additionalSpecializations,
-                    defaultValue: [],
-                    optional: true
-                },
-                body: {
-                    name: AllocationDefinition.body,
-                    defaultValue: [],
-                    optional: true
-                },
-                isAbstract: {
-                    name: AllocationDefinition.isAbstract,
-                    defaultValue: false,
-                    optional: true
-                },
-                name: {
-                    name: AllocationDefinition.name
-                },
-                specialization: {
-                    name: AllocationDefinition.specialization,
-                    optional: true
-                }
-            },
-            superTypes: [DefinitionMember.$type]
-        },
-        ArcadiaMember: {
-            name: ArcadiaMember.$type,
-            properties: {},
-            superTypes: [DefinitionBodyMember.$type, PackageMember.$type, UsageBodyMember.$type]
-        },
-        AttributeDefinition: {
-            name: AttributeDefinition.$type,
-            properties: {
-                additionalSpecializations: {
-                    name: AttributeDefinition.additionalSpecializations,
-                    defaultValue: [],
-                    optional: true
-                },
-                body: {
-                    name: AttributeDefinition.body,
-                    defaultValue: [],
-                    optional: true
-                },
-                isAbstract: {
-                    name: AttributeDefinition.isAbstract,
-                    defaultValue: false,
-                    optional: true
-                },
-                isVariation: {
-                    name: AttributeDefinition.isVariation,
-                    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
-                },
-                isDefault: {
-                    name: AttributeMember.isDefault,
-                    defaultValue: false,
-                    optional: true
-                },
-                isVariation: {
-                    name: AttributeMember.isVariation,
-                    defaultValue: false,
-                    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]
-        },
-        BindingUsage: {
-            name: BindingUsage.$type,
-            properties: {
-                source: {
-                    name: BindingUsage.source
-                },
-                target: {
-                    name: BindingUsage.target
-                }
-            },
-            superTypes: [PackageMember.$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]
-        },
-        ConcernDefinition: {
-            name: ConcernDefinition.$type,
-            properties: {
-                additionalSpecializations: {
-                    name: ConcernDefinition.additionalSpecializations,
-                    defaultValue: [],
-                    optional: true
-                },
-                body: {
-                    name: ConcernDefinition.body,
-                    defaultValue: [],
-                    optional: true
-                },
-                isAbstract: {
-                    name: ConcernDefinition.isAbstract,
-                    defaultValue: false,
-                    optional: true
-                },
-                name: {
-                    name: ConcernDefinition.name
-                },
-                specialization: {
-                    name: ConcernDefinition.specialization,
-                    optional: true
-                }
-            },
-            superTypes: [DefinitionMember.$type]
-        },
-        ConcernUsage: {
-            name: ConcernUsage.$type,
-            properties: {
-                body: {
-                    name: ConcernUsage.body,
-                    defaultValue: [],
-                    optional: true
-                },
-                name: {
-                    name: ConcernUsage.name
-                },
-                type: {
-                    name: ConcernUsage.type,
-                    optional: true
-                }
-            },
-            superTypes: [ArcadiaMember.$type]
-        },
-        ConnectionBodyMember: {
-            name: ConnectionBodyMember.$type,
-            properties: {},
-            superTypes: []
-        },
-        ConnectionDefinition: {
-            name: ConnectionDefinition.$type,
-            properties: {
-                additionalSpecializations: {
-                    name: ConnectionDefinition.additionalSpecializations,
-                    defaultValue: [],
-                    optional: true
-                },
-                body: {
-                    name: ConnectionDefinition.body,
-                    defaultValue: [],
-                    optional: true
-                },
-                isAbstract: {
-                    name: ConnectionDefinition.isAbstract,
-                    defaultValue: false,
-                    optional: true
-                },
-                name: {
-                    name: ConnectionDefinition.name
-                },
-                specialization: {
-                    name: ConnectionDefinition.specialization,
-                    optional: true
-                }
-            },
-            superTypes: [DefinitionMember.$type]
-        },
-        ConnectionEnd: {
-            name: ConnectionEnd.$type,
-            properties: {
-                endName: {
-                    name: ConnectionEnd.endName,
-                    optional: true
-                },
-                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: [ActionDefBodyMember.$type, ActionUsageBodyMember.$type]
-        },
-        DefinitionBodyMember: {
-            name: DefinitionBodyMember.$type,
-            properties: {},
-            superTypes: [ConnectionBodyMember.$type]
-        },
-        DefinitionMember: {
-            name: DefinitionMember.$type,
-            properties: {},
-            superTypes: [NamespaceMember.$type, PackageMember.$type]
-        },
-        Dependency: {
-            name: Dependency.$type,
-            properties: {
-                body: {
-                    name: Dependency.body,
-                    defaultValue: [],
-                    optional: true
-                },
-                clients: {
-                    name: Dependency.clients,
-                    defaultValue: []
-                },
-                name: {
-                    name: Dependency.name,
-                    optional: true
-                },
-                prefixMetadata: {
-                    name: Dependency.prefixMetadata,
-                    defaultValue: [],
-                    optional: true
-                },
-                suppliers: {
-                    name: Dependency.suppliers,
-                    defaultValue: []
-                }
-            },
-            superTypes: [NamespaceMember.$type, PackageMember.$type, UsageBodyMember.$type]
-        },
-        DocComment: {
-            name: DocComment.$type,
-            properties: {
-                content: {
-                    name: DocComment.content
-                }
-            },
-            superTypes: [DefinitionBodyMember.$type, NamespaceMember.$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
-                },
-                redefinedEnd: {
-                    name: EndDeclaration.redefinedEnd,
-                    optional: true
-                },
-                redefines: {
-                    name: EndDeclaration.redefines,
-                    defaultValue: false,
-                    optional: true
-                },
-                type: {
-                    name: EndDeclaration.type,
-                    optional: true
-                }
-            },
-            superTypes: [ConnectionBodyMember.$type]
-        },
-        EnumDefinition: {
-            name: EnumDefinition.$type,
-            properties: {
-                docs: {
-                    name: EnumDefinition.docs,
-                    defaultValue: [],
-                    optional: true
-                },
-                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
-                },
-                metaclass: {
-                    name: EnumValue.metaclass,
-                    optional: true
-                },
-                tail: {
-                    name: EnumValue.tail,
-                    defaultValue: [],
-                    optional: true
-                }
-            },
-            superTypes: [AttributeValue.$type]
-        },
-        ExhibitStateUsage: {
-            name: ExhibitStateUsage.$type,
-            properties: {
-                body: {
-                    name: ExhibitStateUsage.body,
-                    defaultValue: [],
-                    optional: true
-                },
-                exhibited: {
-                    name: ExhibitStateUsage.exhibited,
-                    optional: true
-                },
-                isState: {
-                    name: ExhibitStateUsage.isState,
-                    defaultValue: false,
-                    optional: true
-                },
-                name: {
-                    name: ExhibitStateUsage.name,
-                    optional: true
-                },
-                type: {
-                    name: ExhibitStateUsage.type,
-                    optional: true
-                }
-            },
-            superTypes: [ArcadiaMember.$type]
-        },
-        ExposeMember: {
-            name: ExposeMember.$type,
-            properties: {
-                path: {
-                    name: ExposeMember.path
-                }
-            },
-            superTypes: [ViewBodyMember.$type]
-        },
-        FeatureChain: {
-            name: FeatureChain.$type,
-            properties: {
-                segments: {
-                    name: FeatureChain.segments,
-                    defaultValue: []
-                }
-            },
-            superTypes: [ConstraintExpr.$type]
-        },
-        FeatureMembershipMember: {
-            name: FeatureMembershipMember.$type,
-            properties: {
-                feature: {
-                    name: FeatureMembershipMember.feature
-                },
-                isRedefinition: {
-                    name: FeatureMembershipMember.isRedefinition,
-                    defaultValue: false,
-                    optional: true
-                },
-                multiplicity: {
-                    name: FeatureMembershipMember.multiplicity,
-                    optional: true
-                },
-                type: {
-                    name: FeatureMembershipMember.type,
-                    optional: true
-                },
-                value: {
-                    name: FeatureMembershipMember.value,
-                    optional: true
-                }
-            },
-            superTypes: [DefinitionBodyMember.$type]
-        },
-        FeatureReference: {
-            name: FeatureReference.$type,
-            properties: {
-                segments: {
-                    name: FeatureReference.segments,
-                    defaultValue: []
-                }
-            },
-            superTypes: []
-        },
-        FlowConnectionUsage: {
-            name: FlowConnectionUsage.$type,
-            properties: {
-                body: {
-                    name: FlowConnectionUsage.body,
-                    defaultValue: [],
-                    optional: true
-                },
-                itemType: {
-                    name: FlowConnectionUsage.itemType,
-                    optional: true
-                },
-                name: {
-                    name: FlowConnectionUsage.name,
-                    optional: true
-                },
-                source: {
-                    name: FlowConnectionUsage.source
-                },
-                target: {
-                    name: FlowConnectionUsage.target
-                }
-            },
-            superTypes: [ConnectionBodyMember.$type, PackageMember.$type, UsageBodyMember.$type]
-        },
-        FlowEnd: {
-            name: FlowEnd.$type,
-            properties: {
-                ref: {
-                    name: FlowEnd.ref
-                }
-            },
-            superTypes: []
-        },
-        FramedConcernMember: {
-            name: FramedConcernMember.$type,
-            properties: {
-                body: {
-                    name: FramedConcernMember.body,
-                    defaultValue: [],
-                    optional: true
-                },
-                framed: {
-                    name: FramedConcernMember.framed,
-                    optional: true
-                },
-                isConcern: {
-                    name: FramedConcernMember.isConcern,
-                    defaultValue: false,
-                    optional: true
-                },
-                name: {
-                    name: FramedConcernMember.name,
-                    optional: true
-                },
-                type: {
-                    name: FramedConcernMember.type,
-                    optional: true
-                }
-            },
-            superTypes: [ArcadiaMember.$type]
-        },
-        ImportDeclaration: {
-            name: ImportDeclaration.$type,
-            properties: {
-                path: {
-                    name: ImportDeclaration.path
-                },
-                visibility: {
-                    name: ImportDeclaration.visibility,
-                    optional: true
-                }
-            },
-            superTypes: [NamespaceMember.$type, PackageMember.$type]
-        },
-        IncludeUseCaseUsage: {
-            name: IncludeUseCaseUsage.$type,
-            properties: {
-                body: {
-                    name: IncludeUseCaseUsage.body,
-                    defaultValue: [],
-                    optional: true
-                },
-                included: {
-                    name: IncludeUseCaseUsage.included,
-                    optional: true
-                },
-                isUseCase: {
-                    name: IncludeUseCaseUsage.isUseCase,
-                    defaultValue: false,
-                    optional: true
-                },
-                name: {
-                    name: IncludeUseCaseUsage.name,
-                    optional: true
-                },
-                type: {
-                    name: IncludeUseCaseUsage.type,
-                    optional: true
-                }
-            },
-            superTypes: [ArcadiaMember.$type]
-        },
-        IntValue: {
-            name: IntValue.$type,
-            properties: {
-                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
-                },
-                source: {
-                    name: InterfaceUsage.source,
-                    optional: true
-                },
-                target: {
-                    name: InterfaceUsage.target,
-                    optional: true
-                },
-                type: {
-                    name: InterfaceUsage.type,
-                    optional: true
-                }
-            },
-            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
-                },
-                isVariation: {
-                    name: ItemDefinition.isVariation,
-                    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
-                },
-                preMultiplicity: {
-                    name: ItemUsage.preMultiplicity,
-                    optional: true
-                },
-                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]
-        },
-        MessageUsage: {
-            name: MessageUsage.$type,
-            properties: {
-                body: {
-                    name: MessageUsage.body,
-                    defaultValue: [],
-                    optional: true
-                },
-                itemType: {
-                    name: MessageUsage.itemType
-                },
-                name: {
-                    name: MessageUsage.name,
-                    optional: true
-                },
-                source: {
-                    name: MessageUsage.source
-                },
-                target: {
-                    name: MessageUsage.target
-                }
-            },
-            superTypes: [UsageBodyMember.$type, UsageMember.$type]
-        },
-        MetadataApplication: {
-            name: MetadataApplication.$type,
-            properties: {
-                body: {
-                    name: MetadataApplication.body,
-                    defaultValue: [],
-                    optional: true
-                },
-                type: {
-                    name: MetadataApplication.type
-                }
-            },
-            superTypes: [DefinitionBodyMember.$type, PackageMember.$type, UsageBodyMember.$type]
-        },
-        MetadataBodyMember: {
-            name: MetadataBodyMember.$type,
-            properties: {},
-            superTypes: []
-        },
-        MetadataDefinition: {
-            name: MetadataDefinition.$type,
-            properties: {
-                body: {
-                    name: MetadataDefinition.body,
-                    defaultValue: [],
-                    optional: true
-                },
-                name: {
-                    name: MetadataDefinition.name
-                },
-                shortName: {
-                    name: MetadataDefinition.shortName,
-                    optional: true
-                },
-                specialization: {
-                    name: MetadataDefinition.specialization,
-                    optional: true
-                }
-            },
-            superTypes: [DefinitionMember.$type]
-        },
-        MetadataFeatureMember: {
-            name: MetadataFeatureMember.$type,
-            properties: {
-                name: {
-                    name: MetadataFeatureMember.name
-                },
-                redefines: {
-                    name: MetadataFeatureMember.redefines,
-                    defaultValue: false
-                },
-                value: {
-                    name: MetadataFeatureMember.value
-                }
-            },
-            superTypes: [MetadataBodyMember.$type]
-        },
-        Model: {
-            name: Model.$type,
-            properties: {
-                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: []
-        },
-        ObjectiveMember: {
-            name: ObjectiveMember.$type,
-            properties: {
-                body: {
-                    name: ObjectiveMember.body,
-                    defaultValue: [],
-                    optional: true
-                },
-                name: {
-                    name: ObjectiveMember.name,
-                    optional: true
-                },
-                type: {
-                    name: ObjectiveMember.type,
-                    optional: true
-                }
-            },
-            superTypes: [ArcadiaMember.$type]
-        },
-        PackageDeclaration: {
-            name: PackageDeclaration.$type,
-            properties: {
-                isLibrary: {
-                    name: PackageDeclaration.isLibrary,
-                    defaultValue: false,
-                    optional: true
-                },
-                isStandard: {
-                    name: PackageDeclaration.isStandard,
-                    defaultValue: false,
-                    optional: true
-                },
-                members: {
-                    name: PackageDeclaration.members,
-                    defaultValue: [],
-                    optional: true
-                },
-                name: {
-                    name: PackageDeclaration.name
-                }
-            },
-            superTypes: [NamespaceMember.$type, PackageMember.$type, UsageBodyMember.$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
-                },
-                isVariation: {
-                    name: PartDefinition.isVariation,
-                    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
-                },
-                isVariation: {
-                    name: PartMember.isVariation,
-                    defaultValue: false,
-                    optional: true
-                },
-                multiplicity: {
-                    name: PartMember.multiplicity,
-                    optional: true
-                },
-                name: {
-                    name: PartMember.name
-                },
-                subsetValue: {
-                    name: PartMember.subsetValue,
-                    optional: true
-                },
-                type: {
-                    name: PartMember.type,
-                    optional: true
-                }
-            },
-            superTypes: [DefinitionBodyMember.$type, UsageBodyMember.$type]
-        },
-        PartUsage: {
-            name: PartUsage.$type,
-            properties: {
-                body: {
-                    name: PartUsage.body,
-                    defaultValue: [],
-                    optional: true
-                },
-                isVariation: {
-                    name: PartUsage.isVariation,
-                    defaultValue: false,
-                    optional: true
-                },
-                multiplicity: {
-                    name: PartUsage.multiplicity,
-                    optional: true
-                },
-                name: {
-                    name: PartUsage.name
-                },
-                type: {
-                    name: PartUsage.type,
-                    optional: true
-                }
-            },
-            superTypes: [UsageMember.$type]
-        },
-        PerformActionUsage: {
-            name: PerformActionUsage.$type,
-            properties: {
-                body: {
-                    name: PerformActionUsage.body,
-                    defaultValue: [],
-                    optional: true
-                },
-                isAction: {
-                    name: PerformActionUsage.isAction,
-                    defaultValue: false,
-                    optional: true
-                },
-                name: {
-                    name: PerformActionUsage.name,
-                    optional: true
-                },
-                performed: {
-                    name: PerformActionUsage.performed
-                },
-                type: {
-                    name: PerformActionUsage.type,
-                    optional: true
-                }
-            },
-            superTypes: [ArcadiaMember.$type]
-        },
-        PortDefinition: {
-            name: PortDefinition.$type,
-            properties: {
-                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]
-        },
-        PrefixMetadataAnnotation: {
-            name: PrefixMetadataAnnotation.$type,
-            properties: {
-                type: {
-                    name: PrefixMetadataAnnotation.type
-                }
-            },
-            superTypes: []
-        },
-        RealValue: {
-            name: RealValue.$type,
-            properties: {
-                value: {
-                    name: RealValue.value
-                }
-            },
-            superTypes: [AttributeValue.$type]
-        },
-        RefMember: {
-            name: RefMember.$type,
-            properties: {
-                bindingOp: {
-                    name: RefMember.bindingOp,
-                    optional: true
-                },
-                boundRef: {
-                    name: RefMember.boundRef,
-                    optional: true
-                },
-                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
-                },
-                subsetValue: {
-                    name: RefMember.subsetValue,
-                    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: [ActionDefBodyMember.$type, 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]
-        },
-        RequirementVerificationMember: {
-            name: RequirementVerificationMember.$type,
-            properties: {
-                body: {
-                    name: RequirementVerificationMember.body,
-                    defaultValue: [],
-                    optional: true
-                },
-                requirement: {
-                    name: RequirementVerificationMember.requirement
-                }
-            },
-            superTypes: [DefinitionBodyMember.$type, UsageBodyMember.$type]
-        },
-        SatisfyRequirementUsage: {
-            name: SatisfyRequirementUsage.$type,
-            properties: {
-                body: {
-                    name: SatisfyRequirementUsage.body,
-                    defaultValue: [],
-                    optional: true
-                },
-                isAsserted: {
-                    name: SatisfyRequirementUsage.isAsserted,
-                    defaultValue: false,
-                    optional: true
-                },
-                isNegated: {
-                    name: SatisfyRequirementUsage.isNegated,
-                    defaultValue: false,
-                    optional: true
-                },
-                requirement: {
-                    name: SatisfyRequirementUsage.requirement
-                },
-                satisfyingFeature: {
-                    name: SatisfyRequirementUsage.satisfyingFeature,
-                    optional: true
-                }
-            },
-            superTypes: [PackageMember.$type, UsageBodyMember.$type]
-        },
-        SendActionUsage: {
-            name: SendActionUsage.$type,
-            properties: {
-                followsPrevious: {
-                    name: SendActionUsage.followsPrevious,
-                    defaultValue: false,
-                    optional: true
-                },
-                name: {
-                    name: SendActionUsage.name
-                },
-                receiver: {
-                    name: SendActionUsage.receiver
-                },
-                target: {
-                    name: SendActionUsage.target
-                }
-            },
-            superTypes: [ActionDefBodyMember.$type, ActionUsageBodyMember.$type]
-        },
-        SetElement: {
-            name: SetElement.$type,
-            properties: {
-                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: []
-        },
-        StakeholderMember: {
-            name: StakeholderMember.$type,
-            properties: {
-                bindingOp: {
-                    name: StakeholderMember.bindingOp,
-                    optional: true
-                },
-                body: {
-                    name: StakeholderMember.body,
-                    defaultValue: [],
-                    optional: true
-                },
-                boundRef: {
-                    name: StakeholderMember.boundRef,
-                    optional: true
-                },
-                multiplicity: {
-                    name: StakeholderMember.multiplicity,
-                    optional: true
-                },
-                name: {
-                    name: StakeholderMember.name
-                },
-                type: {
-                    name: StakeholderMember.type,
-                    optional: true
-                }
-            },
-            superTypes: [ArcadiaMember.$type]
-        },
-        StateDefinition: {
-            name: StateDefinition.$type,
-            properties: {
-                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: [UsageBodyMember.$type, UsageMember.$type]
-        },
-        StringValue: {
-            name: StringValue.$type,
-            properties: {
-                value: {
-                    name: StringValue.value
-                }
-            },
-            superTypes: [AttributeValue.$type]
-        },
-        SubjectMember: {
-            name: SubjectMember.$type,
-            properties: {
-                bindingOp: {
-                    name: SubjectMember.bindingOp,
-                    optional: true
-                },
-                body: {
-                    name: SubjectMember.body,
-                    defaultValue: [],
-                    optional: true
-                },
-                boundRefs: {
-                    name: SubjectMember.boundRefs,
-                    defaultValue: [],
-                    optional: true
-                },
-                multiplicity: {
-                    name: SubjectMember.multiplicity,
-                    optional: true
-                },
-                name: {
-                    name: SubjectMember.name
-                },
-                redefines: {
-                    name: SubjectMember.redefines,
-                    defaultValue: false,
-                    optional: true
-                },
-                type: {
-                    name: SubjectMember.type,
-                    optional: true
-                }
-            },
-            superTypes: [ArcadiaMember.$type]
-        },
-        SuccessionStep: {
-            name: SuccessionStep.$type,
-            properties: {
-                guard: {
-                    name: SuccessionStep.guard,
-                    optional: true
-                },
-                ref: {
-                    name: SuccessionStep.ref
-                }
-            },
-            superTypes: []
-        },
-        SuccessionUsage: {
-            name: SuccessionUsage.$type,
-            properties: {
-                steps: {
-                    name: SuccessionUsage.steps,
-                    defaultValue: []
-                }
-            },
-            superTypes: [PackageMember.$type, UsageBodyMember.$type]
-        },
-        TerminateUsage: {
-            name: TerminateUsage.$type,
-            properties: {
-                followsPrevious: {
-                    name: TerminateUsage.followsPrevious,
-                    defaultValue: false,
-                    optional: true
-                },
-                name: {
-                    name: TerminateUsage.name,
-                    optional: true
-                }
-            },
-            superTypes: [ActionDefBodyMember.$type, ActionUsageBodyMember.$type]
-        },
-        TransitionUsage: {
-            name: TransitionUsage.$type,
-            properties: {
-                body: {
-                    name: TransitionUsage.body,
-                    defaultValue: [],
-                    optional: true
-                },
-                effect: {
-                    name: TransitionUsage.effect,
-                    optional: true
-                },
-                guard: {
-                    name: TransitionUsage.guard,
-                    optional: true
-                },
-                name: {
-                    name: TransitionUsage.name,
-                    optional: true
-                },
-                source: {
-                    name: TransitionUsage.source
-                },
-                target: {
-                    name: TransitionUsage.target
-                },
-                trigger: {
-                    name: TransitionUsage.trigger,
-                    optional: true
-                },
-                type: {
-                    name: TransitionUsage.type,
-                    optional: true
-                }
-            },
-            superTypes: [ArcadiaMember.$type]
-        },
-        UnaryExpr: {
-            name: UnaryExpr.$type,
-            properties: {
-                op: {
-                    name: UnaryExpr.op
-                },
-                operand: {
-                    name: UnaryExpr.operand
-                }
-            },
-            superTypes: [ConstraintExpr.$type]
-        },
-        UsageBodyMember: {
-            name: UsageBodyMember.$type,
-            properties: {},
-            superTypes: [ActionDefBodyMember.$type, ActionUsageBodyMember.$type, MetadataBodyMember.$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: [NamespaceMember.$type, PackageMember.$type]
-        },
-        VariantMember: {
-            name: VariantMember.$type,
-            properties: {
-                body: {
-                    name: VariantMember.body,
-                    defaultValue: [],
-                    optional: true
-                },
-                multiplicity: {
-                    name: VariantMember.multiplicity,
-                    optional: true
-                },
-                name: {
-                    name: VariantMember.name
-                },
-                type: {
-                    name: VariantMember.type,
-                    optional: true
-                },
-                usageKind: {
-                    name: VariantMember.usageKind,
-                    optional: true
-                },
-                value: {
-                    name: VariantMember.value,
-                    optional: true
-                }
-            },
-            superTypes: [ArcadiaMember.$type]
-        },
-        VerificationDefinition: {
-            name: VerificationDefinition.$type,
-            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]
-        },
-        ViewpointUsage: {
-            name: ViewpointUsage.$type,
-            properties: {
-                body: {
-                    name: ViewpointUsage.body,
-                    defaultValue: [],
-                    optional: true
-                },
-                name: {
-                    name: ViewpointUsage.name
-                },
-                type: {
-                    name: ViewpointUsage.type,
-                    optional: true
-                }
-            },
-            superTypes: [DefinitionBodyMember.$type, UsageBodyMember.$type, UsageMember.$type]
-        }
-    };
-}
-export const reflection = new MemoSysMLAstReflection();
-//# sourceMappingURL=ast.js.map