@windrun-huaiin/third-ui 12.1.0 → 13.0.1

package/dist/node_modules/.pnpm/langium@4.2.1/node_modules/langium/lib/languages/generated/ast.js

@@ -0,0 +1,1216 @@
+'use strict';
+
+var syntaxTree = require('../../syntax-tree.js');
+
+/******************************************************************************
+ * This file was generated by langium-cli 4.2.0.
+ * DO NOT EDIT MANUALLY!
+ ******************************************************************************/
+/* eslint-disable */
+const AbstractElement = {
+    $type: 'AbstractElement',
+    cardinality: 'cardinality'
+};
+function isAbstractElement(item) {
+    return reflection.isInstance(item, AbstractElement.$type);
+}
+const AbstractParserRule = {
+    $type: 'AbstractParserRule'
+};
+function isAbstractParserRule(item) {
+    return reflection.isInstance(item, AbstractParserRule.$type);
+}
+const AbstractRule = {
+    $type: 'AbstractRule'
+};
+const AbstractType = {
+    $type: 'AbstractType'
+};
+const Action = {
+    $type: 'Action',
+    cardinality: 'cardinality',
+    feature: 'feature',
+    inferredType: 'inferredType',
+    operator: 'operator',
+    type: 'type'
+};
+function isAction(item) {
+    return reflection.isInstance(item, Action.$type);
+}
+const Alternatives = {
+    $type: 'Alternatives',
+    cardinality: 'cardinality',
+    elements: 'elements'
+};
+function isAlternatives(item) {
+    return reflection.isInstance(item, Alternatives.$type);
+}
+const ArrayLiteral = {
+    $type: 'ArrayLiteral',
+    elements: 'elements'
+};
+const ArrayType = {
+    $type: 'ArrayType',
+    elementType: 'elementType'
+};
+const Assignment = {
+    $type: 'Assignment',
+    cardinality: 'cardinality',
+    feature: 'feature',
+    operator: 'operator',
+    predicate: 'predicate',
+    terminal: 'terminal'
+};
+function isAssignment(item) {
+    return reflection.isInstance(item, Assignment.$type);
+}
+const BooleanLiteral = {
+    $type: 'BooleanLiteral',
+    true: 'true'
+};
+function isBooleanLiteral(item) {
+    return reflection.isInstance(item, BooleanLiteral.$type);
+}
+const CharacterRange = {
+    $type: 'CharacterRange',
+    cardinality: 'cardinality',
+    left: 'left',
+    lookahead: 'lookahead',
+    parenthesized: 'parenthesized',
+    right: 'right'
+};
+function isCharacterRange(item) {
+    return reflection.isInstance(item, CharacterRange.$type);
+}
+const Condition = {
+    $type: 'Condition'
+};
+const Conjunction = {
+    $type: 'Conjunction',
+    left: 'left',
+    right: 'right'
+};
+function isConjunction(item) {
+    return reflection.isInstance(item, Conjunction.$type);
+}
+const CrossReference = {
+    $type: 'CrossReference',
+    cardinality: 'cardinality',
+    deprecatedSyntax: 'deprecatedSyntax',
+    isMulti: 'isMulti',
+    terminal: 'terminal',
+    type: 'type'
+};
+function isCrossReference(item) {
+    return reflection.isInstance(item, CrossReference.$type);
+}
+const Disjunction = {
+    $type: 'Disjunction',
+    left: 'left',
+    right: 'right'
+};
+function isDisjunction(item) {
+    return reflection.isInstance(item, Disjunction.$type);
+}
+const EndOfFile = {
+    $type: 'EndOfFile',
+    cardinality: 'cardinality'
+};
+function isEndOfFile(item) {
+    return reflection.isInstance(item, EndOfFile.$type);
+}
+const Grammar = {
+    $type: 'Grammar',
+    imports: 'imports',
+    interfaces: 'interfaces',
+    isDeclared: 'isDeclared',
+    name: 'name',
+    rules: 'rules',
+    types: 'types'
+};
+const GrammarImport = {
+    $type: 'GrammarImport',
+    path: 'path'
+};
+const Group = {
+    $type: 'Group',
+    cardinality: 'cardinality',
+    elements: 'elements',
+    guardCondition: 'guardCondition',
+    predicate: 'predicate'
+};
+function isGroup(item) {
+    return reflection.isInstance(item, Group.$type);
+}
+const InferredType = {
+    $type: 'InferredType',
+    name: 'name'
+};
+function isInferredType(item) {
+    return reflection.isInstance(item, InferredType.$type);
+}
+const InfixRule = {
+    $type: 'InfixRule',
+    call: 'call',
+    dataType: 'dataType',
+    inferredType: 'inferredType',
+    name: 'name',
+    operators: 'operators',
+    parameters: 'parameters',
+    returnType: 'returnType'
+};
+function isInfixRule(item) {
+    return reflection.isInstance(item, InfixRule.$type);
+}
+const InfixRuleOperatorList = {
+    $type: 'InfixRuleOperatorList',
+    associativity: 'associativity',
+    operators: 'operators'
+};
+const InfixRuleOperators = {
+    $type: 'InfixRuleOperators',
+    precedences: 'precedences'
+};
+const Interface = {
+    $type: 'Interface',
+    attributes: 'attributes',
+    name: 'name',
+    superTypes: 'superTypes'
+};
+function isInterface(item) {
+    return reflection.isInstance(item, Interface.$type);
+}
+const Keyword = {
+    $type: 'Keyword',
+    cardinality: 'cardinality',
+    predicate: 'predicate',
+    value: 'value'
+};
+function isKeyword(item) {
+    return reflection.isInstance(item, Keyword.$type);
+}
+const NamedArgument = {
+    $type: 'NamedArgument',
+    calledByName: 'calledByName',
+    parameter: 'parameter',
+    value: 'value'
+};
+const NegatedToken = {
+    $type: 'NegatedToken',
+    cardinality: 'cardinality',
+    lookahead: 'lookahead',
+    parenthesized: 'parenthesized',
+    terminal: 'terminal'
+};
+function isNegatedToken(item) {
+    return reflection.isInstance(item, NegatedToken.$type);
+}
+const Negation = {
+    $type: 'Negation',
+    value: 'value'
+};
+function isNegation(item) {
+    return reflection.isInstance(item, Negation.$type);
+}
+const NumberLiteral = {
+    $type: 'NumberLiteral',
+    value: 'value'
+};
+const Parameter = {
+    $type: 'Parameter',
+    name: 'name'
+};
+const ParameterReference = {
+    $type: 'ParameterReference',
+    parameter: 'parameter'
+};
+function isParameterReference(item) {
+    return reflection.isInstance(item, ParameterReference.$type);
+}
+const ParserRule = {
+    $type: 'ParserRule',
+    dataType: 'dataType',
+    definition: 'definition',
+    entry: 'entry',
+    fragment: 'fragment',
+    inferredType: 'inferredType',
+    name: 'name',
+    parameters: 'parameters',
+    returnType: 'returnType'
+};
+function isParserRule(item) {
+    return reflection.isInstance(item, ParserRule.$type);
+}
+const ReferenceType = {
+    $type: 'ReferenceType',
+    isMulti: 'isMulti',
+    referenceType: 'referenceType'
+};
+const RegexToken = {
+    $type: 'RegexToken',
+    cardinality: 'cardinality',
+    lookahead: 'lookahead',
+    parenthesized: 'parenthesized',
+    regex: 'regex'
+};
+function isRegexToken(item) {
+    return reflection.isInstance(item, RegexToken.$type);
+}
+const ReturnType = {
+    $type: 'ReturnType',
+    name: 'name'
+};
+function isReturnType(item) {
+    return reflection.isInstance(item, ReturnType.$type);
+}
+const RuleCall = {
+    $type: 'RuleCall',
+    arguments: 'arguments',
+    cardinality: 'cardinality',
+    predicate: 'predicate',
+    rule: 'rule'
+};
+function isRuleCall(item) {
+    return reflection.isInstance(item, RuleCall.$type);
+}
+const SimpleType = {
+    $type: 'SimpleType',
+    primitiveType: 'primitiveType',
+    stringType: 'stringType',
+    typeRef: 'typeRef'
+};
+function isSimpleType(item) {
+    return reflection.isInstance(item, SimpleType.$type);
+}
+const StringLiteral = {
+    $type: 'StringLiteral',
+    value: 'value'
+};
+const TerminalAlternatives = {
+    $type: 'TerminalAlternatives',
+    cardinality: 'cardinality',
+    elements: 'elements',
+    lookahead: 'lookahead',
+    parenthesized: 'parenthesized'
+};
+function isTerminalAlternatives(item) {
+    return reflection.isInstance(item, TerminalAlternatives.$type);
+}
+const TerminalElement = {
+    $type: 'TerminalElement',
+    cardinality: 'cardinality',
+    lookahead: 'lookahead',
+    parenthesized: 'parenthesized'
+};
+const TerminalGroup = {
+    $type: 'TerminalGroup',
+    cardinality: 'cardinality',
+    elements: 'elements',
+    lookahead: 'lookahead',
+    parenthesized: 'parenthesized'
+};
+function isTerminalGroup(item) {
+    return reflection.isInstance(item, TerminalGroup.$type);
+}
+const TerminalRule = {
+    $type: 'TerminalRule',
+    definition: 'definition',
+    fragment: 'fragment',
+    hidden: 'hidden',
+    name: 'name',
+    type: 'type'
+};
+function isTerminalRule(item) {
+    return reflection.isInstance(item, TerminalRule.$type);
+}
+const TerminalRuleCall = {
+    $type: 'TerminalRuleCall',
+    cardinality: 'cardinality',
+    lookahead: 'lookahead',
+    parenthesized: 'parenthesized',
+    rule: 'rule'
+};
+function isTerminalRuleCall(item) {
+    return reflection.isInstance(item, TerminalRuleCall.$type);
+}
+const Type = {
+    $type: 'Type',
+    name: 'name',
+    type: 'type'
+};
+function isType(item) {
+    return reflection.isInstance(item, Type.$type);
+}
+const TypeAttribute = {
+    $type: 'TypeAttribute',
+    defaultValue: 'defaultValue',
+    isOptional: 'isOptional',
+    name: 'name',
+    type: 'type'
+};
+const TypeDefinition = {
+    $type: 'TypeDefinition'
+};
+const UnionType = {
+    $type: 'UnionType',
+    types: 'types'
+};
+const UnorderedGroup = {
+    $type: 'UnorderedGroup',
+    cardinality: 'cardinality',
+    elements: 'elements'
+};
+function isUnorderedGroup(item) {
+    return reflection.isInstance(item, UnorderedGroup.$type);
+}
+const UntilToken = {
+    $type: 'UntilToken',
+    cardinality: 'cardinality',
+    lookahead: 'lookahead',
+    parenthesized: 'parenthesized',
+    terminal: 'terminal'
+};
+function isUntilToken(item) {
+    return reflection.isInstance(item, UntilToken.$type);
+}
+const ValueLiteral = {
+    $type: 'ValueLiteral'
+};
+const Wildcard = {
+    $type: 'Wildcard',
+    cardinality: 'cardinality',
+    lookahead: 'lookahead',
+    parenthesized: 'parenthesized'
+};
+function isWildcard(item) {
+    return reflection.isInstance(item, Wildcard.$type);
+}
+class LangiumGrammarAstReflection extends syntaxTree.AbstractAstReflection {
+    constructor() {
+        super(...arguments);
+        this.types = {
+            AbstractElement: {
+                name: AbstractElement.$type,
+                properties: {
+                    cardinality: {
+                        name: AbstractElement.cardinality
+                    }
+                },
+                superTypes: []
+            },
+            AbstractParserRule: {
+                name: AbstractParserRule.$type,
+                properties: {},
+                superTypes: [AbstractRule.$type, AbstractType.$type]
+            },
+            AbstractRule: {
+                name: AbstractRule.$type,
+                properties: {},
+                superTypes: []
+            },
+            AbstractType: {
+                name: AbstractType.$type,
+                properties: {},
+                superTypes: []
+            },
+            Action: {
+                name: Action.$type,
+                properties: {
+                    cardinality: {
+                        name: Action.cardinality
+                    },
+                    feature: {
+                        name: Action.feature
+                    },
+                    inferredType: {
+                        name: Action.inferredType
+                    },
+                    operator: {
+                        name: Action.operator
+                    },
+                    type: {
+                        name: Action.type,
+                        referenceType: AbstractType.$type
+                    }
+                },
+                superTypes: [AbstractElement.$type]
+            },
+            Alternatives: {
+                name: Alternatives.$type,
+                properties: {
+                    cardinality: {
+                        name: Alternatives.cardinality
+                    },
+                    elements: {
+                        name: Alternatives.elements,
+                        defaultValue: []
+                    }
+                },
+                superTypes: [AbstractElement.$type]
+            },
+            ArrayLiteral: {
+                name: ArrayLiteral.$type,
+                properties: {
+                    elements: {
+                        name: ArrayLiteral.elements,
+                        defaultValue: []
+                    }
+                },
+                superTypes: [ValueLiteral.$type]
+            },
+            ArrayType: {
+                name: ArrayType.$type,
+                properties: {
+                    elementType: {
+                        name: ArrayType.elementType
+                    }
+                },
+                superTypes: [TypeDefinition.$type]
+            },
+            Assignment: {
+                name: Assignment.$type,
+                properties: {
+                    cardinality: {
+                        name: Assignment.cardinality
+                    },
+                    feature: {
+                        name: Assignment.feature
+                    },
+                    operator: {
+                        name: Assignment.operator
+                    },
+                    predicate: {
+                        name: Assignment.predicate
+                    },
+                    terminal: {
+                        name: Assignment.terminal
+                    }
+                },
+                superTypes: [AbstractElement.$type]
+            },
+            BooleanLiteral: {
+                name: BooleanLiteral.$type,
+                properties: {
+                    true: {
+                        name: BooleanLiteral.true,
+                        defaultValue: false
+                    }
+                },
+                superTypes: [Condition.$type, ValueLiteral.$type]
+            },
+            CharacterRange: {
+                name: CharacterRange.$type,
+                properties: {
+                    cardinality: {
+                        name: CharacterRange.cardinality
+                    },
+                    left: {
+                        name: CharacterRange.left
+                    },
+                    lookahead: {
+                        name: CharacterRange.lookahead
+                    },
+                    parenthesized: {
+                        name: CharacterRange.parenthesized,
+                        defaultValue: false
+                    },
+                    right: {
+                        name: CharacterRange.right
+                    }
+                },
+                superTypes: [TerminalElement.$type]
+            },
+            Condition: {
+                name: Condition.$type,
+                properties: {},
+                superTypes: []
+            },
+            Conjunction: {
+                name: Conjunction.$type,
+                properties: {
+                    left: {
+                        name: Conjunction.left
+                    },
+                    right: {
+                        name: Conjunction.right
+                    }
+                },
+                superTypes: [Condition.$type]
+            },
+            CrossReference: {
+                name: CrossReference.$type,
+                properties: {
+                    cardinality: {
+                        name: CrossReference.cardinality
+                    },
+                    deprecatedSyntax: {
+                        name: CrossReference.deprecatedSyntax,
+                        defaultValue: false
+                    },
+                    isMulti: {
+                        name: CrossReference.isMulti,
+                        defaultValue: false
+                    },
+                    terminal: {
+                        name: CrossReference.terminal
+                    },
+                    type: {
+                        name: CrossReference.type,
+                        referenceType: AbstractType.$type
+                    }
+                },
+                superTypes: [AbstractElement.$type]
+            },
+            Disjunction: {
+                name: Disjunction.$type,
+                properties: {
+                    left: {
+                        name: Disjunction.left
+                    },
+                    right: {
+                        name: Disjunction.right
+                    }
+                },
+                superTypes: [Condition.$type]
+            },
+            EndOfFile: {
+                name: EndOfFile.$type,
+                properties: {
+                    cardinality: {
+                        name: EndOfFile.cardinality
+                    }
+                },
+                superTypes: [AbstractElement.$type]
+            },
+            Grammar: {
+                name: Grammar.$type,
+                properties: {
+                    imports: {
+                        name: Grammar.imports,
+                        defaultValue: []
+                    },
+                    interfaces: {
+                        name: Grammar.interfaces,
+                        defaultValue: []
+                    },
+                    isDeclared: {
+                        name: Grammar.isDeclared,
+                        defaultValue: false
+                    },
+                    name: {
+                        name: Grammar.name
+                    },
+                    rules: {
+                        name: Grammar.rules,
+                        defaultValue: []
+                    },
+                    types: {
+                        name: Grammar.types,
+                        defaultValue: []
+                    }
+                },
+                superTypes: []
+            },
+            GrammarImport: {
+                name: GrammarImport.$type,
+                properties: {
+                    path: {
+                        name: GrammarImport.path
+                    }
+                },
+                superTypes: []
+            },
+            Group: {
+                name: Group.$type,
+                properties: {
+                    cardinality: {
+                        name: Group.cardinality
+                    },
+                    elements: {
+                        name: Group.elements,
+                        defaultValue: []
+                    },
+                    guardCondition: {
+                        name: Group.guardCondition
+                    },
+                    predicate: {
+                        name: Group.predicate
+                    }
+                },
+                superTypes: [AbstractElement.$type]
+            },
+            InferredType: {
+                name: InferredType.$type,
+                properties: {
+                    name: {
+                        name: InferredType.name
+                    }
+                },
+                superTypes: [AbstractType.$type]
+            },
+            InfixRule: {
+                name: InfixRule.$type,
+                properties: {
+                    call: {
+                        name: InfixRule.call
+                    },
+                    dataType: {
+                        name: InfixRule.dataType
+                    },
+                    inferredType: {
+                        name: InfixRule.inferredType
+                    },
+                    name: {
+                        name: InfixRule.name
+                    },
+                    operators: {
+                        name: InfixRule.operators
+                    },
+                    parameters: {
+                        name: InfixRule.parameters,
+                        defaultValue: []
+                    },
+                    returnType: {
+                        name: InfixRule.returnType,
+                        referenceType: AbstractType.$type
+                    }
+                },
+                superTypes: [AbstractParserRule.$type]
+            },
+            InfixRuleOperatorList: {
+                name: InfixRuleOperatorList.$type,
+                properties: {
+                    associativity: {
+                        name: InfixRuleOperatorList.associativity
+                    },
+                    operators: {
+                        name: InfixRuleOperatorList.operators,
+                        defaultValue: []
+                    }
+                },
+                superTypes: []
+            },
+            InfixRuleOperators: {
+                name: InfixRuleOperators.$type,
+                properties: {
+                    precedences: {
+                        name: InfixRuleOperators.precedences,
+                        defaultValue: []
+                    }
+                },
+                superTypes: []
+            },
+            Interface: {
+                name: Interface.$type,
+                properties: {
+                    attributes: {
+                        name: Interface.attributes,
+                        defaultValue: []
+                    },
+                    name: {
+                        name: Interface.name
+                    },
+                    superTypes: {
+                        name: Interface.superTypes,
+                        defaultValue: [],
+                        referenceType: AbstractType.$type
+                    }
+                },
+                superTypes: [AbstractType.$type]
+            },
+            Keyword: {
+                name: Keyword.$type,
+                properties: {
+                    cardinality: {
+                        name: Keyword.cardinality
+                    },
+                    predicate: {
+                        name: Keyword.predicate
+                    },
+                    value: {
+                        name: Keyword.value
+                    }
+                },
+                superTypes: [AbstractElement.$type]
+            },
+            NamedArgument: {
+                name: NamedArgument.$type,
+                properties: {
+                    calledByName: {
+                        name: NamedArgument.calledByName,
+                        defaultValue: false
+                    },
+                    parameter: {
+                        name: NamedArgument.parameter,
+                        referenceType: Parameter.$type
+                    },
+                    value: {
+                        name: NamedArgument.value
+                    }
+                },
+                superTypes: []
+            },
+            NegatedToken: {
+                name: NegatedToken.$type,
+                properties: {
+                    cardinality: {
+                        name: NegatedToken.cardinality
+                    },
+                    lookahead: {
+                        name: NegatedToken.lookahead
+                    },
+                    parenthesized: {
+                        name: NegatedToken.parenthesized,
+                        defaultValue: false
+                    },
+                    terminal: {
+                        name: NegatedToken.terminal
+                    }
+                },
+                superTypes: [TerminalElement.$type]
+            },
+            Negation: {
+                name: Negation.$type,
+                properties: {
+                    value: {
+                        name: Negation.value
+                    }
+                },
+                superTypes: [Condition.$type]
+            },
+            NumberLiteral: {
+                name: NumberLiteral.$type,
+                properties: {
+                    value: {
+                        name: NumberLiteral.value
+                    }
+                },
+                superTypes: [ValueLiteral.$type]
+            },
+            Parameter: {
+                name: Parameter.$type,
+                properties: {
+                    name: {
+                        name: Parameter.name
+                    }
+                },
+                superTypes: []
+            },
+            ParameterReference: {
+                name: ParameterReference.$type,
+                properties: {
+                    parameter: {
+                        name: ParameterReference.parameter,
+                        referenceType: Parameter.$type
+                    }
+                },
+                superTypes: [Condition.$type]
+            },
+            ParserRule: {
+                name: ParserRule.$type,
+                properties: {
+                    dataType: {
+                        name: ParserRule.dataType
+                    },
+                    definition: {
+                        name: ParserRule.definition
+                    },
+                    entry: {
+                        name: ParserRule.entry,
+                        defaultValue: false
+                    },
+                    fragment: {
+                        name: ParserRule.fragment,
+                        defaultValue: false
+                    },
+                    inferredType: {
+                        name: ParserRule.inferredType
+                    },
+                    name: {
+                        name: ParserRule.name
+                    },
+                    parameters: {
+                        name: ParserRule.parameters,
+                        defaultValue: []
+                    },
+                    returnType: {
+                        name: ParserRule.returnType,
+                        referenceType: AbstractType.$type
+                    }
+                },
+                superTypes: [AbstractParserRule.$type]
+            },
+            ReferenceType: {
+                name: ReferenceType.$type,
+                properties: {
+                    isMulti: {
+                        name: ReferenceType.isMulti,
+                        defaultValue: false
+                    },
+                    referenceType: {
+                        name: ReferenceType.referenceType
+                    }
+                },
+                superTypes: [TypeDefinition.$type]
+            },
+            RegexToken: {
+                name: RegexToken.$type,
+                properties: {
+                    cardinality: {
+                        name: RegexToken.cardinality
+                    },
+                    lookahead: {
+                        name: RegexToken.lookahead
+                    },
+                    parenthesized: {
+                        name: RegexToken.parenthesized,
+                        defaultValue: false
+                    },
+                    regex: {
+                        name: RegexToken.regex
+                    }
+                },
+                superTypes: [TerminalElement.$type]
+            },
+            ReturnType: {
+                name: ReturnType.$type,
+                properties: {
+                    name: {
+                        name: ReturnType.name
+                    }
+                },
+                superTypes: []
+            },
+            RuleCall: {
+                name: RuleCall.$type,
+                properties: {
+                    arguments: {
+                        name: RuleCall.arguments,
+                        defaultValue: []
+                    },
+                    cardinality: {
+                        name: RuleCall.cardinality
+                    },
+                    predicate: {
+                        name: RuleCall.predicate
+                    },
+                    rule: {
+                        name: RuleCall.rule,
+                        referenceType: AbstractRule.$type
+                    }
+                },
+                superTypes: [AbstractElement.$type]
+            },
+            SimpleType: {
+                name: SimpleType.$type,
+                properties: {
+                    primitiveType: {
+                        name: SimpleType.primitiveType
+                    },
+                    stringType: {
+                        name: SimpleType.stringType
+                    },
+                    typeRef: {
+                        name: SimpleType.typeRef,
+                        referenceType: AbstractType.$type
+                    }
+                },
+                superTypes: [TypeDefinition.$type]
+            },
+            StringLiteral: {
+                name: StringLiteral.$type,
+                properties: {
+                    value: {
+                        name: StringLiteral.value
+                    }
+                },
+                superTypes: [ValueLiteral.$type]
+            },
+            TerminalAlternatives: {
+                name: TerminalAlternatives.$type,
+                properties: {
+                    cardinality: {
+                        name: TerminalAlternatives.cardinality
+                    },
+                    elements: {
+                        name: TerminalAlternatives.elements,
+                        defaultValue: []
+                    },
+                    lookahead: {
+                        name: TerminalAlternatives.lookahead
+                    },
+                    parenthesized: {
+                        name: TerminalAlternatives.parenthesized,
+                        defaultValue: false
+                    }
+                },
+                superTypes: [TerminalElement.$type]
+            },
+            TerminalElement: {
+                name: TerminalElement.$type,
+                properties: {
+                    cardinality: {
+                        name: TerminalElement.cardinality
+                    },
+                    lookahead: {
+                        name: TerminalElement.lookahead
+                    },
+                    parenthesized: {
+                        name: TerminalElement.parenthesized,
+                        defaultValue: false
+                    }
+                },
+                superTypes: [AbstractElement.$type]
+            },
+            TerminalGroup: {
+                name: TerminalGroup.$type,
+                properties: {
+                    cardinality: {
+                        name: TerminalGroup.cardinality
+                    },
+                    elements: {
+                        name: TerminalGroup.elements,
+                        defaultValue: []
+                    },
+                    lookahead: {
+                        name: TerminalGroup.lookahead
+                    },
+                    parenthesized: {
+                        name: TerminalGroup.parenthesized,
+                        defaultValue: false
+                    }
+                },
+                superTypes: [TerminalElement.$type]
+            },
+            TerminalRule: {
+                name: TerminalRule.$type,
+                properties: {
+                    definition: {
+                        name: TerminalRule.definition
+                    },
+                    fragment: {
+                        name: TerminalRule.fragment,
+                        defaultValue: false
+                    },
+                    hidden: {
+                        name: TerminalRule.hidden,
+                        defaultValue: false
+                    },
+                    name: {
+                        name: TerminalRule.name
+                    },
+                    type: {
+                        name: TerminalRule.type
+                    }
+                },
+                superTypes: [AbstractRule.$type]
+            },
+            TerminalRuleCall: {
+                name: TerminalRuleCall.$type,
+                properties: {
+                    cardinality: {
+                        name: TerminalRuleCall.cardinality
+                    },
+                    lookahead: {
+                        name: TerminalRuleCall.lookahead
+                    },
+                    parenthesized: {
+                        name: TerminalRuleCall.parenthesized,
+                        defaultValue: false
+                    },
+                    rule: {
+                        name: TerminalRuleCall.rule,
+                        referenceType: TerminalRule.$type
+                    }
+                },
+                superTypes: [TerminalElement.$type]
+            },
+            Type: {
+                name: Type.$type,
+                properties: {
+                    name: {
+                        name: Type.name
+                    },
+                    type: {
+                        name: Type.type
+                    }
+                },
+                superTypes: [AbstractType.$type]
+            },
+            TypeAttribute: {
+                name: TypeAttribute.$type,
+                properties: {
+                    defaultValue: {
+                        name: TypeAttribute.defaultValue
+                    },
+                    isOptional: {
+                        name: TypeAttribute.isOptional,
+                        defaultValue: false
+                    },
+                    name: {
+                        name: TypeAttribute.name
+                    },
+                    type: {
+                        name: TypeAttribute.type
+                    }
+                },
+                superTypes: []
+            },
+            TypeDefinition: {
+                name: TypeDefinition.$type,
+                properties: {},
+                superTypes: []
+            },
+            UnionType: {
+                name: UnionType.$type,
+                properties: {
+                    types: {
+                        name: UnionType.types,
+                        defaultValue: []
+                    }
+                },
+                superTypes: [TypeDefinition.$type]
+            },
+            UnorderedGroup: {
+                name: UnorderedGroup.$type,
+                properties: {
+                    cardinality: {
+                        name: UnorderedGroup.cardinality
+                    },
+                    elements: {
+                        name: UnorderedGroup.elements,
+                        defaultValue: []
+                    }
+                },
+                superTypes: [AbstractElement.$type]
+            },
+            UntilToken: {
+                name: UntilToken.$type,
+                properties: {
+                    cardinality: {
+                        name: UntilToken.cardinality
+                    },
+                    lookahead: {
+                        name: UntilToken.lookahead
+                    },
+                    parenthesized: {
+                        name: UntilToken.parenthesized,
+                        defaultValue: false
+                    },
+                    terminal: {
+                        name: UntilToken.terminal
+                    }
+                },
+                superTypes: [TerminalElement.$type]
+            },
+            ValueLiteral: {
+                name: ValueLiteral.$type,
+                properties: {},
+                superTypes: []
+            },
+            Wildcard: {
+                name: Wildcard.$type,
+                properties: {
+                    cardinality: {
+                        name: Wildcard.cardinality
+                    },
+                    lookahead: {
+                        name: Wildcard.lookahead
+                    },
+                    parenthesized: {
+                        name: Wildcard.parenthesized,
+                        defaultValue: false
+                    }
+                },
+                superTypes: [TerminalElement.$type]
+            }
+        };
+    }
+}
+const reflection = new LangiumGrammarAstReflection();
+
+exports.AbstractElement = AbstractElement;
+exports.AbstractParserRule = AbstractParserRule;
+exports.AbstractRule = AbstractRule;
+exports.AbstractType = AbstractType;
+exports.Action = Action;
+exports.Alternatives = Alternatives;
+exports.ArrayLiteral = ArrayLiteral;
+exports.ArrayType = ArrayType;
+exports.Assignment = Assignment;
+exports.BooleanLiteral = BooleanLiteral;
+exports.CharacterRange = CharacterRange;
+exports.Condition = Condition;
+exports.Conjunction = Conjunction;
+exports.CrossReference = CrossReference;
+exports.Disjunction = Disjunction;
+exports.EndOfFile = EndOfFile;
+exports.Grammar = Grammar;
+exports.GrammarImport = GrammarImport;
+exports.Group = Group;
+exports.InferredType = InferredType;
+exports.InfixRule = InfixRule;
+exports.InfixRuleOperatorList = InfixRuleOperatorList;
+exports.InfixRuleOperators = InfixRuleOperators;
+exports.Interface = Interface;
+exports.Keyword = Keyword;
+exports.LangiumGrammarAstReflection = LangiumGrammarAstReflection;
+exports.NamedArgument = NamedArgument;
+exports.NegatedToken = NegatedToken;
+exports.Negation = Negation;
+exports.NumberLiteral = NumberLiteral;
+exports.Parameter = Parameter;
+exports.ParameterReference = ParameterReference;
+exports.ParserRule = ParserRule;
+exports.ReferenceType = ReferenceType;
+exports.RegexToken = RegexToken;
+exports.ReturnType = ReturnType;
+exports.RuleCall = RuleCall;
+exports.SimpleType = SimpleType;
+exports.StringLiteral = StringLiteral;
+exports.TerminalAlternatives = TerminalAlternatives;
+exports.TerminalElement = TerminalElement;
+exports.TerminalGroup = TerminalGroup;
+exports.TerminalRule = TerminalRule;
+exports.TerminalRuleCall = TerminalRuleCall;
+exports.Type = Type;
+exports.TypeAttribute = TypeAttribute;
+exports.TypeDefinition = TypeDefinition;
+exports.UnionType = UnionType;
+exports.UnorderedGroup = UnorderedGroup;
+exports.UntilToken = UntilToken;
+exports.ValueLiteral = ValueLiteral;
+exports.Wildcard = Wildcard;
+exports.isAbstractElement = isAbstractElement;
+exports.isAbstractParserRule = isAbstractParserRule;
+exports.isAction = isAction;
+exports.isAlternatives = isAlternatives;
+exports.isAssignment = isAssignment;
+exports.isBooleanLiteral = isBooleanLiteral;
+exports.isCharacterRange = isCharacterRange;
+exports.isConjunction = isConjunction;
+exports.isCrossReference = isCrossReference;
+exports.isDisjunction = isDisjunction;
+exports.isEndOfFile = isEndOfFile;
+exports.isGroup = isGroup;
+exports.isInferredType = isInferredType;
+exports.isInfixRule = isInfixRule;
+exports.isInterface = isInterface;
+exports.isKeyword = isKeyword;
+exports.isNegatedToken = isNegatedToken;
+exports.isNegation = isNegation;
+exports.isParameterReference = isParameterReference;
+exports.isParserRule = isParserRule;
+exports.isRegexToken = isRegexToken;
+exports.isReturnType = isReturnType;
+exports.isRuleCall = isRuleCall;
+exports.isSimpleType = isSimpleType;
+exports.isTerminalAlternatives = isTerminalAlternatives;
+exports.isTerminalGroup = isTerminalGroup;
+exports.isTerminalRule = isTerminalRule;
+exports.isTerminalRuleCall = isTerminalRuleCall;
+exports.isType = isType;
+exports.isUnorderedGroup = isUnorderedGroup;
+exports.isUntilToken = isUntilToken;
+exports.isWildcard = isWildcard;
+exports.reflection = reflection;