import { AbstractAstReflection as e } from "../../syntax-tree.js";
//#region ../../node_modules/langium/lib/languages/generated/ast.js
var t = {
	$type: "AbstractElement",
	cardinality: "cardinality"
};
function ee(e) {
	return $.isInstance(e, t.$type);
}
var n = { $type: "AbstractParserRule" };
function te(e) {
	return $.isInstance(e, n.$type);
}
var r = { $type: "AbstractRule" }, i = { $type: "AbstractType" }, a = {
	$type: "Action",
	cardinality: "cardinality",
	feature: "feature",
	inferredType: "inferredType",
	operator: "operator",
	type: "type"
};
function ne(e) {
	return $.isInstance(e, a.$type);
}
var o = {
	$type: "Alternatives",
	cardinality: "cardinality",
	elements: "elements"
};
function re(e) {
	return $.isInstance(e, o.$type);
}
var s = {
	$type: "ArrayLiteral",
	elements: "elements"
}, c = {
	$type: "ArrayType",
	elementType: "elementType"
}, l = {
	$type: "Assignment",
	cardinality: "cardinality",
	feature: "feature",
	operator: "operator",
	predicate: "predicate",
	terminal: "terminal"
};
function ie(e) {
	return $.isInstance(e, l.$type);
}
var u = {
	$type: "BooleanLiteral",
	true: "true"
};
function ae(e) {
	return $.isInstance(e, u.$type);
}
var d = {
	$type: "CharacterRange",
	cardinality: "cardinality",
	left: "left",
	lookahead: "lookahead",
	parenthesized: "parenthesized",
	right: "right"
};
function oe(e) {
	return $.isInstance(e, d.$type);
}
var f = { $type: "Condition" }, p = {
	$type: "Conjunction",
	left: "left",
	right: "right"
};
function se(e) {
	return $.isInstance(e, p.$type);
}
var m = {
	$type: "CrossReference",
	cardinality: "cardinality",
	deprecatedSyntax: "deprecatedSyntax",
	isMulti: "isMulti",
	terminal: "terminal",
	type: "type"
};
function ce(e) {
	return $.isInstance(e, m.$type);
}
var h = {
	$type: "Disjunction",
	left: "left",
	right: "right"
};
function le(e) {
	return $.isInstance(e, h.$type);
}
var g = {
	$type: "EndOfFile",
	cardinality: "cardinality"
};
function ue(e) {
	return $.isInstance(e, g.$type);
}
var _ = {
	$type: "Grammar",
	imports: "imports",
	interfaces: "interfaces",
	isDeclared: "isDeclared",
	name: "name",
	rules: "rules",
	types: "types"
}, v = {
	$type: "GrammarImport",
	path: "path"
}, y = {
	$type: "Group",
	cardinality: "cardinality",
	elements: "elements",
	guardCondition: "guardCondition",
	predicate: "predicate"
};
function de(e) {
	return $.isInstance(e, y.$type);
}
var b = {
	$type: "InferredType",
	name: "name"
};
function fe(e) {
	return $.isInstance(e, b.$type);
}
var x = {
	$type: "InfixRule",
	call: "call",
	dataType: "dataType",
	inferredType: "inferredType",
	name: "name",
	operators: "operators",
	parameters: "parameters",
	returnType: "returnType"
};
function pe(e) {
	return $.isInstance(e, x.$type);
}
var S = {
	$type: "InfixRuleOperatorList",
	associativity: "associativity",
	operators: "operators"
}, C = {
	$type: "InfixRuleOperators",
	precedences: "precedences"
}, w = {
	$type: "Interface",
	attributes: "attributes",
	name: "name",
	superTypes: "superTypes"
};
function me(e) {
	return $.isInstance(e, w.$type);
}
var T = {
	$type: "Keyword",
	cardinality: "cardinality",
	predicate: "predicate",
	value: "value"
};
function he(e) {
	return $.isInstance(e, T.$type);
}
var E = {
	$type: "NamedArgument",
	calledByName: "calledByName",
	parameter: "parameter",
	value: "value"
}, D = {
	$type: "NegatedToken",
	cardinality: "cardinality",
	lookahead: "lookahead",
	parenthesized: "parenthesized",
	terminal: "terminal"
};
function ge(e) {
	return $.isInstance(e, D.$type);
}
var O = {
	$type: "Negation",
	value: "value"
};
function _e(e) {
	return $.isInstance(e, O.$type);
}
var k = {
	$type: "NumberLiteral",
	value: "value"
}, A = {
	$type: "Parameter",
	name: "name"
}, j = {
	$type: "ParameterReference",
	parameter: "parameter"
};
function ve(e) {
	return $.isInstance(e, j.$type);
}
var M = {
	$type: "ParserRule",
	dataType: "dataType",
	definition: "definition",
	entry: "entry",
	fragment: "fragment",
	inferredType: "inferredType",
	name: "name",
	parameters: "parameters",
	returnType: "returnType"
};
function ye(e) {
	return $.isInstance(e, M.$type);
}
var N = {
	$type: "ReferenceType",
	isMulti: "isMulti",
	referenceType: "referenceType"
}, P = {
	$type: "RegexToken",
	cardinality: "cardinality",
	lookahead: "lookahead",
	parenthesized: "parenthesized",
	regex: "regex"
};
function be(e) {
	return $.isInstance(e, P.$type);
}
var F = {
	$type: "ReturnType",
	name: "name"
};
function xe(e) {
	return $.isInstance(e, F.$type);
}
var I = {
	$type: "RuleCall",
	arguments: "arguments",
	cardinality: "cardinality",
	predicate: "predicate",
	rule: "rule"
};
function Se(e) {
	return $.isInstance(e, I.$type);
}
var L = {
	$type: "SimpleType",
	primitiveType: "primitiveType",
	stringType: "stringType",
	typeRef: "typeRef"
};
function Ce(e) {
	return $.isInstance(e, L.$type);
}
var R = {
	$type: "StringLiteral",
	value: "value"
}, z = {
	$type: "TerminalAlternatives",
	cardinality: "cardinality",
	elements: "elements",
	lookahead: "lookahead",
	parenthesized: "parenthesized"
};
function we(e) {
	return $.isInstance(e, z.$type);
}
var B = {
	$type: "TerminalElement",
	cardinality: "cardinality",
	lookahead: "lookahead",
	parenthesized: "parenthesized"
}, V = {
	$type: "TerminalGroup",
	cardinality: "cardinality",
	elements: "elements",
	lookahead: "lookahead",
	parenthesized: "parenthesized"
};
function Te(e) {
	return $.isInstance(e, V.$type);
}
var H = {
	$type: "TerminalRule",
	definition: "definition",
	fragment: "fragment",
	hidden: "hidden",
	name: "name",
	type: "type"
};
function Ee(e) {
	return $.isInstance(e, H.$type);
}
var U = {
	$type: "TerminalRuleCall",
	cardinality: "cardinality",
	lookahead: "lookahead",
	parenthesized: "parenthesized",
	rule: "rule"
};
function De(e) {
	return $.isInstance(e, U.$type);
}
var W = {
	$type: "Type",
	name: "name",
	type: "type"
};
function Oe(e) {
	return $.isInstance(e, W.$type);
}
var G = {
	$type: "TypeAttribute",
	defaultValue: "defaultValue",
	isOptional: "isOptional",
	name: "name",
	type: "type"
}, K = { $type: "TypeDefinition" }, q = {
	$type: "UnionType",
	types: "types"
}, J = {
	$type: "UnorderedGroup",
	cardinality: "cardinality",
	elements: "elements"
};
function ke(e) {
	return $.isInstance(e, J.$type);
}
var Y = {
	$type: "UntilToken",
	cardinality: "cardinality",
	lookahead: "lookahead",
	parenthesized: "parenthesized",
	terminal: "terminal"
};
function Ae(e) {
	return $.isInstance(e, Y.$type);
}
var X = { $type: "ValueLiteral" }, Z = {
	$type: "Wildcard",
	cardinality: "cardinality",
	lookahead: "lookahead",
	parenthesized: "parenthesized"
};
function je(e) {
	return $.isInstance(e, Z.$type);
}
var Q = class extends e {
	constructor() {
		super(...arguments), this.types = {
			AbstractElement: {
				name: t.$type,
				properties: { cardinality: { name: t.cardinality } },
				superTypes: []
			},
			AbstractParserRule: {
				name: n.$type,
				properties: {},
				superTypes: [r.$type, i.$type]
			},
			AbstractRule: {
				name: r.$type,
				properties: {},
				superTypes: []
			},
			AbstractType: {
				name: i.$type,
				properties: {},
				superTypes: []
			},
			Action: {
				name: a.$type,
				properties: {
					cardinality: { name: a.cardinality },
					feature: { name: a.feature },
					inferredType: { name: a.inferredType },
					operator: { name: a.operator },
					type: {
						name: a.type,
						referenceType: i.$type
					}
				},
				superTypes: [t.$type]
			},
			Alternatives: {
				name: o.$type,
				properties: {
					cardinality: { name: o.cardinality },
					elements: {
						name: o.elements,
						defaultValue: []
					}
				},
				superTypes: [t.$type]
			},
			ArrayLiteral: {
				name: s.$type,
				properties: { elements: {
					name: s.elements,
					defaultValue: []
				} },
				superTypes: [X.$type]
			},
			ArrayType: {
				name: c.$type,
				properties: { elementType: { name: c.elementType } },
				superTypes: [K.$type]
			},
			Assignment: {
				name: l.$type,
				properties: {
					cardinality: { name: l.cardinality },
					feature: { name: l.feature },
					operator: { name: l.operator },
					predicate: { name: l.predicate },
					terminal: { name: l.terminal }
				},
				superTypes: [t.$type]
			},
			BooleanLiteral: {
				name: u.$type,
				properties: { true: {
					name: u.true,
					defaultValue: !1
				} },
				superTypes: [f.$type, X.$type]
			},
			CharacterRange: {
				name: d.$type,
				properties: {
					cardinality: { name: d.cardinality },
					left: { name: d.left },
					lookahead: { name: d.lookahead },
					parenthesized: {
						name: d.parenthesized,
						defaultValue: !1
					},
					right: { name: d.right }
				},
				superTypes: [B.$type]
			},
			Condition: {
				name: f.$type,
				properties: {},
				superTypes: []
			},
			Conjunction: {
				name: p.$type,
				properties: {
					left: { name: p.left },
					right: { name: p.right }
				},
				superTypes: [f.$type]
			},
			CrossReference: {
				name: m.$type,
				properties: {
					cardinality: { name: m.cardinality },
					deprecatedSyntax: {
						name: m.deprecatedSyntax,
						defaultValue: !1
					},
					isMulti: {
						name: m.isMulti,
						defaultValue: !1
					},
					terminal: { name: m.terminal },
					type: {
						name: m.type,
						referenceType: i.$type
					}
				},
				superTypes: [t.$type]
			},
			Disjunction: {
				name: h.$type,
				properties: {
					left: { name: h.left },
					right: { name: h.right }
				},
				superTypes: [f.$type]
			},
			EndOfFile: {
				name: g.$type,
				properties: { cardinality: { name: g.cardinality } },
				superTypes: [t.$type]
			},
			Grammar: {
				name: _.$type,
				properties: {
					imports: {
						name: _.imports,
						defaultValue: []
					},
					interfaces: {
						name: _.interfaces,
						defaultValue: []
					},
					isDeclared: {
						name: _.isDeclared,
						defaultValue: !1
					},
					name: { name: _.name },
					rules: {
						name: _.rules,
						defaultValue: []
					},
					types: {
						name: _.types,
						defaultValue: []
					}
				},
				superTypes: []
			},
			GrammarImport: {
				name: v.$type,
				properties: { path: { name: v.path } },
				superTypes: []
			},
			Group: {
				name: y.$type,
				properties: {
					cardinality: { name: y.cardinality },
					elements: {
						name: y.elements,
						defaultValue: []
					},
					guardCondition: { name: y.guardCondition },
					predicate: { name: y.predicate }
				},
				superTypes: [t.$type]
			},
			InferredType: {
				name: b.$type,
				properties: { name: { name: b.name } },
				superTypes: [i.$type]
			},
			InfixRule: {
				name: x.$type,
				properties: {
					call: { name: x.call },
					dataType: { name: x.dataType },
					inferredType: { name: x.inferredType },
					name: { name: x.name },
					operators: { name: x.operators },
					parameters: {
						name: x.parameters,
						defaultValue: []
					},
					returnType: {
						name: x.returnType,
						referenceType: i.$type
					}
				},
				superTypes: [n.$type]
			},
			InfixRuleOperatorList: {
				name: S.$type,
				properties: {
					associativity: { name: S.associativity },
					operators: {
						name: S.operators,
						defaultValue: []
					}
				},
				superTypes: []
			},
			InfixRuleOperators: {
				name: C.$type,
				properties: { precedences: {
					name: C.precedences,
					defaultValue: []
				} },
				superTypes: []
			},
			Interface: {
				name: w.$type,
				properties: {
					attributes: {
						name: w.attributes,
						defaultValue: []
					},
					name: { name: w.name },
					superTypes: {
						name: w.superTypes,
						defaultValue: [],
						referenceType: i.$type
					}
				},
				superTypes: [i.$type]
			},
			Keyword: {
				name: T.$type,
				properties: {
					cardinality: { name: T.cardinality },
					predicate: { name: T.predicate },
					value: { name: T.value }
				},
				superTypes: [t.$type]
			},
			NamedArgument: {
				name: E.$type,
				properties: {
					calledByName: {
						name: E.calledByName,
						defaultValue: !1
					},
					parameter: {
						name: E.parameter,
						referenceType: A.$type
					},
					value: { name: E.value }
				},
				superTypes: []
			},
			NegatedToken: {
				name: D.$type,
				properties: {
					cardinality: { name: D.cardinality },
					lookahead: { name: D.lookahead },
					parenthesized: {
						name: D.parenthesized,
						defaultValue: !1
					},
					terminal: { name: D.terminal }
				},
				superTypes: [B.$type]
			},
			Negation: {
				name: O.$type,
				properties: { value: { name: O.value } },
				superTypes: [f.$type]
			},
			NumberLiteral: {
				name: k.$type,
				properties: { value: { name: k.value } },
				superTypes: [X.$type]
			},
			Parameter: {
				name: A.$type,
				properties: { name: { name: A.name } },
				superTypes: []
			},
			ParameterReference: {
				name: j.$type,
				properties: { parameter: {
					name: j.parameter,
					referenceType: A.$type
				} },
				superTypes: [f.$type]
			},
			ParserRule: {
				name: M.$type,
				properties: {
					dataType: { name: M.dataType },
					definition: { name: M.definition },
					entry: {
						name: M.entry,
						defaultValue: !1
					},
					fragment: {
						name: M.fragment,
						defaultValue: !1
					},
					inferredType: { name: M.inferredType },
					name: { name: M.name },
					parameters: {
						name: M.parameters,
						defaultValue: []
					},
					returnType: {
						name: M.returnType,
						referenceType: i.$type
					}
				},
				superTypes: [n.$type]
			},
			ReferenceType: {
				name: N.$type,
				properties: {
					isMulti: {
						name: N.isMulti,
						defaultValue: !1
					},
					referenceType: { name: N.referenceType }
				},
				superTypes: [K.$type]
			},
			RegexToken: {
				name: P.$type,
				properties: {
					cardinality: { name: P.cardinality },
					lookahead: { name: P.lookahead },
					parenthesized: {
						name: P.parenthesized,
						defaultValue: !1
					},
					regex: { name: P.regex }
				},
				superTypes: [B.$type]
			},
			ReturnType: {
				name: F.$type,
				properties: { name: { name: F.name } },
				superTypes: []
			},
			RuleCall: {
				name: I.$type,
				properties: {
					arguments: {
						name: I.arguments,
						defaultValue: []
					},
					cardinality: { name: I.cardinality },
					predicate: { name: I.predicate },
					rule: {
						name: I.rule,
						referenceType: r.$type
					}
				},
				superTypes: [t.$type]
			},
			SimpleType: {
				name: L.$type,
				properties: {
					primitiveType: { name: L.primitiveType },
					stringType: { name: L.stringType },
					typeRef: {
						name: L.typeRef,
						referenceType: i.$type
					}
				},
				superTypes: [K.$type]
			},
			StringLiteral: {
				name: R.$type,
				properties: { value: { name: R.value } },
				superTypes: [X.$type]
			},
			TerminalAlternatives: {
				name: z.$type,
				properties: {
					cardinality: { name: z.cardinality },
					elements: {
						name: z.elements,
						defaultValue: []
					},
					lookahead: { name: z.lookahead },
					parenthesized: {
						name: z.parenthesized,
						defaultValue: !1
					}
				},
				superTypes: [B.$type]
			},
			TerminalElement: {
				name: B.$type,
				properties: {
					cardinality: { name: B.cardinality },
					lookahead: { name: B.lookahead },
					parenthesized: {
						name: B.parenthesized,
						defaultValue: !1
					}
				},
				superTypes: [t.$type]
			},
			TerminalGroup: {
				name: V.$type,
				properties: {
					cardinality: { name: V.cardinality },
					elements: {
						name: V.elements,
						defaultValue: []
					},
					lookahead: { name: V.lookahead },
					parenthesized: {
						name: V.parenthesized,
						defaultValue: !1
					}
				},
				superTypes: [B.$type]
			},
			TerminalRule: {
				name: H.$type,
				properties: {
					definition: { name: H.definition },
					fragment: {
						name: H.fragment,
						defaultValue: !1
					},
					hidden: {
						name: H.hidden,
						defaultValue: !1
					},
					name: { name: H.name },
					type: { name: H.type }
				},
				superTypes: [r.$type]
			},
			TerminalRuleCall: {
				name: U.$type,
				properties: {
					cardinality: { name: U.cardinality },
					lookahead: { name: U.lookahead },
					parenthesized: {
						name: U.parenthesized,
						defaultValue: !1
					},
					rule: {
						name: U.rule,
						referenceType: H.$type
					}
				},
				superTypes: [B.$type]
			},
			Type: {
				name: W.$type,
				properties: {
					name: { name: W.name },
					type: { name: W.type }
				},
				superTypes: [i.$type]
			},
			TypeAttribute: {
				name: G.$type,
				properties: {
					defaultValue: { name: G.defaultValue },
					isOptional: {
						name: G.isOptional,
						defaultValue: !1
					},
					name: { name: G.name },
					type: { name: G.type }
				},
				superTypes: []
			},
			TypeDefinition: {
				name: K.$type,
				properties: {},
				superTypes: []
			},
			UnionType: {
				name: q.$type,
				properties: { types: {
					name: q.types,
					defaultValue: []
				} },
				superTypes: [K.$type]
			},
			UnorderedGroup: {
				name: J.$type,
				properties: {
					cardinality: { name: J.cardinality },
					elements: {
						name: J.elements,
						defaultValue: []
					}
				},
				superTypes: [t.$type]
			},
			UntilToken: {
				name: Y.$type,
				properties: {
					cardinality: { name: Y.cardinality },
					lookahead: { name: Y.lookahead },
					parenthesized: {
						name: Y.parenthesized,
						defaultValue: !1
					},
					terminal: { name: Y.terminal }
				},
				superTypes: [B.$type]
			},
			ValueLiteral: {
				name: X.$type,
				properties: {},
				superTypes: []
			},
			Wildcard: {
				name: Z.$type,
				properties: {
					cardinality: { name: Z.cardinality },
					lookahead: { name: Z.lookahead },
					parenthesized: {
						name: Z.parenthesized,
						defaultValue: !1
					}
				},
				superTypes: [B.$type]
			}
		};
	}
}, $ = new Q();
//#endregion
export { Q as LangiumGrammarAstReflection, ee as isAbstractElement, te as isAbstractParserRule, ne as isAction, re as isAlternatives, ie as isAssignment, ae as isBooleanLiteral, oe as isCharacterRange, se as isConjunction, ce as isCrossReference, le as isDisjunction, ue as isEndOfFile, de as isGroup, fe as isInferredType, pe as isInfixRule, me as isInterface, he as isKeyword, ge as isNegatedToken, _e as isNegation, ve as isParameterReference, ye as isParserRule, be as isRegexToken, xe as isReturnType, Se as isRuleCall, Ce as isSimpleType, we as isTerminalAlternatives, Te as isTerminalGroup, Ee as isTerminalRule, De as isTerminalRuleCall, Oe as isType, ke as isUnorderedGroup, Ae as isUntilToken, je as isWildcard };
