@oml/language 0.18.1 → 0.19.1

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

@@ -19,10 +19,10 @@ export declare const OmlTerminals: {
     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 OmlKeywordNames = "$" | "&" | "(" | ")" | "," | "->" | ":" | "<" | "=" | "@" | "[" | "]" | "^^" | "all" | "annotation" | "as" | "aspect" | "asymmetric" | "builtIn" | "builtin" | "bundle" | "concept" | "description" | "differentFrom" | "dimension" | "domain" | "entity" | "exactly" | "extends" | "forward" | "from" | "functional" | "includes" | "instance" | "inverse" | "irreflexive" | "key" | "language" | "length" | "max" | "maxExclusive" | "maxInclusive" | "maxLength" | "measures" | "min" | "minExclusive" | "minInclusive" | "minLength" | "multiplier" | "oneOf" | "pattern" | "property" | "quantity" | "range" | "ref" | "reflexive" | "relation" | "restricts" | "reverse" | "rule" | "sameAs" | "scalar" | "self" | "some" | "symbol" | "symmetric" | "to" | "transitive" | "unit" | "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 $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>;
@@ -222,10 +222,12 @@ 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';
+    unit?: langium.Reference<Unit>;
     value: Decimal;
 }
 export declare const DecimalLiteral: {
     readonly $type: "DecimalLiteral";
+    readonly unit: "unit";
     readonly value: "value";
 };
 export declare function isDecimalLiteral(item: unknown): item is DecimalLiteral;
@@ -293,10 +295,12 @@ 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';
+    unit?: langium.Reference<Unit>;
     value: Double;
 }
 export declare const DoubleLiteral: {
     readonly $type: "DoubleLiteral";
+    readonly unit: "unit";
     readonly value: "value";
 };
 export declare function isDoubleLiteral(item: unknown): item is DoubleLiteral;
@@ -380,10 +384,12 @@ 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';
+    unit?: langium.Reference<Unit>;
     value: Integer;
 }
 export declare const IntegerLiteral: {
     readonly $type: "IntegerLiteral";
+    readonly unit: "unit";
     readonly value: "value";
 };
 export declare function isIntegerLiteral(item: unknown): item is IntegerLiteral;
@@ -454,7 +460,7 @@ export declare const PropertyCardinalityRestrictionAxiom: {
 };
 export declare function isPropertyCardinalityRestrictionAxiom(item: unknown): item is PropertyCardinalityRestrictionAxiom;
 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>>;
 }
@@ -538,6 +544,46 @@ export declare const PropertyValueRestrictionAxiom: {
     readonly referencedValue: "referencedValue";
 };
 export declare function isPropertyValueRestrictionAxiom(item: unknown): item is PropertyValueRestrictionAxiom;
+export interface Quantity extends langium.AstNode {
+    readonly $container: Vocabulary;
+    readonly $type: 'Quantity';
+    dimension?: string;
+    name?: string;
+    ownedAnnotations: Array<Annotation>;
+    ref?: langium.Reference<Quantity>;
+}
+export declare const Quantity: {
+    readonly $type: "Quantity";
+    readonly dimension: "dimension";
+    readonly name: "name";
+    readonly ownedAnnotations: "ownedAnnotations";
+    readonly ref: "ref";
+};
+export declare function isQuantity(item: unknown): item is Quantity;
+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 declare const QuantityProperty: {
+    readonly $type: "QuantityProperty";
+    readonly domains: "domains";
+    readonly functional: "functional";
+    readonly kind: "kind";
+    readonly name: "name";
+    readonly ownedAnnotations: "ownedAnnotations";
+    readonly ownedEquivalences: "ownedEquivalences";
+    readonly ownedSpecializations: "ownedSpecializations";
+    readonly ref: "ref";
+};
+export declare function isQuantityProperty(item: unknown): item is QuantityProperty;
 export interface QuotedLiteral extends langium.AstNode {
     readonly $container: Annotation | Argument | LiteralEnumerationAxiom | PropertyValueAssertion | PropertyValueRestrictionAxiom | ScalarEquivalenceAxiom;
     readonly $type: 'QuotedLiteral';
@@ -762,12 +808,12 @@ export declare const ScalarProperty: {
     readonly ref: "ref";
 };
 export declare function isScalarProperty(item: unknown): item is ScalarProperty;
-export type SemanticProperty = Relation | ScalarProperty;
+export type SemanticProperty = QuantityProperty | 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 type SpecializableProperty = AnnotationProperty | QuantityProperty | ScalarProperty | UnreifiedRelation;
 export declare const SpecializableProperty: {
     readonly $type: "SpecializableProperty";
 };
@@ -778,7 +824,7 @@ export declare const 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 $container: AnnotationProperty | Aspect | Concept | QuantityProperty | RelationEntity | Scalar | ScalarProperty | UnreifiedRelation;
     readonly $type: 'SpecializationAxiom';
     superTerm: langium.Reference<Term>;
 }
@@ -792,7 +838,7 @@ export declare const Statement: {
     readonly $type: "Statement";
 };
 export declare function isStatement(item: unknown): item is Statement;
-export type Term = Property | RelationBase | SpecializableTerm;
+export type Term = Property | Quantity | RelationBase | SpecializableTerm | Unit;
 export declare const Term: {
     readonly $type: "Term";
 };
@@ -829,6 +875,26 @@ export declare const UnaryPredicate: {
     readonly $type: "UnaryPredicate";
 };
 export declare function isUnaryPredicate(item: unknown): item is UnaryPredicate;
+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 declare const Unit: {
+    readonly $type: "Unit";
+    readonly kinds: "kinds";
+    readonly multiplier: "multiplier";
+    readonly name: "name";
+    readonly ownedAnnotations: "ownedAnnotations";
+    readonly ref: "ref";
+    readonly symbol: "symbol";
+};
+export declare function isUnit(item: unknown): item is Unit;
 export interface UnreifiedRelation extends langium.AstNode {
     readonly $container: Vocabulary;
     readonly $type: 'UnreifiedRelation';
@@ -911,7 +977,7 @@ export declare const VocabularyMember: {
     readonly $type: "VocabularyMember";
 };
 export declare function isVocabularyMember(item: unknown): item is VocabularyMember;
-export type VocabularyStatement = BuiltIn | Rule | SpecializableTerm;
+export type VocabularyStatement = BuiltIn | Quantity | Rule | SpecializableTerm | Unit;
 export declare const VocabularyStatement: {
     readonly $type: "VocabularyStatement";
 };
@@ -966,6 +1032,8 @@ export type OmlAstType = {
     PropertySelfRestrictionAxiom: PropertySelfRestrictionAxiom;
     PropertyValueAssertion: PropertyValueAssertion;
     PropertyValueRestrictionAxiom: PropertyValueRestrictionAxiom;
+    Quantity: Quantity;
+    QuantityProperty: QuantityProperty;
     QuotedLiteral: QuotedLiteral;
     Relation: Relation;
     RelationBase: RelationBase;
@@ -988,6 +1056,7 @@ export type OmlAstType = {
     TypeAssertion: TypeAssertion;
     TypePredicate: TypePredicate;
     UnaryPredicate: UnaryPredicate;
+    Unit: Unit;
     UnreifiedRelation: UnreifiedRelation;
     Vocabulary: Vocabulary;
     VocabularyBox: VocabularyBox;
@@ -1242,6 +1311,10 @@ export declare class OmlAstReflection extends langium.AbstractAstReflection {
         readonly DecimalLiteral: {
             readonly name: "DecimalLiteral";
             readonly properties: {
+                readonly unit: {
+                    readonly name: "unit";
+                    readonly referenceType: "Unit";
+                };
                 readonly value: {
                     readonly name: "value";
                 };
@@ -1322,6 +1395,10 @@ export declare class OmlAstReflection extends langium.AbstractAstReflection {
         readonly DoubleLiteral: {
             readonly name: "DoubleLiteral";
             readonly properties: {
+                readonly unit: {
+                    readonly name: "unit";
+                    readonly referenceType: "Unit";
+                };
                 readonly value: {
                     readonly name: "value";
                 };
@@ -1411,6 +1488,10 @@ export declare class OmlAstReflection extends langium.AbstractAstReflection {
         readonly IntegerLiteral: {
             readonly name: "IntegerLiteral";
             readonly properties: {
+                readonly unit: {
+                    readonly name: "unit";
+                    readonly referenceType: "Unit";
+                };
                 readonly value: {
                     readonly name: "value";
                 };
@@ -1590,6 +1671,65 @@ export declare class OmlAstReflection extends langium.AbstractAstReflection {
             };
             readonly superTypes: ["PropertyRestrictionAxiom"];
         };
+        readonly Quantity: {
+            readonly name: "Quantity";
+            readonly properties: {
+                readonly dimension: {
+                    readonly name: "dimension";
+                };
+                readonly name: {
+                    readonly name: "name";
+                };
+                readonly ownedAnnotations: {
+                    readonly name: "ownedAnnotations";
+                    readonly defaultValue: [];
+                };
+                readonly ref: {
+                    readonly name: "ref";
+                    readonly referenceType: "Quantity";
+                };
+            };
+            readonly superTypes: ["Term", "VocabularyStatement"];
+        };
+        readonly QuantityProperty: {
+            readonly name: "QuantityProperty";
+            readonly properties: {
+                readonly domains: {
+                    readonly name: "domains";
+                    readonly defaultValue: [];
+                    readonly referenceType: "Entity";
+                };
+                readonly functional: {
+                    readonly name: "functional";
+                    readonly defaultValue: false;
+                };
+                readonly kind: {
+                    readonly name: "kind";
+                    readonly defaultValue: [];
+                    readonly referenceType: "Quantity";
+                };
+                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: "QuantityProperty";
+                };
+            };
+            readonly superTypes: ["SemanticProperty", "SpecializableProperty"];
+        };
         readonly QuotedLiteral: {
             readonly name: "QuotedLiteral";
             readonly properties: {
@@ -1979,6 +2119,36 @@ export declare class OmlAstReflection extends langium.AbstractAstReflection {
             readonly properties: {};
             readonly superTypes: ["Predicate"];
         };
+        readonly Unit: {
+            readonly name: "Unit";
+            readonly properties: {
+                readonly kinds: {
+                    readonly name: "kinds";
+                    readonly defaultValue: [];
+                    readonly referenceType: "Quantity";
+                };
+                readonly multiplier: {
+                    readonly name: "multiplier";
+                    readonly defaultValue: [];
+                };
+                readonly name: {
+                    readonly name: "name";
+                };
+                readonly ownedAnnotations: {
+                    readonly name: "ownedAnnotations";
+                    readonly defaultValue: [];
+                };
+                readonly ref: {
+                    readonly name: "ref";
+                    readonly referenceType: "Unit";
+                };
+                readonly symbol: {
+                    readonly name: "symbol";
+                    readonly defaultValue: [];
+                };
+            };
+            readonly superTypes: ["Term", "VocabularyStatement"];
+        };
         readonly UnreifiedRelation: {
             readonly name: "UnreifiedRelation";
             readonly properties: {

package/out/oml/generated/ast.js

@@ -164,6 +164,7 @@ export function isDecimal(item) {
 }
 export const DecimalLiteral = {
     $type: 'DecimalLiteral',
+    unit: 'unit',
     value: 'value'
 };
 export function isDecimalLiteral(item) {
@@ -221,6 +222,7 @@ export function isDouble(item) {
 }
 export const DoubleLiteral = {
     $type: 'DoubleLiteral',
+    unit: 'unit',
     value: 'value'
 };
 export function isDoubleLiteral(item) {
@@ -296,6 +298,7 @@ export function isInteger(item) {
 }
 export const IntegerLiteral = {
     $type: 'IntegerLiteral',
+    unit: 'unit',
     value: 'value'
 };
 export function isIntegerLiteral(item) {
@@ -419,6 +422,30 @@ export const PropertyValueRestrictionAxiom = {
 export function isPropertyValueRestrictionAxiom(item) {
     return reflection.isInstance(item, PropertyValueRestrictionAxiom.$type);
 }
+export const Quantity = {
+    $type: 'Quantity',
+    dimension: 'dimension',
+    name: 'name',
+    ownedAnnotations: 'ownedAnnotations',
+    ref: 'ref'
+};
+export function isQuantity(item) {
+    return reflection.isInstance(item, Quantity.$type);
+}
+export const QuantityProperty = {
+    $type: 'QuantityProperty',
+    domains: 'domains',
+    functional: 'functional',
+    kind: 'kind',
+    name: 'name',
+    ownedAnnotations: 'ownedAnnotations',
+    ownedEquivalences: 'ownedEquivalences',
+    ownedSpecializations: 'ownedSpecializations',
+    ref: 'ref'
+};
+export function isQuantityProperty(item) {
+    return reflection.isInstance(item, QuantityProperty.$type);
+}
 export const QuotedLiteral = {
     $type: 'QuotedLiteral',
     langTag: 'langTag',
@@ -626,6 +653,18 @@ export const UnaryPredicate = {
 export function isUnaryPredicate(item) {
     return reflection.isInstance(item, UnaryPredicate.$type);
 }
+export const Unit = {
+    $type: 'Unit',
+    kinds: 'kinds',
+    multiplier: 'multiplier',
+    name: 'name',
+    ownedAnnotations: 'ownedAnnotations',
+    ref: 'ref',
+    symbol: 'symbol'
+};
+export function isUnit(item) {
+    return reflection.isInstance(item, Unit.$type);
+}
 export const UnreifiedRelation = {
     $type: 'UnreifiedRelation',
     asymmetric: 'asymmetric',
@@ -938,6 +977,10 @@ export class OmlAstReflection extends langium.AbstractAstReflection {
             DecimalLiteral: {
                 name: DecimalLiteral.$type,
                 properties: {
+                    unit: {
+                        name: DecimalLiteral.unit,
+                        referenceType: Unit.$type
+                    },
                     value: {
                         name: DecimalLiteral.value
                     }
@@ -1018,6 +1061,10 @@ export class OmlAstReflection extends langium.AbstractAstReflection {
             DoubleLiteral: {
                 name: DoubleLiteral.$type,
                 properties: {
+                    unit: {
+                        name: DoubleLiteral.unit,
+                        referenceType: Unit.$type
+                    },
                     value: {
                         name: DoubleLiteral.value
                     }
@@ -1107,6 +1154,10 @@ export class OmlAstReflection extends langium.AbstractAstReflection {
             IntegerLiteral: {
                 name: IntegerLiteral.$type,
                 properties: {
+                    unit: {
+                        name: IntegerLiteral.unit,
+                        referenceType: Unit.$type
+                    },
                     value: {
                         name: IntegerLiteral.value
                     }
@@ -1286,6 +1337,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: {
@@ -1675,6 +1785,36 @@ export class OmlAstReflection extends langium.AbstractAstReflection {
                 properties: {},
                 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: {