@loopstack/loopstack-studio 0.27.0 → 0.29.0

package/dist/node_modules/langium/lib/languages/generated/ast.js

@@ -1,1089 +0,0 @@
-import { __export } from "../../../../../_virtual/rolldown_runtime.js";
-import { AbstractAstReflection } from "../../syntax-tree.js";
-var ast_exports = /* @__PURE__ */ __export({
-	AbstractElement: () => AbstractElement,
-	AbstractParserRule: () => AbstractParserRule,
-	AbstractRule: () => AbstractRule,
-	AbstractType: () => AbstractType,
-	Action: () => Action,
-	Alternatives: () => Alternatives,
-	ArrayLiteral: () => ArrayLiteral,
-	ArrayType: () => ArrayType,
-	Assignment: () => Assignment,
-	BooleanLiteral: () => BooleanLiteral,
-	CharacterRange: () => CharacterRange,
-	Condition: () => Condition,
-	Conjunction: () => Conjunction,
-	CrossReference: () => CrossReference,
-	Disjunction: () => Disjunction,
-	EndOfFile: () => EndOfFile,
-	Grammar: () => Grammar,
-	GrammarImport: () => GrammarImport,
-	Group: () => Group,
-	InferredType: () => InferredType,
-	InfixRule: () => InfixRule,
-	InfixRuleOperatorList: () => InfixRuleOperatorList,
-	InfixRuleOperators: () => InfixRuleOperators,
-	Interface: () => Interface,
-	Keyword: () => Keyword,
-	LangiumGrammarAstReflection: () => LangiumGrammarAstReflection,
-	LangiumGrammarTerminals: () => LangiumGrammarTerminals,
-	NamedArgument: () => NamedArgument,
-	NegatedToken: () => NegatedToken,
-	Negation: () => Negation,
-	NumberLiteral: () => NumberLiteral,
-	Parameter: () => Parameter,
-	ParameterReference: () => ParameterReference,
-	ParserRule: () => ParserRule,
-	ReferenceType: () => ReferenceType,
-	RegexToken: () => RegexToken,
-	ReturnType: () => ReturnType,
-	RuleCall: () => RuleCall,
-	SimpleType: () => SimpleType,
-	StringLiteral: () => StringLiteral,
-	TerminalAlternatives: () => TerminalAlternatives,
-	TerminalElement: () => TerminalElement,
-	TerminalGroup: () => TerminalGroup,
-	TerminalRule: () => TerminalRule,
-	TerminalRuleCall: () => TerminalRuleCall,
-	Type: () => Type,
-	TypeAttribute: () => TypeAttribute,
-	TypeDefinition: () => TypeDefinition,
-	UnionType: () => UnionType,
-	UnorderedGroup: () => UnorderedGroup,
-	UntilToken: () => UntilToken,
-	ValueLiteral: () => ValueLiteral,
-	Wildcard: () => Wildcard,
-	isAbstractElement: () => isAbstractElement,
-	isAbstractParserRule: () => isAbstractParserRule,
-	isAbstractRule: () => isAbstractRule,
-	isAbstractType: () => isAbstractType,
-	isAction: () => isAction,
-	isAlternatives: () => isAlternatives,
-	isArrayLiteral: () => isArrayLiteral,
-	isArrayType: () => isArrayType,
-	isAssignment: () => isAssignment,
-	isBooleanLiteral: () => isBooleanLiteral,
-	isCharacterRange: () => isCharacterRange,
-	isCondition: () => isCondition,
-	isConjunction: () => isConjunction,
-	isCrossReference: () => isCrossReference,
-	isDisjunction: () => isDisjunction,
-	isEndOfFile: () => isEndOfFile,
-	isGrammar: () => isGrammar,
-	isGrammarImport: () => isGrammarImport,
-	isGroup: () => isGroup,
-	isInferredType: () => isInferredType,
-	isInfixRule: () => isInfixRule,
-	isInfixRuleOperatorList: () => isInfixRuleOperatorList,
-	isInfixRuleOperators: () => isInfixRuleOperators,
-	isInterface: () => isInterface,
-	isKeyword: () => isKeyword,
-	isNamedArgument: () => isNamedArgument,
-	isNegatedToken: () => isNegatedToken,
-	isNegation: () => isNegation,
-	isNumberLiteral: () => isNumberLiteral,
-	isParameter: () => isParameter,
-	isParameterReference: () => isParameterReference,
-	isParserRule: () => isParserRule,
-	isReferenceType: () => isReferenceType,
-	isRegexToken: () => isRegexToken,
-	isReturnType: () => isReturnType,
-	isRuleCall: () => isRuleCall,
-	isSimpleType: () => isSimpleType,
-	isStringLiteral: () => isStringLiteral,
-	isTerminalAlternatives: () => isTerminalAlternatives,
-	isTerminalElement: () => isTerminalElement,
-	isTerminalGroup: () => isTerminalGroup,
-	isTerminalRule: () => isTerminalRule,
-	isTerminalRuleCall: () => isTerminalRuleCall,
-	isType: () => isType,
-	isTypeAttribute: () => isTypeAttribute,
-	isTypeDefinition: () => isTypeDefinition,
-	isUnionType: () => isUnionType,
-	isUnorderedGroup: () => isUnorderedGroup,
-	isUntilToken: () => isUntilToken,
-	isValueLiteral: () => isValueLiteral,
-	isWildcard: () => isWildcard,
-	reflection: () => reflection
-}, 1);
-const LangiumGrammarTerminals = {
-	ID: /\^?[_a-zA-Z][\w_]*/,
-	STRING: /"(\\.|[^"\\])*"|'(\\.|[^'\\])*'/,
-	NUMBER: /NaN|-?((\d*\.\d+|\d+)([Ee][+-]?\d+)?|Infinity)/,
-	RegexLiteral: /\/(?![*+?])(?:[^\r\n\[/\\]|\\.|\[(?:[^\r\n\]\\]|\\.)*\])+\/[a-z]*/,
-	WS: /\s+/,
-	ML_COMMENT: /\/\*[\s\S]*?\*\//,
-	SL_COMMENT: /\/\/[^\n\r]*/
-}, AbstractElement = {
-	$type: "AbstractElement",
-	cardinality: "cardinality"
-};
-function isAbstractElement(e) {
-	return reflection.isInstance(e, AbstractElement.$type);
-}
-const AbstractParserRule = { $type: "AbstractParserRule" };
-function isAbstractParserRule(e) {
-	return reflection.isInstance(e, AbstractParserRule.$type);
-}
-const AbstractRule = { $type: "AbstractRule" };
-function isAbstractRule(e) {
-	return reflection.isInstance(e, AbstractRule.$type);
-}
-const AbstractType = { $type: "AbstractType" };
-function isAbstractType(e) {
-	return reflection.isInstance(e, AbstractType.$type);
-}
-const Action = {
-	$type: "Action",
-	cardinality: "cardinality",
-	feature: "feature",
-	inferredType: "inferredType",
-	operator: "operator",
-	type: "type"
-};
-function isAction(e) {
-	return reflection.isInstance(e, Action.$type);
-}
-const Alternatives = {
-	$type: "Alternatives",
-	cardinality: "cardinality",
-	elements: "elements"
-};
-function isAlternatives(e) {
-	return reflection.isInstance(e, Alternatives.$type);
-}
-const ArrayLiteral = {
-	$type: "ArrayLiteral",
-	elements: "elements"
-};
-function isArrayLiteral(e) {
-	return reflection.isInstance(e, ArrayLiteral.$type);
-}
-const ArrayType = {
-	$type: "ArrayType",
-	elementType: "elementType"
-};
-function isArrayType(e) {
-	return reflection.isInstance(e, ArrayType.$type);
-}
-const Assignment = {
-	$type: "Assignment",
-	cardinality: "cardinality",
-	feature: "feature",
-	operator: "operator",
-	predicate: "predicate",
-	terminal: "terminal"
-};
-function isAssignment(e) {
-	return reflection.isInstance(e, Assignment.$type);
-}
-const BooleanLiteral = {
-	$type: "BooleanLiteral",
-	true: "true"
-};
-function isBooleanLiteral(e) {
-	return reflection.isInstance(e, BooleanLiteral.$type);
-}
-const CharacterRange = {
-	$type: "CharacterRange",
-	cardinality: "cardinality",
-	left: "left",
-	lookahead: "lookahead",
-	parenthesized: "parenthesized",
-	right: "right"
-};
-function isCharacterRange(e) {
-	return reflection.isInstance(e, CharacterRange.$type);
-}
-const Condition = { $type: "Condition" };
-function isCondition(e) {
-	return reflection.isInstance(e, Condition.$type);
-}
-const Conjunction = {
-	$type: "Conjunction",
-	left: "left",
-	right: "right"
-};
-function isConjunction(e) {
-	return reflection.isInstance(e, Conjunction.$type);
-}
-const CrossReference = {
-	$type: "CrossReference",
-	cardinality: "cardinality",
-	deprecatedSyntax: "deprecatedSyntax",
-	isMulti: "isMulti",
-	terminal: "terminal",
-	type: "type"
-};
-function isCrossReference(e) {
-	return reflection.isInstance(e, CrossReference.$type);
-}
-const Disjunction = {
-	$type: "Disjunction",
-	left: "left",
-	right: "right"
-};
-function isDisjunction(e) {
-	return reflection.isInstance(e, Disjunction.$type);
-}
-const EndOfFile = {
-	$type: "EndOfFile",
-	cardinality: "cardinality"
-};
-function isEndOfFile(e) {
-	return reflection.isInstance(e, EndOfFile.$type);
-}
-const Grammar = {
-	$type: "Grammar",
-	imports: "imports",
-	interfaces: "interfaces",
-	isDeclared: "isDeclared",
-	name: "name",
-	rules: "rules",
-	types: "types"
-};
-function isGrammar(e) {
-	return reflection.isInstance(e, Grammar.$type);
-}
-const GrammarImport = {
-	$type: "GrammarImport",
-	path: "path"
-};
-function isGrammarImport(e) {
-	return reflection.isInstance(e, GrammarImport.$type);
-}
-const Group = {
-	$type: "Group",
-	cardinality: "cardinality",
-	elements: "elements",
-	guardCondition: "guardCondition",
-	predicate: "predicate"
-};
-function isGroup(e) {
-	return reflection.isInstance(e, Group.$type);
-}
-const InferredType = {
-	$type: "InferredType",
-	name: "name"
-};
-function isInferredType(e) {
-	return reflection.isInstance(e, InferredType.$type);
-}
-const InfixRule = {
-	$type: "InfixRule",
-	call: "call",
-	dataType: "dataType",
-	inferredType: "inferredType",
-	name: "name",
-	operators: "operators",
-	parameters: "parameters",
-	returnType: "returnType"
-};
-function isInfixRule(e) {
-	return reflection.isInstance(e, InfixRule.$type);
-}
-const InfixRuleOperatorList = {
-	$type: "InfixRuleOperatorList",
-	associativity: "associativity",
-	operators: "operators"
-};
-function isInfixRuleOperatorList(e) {
-	return reflection.isInstance(e, InfixRuleOperatorList.$type);
-}
-const InfixRuleOperators = {
-	$type: "InfixRuleOperators",
-	precedences: "precedences"
-};
-function isInfixRuleOperators(e) {
-	return reflection.isInstance(e, InfixRuleOperators.$type);
-}
-const Interface = {
-	$type: "Interface",
-	attributes: "attributes",
-	name: "name",
-	superTypes: "superTypes"
-};
-function isInterface(e) {
-	return reflection.isInstance(e, Interface.$type);
-}
-const Keyword = {
-	$type: "Keyword",
-	cardinality: "cardinality",
-	predicate: "predicate",
-	value: "value"
-};
-function isKeyword(e) {
-	return reflection.isInstance(e, Keyword.$type);
-}
-const NamedArgument = {
-	$type: "NamedArgument",
-	calledByName: "calledByName",
-	parameter: "parameter",
-	value: "value"
-};
-function isNamedArgument(e) {
-	return reflection.isInstance(e, NamedArgument.$type);
-}
-const NegatedToken = {
-	$type: "NegatedToken",
-	cardinality: "cardinality",
-	lookahead: "lookahead",
-	parenthesized: "parenthesized",
-	terminal: "terminal"
-};
-function isNegatedToken(e) {
-	return reflection.isInstance(e, NegatedToken.$type);
-}
-const Negation = {
-	$type: "Negation",
-	value: "value"
-};
-function isNegation(e) {
-	return reflection.isInstance(e, Negation.$type);
-}
-const NumberLiteral = {
-	$type: "NumberLiteral",
-	value: "value"
-};
-function isNumberLiteral(e) {
-	return reflection.isInstance(e, NumberLiteral.$type);
-}
-const Parameter = {
-	$type: "Parameter",
-	name: "name"
-};
-function isParameter(e) {
-	return reflection.isInstance(e, Parameter.$type);
-}
-const ParameterReference = {
-	$type: "ParameterReference",
-	parameter: "parameter"
-};
-function isParameterReference(e) {
-	return reflection.isInstance(e, ParameterReference.$type);
-}
-const ParserRule = {
-	$type: "ParserRule",
-	dataType: "dataType",
-	definition: "definition",
-	entry: "entry",
-	fragment: "fragment",
-	inferredType: "inferredType",
-	name: "name",
-	parameters: "parameters",
-	returnType: "returnType"
-};
-function isParserRule(e) {
-	return reflection.isInstance(e, ParserRule.$type);
-}
-const ReferenceType = {
-	$type: "ReferenceType",
-	isMulti: "isMulti",
-	referenceType: "referenceType"
-};
-function isReferenceType(e) {
-	return reflection.isInstance(e, ReferenceType.$type);
-}
-const RegexToken = {
-	$type: "RegexToken",
-	cardinality: "cardinality",
-	lookahead: "lookahead",
-	parenthesized: "parenthesized",
-	regex: "regex"
-};
-function isRegexToken(e) {
-	return reflection.isInstance(e, RegexToken.$type);
-}
-const ReturnType = {
-	$type: "ReturnType",
-	name: "name"
-};
-function isReturnType(e) {
-	return reflection.isInstance(e, ReturnType.$type);
-}
-const RuleCall = {
-	$type: "RuleCall",
-	arguments: "arguments",
-	cardinality: "cardinality",
-	predicate: "predicate",
-	rule: "rule"
-};
-function isRuleCall(e) {
-	return reflection.isInstance(e, RuleCall.$type);
-}
-const SimpleType = {
-	$type: "SimpleType",
-	primitiveType: "primitiveType",
-	stringType: "stringType",
-	typeRef: "typeRef"
-};
-function isSimpleType(e) {
-	return reflection.isInstance(e, SimpleType.$type);
-}
-const StringLiteral = {
-	$type: "StringLiteral",
-	value: "value"
-};
-function isStringLiteral(e) {
-	return reflection.isInstance(e, StringLiteral.$type);
-}
-const TerminalAlternatives = {
-	$type: "TerminalAlternatives",
-	cardinality: "cardinality",
-	elements: "elements",
-	lookahead: "lookahead",
-	parenthesized: "parenthesized"
-};
-function isTerminalAlternatives(e) {
-	return reflection.isInstance(e, TerminalAlternatives.$type);
-}
-const TerminalElement = {
-	$type: "TerminalElement",
-	cardinality: "cardinality",
-	lookahead: "lookahead",
-	parenthesized: "parenthesized"
-};
-function isTerminalElement(e) {
-	return reflection.isInstance(e, TerminalElement.$type);
-}
-const TerminalGroup = {
-	$type: "TerminalGroup",
-	cardinality: "cardinality",
-	elements: "elements",
-	lookahead: "lookahead",
-	parenthesized: "parenthesized"
-};
-function isTerminalGroup(e) {
-	return reflection.isInstance(e, TerminalGroup.$type);
-}
-const TerminalRule = {
-	$type: "TerminalRule",
-	definition: "definition",
-	fragment: "fragment",
-	hidden: "hidden",
-	name: "name",
-	type: "type"
-};
-function isTerminalRule(e) {
-	return reflection.isInstance(e, TerminalRule.$type);
-}
-const TerminalRuleCall = {
-	$type: "TerminalRuleCall",
-	cardinality: "cardinality",
-	lookahead: "lookahead",
-	parenthesized: "parenthesized",
-	rule: "rule"
-};
-function isTerminalRuleCall(e) {
-	return reflection.isInstance(e, TerminalRuleCall.$type);
-}
-const Type = {
-	$type: "Type",
-	name: "name",
-	type: "type"
-};
-function isType(e) {
-	return reflection.isInstance(e, Type.$type);
-}
-const TypeAttribute = {
-	$type: "TypeAttribute",
-	defaultValue: "defaultValue",
-	isOptional: "isOptional",
-	name: "name",
-	type: "type"
-};
-function isTypeAttribute(e) {
-	return reflection.isInstance(e, TypeAttribute.$type);
-}
-const TypeDefinition = { $type: "TypeDefinition" };
-function isTypeDefinition(e) {
-	return reflection.isInstance(e, TypeDefinition.$type);
-}
-const UnionType = {
-	$type: "UnionType",
-	types: "types"
-};
-function isUnionType(e) {
-	return reflection.isInstance(e, UnionType.$type);
-}
-const UnorderedGroup = {
-	$type: "UnorderedGroup",
-	cardinality: "cardinality",
-	elements: "elements"
-};
-function isUnorderedGroup(e) {
-	return reflection.isInstance(e, UnorderedGroup.$type);
-}
-const UntilToken = {
-	$type: "UntilToken",
-	cardinality: "cardinality",
-	lookahead: "lookahead",
-	parenthesized: "parenthesized",
-	terminal: "terminal"
-};
-function isUntilToken(e) {
-	return reflection.isInstance(e, UntilToken.$type);
-}
-const ValueLiteral = { $type: "ValueLiteral" };
-function isValueLiteral(e) {
-	return reflection.isInstance(e, ValueLiteral.$type);
-}
-const Wildcard = {
-	$type: "Wildcard",
-	cardinality: "cardinality",
-	lookahead: "lookahead",
-	parenthesized: "parenthesized"
-};
-function isWildcard(e) {
-	return reflection.isInstance(e, Wildcard.$type);
-}
-var LangiumGrammarAstReflection = class extends 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: !1
-				} },
-				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: !1
-					},
-					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: !1
-					},
-					isMulti: {
-						name: CrossReference.isMulti,
-						defaultValue: !1
-					},
-					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: !1
-					},
-					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: !1
-					},
-					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: !1
-					},
-					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: !1
-					},
-					fragment: {
-						name: ParserRule.fragment,
-						defaultValue: !1
-					},
-					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: !1
-					},
-					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: !1
-					},
-					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: !1
-					}
-				},
-				superTypes: [TerminalElement.$type]
-			},
-			TerminalElement: {
-				name: TerminalElement.$type,
-				properties: {
-					cardinality: { name: TerminalElement.cardinality },
-					lookahead: { name: TerminalElement.lookahead },
-					parenthesized: {
-						name: TerminalElement.parenthesized,
-						defaultValue: !1
-					}
-				},
-				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: !1
-					}
-				},
-				superTypes: [TerminalElement.$type]
-			},
-			TerminalRule: {
-				name: TerminalRule.$type,
-				properties: {
-					definition: { name: TerminalRule.definition },
-					fragment: {
-						name: TerminalRule.fragment,
-						defaultValue: !1
-					},
-					hidden: {
-						name: TerminalRule.hidden,
-						defaultValue: !1
-					},
-					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: !1
-					},
-					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: !1
-					},
-					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: !1
-					},
-					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: !1
-					}
-				},
-				superTypes: [TerminalElement.$type]
-			}
-		};
-	}
-};
-const reflection = new LangiumGrammarAstReflection();
-export { LangiumGrammarAstReflection, ast_exports, isAbstractElement, isAbstractParserRule, isAction, isAlternatives, isArrayType, isAssignment, isBooleanLiteral, isCharacterRange, isConjunction, isCrossReference, isDisjunction, isEndOfFile, isGroup, isInferredType, isInfixRule, isInterface, isKeyword, isNegatedToken, isNegation, isParameterReference, isParserRule, isReferenceType, isRegexToken, isReturnType, isRuleCall, isSimpleType, isTerminalAlternatives, isTerminalGroup, isTerminalRule, isTerminalRuleCall, isType, isUnionType, isUnorderedGroup, isUntilToken, isWildcard };