@loopstack/loopstack-studio 0.20.2 → 0.21.0-rc.0

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

@@ -0,0 +1,1089 @@
+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 };