@oml/language 0.7.0

package/out/oml/generated/ast.js

@@ -0,0 +1,1807 @@
+/******************************************************************************
+ * This file was generated by langium-cli 4.1.0.
+ * DO NOT EDIT MANUALLY!
+ ******************************************************************************/
+/* eslint-disable */
+import * as langium from 'langium';
+export const OmlTerminals = {
+    ML_COMMENT: /\/\*[\s\S]*?\*\//,
+    SL_COMMENT: /\/\/[^\n\r]*/,
+    WS: /\s+/,
+    BOOLEAN: /(false|true)/,
+    DOUBLE: /((\+|-)?((?:[0-9])+(\.(?:[0-9])*)?|(\.(?:[0-9])+))(e|E)(\+|-)?(?:[0-9])+)(?!(?:[a-zA-Z])|(?:[-_.~%]))/,
+    DECIMAL: /((\+|-)?((?:[0-9])+(\.(?:[0-9])*))|(\.(?:[0-9])+))(?!(?:[a-zA-Z])|(?:[-_.~%]))/,
+    INTEGER: /((\+|-)(?:[0-9])+)(?!(?:[a-zA-Z])|(?:[-_.~%]))/,
+    UNSIGNED_INTEGER: /([0-9])+(?!(?:[a-zA-Z])|(?:[-_.~%]))/,
+    STRING: /("""(?:[\s\S]*?"""))|('''(?:[\s\S]*?'''))|('(?:[\s\S]*?'))|("(?:[\s\S]*?"))/,
+    NAMESPACE: /<[^#>\s]*[#/]>/,
+    IRI: /<[^>\s]*>/,
+    QNAME: /(?:((?:[a-zA-Z])|(?:[0-9])|(?:[-_.~%]))((?:[a-zA-Z])|(?:[0-9])|(?:[-_.~%])|\$)*):(?:((?:[a-zA-Z])|(?:[0-9])|(?:[-_.~%]))((?:[a-zA-Z])|(?:[0-9])|(?:[-_.~%])|\$)*)/,
+    ID: /\^?(?:((?:[a-zA-Z])|(?:[0-9])|(?:[-_.~%]))((?:[a-zA-Z])|(?:[0-9])|(?:[-_.~%])|\$)*)/,
+};
+export const Annotation = {
+    $type: 'Annotation',
+    literalValues: 'literalValues',
+    property: 'property',
+    referencedValues: 'referencedValues'
+};
+export function isAnnotation(item) {
+    return reflection.isInstance(item, Annotation.$type);
+}
+export const AnnotationProperty = {
+    $type: 'AnnotationProperty',
+    name: 'name',
+    ownedAnnotations: 'ownedAnnotations',
+    ownedEquivalences: 'ownedEquivalences',
+    ownedSpecializations: 'ownedSpecializations',
+    ref: 'ref'
+};
+export function isAnnotationProperty(item) {
+    return reflection.isInstance(item, AnnotationProperty.$type);
+}
+export const AnonymousConceptInstance = {
+    $type: 'AnonymousConceptInstance',
+    ownedPropertyValues: 'ownedPropertyValues',
+    type: 'type'
+};
+export function isAnonymousConceptInstance(item) {
+    return reflection.isInstance(item, AnonymousConceptInstance.$type);
+}
+export const AnonymousInstance = {
+    $type: 'AnonymousInstance'
+};
+export function isAnonymousInstance(item) {
+    return reflection.isInstance(item, AnonymousInstance.$type);
+}
+export const AnonymousRelationInstance = {
+    $type: 'AnonymousRelationInstance',
+    ownedPropertyValues: 'ownedPropertyValues',
+    target: 'target'
+};
+export function isAnonymousRelationInstance(item) {
+    return reflection.isInstance(item, AnonymousRelationInstance.$type);
+}
+export const Argument = {
+    $type: 'Argument',
+    instance: 'instance',
+    literal: 'literal',
+    variable: 'variable'
+};
+export function isArgument(item) {
+    return reflection.isInstance(item, Argument.$type);
+}
+export const Aspect = {
+    $type: 'Aspect',
+    name: 'name',
+    ownedAnnotations: 'ownedAnnotations',
+    ownedEquivalences: 'ownedEquivalences',
+    ownedKeys: 'ownedKeys',
+    ownedPropertyRestrictions: 'ownedPropertyRestrictions',
+    ownedSpecializations: 'ownedSpecializations',
+    ref: 'ref'
+};
+export function isAspect(item) {
+    return reflection.isInstance(item, Aspect.$type);
+}
+export const Assertion = {
+    $type: 'Assertion'
+};
+export function isAssertion(item) {
+    return reflection.isInstance(item, Assertion.$type);
+}
+export const Axiom = {
+    $type: 'Axiom'
+};
+export function isAxiom(item) {
+    return reflection.isInstance(item, Axiom.$type);
+}
+export const BinaryPredicate = {
+    $type: 'BinaryPredicate'
+};
+export function isBinaryPredicate(item) {
+    return reflection.isInstance(item, BinaryPredicate.$type);
+}
+export function isBoolean(item) {
+    return typeof item === 'boolean';
+}
+export const BooleanLiteral = {
+    $type: 'BooleanLiteral',
+    value: 'value'
+};
+export function isBooleanLiteral(item) {
+    return reflection.isInstance(item, BooleanLiteral.$type);
+}
+export const BuiltIn = {
+    $type: 'BuiltIn',
+    name: 'name',
+    ownedAnnotations: 'ownedAnnotations',
+    ref: 'ref'
+};
+export function isBuiltIn(item) {
+    return reflection.isInstance(item, BuiltIn.$type);
+}
+export const BuiltInPredicate = {
+    $type: 'BuiltInPredicate',
+    arguments: 'arguments',
+    builtIn: 'builtIn'
+};
+export function isBuiltInPredicate(item) {
+    return reflection.isInstance(item, BuiltInPredicate.$type);
+}
+export function isCardinalityRestrictionKind(item) {
+    return item === 'exactly' || item === 'min' || item === 'max';
+}
+export const Concept = {
+    $type: 'Concept',
+    name: 'name',
+    ownedAnnotations: 'ownedAnnotations',
+    ownedEnumeration: 'ownedEnumeration',
+    ownedEquivalences: 'ownedEquivalences',
+    ownedKeys: 'ownedKeys',
+    ownedPropertyRestrictions: 'ownedPropertyRestrictions',
+    ownedSpecializations: 'ownedSpecializations',
+    ref: 'ref'
+};
+export function isConcept(item) {
+    return reflection.isInstance(item, Concept.$type);
+}
+export const ConceptInstance = {
+    $type: 'ConceptInstance',
+    name: 'name',
+    ownedAnnotations: 'ownedAnnotations',
+    ownedPropertyValues: 'ownedPropertyValues',
+    ownedTypes: 'ownedTypes',
+    ref: 'ref'
+};
+export function isConceptInstance(item) {
+    return reflection.isInstance(item, ConceptInstance.$type);
+}
+export function isCrossRef(item) {
+    return (typeof item === 'string' && (/(?:((?:[a-zA-Z])|(?:[0-9])|(?:[-_.~%]))((?:[a-zA-Z])|(?:[0-9])|(?:[-_.~%])|\$)*):(?:((?:[a-zA-Z])|(?:[0-9])|(?:[-_.~%]))((?:[a-zA-Z])|(?:[0-9])|(?:[-_.~%])|\$)*)/.test(item) || /<[^>\s]*>/.test(item)));
+}
+export function isDecimal(item) {
+    return typeof item === 'number';
+}
+export const DecimalLiteral = {
+    $type: 'DecimalLiteral',
+    value: 'value'
+};
+export function isDecimalLiteral(item) {
+    return reflection.isInstance(item, DecimalLiteral.$type);
+}
+export const Description = {
+    $type: 'Description',
+    namespace: 'namespace',
+    ownedAnnotations: 'ownedAnnotations',
+    ownedImports: 'ownedImports',
+    ownedStatements: 'ownedStatements',
+    prefix: 'prefix'
+};
+export function isDescription(item) {
+    return reflection.isInstance(item, Description.$type);
+}
+export const DescriptionBox = {
+    $type: 'DescriptionBox'
+};
+export function isDescriptionBox(item) {
+    return reflection.isInstance(item, DescriptionBox.$type);
+}
+export const DescriptionBundle = {
+    $type: 'DescriptionBundle',
+    namespace: 'namespace',
+    ownedAnnotations: 'ownedAnnotations',
+    ownedImports: 'ownedImports',
+    prefix: 'prefix'
+};
+export function isDescriptionBundle(item) {
+    return reflection.isInstance(item, DescriptionBundle.$type);
+}
+export const DescriptionMember = {
+    $type: 'DescriptionMember'
+};
+export function isDescriptionMember(item) {
+    return reflection.isInstance(item, DescriptionMember.$type);
+}
+export const DescriptionStatement = {
+    $type: 'DescriptionStatement'
+};
+export function isDescriptionStatement(item) {
+    return reflection.isInstance(item, DescriptionStatement.$type);
+}
+export const DifferentFromPredicate = {
+    $type: 'DifferentFromPredicate',
+    argument1: 'argument1',
+    argument2: 'argument2'
+};
+export function isDifferentFromPredicate(item) {
+    return reflection.isInstance(item, DifferentFromPredicate.$type);
+}
+export function isDouble(item) {
+    return typeof item === 'number';
+}
+export const DoubleLiteral = {
+    $type: 'DoubleLiteral',
+    value: 'value'
+};
+export function isDoubleLiteral(item) {
+    return reflection.isInstance(item, DoubleLiteral.$type);
+}
+export const Element = {
+    $type: 'Element'
+};
+export function isElement(item) {
+    return reflection.isInstance(item, Element.$type);
+}
+export const Entity = {
+    $type: 'Entity'
+};
+export function isEntity(item) {
+    return reflection.isInstance(item, Entity.$type);
+}
+export const EntityEquivalenceAxiom = {
+    $type: 'EntityEquivalenceAxiom',
+    ownedPropertyRestrictions: 'ownedPropertyRestrictions',
+    superTerms: 'superTerms'
+};
+export function isEntityEquivalenceAxiom(item) {
+    return reflection.isInstance(item, EntityEquivalenceAxiom.$type);
+}
+export const EquivalenceAxiom = {
+    $type: 'EquivalenceAxiom'
+};
+export function isEquivalenceAxiom(item) {
+    return reflection.isInstance(item, EquivalenceAxiom.$type);
+}
+export const ForwardRelation = {
+    $type: 'ForwardRelation',
+    name: 'name',
+    ownedAnnotations: 'ownedAnnotations'
+};
+export function isForwardRelation(item) {
+    return reflection.isInstance(item, ForwardRelation.$type);
+}
+export const IdentifiedElement = {
+    $type: 'IdentifiedElement'
+};
+export function isIdentifiedElement(item) {
+    return reflection.isInstance(item, IdentifiedElement.$type);
+}
+export const Import = {
+    $type: 'Import',
+    imported: 'imported',
+    kind: 'kind',
+    prefix: 'prefix'
+};
+export function isImport(item) {
+    return reflection.isInstance(item, Import.$type);
+}
+export function isImportKind(item) {
+    return item === 'extends' || item === 'uses' || item === 'includes';
+}
+export const Instance = {
+    $type: 'Instance'
+};
+export function isInstance(item) {
+    return reflection.isInstance(item, Instance.$type);
+}
+export const InstanceEnumerationAxiom = {
+    $type: 'InstanceEnumerationAxiom',
+    instances: 'instances'
+};
+export function isInstanceEnumerationAxiom(item) {
+    return reflection.isInstance(item, InstanceEnumerationAxiom.$type);
+}
+export function isInteger(item) {
+    return typeof item === 'number';
+}
+export const IntegerLiteral = {
+    $type: 'IntegerLiteral',
+    value: 'value'
+};
+export function isIntegerLiteral(item) {
+    return reflection.isInstance(item, IntegerLiteral.$type);
+}
+export const KeyAxiom = {
+    $type: 'KeyAxiom',
+    properties: 'properties'
+};
+export function isKeyAxiom(item) {
+    return reflection.isInstance(item, KeyAxiom.$type);
+}
+export const Literal = {
+    $type: 'Literal'
+};
+export function isLiteral(item) {
+    return reflection.isInstance(item, Literal.$type);
+}
+export const LiteralEnumerationAxiom = {
+    $type: 'LiteralEnumerationAxiom',
+    literals: 'literals'
+};
+export function isLiteralEnumerationAxiom(item) {
+    return reflection.isInstance(item, LiteralEnumerationAxiom.$type);
+}
+export const Member = {
+    $type: 'Member'
+};
+export function isMember(item) {
+    return reflection.isInstance(item, Member.$type);
+}
+export const NamedInstance = {
+    $type: 'NamedInstance'
+};
+export function isNamedInstance(item) {
+    return reflection.isInstance(item, NamedInstance.$type);
+}
+export const Ontology = {
+    $type: 'Ontology'
+};
+export function isOntology(item) {
+    return reflection.isInstance(item, Ontology.$type);
+}
+export const Predicate = {
+    $type: 'Predicate'
+};
+export function isPredicate(item) {
+    return reflection.isInstance(item, Predicate.$type);
+}
+export const Property = {
+    $type: 'Property'
+};
+export function isProperty(item) {
+    return reflection.isInstance(item, Property.$type);
+}
+export const PropertyCardinalityRestrictionAxiom = {
+    $type: 'PropertyCardinalityRestrictionAxiom',
+    cardinality: 'cardinality',
+    kind: 'kind',
+    property: 'property',
+    range: 'range'
+};
+export function isPropertyCardinalityRestrictionAxiom(item) {
+    return reflection.isInstance(item, PropertyCardinalityRestrictionAxiom.$type);
+}
+export const PropertyEquivalenceAxiom = {
+    $type: 'PropertyEquivalenceAxiom',
+    superTerms: 'superTerms'
+};
+export function isPropertyEquivalenceAxiom(item) {
+    return reflection.isInstance(item, PropertyEquivalenceAxiom.$type);
+}
+export const PropertyPredicate = {
+    $type: 'PropertyPredicate',
+    argument1: 'argument1',
+    argument2: 'argument2',
+    property: 'property'
+};
+export function isPropertyPredicate(item) {
+    return reflection.isInstance(item, PropertyPredicate.$type);
+}
+export const PropertyRangeRestrictionAxiom = {
+    $type: 'PropertyRangeRestrictionAxiom',
+    kind: 'kind',
+    property: 'property',
+    range: 'range'
+};
+export function isPropertyRangeRestrictionAxiom(item) {
+    return reflection.isInstance(item, PropertyRangeRestrictionAxiom.$type);
+}
+export const PropertyRestrictionAxiom = {
+    $type: 'PropertyRestrictionAxiom'
+};
+export function isPropertyRestrictionAxiom(item) {
+    return reflection.isInstance(item, PropertyRestrictionAxiom.$type);
+}
+export const PropertySelfRestrictionAxiom = {
+    $type: 'PropertySelfRestrictionAxiom',
+    property: 'property'
+};
+export function isPropertySelfRestrictionAxiom(item) {
+    return reflection.isInstance(item, PropertySelfRestrictionAxiom.$type);
+}
+export const PropertyValueAssertion = {
+    $type: 'PropertyValueAssertion',
+    containedValues: 'containedValues',
+    literalValues: 'literalValues',
+    property: 'property',
+    referencedValues: 'referencedValues'
+};
+export function isPropertyValueAssertion(item) {
+    return reflection.isInstance(item, PropertyValueAssertion.$type);
+}
+export const PropertyValueRestrictionAxiom = {
+    $type: 'PropertyValueRestrictionAxiom',
+    containedValue: 'containedValue',
+    literalValue: 'literalValue',
+    property: 'property',
+    referencedValue: 'referencedValue'
+};
+export function isPropertyValueRestrictionAxiom(item) {
+    return reflection.isInstance(item, PropertyValueRestrictionAxiom.$type);
+}
+export const QuotedLiteral = {
+    $type: 'QuotedLiteral',
+    langTag: 'langTag',
+    type: 'type',
+    value: 'value'
+};
+export function isQuotedLiteral(item) {
+    return reflection.isInstance(item, QuotedLiteral.$type);
+}
+export function isRangeRestrictionKind(item) {
+    return item === 'all' || item === 'some';
+}
+export function isRef(item) {
+    return (typeof item === 'string' && (/(?:((?:[a-zA-Z])|(?:[0-9])|(?:[-_.~%]))((?:[a-zA-Z])|(?:[0-9])|(?:[-_.~%])|\$)*):(?:((?:[a-zA-Z])|(?:[0-9])|(?:[-_.~%]))((?:[a-zA-Z])|(?:[0-9])|(?:[-_.~%])|\$)*)/.test(item) || /\^?(?:((?:[a-zA-Z])|(?:[0-9])|(?:[-_.~%]))((?:[a-zA-Z])|(?:[0-9])|(?:[-_.~%])|\$)*)/.test(item) || /<[^>\s]*>/.test(item)));
+}
+export const Relation = {
+    $type: 'Relation'
+};
+export function isRelation(item) {
+    return reflection.isInstance(item, Relation.$type);
+}
+export const RelationBase = {
+    $type: 'RelationBase'
+};
+export function isRelationBase(item) {
+    return reflection.isInstance(item, RelationBase.$type);
+}
+export const RelationEntity = {
+    $type: 'RelationEntity',
+    asymmetric: 'asymmetric',
+    forwardRelation: 'forwardRelation',
+    functional: 'functional',
+    inverseFunctional: 'inverseFunctional',
+    irreflexive: 'irreflexive',
+    name: 'name',
+    ownedAnnotations: 'ownedAnnotations',
+    ownedEquivalences: 'ownedEquivalences',
+    ownedKeys: 'ownedKeys',
+    ownedPropertyRestrictions: 'ownedPropertyRestrictions',
+    ownedSpecializations: 'ownedSpecializations',
+    ref: 'ref',
+    reflexive: 'reflexive',
+    reverseRelation: 'reverseRelation',
+    sources: 'sources',
+    symmetric: 'symmetric',
+    targets: 'targets',
+    transitive: 'transitive'
+};
+export function isRelationEntity(item) {
+    return reflection.isInstance(item, RelationEntity.$type);
+}
+export const RelationEntityPredicate = {
+    $type: 'RelationEntityPredicate',
+    argument: 'argument',
+    argument1: 'argument1',
+    argument2: 'argument2',
+    type: 'type'
+};
+export function isRelationEntityPredicate(item) {
+    return reflection.isInstance(item, RelationEntityPredicate.$type);
+}
+export const RelationInstance = {
+    $type: 'RelationInstance',
+    name: 'name',
+    ownedAnnotations: 'ownedAnnotations',
+    ownedPropertyValues: 'ownedPropertyValues',
+    ownedTypes: 'ownedTypes',
+    ref: 'ref',
+    sources: 'sources',
+    targets: 'targets'
+};
+export function isRelationInstance(item) {
+    return reflection.isInstance(item, RelationInstance.$type);
+}
+export const ReverseRelation = {
+    $type: 'ReverseRelation',
+    name: 'name',
+    ownedAnnotations: 'ownedAnnotations'
+};
+export function isReverseRelation(item) {
+    return reflection.isInstance(item, ReverseRelation.$type);
+}
+export const Rule = {
+    $type: 'Rule',
+    antecedent: 'antecedent',
+    consequent: 'consequent',
+    name: 'name',
+    ownedAnnotations: 'ownedAnnotations',
+    ref: 'ref'
+};
+export function isRule(item) {
+    return reflection.isInstance(item, Rule.$type);
+}
+export const SameAsPredicate = {
+    $type: 'SameAsPredicate',
+    argument1: 'argument1',
+    argument2: 'argument2'
+};
+export function isSameAsPredicate(item) {
+    return reflection.isInstance(item, SameAsPredicate.$type);
+}
+export const Scalar = {
+    $type: 'Scalar',
+    name: 'name',
+    ownedAnnotations: 'ownedAnnotations',
+    ownedEnumeration: 'ownedEnumeration',
+    ownedEquivalences: 'ownedEquivalences',
+    ownedSpecializations: 'ownedSpecializations',
+    ref: 'ref'
+};
+export function isScalar(item) {
+    return reflection.isInstance(item, Scalar.$type);
+}
+export const ScalarEquivalenceAxiom = {
+    $type: 'ScalarEquivalenceAxiom',
+    language: 'language',
+    length: 'length',
+    maxExclusive: 'maxExclusive',
+    maxInclusive: 'maxInclusive',
+    maxLength: 'maxLength',
+    minExclusive: 'minExclusive',
+    minInclusive: 'minInclusive',
+    minLength: 'minLength',
+    pattern: 'pattern',
+    superTerms: 'superTerms'
+};
+export function isScalarEquivalenceAxiom(item) {
+    return reflection.isInstance(item, ScalarEquivalenceAxiom.$type);
+}
+export const ScalarProperty = {
+    $type: 'ScalarProperty',
+    domains: 'domains',
+    functional: 'functional',
+    name: 'name',
+    ownedAnnotations: 'ownedAnnotations',
+    ownedEquivalences: 'ownedEquivalences',
+    ownedSpecializations: 'ownedSpecializations',
+    ranges: 'ranges',
+    ref: 'ref'
+};
+export function isScalarProperty(item) {
+    return reflection.isInstance(item, ScalarProperty.$type);
+}
+export const SemanticProperty = {
+    $type: 'SemanticProperty'
+};
+export function isSemanticProperty(item) {
+    return reflection.isInstance(item, SemanticProperty.$type);
+}
+export const SpecializableProperty = {
+    $type: 'SpecializableProperty'
+};
+export function isSpecializableProperty(item) {
+    return reflection.isInstance(item, SpecializableProperty.$type);
+}
+export const SpecializableTerm = {
+    $type: 'SpecializableTerm'
+};
+export function isSpecializableTerm(item) {
+    return reflection.isInstance(item, SpecializableTerm.$type);
+}
+export const SpecializationAxiom = {
+    $type: 'SpecializationAxiom',
+    superTerm: 'superTerm'
+};
+export function isSpecializationAxiom(item) {
+    return reflection.isInstance(item, SpecializationAxiom.$type);
+}
+export const Statement = {
+    $type: 'Statement'
+};
+export function isStatement(item) {
+    return reflection.isInstance(item, Statement.$type);
+}
+export const Term = {
+    $type: 'Term'
+};
+export function isTerm(item) {
+    return reflection.isInstance(item, Term.$type);
+}
+export const Type = {
+    $type: 'Type'
+};
+export function isType(item) {
+    return reflection.isInstance(item, Type.$type);
+}
+export const TypeAssertion = {
+    $type: 'TypeAssertion',
+    type: 'type'
+};
+export function isTypeAssertion(item) {
+    return reflection.isInstance(item, TypeAssertion.$type);
+}
+export const TypePredicate = {
+    $type: 'TypePredicate',
+    argument: 'argument',
+    type: 'type'
+};
+export function isTypePredicate(item) {
+    return reflection.isInstance(item, TypePredicate.$type);
+}
+export const UnaryPredicate = {
+    $type: 'UnaryPredicate'
+};
+export function isUnaryPredicate(item) {
+    return reflection.isInstance(item, UnaryPredicate.$type);
+}
+export const UnreifiedRelation = {
+    $type: 'UnreifiedRelation',
+    asymmetric: 'asymmetric',
+    functional: 'functional',
+    inverseFunctional: 'inverseFunctional',
+    irreflexive: 'irreflexive',
+    name: 'name',
+    ownedAnnotations: 'ownedAnnotations',
+    ownedEquivalences: 'ownedEquivalences',
+    ownedSpecializations: 'ownedSpecializations',
+    ref: 'ref',
+    reflexive: 'reflexive',
+    reverseRelation: 'reverseRelation',
+    sources: 'sources',
+    symmetric: 'symmetric',
+    targets: 'targets',
+    transitive: 'transitive'
+};
+export function isUnreifiedRelation(item) {
+    return reflection.isInstance(item, UnreifiedRelation.$type);
+}
+export function isUnsignedInteger(item) {
+    return typeof item === 'number';
+}
+export const Vocabulary = {
+    $type: 'Vocabulary',
+    namespace: 'namespace',
+    ownedAnnotations: 'ownedAnnotations',
+    ownedImports: 'ownedImports',
+    ownedStatements: 'ownedStatements',
+    prefix: 'prefix'
+};
+export function isVocabulary(item) {
+    return reflection.isInstance(item, Vocabulary.$type);
+}
+export const VocabularyBox = {
+    $type: 'VocabularyBox'
+};
+export function isVocabularyBox(item) {
+    return reflection.isInstance(item, VocabularyBox.$type);
+}
+export const VocabularyBundle = {
+    $type: 'VocabularyBundle',
+    namespace: 'namespace',
+    ownedAnnotations: 'ownedAnnotations',
+    ownedImports: 'ownedImports',
+    prefix: 'prefix'
+};
+export function isVocabularyBundle(item) {
+    return reflection.isInstance(item, VocabularyBundle.$type);
+}
+export const VocabularyMember = {
+    $type: 'VocabularyMember'
+};
+export function isVocabularyMember(item) {
+    return reflection.isInstance(item, VocabularyMember.$type);
+}
+export const VocabularyStatement = {
+    $type: 'VocabularyStatement'
+};
+export function isVocabularyStatement(item) {
+    return reflection.isInstance(item, VocabularyStatement.$type);
+}
+export class OmlAstReflection extends langium.AbstractAstReflection {
+    constructor() {
+        super(...arguments);
+        this.types = {
+            Annotation: {
+                name: Annotation.$type,
+                properties: {
+                    literalValues: {
+                        name: Annotation.literalValues,
+                        defaultValue: []
+                    },
+                    property: {
+                        name: Annotation.property,
+                        referenceType: AnnotationProperty.$type
+                    },
+                    referencedValues: {
+                        name: Annotation.referencedValues,
+                        defaultValue: [],
+                        referenceType: Member.$type
+                    }
+                },
+                superTypes: [Element.$type]
+            },
+            AnnotationProperty: {
+                name: AnnotationProperty.$type,
+                properties: {
+                    name: {
+                        name: AnnotationProperty.name
+                    },
+                    ownedAnnotations: {
+                        name: AnnotationProperty.ownedAnnotations,
+                        defaultValue: []
+                    },
+                    ownedEquivalences: {
+                        name: AnnotationProperty.ownedEquivalences,
+                        defaultValue: []
+                    },
+                    ownedSpecializations: {
+                        name: AnnotationProperty.ownedSpecializations,
+                        defaultValue: []
+                    },
+                    ref: {
+                        name: AnnotationProperty.ref,
+                        referenceType: AnnotationProperty.$type
+                    }
+                },
+                superTypes: [SpecializableProperty.$type]
+            },
+            AnonymousConceptInstance: {
+                name: AnonymousConceptInstance.$type,
+                properties: {
+                    ownedPropertyValues: {
+                        name: AnonymousConceptInstance.ownedPropertyValues,
+                        defaultValue: []
+                    },
+                    type: {
+                        name: AnonymousConceptInstance.type,
+                        referenceType: Concept.$type
+                    }
+                },
+                superTypes: [AnonymousInstance.$type]
+            },
+            AnonymousInstance: {
+                name: AnonymousInstance.$type,
+                properties: {},
+                superTypes: [Instance.$type]
+            },
+            AnonymousRelationInstance: {
+                name: AnonymousRelationInstance.$type,
+                properties: {
+                    ownedPropertyValues: {
+                        name: AnonymousRelationInstance.ownedPropertyValues,
+                        defaultValue: []
+                    },
+                    target: {
+                        name: AnonymousRelationInstance.target,
+                        referenceType: NamedInstance.$type
+                    }
+                },
+                superTypes: [AnonymousInstance.$type]
+            },
+            Argument: {
+                name: Argument.$type,
+                properties: {
+                    instance: {
+                        name: Argument.instance,
+                        referenceType: NamedInstance.$type
+                    },
+                    literal: {
+                        name: Argument.literal
+                    },
+                    variable: {
+                        name: Argument.variable
+                    }
+                },
+                superTypes: [Element.$type]
+            },
+            Aspect: {
+                name: Aspect.$type,
+                properties: {
+                    name: {
+                        name: Aspect.name
+                    },
+                    ownedAnnotations: {
+                        name: Aspect.ownedAnnotations,
+                        defaultValue: []
+                    },
+                    ownedEquivalences: {
+                        name: Aspect.ownedEquivalences,
+                        defaultValue: []
+                    },
+                    ownedKeys: {
+                        name: Aspect.ownedKeys,
+                        defaultValue: []
+                    },
+                    ownedPropertyRestrictions: {
+                        name: Aspect.ownedPropertyRestrictions,
+                        defaultValue: []
+                    },
+                    ownedSpecializations: {
+                        name: Aspect.ownedSpecializations,
+                        defaultValue: []
+                    },
+                    ref: {
+                        name: Aspect.ref,
+                        referenceType: Aspect.$type
+                    }
+                },
+                superTypes: [Entity.$type]
+            },
+            Assertion: {
+                name: Assertion.$type,
+                properties: {},
+                superTypes: [Element.$type]
+            },
+            Axiom: {
+                name: Axiom.$type,
+                properties: {},
+                superTypes: [Element.$type]
+            },
+            BinaryPredicate: {
+                name: BinaryPredicate.$type,
+                properties: {},
+                superTypes: [Predicate.$type]
+            },
+            BooleanLiteral: {
+                name: BooleanLiteral.$type,
+                properties: {
+                    value: {
+                        name: BooleanLiteral.value
+                    }
+                },
+                superTypes: [Literal.$type]
+            },
+            BuiltIn: {
+                name: BuiltIn.$type,
+                properties: {
+                    name: {
+                        name: BuiltIn.name
+                    },
+                    ownedAnnotations: {
+                        name: BuiltIn.ownedAnnotations,
+                        defaultValue: []
+                    },
+                    ref: {
+                        name: BuiltIn.ref,
+                        referenceType: BuiltIn.$type
+                    }
+                },
+                superTypes: [VocabularyStatement.$type]
+            },
+            BuiltInPredicate: {
+                name: BuiltInPredicate.$type,
+                properties: {
+                    arguments: {
+                        name: BuiltInPredicate.arguments,
+                        defaultValue: []
+                    },
+                    builtIn: {
+                        name: BuiltInPredicate.builtIn,
+                        referenceType: BuiltIn.$type
+                    }
+                },
+                superTypes: [Predicate.$type]
+            },
+            Concept: {
+                name: Concept.$type,
+                properties: {
+                    name: {
+                        name: Concept.name
+                    },
+                    ownedAnnotations: {
+                        name: Concept.ownedAnnotations,
+                        defaultValue: []
+                    },
+                    ownedEnumeration: {
+                        name: Concept.ownedEnumeration
+                    },
+                    ownedEquivalences: {
+                        name: Concept.ownedEquivalences,
+                        defaultValue: []
+                    },
+                    ownedKeys: {
+                        name: Concept.ownedKeys,
+                        defaultValue: []
+                    },
+                    ownedPropertyRestrictions: {
+                        name: Concept.ownedPropertyRestrictions,
+                        defaultValue: []
+                    },
+                    ownedSpecializations: {
+                        name: Concept.ownedSpecializations,
+                        defaultValue: []
+                    },
+                    ref: {
+                        name: Concept.ref,
+                        referenceType: Concept.$type
+                    }
+                },
+                superTypes: [Entity.$type]
+            },
+            ConceptInstance: {
+                name: ConceptInstance.$type,
+                properties: {
+                    name: {
+                        name: ConceptInstance.name
+                    },
+                    ownedAnnotations: {
+                        name: ConceptInstance.ownedAnnotations,
+                        defaultValue: []
+                    },
+                    ownedPropertyValues: {
+                        name: ConceptInstance.ownedPropertyValues,
+                        defaultValue: []
+                    },
+                    ownedTypes: {
+                        name: ConceptInstance.ownedTypes,
+                        defaultValue: []
+                    },
+                    ref: {
+                        name: ConceptInstance.ref,
+                        referenceType: ConceptInstance.$type
+                    }
+                },
+                superTypes: [NamedInstance.$type]
+            },
+            DecimalLiteral: {
+                name: DecimalLiteral.$type,
+                properties: {
+                    value: {
+                        name: DecimalLiteral.value
+                    }
+                },
+                superTypes: [Literal.$type]
+            },
+            Description: {
+                name: Description.$type,
+                properties: {
+                    namespace: {
+                        name: Description.namespace
+                    },
+                    ownedAnnotations: {
+                        name: Description.ownedAnnotations,
+                        defaultValue: []
+                    },
+                    ownedImports: {
+                        name: Description.ownedImports,
+                        defaultValue: []
+                    },
+                    ownedStatements: {
+                        name: Description.ownedStatements,
+                        defaultValue: []
+                    },
+                    prefix: {
+                        name: Description.prefix
+                    }
+                },
+                superTypes: [DescriptionBox.$type]
+            },
+            DescriptionBox: {
+                name: DescriptionBox.$type,
+                properties: {},
+                superTypes: [Ontology.$type]
+            },
+            DescriptionBundle: {
+                name: DescriptionBundle.$type,
+                properties: {
+                    namespace: {
+                        name: DescriptionBundle.namespace
+                    },
+                    ownedAnnotations: {
+                        name: DescriptionBundle.ownedAnnotations,
+                        defaultValue: []
+                    },
+                    ownedImports: {
+                        name: DescriptionBundle.ownedImports,
+                        defaultValue: []
+                    },
+                    prefix: {
+                        name: DescriptionBundle.prefix
+                    }
+                },
+                superTypes: [DescriptionBox.$type]
+            },
+            DescriptionMember: {
+                name: DescriptionMember.$type,
+                properties: {},
+                superTypes: [Member.$type]
+            },
+            DescriptionStatement: {
+                name: DescriptionStatement.$type,
+                properties: {},
+                superTypes: [DescriptionMember.$type, Statement.$type]
+            },
+            DifferentFromPredicate: {
+                name: DifferentFromPredicate.$type,
+                properties: {
+                    argument1: {
+                        name: DifferentFromPredicate.argument1
+                    },
+                    argument2: {
+                        name: DifferentFromPredicate.argument2
+                    }
+                },
+                superTypes: [BinaryPredicate.$type]
+            },
+            DoubleLiteral: {
+                name: DoubleLiteral.$type,
+                properties: {
+                    value: {
+                        name: DoubleLiteral.value
+                    }
+                },
+                superTypes: [Literal.$type]
+            },
+            Element: {
+                name: Element.$type,
+                properties: {},
+                superTypes: []
+            },
+            Entity: {
+                name: Entity.$type,
+                properties: {},
+                superTypes: [Type.$type]
+            },
+            EntityEquivalenceAxiom: {
+                name: EntityEquivalenceAxiom.$type,
+                properties: {
+                    ownedPropertyRestrictions: {
+                        name: EntityEquivalenceAxiom.ownedPropertyRestrictions,
+                        defaultValue: []
+                    },
+                    superTerms: {
+                        name: EntityEquivalenceAxiom.superTerms,
+                        defaultValue: [],
+                        referenceType: Entity.$type
+                    }
+                },
+                superTypes: [Axiom.$type, EquivalenceAxiom.$type]
+            },
+            EquivalenceAxiom: {
+                name: EquivalenceAxiom.$type,
+                properties: {},
+                superTypes: []
+            },
+            ForwardRelation: {
+                name: ForwardRelation.$type,
+                properties: {
+                    name: {
+                        name: ForwardRelation.name
+                    },
+                    ownedAnnotations: {
+                        name: ForwardRelation.ownedAnnotations,
+                        defaultValue: []
+                    }
+                },
+                superTypes: [Relation.$type]
+            },
+            IdentifiedElement: {
+                name: IdentifiedElement.$type,
+                properties: {},
+                superTypes: [Element.$type]
+            },
+            Import: {
+                name: Import.$type,
+                properties: {
+                    imported: {
+                        name: Import.imported,
+                        referenceType: Ontology.$type
+                    },
+                    kind: {
+                        name: Import.kind
+                    },
+                    prefix: {
+                        name: Import.prefix
+                    }
+                },
+                superTypes: [Element.$type]
+            },
+            Instance: {
+                name: Instance.$type,
+                properties: {},
+                superTypes: [Element.$type]
+            },
+            InstanceEnumerationAxiom: {
+                name: InstanceEnumerationAxiom.$type,
+                properties: {
+                    instances: {
+                        name: InstanceEnumerationAxiom.instances,
+                        defaultValue: [],
+                        referenceType: ConceptInstance.$type
+                    }
+                },
+                superTypes: [Axiom.$type]
+            },
+            IntegerLiteral: {
+                name: IntegerLiteral.$type,
+                properties: {
+                    value: {
+                        name: IntegerLiteral.value
+                    }
+                },
+                superTypes: [Literal.$type]
+            },
+            KeyAxiom: {
+                name: KeyAxiom.$type,
+                properties: {
+                    properties: {
+                        name: KeyAxiom.properties,
+                        defaultValue: [],
+                        referenceType: Property.$type
+                    }
+                },
+                superTypes: [Axiom.$type]
+            },
+            Literal: {
+                name: Literal.$type,
+                properties: {},
+                superTypes: [Element.$type]
+            },
+            LiteralEnumerationAxiom: {
+                name: LiteralEnumerationAxiom.$type,
+                properties: {
+                    literals: {
+                        name: LiteralEnumerationAxiom.literals,
+                        defaultValue: []
+                    }
+                },
+                superTypes: [Axiom.$type]
+            },
+            Member: {
+                name: Member.$type,
+                properties: {},
+                superTypes: [IdentifiedElement.$type]
+            },
+            NamedInstance: {
+                name: NamedInstance.$type,
+                properties: {},
+                superTypes: [DescriptionStatement.$type, Instance.$type]
+            },
+            Ontology: {
+                name: Ontology.$type,
+                properties: {},
+                superTypes: [IdentifiedElement.$type]
+            },
+            Predicate: {
+                name: Predicate.$type,
+                properties: {},
+                superTypes: [Element.$type]
+            },
+            Property: {
+                name: Property.$type,
+                properties: {},
+                superTypes: [Term.$type]
+            },
+            PropertyCardinalityRestrictionAxiom: {
+                name: PropertyCardinalityRestrictionAxiom.$type,
+                properties: {
+                    cardinality: {
+                        name: PropertyCardinalityRestrictionAxiom.cardinality
+                    },
+                    kind: {
+                        name: PropertyCardinalityRestrictionAxiom.kind
+                    },
+                    property: {
+                        name: PropertyCardinalityRestrictionAxiom.property,
+                        referenceType: SemanticProperty.$type
+                    },
+                    range: {
+                        name: PropertyCardinalityRestrictionAxiom.range,
+                        referenceType: Type.$type
+                    }
+                },
+                superTypes: [PropertyRestrictionAxiom.$type]
+            },
+            PropertyEquivalenceAxiom: {
+                name: PropertyEquivalenceAxiom.$type,
+                properties: {
+                    superTerms: {
+                        name: PropertyEquivalenceAxiom.superTerms,
+                        defaultValue: [],
+                        referenceType: Property.$type
+                    }
+                },
+                superTypes: [Axiom.$type, EquivalenceAxiom.$type]
+            },
+            PropertyPredicate: {
+                name: PropertyPredicate.$type,
+                properties: {
+                    argument1: {
+                        name: PropertyPredicate.argument1
+                    },
+                    argument2: {
+                        name: PropertyPredicate.argument2
+                    },
+                    property: {
+                        name: PropertyPredicate.property,
+                        referenceType: Property.$type
+                    }
+                },
+                superTypes: [BinaryPredicate.$type]
+            },
+            PropertyRangeRestrictionAxiom: {
+                name: PropertyRangeRestrictionAxiom.$type,
+                properties: {
+                    kind: {
+                        name: PropertyRangeRestrictionAxiom.kind
+                    },
+                    property: {
+                        name: PropertyRangeRestrictionAxiom.property,
+                        referenceType: SemanticProperty.$type
+                    },
+                    range: {
+                        name: PropertyRangeRestrictionAxiom.range,
+                        referenceType: Type.$type
+                    }
+                },
+                superTypes: [PropertyRestrictionAxiom.$type]
+            },
+            PropertyRestrictionAxiom: {
+                name: PropertyRestrictionAxiom.$type,
+                properties: {},
+                superTypes: [Axiom.$type]
+            },
+            PropertySelfRestrictionAxiom: {
+                name: PropertySelfRestrictionAxiom.$type,
+                properties: {
+                    property: {
+                        name: PropertySelfRestrictionAxiom.property,
+                        referenceType: SemanticProperty.$type
+                    }
+                },
+                superTypes: [PropertyRestrictionAxiom.$type]
+            },
+            PropertyValueAssertion: {
+                name: PropertyValueAssertion.$type,
+                properties: {
+                    containedValues: {
+                        name: PropertyValueAssertion.containedValues,
+                        defaultValue: []
+                    },
+                    literalValues: {
+                        name: PropertyValueAssertion.literalValues,
+                        defaultValue: []
+                    },
+                    property: {
+                        name: PropertyValueAssertion.property,
+                        referenceType: SemanticProperty.$type
+                    },
+                    referencedValues: {
+                        name: PropertyValueAssertion.referencedValues,
+                        defaultValue: [],
+                        referenceType: NamedInstance.$type
+                    }
+                },
+                superTypes: [Assertion.$type]
+            },
+            PropertyValueRestrictionAxiom: {
+                name: PropertyValueRestrictionAxiom.$type,
+                properties: {
+                    containedValue: {
+                        name: PropertyValueRestrictionAxiom.containedValue
+                    },
+                    literalValue: {
+                        name: PropertyValueRestrictionAxiom.literalValue
+                    },
+                    property: {
+                        name: PropertyValueRestrictionAxiom.property,
+                        referenceType: SemanticProperty.$type
+                    },
+                    referencedValue: {
+                        name: PropertyValueRestrictionAxiom.referencedValue,
+                        referenceType: NamedInstance.$type
+                    }
+                },
+                superTypes: [PropertyRestrictionAxiom.$type]
+            },
+            QuotedLiteral: {
+                name: QuotedLiteral.$type,
+                properties: {
+                    langTag: {
+                        name: QuotedLiteral.langTag
+                    },
+                    type: {
+                        name: QuotedLiteral.type,
+                        referenceType: Scalar.$type
+                    },
+                    value: {
+                        name: QuotedLiteral.value
+                    }
+                },
+                superTypes: [Literal.$type]
+            },
+            Relation: {
+                name: Relation.$type,
+                properties: {},
+                superTypes: [SemanticProperty.$type]
+            },
+            RelationBase: {
+                name: RelationBase.$type,
+                properties: {},
+                superTypes: [Term.$type]
+            },
+            RelationEntity: {
+                name: RelationEntity.$type,
+                properties: {
+                    asymmetric: {
+                        name: RelationEntity.asymmetric,
+                        defaultValue: false
+                    },
+                    forwardRelation: {
+                        name: RelationEntity.forwardRelation
+                    },
+                    functional: {
+                        name: RelationEntity.functional,
+                        defaultValue: false
+                    },
+                    inverseFunctional: {
+                        name: RelationEntity.inverseFunctional,
+                        defaultValue: false
+                    },
+                    irreflexive: {
+                        name: RelationEntity.irreflexive,
+                        defaultValue: false
+                    },
+                    name: {
+                        name: RelationEntity.name
+                    },
+                    ownedAnnotations: {
+                        name: RelationEntity.ownedAnnotations,
+                        defaultValue: []
+                    },
+                    ownedEquivalences: {
+                        name: RelationEntity.ownedEquivalences,
+                        defaultValue: []
+                    },
+                    ownedKeys: {
+                        name: RelationEntity.ownedKeys,
+                        defaultValue: []
+                    },
+                    ownedPropertyRestrictions: {
+                        name: RelationEntity.ownedPropertyRestrictions,
+                        defaultValue: []
+                    },
+                    ownedSpecializations: {
+                        name: RelationEntity.ownedSpecializations,
+                        defaultValue: []
+                    },
+                    ref: {
+                        name: RelationEntity.ref,
+                        referenceType: RelationEntity.$type
+                    },
+                    reflexive: {
+                        name: RelationEntity.reflexive,
+                        defaultValue: false
+                    },
+                    reverseRelation: {
+                        name: RelationEntity.reverseRelation
+                    },
+                    sources: {
+                        name: RelationEntity.sources,
+                        defaultValue: [],
+                        referenceType: Entity.$type
+                    },
+                    symmetric: {
+                        name: RelationEntity.symmetric,
+                        defaultValue: false
+                    },
+                    targets: {
+                        name: RelationEntity.targets,
+                        defaultValue: [],
+                        referenceType: Entity.$type
+                    },
+                    transitive: {
+                        name: RelationEntity.transitive,
+                        defaultValue: false
+                    }
+                },
+                superTypes: [Entity.$type, RelationBase.$type]
+            },
+            RelationEntityPredicate: {
+                name: RelationEntityPredicate.$type,
+                properties: {
+                    argument: {
+                        name: RelationEntityPredicate.argument
+                    },
+                    argument1: {
+                        name: RelationEntityPredicate.argument1
+                    },
+                    argument2: {
+                        name: RelationEntityPredicate.argument2
+                    },
+                    type: {
+                        name: RelationEntityPredicate.type,
+                        referenceType: RelationEntity.$type
+                    }
+                },
+                superTypes: [UnaryPredicate.$type]
+            },
+            RelationInstance: {
+                name: RelationInstance.$type,
+                properties: {
+                    name: {
+                        name: RelationInstance.name
+                    },
+                    ownedAnnotations: {
+                        name: RelationInstance.ownedAnnotations,
+                        defaultValue: []
+                    },
+                    ownedPropertyValues: {
+                        name: RelationInstance.ownedPropertyValues,
+                        defaultValue: []
+                    },
+                    ownedTypes: {
+                        name: RelationInstance.ownedTypes,
+                        defaultValue: []
+                    },
+                    ref: {
+                        name: RelationInstance.ref,
+                        referenceType: RelationInstance.$type
+                    },
+                    sources: {
+                        name: RelationInstance.sources,
+                        defaultValue: [],
+                        referenceType: NamedInstance.$type
+                    },
+                    targets: {
+                        name: RelationInstance.targets,
+                        defaultValue: [],
+                        referenceType: NamedInstance.$type
+                    }
+                },
+                superTypes: [NamedInstance.$type]
+            },
+            ReverseRelation: {
+                name: ReverseRelation.$type,
+                properties: {
+                    name: {
+                        name: ReverseRelation.name
+                    },
+                    ownedAnnotations: {
+                        name: ReverseRelation.ownedAnnotations,
+                        defaultValue: []
+                    }
+                },
+                superTypes: [Relation.$type]
+            },
+            Rule: {
+                name: Rule.$type,
+                properties: {
+                    antecedent: {
+                        name: Rule.antecedent,
+                        defaultValue: []
+                    },
+                    consequent: {
+                        name: Rule.consequent,
+                        defaultValue: []
+                    },
+                    name: {
+                        name: Rule.name
+                    },
+                    ownedAnnotations: {
+                        name: Rule.ownedAnnotations,
+                        defaultValue: []
+                    },
+                    ref: {
+                        name: Rule.ref,
+                        referenceType: Rule.$type
+                    }
+                },
+                superTypes: [VocabularyStatement.$type]
+            },
+            SameAsPredicate: {
+                name: SameAsPredicate.$type,
+                properties: {
+                    argument1: {
+                        name: SameAsPredicate.argument1
+                    },
+                    argument2: {
+                        name: SameAsPredicate.argument2
+                    }
+                },
+                superTypes: [BinaryPredicate.$type]
+            },
+            Scalar: {
+                name: Scalar.$type,
+                properties: {
+                    name: {
+                        name: Scalar.name
+                    },
+                    ownedAnnotations: {
+                        name: Scalar.ownedAnnotations,
+                        defaultValue: []
+                    },
+                    ownedEnumeration: {
+                        name: Scalar.ownedEnumeration
+                    },
+                    ownedEquivalences: {
+                        name: Scalar.ownedEquivalences,
+                        defaultValue: []
+                    },
+                    ownedSpecializations: {
+                        name: Scalar.ownedSpecializations,
+                        defaultValue: []
+                    },
+                    ref: {
+                        name: Scalar.ref,
+                        referenceType: Scalar.$type
+                    }
+                },
+                superTypes: [Type.$type]
+            },
+            ScalarEquivalenceAxiom: {
+                name: ScalarEquivalenceAxiom.$type,
+                properties: {
+                    language: {
+                        name: ScalarEquivalenceAxiom.language,
+                        defaultValue: []
+                    },
+                    length: {
+                        name: ScalarEquivalenceAxiom.length,
+                        defaultValue: []
+                    },
+                    maxExclusive: {
+                        name: ScalarEquivalenceAxiom.maxExclusive,
+                        defaultValue: []
+                    },
+                    maxInclusive: {
+                        name: ScalarEquivalenceAxiom.maxInclusive,
+                        defaultValue: []
+                    },
+                    maxLength: {
+                        name: ScalarEquivalenceAxiom.maxLength,
+                        defaultValue: []
+                    },
+                    minExclusive: {
+                        name: ScalarEquivalenceAxiom.minExclusive,
+                        defaultValue: []
+                    },
+                    minInclusive: {
+                        name: ScalarEquivalenceAxiom.minInclusive,
+                        defaultValue: []
+                    },
+                    minLength: {
+                        name: ScalarEquivalenceAxiom.minLength,
+                        defaultValue: []
+                    },
+                    pattern: {
+                        name: ScalarEquivalenceAxiom.pattern,
+                        defaultValue: []
+                    },
+                    superTerms: {
+                        name: ScalarEquivalenceAxiom.superTerms,
+                        defaultValue: [],
+                        referenceType: Scalar.$type
+                    }
+                },
+                superTypes: [Axiom.$type, EquivalenceAxiom.$type]
+            },
+            ScalarProperty: {
+                name: ScalarProperty.$type,
+                properties: {
+                    domains: {
+                        name: ScalarProperty.domains,
+                        defaultValue: [],
+                        referenceType: Entity.$type
+                    },
+                    functional: {
+                        name: ScalarProperty.functional,
+                        defaultValue: false
+                    },
+                    name: {
+                        name: ScalarProperty.name
+                    },
+                    ownedAnnotations: {
+                        name: ScalarProperty.ownedAnnotations,
+                        defaultValue: []
+                    },
+                    ownedEquivalences: {
+                        name: ScalarProperty.ownedEquivalences,
+                        defaultValue: []
+                    },
+                    ownedSpecializations: {
+                        name: ScalarProperty.ownedSpecializations,
+                        defaultValue: []
+                    },
+                    ranges: {
+                        name: ScalarProperty.ranges,
+                        defaultValue: [],
+                        referenceType: Scalar.$type
+                    },
+                    ref: {
+                        name: ScalarProperty.ref,
+                        referenceType: ScalarProperty.$type
+                    }
+                },
+                superTypes: [SemanticProperty.$type, SpecializableProperty.$type]
+            },
+            SemanticProperty: {
+                name: SemanticProperty.$type,
+                properties: {},
+                superTypes: [Property.$type]
+            },
+            SpecializableProperty: {
+                name: SpecializableProperty.$type,
+                properties: {},
+                superTypes: [Property.$type, SpecializableTerm.$type]
+            },
+            SpecializableTerm: {
+                name: SpecializableTerm.$type,
+                properties: {},
+                superTypes: [Term.$type, VocabularyStatement.$type]
+            },
+            SpecializationAxiom: {
+                name: SpecializationAxiom.$type,
+                properties: {
+                    superTerm: {
+                        name: SpecializationAxiom.superTerm,
+                        referenceType: Term.$type
+                    }
+                },
+                superTypes: [Axiom.$type]
+            },
+            Statement: {
+                name: Statement.$type,
+                properties: {},
+                superTypes: [Member.$type]
+            },
+            Term: {
+                name: Term.$type,
+                properties: {},
+                superTypes: [VocabularyMember.$type]
+            },
+            Type: {
+                name: Type.$type,
+                properties: {},
+                superTypes: [SpecializableTerm.$type]
+            },
+            TypeAssertion: {
+                name: TypeAssertion.$type,
+                properties: {
+                    type: {
+                        name: TypeAssertion.type,
+                        referenceType: Entity.$type
+                    }
+                },
+                superTypes: [Assertion.$type]
+            },
+            TypePredicate: {
+                name: TypePredicate.$type,
+                properties: {
+                    argument: {
+                        name: TypePredicate.argument
+                    },
+                    type: {
+                        name: TypePredicate.type,
+                        referenceType: Type.$type
+                    }
+                },
+                superTypes: [UnaryPredicate.$type]
+            },
+            UnaryPredicate: {
+                name: UnaryPredicate.$type,
+                properties: {},
+                superTypes: [Predicate.$type]
+            },
+            UnreifiedRelation: {
+                name: UnreifiedRelation.$type,
+                properties: {
+                    asymmetric: {
+                        name: UnreifiedRelation.asymmetric,
+                        defaultValue: false
+                    },
+                    functional: {
+                        name: UnreifiedRelation.functional,
+                        defaultValue: false
+                    },
+                    inverseFunctional: {
+                        name: UnreifiedRelation.inverseFunctional,
+                        defaultValue: false
+                    },
+                    irreflexive: {
+                        name: UnreifiedRelation.irreflexive,
+                        defaultValue: false
+                    },
+                    name: {
+                        name: UnreifiedRelation.name
+                    },
+                    ownedAnnotations: {
+                        name: UnreifiedRelation.ownedAnnotations,
+                        defaultValue: []
+                    },
+                    ownedEquivalences: {
+                        name: UnreifiedRelation.ownedEquivalences,
+                        defaultValue: []
+                    },
+                    ownedSpecializations: {
+                        name: UnreifiedRelation.ownedSpecializations,
+                        defaultValue: []
+                    },
+                    ref: {
+                        name: UnreifiedRelation.ref,
+                        referenceType: Relation.$type
+                    },
+                    reflexive: {
+                        name: UnreifiedRelation.reflexive,
+                        defaultValue: false
+                    },
+                    reverseRelation: {
+                        name: UnreifiedRelation.reverseRelation
+                    },
+                    sources: {
+                        name: UnreifiedRelation.sources,
+                        defaultValue: [],
+                        referenceType: Entity.$type
+                    },
+                    symmetric: {
+                        name: UnreifiedRelation.symmetric,
+                        defaultValue: false
+                    },
+                    targets: {
+                        name: UnreifiedRelation.targets,
+                        defaultValue: [],
+                        referenceType: Entity.$type
+                    },
+                    transitive: {
+                        name: UnreifiedRelation.transitive,
+                        defaultValue: false
+                    }
+                },
+                superTypes: [Relation.$type, RelationBase.$type, SpecializableProperty.$type]
+            },
+            Vocabulary: {
+                name: Vocabulary.$type,
+                properties: {
+                    namespace: {
+                        name: Vocabulary.namespace
+                    },
+                    ownedAnnotations: {
+                        name: Vocabulary.ownedAnnotations,
+                        defaultValue: []
+                    },
+                    ownedImports: {
+                        name: Vocabulary.ownedImports,
+                        defaultValue: []
+                    },
+                    ownedStatements: {
+                        name: Vocabulary.ownedStatements,
+                        defaultValue: []
+                    },
+                    prefix: {
+                        name: Vocabulary.prefix
+                    }
+                },
+                superTypes: [VocabularyBox.$type]
+            },
+            VocabularyBox: {
+                name: VocabularyBox.$type,
+                properties: {},
+                superTypes: [Ontology.$type]
+            },
+            VocabularyBundle: {
+                name: VocabularyBundle.$type,
+                properties: {
+                    namespace: {
+                        name: VocabularyBundle.namespace
+                    },
+                    ownedAnnotations: {
+                        name: VocabularyBundle.ownedAnnotations,
+                        defaultValue: []
+                    },
+                    ownedImports: {
+                        name: VocabularyBundle.ownedImports,
+                        defaultValue: []
+                    },
+                    prefix: {
+                        name: VocabularyBundle.prefix
+                    }
+                },
+                superTypes: [VocabularyBox.$type]
+            },
+            VocabularyMember: {
+                name: VocabularyMember.$type,
+                properties: {},
+                superTypes: [Member.$type]
+            },
+            VocabularyStatement: {
+                name: VocabularyStatement.$type,
+                properties: {},
+                superTypes: [Statement.$type, VocabularyMember.$type]
+            }
+        };
+    }
+}
+export const reflection = new OmlAstReflection();
+//# sourceMappingURL=ast.js.map