@oml/language 0.7.0

package/out/oml/generated/ast.d.ts

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