@oml/language 0.7.0

package/src/oml/generated/ast.ts

@@ -0,0 +1,2641 @@
+/******************************************************************************
+ * 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 type OmlTerminalNames = keyof typeof OmlTerminals;
+
+export type OmlKeywordNames =
+    | "$"
+    | "&"
+    | "("
+    | ")"
+    | ","
+    | "->"
+    | ":"
+    | "<"
+    | "="
+    | "@"
+    | "["
+    | "]"
+    | "^^"
+    | "all"
+    | "annotation"
+    | "as"
+    | "aspect"
+    | "asymmetric"
+    | "builtIn"
+    | "builtin"
+    | "bundle"
+    | "concept"
+    | "description"
+    | "differentFrom"
+    | "domain"
+    | "entity"
+    | "exactly"
+    | "extends"
+    | "forward"
+    | "from"
+    | "functional"
+    | "includes"
+    | "instance"
+    | "inverse"
+    | "irreflexive"
+    | "key"
+    | "language"
+    | "length"
+    | "max"
+    | "maxExclusive"
+    | "maxInclusive"
+    | "maxLength"
+    | "min"
+    | "minExclusive"
+    | "minInclusive"
+    | "minLength"
+    | "oneOf"
+    | "pattern"
+    | "property"
+    | "range"
+    | "ref"
+    | "reflexive"
+    | "relation"
+    | "restricts"
+    | "reverse"
+    | "rule"
+    | "sameAs"
+    | "scalar"
+    | "self"
+    | "some"
+    | "symmetric"
+    | "to"
+    | "transitive"
+    | "uses"
+    | "vocabulary"
+    | "{"
+    | "}";
+
+export type OmlTokenNames = OmlTerminalNames | OmlKeywordNames;
+
+export interface Annotation extends langium.AstNode {
+    readonly $container: AnnotationProperty | Aspect | BuiltIn | Concept | ConceptInstance | Description | DescriptionBundle | ForwardRelation | RelationEntity | RelationInstance | ReverseRelation | Rule | Scalar | ScalarProperty | UnreifiedRelation | Vocabulary | VocabularyBundle;
+    readonly $type: 'Annotation';
+    literalValues: Array<Literal>;
+    property: langium.Reference<AnnotationProperty>;
+    referencedValues: Array<langium.Reference<Member>>;
+}
+
+export const Annotation = {
+    $type: 'Annotation',
+    literalValues: 'literalValues',
+    property: 'property',
+    referencedValues: 'referencedValues'
+} as const;
+
+export function isAnnotation(item: unknown): item is Annotation {
+    return reflection.isInstance(item, Annotation.$type);
+}
+
+export interface AnnotationProperty extends langium.AstNode {
+    readonly $container: Vocabulary;
+    readonly $type: 'AnnotationProperty';
+    name?: string;
+    ownedAnnotations: Array<Annotation>;
+    ownedEquivalences: Array<PropertyEquivalenceAxiom>;
+    ownedSpecializations: Array<SpecializationAxiom>;
+    ref?: langium.Reference<AnnotationProperty>;
+}
+
+export const AnnotationProperty = {
+    $type: 'AnnotationProperty',
+    name: 'name',
+    ownedAnnotations: 'ownedAnnotations',
+    ownedEquivalences: 'ownedEquivalences',
+    ownedSpecializations: 'ownedSpecializations',
+    ref: 'ref'
+} as const;
+
+export function isAnnotationProperty(item: unknown): item is AnnotationProperty {
+    return reflection.isInstance(item, AnnotationProperty.$type);
+}
+
+export interface AnonymousConceptInstance extends langium.AstNode {
+    readonly $container: PropertyValueAssertion | PropertyValueRestrictionAxiom;
+    readonly $type: 'AnonymousConceptInstance';
+    ownedPropertyValues: Array<PropertyValueAssertion>;
+    type?: langium.Reference<Concept>;
+}
+
+export const AnonymousConceptInstance = {
+    $type: 'AnonymousConceptInstance',
+    ownedPropertyValues: 'ownedPropertyValues',
+    type: 'type'
+} as const;
+
+export function isAnonymousConceptInstance(item: unknown): item is AnonymousConceptInstance {
+    return reflection.isInstance(item, AnonymousConceptInstance.$type);
+}
+
+export type AnonymousInstance = AnonymousConceptInstance | AnonymousRelationInstance;
+
+export const AnonymousInstance = {
+    $type: 'AnonymousInstance'
+} as const;
+
+export function isAnonymousInstance(item: unknown): item is AnonymousInstance {
+    return reflection.isInstance(item, AnonymousInstance.$type);
+}
+
+export interface AnonymousRelationInstance extends langium.AstNode {
+    readonly $container: PropertyValueAssertion | PropertyValueRestrictionAxiom;
+    readonly $type: 'AnonymousRelationInstance';
+    ownedPropertyValues: Array<PropertyValueAssertion>;
+    target: langium.Reference<NamedInstance>;
+}
+
+export const AnonymousRelationInstance = {
+    $type: 'AnonymousRelationInstance',
+    ownedPropertyValues: 'ownedPropertyValues',
+    target: 'target'
+} as const;
+
+export function isAnonymousRelationInstance(item: unknown): item is AnonymousRelationInstance {
+    return reflection.isInstance(item, AnonymousRelationInstance.$type);
+}
+
+export interface Argument extends langium.AstNode {
+    readonly $container: BuiltInPredicate | DifferentFromPredicate | PropertyPredicate | RelationEntityPredicate | SameAsPredicate | TypePredicate;
+    readonly $type: 'Argument';
+    instance?: langium.Reference<NamedInstance>;
+    literal?: Literal;
+    variable?: string;
+}
+
+export const Argument = {
+    $type: 'Argument',
+    instance: 'instance',
+    literal: 'literal',
+    variable: 'variable'
+} as const;
+
+export function isArgument(item: unknown): item is Argument {
+    return reflection.isInstance(item, Argument.$type);
+}
+
+export interface Aspect extends langium.AstNode {
+    readonly $container: Vocabulary;
+    readonly $type: 'Aspect';
+    name?: string;
+    ownedAnnotations: Array<Annotation>;
+    ownedEquivalences: Array<EntityEquivalenceAxiom>;
+    ownedKeys: Array<KeyAxiom>;
+    ownedPropertyRestrictions: Array<PropertyRestrictionAxiom>;
+    ownedSpecializations: Array<SpecializationAxiom>;
+    ref?: langium.Reference<Aspect>;
+}
+
+export const Aspect = {
+    $type: 'Aspect',
+    name: 'name',
+    ownedAnnotations: 'ownedAnnotations',
+    ownedEquivalences: 'ownedEquivalences',
+    ownedKeys: 'ownedKeys',
+    ownedPropertyRestrictions: 'ownedPropertyRestrictions',
+    ownedSpecializations: 'ownedSpecializations',
+    ref: 'ref'
+} as const;
+
+export function isAspect(item: unknown): item is Aspect {
+    return reflection.isInstance(item, Aspect.$type);
+}
+
+export type Assertion = PropertyValueAssertion | TypeAssertion;
+
+export const Assertion = {
+    $type: 'Assertion'
+} as const;
+
+export function isAssertion(item: unknown): item is Assertion {
+    return reflection.isInstance(item, Assertion.$type);
+}
+
+export type Axiom = EntityEquivalenceAxiom | InstanceEnumerationAxiom | KeyAxiom | LiteralEnumerationAxiom | PropertyEquivalenceAxiom | PropertyRestrictionAxiom | ScalarEquivalenceAxiom | SpecializationAxiom;
+
+export const Axiom = {
+    $type: 'Axiom'
+} as const;
+
+export function isAxiom(item: unknown): item is Axiom {
+    return reflection.isInstance(item, Axiom.$type);
+}
+
+export type BinaryPredicate = DifferentFromPredicate | PropertyPredicate | SameAsPredicate;
+
+export const BinaryPredicate = {
+    $type: 'BinaryPredicate'
+} as const;
+
+export function isBinaryPredicate(item: unknown): item is BinaryPredicate {
+    return reflection.isInstance(item, BinaryPredicate.$type);
+}
+
+export type Boolean = boolean;
+
+export function isBoolean(item: unknown): item is Boolean {
+    return typeof item === 'boolean';
+}
+
+export interface BooleanLiteral extends langium.AstNode {
+    readonly $container: Annotation | Argument | LiteralEnumerationAxiom | PropertyValueAssertion | PropertyValueRestrictionAxiom | ScalarEquivalenceAxiom;
+    readonly $type: 'BooleanLiteral';
+    value: Boolean;
+}
+
+export const BooleanLiteral = {
+    $type: 'BooleanLiteral',
+    value: 'value'
+} as const;
+
+export function isBooleanLiteral(item: unknown): item is BooleanLiteral {
+    return reflection.isInstance(item, BooleanLiteral.$type);
+}
+
+export interface BuiltIn extends langium.AstNode {
+    readonly $container: Vocabulary;
+    readonly $type: 'BuiltIn';
+    name?: string;
+    ownedAnnotations: Array<Annotation>;
+    ref?: langium.Reference<BuiltIn>;
+}
+
+export const BuiltIn = {
+    $type: 'BuiltIn',
+    name: 'name',
+    ownedAnnotations: 'ownedAnnotations',
+    ref: 'ref'
+} as const;
+
+export function isBuiltIn(item: unknown): item is BuiltIn {
+    return reflection.isInstance(item, BuiltIn.$type);
+}
+
+export interface BuiltInPredicate extends langium.AstNode {
+    readonly $container: Rule;
+    readonly $type: 'BuiltInPredicate';
+    arguments: Array<Argument>;
+    builtIn: langium.Reference<BuiltIn>;
+}
+
+export const BuiltInPredicate = {
+    $type: 'BuiltInPredicate',
+    arguments: 'arguments',
+    builtIn: 'builtIn'
+} as const;
+
+export function isBuiltInPredicate(item: unknown): item is BuiltInPredicate {
+    return reflection.isInstance(item, BuiltInPredicate.$type);
+}
+
+export type CardinalityRestrictionKind = 'exactly' | 'max' | 'min';
+
+export function isCardinalityRestrictionKind(item: unknown): item is CardinalityRestrictionKind {
+    return item === 'exactly' || item === 'min' || item === 'max';
+}
+
+export interface Concept extends langium.AstNode {
+    readonly $container: Vocabulary;
+    readonly $type: 'Concept';
+    name?: string;
+    ownedAnnotations: Array<Annotation>;
+    ownedEnumeration?: InstanceEnumerationAxiom;
+    ownedEquivalences: Array<EntityEquivalenceAxiom>;
+    ownedKeys: Array<KeyAxiom>;
+    ownedPropertyRestrictions: Array<PropertyRestrictionAxiom>;
+    ownedSpecializations: Array<SpecializationAxiom>;
+    ref?: langium.Reference<Concept>;
+}
+
+export const Concept = {
+    $type: 'Concept',
+    name: 'name',
+    ownedAnnotations: 'ownedAnnotations',
+    ownedEnumeration: 'ownedEnumeration',
+    ownedEquivalences: 'ownedEquivalences',
+    ownedKeys: 'ownedKeys',
+    ownedPropertyRestrictions: 'ownedPropertyRestrictions',
+    ownedSpecializations: 'ownedSpecializations',
+    ref: 'ref'
+} as const;
+
+export function isConcept(item: unknown): item is Concept {
+    return reflection.isInstance(item, Concept.$type);
+}
+
+export interface ConceptInstance extends langium.AstNode {
+    readonly $container: Description;
+    readonly $type: 'ConceptInstance';
+    name?: string;
+    ownedAnnotations: Array<Annotation>;
+    ownedPropertyValues: Array<PropertyValueAssertion>;
+    ownedTypes: Array<TypeAssertion>;
+    ref?: langium.Reference<ConceptInstance>;
+}
+
+export const ConceptInstance = {
+    $type: 'ConceptInstance',
+    name: 'name',
+    ownedAnnotations: 'ownedAnnotations',
+    ownedPropertyValues: 'ownedPropertyValues',
+    ownedTypes: 'ownedTypes',
+    ref: 'ref'
+} as const;
+
+export function isConceptInstance(item: unknown): item is ConceptInstance {
+    return reflection.isInstance(item, ConceptInstance.$type);
+}
+
+export type CrossRef = string;
+
+export function isCrossRef(item: unknown): item is CrossRef {
+    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 type Decimal = number;
+
+export function isDecimal(item: unknown): item is Decimal {
+    return typeof item === 'number';
+}
+
+export interface DecimalLiteral extends langium.AstNode {
+    readonly $container: Annotation | Argument | LiteralEnumerationAxiom | PropertyValueAssertion | PropertyValueRestrictionAxiom | ScalarEquivalenceAxiom;
+    readonly $type: 'DecimalLiteral';
+    value: Decimal;
+}
+
+export const DecimalLiteral = {
+    $type: 'DecimalLiteral',
+    value: 'value'
+} as const;
+
+export function isDecimalLiteral(item: unknown): item is DecimalLiteral {
+    return reflection.isInstance(item, DecimalLiteral.$type);
+}
+
+export interface Description extends langium.AstNode {
+    readonly $type: 'Description';
+    namespace: string;
+    ownedAnnotations: Array<Annotation>;
+    ownedImports: Array<Import>;
+    ownedStatements: Array<DescriptionStatement>;
+    prefix: string;
+}
+
+export const Description = {
+    $type: 'Description',
+    namespace: 'namespace',
+    ownedAnnotations: 'ownedAnnotations',
+    ownedImports: 'ownedImports',
+    ownedStatements: 'ownedStatements',
+    prefix: 'prefix'
+} as const;
+
+export function isDescription(item: unknown): item is Description {
+    return reflection.isInstance(item, Description.$type);
+}
+
+export type DescriptionBox = Description | DescriptionBundle;
+
+export const DescriptionBox = {
+    $type: 'DescriptionBox'
+} as const;
+
+export function isDescriptionBox(item: unknown): item is DescriptionBox {
+    return reflection.isInstance(item, DescriptionBox.$type);
+}
+
+export interface DescriptionBundle extends langium.AstNode {
+    readonly $type: 'DescriptionBundle';
+    namespace: string;
+    ownedAnnotations: Array<Annotation>;
+    ownedImports: Array<Import>;
+    prefix: string;
+}
+
+export const DescriptionBundle = {
+    $type: 'DescriptionBundle',
+    namespace: 'namespace',
+    ownedAnnotations: 'ownedAnnotations',
+    ownedImports: 'ownedImports',
+    prefix: 'prefix'
+} as const;
+
+export function isDescriptionBundle(item: unknown): item is DescriptionBundle {
+    return reflection.isInstance(item, DescriptionBundle.$type);
+}
+
+export type DescriptionMember = DescriptionStatement;
+
+export const DescriptionMember = {
+    $type: 'DescriptionMember'
+} as const;
+
+export function isDescriptionMember(item: unknown): item is DescriptionMember {
+    return reflection.isInstance(item, DescriptionMember.$type);
+}
+
+export type DescriptionStatement = NamedInstance;
+
+export const DescriptionStatement = {
+    $type: 'DescriptionStatement'
+} as const;
+
+export function isDescriptionStatement(item: unknown): item is DescriptionStatement {
+    return reflection.isInstance(item, DescriptionStatement.$type);
+}
+
+export interface DifferentFromPredicate extends langium.AstNode {
+    readonly $container: Rule;
+    readonly $type: 'DifferentFromPredicate';
+    argument1: Argument;
+    argument2: Argument;
+}
+
+export const DifferentFromPredicate = {
+    $type: 'DifferentFromPredicate',
+    argument1: 'argument1',
+    argument2: 'argument2'
+} as const;
+
+export function isDifferentFromPredicate(item: unknown): item is DifferentFromPredicate {
+    return reflection.isInstance(item, DifferentFromPredicate.$type);
+}
+
+export type Double = number;
+
+export function isDouble(item: unknown): item is Double {
+    return typeof item === 'number';
+}
+
+export interface DoubleLiteral extends langium.AstNode {
+    readonly $container: Annotation | Argument | LiteralEnumerationAxiom | PropertyValueAssertion | PropertyValueRestrictionAxiom | ScalarEquivalenceAxiom;
+    readonly $type: 'DoubleLiteral';
+    value: Double;
+}
+
+export const DoubleLiteral = {
+    $type: 'DoubleLiteral',
+    value: 'value'
+} as const;
+
+export function isDoubleLiteral(item: unknown): item is DoubleLiteral {
+    return reflection.isInstance(item, DoubleLiteral.$type);
+}
+
+export type Element = Annotation | Argument | Assertion | Axiom | IdentifiedElement | Import | Instance | Literal | Predicate;
+
+export const Element = {
+    $type: 'Element'
+} as const;
+
+export function isElement(item: unknown): item is Element {
+    return reflection.isInstance(item, Element.$type);
+}
+
+export type Entity = Aspect | Concept | RelationEntity;
+
+export const Entity = {
+    $type: 'Entity'
+} as const;
+
+export function isEntity(item: unknown): item is Entity {
+    return reflection.isInstance(item, Entity.$type);
+}
+
+export interface EntityEquivalenceAxiom extends langium.AstNode {
+    readonly $container: Aspect | Concept | RelationEntity;
+    readonly $type: 'EntityEquivalenceAxiom';
+    ownedPropertyRestrictions: Array<PropertyRestrictionAxiom>;
+    superTerms: Array<langium.Reference<Entity>>;
+}
+
+export const EntityEquivalenceAxiom = {
+    $type: 'EntityEquivalenceAxiom',
+    ownedPropertyRestrictions: 'ownedPropertyRestrictions',
+    superTerms: 'superTerms'
+} as const;
+
+export function isEntityEquivalenceAxiom(item: unknown): item is EntityEquivalenceAxiom {
+    return reflection.isInstance(item, EntityEquivalenceAxiom.$type);
+}
+
+export type EquivalenceAxiom = EntityEquivalenceAxiom | PropertyEquivalenceAxiom | ScalarEquivalenceAxiom;
+
+export const EquivalenceAxiom = {
+    $type: 'EquivalenceAxiom'
+} as const;
+
+export function isEquivalenceAxiom(item: unknown): item is EquivalenceAxiom {
+    return reflection.isInstance(item, EquivalenceAxiom.$type);
+}
+
+export interface ForwardRelation extends langium.AstNode {
+    readonly $container: RelationEntity;
+    readonly $type: 'ForwardRelation';
+    name: string;
+    ownedAnnotations: Array<Annotation>;
+}
+
+export const ForwardRelation = {
+    $type: 'ForwardRelation',
+    name: 'name',
+    ownedAnnotations: 'ownedAnnotations'
+} as const;
+
+export function isForwardRelation(item: unknown): item is ForwardRelation {
+    return reflection.isInstance(item, ForwardRelation.$type);
+}
+
+export type IdentifiedElement = Member | Ontology;
+
+export const IdentifiedElement = {
+    $type: 'IdentifiedElement'
+} as const;
+
+export function isIdentifiedElement(item: unknown): item is IdentifiedElement {
+    return reflection.isInstance(item, IdentifiedElement.$type);
+}
+
+export interface Import extends langium.AstNode {
+    readonly $container: Description | DescriptionBundle | Vocabulary | VocabularyBundle;
+    readonly $type: 'Import';
+    imported: langium.Reference<Ontology>;
+    kind: ImportKind;
+    prefix?: string;
+}
+
+export const Import = {
+    $type: 'Import',
+    imported: 'imported',
+    kind: 'kind',
+    prefix: 'prefix'
+} as const;
+
+export function isImport(item: unknown): item is Import {
+    return reflection.isInstance(item, Import.$type);
+}
+
+export type ImportKind = 'extends' | 'includes' | 'uses';
+
+export function isImportKind(item: unknown): item is ImportKind {
+    return item === 'extends' || item === 'uses' || item === 'includes';
+}
+
+export type Instance = AnonymousInstance | NamedInstance;
+
+export const Instance = {
+    $type: 'Instance'
+} as const;
+
+export function isInstance(item: unknown): item is Instance {
+    return reflection.isInstance(item, Instance.$type);
+}
+
+export interface InstanceEnumerationAxiom extends langium.AstNode {
+    readonly $container: Concept;
+    readonly $type: 'InstanceEnumerationAxiom';
+    instances: Array<langium.Reference<ConceptInstance>>;
+}
+
+export const InstanceEnumerationAxiom = {
+    $type: 'InstanceEnumerationAxiom',
+    instances: 'instances'
+} as const;
+
+export function isInstanceEnumerationAxiom(item: unknown): item is InstanceEnumerationAxiom {
+    return reflection.isInstance(item, InstanceEnumerationAxiom.$type);
+}
+
+export type Integer = number;
+
+export function isInteger(item: unknown): item is Integer {
+    return typeof item === 'number';
+}
+
+export interface IntegerLiteral extends langium.AstNode {
+    readonly $container: Annotation | Argument | LiteralEnumerationAxiom | PropertyValueAssertion | PropertyValueRestrictionAxiom | ScalarEquivalenceAxiom;
+    readonly $type: 'IntegerLiteral';
+    value: Integer;
+}
+
+export const IntegerLiteral = {
+    $type: 'IntegerLiteral',
+    value: 'value'
+} as const;
+
+export function isIntegerLiteral(item: unknown): item is IntegerLiteral {
+    return reflection.isInstance(item, IntegerLiteral.$type);
+}
+
+export interface KeyAxiom extends langium.AstNode {
+    readonly $container: Aspect | Concept | RelationEntity;
+    readonly $type: 'KeyAxiom';
+    properties: Array<langium.Reference<Property>>;
+}
+
+export const KeyAxiom = {
+    $type: 'KeyAxiom',
+    properties: 'properties'
+} as const;
+
+export function isKeyAxiom(item: unknown): item is KeyAxiom {
+    return reflection.isInstance(item, KeyAxiom.$type);
+}
+
+export type Literal = BooleanLiteral | DecimalLiteral | DoubleLiteral | IntegerLiteral | QuotedLiteral;
+
+export const Literal = {
+    $type: 'Literal'
+} as const;
+
+export function isLiteral(item: unknown): item is Literal {
+    return reflection.isInstance(item, Literal.$type);
+}
+
+export interface LiteralEnumerationAxiom extends langium.AstNode {
+    readonly $container: Scalar;
+    readonly $type: 'LiteralEnumerationAxiom';
+    literals: Array<Literal>;
+}
+
+export const LiteralEnumerationAxiom = {
+    $type: 'LiteralEnumerationAxiom',
+    literals: 'literals'
+} as const;
+
+export function isLiteralEnumerationAxiom(item: unknown): item is LiteralEnumerationAxiom {
+    return reflection.isInstance(item, LiteralEnumerationAxiom.$type);
+}
+
+export type Member = DescriptionMember | Statement | VocabularyMember;
+
+export const Member = {
+    $type: 'Member'
+} as const;
+
+export function isMember(item: unknown): item is Member {
+    return reflection.isInstance(item, Member.$type);
+}
+
+export type NamedInstance = ConceptInstance | RelationInstance;
+
+export const NamedInstance = {
+    $type: 'NamedInstance'
+} as const;
+
+export function isNamedInstance(item: unknown): item is NamedInstance {
+    return reflection.isInstance(item, NamedInstance.$type);
+}
+
+export type Ontology = DescriptionBox | VocabularyBox;
+
+export const Ontology = {
+    $type: 'Ontology'
+} as const;
+
+export function isOntology(item: unknown): item is Ontology {
+    return reflection.isInstance(item, Ontology.$type);
+}
+
+export type Predicate = BinaryPredicate | BuiltInPredicate | UnaryPredicate;
+
+export const Predicate = {
+    $type: 'Predicate'
+} as const;
+
+export function isPredicate(item: unknown): item is Predicate {
+    return reflection.isInstance(item, Predicate.$type);
+}
+
+export type Property = SemanticProperty | SpecializableProperty;
+
+export const Property = {
+    $type: 'Property'
+} as const;
+
+export function isProperty(item: unknown): item is Property {
+    return reflection.isInstance(item, Property.$type);
+}
+
+export interface PropertyCardinalityRestrictionAxiom extends langium.AstNode {
+    readonly $container: Aspect | Concept | EntityEquivalenceAxiom | RelationEntity;
+    readonly $type: 'PropertyCardinalityRestrictionAxiom';
+    cardinality: UnsignedInteger;
+    kind: CardinalityRestrictionKind;
+    property: langium.Reference<SemanticProperty>;
+    range?: langium.Reference<Type>;
+}
+
+export const PropertyCardinalityRestrictionAxiom = {
+    $type: 'PropertyCardinalityRestrictionAxiom',
+    cardinality: 'cardinality',
+    kind: 'kind',
+    property: 'property',
+    range: 'range'
+} as const;
+
+export function isPropertyCardinalityRestrictionAxiom(item: unknown): item is PropertyCardinalityRestrictionAxiom {
+    return reflection.isInstance(item, PropertyCardinalityRestrictionAxiom.$type);
+}
+
+export interface PropertyEquivalenceAxiom extends langium.AstNode {
+    readonly $container: AnnotationProperty | ScalarProperty | UnreifiedRelation;
+    readonly $type: 'PropertyEquivalenceAxiom';
+    superTerms: Array<langium.Reference<Property>>;
+}
+
+export const PropertyEquivalenceAxiom = {
+    $type: 'PropertyEquivalenceAxiom',
+    superTerms: 'superTerms'
+} as const;
+
+export function isPropertyEquivalenceAxiom(item: unknown): item is PropertyEquivalenceAxiom {
+    return reflection.isInstance(item, PropertyEquivalenceAxiom.$type);
+}
+
+export interface PropertyPredicate extends langium.AstNode {
+    readonly $container: Rule;
+    readonly $type: 'PropertyPredicate';
+    argument1: Argument;
+    argument2: Argument;
+    property: langium.Reference<Property>;
+}
+
+export const PropertyPredicate = {
+    $type: 'PropertyPredicate',
+    argument1: 'argument1',
+    argument2: 'argument2',
+    property: 'property'
+} as const;
+
+export function isPropertyPredicate(item: unknown): item is PropertyPredicate {
+    return reflection.isInstance(item, PropertyPredicate.$type);
+}
+
+export interface PropertyRangeRestrictionAxiom extends langium.AstNode {
+    readonly $container: Aspect | Concept | EntityEquivalenceAxiom | RelationEntity;
+    readonly $type: 'PropertyRangeRestrictionAxiom';
+    kind: RangeRestrictionKind;
+    property: langium.Reference<SemanticProperty>;
+    range: langium.Reference<Type>;
+}
+
+export const PropertyRangeRestrictionAxiom = {
+    $type: 'PropertyRangeRestrictionAxiom',
+    kind: 'kind',
+    property: 'property',
+    range: 'range'
+} as const;
+
+export function isPropertyRangeRestrictionAxiom(item: unknown): item is PropertyRangeRestrictionAxiom {
+    return reflection.isInstance(item, PropertyRangeRestrictionAxiom.$type);
+}
+
+export type PropertyRestrictionAxiom = PropertyCardinalityRestrictionAxiom | PropertyRangeRestrictionAxiom | PropertySelfRestrictionAxiom | PropertyValueRestrictionAxiom;
+
+export const PropertyRestrictionAxiom = {
+    $type: 'PropertyRestrictionAxiom'
+} as const;
+
+export function isPropertyRestrictionAxiom(item: unknown): item is PropertyRestrictionAxiom {
+    return reflection.isInstance(item, PropertyRestrictionAxiom.$type);
+}
+
+export interface PropertySelfRestrictionAxiom extends langium.AstNode {
+    readonly $container: Aspect | Concept | EntityEquivalenceAxiom | RelationEntity;
+    readonly $type: 'PropertySelfRestrictionAxiom';
+    property: langium.Reference<SemanticProperty>;
+}
+
+export const PropertySelfRestrictionAxiom = {
+    $type: 'PropertySelfRestrictionAxiom',
+    property: 'property'
+} as const;
+
+export function isPropertySelfRestrictionAxiom(item: unknown): item is PropertySelfRestrictionAxiom {
+    return reflection.isInstance(item, PropertySelfRestrictionAxiom.$type);
+}
+
+export interface PropertyValueAssertion extends langium.AstNode {
+    readonly $container: AnonymousConceptInstance | AnonymousRelationInstance | ConceptInstance | RelationInstance;
+    readonly $type: 'PropertyValueAssertion';
+    containedValues: Array<AnonymousInstance>;
+    literalValues: Array<Literal>;
+    property: langium.Reference<SemanticProperty>;
+    referencedValues: Array<langium.Reference<NamedInstance>>;
+}
+
+export const PropertyValueAssertion = {
+    $type: 'PropertyValueAssertion',
+    containedValues: 'containedValues',
+    literalValues: 'literalValues',
+    property: 'property',
+    referencedValues: 'referencedValues'
+} as const;
+
+export function isPropertyValueAssertion(item: unknown): item is PropertyValueAssertion {
+    return reflection.isInstance(item, PropertyValueAssertion.$type);
+}
+
+export interface PropertyValueRestrictionAxiom extends langium.AstNode {
+    readonly $container: Aspect | Concept | EntityEquivalenceAxiom | RelationEntity;
+    readonly $type: 'PropertyValueRestrictionAxiom';
+    containedValue?: AnonymousInstance;
+    literalValue?: Literal;
+    property: langium.Reference<SemanticProperty>;
+    referencedValue?: langium.Reference<NamedInstance>;
+}
+
+export const PropertyValueRestrictionAxiom = {
+    $type: 'PropertyValueRestrictionAxiom',
+    containedValue: 'containedValue',
+    literalValue: 'literalValue',
+    property: 'property',
+    referencedValue: 'referencedValue'
+} as const;
+
+export function isPropertyValueRestrictionAxiom(item: unknown): item is PropertyValueRestrictionAxiom {
+    return reflection.isInstance(item, PropertyValueRestrictionAxiom.$type);
+}
+
+export interface QuotedLiteral extends langium.AstNode {
+    readonly $container: Annotation | Argument | LiteralEnumerationAxiom | PropertyValueAssertion | PropertyValueRestrictionAxiom | ScalarEquivalenceAxiom;
+    readonly $type: 'QuotedLiteral';
+    langTag?: string;
+    type?: langium.Reference<Scalar>;
+    value: string;
+}
+
+export const QuotedLiteral = {
+    $type: 'QuotedLiteral',
+    langTag: 'langTag',
+    type: 'type',
+    value: 'value'
+} as const;
+
+export function isQuotedLiteral(item: unknown): item is QuotedLiteral {
+    return reflection.isInstance(item, QuotedLiteral.$type);
+}
+
+export type RangeRestrictionKind = 'all' | 'some';
+
+export function isRangeRestrictionKind(item: unknown): item is RangeRestrictionKind {
+    return item === 'all' || item === 'some';
+}
+
+export type Ref = string;
+
+export function isRef(item: unknown): item is Ref {
+    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 type Relation = ForwardRelation | ReverseRelation | UnreifiedRelation;
+
+export const Relation = {
+    $type: 'Relation'
+} as const;
+
+export function isRelation(item: unknown): item is Relation {
+    return reflection.isInstance(item, Relation.$type);
+}
+
+export type RelationBase = RelationEntity | UnreifiedRelation;
+
+export const RelationBase = {
+    $type: 'RelationBase'
+} as const;
+
+export function isRelationBase(item: unknown): item is RelationBase {
+    return reflection.isInstance(item, RelationBase.$type);
+}
+
+export interface RelationEntity extends langium.AstNode {
+    readonly $container: Vocabulary;
+    readonly $type: 'RelationEntity';
+    asymmetric: boolean;
+    forwardRelation?: ForwardRelation;
+    functional: boolean;
+    inverseFunctional: boolean;
+    irreflexive: boolean;
+    name?: string;
+    ownedAnnotations: Array<Annotation>;
+    ownedEquivalences: Array<EntityEquivalenceAxiom>;
+    ownedKeys: Array<KeyAxiom>;
+    ownedPropertyRestrictions: Array<PropertyRestrictionAxiom>;
+    ownedSpecializations: Array<SpecializationAxiom>;
+    ref?: langium.Reference<RelationEntity>;
+    reflexive: boolean;
+    reverseRelation?: ReverseRelation;
+    sources: Array<langium.Reference<Entity>>;
+    symmetric: boolean;
+    targets: Array<langium.Reference<Entity>>;
+    transitive: boolean;
+}
+
+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'
+} as const;
+
+export function isRelationEntity(item: unknown): item is RelationEntity {
+    return reflection.isInstance(item, RelationEntity.$type);
+}
+
+export interface RelationEntityPredicate extends langium.AstNode {
+    readonly $container: Rule;
+    readonly $type: 'RelationEntityPredicate';
+    argument: Argument;
+    argument1: Argument;
+    argument2: Argument;
+    type: langium.Reference<RelationEntity>;
+}
+
+export const RelationEntityPredicate = {
+    $type: 'RelationEntityPredicate',
+    argument: 'argument',
+    argument1: 'argument1',
+    argument2: 'argument2',
+    type: 'type'
+} as const;
+
+export function isRelationEntityPredicate(item: unknown): item is RelationEntityPredicate {
+    return reflection.isInstance(item, RelationEntityPredicate.$type);
+}
+
+export interface RelationInstance extends langium.AstNode {
+    readonly $container: Description;
+    readonly $type: 'RelationInstance';
+    name?: string;
+    ownedAnnotations: Array<Annotation>;
+    ownedPropertyValues: Array<PropertyValueAssertion>;
+    ownedTypes: Array<TypeAssertion>;
+    ref?: langium.Reference<RelationInstance>;
+    sources: Array<langium.Reference<NamedInstance>>;
+    targets: Array<langium.Reference<NamedInstance>>;
+}
+
+export const RelationInstance = {
+    $type: 'RelationInstance',
+    name: 'name',
+    ownedAnnotations: 'ownedAnnotations',
+    ownedPropertyValues: 'ownedPropertyValues',
+    ownedTypes: 'ownedTypes',
+    ref: 'ref',
+    sources: 'sources',
+    targets: 'targets'
+} as const;
+
+export function isRelationInstance(item: unknown): item is RelationInstance {
+    return reflection.isInstance(item, RelationInstance.$type);
+}
+
+export interface ReverseRelation extends langium.AstNode {
+    readonly $container: RelationEntity | UnreifiedRelation;
+    readonly $type: 'ReverseRelation';
+    name: string;
+    ownedAnnotations: Array<Annotation>;
+}
+
+export const ReverseRelation = {
+    $type: 'ReverseRelation',
+    name: 'name',
+    ownedAnnotations: 'ownedAnnotations'
+} as const;
+
+export function isReverseRelation(item: unknown): item is ReverseRelation {
+    return reflection.isInstance(item, ReverseRelation.$type);
+}
+
+export interface Rule extends langium.AstNode {
+    readonly $container: Vocabulary;
+    readonly $type: 'Rule';
+    antecedent: Array<Predicate>;
+    consequent: Array<Predicate>;
+    name?: string;
+    ownedAnnotations: Array<Annotation>;
+    ref?: langium.Reference<Rule>;
+}
+
+export const Rule = {
+    $type: 'Rule',
+    antecedent: 'antecedent',
+    consequent: 'consequent',
+    name: 'name',
+    ownedAnnotations: 'ownedAnnotations',
+    ref: 'ref'
+} as const;
+
+export function isRule(item: unknown): item is Rule {
+    return reflection.isInstance(item, Rule.$type);
+}
+
+export interface SameAsPredicate extends langium.AstNode {
+    readonly $container: Rule;
+    readonly $type: 'SameAsPredicate';
+    argument1: Argument;
+    argument2: Argument;
+}
+
+export const SameAsPredicate = {
+    $type: 'SameAsPredicate',
+    argument1: 'argument1',
+    argument2: 'argument2'
+} as const;
+
+export function isSameAsPredicate(item: unknown): item is SameAsPredicate {
+    return reflection.isInstance(item, SameAsPredicate.$type);
+}
+
+export interface Scalar extends langium.AstNode {
+    readonly $container: Vocabulary;
+    readonly $type: 'Scalar';
+    name?: string;
+    ownedAnnotations: Array<Annotation>;
+    ownedEnumeration?: LiteralEnumerationAxiom;
+    ownedEquivalences: Array<ScalarEquivalenceAxiom>;
+    ownedSpecializations: Array<SpecializationAxiom>;
+    ref?: langium.Reference<Scalar>;
+}
+
+export const Scalar = {
+    $type: 'Scalar',
+    name: 'name',
+    ownedAnnotations: 'ownedAnnotations',
+    ownedEnumeration: 'ownedEnumeration',
+    ownedEquivalences: 'ownedEquivalences',
+    ownedSpecializations: 'ownedSpecializations',
+    ref: 'ref'
+} as const;
+
+export function isScalar(item: unknown): item is Scalar {
+    return reflection.isInstance(item, Scalar.$type);
+}
+
+export interface ScalarEquivalenceAxiom extends langium.AstNode {
+    readonly $container: Scalar;
+    readonly $type: 'ScalarEquivalenceAxiom';
+    language: Array<string>;
+    length: Array<UnsignedInteger>;
+    maxExclusive: Array<Literal>;
+    maxInclusive: Array<Literal>;
+    maxLength: Array<UnsignedInteger>;
+    minExclusive: Array<Literal>;
+    minInclusive: Array<Literal>;
+    minLength: Array<UnsignedInteger>;
+    pattern: Array<string>;
+    superTerms: Array<langium.Reference<Scalar>>;
+}
+
+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'
+} as const;
+
+export function isScalarEquivalenceAxiom(item: unknown): item is ScalarEquivalenceAxiom {
+    return reflection.isInstance(item, ScalarEquivalenceAxiom.$type);
+}
+
+export interface ScalarProperty extends langium.AstNode {
+    readonly $container: Vocabulary;
+    readonly $type: 'ScalarProperty';
+    domains: Array<langium.Reference<Entity>>;
+    functional: boolean;
+    name?: string;
+    ownedAnnotations: Array<Annotation>;
+    ownedEquivalences: Array<PropertyEquivalenceAxiom>;
+    ownedSpecializations: Array<SpecializationAxiom>;
+    ranges: Array<langium.Reference<Scalar>>;
+    ref?: langium.Reference<ScalarProperty>;
+}
+
+export const ScalarProperty = {
+    $type: 'ScalarProperty',
+    domains: 'domains',
+    functional: 'functional',
+    name: 'name',
+    ownedAnnotations: 'ownedAnnotations',
+    ownedEquivalences: 'ownedEquivalences',
+    ownedSpecializations: 'ownedSpecializations',
+    ranges: 'ranges',
+    ref: 'ref'
+} as const;
+
+export function isScalarProperty(item: unknown): item is ScalarProperty {
+    return reflection.isInstance(item, ScalarProperty.$type);
+}
+
+export type SemanticProperty = Relation | ScalarProperty;
+
+export const SemanticProperty = {
+    $type: 'SemanticProperty'
+} as const;
+
+export function isSemanticProperty(item: unknown): item is SemanticProperty {
+    return reflection.isInstance(item, SemanticProperty.$type);
+}
+
+export type SpecializableProperty = AnnotationProperty | ScalarProperty | UnreifiedRelation;
+
+export const SpecializableProperty = {
+    $type: 'SpecializableProperty'
+} as const;
+
+export function isSpecializableProperty(item: unknown): item is SpecializableProperty {
+    return reflection.isInstance(item, SpecializableProperty.$type);
+}
+
+export type SpecializableTerm = SpecializableProperty | Type;
+
+export const SpecializableTerm = {
+    $type: 'SpecializableTerm'
+} as const;
+
+export function isSpecializableTerm(item: unknown): item is SpecializableTerm {
+    return reflection.isInstance(item, SpecializableTerm.$type);
+}
+
+export interface SpecializationAxiom extends langium.AstNode {
+    readonly $container: AnnotationProperty | Aspect | Concept | RelationEntity | Scalar | ScalarProperty | UnreifiedRelation;
+    readonly $type: 'SpecializationAxiom';
+    superTerm: langium.Reference<Term>;
+}
+
+export const SpecializationAxiom = {
+    $type: 'SpecializationAxiom',
+    superTerm: 'superTerm'
+} as const;
+
+export function isSpecializationAxiom(item: unknown): item is SpecializationAxiom {
+    return reflection.isInstance(item, SpecializationAxiom.$type);
+}
+
+export type Statement = DescriptionStatement | VocabularyStatement;
+
+export const Statement = {
+    $type: 'Statement'
+} as const;
+
+export function isStatement(item: unknown): item is Statement {
+    return reflection.isInstance(item, Statement.$type);
+}
+
+export type Term = Property | RelationBase | SpecializableTerm;
+
+export const Term = {
+    $type: 'Term'
+} as const;
+
+export function isTerm(item: unknown): item is Term {
+    return reflection.isInstance(item, Term.$type);
+}
+
+export type Type = Entity | Scalar;
+
+export const Type = {
+    $type: 'Type'
+} as const;
+
+export function isType(item: unknown): item is Type {
+    return reflection.isInstance(item, Type.$type);
+}
+
+export interface TypeAssertion extends langium.AstNode {
+    readonly $container: ConceptInstance | RelationInstance;
+    readonly $type: 'TypeAssertion';
+    type: langium.Reference<Entity>;
+}
+
+export const TypeAssertion = {
+    $type: 'TypeAssertion',
+    type: 'type'
+} as const;
+
+export function isTypeAssertion(item: unknown): item is TypeAssertion {
+    return reflection.isInstance(item, TypeAssertion.$type);
+}
+
+export interface TypePredicate extends langium.AstNode {
+    readonly $container: Rule;
+    readonly $type: 'TypePredicate';
+    argument: Argument;
+    type: langium.Reference<Type>;
+}
+
+export const TypePredicate = {
+    $type: 'TypePredicate',
+    argument: 'argument',
+    type: 'type'
+} as const;
+
+export function isTypePredicate(item: unknown): item is TypePredicate {
+    return reflection.isInstance(item, TypePredicate.$type);
+}
+
+export type UnaryPredicate = RelationEntityPredicate | TypePredicate;
+
+export const UnaryPredicate = {
+    $type: 'UnaryPredicate'
+} as const;
+
+export function isUnaryPredicate(item: unknown): item is UnaryPredicate {
+    return reflection.isInstance(item, UnaryPredicate.$type);
+}
+
+export interface UnreifiedRelation extends langium.AstNode {
+    readonly $container: Vocabulary;
+    readonly $type: 'UnreifiedRelation';
+    asymmetric: boolean;
+    functional: boolean;
+    inverseFunctional: boolean;
+    irreflexive: boolean;
+    name?: string;
+    ownedAnnotations: Array<Annotation>;
+    ownedEquivalences: Array<PropertyEquivalenceAxiom>;
+    ownedSpecializations: Array<SpecializationAxiom>;
+    ref?: langium.Reference<Relation>;
+    reflexive: boolean;
+    reverseRelation?: ReverseRelation;
+    sources: Array<langium.Reference<Entity>>;
+    symmetric: boolean;
+    targets: Array<langium.Reference<Entity>>;
+    transitive: boolean;
+}
+
+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'
+} as const;
+
+export function isUnreifiedRelation(item: unknown): item is UnreifiedRelation {
+    return reflection.isInstance(item, UnreifiedRelation.$type);
+}
+
+export type UnsignedInteger = number;
+
+export function isUnsignedInteger(item: unknown): item is UnsignedInteger {
+    return typeof item === 'number';
+}
+
+export interface Vocabulary extends langium.AstNode {
+    readonly $type: 'Vocabulary';
+    namespace: string;
+    ownedAnnotations: Array<Annotation>;
+    ownedImports: Array<Import>;
+    ownedStatements: Array<VocabularyStatement>;
+    prefix: string;
+}
+
+export const Vocabulary = {
+    $type: 'Vocabulary',
+    namespace: 'namespace',
+    ownedAnnotations: 'ownedAnnotations',
+    ownedImports: 'ownedImports',
+    ownedStatements: 'ownedStatements',
+    prefix: 'prefix'
+} as const;
+
+export function isVocabulary(item: unknown): item is Vocabulary {
+    return reflection.isInstance(item, Vocabulary.$type);
+}
+
+export type VocabularyBox = Vocabulary | VocabularyBundle;
+
+export const VocabularyBox = {
+    $type: 'VocabularyBox'
+} as const;
+
+export function isVocabularyBox(item: unknown): item is VocabularyBox {
+    return reflection.isInstance(item, VocabularyBox.$type);
+}
+
+export interface VocabularyBundle extends langium.AstNode {
+    readonly $type: 'VocabularyBundle';
+    namespace: string;
+    ownedAnnotations: Array<Annotation>;
+    ownedImports: Array<Import>;
+    prefix: string;
+}
+
+export const VocabularyBundle = {
+    $type: 'VocabularyBundle',
+    namespace: 'namespace',
+    ownedAnnotations: 'ownedAnnotations',
+    ownedImports: 'ownedImports',
+    prefix: 'prefix'
+} as const;
+
+export function isVocabularyBundle(item: unknown): item is VocabularyBundle {
+    return reflection.isInstance(item, VocabularyBundle.$type);
+}
+
+export type VocabularyMember = Term | VocabularyStatement;
+
+export const VocabularyMember = {
+    $type: 'VocabularyMember'
+} as const;
+
+export function isVocabularyMember(item: unknown): item is VocabularyMember {
+    return reflection.isInstance(item, VocabularyMember.$type);
+}
+
+export type VocabularyStatement = BuiltIn | Rule | SpecializableTerm;
+
+export const VocabularyStatement = {
+    $type: 'VocabularyStatement'
+} as const;
+
+export function isVocabularyStatement(item: unknown): item is VocabularyStatement {
+    return reflection.isInstance(item, VocabularyStatement.$type);
+}
+
+export type OmlAstType = {
+    Annotation: Annotation
+    AnnotationProperty: AnnotationProperty
+    AnonymousConceptInstance: AnonymousConceptInstance
+    AnonymousInstance: AnonymousInstance
+    AnonymousRelationInstance: AnonymousRelationInstance
+    Argument: Argument
+    Aspect: Aspect
+    Assertion: Assertion
+    Axiom: Axiom
+    BinaryPredicate: BinaryPredicate
+    BooleanLiteral: BooleanLiteral
+    BuiltIn: BuiltIn
+    BuiltInPredicate: BuiltInPredicate
+    Concept: Concept
+    ConceptInstance: ConceptInstance
+    DecimalLiteral: DecimalLiteral
+    Description: Description
+    DescriptionBox: DescriptionBox
+    DescriptionBundle: DescriptionBundle
+    DescriptionMember: DescriptionMember
+    DescriptionStatement: DescriptionStatement
+    DifferentFromPredicate: DifferentFromPredicate
+    DoubleLiteral: DoubleLiteral
+    Element: Element
+    Entity: Entity
+    EntityEquivalenceAxiom: EntityEquivalenceAxiom
+    EquivalenceAxiom: EquivalenceAxiom
+    ForwardRelation: ForwardRelation
+    IdentifiedElement: IdentifiedElement
+    Import: Import
+    Instance: Instance
+    InstanceEnumerationAxiom: InstanceEnumerationAxiom
+    IntegerLiteral: IntegerLiteral
+    KeyAxiom: KeyAxiom
+    Literal: Literal
+    LiteralEnumerationAxiom: LiteralEnumerationAxiom
+    Member: Member
+    NamedInstance: NamedInstance
+    Ontology: Ontology
+    Predicate: Predicate
+    Property: Property
+    PropertyCardinalityRestrictionAxiom: PropertyCardinalityRestrictionAxiom
+    PropertyEquivalenceAxiom: PropertyEquivalenceAxiom
+    PropertyPredicate: PropertyPredicate
+    PropertyRangeRestrictionAxiom: PropertyRangeRestrictionAxiom
+    PropertyRestrictionAxiom: PropertyRestrictionAxiom
+    PropertySelfRestrictionAxiom: PropertySelfRestrictionAxiom
+    PropertyValueAssertion: PropertyValueAssertion
+    PropertyValueRestrictionAxiom: PropertyValueRestrictionAxiom
+    QuotedLiteral: QuotedLiteral
+    Relation: Relation
+    RelationBase: RelationBase
+    RelationEntity: RelationEntity
+    RelationEntityPredicate: RelationEntityPredicate
+    RelationInstance: RelationInstance
+    ReverseRelation: ReverseRelation
+    Rule: Rule
+    SameAsPredicate: SameAsPredicate
+    Scalar: Scalar
+    ScalarEquivalenceAxiom: ScalarEquivalenceAxiom
+    ScalarProperty: ScalarProperty
+    SemanticProperty: SemanticProperty
+    SpecializableProperty: SpecializableProperty
+    SpecializableTerm: SpecializableTerm
+    SpecializationAxiom: SpecializationAxiom
+    Statement: Statement
+    Term: Term
+    Type: Type
+    TypeAssertion: TypeAssertion
+    TypePredicate: TypePredicate
+    UnaryPredicate: UnaryPredicate
+    UnreifiedRelation: UnreifiedRelation
+    Vocabulary: Vocabulary
+    VocabularyBox: VocabularyBox
+    VocabularyBundle: VocabularyBundle
+    VocabularyMember: VocabularyMember
+    VocabularyStatement: VocabularyStatement
+}
+
+export class OmlAstReflection extends langium.AbstractAstReflection {
+    override readonly 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]
+        }
+    } as const satisfies langium.AstMetaData
+}
+
+export const reflection = new OmlAstReflection();