@windrun-huaiin/third-ui 13.1.3 → 13.1.5

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

@@ -1,1216 +0,0 @@
-'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;