@oml/language 0.18.0 → 0.19.0

package/src/oml/generated/ast.ts

@@ -49,6 +49,7 @@ export type OmlKeywordNames =
     | "concept"
     | "description"
     | "differentFrom"
+    | "dimension"
     | "domain"
     | "entity"
     | "exactly"
@@ -67,13 +68,16 @@ export type OmlKeywordNames =
     | "maxExclusive"
     | "maxInclusive"
     | "maxLength"
+    | "measures"
     | "min"
     | "minExclusive"
     | "minInclusive"
     | "minLength"
+    | "multiplier"
     | "oneOf"
     | "pattern"
     | "property"
+    | "quantity"
     | "range"
     | "ref"
     | "reflexive"
@@ -85,9 +89,11 @@ export type OmlKeywordNames =
     | "scalar"
     | "self"
     | "some"
+    | "symbol"
     | "symmetric"
     | "to"
     | "transitive"
+    | "unit"
     | "uses"
     | "vocabulary"
     | "{"
@@ -96,7 +102,7 @@ export type OmlKeywordNames =
 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 $container: AnnotationProperty | Aspect | BuiltIn | Concept | ConceptInstance | Description | DescriptionBundle | ForwardRelation | Quantity | QuantityProperty | RelationEntity | RelationInstance | ReverseRelation | Rule | Scalar | ScalarProperty | Unit | UnreifiedRelation | Vocabulary | VocabularyBundle;
     readonly $type: 'Annotation';
     literalValues: Array<Literal>;
     property: langium.Reference<AnnotationProperty>;
@@ -387,11 +393,13 @@ export function isDecimal(item: unknown): item is Decimal {
 export interface DecimalLiteral extends langium.AstNode {
     readonly $container: Annotation | Argument | LiteralEnumerationAxiom | PropertyValueAssertion | PropertyValueRestrictionAxiom | ScalarEquivalenceAxiom;
     readonly $type: 'DecimalLiteral';
+    unit?: langium.Reference<Unit>;
     value: Decimal;
 }
 
 export const DecimalLiteral = {
     $type: 'DecimalLiteral',
+    unit: 'unit',
     value: 'value'
 } as const;
 
@@ -497,11 +505,13 @@ export function isDouble(item: unknown): item is Double {
 export interface DoubleLiteral extends langium.AstNode {
     readonly $container: Annotation | Argument | LiteralEnumerationAxiom | PropertyValueAssertion | PropertyValueRestrictionAxiom | ScalarEquivalenceAxiom;
     readonly $type: 'DoubleLiteral';
+    unit?: langium.Reference<Unit>;
     value: Double;
 }
 
 export const DoubleLiteral = {
     $type: 'DoubleLiteral',
+    unit: 'unit',
     value: 'value'
 } as const;
 
@@ -642,11 +652,13 @@ export function isInteger(item: unknown): item is Integer {
 export interface IntegerLiteral extends langium.AstNode {
     readonly $container: Annotation | Argument | LiteralEnumerationAxiom | PropertyValueAssertion | PropertyValueRestrictionAxiom | ScalarEquivalenceAxiom;
     readonly $type: 'IntegerLiteral';
+    unit?: langium.Reference<Unit>;
     value: Integer;
 }
 
 export const IntegerLiteral = {
     $type: 'IntegerLiteral',
+    unit: 'unit',
     value: 'value'
 } as const;
 
@@ -766,7 +778,7 @@ export function isPropertyCardinalityRestrictionAxiom(item: unknown): item is Pr
 }
 
 export interface PropertyEquivalenceAxiom extends langium.AstNode {
-    readonly $container: AnnotationProperty | ScalarProperty | UnreifiedRelation;
+    readonly $container: AnnotationProperty | QuantityProperty | ScalarProperty | UnreifiedRelation;
     readonly $type: 'PropertyEquivalenceAxiom';
     superTerms: Array<langium.Reference<Property>>;
 }
@@ -885,6 +897,56 @@ export function isPropertyValueRestrictionAxiom(item: unknown): item is Property
     return reflection.isInstance(item, PropertyValueRestrictionAxiom.$type);
 }
 
+export interface Quantity extends langium.AstNode {
+    readonly $container: Vocabulary;
+    readonly $type: 'Quantity';
+    dimension?: string;
+    name?: string;
+    ownedAnnotations: Array<Annotation>;
+    ref?: langium.Reference<Quantity>;
+}
+
+export const Quantity = {
+    $type: 'Quantity',
+    dimension: 'dimension',
+    name: 'name',
+    ownedAnnotations: 'ownedAnnotations',
+    ref: 'ref'
+} as const;
+
+export function isQuantity(item: unknown): item is Quantity {
+    return reflection.isInstance(item, Quantity.$type);
+}
+
+export interface QuantityProperty extends langium.AstNode {
+    readonly $container: Vocabulary;
+    readonly $type: 'QuantityProperty';
+    domains: Array<langium.Reference<Entity>>;
+    functional: boolean;
+    kind: Array<langium.Reference<Quantity>>;
+    name?: string;
+    ownedAnnotations: Array<Annotation>;
+    ownedEquivalences: Array<PropertyEquivalenceAxiom>;
+    ownedSpecializations: Array<SpecializationAxiom>;
+    ref?: langium.Reference<QuantityProperty>;
+}
+
+export const QuantityProperty = {
+    $type: 'QuantityProperty',
+    domains: 'domains',
+    functional: 'functional',
+    kind: 'kind',
+    name: 'name',
+    ownedAnnotations: 'ownedAnnotations',
+    ownedEquivalences: 'ownedEquivalences',
+    ownedSpecializations: 'ownedSpecializations',
+    ref: 'ref'
+} as const;
+
+export function isQuantityProperty(item: unknown): item is QuantityProperty {
+    return reflection.isInstance(item, QuantityProperty.$type);
+}
+
 export interface QuotedLiteral extends langium.AstNode {
     readonly $container: Annotation | Argument | LiteralEnumerationAxiom | PropertyValueAssertion | PropertyValueRestrictionAxiom | ScalarEquivalenceAxiom;
     readonly $type: 'QuotedLiteral';
@@ -1177,7 +1239,7 @@ export function isScalarProperty(item: unknown): item is ScalarProperty {
     return reflection.isInstance(item, ScalarProperty.$type);
 }
 
-export type SemanticProperty = Relation | ScalarProperty;
+export type SemanticProperty = QuantityProperty | Relation | ScalarProperty;
 
 export const SemanticProperty = {
     $type: 'SemanticProperty'
@@ -1187,7 +1249,7 @@ export function isSemanticProperty(item: unknown): item is SemanticProperty {
     return reflection.isInstance(item, SemanticProperty.$type);
 }
 
-export type SpecializableProperty = AnnotationProperty | ScalarProperty | UnreifiedRelation;
+export type SpecializableProperty = AnnotationProperty | QuantityProperty | ScalarProperty | UnreifiedRelation;
 
 export const SpecializableProperty = {
     $type: 'SpecializableProperty'
@@ -1208,7 +1270,7 @@ export function isSpecializableTerm(item: unknown): item is SpecializableTerm {
 }
 
 export interface SpecializationAxiom extends langium.AstNode {
-    readonly $container: AnnotationProperty | Aspect | Concept | RelationEntity | Scalar | ScalarProperty | UnreifiedRelation;
+    readonly $container: AnnotationProperty | Aspect | Concept | QuantityProperty | RelationEntity | Scalar | ScalarProperty | UnreifiedRelation;
     readonly $type: 'SpecializationAxiom';
     superTerm: langium.Reference<Term>;
 }
@@ -1232,7 +1294,7 @@ export function isStatement(item: unknown): item is Statement {
     return reflection.isInstance(item, Statement.$type);
 }
 
-export type Term = Property | RelationBase | SpecializableTerm;
+export type Term = Property | Quantity | RelationBase | SpecializableTerm | Unit;
 
 export const Term = {
     $type: 'Term'
@@ -1294,6 +1356,31 @@ export function isUnaryPredicate(item: unknown): item is UnaryPredicate {
     return reflection.isInstance(item, UnaryPredicate.$type);
 }
 
+export interface Unit extends langium.AstNode {
+    readonly $container: Vocabulary;
+    readonly $type: 'Unit';
+    kinds: Array<langium.Reference<Quantity>>;
+    multiplier: Array<Decimal>;
+    name?: string;
+    ownedAnnotations: Array<Annotation>;
+    ref?: langium.Reference<Unit>;
+    symbol: Array<string>;
+}
+
+export const Unit = {
+    $type: 'Unit',
+    kinds: 'kinds',
+    multiplier: 'multiplier',
+    name: 'name',
+    ownedAnnotations: 'ownedAnnotations',
+    ref: 'ref',
+    symbol: 'symbol'
+} as const;
+
+export function isUnit(item: unknown): item is Unit {
+    return reflection.isInstance(item, Unit.$type);
+}
+
 export interface UnreifiedRelation extends langium.AstNode {
     readonly $container: Vocabulary;
     readonly $type: 'UnreifiedRelation';
@@ -1405,7 +1492,7 @@ export function isVocabularyMember(item: unknown): item is VocabularyMember {
     return reflection.isInstance(item, VocabularyMember.$type);
 }
 
-export type VocabularyStatement = BuiltIn | Rule | SpecializableTerm;
+export type VocabularyStatement = BuiltIn | Quantity | Rule | SpecializableTerm | Unit;
 
 export const VocabularyStatement = {
     $type: 'VocabularyStatement'
@@ -1465,6 +1552,8 @@ export type OmlAstType = {
     PropertySelfRestrictionAxiom: PropertySelfRestrictionAxiom
     PropertyValueAssertion: PropertyValueAssertion
     PropertyValueRestrictionAxiom: PropertyValueRestrictionAxiom
+    Quantity: Quantity
+    QuantityProperty: QuantityProperty
     QuotedLiteral: QuotedLiteral
     Relation: Relation
     RelationBase: RelationBase
@@ -1487,6 +1576,7 @@ export type OmlAstType = {
     TypeAssertion: TypeAssertion
     TypePredicate: TypePredicate
     UnaryPredicate: UnaryPredicate
+    Unit: Unit
     UnreifiedRelation: UnreifiedRelation
     Vocabulary: Vocabulary
     VocabularyBox: VocabularyBox
@@ -1746,6 +1836,10 @@ export class OmlAstReflection extends langium.AbstractAstReflection {
         DecimalLiteral: {
             name: DecimalLiteral.$type,
             properties: {
+                unit: {
+                    name: DecimalLiteral.unit,
+                    referenceType: Unit.$type
+                },
                 value: {
                     name: DecimalLiteral.value
                 }
@@ -1829,6 +1923,10 @@ export class OmlAstReflection extends langium.AbstractAstReflection {
         DoubleLiteral: {
             name: DoubleLiteral.$type,
             properties: {
+                unit: {
+                    name: DoubleLiteral.unit,
+                    referenceType: Unit.$type
+                },
                 value: {
                     name: DoubleLiteral.value
                 }
@@ -1923,6 +2021,10 @@ export class OmlAstReflection extends langium.AbstractAstReflection {
         IntegerLiteral: {
             name: IntegerLiteral.$type,
             properties: {
+                unit: {
+                    name: IntegerLiteral.unit,
+                    referenceType: Unit.$type
+                },
                 value: {
                     name: IntegerLiteral.value
                 }
@@ -2109,6 +2211,65 @@ export class OmlAstReflection extends langium.AbstractAstReflection {
             },
             superTypes: [PropertyRestrictionAxiom.$type]
         },
+        Quantity: {
+            name: Quantity.$type,
+            properties: {
+                dimension: {
+                    name: Quantity.dimension
+                },
+                name: {
+                    name: Quantity.name
+                },
+                ownedAnnotations: {
+                    name: Quantity.ownedAnnotations,
+                    defaultValue: []
+                },
+                ref: {
+                    name: Quantity.ref,
+                    referenceType: Quantity.$type
+                }
+            },
+            superTypes: [Term.$type, VocabularyStatement.$type]
+        },
+        QuantityProperty: {
+            name: QuantityProperty.$type,
+            properties: {
+                domains: {
+                    name: QuantityProperty.domains,
+                    defaultValue: [],
+                    referenceType: Entity.$type
+                },
+                functional: {
+                    name: QuantityProperty.functional,
+                    defaultValue: false
+                },
+                kind: {
+                    name: QuantityProperty.kind,
+                    defaultValue: [],
+                    referenceType: Quantity.$type
+                },
+                name: {
+                    name: QuantityProperty.name
+                },
+                ownedAnnotations: {
+                    name: QuantityProperty.ownedAnnotations,
+                    defaultValue: []
+                },
+                ownedEquivalences: {
+                    name: QuantityProperty.ownedEquivalences,
+                    defaultValue: []
+                },
+                ownedSpecializations: {
+                    name: QuantityProperty.ownedSpecializations,
+                    defaultValue: []
+                },
+                ref: {
+                    name: QuantityProperty.ref,
+                    referenceType: QuantityProperty.$type
+                }
+            },
+            superTypes: [SemanticProperty.$type, SpecializableProperty.$type]
+        },
         QuotedLiteral: {
             name: QuotedLiteral.$type,
             properties: {
@@ -2507,6 +2668,36 @@ export class OmlAstReflection extends langium.AbstractAstReflection {
             },
             superTypes: [Predicate.$type]
         },
+        Unit: {
+            name: Unit.$type,
+            properties: {
+                kinds: {
+                    name: Unit.kinds,
+                    defaultValue: [],
+                    referenceType: Quantity.$type
+                },
+                multiplier: {
+                    name: Unit.multiplier,
+                    defaultValue: []
+                },
+                name: {
+                    name: Unit.name
+                },
+                ownedAnnotations: {
+                    name: Unit.ownedAnnotations,
+                    defaultValue: []
+                },
+                ref: {
+                    name: Unit.ref,
+                    referenceType: Unit.$type
+                },
+                symbol: {
+                    name: Unit.symbol,
+                    defaultValue: []
+                }
+            },
+            superTypes: [Term.$type, VocabularyStatement.$type]
+        },
         UnreifiedRelation: {
             name: UnreifiedRelation.$type,
             properties: {