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 };
