likec4 1.60.0 → 1.61.0

package/dist/chunks/libs/langium.d.mts

@@ -1,8 +1,6 @@
 /// <reference path="../../typings/thenable.d.ts" preserve="true" />
-import { i as __name, r as __exportAll } from "../rolldown-runtime.mjs";
-import { t as IToken$1 } from "./@chevrotain/types.mjs";
-import { CustomPatternMatcherFunc, DSLMethodOpts, EmbeddedActionsParser, ILexerErrorMessageProvider, ILexingError, IMultiModeLexerDefinition, IOrAlt, IParserConfig, IParserErrorMessageProvider, IRecognitionException, IRuleConfig, IToken, Lexer, TokenPattern, TokenType, TokenTypeDictionary, TokenVocabulary } from "chevrotain";
-//#region ../../node_modules/.pnpm/vscode-uri@3.2.0/node_modules/vscode-uri/lib/umd/uri.d.ts
+import { i as __name } from "../rolldown-runtime.mjs";
+import { DSLMethodOpts, EmbeddedActionsParser, ILexerErrorMessageProvider, ILexingError, IOrAlt, IParserConfig, IParserErrorMessageProvider, IRecognitionException, IRuleConfig, IToken, TokenType, TokenTypeDictionary, TokenVocabulary } from "chevrotain";
 /**
  * Uniform Resource Identifier (URI) http://tools.ietf.org/html/rfc3986.
  * This class is a simple parser which creates the basic component parts
@@ -144,78 +142,6 @@ interface UriComponents {
   query: string;
   fragment: string;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/vscode-uri@3.2.0/node_modules/vscode-uri/lib/umd/utils.d.ts
-declare namespace Utils {
-  /**
-   * Joins one or more input paths to the path of URI.
-   * '/' is used as the directory separation character.
-   *
-   * The resolved path will be normalized. That means:
-   *  - all '..' and '.' segments are resolved.
-   *  - multiple, sequential occurences of '/' are replaced by a single instance of '/'.
-   *  - trailing separators are preserved.
-   *
-   * @param uri The input URI.
-   * @param paths The paths to be joined with the path of URI.
-   * @returns A URI with the joined path. All other properties of the URI (scheme, authority, query, fragments, ...) will be taken from the input URI.
-   */
-  function joinPath(uri: URI$1, ...paths: string[]): URI$1;
-  /**
-   * Resolves one or more paths against the path of a URI.
-   * '/' is used as the directory separation character.
-   *
-   * The resolved path will be normalized. That means:
-   *  - all '..' and '.' segments are resolved.
-   *  - multiple, sequential occurences of '/' are replaced by a single instance of '/'.
-   *  - trailing separators are removed.
-   *
-   * @param uri The input URI.
-   * @param paths The paths to resolve against the path of URI.
-   * @returns A URI with the resolved path. All other properties of the URI (scheme, authority, query, fragments, ...) will be taken from the input URI.
-   */
-  function resolvePath(uri: URI$1, ...paths: string[]): URI$1;
-  /**
-   * Returns a URI where the path is the directory name of the input uri, similar to the Unix dirname command.
-   * In the path, '/' is recognized as the directory separation character. Trailing directory separators are ignored.
-   * The orignal URI is returned if the URIs path is empty or does not contain any path segments.
-   *
-   * @param uri The input URI.
-   * @return The last segment of the URIs path.
-   */
-  function dirname(uri: URI$1): URI$1;
-  /**
-   * Returns the last segment of the path of a URI, similar to the Unix basename command.
-   * In the path, '/' is recognized as the directory separation character. Trailing directory separators are ignored.
-   * The empty string is returned if the URIs path is empty or does not contain any path segments.
-   *
-   * @param uri The input URI.
-   * @return The base name of the URIs path.
-   */
-  function basename(uri: URI$1): string;
-  /**
-   * Returns the extension name of the path of a URI, similar to the Unix extname command.
-   * In the path, '/' is recognized as the directory separation character. Trailing directory separators are ignored.
-   * The empty string is returned if the URIs path is empty or does not contain any path segments.
-   *
-   * @param uri The input URI.
-   * @return The extension name of the URIs path.
-   */
-  function extname(uri: URI$1): string;
-}
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/utils/uri-utils.d.ts
-declare namespace UriUtils {
-  const basename: typeof Utils.basename;
-  const dirname: typeof Utils.dirname;
-  const extname: typeof Utils.extname;
-  const joinPath: typeof Utils.joinPath;
-  const resolvePath: typeof Utils.resolvePath;
-  function equals(a?: URI$1 | string, b?: URI$1 | string): boolean;
-  function relative(from: URI$1 | string, to: URI$1 | string): string;
-  function normalize(uri: URI$1 | string): string;
-  function contains(parent: URI$1 | string, child: URI$1 | string): boolean;
-}
 interface InternalUriTrieNode<T> {
   name: string;
   children: Map<string, InternalUriTrieNode<T>>;
@@ -252,21 +178,6 @@ declare class UriTrie<T> {
   protected getNode(uri: string, create: false): InternalUriTrieNode<T> | undefined;
   protected collectValues(node: InternalUriTrieNode<T>): T[];
 }
-declare namespace ast_d_exports {
-  export { AbstractElement, AbstractParserRule, AbstractRule, AbstractType, Action, Alternatives, ArrayLiteral, ArrayType, Assignment, Associativity, BooleanLiteral, CharacterRange, Condition, Conjunction, CrossReference, Disjunction, EndOfFile, FeatureName, Grammar, GrammarImport, Group, InferredType, InfixRule, InfixRuleOperatorList, InfixRuleOperators, Interface, Keyword, LangiumGrammarAstReflection, LangiumGrammarAstType, LangiumGrammarKeywordNames, LangiumGrammarTerminalNames, LangiumGrammarTerminals, LangiumGrammarTokenNames, NamedArgument, NegatedToken, Negation, NumberLiteral, Parameter, ParameterReference, ParserRule, PrimitiveType, ReferenceType, RegexToken, ReturnType$1 as ReturnType, RuleCall, SimpleType, StringLiteral, TerminalAlternatives, TerminalElement, TerminalGroup, TerminalRule, TerminalRuleCall, Type, TypeAttribute, TypeDefinition, UnionType, UnorderedGroup, UntilToken, ValueLiteral, Wildcard, isAbstractElement, isAbstractParserRule, isAbstractRule, isAbstractType, isAction, isAlternatives, isArrayLiteral, isArrayType, isAssignment, isBooleanLiteral, isCharacterRange, isCondition, isConjunction, isCrossReference, isDisjunction, isEndOfFile, isGrammar, isGrammarImport, isGroup, isInferredType, isInfixRule, isInfixRuleOperatorList, isInfixRuleOperators, isInterface, isKeyword, isNamedArgument, isNegatedToken, isNegation, isNumberLiteral, isParameter, isParameterReference, isParserRule, isReferenceType, isRegexToken, isReturnType, isRuleCall, isSimpleType, isStringLiteral, isTerminalAlternatives, isTerminalElement, isTerminalGroup, isTerminalRule, isTerminalRuleCall, isType, isTypeAttribute, isTypeDefinition, isUnionType, isUnorderedGroup, isUntilToken, isValueLiteral, isWildcard, reflection };
-}
-declare const LangiumGrammarTerminals: {
-  ID: RegExp;
-  STRING: RegExp;
-  NUMBER: RegExp;
-  RegexLiteral: RegExp;
-  WS: RegExp;
-  ML_COMMENT: RegExp;
-  SL_COMMENT: RegExp;
-};
-type LangiumGrammarTerminalNames = keyof typeof LangiumGrammarTerminals;
-type LangiumGrammarKeywordNames = "!" | "&" | "(" | ")" | "*" | "+" | "+=" | "," | "->" | "." | ".." | ":" | ";" | "<" | "=" | "=>" | ">" | "?" | "?!" | "?<!" | "?<=" | "?=" | "@" | "Date" | "EOF" | "[" | "]" | "assoc" | "bigint" | "boolean" | "current" | "entry" | "extends" | "false" | "fragment" | "grammar" | "hidden" | "import" | "infer" | "infers" | "infix" | "interface" | "left" | "number" | "on" | "returns" | "right" | "string" | "terminal" | "true" | "type" | "with" | "{" | "|" | "}";
-type LangiumGrammarTokenNames = LangiumGrammarTerminalNames | LangiumGrammarKeywordNames;
 interface AbstractElement extends AstNode {
   readonly $type: 'AbstractElement' | 'Action' | 'Alternatives' | 'Assignment' | 'CharacterRange' | 'CrossReference' | 'EndOfFile' | 'Group' | 'Keyword' | 'NegatedToken' | 'RegexToken' | 'RuleCall' | 'TerminalAlternatives' | 'TerminalElement' | 'TerminalGroup' | 'TerminalRuleCall' | 'UnorderedGroup' | 'UntilToken' | 'Wildcard';
   cardinality?: '*' | '+' | '?';
@@ -275,22 +186,18 @@ declare const AbstractElement: {
   readonly $type: "AbstractElement";
   readonly cardinality: "cardinality";
 };
-declare function isAbstractElement(item: unknown): item is AbstractElement;
 type AbstractParserRule = InfixRule | ParserRule;
 declare const AbstractParserRule: {
   readonly $type: "AbstractParserRule";
 };
-declare function isAbstractParserRule(item: unknown): item is AbstractParserRule;
 type AbstractRule = AbstractParserRule | TerminalRule;
 declare const AbstractRule: {
   readonly $type: "AbstractRule";
 };
-declare function isAbstractRule(item: unknown): item is AbstractRule;
 type AbstractType = AbstractParserRule | InferredType | Interface | Type;
 declare const AbstractType: {
   readonly $type: "AbstractType";
 };
-declare function isAbstractType(item: unknown): item is AbstractType;
 interface Action extends AbstractElement {
   readonly $type: 'Action';
   feature?: FeatureName;
@@ -306,17 +213,6 @@ declare const Action: {
   readonly operator: "operator";
   readonly type: "type";
 };
-declare function isAction(item: unknown): item is Action;
-interface Alternatives extends AbstractElement {
-  readonly $type: 'Alternatives';
-  elements: Array<AbstractElement>;
-}
-declare const Alternatives: {
-  readonly $type: "Alternatives";
-  readonly cardinality: "cardinality";
-  readonly elements: "elements";
-};
-declare function isAlternatives(item: unknown): item is Alternatives;
 interface ArrayLiteral extends AstNode {
   readonly $container: ArrayLiteral | TypeAttribute;
   readonly $type: 'ArrayLiteral';
@@ -326,7 +222,6 @@ declare const ArrayLiteral: {
   readonly $type: "ArrayLiteral";
   readonly elements: "elements";
 };
-declare function isArrayLiteral(item: unknown): item is ArrayLiteral;
 interface ArrayType extends AstNode {
   readonly $container: ArrayType | ReferenceType | Type | TypeAttribute | UnionType;
   readonly $type: 'ArrayType';
@@ -336,23 +231,6 @@ declare const ArrayType: {
   readonly $type: "ArrayType";
   readonly elementType: "elementType";
 };
-declare function isArrayType(item: unknown): item is ArrayType;
-interface Assignment extends AbstractElement {
-  readonly $type: 'Assignment';
-  feature: FeatureName;
-  operator: '+=' | '=' | '?=';
-  predicate?: '->' | '=>';
-  terminal: AbstractElement;
-}
-declare const Assignment: {
-  readonly $type: "Assignment";
-  readonly cardinality: "cardinality";
-  readonly feature: "feature";
-  readonly operator: "operator";
-  readonly predicate: "predicate";
-  readonly terminal: "terminal";
-};
-declare function isAssignment(item: unknown): item is Assignment;
 type Associativity = 'left' | 'right';
 interface BooleanLiteral extends AstNode {
   readonly $container: ArrayLiteral | Conjunction | Disjunction | Group | NamedArgument | Negation | TypeAttribute;
@@ -363,7 +241,6 @@ declare const BooleanLiteral: {
   readonly $type: "BooleanLiteral";
   readonly true: "true";
 };
-declare function isBooleanLiteral(item: unknown): item is BooleanLiteral;
 interface CharacterRange extends TerminalElement {
   readonly $type: 'CharacterRange';
   left: Keyword;
@@ -377,12 +254,10 @@ declare const CharacterRange: {
   readonly parenthesized: "parenthesized";
   readonly right: "right";
 };
-declare function isCharacterRange(item: unknown): item is CharacterRange;
 type Condition = BooleanLiteral | Conjunction | Disjunction | Negation | ParameterReference;
 declare const Condition: {
   readonly $type: "Condition";
 };
-declare function isCondition(item: unknown): item is Condition;
 interface Conjunction extends AstNode {
   readonly $container: Conjunction | Disjunction | Group | NamedArgument | Negation;
   readonly $type: 'Conjunction';
@@ -394,7 +269,6 @@ declare const Conjunction: {
   readonly left: "left";
   readonly right: "right";
 };
-declare function isConjunction(item: unknown): item is Conjunction;
 interface CrossReference extends AbstractElement {
   readonly $type: 'CrossReference';
   deprecatedSyntax: boolean;
@@ -410,7 +284,6 @@ declare const CrossReference: {
   readonly terminal: "terminal";
   readonly type: "type";
 };
-declare function isCrossReference(item: unknown): item is CrossReference;
 interface Disjunction extends AstNode {
   readonly $container: Conjunction | Disjunction | Group | NamedArgument | Negation;
   readonly $type: 'Disjunction';
@@ -422,15 +295,6 @@ declare const Disjunction: {
   readonly left: "left";
   readonly right: "right";
 };
-declare function isDisjunction(item: unknown): item is Disjunction;
-interface EndOfFile extends AbstractElement {
-  readonly $type: 'EndOfFile';
-}
-declare const EndOfFile: {
-  readonly $type: "EndOfFile";
-  readonly cardinality: "cardinality";
-};
-declare function isEndOfFile(item: unknown): item is EndOfFile;
 type FeatureName = 'assoc' | 'current' | 'entry' | 'extends' | 'false' | 'fragment' | 'grammar' | 'hidden' | 'import' | 'infer' | 'infers' | 'infix' | 'interface' | 'left' | 'on' | 'returns' | 'right' | 'terminal' | 'true' | 'type' | 'with' | PrimitiveType | string;
 interface Grammar extends AstNode {
   readonly $type: 'Grammar';
@@ -450,7 +314,6 @@ declare const Grammar: {
   readonly rules: "rules";
   readonly types: "types";
 };
-declare function isGrammar(item: unknown): item is Grammar;
 interface GrammarImport extends AstNode {
   readonly $container: Grammar;
   readonly $type: 'GrammarImport';
@@ -460,7 +323,6 @@ declare const GrammarImport: {
   readonly $type: "GrammarImport";
   readonly path: "path";
 };
-declare function isGrammarImport(item: unknown): item is GrammarImport;
 interface Group extends AbstractElement {
   readonly $type: 'Group';
   elements: Array<AbstractElement>;
@@ -474,7 +336,6 @@ declare const Group: {
   readonly guardCondition: "guardCondition";
   readonly predicate: "predicate";
 };
-declare function isGroup(item: unknown): item is Group;
 interface InferredType extends AstNode {
   readonly $container: Action | InfixRule | ParserRule;
   readonly $type: 'InferredType';
@@ -484,7 +345,6 @@ declare const InferredType: {
   readonly $type: "InferredType";
   readonly name: "name";
 };
-declare function isInferredType(item: unknown): item is InferredType;
 interface InfixRule extends AstNode {
   readonly $container: Grammar;
   readonly $type: 'InfixRule';
@@ -506,7 +366,6 @@ declare const InfixRule: {
   readonly parameters: "parameters";
   readonly returnType: "returnType";
 };
-declare function isInfixRule(item: unknown): item is InfixRule;
 interface InfixRuleOperatorList extends AstNode {
   readonly $container: InfixRuleOperators;
   readonly $type: 'InfixRuleOperatorList';
@@ -518,7 +377,6 @@ declare const InfixRuleOperatorList: {
   readonly associativity: "associativity";
   readonly operators: "operators";
 };
-declare function isInfixRuleOperatorList(item: unknown): item is InfixRuleOperatorList;
 interface InfixRuleOperators extends AstNode {
   readonly $container: InfixRule;
   readonly $type: 'InfixRuleOperators';
@@ -528,7 +386,6 @@ declare const InfixRuleOperators: {
   readonly $type: "InfixRuleOperators";
   readonly precedences: "precedences";
 };
-declare function isInfixRuleOperators(item: unknown): item is InfixRuleOperators;
 interface Interface extends AstNode {
   readonly $container: Grammar;
   readonly $type: 'Interface';
@@ -542,7 +399,6 @@ declare const Interface: {
   readonly name: "name";
   readonly superTypes: "superTypes";
 };
-declare function isInterface(item: unknown): item is Interface;
 interface Keyword extends AbstractElement {
   readonly $container: CharacterRange | InfixRuleOperatorList;
   readonly $type: 'Keyword';
@@ -555,7 +411,6 @@ declare const Keyword: {
   readonly predicate: "predicate";
   readonly value: "value";
 };
-declare function isKeyword(item: unknown): item is Keyword;
 interface NamedArgument extends AstNode {
   readonly $container: RuleCall;
   readonly $type: 'NamedArgument';
@@ -569,19 +424,6 @@ declare const NamedArgument: {
   readonly parameter: "parameter";
   readonly value: "value";
 };
-declare function isNamedArgument(item: unknown): item is NamedArgument;
-interface NegatedToken extends TerminalElement {
-  readonly $type: 'NegatedToken';
-  terminal: AbstractElement;
-}
-declare const NegatedToken: {
-  readonly $type: "NegatedToken";
-  readonly cardinality: "cardinality";
-  readonly lookahead: "lookahead";
-  readonly parenthesized: "parenthesized";
-  readonly terminal: "terminal";
-};
-declare function isNegatedToken(item: unknown): item is NegatedToken;
 interface Negation extends AstNode {
   readonly $container: Conjunction | Disjunction | Group | NamedArgument | Negation;
   readonly $type: 'Negation';
@@ -591,7 +433,6 @@ declare const Negation: {
   readonly $type: "Negation";
   readonly value: "value";
 };
-declare function isNegation(item: unknown): item is Negation;
 interface NumberLiteral extends AstNode {
   readonly $container: ArrayLiteral | TypeAttribute;
   readonly $type: 'NumberLiteral';
@@ -601,7 +442,6 @@ declare const NumberLiteral: {
   readonly $type: "NumberLiteral";
   readonly value: "value";
 };
-declare function isNumberLiteral(item: unknown): item is NumberLiteral;
 interface Parameter extends AstNode {
   readonly $container: InfixRule | ParserRule;
   readonly $type: 'Parameter';
@@ -611,7 +451,6 @@ declare const Parameter: {
   readonly $type: "Parameter";
   readonly name: "name";
 };
-declare function isParameter(item: unknown): item is Parameter;
 interface ParameterReference extends AstNode {
   readonly $container: Conjunction | Disjunction | Group | NamedArgument | Negation;
   readonly $type: 'ParameterReference';
@@ -621,7 +460,6 @@ declare const ParameterReference: {
   readonly $type: "ParameterReference";
   readonly parameter: "parameter";
 };
-declare function isParameterReference(item: unknown): item is ParameterReference;
 interface ParserRule extends AstNode {
   readonly $container: Grammar;
   readonly $type: 'ParserRule';
@@ -645,7 +483,6 @@ declare const ParserRule: {
   readonly parameters: "parameters";
   readonly returnType: "returnType";
 };
-declare function isParserRule(item: unknown): item is ParserRule;
 type PrimitiveType = 'Date' | 'bigint' | 'boolean' | 'number' | 'string';
 interface ReferenceType extends AstNode {
   readonly $container: ArrayType | ReferenceType | Type | TypeAttribute | UnionType;
@@ -658,29 +495,15 @@ declare const ReferenceType: {
   readonly isMulti: "isMulti";
   readonly referenceType: "referenceType";
 };
-declare function isReferenceType(item: unknown): item is ReferenceType;
-interface RegexToken extends TerminalElement {
-  readonly $type: 'RegexToken';
-  regex: string;
-}
-declare const RegexToken: {
-  readonly $type: "RegexToken";
-  readonly cardinality: "cardinality";
-  readonly lookahead: "lookahead";
-  readonly parenthesized: "parenthesized";
-  readonly regex: "regex";
-};
-declare function isRegexToken(item: unknown): item is RegexToken;
-interface ReturnType$1 extends AstNode {
+interface ReturnType extends AstNode {
   readonly $container: TerminalRule;
   readonly $type: 'ReturnType';
   name: PrimitiveType | string;
 }
-declare const ReturnType$1: {
+declare const ReturnType: {
   readonly $type: "ReturnType";
   readonly name: "name";
 };
-declare function isReturnType(item: unknown): item is ReturnType$1;
 interface RuleCall extends AbstractElement {
   readonly $container: InfixRule;
   readonly $type: 'RuleCall';
@@ -695,7 +518,6 @@ declare const RuleCall: {
   readonly predicate: "predicate";
   readonly rule: "rule";
 };
-declare function isRuleCall(item: unknown): item is RuleCall;
 interface SimpleType extends AstNode {
   readonly $container: ArrayType | ReferenceType | Type | TypeAttribute | UnionType;
   readonly $type: 'SimpleType';
@@ -709,7 +531,6 @@ declare const SimpleType: {
   readonly stringType: "stringType";
   readonly typeRef: "typeRef";
 };
-declare function isSimpleType(item: unknown): item is SimpleType;
 interface StringLiteral extends AstNode {
   readonly $container: ArrayLiteral | TypeAttribute;
   readonly $type: 'StringLiteral';
@@ -719,19 +540,6 @@ declare const StringLiteral: {
   readonly $type: "StringLiteral";
   readonly value: "value";
 };
-declare function isStringLiteral(item: unknown): item is StringLiteral;
-interface TerminalAlternatives extends TerminalElement {
-  readonly $type: 'TerminalAlternatives';
-  elements: Array<AbstractElement>;
-}
-declare const TerminalAlternatives: {
-  readonly $type: "TerminalAlternatives";
-  readonly cardinality: "cardinality";
-  readonly elements: "elements";
-  readonly lookahead: "lookahead";
-  readonly parenthesized: "parenthesized";
-};
-declare function isTerminalAlternatives(item: unknown): item is TerminalAlternatives;
 interface TerminalElement extends AbstractElement {
   readonly $type: 'CharacterRange' | 'NegatedToken' | 'RegexToken' | 'TerminalAlternatives' | 'TerminalElement' | 'TerminalGroup' | 'TerminalRuleCall' | 'UntilToken' | 'Wildcard';
   lookahead?: '?!' | '?<!' | '?<=' | '?=';
@@ -743,19 +551,6 @@ declare const TerminalElement: {
   readonly lookahead: "lookahead";
   readonly parenthesized: "parenthesized";
 };
-declare function isTerminalElement(item: unknown): item is TerminalElement;
-interface TerminalGroup extends TerminalElement {
-  readonly $type: 'TerminalGroup';
-  elements: Array<AbstractElement>;
-}
-declare const TerminalGroup: {
-  readonly $type: "TerminalGroup";
-  readonly cardinality: "cardinality";
-  readonly elements: "elements";
-  readonly lookahead: "lookahead";
-  readonly parenthesized: "parenthesized";
-};
-declare function isTerminalGroup(item: unknown): item is TerminalGroup;
 interface TerminalRule extends AstNode {
   readonly $container: Grammar;
   readonly $type: 'TerminalRule';
@@ -763,7 +558,7 @@ interface TerminalRule extends AstNode {
   fragment: boolean;
   hidden: boolean;
   name: string;
-  type?: ReturnType$1;
+  type?: ReturnType;
 }
 declare const TerminalRule: {
   readonly $type: "TerminalRule";
@@ -773,19 +568,6 @@ declare const TerminalRule: {
   readonly name: "name";
   readonly type: "type";
 };
-declare function isTerminalRule(item: unknown): item is TerminalRule;
-interface TerminalRuleCall extends TerminalElement {
-  readonly $type: 'TerminalRuleCall';
-  rule: Reference<TerminalRule>;
-}
-declare const TerminalRuleCall: {
-  readonly $type: "TerminalRuleCall";
-  readonly cardinality: "cardinality";
-  readonly lookahead: "lookahead";
-  readonly parenthesized: "parenthesized";
-  readonly rule: "rule";
-};
-declare function isTerminalRuleCall(item: unknown): item is TerminalRuleCall;
 interface Type extends AstNode {
   readonly $container: Grammar;
   readonly $type: 'Type';
@@ -797,7 +579,6 @@ declare const Type: {
   readonly name: "name";
   readonly type: "type";
 };
-declare function isType(item: unknown): item is Type;
 interface TypeAttribute extends AstNode {
   readonly $container: Interface;
   readonly $type: 'TypeAttribute';
@@ -813,12 +594,10 @@ declare const TypeAttribute: {
   readonly name: "name";
   readonly type: "type";
 };
-declare function isTypeAttribute(item: unknown): item is TypeAttribute;
 type TypeDefinition = ArrayType | ReferenceType | SimpleType | UnionType;
 declare const TypeDefinition: {
   readonly $type: "TypeDefinition";
 };
-declare function isTypeDefinition(item: unknown): item is TypeDefinition;
 interface UnionType extends AstNode {
   readonly $container: ArrayType | ReferenceType | Type | TypeAttribute | UnionType;
   readonly $type: 'UnionType';
@@ -828,901 +607,10 @@ declare const UnionType: {
   readonly $type: "UnionType";
   readonly types: "types";
 };
-declare function isUnionType(item: unknown): item is UnionType;
-interface UnorderedGroup extends AbstractElement {
-  readonly $type: 'UnorderedGroup';
-  elements: Array<AbstractElement>;
-}
-declare const UnorderedGroup: {
-  readonly $type: "UnorderedGroup";
-  readonly cardinality: "cardinality";
-  readonly elements: "elements";
-};
-declare function isUnorderedGroup(item: unknown): item is UnorderedGroup;
-interface UntilToken extends TerminalElement {
-  readonly $type: 'UntilToken';
-  terminal: AbstractElement;
-}
-declare const UntilToken: {
-  readonly $type: "UntilToken";
-  readonly cardinality: "cardinality";
-  readonly lookahead: "lookahead";
-  readonly parenthesized: "parenthesized";
-  readonly terminal: "terminal";
-};
-declare function isUntilToken(item: unknown): item is UntilToken;
 type ValueLiteral = ArrayLiteral | BooleanLiteral | NumberLiteral | StringLiteral;
 declare const ValueLiteral: {
   readonly $type: "ValueLiteral";
 };
-declare function isValueLiteral(item: unknown): item is ValueLiteral;
-interface Wildcard extends TerminalElement {
-  readonly $type: 'Wildcard';
-}
-declare const Wildcard: {
-  readonly $type: "Wildcard";
-  readonly cardinality: "cardinality";
-  readonly lookahead: "lookahead";
-  readonly parenthesized: "parenthesized";
-};
-declare function isWildcard(item: unknown): item is Wildcard;
-type LangiumGrammarAstType = {
-  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;
-  NamedArgument: NamedArgument;
-  NegatedToken: NegatedToken;
-  Negation: Negation;
-  NumberLiteral: NumberLiteral;
-  Parameter: Parameter;
-  ParameterReference: ParameterReference;
-  ParserRule: ParserRule;
-  ReferenceType: ReferenceType;
-  RegexToken: RegexToken;
-  ReturnType: ReturnType$1;
-  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;
-};
-declare class LangiumGrammarAstReflection extends AbstractAstReflection {
-  readonly types: {
-    readonly AbstractElement: {
-      readonly name: "AbstractElement";
-      readonly properties: {
-        readonly cardinality: {
-          readonly name: "cardinality";
-          readonly optional: true;
-        };
-      };
-      readonly superTypes: [];
-    };
-    readonly AbstractParserRule: {
-      readonly name: "AbstractParserRule";
-      readonly properties: {};
-      readonly superTypes: ["AbstractRule", "AbstractType"];
-    };
-    readonly AbstractRule: {
-      readonly name: "AbstractRule";
-      readonly properties: {};
-      readonly superTypes: [];
-    };
-    readonly AbstractType: {
-      readonly name: "AbstractType";
-      readonly properties: {};
-      readonly superTypes: [];
-    };
-    readonly Action: {
-      readonly name: "Action";
-      readonly properties: {
-        readonly cardinality: {
-          readonly name: "cardinality";
-          readonly optional: true;
-        };
-        readonly feature: {
-          readonly name: "feature";
-          readonly optional: true;
-        };
-        readonly inferredType: {
-          readonly name: "inferredType";
-          readonly optional: true;
-        };
-        readonly operator: {
-          readonly name: "operator";
-          readonly optional: true;
-        };
-        readonly type: {
-          readonly name: "type";
-          readonly referenceType: "AbstractType";
-          readonly optional: true;
-        };
-      };
-      readonly superTypes: ["AbstractElement"];
-    };
-    readonly Alternatives: {
-      readonly name: "Alternatives";
-      readonly properties: {
-        readonly cardinality: {
-          readonly name: "cardinality";
-          readonly optional: true;
-        };
-        readonly elements: {
-          readonly name: "elements";
-          readonly defaultValue: [];
-        };
-      };
-      readonly superTypes: ["AbstractElement"];
-    };
-    readonly ArrayLiteral: {
-      readonly name: "ArrayLiteral";
-      readonly properties: {
-        readonly elements: {
-          readonly name: "elements";
-          readonly defaultValue: [];
-        };
-      };
-      readonly superTypes: ["ValueLiteral"];
-    };
-    readonly ArrayType: {
-      readonly name: "ArrayType";
-      readonly properties: {
-        readonly elementType: {
-          readonly name: "elementType";
-        };
-      };
-      readonly superTypes: ["TypeDefinition"];
-    };
-    readonly Assignment: {
-      readonly name: "Assignment";
-      readonly properties: {
-        readonly cardinality: {
-          readonly name: "cardinality";
-          readonly optional: true;
-        };
-        readonly feature: {
-          readonly name: "feature";
-        };
-        readonly operator: {
-          readonly name: "operator";
-        };
-        readonly predicate: {
-          readonly name: "predicate";
-          readonly optional: true;
-        };
-        readonly terminal: {
-          readonly name: "terminal";
-        };
-      };
-      readonly superTypes: ["AbstractElement"];
-    };
-    readonly BooleanLiteral: {
-      readonly name: "BooleanLiteral";
-      readonly properties: {
-        readonly true: {
-          readonly name: "true";
-          readonly defaultValue: false;
-        };
-      };
-      readonly superTypes: ["Condition", "ValueLiteral"];
-    };
-    readonly CharacterRange: {
-      readonly name: "CharacterRange";
-      readonly properties: {
-        readonly cardinality: {
-          readonly name: "cardinality";
-          readonly optional: true;
-        };
-        readonly left: {
-          readonly name: "left";
-        };
-        readonly lookahead: {
-          readonly name: "lookahead";
-          readonly optional: true;
-        };
-        readonly parenthesized: {
-          readonly name: "parenthesized";
-          readonly defaultValue: false;
-          readonly optional: true;
-        };
-        readonly right: {
-          readonly name: "right";
-          readonly optional: true;
-        };
-      };
-      readonly superTypes: ["TerminalElement"];
-    };
-    readonly Condition: {
-      readonly name: "Condition";
-      readonly properties: {};
-      readonly superTypes: [];
-    };
-    readonly Conjunction: {
-      readonly name: "Conjunction";
-      readonly properties: {
-        readonly left: {
-          readonly name: "left";
-        };
-        readonly right: {
-          readonly name: "right";
-        };
-      };
-      readonly superTypes: ["Condition"];
-    };
-    readonly CrossReference: {
-      readonly name: "CrossReference";
-      readonly properties: {
-        readonly cardinality: {
-          readonly name: "cardinality";
-          readonly optional: true;
-        };
-        readonly deprecatedSyntax: {
-          readonly name: "deprecatedSyntax";
-          readonly defaultValue: false;
-        };
-        readonly isMulti: {
-          readonly name: "isMulti";
-          readonly defaultValue: false;
-        };
-        readonly terminal: {
-          readonly name: "terminal";
-          readonly optional: true;
-        };
-        readonly type: {
-          readonly name: "type";
-          readonly referenceType: "AbstractType";
-        };
-      };
-      readonly superTypes: ["AbstractElement"];
-    };
-    readonly Disjunction: {
-      readonly name: "Disjunction";
-      readonly properties: {
-        readonly left: {
-          readonly name: "left";
-        };
-        readonly right: {
-          readonly name: "right";
-        };
-      };
-      readonly superTypes: ["Condition"];
-    };
-    readonly EndOfFile: {
-      readonly name: "EndOfFile";
-      readonly properties: {
-        readonly cardinality: {
-          readonly name: "cardinality";
-          readonly optional: true;
-        };
-      };
-      readonly superTypes: ["AbstractElement"];
-    };
-    readonly Grammar: {
-      readonly name: "Grammar";
-      readonly properties: {
-        readonly imports: {
-          readonly name: "imports";
-          readonly defaultValue: [];
-        };
-        readonly interfaces: {
-          readonly name: "interfaces";
-          readonly defaultValue: [];
-        };
-        readonly isDeclared: {
-          readonly name: "isDeclared";
-          readonly defaultValue: false;
-        };
-        readonly name: {
-          readonly name: "name";
-          readonly optional: true;
-        };
-        readonly rules: {
-          readonly name: "rules";
-          readonly defaultValue: [];
-        };
-        readonly types: {
-          readonly name: "types";
-          readonly defaultValue: [];
-        };
-      };
-      readonly superTypes: [];
-    };
-    readonly GrammarImport: {
-      readonly name: "GrammarImport";
-      readonly properties: {
-        readonly path: {
-          readonly name: "path";
-        };
-      };
-      readonly superTypes: [];
-    };
-    readonly Group: {
-      readonly name: "Group";
-      readonly properties: {
-        readonly cardinality: {
-          readonly name: "cardinality";
-          readonly optional: true;
-        };
-        readonly elements: {
-          readonly name: "elements";
-          readonly defaultValue: [];
-        };
-        readonly guardCondition: {
-          readonly name: "guardCondition";
-          readonly optional: true;
-        };
-        readonly predicate: {
-          readonly name: "predicate";
-          readonly optional: true;
-        };
-      };
-      readonly superTypes: ["AbstractElement"];
-    };
-    readonly InferredType: {
-      readonly name: "InferredType";
-      readonly properties: {
-        readonly name: {
-          readonly name: "name";
-        };
-      };
-      readonly superTypes: ["AbstractType"];
-    };
-    readonly InfixRule: {
-      readonly name: "InfixRule";
-      readonly properties: {
-        readonly call: {
-          readonly name: "call";
-        };
-        readonly dataType: {
-          readonly name: "dataType";
-          readonly optional: true;
-        };
-        readonly inferredType: {
-          readonly name: "inferredType";
-          readonly optional: true;
-        };
-        readonly name: {
-          readonly name: "name";
-        };
-        readonly operators: {
-          readonly name: "operators";
-        };
-        readonly parameters: {
-          readonly name: "parameters";
-          readonly defaultValue: [];
-        };
-        readonly returnType: {
-          readonly name: "returnType";
-          readonly referenceType: "AbstractType";
-          readonly optional: true;
-        };
-      };
-      readonly superTypes: ["AbstractParserRule"];
-    };
-    readonly InfixRuleOperatorList: {
-      readonly name: "InfixRuleOperatorList";
-      readonly properties: {
-        readonly associativity: {
-          readonly name: "associativity";
-          readonly optional: true;
-        };
-        readonly operators: {
-          readonly name: "operators";
-          readonly defaultValue: [];
-        };
-      };
-      readonly superTypes: [];
-    };
-    readonly InfixRuleOperators: {
-      readonly name: "InfixRuleOperators";
-      readonly properties: {
-        readonly precedences: {
-          readonly name: "precedences";
-          readonly defaultValue: [];
-        };
-      };
-      readonly superTypes: [];
-    };
-    readonly Interface: {
-      readonly name: "Interface";
-      readonly properties: {
-        readonly attributes: {
-          readonly name: "attributes";
-          readonly defaultValue: [];
-        };
-        readonly name: {
-          readonly name: "name";
-        };
-        readonly superTypes: {
-          readonly name: "superTypes";
-          readonly defaultValue: [];
-          readonly referenceType: "AbstractType";
-        };
-      };
-      readonly superTypes: ["AbstractType"];
-    };
-    readonly Keyword: {
-      readonly name: "Keyword";
-      readonly properties: {
-        readonly cardinality: {
-          readonly name: "cardinality";
-          readonly optional: true;
-        };
-        readonly predicate: {
-          readonly name: "predicate";
-          readonly optional: true;
-        };
-        readonly value: {
-          readonly name: "value";
-        };
-      };
-      readonly superTypes: ["AbstractElement"];
-    };
-    readonly NamedArgument: {
-      readonly name: "NamedArgument";
-      readonly properties: {
-        readonly calledByName: {
-          readonly name: "calledByName";
-          readonly defaultValue: false;
-        };
-        readonly parameter: {
-          readonly name: "parameter";
-          readonly referenceType: "Parameter";
-          readonly optional: true;
-        };
-        readonly value: {
-          readonly name: "value";
-        };
-      };
-      readonly superTypes: [];
-    };
-    readonly NegatedToken: {
-      readonly name: "NegatedToken";
-      readonly properties: {
-        readonly cardinality: {
-          readonly name: "cardinality";
-          readonly optional: true;
-        };
-        readonly lookahead: {
-          readonly name: "lookahead";
-          readonly optional: true;
-        };
-        readonly parenthesized: {
-          readonly name: "parenthesized";
-          readonly defaultValue: false;
-          readonly optional: true;
-        };
-        readonly terminal: {
-          readonly name: "terminal";
-        };
-      };
-      readonly superTypes: ["TerminalElement"];
-    };
-    readonly Negation: {
-      readonly name: "Negation";
-      readonly properties: {
-        readonly value: {
-          readonly name: "value";
-        };
-      };
-      readonly superTypes: ["Condition"];
-    };
-    readonly NumberLiteral: {
-      readonly name: "NumberLiteral";
-      readonly properties: {
-        readonly value: {
-          readonly name: "value";
-        };
-      };
-      readonly superTypes: ["ValueLiteral"];
-    };
-    readonly Parameter: {
-      readonly name: "Parameter";
-      readonly properties: {
-        readonly name: {
-          readonly name: "name";
-        };
-      };
-      readonly superTypes: [];
-    };
-    readonly ParameterReference: {
-      readonly name: "ParameterReference";
-      readonly properties: {
-        readonly parameter: {
-          readonly name: "parameter";
-          readonly referenceType: "Parameter";
-        };
-      };
-      readonly superTypes: ["Condition"];
-    };
-    readonly ParserRule: {
-      readonly name: "ParserRule";
-      readonly properties: {
-        readonly dataType: {
-          readonly name: "dataType";
-          readonly optional: true;
-        };
-        readonly definition: {
-          readonly name: "definition";
-        };
-        readonly entry: {
-          readonly name: "entry";
-          readonly defaultValue: false;
-        };
-        readonly fragment: {
-          readonly name: "fragment";
-          readonly defaultValue: false;
-        };
-        readonly inferredType: {
-          readonly name: "inferredType";
-          readonly optional: true;
-        };
-        readonly name: {
-          readonly name: "name";
-        };
-        readonly parameters: {
-          readonly name: "parameters";
-          readonly defaultValue: [];
-        };
-        readonly returnType: {
-          readonly name: "returnType";
-          readonly referenceType: "AbstractType";
-          readonly optional: true;
-        };
-      };
-      readonly superTypes: ["AbstractParserRule"];
-    };
-    readonly ReferenceType: {
-      readonly name: "ReferenceType";
-      readonly properties: {
-        readonly isMulti: {
-          readonly name: "isMulti";
-          readonly defaultValue: false;
-        };
-        readonly referenceType: {
-          readonly name: "referenceType";
-        };
-      };
-      readonly superTypes: ["TypeDefinition"];
-    };
-    readonly RegexToken: {
-      readonly name: "RegexToken";
-      readonly properties: {
-        readonly cardinality: {
-          readonly name: "cardinality";
-          readonly optional: true;
-        };
-        readonly lookahead: {
-          readonly name: "lookahead";
-          readonly optional: true;
-        };
-        readonly parenthesized: {
-          readonly name: "parenthesized";
-          readonly defaultValue: false;
-          readonly optional: true;
-        };
-        readonly regex: {
-          readonly name: "regex";
-        };
-      };
-      readonly superTypes: ["TerminalElement"];
-    };
-    readonly ReturnType: {
-      readonly name: "ReturnType";
-      readonly properties: {
-        readonly name: {
-          readonly name: "name";
-        };
-      };
-      readonly superTypes: [];
-    };
-    readonly RuleCall: {
-      readonly name: "RuleCall";
-      readonly properties: {
-        readonly arguments: {
-          readonly name: "arguments";
-          readonly defaultValue: [];
-        };
-        readonly cardinality: {
-          readonly name: "cardinality";
-          readonly optional: true;
-        };
-        readonly predicate: {
-          readonly name: "predicate";
-          readonly optional: true;
-        };
-        readonly rule: {
-          readonly name: "rule";
-          readonly referenceType: "AbstractRule";
-        };
-      };
-      readonly superTypes: ["AbstractElement"];
-    };
-    readonly SimpleType: {
-      readonly name: "SimpleType";
-      readonly properties: {
-        readonly primitiveType: {
-          readonly name: "primitiveType";
-          readonly optional: true;
-        };
-        readonly stringType: {
-          readonly name: "stringType";
-          readonly optional: true;
-        };
-        readonly typeRef: {
-          readonly name: "typeRef";
-          readonly referenceType: "AbstractType";
-          readonly optional: true;
-        };
-      };
-      readonly superTypes: ["TypeDefinition"];
-    };
-    readonly StringLiteral: {
-      readonly name: "StringLiteral";
-      readonly properties: {
-        readonly value: {
-          readonly name: "value";
-        };
-      };
-      readonly superTypes: ["ValueLiteral"];
-    };
-    readonly TerminalAlternatives: {
-      readonly name: "TerminalAlternatives";
-      readonly properties: {
-        readonly cardinality: {
-          readonly name: "cardinality";
-          readonly optional: true;
-        };
-        readonly elements: {
-          readonly name: "elements";
-          readonly defaultValue: [];
-        };
-        readonly lookahead: {
-          readonly name: "lookahead";
-          readonly optional: true;
-        };
-        readonly parenthesized: {
-          readonly name: "parenthesized";
-          readonly defaultValue: false;
-          readonly optional: true;
-        };
-      };
-      readonly superTypes: ["TerminalElement"];
-    };
-    readonly TerminalElement: {
-      readonly name: "TerminalElement";
-      readonly properties: {
-        readonly cardinality: {
-          readonly name: "cardinality";
-          readonly optional: true;
-        };
-        readonly lookahead: {
-          readonly name: "lookahead";
-          readonly optional: true;
-        };
-        readonly parenthesized: {
-          readonly name: "parenthesized";
-          readonly defaultValue: false;
-          readonly optional: true;
-        };
-      };
-      readonly superTypes: ["AbstractElement"];
-    };
-    readonly TerminalGroup: {
-      readonly name: "TerminalGroup";
-      readonly properties: {
-        readonly cardinality: {
-          readonly name: "cardinality";
-          readonly optional: true;
-        };
-        readonly elements: {
-          readonly name: "elements";
-          readonly defaultValue: [];
-        };
-        readonly lookahead: {
-          readonly name: "lookahead";
-          readonly optional: true;
-        };
-        readonly parenthesized: {
-          readonly name: "parenthesized";
-          readonly defaultValue: false;
-          readonly optional: true;
-        };
-      };
-      readonly superTypes: ["TerminalElement"];
-    };
-    readonly TerminalRule: {
-      readonly name: "TerminalRule";
-      readonly properties: {
-        readonly definition: {
-          readonly name: "definition";
-        };
-        readonly fragment: {
-          readonly name: "fragment";
-          readonly defaultValue: false;
-        };
-        readonly hidden: {
-          readonly name: "hidden";
-          readonly defaultValue: false;
-        };
-        readonly name: {
-          readonly name: "name";
-        };
-        readonly type: {
-          readonly name: "type";
-          readonly optional: true;
-        };
-      };
-      readonly superTypes: ["AbstractRule"];
-    };
-    readonly TerminalRuleCall: {
-      readonly name: "TerminalRuleCall";
-      readonly properties: {
-        readonly cardinality: {
-          readonly name: "cardinality";
-          readonly optional: true;
-        };
-        readonly lookahead: {
-          readonly name: "lookahead";
-          readonly optional: true;
-        };
-        readonly parenthesized: {
-          readonly name: "parenthesized";
-          readonly defaultValue: false;
-          readonly optional: true;
-        };
-        readonly rule: {
-          readonly name: "rule";
-          readonly referenceType: "TerminalRule";
-        };
-      };
-      readonly superTypes: ["TerminalElement"];
-    };
-    readonly Type: {
-      readonly name: "Type";
-      readonly properties: {
-        readonly name: {
-          readonly name: "name";
-        };
-        readonly type: {
-          readonly name: "type";
-        };
-      };
-      readonly superTypes: ["AbstractType"];
-    };
-    readonly TypeAttribute: {
-      readonly name: "TypeAttribute";
-      readonly properties: {
-        readonly defaultValue: {
-          readonly name: "defaultValue";
-          readonly optional: true;
-        };
-        readonly isOptional: {
-          readonly name: "isOptional";
-          readonly defaultValue: false;
-        };
-        readonly name: {
-          readonly name: "name";
-        };
-        readonly type: {
-          readonly name: "type";
-        };
-      };
-      readonly superTypes: [];
-    };
-    readonly TypeDefinition: {
-      readonly name: "TypeDefinition";
-      readonly properties: {};
-      readonly superTypes: [];
-    };
-    readonly UnionType: {
-      readonly name: "UnionType";
-      readonly properties: {
-        readonly types: {
-          readonly name: "types";
-          readonly defaultValue: [];
-        };
-      };
-      readonly superTypes: ["TypeDefinition"];
-    };
-    readonly UnorderedGroup: {
-      readonly name: "UnorderedGroup";
-      readonly properties: {
-        readonly cardinality: {
-          readonly name: "cardinality";
-          readonly optional: true;
-        };
-        readonly elements: {
-          readonly name: "elements";
-          readonly defaultValue: [];
-        };
-      };
-      readonly superTypes: ["AbstractElement"];
-    };
-    readonly UntilToken: {
-      readonly name: "UntilToken";
-      readonly properties: {
-        readonly cardinality: {
-          readonly name: "cardinality";
-          readonly optional: true;
-        };
-        readonly lookahead: {
-          readonly name: "lookahead";
-          readonly optional: true;
-        };
-        readonly parenthesized: {
-          readonly name: "parenthesized";
-          readonly defaultValue: false;
-          readonly optional: true;
-        };
-        readonly terminal: {
-          readonly name: "terminal";
-        };
-      };
-      readonly superTypes: ["TerminalElement"];
-    };
-    readonly ValueLiteral: {
-      readonly name: "ValueLiteral";
-      readonly properties: {};
-      readonly superTypes: [];
-    };
-    readonly Wildcard: {
-      readonly name: "Wildcard";
-      readonly properties: {
-        readonly cardinality: {
-          readonly name: "cardinality";
-          readonly optional: true;
-        };
-        readonly lookahead: {
-          readonly name: "lookahead";
-          readonly optional: true;
-        };
-        readonly parenthesized: {
-          readonly name: "parenthesized";
-          readonly defaultValue: false;
-          readonly optional: true;
-        };
-      };
-      readonly superTypes: ["TerminalElement"];
-    };
-  };
-}
-declare const reflection: LangiumGrammarAstReflection;
-//#endregion
-//#region ../../node_modules/.pnpm/vscode-languageserver-textdocument@1.0.15/node_modules/vscode-languageserver-textdocument/lib/esm/main.d.ts
 /**
  * A tagging type for string properties that are actually URIs.
  */
@@ -1858,6 +746,7 @@ interface TextDocument {
    * and {@link Position.character}.
    * If the start range position is greater than the end range position,
    * then the effect of getText is as if the two positions were swapped.
+
    * @return The text of this document or a substring of the text if a
    *         range is provided.
    */
@@ -1933,8 +822,6 @@ declare namespace TextDocument {
   function update(document: TextDocument, changes: TextDocumentContentChangeEvent$1[], version: number): TextDocument;
   function applyEdits(document: TextDocument, edits: TextEdit$1[]): string;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/vscode-languageserver-types@3.18.4/node_modules/vscode-languageserver-types/lib/esm/main.d.ts
 /**
  * A tagging type for string properties that are actually document URIs.
  */
@@ -5214,14 +4101,11 @@ interface WorkspaceFolder {
 declare namespace WorkspaceFolder {
   function is(value: any): value is WorkspaceFolder;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/workspace/file-system-provider.d.ts
 interface FileSystemNode {
   readonly isFile: boolean;
   readonly isDirectory: boolean;
   readonly uri: URI$1;
 }
-type FileSystemFilter = (node: FileSystemNode) => boolean;
 /**
  * Provides methods to interact with an abstract file system. The default implementation is based on the node.js `fs` API.
  */
@@ -5279,23 +4163,6 @@ interface FileSystemProvider {
    */
   readDirectorySync(uri: URI$1): FileSystemNode[];
 }
-declare class EmptyFileSystemProvider implements FileSystemProvider {
-  stat(_uri: URI$1): Promise<FileSystemNode>;
-  statSync(_uri: URI$1): FileSystemNode;
-  exists(): Promise<boolean>;
-  existsSync(): boolean;
-  readBinary(): Promise<Uint8Array>;
-  readBinarySync(): Uint8Array;
-  readFile(): Promise<string>;
-  readFileSync(): string;
-  readDirectory(): Promise<FileSystemNode[]>;
-  readDirectorySync(): FileSystemNode[];
-}
-declare const EmptyFileSystem: {
-  fileSystemProvider: () => EmptyFileSystemProvider;
-};
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/languages/grammar-config.d.ts
 interface GrammarConfig {
   /**
    * Lists all rule names which are classified as multiline comment rules
@@ -5306,13 +4173,6 @@ interface GrammarConfig {
    */
   nameRegexp: RegExp;
 }
-/**
- * Create the default grammar configuration (used by `createDefaultModule`). This can be overridden in a
- * language-specific module.
- */
-declare function createGrammarConfig(services: LangiumCoreServices): GrammarConfig;
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/documentation/comment-provider.d.ts
 /**
  * Provides comments for AST nodes.
  */
@@ -5324,13 +4184,6 @@ interface CommentProvider {
    */
   getComment(node: AstNode): string | undefined;
 }
-declare class DefaultCommentProvider implements CommentProvider {
-  protected readonly grammarConfig: () => GrammarConfig;
-  constructor(services: LangiumCoreServices);
-  getComment(node: AstNode): string | undefined;
-}
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/service-registry.d.ts
 /**
  * The service registry provides access to the language-specific {@link LangiumCoreServices} optionally including LSP-related services.
  * These are resolved via the URI of a text document.
@@ -5354,26 +4207,6 @@ interface ServiceRegistry {
    */
   readonly all: readonly LangiumCoreServices[];
 }
-/**
- * Generic registry for Langium services, but capable of being used with extending service sets as well (such as the lsp-complete LangiumCoreServices set)
- */
-declare class DefaultServiceRegistry implements ServiceRegistry {
-  protected readonly languageIdMap: Map<string, LangiumCoreServices>;
-  protected readonly fileExtensionMap: Map<string, LangiumCoreServices>;
-  protected readonly fileNameMap: Map<string, LangiumCoreServices>;
-  /**
-   * @deprecated Since 3.1.0. Use the new `fileExtensionMap` (or `languageIdMap`) property instead.
-   */
-  protected get map(): Map<string, LangiumCoreServices> | undefined;
-  protected readonly textDocuments?: TextDocumentProvider;
-  constructor(services?: LangiumSharedCoreServices);
-  register(language: LangiumCoreServices): void;
-  getServices(uri: URI$1): LangiumCoreServices;
-  hasServices(uri: URI$1): boolean;
-  get all(): readonly LangiumCoreServices[];
-}
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/utils/disposable.d.ts
 /******************************************************************************
  * Copyright 2021 TypeFox GmbH
  * This program and the accompanying materials are made available under the
@@ -5395,8 +4228,6 @@ declare namespace Disposable$1 {
   function create(callback: () => Promise<void>): AsyncDisposable;
   function create(callback: () => void): Disposable$1;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/utils/caching.d.ts
 declare abstract class DisposableCache implements Disposable$1 {
   protected toDispose: Disposable$1[];
   protected isDisposed: boolean;
@@ -5427,25 +4258,6 @@ declare class ContextCache<Context, Key, Value, ContextKey = Context> extends Di
   clear(contextKey: Context): void;
   protected cacheForContext(contextKey: Context): Map<Key, Value>;
 }
-/**
- * Every key/value pair in this cache is scoped to a document.
- * If this document is changed or deleted, all associated key/value pairs are deleted.
- */
-declare class DocumentCache<K, V> extends ContextCache<URI$1 | string, K, V, string> {
-  /**
-   * Creates a new document cache.
-   *
-   * @param sharedServices Service container instance to hook into document lifecycle events.
-   * @param state Optional document state on which the cache should evict.
-   * If not provided, the cache will evict on `DocumentBuilder#onUpdate`.
-   * *Deleted* documents are considered in both cases.
-   *
-   * Providing a state here will use `DocumentBuilder#onDocumentPhase` instead,
-   * which triggers on all documents that have been affected by this change, assuming that the
-   * state is `DocumentState.Linked` or a later state.
-   */
-  constructor(sharedServices: LangiumSharedCoreServices, state?: DocumentState);
-}
 /**
  * Every key/value pair in this cache is scoped to the whole workspace.
  * If any document in the workspace is added, changed or deleted, the whole cache is evicted.
@@ -5461,8 +4273,6 @@ declare class WorkspaceCache<K, V> extends SimpleCache<K, V> {
    */
   constructor(sharedServices: LangiumSharedCoreServices, state?: DocumentState);
 }
-//#endregion
-//#region ../../node_modules/.pnpm/vscode-jsonrpc@9.0.3/node_modules/vscode-jsonrpc/lib/common/messages.d.ts
 interface ResponseErrorLiteral<D = void> {
   /**
    * A number indicating the error type that occurred.
@@ -5568,8 +4378,6 @@ declare class NotificationType0 extends AbstractMessageSignature {
   readonly _: [_EM] | undefined;
   constructor(method: string);
 }
-//#endregion
-//#region ../../node_modules/.pnpm/vscode-jsonrpc@9.0.3/node_modules/vscode-jsonrpc/lib/common/disposable.d.ts
 interface Disposable {
   /**
    * Dispose this object.
@@ -5579,8 +4387,6 @@ interface Disposable {
 declare namespace Disposable {
   function create(func: () => void): Disposable;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/vscode-jsonrpc@9.0.3/node_modules/vscode-jsonrpc/lib/common/events.d.ts
 /**
  * Represents a typed event.
  */
@@ -5619,8 +4425,6 @@ declare class Emitter<T> {
   fire(event: T): any;
   dispose(): void;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/vscode-jsonrpc@9.0.3/node_modules/vscode-jsonrpc/lib/common/cancellation.d.ts
 /**
  * Defines a CancellationToken. This interface is not
  * intended to be implemented. A CancellationToken must
@@ -5641,18 +4445,6 @@ declare namespace CancellationToken {
   const Cancelled: CancellationToken;
   function is(value: any): value is CancellationToken;
 }
-interface AbstractCancellationTokenSource extends Disposable {
-  token: CancellationToken;
-  cancel(): void;
-}
-declare class CancellationTokenSource implements AbstractCancellationTokenSource {
-  private _token;
-  get token(): CancellationToken;
-  cancel(): void;
-  dispose(): void;
-}
-//#endregion
-//#region ../../node_modules/.pnpm/vscode-jsonrpc@9.0.3/node_modules/vscode-jsonrpc/lib/common/connection.d.ts
 type ProgressToken = number | string;
 declare namespace ProgressToken {
   function is(value: any): value is number | string;
@@ -5715,8 +4507,6 @@ declare namespace TraceValue {
   const Verbose: 'verbose';
 }
 type TraceValue = 'off' | 'messages' | 'compact' | 'verbose';
-//#endregion
-//#region ../../node_modules/.pnpm/vscode-languageserver-protocol@3.18.4/node_modules/vscode-languageserver-protocol/lib/common/messages.d.ts
 declare class RegistrationType<RO> {
   /**
    * Clients must not use this property. It is here to ensure correct typing.
@@ -5762,8 +4552,6 @@ declare class ProtocolNotificationType<P, RO> extends NotificationType<P> implem
   readonly ____: [RO, _EM] | undefined;
   constructor(method: string);
 }
-//#endregion
-//#region ../../node_modules/.pnpm/vscode-languageserver-protocol@3.18.4/node_modules/vscode-languageserver-protocol/lib/common/protocol.implementation.d.ts
 /**
  * @since 3.6.0
  */
@@ -5784,8 +4572,6 @@ interface ImplementationClientCapabilities {
 interface ImplementationOptions extends WorkDoneProgressOptions {}
 interface ImplementationRegistrationOptions extends TextDocumentRegistrationOptions, ImplementationOptions, StaticRegistrationOptions {}
 interface ImplementationParams extends TextDocumentPositionParams, WorkDoneProgressParams, PartialResultParams {}
-//#endregion
-//#region ../../node_modules/.pnpm/vscode-languageserver-protocol@3.18.4/node_modules/vscode-languageserver-protocol/lib/common/protocol.typeDefinition.d.ts
 /**
  * Since 3.6.0
  */
@@ -5806,8 +4592,6 @@ interface TypeDefinitionClientCapabilities {
 interface TypeDefinitionOptions extends WorkDoneProgressOptions {}
 interface TypeDefinitionRegistrationOptions extends TextDocumentRegistrationOptions, TypeDefinitionOptions, StaticRegistrationOptions {}
 interface TypeDefinitionParams extends TextDocumentPositionParams, WorkDoneProgressParams, PartialResultParams {}
-//#endregion
-//#region ../../node_modules/.pnpm/vscode-languageserver-protocol@3.18.4/node_modules/vscode-languageserver-protocol/lib/common/protocol.workspaceFolder.d.ts
 interface WorkspaceFoldersInitializeParams {
   /**
    * The workspace folders configured in the client when the server starts.
@@ -5849,8 +4633,6 @@ interface WorkspaceFoldersChangeEvent {
    */
   removed: WorkspaceFolder[];
 }
-//#endregion
-//#region ../../node_modules/.pnpm/vscode-languageserver-protocol@3.18.4/node_modules/vscode-languageserver-protocol/lib/common/protocol.configuration.d.ts
 interface ConfigurationItem {
   /**
    * The scope to get the configuration section for.
@@ -5861,8 +4643,6 @@ interface ConfigurationItem {
    */
   section?: string;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/vscode-languageserver-protocol@3.18.4/node_modules/vscode-languageserver-protocol/lib/common/protocol.colorProvider.d.ts
 interface DocumentColorClientCapabilities {
   /**
    * Whether implementation supports dynamic registration. If this is set to `true`
@@ -5899,8 +4679,6 @@ interface ColorPresentationParams extends WorkDoneProgressParams, PartialResultP
    */
   range: Range;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/vscode-languageserver-protocol@3.18.4/node_modules/vscode-languageserver-protocol/lib/common/protocol.foldingRange.d.ts
 /**
  * @since 3.18.0
  */
@@ -5988,8 +4766,6 @@ interface FoldingRangeParams extends WorkDoneProgressParams, PartialResultParams
    */
   textDocument: TextDocumentIdentifier;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/vscode-languageserver-protocol@3.18.4/node_modules/vscode-languageserver-protocol/lib/common/protocol.declaration.d.ts
 /**
  * @since 3.14.0
  */
@@ -6008,8 +4784,6 @@ interface DeclarationClientCapabilities {
 interface DeclarationOptions extends WorkDoneProgressOptions {}
 interface DeclarationRegistrationOptions extends DeclarationOptions, TextDocumentRegistrationOptions, StaticRegistrationOptions {}
 interface DeclarationParams extends TextDocumentPositionParams, WorkDoneProgressParams, PartialResultParams {}
-//#endregion
-//#region ../../node_modules/.pnpm/vscode-languageserver-protocol@3.18.4/node_modules/vscode-languageserver-protocol/lib/common/protocol.selectionRange.d.ts
 interface SelectionRangeClientCapabilities {
   /**
    * Whether implementation supports dynamic registration for selection range providers. If this is set to `true`
@@ -6033,8 +4807,6 @@ interface SelectionRangeParams extends WorkDoneProgressParams, PartialResultPara
    */
   positions: Position[];
 }
-//#endregion
-//#region ../../node_modules/.pnpm/vscode-languageserver-protocol@3.18.4/node_modules/vscode-languageserver-protocol/lib/common/protocol.callHierarchy.d.ts
 /**
  * @since 3.16.0
  */
@@ -6080,8 +4852,6 @@ interface CallHierarchyIncomingCallsParams extends WorkDoneProgressParams, Parti
 interface CallHierarchyOutgoingCallsParams extends WorkDoneProgressParams, PartialResultParams {
   item: CallHierarchyItem;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/vscode-languageserver-protocol@3.18.4/node_modules/vscode-languageserver-protocol/lib/common/protocol.semanticTokens.d.ts
 /**
  * @since 3.16.0
  */
@@ -6271,8 +5041,6 @@ interface SemanticTokensWorkspaceClientCapabilities {
    */
   refreshSupport?: boolean;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/vscode-languageserver-protocol@3.18.4/node_modules/vscode-languageserver-protocol/lib/common/protocol.showDocument.d.ts
 /**
  * Client capabilities for the showDocument request.
  *
@@ -6327,8 +5095,6 @@ interface ShowDocumentResult {
    */
   success: boolean;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/vscode-languageserver-protocol@3.18.4/node_modules/vscode-languageserver-protocol/lib/common/protocol.linkedEditingRange.d.ts
 /**
  * Client capabilities for the linked editing range request.
  *
@@ -6363,8 +5129,6 @@ interface LinkedEditingRanges {
    */
   wordPattern?: string;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/vscode-languageserver-protocol@3.18.4/node_modules/vscode-languageserver-protocol/lib/common/protocol.fileOperations.d.ts
 /**
  * Options for notifications/requests for user operations on files.
  *
@@ -6591,8 +5355,6 @@ interface FileDelete {
    */
   uri: DocumentUri;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/vscode-languageserver-protocol@3.18.4/node_modules/vscode-languageserver-protocol/lib/common/protocol.moniker.d.ts
 /**
  * Moniker uniqueness level to define scope of the moniker.
  *
@@ -6682,8 +5444,6 @@ interface MonikerClientCapabilities {
 interface MonikerOptions extends WorkDoneProgressOptions {}
 interface MonikerRegistrationOptions extends TextDocumentRegistrationOptions, MonikerOptions {}
 interface MonikerParams extends TextDocumentPositionParams, WorkDoneProgressParams, PartialResultParams {}
-//#endregion
-//#region ../../node_modules/.pnpm/vscode-languageserver-protocol@3.18.4/node_modules/vscode-languageserver-protocol/lib/common/protocol.typeHierarchy.d.ts
 /**
  * @since 3.17.0
  */
@@ -6729,8 +5489,6 @@ type TypeHierarchySupertypesParams = WorkDoneProgressParams & PartialResultParam
 type TypeHierarchySubtypesParams = WorkDoneProgressParams & PartialResultParams & {
   item: TypeHierarchyItem;
 };
-//#endregion
-//#region ../../node_modules/.pnpm/vscode-languageserver-protocol@3.18.4/node_modules/vscode-languageserver-protocol/lib/common/protocol.inlineValue.d.ts
 /**
  * Client capabilities specific to inline values.
  *
@@ -6791,8 +5549,6 @@ type InlineValueParams = WorkDoneProgressParams & PartialResultParams & {
    */
   context: InlineValueContext;
 };
-//#endregion
-//#region ../../node_modules/.pnpm/vscode-languageserver-protocol@3.18.4/node_modules/vscode-languageserver-protocol/lib/common/protocol.inlayHint.d.ts
 /**
  * @since 3.18.0
  */
@@ -6868,8 +5624,6 @@ type InlayHintParams = WorkDoneProgressParams & PartialResultParams & {
    */
   range: Range;
 };
-//#endregion
-//#region ../../node_modules/.pnpm/vscode-languageserver-protocol@3.18.4/node_modules/vscode-languageserver-protocol/lib/common/protocol.diagnostic.d.ts
 /**
  * Client capabilities specific to diagnostic pull requests.
  *
@@ -7175,8 +5929,6 @@ type WorkspaceDiagnosticReport = {
 type WorkspaceDiagnosticReportPartialResult = {
   items: WorkspaceDocumentDiagnosticReport[];
 };
-//#endregion
-//#region ../../node_modules/.pnpm/vscode-languageserver-protocol@3.18.4/node_modules/vscode-languageserver-protocol/lib/common/protocol.notebook.d.ts
 /**
  * Notebook specific client capabilities.
  *
@@ -7558,8 +6310,6 @@ type DidCloseNotebookDocumentParams = {
    */
   cellTextDocuments: TextDocumentIdentifier[];
 };
-//#endregion
-//#region ../../node_modules/.pnpm/vscode-languageserver-protocol@3.18.4/node_modules/vscode-languageserver-protocol/lib/common/protocol.inlineCompletion.d.ts
 /**
  * Client capabilities specific to inline completions.
  *
@@ -7589,8 +6339,6 @@ type InlineCompletionParams = WorkDoneProgressParams & TextDocumentPositionParam
    */
   context: InlineCompletionContext;
 };
-//#endregion
-//#region ../../node_modules/.pnpm/vscode-languageserver-protocol@3.18.4/node_modules/vscode-languageserver-protocol/lib/common/protocol.textDocumentContent.d.ts
 /**
  * Client capabilities for a text document content provider.
  *
@@ -7644,8 +6392,6 @@ interface TextDocumentContentResult {
    */
   text: string;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/vscode-languageserver-protocol@3.18.4/node_modules/vscode-languageserver-protocol/lib/common/protocol.d.ts
 /**
  * A document filter where `language` is required field.
  *
@@ -9169,6 +7915,35 @@ type GlobPattern = Pattern | RelativePattern;
 declare namespace GlobPattern {
   function is(value: any): value is GlobPattern;
 }
+interface FileSystemWatcher {
+  /**
+   * The glob pattern to watch. See {@link GlobPattern glob pattern} for more detail.
+   *
+   * @since 3.17.0 support for relative patterns.
+   */
+  globPattern: GlobPattern;
+  /**
+   * The kind of events of interest. If omitted it defaults
+   * to WatchKind.Create | WatchKind.Change | WatchKind.Delete
+   * which is 7.
+   */
+  kind?: WatchKind;
+}
+declare namespace WatchKind {
+  /**
+   * Interested in create events.
+   */
+  const Create: 1;
+  /**
+   * Interested in change events
+   */
+  const Change: 2;
+  /**
+   * Interested in delete events
+   */
+  const Delete: 4;
+}
+type WatchKind = uinteger;
 /**
  * @since 3.18.0
  */
@@ -10495,11 +9270,6 @@ interface ApplyWorkspaceEditResult {
  * @deprecated Use ApplyWorkspaceEditResult instead.
  */
 type ApplyWorkspaceEditResponse = ApplyWorkspaceEditResult;
-declare namespace cancellation_d_exports {
-  export { AbstractCancellationTokenSource, CancellationToken, CancellationTokenSource };
-}
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/utils/stream.d.ts
 /******************************************************************************
  * Copyright 2021 TypeFox GmbH
  * This program and the accompanying materials are made available under the
@@ -10720,120 +9490,6 @@ type FlatStream<T, Depth extends number> = {
   'recur': T extends Iterable<infer Content> ? FlatStream<Content, MinusOne<Depth>> : Stream<T>;
 }[Depth extends 0 ? 'done' : 'recur'];
 type MinusOne<N extends number> = [-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20][N];
-/**
- * The default implementation of `Stream` works with two input functions:
- *  - The first function creates the initial state of an iteration.
- *  - The second function gets the current state as argument and returns an `IteratorResult`.
- */
-declare class StreamImpl<S, T> implements Stream<T> {
-  protected readonly startFn: () => S;
-  protected readonly nextFn: (state: S) => IteratorResult<T>;
-  constructor(startFn: () => S, nextFn: (state: S) => IteratorResult<T, undefined>);
-  iterator(): IterableIterator<T>;
-  [Symbol.iterator](): Iterator<T>;
-  isEmpty(): boolean;
-  count(): number;
-  toArray(): T[];
-  toSet(): Set<T>;
-  toMap<K = T, V = T>(keyFn?: (e: T) => K, valueFn?: (e: T) => V): Map<K, V>;
-  toString(): string;
-  concat<T2>(other: Iterable<T2>): Stream<T | T2>;
-  join(separator?: string): string;
-  indexOf(searchElement: T, fromIndex?: number): number;
-  every<U extends T>(predicate: (value: T) => value is U): this is Stream<U> & this;
-  every(predicate: (value: T) => unknown): boolean;
-  some(predicate: (value: T) => unknown): boolean;
-  forEach(callbackfn: (value: T, index: number) => void): void;
-  map<U>(callbackfn: (value: T) => U): Stream<U>;
-  filter<U extends T>(predicate: (value: T) => value is U): Stream<U> & this;
-  filter(predicate: (value: T) => unknown): Stream<T> & this;
-  nonNullable(): Stream<NonNullable<T>>;
-  reduce(callbackfn: (previousValue: T, currentValue: T) => T): T | undefined;
-  reduce<U = T>(callbackfn: (previousValue: U, currentValue: T) => U, initialValue: U): U;
-  reduceRight(callbackfn: (previousValue: T, currentValue: T) => T): T | undefined;
-  reduceRight<U = T>(callbackfn: (previousValue: U, currentValue: T) => U, initialValue: U): U;
-  protected recursiveReduce<U>(iterator: Iterator<T>, callbackfn: (previousValue: U | T, currentValue: T) => U, initialValue?: U): U | T | undefined;
-  find<S extends T>(predicate: (value: T) => value is S): S | undefined;
-  find(predicate: (value: T) => unknown): T | undefined;
-  findIndex(predicate: (value: T) => unknown): number;
-  includes(searchElement: T): boolean;
-  flatMap<U>(callbackfn: (value: T) => U | Iterable<U>): Stream<U>;
-  flat<D extends number = 1>(depth?: D): FlatStream<T, D>;
-  head(): T | undefined;
-  tail(skipCount?: number): Stream<T>;
-  limit(maxSize: number): Stream<T>;
-  distinct<Key = T>(by?: (element: T) => Key): Stream<T>;
-  exclude<Key = T>(other: Iterable<T>, key?: (element: T) => Key): Stream<T>;
-}
-/**
- * An empty stream of any type.
- */
-declare const EMPTY_STREAM: Stream<any>;
-/**
- * Use this `IteratorResult` when implementing a `StreamImpl` to indicate that there are no more elements in the stream.
- */
-declare const DONE_RESULT: IteratorReturnResult<undefined>;
-/**
- * Create a stream from one or more iterables or array-likes.
- */
-declare function stream<T>(...collections: Array<Iterable<T> | ArrayLike<T>>): Stream<T>;
-/**
- * A tree iterator adds the ability to prune the current iteration.
- */
-interface TreeIterator<T> extends IterableIterator<T> {
-  /**
-   * Skip the whole subtree below the last returned element. The iteration continues as if that
-   * element had no children.
-   */
-  prune(): void;
-}
-/**
- * A tree stream is used to stream the elements of a tree, for example an AST or CST.
- */
-interface TreeStream<T> extends Stream<T> {
-  iterator(): TreeIterator<T>;
-}
-/**
- * The default implementation of `TreeStream` takes a root element and a function that computes the
- * children of its argument. Whether the root node included in the stream is controlled with the
- * `includeRoot` option, which defaults to `false`.
- */
-declare class TreeStreamImpl<T> extends StreamImpl<{
-  iterators: Array<Iterator<T>>;
-  pruned: boolean;
-}, T> implements TreeStream<T> {
-  constructor(root: T, children: (node: T) => Iterable<T>, options?: {
-    includeRoot?: boolean;
-  });
-  iterator(): TreeIterator<T>;
-}
-/**
- * A set of utility functions that reduce a stream to a single value.
- */
-declare namespace Reduction {
-  /**
-   * Compute the sum of a number stream.
-   */
-  function sum(stream: Stream<number>): number;
-  /**
-   * Compute the product of a number stream.
-   */
-  function product(stream: Stream<number>): number;
-  /**
-   * Compute the minimum of a number stream. Returns `undefined` if the stream is empty.
-   */
-  function min(stream: Stream<number>): number | undefined;
-  /**
-   * Compute the maximum of a number stream. Returns `undefined` if the stream is empty.
-   */
-  function max(stream: Stream<number>): number | undefined;
-}
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/references/name-provider.d.ts
-interface NamedAstNode extends AstNode {
-  name: string;
-}
-declare function isNamed(node: AstNode): node is NamedAstNode;
 /**
  * Utility service for retrieving the `name` of an `AstNode` or the `CstNode` containing a `name`.
  */
@@ -10853,8 +9509,6 @@ declare class DefaultNameProvider implements NameProvider {
   getName(node: AstNode): string | undefined;
   getNameNode(node: AstNode): CstNode | undefined;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/workspace/ast-node-locator.d.ts
 /**
  * Language-specific service for locating an `AstNode` in a document.
  */
@@ -10878,15 +9532,6 @@ interface AstNodeLocator {
    */
   getAstNode<T extends AstNode = AstNode>(node: AstNode, path: string): T | undefined;
 }
-declare class DefaultAstNodeLocator implements AstNodeLocator {
-  protected segmentSeparator: string;
-  protected indexSeparator: string;
-  getAstNodePath(node: AstNode): string;
-  protected getPathSegment({ $containerProperty, $containerIndex }: AstNode): string;
-  getAstNode<T extends AstNode = AstNode>(node: AstNode, path: string): T | undefined;
-}
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/workspace/ast-descriptions.d.ts
 /**
  * Language-specific service for creating descriptions of AST nodes to be used for cross-reference resolutions.
  */
@@ -10903,12 +9548,6 @@ interface AstNodeDescriptionProvider {
    */
   createDescription(node: AstNode, name: string | undefined, document?: LangiumDocument): AstNodeDescription;
 }
-declare class DefaultAstNodeDescriptionProvider implements AstNodeDescriptionProvider {
-  protected readonly astNodeLocator: AstNodeLocator;
-  protected readonly nameProvider: NameProvider;
-  constructor(services: LangiumCoreServices);
-  createDescription(node: AstNode, name: string | undefined, document?: LangiumDocument): AstNodeDescription;
-}
 /**
  * Describes a cross-reference within a document or between two documents.
  */
@@ -10942,14 +9581,6 @@ interface ReferenceDescriptionProvider {
    */
   createDescriptions(document: LangiumDocument, cancelToken?: CancellationToken): Promise<ReferenceDescription[]>;
 }
-declare class DefaultReferenceDescriptionProvider implements ReferenceDescriptionProvider {
-  protected readonly nodeLocator: AstNodeLocator;
-  constructor(services: LangiumCoreServices);
-  createDescriptions(document: LangiumDocument, cancelToken?: CancellationToken): Promise<ReferenceDescription[]>;
-  protected createInfoDescriptions(refInfo: ReferenceInfo): ReferenceDescription[];
-}
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/workspace/index-manager.d.ts
 /**
  * The index manager is responsible for keeping metadata about symbols and cross-references
  * in the workspace. It is used to look up symbols in the global scope, mostly during linking
@@ -11045,14 +9676,6 @@ declare class DefaultIndexManager implements IndexManager {
   updateReferences(document: LangiumDocument, cancelToken?: CancellationToken): Promise<void>;
   isAffected(document: LangiumDocument, changedUris: Set<string>): boolean;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/documentation/jsdoc.d.ts
-interface JSDocComment extends JSDocValue {
-  readonly elements: JSDocElement[];
-  getTag(name: string): JSDocTag | undefined;
-  getTags(name: string): JSDocTag[];
-}
-type JSDocElement = JSDocParagraph | JSDocTag;
 type JSDocInline = JSDocTag | JSDocLine;
 interface JSDocValue {
   /**
@@ -11082,23 +9705,9 @@ interface JSDocTag extends JSDocValue {
   readonly content: JSDocParagraph;
   readonly inline: boolean;
 }
-interface JSDocParseOptions {
+interface JSDocRenderOptions {
   /**
-   * The start symbol of your comment format. Defaults to `/**`.
-   */
-  readonly start?: RegExp | string;
-  /**
-   * The symbol that start a line of your comment format. Defaults to `*`.
-   */
-  readonly line?: RegExp | string;
-  /**
-   * The end symbol of your comment format. Defaults to `*\/`.
-   */
-  readonly end?: RegExp | string;
-}
-interface JSDocRenderOptions {
-  /**
-   * Determines the style for rendering tags. Defaults to `italic`.
+   * Determines the style for rendering tags. Defaults to `italic`.
    */
   tag?: 'plain' | 'italic' | 'bold' | 'bold-italic';
   /**
@@ -11116,24 +9725,6 @@ interface JSDocRenderOptions {
    */
   renderLink?(link: string, display: string): string | undefined;
 }
-/**
- * Parses a JSDoc from a `CstNode` containing a comment.
- *
- * @param node A `CstNode` from a parsed Langium document.
- * @param options Parsing options specialized to your language. See {@link JSDocParseOptions}.
- */
-declare function parseJSDoc(node: CstNode, options?: JSDocParseOptions): JSDocComment;
-/**
- * Parses a JSDoc from a string comment.
- *
- * @param content A string containing the source of the JSDoc comment.
- * @param start The start position the comment occupies in the source document.
- * @param options Parsing options specialized to your language. See {@link JSDocParseOptions}.
- */
-declare function parseJSDoc(content: string, start?: Position, options?: JSDocParseOptions): JSDocComment;
-declare function isJSDoc(node: CstNode | string, options?: JSDocParseOptions): boolean;
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/documentation/documentation-provider.d.ts
 /**
  * Provides documentation for AST nodes.
  */
@@ -11155,8 +9746,6 @@ declare class JSDocDocumentationProvider implements DocumentationProvider {
   protected findNameInLocalSymbols(node: AstNode, name: string): AstNodeDescription | undefined;
   protected findNameInGlobalScope(node: AstNode, name: string): AstNodeDescription | undefined;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/languages/language-meta-data.d.ts
 /******************************************************************************
  * Copyright 2021 TypeFox GmbH
  * This program and the accompanying materials are made available under the
@@ -11177,149 +9766,6 @@ interface LanguageMetaData {
    */
   mode: 'development' | 'production';
 }
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/parser/cst-node-builder.d.ts
-/**
- * Incrementally builds the concrete syntax tree (CST) while the parser processes the input.
- *
- * The parser drives the builder with the following protocol: `buildRootNode` starts a new tree,
- * `buildCompositeNode` opens a nested node whenever a parser rule is invoked, `buildLeafNode`
- * adds a node for every consumed token, and `construct` closes the innermost open composite node
- * once its rule implementation has finished. Hidden tokens (e.g. comments and whitespace) are not
- * part of the parser's token stream and are added separately via `addHiddenNodes`.
- */
-declare class CstNodeBuilder {
-  private rootNode;
-  private nodeStack;
-  /**
-   * The composite node currently being built, i.e. the one to which new child nodes are added:
-   * the innermost parser rule invocation that has not been completed with `construct` yet.
-   */
-  get current(): CompositeCstNodeImpl;
-  /**
-   * Reset the builder and create the root node of a new tree. This must be called once
-   * before each parser run; all nodes built afterwards belong to the returned root.
-   */
-  buildRootNode(input: string): RootCstNode;
-  /**
-   * Create a composite node as a child of the current node and make it the new current node.
-   * The parser calls this when a rule is invoked that creates its own AST node; the node
-   * remains current until the corresponding `construct` call closes it.
-   */
-  buildCompositeNode(feature: AbstractElement): CompositeCstNode;
-  /**
-   * Create a leaf node for a consumed token and append it to the current composite node.
-   * If no grammar element is given, the token is treated as hidden (e.g. a comment).
-   */
-  buildLeafNode(token: IToken, feature?: AbstractElement): LeafCstNode;
-  /**
-   * Create a detached leaf node from a token, translating Chevrotain's position
-   * information to the LSP conventions used by the CST.
-   */
-  protected createLeafNode(token: IToken, hidden: boolean): LeafCstNodeImpl;
-  /**
-   * Append a child node to the content of a composite node and set the child's container reference.
-   */
-  appendChild(parent: CompositeCstNode, child: CstNode): void;
-  /**
-   * Append multiple child nodes to the content of a composite node and set their container references.
-   */
-  appendChildren(parent: CompositeCstNode, children: CstNode[]): void;
-  /**
-   * Insert child nodes at the given index into the content of a composite node and set their container references.
-   */
-  insertChildren(parent: CompositeCstNode, index: number, children: CstNode[]): void;
-  /**
-   * Remove a node from the content of its container.
-   */
-  removeNode(node: CstNode): void;
-  /**
-   * Insert leaf nodes for hidden tokens (e.g. comments) into the tree. Since hidden tokens are
-   * not part of the parser's token stream, the parser calls this separately: once before each
-   * consumed token with the hidden tokens preceding it, and once after parsing for the trailing
-   * hidden tokens. The nodes are attached where the tree is currently being built, so hidden
-   * nodes end up next to the non-hidden token that follows them.
-   */
-  addHiddenNodes(tokens: IToken[]): void;
-  /**
-   * Close the current composite node and assign it to the given AST node (`item.$cstNode`).
-   * The parser calls this when a rule implementation has finished, matching the preceding
-   * `buildCompositeNode` (or `buildRootNode`) call; the parent node becomes current again.
-   * If the closed node has no content, e.g. due to an unsuccessful optional rule call,
-   * it is removed from the tree.
-   */
-  construct(item: {
-    $type: string | symbol | undefined;
-    $cstNode: CstNode;
-    $infixName?: string;
-  }): void;
-}
-declare abstract class AbstractCstNode implements CstNode {
-  abstract get offset(): number;
-  abstract get length(): number;
-  abstract get end(): number;
-  abstract get range(): Range;
-  abstract get astNode(): AstNode;
-  abstract get hidden(): boolean;
-  container: CompositeCstNode | undefined;
-  grammarSource: AbstractElement | undefined;
-  get root(): RootCstNode;
-  get text(): string;
-}
-declare class LeafCstNodeImpl extends AbstractCstNode implements LeafCstNode {
-  private _hidden;
-  private _offset;
-  private _length;
-  private _startLine;
-  private _startColumn;
-  private _endLine;
-  private _endColumn;
-  private _tokenType;
-  get offset(): number;
-  get length(): number;
-  get end(): number;
-  get hidden(): boolean;
-  get tokenType(): TokenType;
-  get astNode(): AstNode;
-  get range(): Range;
-  /**
-   * All position values are 0-based and the end position is exclusive,
-   * following the LSP convention (see the `Range` type).
-   */
-  constructor(offset: number, length: number, startLine: number, startColumn: number, endLine: number, endColumn: number, tokenType: TokenType, hidden?: boolean);
-}
-declare class CompositeCstNodeImpl extends AbstractCstNode implements CompositeCstNode {
-  /**
-   * This array must not be modified directly; use the `CstNodeBuilder` methods instead
-   * to ensure that the `container` references of the child nodes are set correctly.
-   */
-  content: CstNode[];
-  /**
-   * These fields are assigned lazily, but eagerly initialized with `undefined` so V8 reserves
-   * in-object slots for them. Without the initializers, late assignments would go to an
-   * out-of-object backing store, costing more memory than the reserved slots and splitting
-   * the hidden class of composite nodes (slower property access).
-   */
-  private _astNode;
-  private _rangeCache;
-  get astNode(): AstNode;
-  set astNode(value: AstNode | undefined);
-  get hidden(): boolean;
-  get offset(): number;
-  get length(): number;
-  get end(): number;
-  get range(): Range;
-  private get firstNonHiddenNode();
-  private get lastNonHiddenNode();
-}
-declare class RootCstNodeImpl extends CompositeCstNodeImpl implements RootCstNode {
-  private _text;
-  get text(): string;
-  get fullText(): string;
-  constructor(input?: string);
-}
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/utils/collections.d.ts
 /**
  * A multimap is a variation of a Map that has potentially multiple values for every key.
  */
@@ -11396,20 +9842,6 @@ declare class MultiMap<K, V> {
    */
   entriesGroupedByKey(): Stream<[K, V[]]>;
 }
-declare class BiMap<K, V> {
-  private map;
-  private inverse;
-  get size(): number;
-  constructor();
-  constructor(elements: Array<[K, V]>);
-  clear(): void;
-  set(key: K, value: V): this;
-  get(key: K): V | undefined;
-  getKey(value: V): K | undefined;
-  delete(key: K): boolean;
-}
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/references/scope.d.ts
 /**
  * A scope describes what target elements are visible from a specific cross-reference context.
  */
@@ -11446,44 +9878,6 @@ interface ScopeOptions {
    */
   concatOuterScope?: boolean;
 }
-/**
- * The default scope implementation is based on a `Stream`. It has an optional _outer scope_ describing
- * the next level of elements, which are queried when a target element is not found in the stream provided
- * to this scope.
- */
-declare class StreamScope implements Scope {
-  readonly elements: Stream<AstNodeDescription>;
-  readonly outerScope?: Scope;
-  readonly caseInsensitive: boolean;
-  readonly concatOuterScope: boolean;
-  constructor(elements: Stream<AstNodeDescription>, outerScope?: Scope, options?: ScopeOptions);
-  getAllElements(): Stream<AstNodeDescription>;
-  getElement(name: string): AstNodeDescription | undefined;
-  getElements(name: string): Stream<AstNodeDescription>;
-}
-declare class MapScope implements Scope {
-  readonly elements: Map<string, AstNodeDescription>;
-  readonly outerScope?: Scope;
-  readonly caseInsensitive: boolean;
-  readonly concatOuterScope: boolean;
-  constructor(elements: Iterable<AstNodeDescription>, outerScope?: Scope, options?: ScopeOptions);
-  getElement(name: string): AstNodeDescription | undefined;
-  getElements(name: string): Stream<AstNodeDescription>;
-  getAllElements(): Stream<AstNodeDescription>;
-}
-declare class MultiMapScope implements Scope {
-  readonly elements: MultiMap<string, AstNodeDescription>;
-  readonly outerScope?: Scope;
-  readonly caseInsensitive: boolean;
-  readonly concatOuterScope: boolean;
-  constructor(elements: Iterable<AstNodeDescription>, outerScope?: Scope, options?: ScopeOptions);
-  getElement(name: string): AstNodeDescription | undefined;
-  getElements(name: string): Stream<AstNodeDescription>;
-  getAllElements(): Stream<AstNodeDescription>;
-}
-declare const EMPTY_SCOPE: Scope;
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/references/scope-provider.d.ts
 /**
  * Language-specific service for determining the scope of target elements visible in a specific cross-reference context.
  */
@@ -11518,8 +9912,6 @@ declare class DefaultScopeProvider implements ScopeProvider {
    */
   protected getGlobalScope(referenceType: string, _context: ReferenceInfo): Scope;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/workspace/profiler.d.ts
 type ProfilingCategory = 'validating' | 'parsing' | 'linking';
 interface LangiumProfiler {
   /**
@@ -11551,18 +9943,6 @@ interface LangiumProfiler {
    */
   getRecords(...categories: ProfilingCategory[]): Stream<ProfilingRecord>;
 }
-declare class DefaultLangiumProfiler implements LangiumProfiler {
-  protected activeCategories: Set<ProfilingCategory>;
-  protected readonly allCategories: ReadonlySet<ProfilingCategory>;
-  protected readonly records: MultiMap<string, ProfilingRecord>;
-  constructor(activeCategories?: Set<ProfilingCategory>);
-  isActive(category: ProfilingCategory): boolean;
-  start(...categories: ProfilingCategory[]): void;
-  stop(...categories: ProfilingCategory[]): void;
-  createTask(category: ProfilingCategory, taskId: string): ProfilingTask;
-  protected dumpRecord(category: string, record: ProfilingRecord): ProfilingRecord;
-  getRecords(...categories: ProfilingCategory[]): Stream<ProfilingRecord>;
-}
 interface ProfilingRecord {
   identifier: string;
   date: Date;
@@ -11585,8 +9965,6 @@ declare class ProfilingTask {
   startSubTask(subTaskId: string): void;
   stopSubTask(subTaskId: string): void;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/references/linker.d.ts
 /**
  * Language-specific service for resolving cross-references in the AST.
  */
@@ -11642,48 +10020,6 @@ interface Linker {
   buildReference(node: AstNode, property: string, refNode: CstNode | undefined, refText: string): Reference;
   buildMultiReference(node: AstNode, property: string, refNode: CstNode | undefined, refText: string): MultiReference;
 }
-declare const RefResolving: unique symbol;
-interface DefaultReference extends Reference {
-  _ref?: AstNode | LinkingError | typeof RefResolving;
-  _nodeDescription?: AstNodeDescription;
-}
-interface DefaultMultiReference extends MultiReference {
-  _items: MultiReferenceItem[] | typeof RefResolving | undefined;
-  _linkingError?: LinkingError;
-}
-interface ReferenceResolver {
-  resolveReference(reference: DefaultReference, node: AstNode, property: string): AstNode | undefined;
-  resolveMultiReference(reference: DefaultMultiReference, node: AstNode, property: string): MultiReferenceItem[];
-}
-declare class DefaultLinker implements Linker {
-  protected readonly reflection: AstReflection;
-  protected readonly scopeProvider: ScopeProvider;
-  protected readonly astNodeLocator: AstNodeLocator;
-  protected readonly langiumDocuments: () => LangiumDocuments;
-  protected readonly profiler: LangiumProfiler | undefined;
-  protected readonly languageId: string;
-  protected readonly referenceResolver: ReferenceResolver;
-  constructor(services: LangiumCoreServices);
-  link(document: LangiumDocument, cancelToken?: CancellationToken): Promise<void>;
-  protected doLink(refInfo: ReferenceInfo, document: LangiumDocument): void;
-  unlink(document: LangiumDocument): void;
-  getCandidate(refInfo: ReferenceInfo): AstNodeDescription | LinkingError;
-  getCandidates(refInfo: ReferenceInfo): AstNodeDescription[] | LinkingError;
-  buildReference(node: AstNode, property: string, refNode: CstNode | undefined, refText: string): Reference;
-  buildMultiReference(node: AstNode, property: string, refNode: CstNode | undefined, refText: string): MultiReference;
-  protected resolveReference(reference: DefaultReference, node: AstNode, property: string): AstNode | undefined;
-  protected resolveMultiReference(reference: DefaultMultiReference, node: AstNode, property: string): MultiReferenceItem[];
-  protected throwCyclicReferenceError(node: AstNode, property: string, refText: string): never;
-  protected getLinkedNode(refInfo: ReferenceInfo): {
-    node?: AstNode;
-    descr?: AstNodeDescription;
-    error?: LinkingError;
-  };
-  protected loadAstNode(nodeDescription: AstNodeDescription): AstNode | undefined;
-  protected createLinkingError(refInfo: ReferenceInfo, targetDescription?: AstNodeDescription): LinkingError;
-}
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/parser/token-builder.d.ts
 interface TokenBuilderOptions {
   caseInsensitive?: boolean;
 }
@@ -11707,29 +10043,6 @@ type LexingDiagnosticSeverity = 'error' | 'warning' | 'info' | 'hint';
 interface LexingDiagnostic extends ILexingError {
   severity?: LexingDiagnosticSeverity;
 }
-declare class DefaultTokenBuilder implements TokenBuilder {
-  /**
-   * The list of diagnostics stored during the lexing process of a single text.
-   */
-  protected diagnostics: LexingDiagnostic[];
-  buildTokens(grammar: Grammar, options?: TokenBuilderOptions): TokenVocabulary;
-  flushLexingReport(text: string): LexingReport;
-  protected popDiagnostics(): LexingDiagnostic[];
-  protected buildTerminalTokens(rules: Stream<AbstractRule>): TokenType[];
-  protected buildTerminalToken(terminal: TerminalRule): TokenType;
-  protected requiresCustomPattern(regex: RegExp): boolean;
-  protected regexPatternFunction(regex: RegExp): CustomPatternMatcherFunc;
-  protected buildKeywordTokens(rules: Stream<AbstractRule>, terminalTokens: TokenType[], options?: TokenBuilderOptions): TokenType[];
-  protected buildKeywordToken(keyword: Keyword, terminalTokens: TokenType[], caseInsensitive: boolean): TokenType;
-  protected buildKeywordPattern(keyword: Keyword, caseInsensitive: boolean): TokenPattern;
-  protected findLongerAlt(keyword: Keyword, terminalTokens: TokenType[]): TokenType[];
-}
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/parser/lexer.d.ts
-declare class DefaultLexerErrorMessageProvider implements ILexerErrorMessageProvider {
-  buildUnexpectedCharactersMessage(fullText: string, startOffset: number, length: number, line?: number, column?: number): string;
-  buildUnableToPopLexerModeMessage(token: IToken): string;
-}
 interface LexerResult {
   /**
    * A list of all tokens that were lexed from the input.
@@ -11749,35 +10062,10 @@ type TokenizeMode = 'full' | 'partial';
 interface TokenizeOptions {
   mode?: TokenizeMode;
 }
-declare const DEFAULT_TOKENIZE_OPTIONS: TokenizeOptions;
-interface Lexer$1 {
+interface Lexer {
   readonly definition: TokenTypeDictionary;
   tokenize(text: string, options?: TokenizeOptions): LexerResult;
 }
-declare class DefaultLexer implements Lexer$1 {
-  protected readonly tokenBuilder: TokenBuilder;
-  protected readonly errorMessageProvider: ILexerErrorMessageProvider;
-  protected tokenTypes: TokenTypeDictionary;
-  protected chevrotainLexer: Lexer;
-  constructor(services: LangiumCoreServices);
-  get definition(): TokenTypeDictionary;
-  tokenize(text: string, _options?: TokenizeOptions): LexerResult;
-  protected toTokenTypeDictionary(buildTokens: TokenVocabulary): TokenTypeDictionary;
-}
-/**
- * Returns a check whether the given TokenVocabulary is TokenType array
- */
-declare function isTokenTypeArray(tokenVocabulary: TokenVocabulary): tokenVocabulary is TokenType[];
-/**
- * Returns a check whether the given TokenVocabulary is IMultiModeLexerDefinition
- */
-declare function isIMultiModeLexerDefinition(tokenVocabulary: TokenVocabulary): tokenVocabulary is IMultiModeLexerDefinition;
-/**
- * Returns a check whether the given TokenVocabulary is TokenTypeDictionary
- */
-declare function isTokenTypeDictionary(tokenVocabulary: TokenVocabulary): tokenVocabulary is TokenTypeDictionary;
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/serializer/hydrator.d.ts
 /**
  * The hydrator service is responsible for allowing AST parse results to be sent across worker threads.
  */
@@ -11792,83 +10080,7 @@ interface Hydrator {
    */
   hydrate<T extends AstNode = AstNode>(result: ParseResult<object>): ParseResult<T>;
 }
-interface DehydrateContext {
-  astNodes: Map<AstNode, any>;
-  cstNodes: Map<CstNode, any>;
-}
-interface HydrateContext {
-  astNodes: Map<any, AstNode>;
-  cstNodes: Map<any, CstNode>;
-  /** CST nodes that already received their AST backlink; used to let the outermost AST node win for shared CST nodes. */
-  linkedCstNodes: Set<CstNode>;
-}
-declare class DefaultHydrator implements Hydrator {
-  protected readonly grammar: Grammar;
-  protected readonly lexer: Lexer$1;
-  protected readonly linker: Linker;
-  protected readonly grammarElementIdMap: BiMap<AbstractElement, number>;
-  protected readonly tokenTypeIdMap: BiMap<number, TokenType>;
-  /** Used to assemble the CST during hydration; `CstNodeBuilder` is not a service, so we keep a local instance. */
-  protected readonly cstNodeBuilder: CstNodeBuilder;
-  constructor(services: LangiumCoreServices);
-  dehydrate(result: ParseResult<AstNode>): ParseResult<object>;
-  protected dehydrateLexerReport(lexerReport: LexingReport): LexingReport;
-  protected createDehyrationContext(node: AstNode): DehydrateContext;
-  protected dehydrateAstNode(node: AstNode, context: DehydrateContext): object;
-  protected dehydrateReference(reference: Reference, context: DehydrateContext): any;
-  protected dehydrateCstNode(node: CstNode, context: DehydrateContext): any;
-  hydrate<T extends AstNode = AstNode>(result: ParseResult<object>): ParseResult<T>;
-  protected createHydrationContext(node: any): HydrateContext;
-  protected hydrateAstNode(node: any, context: HydrateContext): AstNode;
-  protected setParent(node: any, parent: any): any;
-  protected hydrateReference(reference: any, node: AstNode, name: string, context: HydrateContext): Reference;
-  protected hydrateCstNode(cstNode: any, context: HydrateContext, num?: number): CstNode;
-  protected hydrateCstLeafNode(cstNode: any): LeafCstNode;
-  protected getTokenType(name: string): TokenType;
-  protected getGrammarElementId(node: AbstractElement | undefined): number | undefined;
-  protected getGrammarElement(id: number): AbstractElement | undefined;
-  protected createGrammarElementIdMap(): void;
-}
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/utils/promise-utils.d.ts
 type MaybePromise<T> = T | Promise<T>;
-/**
- * Delays the execution of the current code to the next tick of the event loop.
- * Don't call this method directly in a tight loop to prevent too many promises from being created.
- */
-declare function delayNextTick(): Promise<void>;
-/**
- * Reset the global interruption period and create a cancellation token source.
- */
-declare function startCancelableOperation(): AbstractCancellationTokenSource;
-/**
- * Change the period duration for `interruptAndCheck` to the given number of milliseconds.
- * The default value is 10ms.
- */
-declare function setInterruptionPeriod(period: number): void;
-/**
- * This symbol may be thrown in an asynchronous context by any Langium service that receives
- * a `CancellationToken`. This means that the promise returned by such a service is rejected with
- * this symbol as rejection reason.
- */
-declare const OperationCancelled: unique symbol;
-/**
- * Use this in a `catch` block to check whether the thrown object indicates that the operation
- * has been cancelled.
- */
-declare function isOperationCancelled(err: unknown): err is typeof OperationCancelled;
-/**
- * This function does two things:
- *  1. Check the elapsed time since the last call to this function or to `startCancelableOperation`. If the predefined
- *     period (configured with `setInterruptionPeriod`) is exceeded, execution is delayed with `delayNextTick`.
- *  2. If the predefined period is not met yet or execution is resumed after an interruption, the given cancellation
- *     token is checked, and if cancellation is requested, `OperationCanceled` is thrown.
- *
- * All services in Langium that receive a `CancellationToken` may potentially call this function, so the
- * `CancellationToken` must be caught (with an `async` try-catch block or a `catch` callback attached to
- * the promise) to avoid that event being exposed as an error.
- */
-declare function interruptAndCheck(token: CancellationToken): Promise<void>;
 /**
  * Simple implementation of the deferred pattern.
  * An object that exposes a promise and functions to resolve and reject it.
@@ -11878,8 +10090,6 @@ declare class Deferred<T = void> {
   reject: (err?: unknown) => this;
   promise: Promise<T>;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/parser/async-parser.d.ts
 /**
  * Async parser that allows cancellation of the current parsing process.
  *
@@ -11899,57 +10109,6 @@ interface AsyncParser {
    */
   parse<T extends AstNode>(text: string, cancelToken: CancellationToken): Promise<ParseResult<T>>;
 }
-/**
- * Default implementation of the async parser which simply wraps the sync parser in a promise.
- *
- * @remarks
- * A real implementation would create worker threads or web workers to offload the parsing work.
- */
-declare class DefaultAsyncParser implements AsyncParser {
-  protected readonly syncParser: LangiumParser;
-  constructor(services: LangiumCoreServices);
-  parse<T extends AstNode>(text: string, _cancelToken: CancellationToken): Promise<ParseResult<T>>;
-}
-declare abstract class AbstractThreadedAsyncParser implements AsyncParser {
-  /**
-   * The thread count determines how many threads are used to parse files in parallel.
-   * The default value is 8. Decreasing this value increases startup performance, but decreases parallel parsing performance.
-   */
-  protected threadCount: number;
-  /**
-   * The termination delay determines how long the parser waits for a thread to finish after a cancellation request.
-   * The default value is 200(ms).
-   */
-  protected terminationDelay: number;
-  protected workerPool: ParserWorker[];
-  protected queue: Array<Deferred<ParserWorker>>;
-  protected readonly hydrator: Hydrator;
-  constructor(services: LangiumCoreServices);
-  protected initializeWorkers(): void;
-  parse<T extends AstNode>(text: string, cancelToken: CancellationToken): Promise<ParseResult<T>>;
-  protected terminateWorker(worker: ParserWorker): void;
-  protected acquireParserWorker(cancelToken: CancellationToken): Promise<ParserWorker>;
-  protected abstract createWorker(): ParserWorker;
-}
-type WorkerMessagePost = (message: unknown) => void;
-type WorkerMessageCallback = (cb: (message: unknown) => void) => void;
-declare class ParserWorker {
-  protected readonly sendMessage: WorkerMessagePost;
-  protected readonly _terminate: () => void;
-  protected readonly onReadyEmitter: Emitter<void>;
-  protected deferred: Deferred<ParseResult>;
-  protected _ready: boolean;
-  protected _parsing: boolean;
-  get ready(): boolean;
-  get onReady(): Event<void>;
-  constructor(sendMessage: WorkerMessagePost, onMessage: WorkerMessageCallback, onError: WorkerMessageCallback, terminate: () => void);
-  terminate(): void;
-  lock(): void;
-  unlock(): void;
-  parse(text: string): Promise<ParseResult>;
-}
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/parser/value-converter.d.ts
 /**
  * Language-specific service for converting string values from the source text format into a value to be held in the AST.
  */
@@ -11973,8 +10132,6 @@ declare namespace ValueConverter {
   function convertNumber(input: string): number;
   function convertBoolean(input: string): boolean;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/references/references.d.ts
 /**
  * Language-specific service for finding references and declaration of a given `CstNode`.
  */
@@ -12010,26 +10167,6 @@ interface FindReferencesOptions {
    */
   includeDeclaration?: boolean;
 }
-declare class DefaultReferences implements References {
-  protected readonly nameProvider: NameProvider;
-  protected readonly index: IndexManager;
-  protected readonly nodeLocator: AstNodeLocator;
-  protected readonly documents: LangiumDocuments;
-  protected hasMultiReference: boolean;
-  constructor(services: LangiumCoreServices);
-  findDeclarations(sourceCstNode: CstNode): AstNode[];
-  /**
-   * Returns all self-references for the specified node.
-   * Since the node can be part of a multi-reference, this method returns all nodes that are part of the same multi-reference.
-   */
-  protected getSelfNodes(node: AstNode): AstNode[];
-  protected getNodeFromReferenceDescription(ref?: ReferenceDescription): AstNode | undefined;
-  findDeclarationNodes(sourceCstNode: CstNode): CstNode[];
-  findReferences(targetNode: AstNode, options: FindReferencesOptions): Stream<ReferenceDescription>;
-  protected getSelfReferences(targetNode: AstNode): ReferenceDescription[];
-}
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/references/scope-computation.d.ts
 /**
  * Language-specific service for precomputing global and local scopes. The service methods are executed
  * as the first and second phase in the `DocumentBuilder`.
@@ -12108,8 +10245,6 @@ declare class DefaultScopeComputation implements ScopeComputation {
    */
   protected addLocalSymbol(node: AstNode, document: LangiumDocument, symbols: MultiMap<AstNode, AstNodeDescription>): void;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/serializer/json-serializer.d.ts
 interface JsonSerializeOptions {
   /** The space parameter for `JSON.stringify`, controlling whether and how to pretty-print the output. */
   space?: string | number;
@@ -12130,37 +10265,6 @@ interface JsonDeserializeOptions {
   /** Used to parse and convert URIs when the target of a cross-reference is in a different document. */
   uriConverter?: (uri: string) => URI$1;
 }
-/**
- * {@link AstNode}s that may carry information on their definition area within the DSL text.
- */
-interface AstNodeWithTextRegion extends AstNode {
-  $sourceText?: string;
-  $textRegion?: AstNodeRegionWithAssignments;
-}
-/**
- * {@link AstNode}s that may carry a semantically relevant comment.
- */
-interface AstNodeWithComment extends AstNode {
-  $comment?: string;
-}
-declare function isAstNodeWithComment(node: AstNode): node is AstNodeWithComment;
-/**
- * A {@link DocumentSegment} representing the definition area of an AstNode within the DSL text.
- * Usually contains text region information on all assigned property values of the AstNode,
- * and may contain the defining file's URI as string.
- */
-interface AstNodeRegionWithAssignments extends DocumentSegment {
-  /**
-   * A record containing an entry for each assigned property of the AstNode.
-   * The key is equal to the property name and the value is an array of the property values'
-   * text regions, regardless of whether the property is a single value or list property.
-   */
-  assignments?: Record<string, DocumentSegment[]>;
-  /**
-   * The AstNode defining file's URI as string
-   */
-  documentURI?: string;
-}
 /**
  * Utility service for transforming an `AstNode` into a JSON string and vice versa.
  */
@@ -12176,39 +10280,6 @@ interface JsonSerializer {
    */
   deserialize<T extends AstNode = AstNode>(content: string, options?: JsonDeserializeOptions): T;
 }
-/**
- * A cross-reference in the serialized JSON representation of an AstNode.
- */
-interface IntermediateReference {
-  /** URI pointing to the target element. This is either `#${path}` if the target is in the same document, or `${documentURI}#${path}` otherwise. */
-  $ref?: string;
-  /** URI pointing to the target elements. This is the multi reference equivalent for {@link $ref}. */
-  $refs?: string[];
-  /** The actual text used to look up the reference target in the surrounding scope. */
-  $refText?: string;
-  /** If any problem occurred while resolving the reference, it is described by this property. */
-  $error?: string;
-}
-declare class DefaultJsonSerializer implements JsonSerializer {
-  /** The set of AstNode properties to be ignored by the serializer. */
-  ignoreProperties: Set<string>;
-  /** The document that is currently processed by the serializer; this is used by the replacer function.  */
-  protected currentDocument: LangiumDocument | undefined;
-  protected readonly langiumDocuments: LangiumDocuments;
-  protected readonly astNodeLocator: AstNodeLocator;
-  protected readonly nameProvider: NameProvider;
-  protected readonly commentProvider: CommentProvider;
-  constructor(services: LangiumCoreServices);
-  serialize(node: AstNode, options?: JsonSerializeOptions): string;
-  deserialize<T extends AstNode = AstNode>(content: string, options?: JsonDeserializeOptions): T;
-  protected replacer(key: string, value: unknown, { refText, sourceText, textRegions, comments, uriConverter }: JsonSerializeOptions): unknown;
-  protected addAstNodeRegionWithAssignmentsTo(node: AstNodeWithTextRegion): AstNodeWithTextRegion | undefined;
-  protected linkNode(node: GenericAstNode, root: AstNode, options: JsonDeserializeOptions, container?: AstNode, containerProperty?: string, containerIndex?: number): void;
-  protected reviveReference(container: AstNode, property: string, root: AstNode, reference: IntermediateReference, options: JsonDeserializeOptions): Reference | MultiReference | undefined;
-  protected getRefNode(root: AstNode, uri: string, uriConverter?: (uri: string) => URI$1): AstNode | string;
-}
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/validation/validation-registry.d.ts
 type DiagnosticInfo<N extends AstNode, P extends string = Properties<N>> = {
   /** The AST node to which the diagnostic is attached. */
   node: N;
@@ -12231,21 +10302,6 @@ type DiagnosticInfo<N extends AstNode, P extends string = Properties<N>> = {
   /** A data entry field that is preserved between a `textDocument/publishDiagnostics` notification and `textDocument/codeAction` request. */
   data?: unknown;
 };
-/**
- * Shape of information commonly used in the `data` field of diagnostics.
- */
-interface DiagnosticData {
-  /** Diagnostic code for identifying which code action to apply. This code is _not_ shown in the user interface. */
-  code: string;
-  /** Specifies where to apply the code action in the form of a `DocumentSegment`. */
-  actionSegment?: DocumentSegment;
-  /** Specifies where to apply the code action in the form of a `Range`. */
-  actionRange?: Range;
-}
-/**
- * Create DiagnosticData for a given diagnostic code. The result can be put into the `data` field of a DiagnosticInfo.
- */
-declare function diagnosticData(code: string): DiagnosticData;
 type ValidationSeverity = 'error' | 'warning' | 'info' | 'hint';
 type ValidationAcceptor = <N extends AstNode>(severity: ValidationSeverity, message: string, info: DiagnosticInfo<N>) => void;
 type ValidationCheck<T extends AstNode = AstNode> = (node: T, accept: ValidationAcceptor, cancelToken: CancellationToken) => MaybePromise<void>;
@@ -12369,8 +10425,6 @@ declare class ValidationRegistry {
   get checksAfter(): ValidationPreparation[];
   getAllValidationCategories(_document: LangiumDocument): ReadonlySet<ValidationCategory>;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/validation/document-validator.d.ts
 interface ValidationOptions {
   /**
    * If this is set, only the checks associated with these categories are executed; otherwise
@@ -12402,7 +10456,6 @@ interface ValidateSingleNodeOptions {
   validateNode: boolean;
   validateChildren: boolean;
 }
-declare const VALIDATE_EACH_NODE: ValidateSingleNodeOptions;
 declare class DefaultDocumentValidator implements DocumentValidator {
   protected readonly validationRegistry: ValidationRegistry;
   protected readonly metadata: LanguageMetaData;
@@ -12421,15 +10474,6 @@ declare class DefaultDocumentValidator implements DocumentValidator {
   protected toDiagnostic<N extends AstNode>(severity: ValidationSeverity, message: string, info: DiagnosticInfo<N, string>): Diagnostic;
   protected getSource(): string | undefined;
 }
-declare function getDiagnosticRange<N extends AstNode>(info: DiagnosticInfo<N, string>): Range;
-/**
- * Transforms the diagnostic severity from the {@link LexingDiagnosticSeverity} format to LSP's `DiagnosticSeverity` format.
- *
- * @param severity The lexing diagnostic severity
- * @returns Diagnostic severity according to `vscode-languageserver-types/lib/esm/main.js#DiagnosticSeverity`
- */
-declare function toDiagnosticSeverity(severity: LexingDiagnosticSeverity): DiagnosticSeverity;
-declare function toDiagnosticData(severity: LexingDiagnosticSeverity): DiagnosticData;
 declare namespace DocumentValidator {
   const LexingError = "lexing-error";
   const LexingWarning = "lexing-warning";
@@ -12438,13 +10482,6 @@ declare namespace DocumentValidator {
   const ParsingError = "parsing-error";
   const LinkingError = "linking-error";
 }
-interface LinkingErrorData extends DiagnosticData {
-  containerType: string;
-  property: string;
-  refText: string;
-}
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/workspace/configuration.d.ts
 interface ConfigurationProvider {
   /**
    * A promise that resolves when the configuration provider is ready to be used.
@@ -12494,39 +10531,6 @@ interface ConfigurationSectionUpdate {
   configuration: any;
 }
 type ConfigurationSectionUpdateListener = (update: ConfigurationSectionUpdate) => void;
-/**
- * Base configuration provider for building up other configuration providers
- */
-declare class DefaultConfigurationProvider implements ConfigurationProvider {
-  protected readonly serviceRegistry: ServiceRegistry;
-  protected readonly _ready: Deferred<void>;
-  protected readonly onConfigurationSectionUpdateEmitter: Emitter<ConfigurationSectionUpdate>;
-  protected settings: Record<string, Record<string, any>>;
-  protected workspaceConfig: boolean;
-  constructor(services: LangiumSharedCoreServices);
-  get ready(): Promise<void>;
-  initialize(params: InitializeParams): void;
-  initialized(params: ConfigurationInitializedParams): Promise<void>;
-  /**
-   *  Updates the cached configurations using the `change` notification parameters.
-   *
-   * @param change The parameters of a change configuration notification.
-   * `settings` property of the change object could be expressed as `Record<string, Record<string, any>>`
-   */
-  updateConfiguration(change: DidChangeConfigurationParams): void;
-  protected updateSectionConfiguration(section: string, configuration: any): void;
-  /**
-   * Returns a configuration value stored for the given language.
-   *
-   * @param language The language id
-   * @param configuration Configuration name
-   */
-  getConfiguration(language: string, configuration: string): Promise<any>;
-  protected toSectionName(languageId: string): string;
-  get onConfigurationSectionUpdate(): Event<ConfigurationSectionUpdate>;
-}
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/workspace/workspace-lock.d.ts
 /**
  * Utility service to execute mutually exclusive actions.
  */
@@ -12569,20 +10573,6 @@ declare enum ReadPriority {
    */
   Immediate = 1
 }
-declare class DefaultWorkspaceLock implements WorkspaceLock {
-  private previousTokenSource;
-  private writeQueue;
-  private readQueue;
-  private immediateReads;
-  private done;
-  write(action: (token: CancellationToken) => MaybePromise<void>): Promise<void>;
-  read<T>(action: () => MaybePromise<T>, priority?: ReadPriority): Promise<T>;
-  private enqueue;
-  private performNextOperation;
-  cancelWrite(): void;
-}
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/workspace/workspace-manager.d.ts
 /**
  * The workspace manager is responsible for finding source files in the workspace.
  * This service is shared between all languages of a language server.
@@ -12635,15 +10625,6 @@ interface WorkspaceManager {
    */
   shouldIncludeEntry(entry: FileSystemNode): boolean;
 }
-/**
- * The FileSelector provides file names and extensions used by this extension.
- */
-interface FileSelector {
-  /** Allowed file extensions (e.g., ["ts", "js"]). */
-  fileExtensions: string[];
-  /** Allowed file names (e.g., ["config", "settings"]). */
-  fileNames: string[];
-}
 declare class DefaultWorkspaceManager implements WorkspaceManager {
   initialBuildOptions: BuildOptions;
   protected readonly serviceRegistry: ServiceRegistry;
@@ -12688,8 +10669,6 @@ declare class DefaultWorkspaceManager implements WorkspaceManager {
    */
   shouldIncludeEntry(entry: FileSystemNode): boolean;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/workspace/document-builder.d.ts
 interface BuildOptions {
   /**
    * Control the linking and references indexing phase with this option. The default if not specified is `true`.
@@ -12886,8 +10865,6 @@ declare class DefaultDocumentBuilder implements DocumentBuilder {
   protected validate(document: LangiumDocument, cancelToken: CancellationToken): Promise<void>;
   protected getBuildOptions(document: LangiumDocument): BuildOptions;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/services.d.ts
 /**
  * The services generated by `langium-cli` for a specific language. These are derived from the
  * grammar definition and the language configuration.
@@ -12912,7 +10889,7 @@ type LangiumDefaultCoreServices = {
     readonly LexerErrorMessageProvider: ILexerErrorMessageProvider;
     readonly CompletionParser: LangiumCompletionParser;
     readonly TokenBuilder: TokenBuilder;
-    readonly Lexer: Lexer$1;
+    readonly Lexer: Lexer;
   };
   readonly documentation: {
     readonly CommentProvider: CommentProvider;
@@ -12977,28 +10954,12 @@ type LangiumDefaultSharedCoreServices = {
  * This is necessary to enable features like cross references across different languages.
  */
 type LangiumSharedCoreServices = LangiumDefaultSharedCoreServices & LangiumGeneratedSharedCoreServices;
-/**
- * A deep partial type definition for services. We look into T to see whether its type definition contains
- * any methods. If it does, it's one of our services and therefore should not be partialized.
- */
-type DeepPartial<T> = T[keyof T] extends Function ? T : { [P in keyof T]?: DeepPartial<T[P]>; };
-/**
- * Language-specific core services to be partially overridden via dependency injection.
- */
-type PartialLangiumCoreServices = DeepPartial<LangiumCoreServices>;
-/**
- * Shared core services to be partially overridden via dependency injection.
- */
-type PartialLangiumSharedCoreServices = DeepPartial<LangiumSharedCoreServices>;
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/parser/langium-parser.d.ts
 type ParseResult<T = AstNode> = {
   value: T;
   parserErrors: IRecognitionException[];
   lexerErrors: ILexingError[];
   lexerReport?: LexingReport;
 };
-declare const DatatypeSymbol: unique symbol;
 type RuleResult = (args: Args) => any;
 type Args = Record<string, boolean>;
 type RuleImpl = (args: Args) => any;
@@ -13065,7 +11026,7 @@ interface BaseParser {
   getRuleStack(): number[];
 }
 declare abstract class AbstractLangiumParser implements BaseParser {
-  protected readonly lexer: Lexer$1;
+  protected readonly lexer: Lexer;
   protected readonly wrapper: ChevrotainWrapper;
   protected _unorderedGroups: Map<string, boolean[]>;
   protected allRules: Map<string, RuleResult>;
@@ -13137,44 +11098,6 @@ interface IParserDefinitionError {
   type: number;
   ruleName?: string;
 }
-declare abstract class AbstractParserErrorMessageProvider implements IParserErrorMessageProvider {
-  buildMismatchTokenMessage(options: {
-    expected: TokenType;
-    actual: IToken;
-    previous: IToken;
-    ruleName: string;
-  }): string;
-  buildNotAllInputParsedMessage(options: {
-    firstRedundant: IToken;
-    ruleName: string;
-  }): string;
-  buildNoViableAltMessage(options: {
-    expectedPathsPerAlt: TokenType[][][];
-    actual: IToken[];
-    previous: IToken;
-    customUserDescription: string;
-    ruleName: string;
-  }): string;
-  buildEarlyExitMessage(options: {
-    expectedIterationPaths: TokenType[][];
-    actual: IToken[];
-    previous: IToken;
-    customUserDescription: string;
-    ruleName: string;
-  }): string;
-}
-declare class LangiumParserErrorMessageProvider extends AbstractParserErrorMessageProvider {
-  buildMismatchTokenMessage({ expected, actual }: {
-    expected: TokenType;
-    actual: IToken;
-    previous: IToken;
-    ruleName: string;
-  }): string;
-  buildNotAllInputParsedMessage({ firstRedundant }: {
-    firstRedundant: IToken;
-    ruleName: string;
-  }): string;
-}
 interface CompletionParserResult {
   tokens: IToken[];
   elementStack: AbstractElement[];
@@ -13220,8 +11143,6 @@ declare class ChevrotainWrapper extends EmbeddedActionsParser {
   wrapAtLeastOne(idx: number, callback: DSLMethodOpts<unknown>): void;
   rule(rule: RuleResult): any;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/workspace/documents.d.ts
 /**
  * A Langium document holds the parse result (AST and CST) and any additional state that is derived
  * from the AST, e.g. the result of scope precomputation.
@@ -13354,40 +11275,6 @@ interface LangiumDocumentFactory {
    */
   update<T extends AstNode = AstNode>(document: LangiumDocument<T>, cancellationToken: CancellationToken): Promise<LangiumDocument<T>>;
 }
-declare class DefaultLangiumDocumentFactory implements LangiumDocumentFactory {
-  protected readonly serviceRegistry: ServiceRegistry;
-  protected readonly textDocuments?: TextDocumentProvider;
-  protected readonly fileSystemProvider: FileSystemProvider;
-  constructor(services: LangiumSharedCoreServices);
-  fromUri<T extends AstNode = AstNode>(uri: URI$1, cancellationToken?: CancellationToken): Promise<LangiumDocument<T>>;
-  protected getInitialText(uri: URI$1, _cancellationToken: CancellationToken): Promise<string>;
-  fromTextDocument<T extends AstNode = AstNode>(textDocument: TextDocument, uri?: URI$1, options?: ParserOptions): LangiumDocument<T>;
-  fromTextDocument<T extends AstNode = AstNode>(textDocument: TextDocument, uri: URI$1 | undefined, cancellationToken: CancellationToken): Promise<LangiumDocument<T>>;
-  fromString<T extends AstNode = AstNode>(text: string, uri: URI$1, options?: ParserOptions): LangiumDocument<T>;
-  fromString<T extends AstNode = AstNode>(text: string, uri: URI$1, cancellationToken: CancellationToken): Promise<LangiumDocument<T>>;
-  fromModel<T extends AstNode = AstNode>(model: T, uri: URI$1): LangiumDocument<T>;
-  protected create<T extends AstNode = AstNode>(uri: URI$1, content: string | TextDocument | {
-    $model: T;
-  }, options?: ParserOptions): LangiumDocument<T>;
-  protected createAsync<T extends AstNode = AstNode>(uri: URI$1, content: string | TextDocument, cancelToken: CancellationToken): Promise<LangiumDocument<T>>;
-  /**
-   * Create a LangiumDocument from a given parse result.
-   *
-   * A TextDocument is created on demand if it is not provided as argument here. Usually this
-   * should not be necessary because the main purpose of the TextDocument is to convert between
-   * text ranges and offsets, which is done solely in LSP request handling.
-   *
-   * With the introduction of {@link update} below this method is supposed to be mainly called
-   * during workspace initialization and on addition/recognition of new files, while changes in
-   * existing documents are processed via {@link update}.
-   */
-  protected createLangiumDocument<T extends AstNode = AstNode>(parseResult: ParseResult<T>, uri: URI$1, textDocument?: TextDocument, text?: string): LangiumDocument<T>;
-  update<T extends AstNode = AstNode>(document: Mutable<LangiumDocument<T>>, cancellationToken: CancellationToken): Promise<LangiumDocument<T>>;
-  protected getUpdatedText<T extends AstNode>(document: Mutable<LangiumDocument<T>>, textDocument: TextDocument | undefined, _cancellationToken: CancellationToken): Promise<string>;
-  protected parse<T extends AstNode>(uri: URI$1, text: string, options?: ParserOptions): ParseResult<T>;
-  protected parseAsync<T extends AstNode>(uri: URI$1, text: string, cancellationToken: CancellationToken): Promise<ParseResult<T>>;
-  protected createTextDocumentGetter(uri: URI$1, text?: string): () => TextDocument;
-}
 /**
  * Shared service for managing Langium documents.
  */
@@ -13482,9 +11369,6 @@ declare class DefaultLangiumDocuments implements LangiumDocuments {
   deleteDocument(uri: URI$1): LangiumDocument | undefined;
   deleteDocuments(folder: URI$1): LangiumDocument[];
 }
-declare namespace syntax_tree_d_exports {
-  export { AbstractAstReflection, AstMetaData, AstNode, AstNodeDescription, AstNodeTypesWithCrossReferences, AstReflection, AstTypeList, CompositeCstNode, CrossReferencesOfAstNodeType, CstNode, GenericAstNode, LeafCstNode, LinkingError, MultiCrossReferencesOfAstNodeType, MultiReference, MultiReferenceItem, Mutable, Properties, PropertyMetaData, PropertyType, Reference, ReferenceInfo, ResolvedReference, RootCstNode, SingleCrossReferencesOfAstNodeType, TypeMetaData, isAstNode, isAstNodeDescription, isCompositeCstNode, isLeafCstNode, isLinkingError, isMultiReference, isReference, isRootCstNode };
-}
 /**
  * A node in the Abstract Syntax Tree (AST).
  */
@@ -13502,10 +11386,6 @@ interface AstNode {
   /** The document containing the AST; only the root node has a direct reference to the document. */
   readonly $document?: LangiumDocument;
 }
-declare function isAstNode(obj: unknown): obj is AstNode;
-interface GenericAstNode extends AstNode {
-  [key: string]: unknown;
-}
 type SpecificNodeProperties<N extends AstNode> = keyof Omit<N, keyof AstNode | number | symbol>;
 /**
  * The property names of a given AST node type.
@@ -13556,11 +11436,6 @@ interface MultiReferenceItem<T extends AstNode = AstNode> {
    */
   readonly ref: T;
 }
-declare function isReference(obj: unknown): obj is Reference;
-declare function isMultiReference(obj: unknown): obj is MultiReference;
-type ResolvedReference<T extends AstNode = AstNode> = Reference<T> & {
-  readonly ref: T;
-};
 /**
  * A description of an AST node is used when constructing scopes and looking up cross-reference targets.
  */
@@ -13584,7 +11459,6 @@ interface AstNodeDescription {
   /** Navigation path inside the document */
   path: string;
 }
-declare function isAstNodeDescription(obj: unknown): obj is AstNodeDescription;
 /**
  * Information about a cross-reference. This is used when traversing references in an AST or to describe
  * unresolved references.
@@ -13603,7 +11477,6 @@ interface LinkingError {
   info: ReferenceInfo;
   targetDescription?: AstNodeDescription;
 }
-declare function isLinkingError(obj: unknown): obj is LinkingError;
 /**
  * Service used for generic access to the structure of the AST. This service is shared between
  * all involved languages, so it operates on the superset of types of these languages.
@@ -13724,674 +11597,9 @@ interface CstNode extends DocumentSegment {
 interface CompositeCstNode extends CstNode {
   readonly content: readonly CstNode[];
 }
-declare function isCompositeCstNode(node: unknown): node is CompositeCstNode;
-/**
- * A leaf CST node corresponds to a token in the input token stream.
- */
-interface LeafCstNode extends CstNode {
-  readonly tokenType: TokenType;
-}
-declare function isLeafCstNode(node: unknown): node is LeafCstNode;
 interface RootCstNode extends CompositeCstNode {
   readonly fullText: string;
 }
-declare function isRootCstNode(node: unknown): node is RootCstNode;
-/**
- * Describes a union type including only names(!) of properties of type T whose property value is of a certain type K,
- *  or 'never' in case of no such properties.
- * It evaluates the value type regardless of the property being optional or not by converting T to Required<T>.
- * Note the '-?' in '[I in keyof T]-?:' that is required to map all optional but un-intended properties to 'never'.
- * Without that, optional props like those inherited from 'AstNode' would be mapped to 'never|undefined',
- *  and the subsequent value mapping ('...[keyof T]') would yield 'undefined' instead of 'never' for AstNode types
- *  not having any property matching type K, which in turn yields follow-up errors.
- */
-type ExtractKeysOfValueType<T, K> = { [I in keyof T]-?: Required<T>[I] extends K ? I : never; }[keyof T];
-type SingleCrossReferencesOfAstNodeType<N extends AstNode> = ExtractKeysOfValueType<N, Reference | Reference[]>;
-type MultiCrossReferencesOfAstNodeType<N extends AstNode> = ExtractKeysOfValueType<N, MultiReference | MultiReference[]>;
-/**
- * Describes a union type including only names(!) of the cross-reference properties of the given AstNode type.
- * Enhances compile-time validation of cross-reference distinctions, e.g. in scope providers
- *  in combination with `assertUnreachable(context.property)`.
- */
-type CrossReferencesOfAstNodeType<N extends AstNode> = SingleCrossReferencesOfAstNodeType<N> | MultiCrossReferencesOfAstNodeType<N>;
-/**
- * Represents the enumeration-like type, that lists all AstNode types of your grammar.
- */
-type AstTypeList<T> = Record<keyof T, AstNode>;
-/**
- * Describes a union type including of all AstNode types containing cross-references.
- *  A is meant to be the interface `XXXAstType` fromm your generated `ast.ts` file.
- * Enhances compile-time validation of cross-reference distinctions, e.g. in scope providers
- *  in combination with `assertUnreachable(context.container)`.
- */
-type AstNodeTypesWithCrossReferences<A extends AstTypeList<A>> = { [T in keyof A]-?: CrossReferencesOfAstNodeType<A[T]> extends never ? never : A[T]; }[keyof A];
-type Mutable<T> = { -readonly [P in keyof T]: T[P]; };
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/dependency-injection.d.ts
-/******************************************************************************
- * Copyright 2021 TypeFox GmbH
- * This program and the accompanying materials are made available under the
- * terms of the MIT License, which is available in the project root.
- ******************************************************************************/
-/**
- * A `Module<I>` is a description of possibly grouped service factories.
- *
- * Given a type I = { group: { service: A } },
- * Module<I> := { group: { service: (injector: I) => A } }
- *
- * Making `I` available during the creation of `I` allows us to create cyclic
- * dependencies.
- */
-type Module<I, T = I> = { [K in keyof T]: Module<I, T[K]> | ((injector: I) => T[K]); };
-declare namespace Module {
-  /**
-   * Merges two dependency injection modules into a new (third) one that is returned.
-   * At that `m1` and `m2` stay unchanged. Therefore, `m1` is deep-copied first,
-   * and m2 is merged onto the copy afterwards.
-   *
-   * Note that the leaf values of `m1` and `m2`, i.e. the service constructor functions,
-   * cannot be copied generically, since they are functions. They are shared by the source and merged modules.
-   *
-   * @returns the merged module being a deep copy of `m1` with `m2` merged onto it.
-   */
-  const merge: <M1, M2, R extends M1 & M2>(m1: Module<R, M1>, m2: Module<R, M2>) => Module<R, M1 & M2>;
-}
-/**
- * Given a set of modules, the inject function returns a lazily evaluated injector
- * that injects dependencies into the requested service when it is requested the
- * first time. Subsequent requests will return the same service.
- *
- * In the case of cyclic dependencies, an Error will be thrown. This can be fixed
- * by injecting a provider `() => T` instead of a `T`.
- *
- * Please note that the arguments may be objects or arrays. However, the result will
- * be an object. Using it with for..of will have no effect.
- *
- * @param module1 first Module
- * @param module2 (optional) second Module
- * @param module3 (optional) third Module
- * @param module4 (optional) fourth Module
- * @param module5 (optional) fifth Module
- * @param module6 (optional) sixth Module
- * @param module7 (optional) seventh Module
- * @param module8 (optional) eighth Module
- * @param module9 (optional) ninth Module
- * @returns a new object of type I
- */
-declare function inject<I1, I2, I3, I4, I5, I6, I7, I8, I9, I extends I1 & I2 & I3 & I4 & I5 & I6 & I7 & I8 & I9>(module1: Module<I, I1>, module2?: Module<I, I2>, module3?: Module<I, I3>, module4?: Module<I, I4>, module5?: Module<I, I5>, module6?: Module<I, I6>, module7?: Module<I, I7>, module8?: Module<I, I8>, module9?: Module<I, I9>): I;
-/**
- * Eagerly load all services in the given dependency injection container. This is sometimes
- * necessary because services can register event listeners in their constructors.
- */
-declare function eagerLoad<T>(item: T): T;
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/default-module.d.ts
-/**
- * Context required for creating the default language-specific dependency injection module.
- */
-interface DefaultCoreModuleContext {
-  shared: LangiumSharedCoreServices;
-}
-/**
- * Creates a dependency injection module configuring the default core services.
- * This is a set of services that are dedicated to a specific language.
- */
-declare function createDefaultCoreModule(context: DefaultCoreModuleContext): Module<LangiumCoreServices, LangiumDefaultCoreServices>;
-/**
- * Context required for creating the default shared dependency injection module.
- */
-interface DefaultSharedCoreModuleContext {
-  /**
-   * Factory function to create a {@link FileSystemProvider}.
-   *
-   * Langium exposes an `EmptyFileSystem` and `NodeFileSystem`, exported through `langium/node`.
-   * When running Langium as part of a vscode language server or a Node.js app, using the `NodeFileSystem` is recommended,
-   * the `EmptyFileSystem` in every other use case.
-   */
-  fileSystemProvider: (services: LangiumSharedCoreServices) => FileSystemProvider;
-}
-/**
- * Creates a dependency injection module configuring the default shared core services.
- * This is the set of services that are shared between multiple languages.
- */
-declare function createDefaultSharedCoreModule(context: DefaultSharedCoreModuleContext): Module<LangiumSharedCoreServices, LangiumDefaultSharedCoreServices>;
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/parser/completion-parser-builder.d.ts
-declare function createCompletionParser(services: LangiumCoreServices): LangiumCompletionParser;
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/parser/indentation-aware.d.ts
-type IndentationAwareDelimiter<TokenName extends string> = [begin: TokenName, end: TokenName];
-interface IndentationTokenBuilderOptions<TerminalName extends string = string, KeywordName extends string = string> {
-  /**
-   * The name of the token used to denote indentation in the grammar.
-   * A possible definition in the grammar could look like this:
-   * ```langium
-   * terminal INDENT: ':synthetic-indent:';
-   * ```
-   *
-   * @default 'INDENT'
-   */
-  indentTokenName: TerminalName;
-  /**
-   * The name of the token used to denote deindentation in the grammar.
-   * A possible definition in the grammar could look like this:
-   * ```langium
-   * terminal DEDENT: ':synthetic-dedent:';
-   * ```
-   *
-   * @default 'DEDENT'
-   */
-  dedentTokenName: TerminalName;
-  /**
-   * The name of the token used to denote whitespace other than indentation and newlines in the grammar.
-   * A possible definition in the grammar could look like this:
-   * ```langium
-   * hidden terminal WS: /[ \t]+/;
-   * ```
-   *
-   * @default 'WS'
-   */
-  whitespaceTokenName: TerminalName;
-  /**
-   * The delimiter tokens inside of which indentation should be ignored and treated as normal whitespace.
-   * For example, Python doesn't treat any whitespace between `(` and `)` as significant.
-   *
-   * Can be either terminal tokens or keyword tokens.
-   *
-   * @default []
-   */
-  ignoreIndentationDelimiters: Array<IndentationAwareDelimiter<TerminalName | KeywordName>>;
-}
-declare const indentationBuilderDefaultOptions: IndentationTokenBuilderOptions;
-declare enum LexingMode {
-  REGULAR = "indentation-sensitive",
-  IGNORE_INDENTATION = "ignore-indentation"
-}
-interface IndentationLexingReport extends LexingReport {
-  /** Dedent tokens that are necessary to close the remaining indents. */
-  remainingDedents: IToken[];
-}
-/**
- * A token builder that is sensitive to indentation in the input text.
- * It will generate tokens for indentation and dedentation based on the indentation level.
- *
- * The first generic parameter corresponds to the names of terminal tokens,
- * while the second one corresponds to the names of keyword tokens.
- * Both parameters are optional and can be imported from `./generated/ast.js`.
- *
- * Inspired by https://github.com/chevrotain/chevrotain/blob/master/examples/lexer/python_indentation/python_indentation.js
- */
-declare class IndentationAwareTokenBuilder<Terminals extends string = string, KeywordName extends string = string> extends DefaultTokenBuilder {
-  /**
-   * The stack stores all the previously matched indentation levels to understand how deeply the next tokens are nested.
-   * The stack is valid for lexing
-   */
-  protected indentationStack: number[];
-  readonly options: IndentationTokenBuilderOptions<Terminals, KeywordName>;
-  /**
-   * The token type to be used for indentation tokens
-   */
-  readonly indentTokenType: TokenType;
-  /**
-   * The token type to be used for dedentation tokens
-   */
-  readonly dedentTokenType: TokenType;
-  /**
-   * A regular expression to match a series of tabs and/or spaces.
-   * Override this to customize what the indentation is allowed to consist of.
-   */
-  protected whitespaceRegExp: RegExp;
-  constructor(options?: Partial<IndentationTokenBuilderOptions<NoInfer<Terminals>, NoInfer<KeywordName>>>);
-  buildTokens(grammar: Grammar, options?: TokenBuilderOptions | undefined): TokenVocabulary;
-  flushLexingReport(text: string): IndentationLexingReport;
-  /**
-   * Helper function to check if the current position is the start of a new line.
-   *
-   * @param text The full input string.
-   * @param offset The current position at which to check
-   * @returns Whether the current position is the start of a new line
-   */
-  protected isStartOfLine(text: string, offset: number): boolean;
-  /**
-   * A helper function used in matching both indents and dedents.
-   *
-   * @param text The full input string.
-   * @param offset The current position at which to attempt a match
-   * @param tokens Previously scanned tokens
-   * @param groups Token Groups
-   * @returns The current and previous indentation levels and the matched whitespace
-   */
-  protected matchWhitespace(text: string, offset: number, tokens: IToken[], groups: Record<string, IToken[]>): {
-    currIndentLevel: number;
-    prevIndentLevel: number;
-    match: RegExpExecArray | null;
-  };
-  /**
-   * Helper function to create an instance of an indentation token.
-   *
-   * @param tokenType Indent or dedent token type
-   * @param text Full input string, used to calculate the line number
-   * @param image The original image of the token (tabs or spaces)
-   * @param offset Current position in the input string
-   * @returns The indentation token instance
-   */
-  protected createIndentationTokenInstance(tokenType: TokenType, text: string, image: string, offset: number): IToken;
-  /**
-   * Helper function to get the line number at a given offset.
-   *
-   * @param text Full input string, used to calculate the line number
-   * @param offset Current position in the input string
-   * @returns The line number at the given offset
-   */
-  protected getLineNumber(text: string, offset: number): number;
-  /**
-   * A custom pattern for matching indents
-   *
-   * @param text The full input string.
-   * @param offset The offset at which to attempt a match
-   * @param tokens Previously scanned tokens
-   * @param groups Token Groups
-   */
-  protected indentMatcher(text: string, offset: number, tokens: IToken[], groups: Record<string, IToken[]>): ReturnType<CustomPatternMatcherFunc>;
-  /**
-   * A custom pattern for matching dedents
-   *
-   * @param text The full input string.
-   * @param offset The offset at which to attempt a match
-   * @param tokens Previously scanned tokens
-   * @param groups Token Groups
-   */
-  protected dedentMatcher(text: string, offset: number, tokens: IToken[], groups: Record<string, IToken[]>): ReturnType<CustomPatternMatcherFunc>;
-  protected buildTerminalToken(terminal: TerminalRule): TokenType;
-  /**
-   * Resets the indentation stack between different runs of the lexer
-   *
-   * @param text Full text that was tokenized
-   * @returns Remaining dedent tokens to match all previous indents at the end of the file
-   */
-  flushRemainingDedents(text: string): IToken[];
-}
-/**
- * A lexer that is aware of indentation in the input text.
- * The only purpose of this lexer is to reset the internal state of the {@link IndentationAwareTokenBuilder}
- * between the tokenization of different text inputs.
- *
- * In your module, you can override the default lexer with this one as such:
- * ```ts
- * parser: {
- *    TokenBuilder: () => new IndentationAwareTokenBuilder(),
- *    Lexer: (services) => new IndentationAwareLexer(services),
- * }
- * ```
- */
-declare class IndentationAwareLexer extends DefaultLexer {
-  protected readonly indentationTokenBuilder: IndentationAwareTokenBuilder;
-  constructor(services: LangiumCoreServices);
-  tokenize(text: string, options?: TokenizeOptions): LexerResult;
-}
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/parser/langium-parser-builder.d.ts
-/**
- * Create and finalize a Langium parser. The parser rules are derived from the grammar, which is
- * available at `services.Grammar`.
- */
-declare function createLangiumParser(services: LangiumCoreServices): LangiumParser;
-/**
- * Create a Langium parser without finalizing it. This is used to extract more detailed error
- * information when the parser is initially validated.
- */
-declare function prepareLangiumParser(services: LangiumCoreServices): LangiumParser;
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/parser/parser-builder-base.d.ts
-declare function createParser<T extends BaseParser>(grammar: Grammar, parser: T, tokens: TokenTypeDictionary): T;
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/utils/errors.d.ts
-declare class ErrorWithLocation extends Error {
-  constructor(node: CstNode | undefined, message: string | (() => string));
-}
-declare function assertUnreachable(_: never, message?: string | (() => string)): never;
-declare function assertCondition(condition: boolean, message?: string | (() => string)): asserts condition;
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/utils/grammar-loader.d.ts
-/**
- * Load a Langium grammar for your language from a JSON string. This is used by several services,
- * most notably the parser builder which interprets the grammar to create a parser.
- */
-declare function loadGrammarFromJson(json: string): Grammar;
-declare namespace ast_utils_d_exports {
-  export { AstStreamOptions, DeepPartialAstNode, assignMandatoryProperties, copyAstNode, findRootNode, getContainerOfType, getDocument, getReferenceNodes, hasContainerOfType, linkContentToContainer, streamAllContents, streamAst, streamContents, streamReferences };
-}
-/**
- * Link the `$container` and other related properties of every AST node that is directly contained
- * in the given `node`.
- */
-declare function linkContentToContainer(node: AstNode, options?: {
-  /**
-   * If true, the function will also link the content of the contained nodes.
-   * Otherwise, only the immediate children of the given node are linked to their container.
-   */
-  deep?: boolean;
-}): void;
-/**
- * Walk along the hierarchy of containers from the given AST node to the root and return the first
- * node that matches the type predicate. If the start node itself matches, it is returned.
- * If no container matches, `undefined` is returned.
- */
-declare function getContainerOfType<T extends AstNode>(node: AstNode | undefined, typePredicate: (n: AstNode) => n is T): T | undefined;
-/**
- * Walk along the hierarchy of containers from the given AST node to the root and check for existence
- * of a container that matches the given predicate. The start node is included in the checks.
- */
-declare function hasContainerOfType(node: AstNode | undefined, predicate: (n: AstNode) => boolean): boolean;
-/**
- * Retrieve the document in which the given AST node is contained. A reference to the document is
- * usually held by the root node of the AST.
- *
- * @throws an error if the node is not contained in a document.
- */
-declare function getDocument<T extends AstNode = AstNode>(node: AstNode): LangiumDocument<T>;
-/**
- * Returns the root node of the given AST node by following the `$container` references.
- */
-declare function findRootNode(node: AstNode): AstNode;
-/**
- * Returns all AST nodes that are referenced by the given reference or multi-reference.
- */
-declare function getReferenceNodes(reference: Reference | MultiReference): AstNode[];
-interface AstStreamOptions {
-  /**
-   * Optional target range that the nodes in the stream need to intersect
-   */
-  range?: Range;
-}
-/**
- * Create a stream of all AST nodes that are directly contained in the given node. This includes
- * single-valued as well as multi-valued (array) properties.
- */
-declare function streamContents(node: AstNode, options?: AstStreamOptions): Stream<AstNode>;
-/**
- * Create a stream of all AST nodes that are directly and indirectly contained in the given root node.
- * This does not include the root node itself.
- */
-declare function streamAllContents(root: AstNode, options?: AstStreamOptions): TreeStream<AstNode>;
-/**
- * Create a stream of all AST nodes that are directly and indirectly contained in the given root node,
- * including the root node itself.
- */
-declare function streamAst(root: AstNode, options?: AstStreamOptions): TreeStream<AstNode>;
-/**
- * Create a stream of all cross-references that are held by the given AST node. This includes
- * single-valued as well as multi-valued (array) properties.
- */
-declare function streamReferences(node: AstNode): Stream<ReferenceInfo>;
-/**
- * Assigns all mandatory AST properties to the specified node.
- *
- * @param reflection Reflection object used to gather mandatory properties for the node.
- * @param node Specified node is modified in place and properties are directly assigned.
- */
-declare function assignMandatoryProperties(reflection: AstReflection, node: AstNode): void;
-/**
- * Creates a deep copy of the specified AST node.
- * The resulting copy will only contain semantically relevant information, such as the `$type` property and AST properties.
- *
- * @param node The AST node to deeply copy.
- * @param buildReference References are not copied, instead this function is called to rebuild them.
- * @param trace For the sake of tracking copied nodes and their originals a `trace` map can be provided (optional).
- */
-declare function copyAstNode<T extends AstNode = AstNode>(node: T, buildReference: (node: AstNode, property: string, refNode: CstNode | undefined, refText: string, origReference: Reference<AstNode>) => Reference<AstNode>, trace?: Map<AstNode, AstNode>): T;
-/**
- * Recursively makes all properties of an AstNode optional, except for those
- * that start with a dollar sign ($) or are of type boolean or are of type array.
- * If the type is a Reference or an Array, it applies the transformation recursively
- * to the inner type.
- * Otherwise the type is returned as is.
- *
- * @template T - The type to be transformed.
- */
-type DeepPartialAstNode<T> = T extends Reference<infer U extends AstNode> ? Reference<DeepPartialAstNode<U>> : T extends AstNode ? { [K in keyof T as K extends `$${string}` | (T[K] extends (boolean | any[]) ? K : never) ? K : never]: DeepPartialAstNode<T[K]>; } & { [K in keyof T as K extends `$${string}` ? never : T[K] extends (boolean | any[]) ? never : K]?: DeepPartialAstNode<T[K]>; } : T extends Array<infer U> ? Array<DeepPartialAstNode<U>> : T;
-declare namespace cst_utils_d_exports {
-  export { DefaultNameRegexp, RangeComparison, compareRange, findCommentNode, findDeclarationNodeAtOffset, findLeafNodeAtOffset, findLeafNodeBeforeOffset, flattenCst, getDatatypeNode, getInteriorNodes, getNextNode, getPreviousNode, getStartlineNode, inRange, isChildNode, isCommentNode, isValidTokenRange, streamCst, toDocumentSegment, tokenToRange };
-}
-/**
- * Attempts to find the CST node that belongs to the datatype element that contains the given CST node.
- *
- * @param cstNode The CST node for which to find the datatype node.
- * @returns The CST node corresponding to the datatype element, or the undefined if no such element exists.
- */
-declare function getDatatypeNode(cstNode: CstNode): CstNode | undefined;
-/**
- * Create a stream of all CST nodes that are directly and indirectly contained in the given root node,
- * including the root node itself.
- */
-declare function streamCst(node: CstNode): TreeStream<CstNode>;
-/**
- * Create a stream of all leaf nodes that are directly and indirectly contained in the given root node.
- */
-declare function flattenCst(node: CstNode): Stream<LeafCstNode>;
-/**
- * Determines whether the specified cst node is a child of the specified parent node.
- */
-declare function isChildNode(child: CstNode, parent: CstNode): boolean;
-declare function tokenToRange(token: IToken$1): Range;
-/**
- * Checks whether a token has a valid source range.
- *
- * Chevrotain uses negative offsets for virtual tokens such as EOF and tokens
- * inserted during error recovery. Older versions used `NaN` for the same
- * purpose, so both forms need to be rejected here.
- */
-declare function isValidTokenRange(token: Pick<IToken$1, 'startOffset' | 'endOffset'>): boolean;
-declare function toDocumentSegment(node: CstNode): DocumentSegment;
-declare function toDocumentSegment(node?: CstNode): DocumentSegment | undefined;
-declare enum RangeComparison {
-  Before = 0,
-  After = 1,
-  OverlapFront = 2,
-  OverlapBack = 3,
-  Inside = 4,
-  Outside = 5
-}
-declare function compareRange(range: Range, to: Range): RangeComparison;
-declare function inRange(range: Range, to: Range): boolean;
-declare const DefaultNameRegexp: RegExp;
-/**
- * Performs `findLeafNodeAtOffset` with a minor difference: When encountering a character that matches the `nameRegexp` argument,
- * it will instead return the leaf node at the `offset - 1` position.
- *
- * For LSP services, users expect that the declaration of an element is available if the cursor is directly after the element.
- */
-declare function findDeclarationNodeAtOffset(cstNode: CstNode | undefined, offset: number, nameRegexp?: RegExp): LeafCstNode | undefined;
-declare function findCommentNode(cstNode: CstNode | undefined, commentNames: string[]): CstNode | undefined;
-declare function isCommentNode(cstNode: CstNode, commentNames: string[]): boolean;
-/**
- * Finds the leaf CST node at the specified 0-based string offset.
- * Note that the given offset will be within the range of the returned leaf node.
- *
- * If the offset does not point to a CST node (but just white space), this method will return `undefined`.
- *
- * @param node The CST node to search through.
- * @param offset The specified offset.
- * @returns The CST node at the specified offset.
- */
-declare function findLeafNodeAtOffset(node: CstNode, offset: number): LeafCstNode | undefined;
-/**
- * Finds the leaf CST node at the specified 0-based string offset.
- * If no CST node exists at the specified position, it will return the leaf node before it.
- *
- * If there is no leaf node before the specified offset, this method will return `undefined`.
- *
- * @param node The CST node to search through.
- * @param offset The specified offset.
- * @returns The CST node closest to the specified offset.
- */
-declare function findLeafNodeBeforeOffset(node: CstNode, offset: number): LeafCstNode | undefined;
-declare function getPreviousNode(node: CstNode, hidden?: boolean): CstNode | undefined;
-declare function getNextNode(node: CstNode, hidden?: boolean): CstNode | undefined;
-declare function getStartlineNode(node: CstNode): CstNode;
-declare function getInteriorNodes(start: CstNode, end: CstNode): CstNode[];
-declare namespace grammar_utils_d_exports {
-  export { Cardinality, Operator, findAssignment, findNameAssignment, findNodeForKeyword, findNodeForProperty, findNodesForKeyword, findNodesForKeywordInternal, findNodesForProperty, getActionAtElement, getActionType, getAllReachableRules, getAllRulesUsedForCrossReferences, getCrossReferenceTerminal, getEntryRule, getExplicitRuleType, getHiddenRules, getRuleType, getRuleTypeName, getTypeName, isArrayCardinality, isArrayOperator, isCommentTerminal, isDataType, isDataTypeRule, isOptionalCardinality, terminalRegex };
-}
-/**
- * Returns the entry rule of the given grammar, if any. If the grammar file does not contain an entry rule,
- * the result is `undefined`.
- */
-declare function getEntryRule(grammar: Grammar): ParserRule | undefined;
-/**
- * Returns all hidden terminal rules of the given grammar, if any.
- */
-declare function getHiddenRules(grammar: Grammar): AbstractRule[];
-/**
- * Returns all rules that can be reached from the topmost rules of the specified grammar (entry and hidden terminal rules).
- *
- * @param grammar The grammar that contains all rules
- * @param allTerminals Whether or not to include terminals that are referenced only by other terminals
- * @returns A list of referenced parser and terminal rules. If the grammar contains no entry rule,
- *      this function returns all rules of the specified grammar.
- */
-declare function getAllReachableRules(grammar: Grammar, allTerminals: boolean): Set<AbstractRule>;
-/**
- * Returns all parser rules which provide types which are used in the grammar as type in cross-references.
- * @param grammar the grammar to investigate
- * @returns the set of parser rules whose contributed types are used as type in cross-references
- */
-declare function getAllRulesUsedForCrossReferences(grammar: Grammar): Set<ParserRule>;
-/**
- * Determines the grammar expression used to parse a cross-reference (usually a reference to a terminal rule).
- * A cross-reference can declare this expression explicitly in the form `[Type : Terminal]`, but if `Terminal`
- * is omitted, this function attempts to infer it from the name of the referenced `Type` (using `findNameAssignment`).
- *
- * Returns the grammar expression used to parse the given cross-reference, or `undefined` if it is not declared
- * and cannot be inferred.
- */
-declare function getCrossReferenceTerminal(crossRef: CrossReference): AbstractElement | undefined;
-/**
- * Determines whether the given terminal rule represents a comment. This is true if the rule is marked
- * as `hidden` and it does not match white space. This means every hidden token (i.e. excluded from the AST)
- * that contains visible characters is considered a comment.
- */
-declare function isCommentTerminal(terminalRule: TerminalRule): boolean;
-/**
- * Find all CST nodes within the given node that contribute to the specified property.
- *
- * @param node A CST node in which to look for property assignments. If this is undefined, the result is an empty array.
- * @param property A property name of the constructed AST node. If this is undefined, the result is an empty array.
- */
-declare function findNodesForProperty(node: CstNode | undefined, property: string | undefined): CstNode[];
-/**
- * Find a single CST node within the given node that contributes to the specified property.
- *
- * @param node A CST node in which to look for property assignments. If this is undefined, the result is `undefined`.
- * @param property A property name of the constructed AST node. If this is undefined, the result is `undefined`.
- * @param index If no index is specified or the index is less than zero, the first found node is returned. If the
- *        specified index exceeds the number of assignments to the property, the last found node is returned. Otherwise,
- *        the node with the specified index is returned.
- */
-declare function findNodeForProperty(node: CstNode | undefined, property: string | undefined, index?: number): CstNode | undefined;
-/**
- * Find all CST nodes within the given node that correspond to the specified keyword.
- *
- * @param node A CST node in which to look for keywords. If this is undefined, the result is an empty array.
- * @param keyword A keyword as specified in the grammar.
- */
-declare function findNodesForKeyword(node: CstNode | undefined, keyword: string): CstNode[];
-/**
- * Find a single CST node within the given node that corresponds to the specified keyword.
- *
- * @param node A CST node in which to look for keywords. If this is undefined, the result is `undefined`.
- * @param keyword A keyword as specified in the grammar.
- * @param index If no index is specified or the index is less than zero, the first found node is returned. If the
- *        specified index exceeds the number of keyword occurrences, the last found node is returned. Otherwise,
- *        the node with the specified index is returned.
- */
-declare function findNodeForKeyword(node: CstNode | undefined, keyword: string, index?: number): CstNode | undefined;
-declare function findNodesForKeywordInternal(node: CstNode, keyword: string, element: AstNode | undefined): CstNode[];
-/**
- * If the given CST node was parsed in the context of a property assignment, the respective `Assignment` grammar
- * node is returned. If no assignment is found, the result is `undefined`.
- *
- * @param cstNode A CST node for which to find a property assignment.
- */
-declare function findAssignment(cstNode: CstNode): Assignment | undefined;
-/**
- * Find an assignment to the `name` property for the given grammar type. This requires the `type` to be inferred
- * from a parser rule, and that rule must contain an assignment to the `name` property. In all other cases,
- * this function returns `undefined`.
- */
-declare function findNameAssignment(type: AbstractType): Assignment | undefined;
-declare function getActionAtElement(element: AbstractElement): Action | undefined;
-type Cardinality = '?' | '*' | '+' | undefined;
-type Operator = '=' | '+=' | '?=' | undefined;
-declare function isOptionalCardinality(cardinality?: Cardinality, element?: AbstractElement): boolean;
-declare function isArrayCardinality(cardinality?: Cardinality): boolean;
-declare function isArrayOperator(operator?: Operator): boolean;
-/**
- * Determines whether the given parser rule is a _data type rule_, meaning that it has a
- * primitive return type like `number`, `boolean`, etc.
- */
-declare function isDataTypeRule(rule: ParserRule): boolean;
-declare function isDataType(type: Type): boolean;
-declare function getExplicitRuleType(rule: AbstractRule): string | undefined;
-declare function getTypeName(type: AbstractType | Action): string;
-declare function getActionType(action: Action): string | undefined;
-/**
- * This function is used at development time (for code generation and the internal type system) to get the type of the AST node produced by the given rule.
- * For data type rules, the name of the rule is returned,
- * e.g. "INT_value returns number: MY_INT;" returns "INT_value".
- * @param rule the given rule
- * @returns the name of the AST node type of the rule
- */
-declare function getRuleTypeName(rule: AbstractRule): string;
-/**
- * This function is used at runtime to get the actual type of the values produced by the given rule at runtime.
- * For data type rules, the name of the declared return type of the rule is returned (if any),
- * e.g. "INT_value returns number: MY_INT;" returns "number".
- * @param rule the given rule
- * @returns the name of the type of the produced values of the rule at runtime
- */
-declare function getRuleType(rule: AbstractRule): string;
-declare function terminalRegex(terminalRule: TerminalRule): RegExp;
-declare namespace regexp_utils_d_exports {
-  export { NEWLINE_REGEXP, escapeRegExp, getTerminalParts, isMultilineComment, isWhitespace, partialMatches, partialRegExp, whitespaceCharacters };
-}
-/******************************************************************************
- * Copyright 2021 TypeFox GmbH
- * This program and the accompanying materials are made available under the
- * terms of the MIT License, which is available in the project root.
- ******************************************************************************/
-declare const NEWLINE_REGEXP: RegExp;
-declare function getTerminalParts(regexp: RegExp | string): Array<{
-  start: string;
-  end: string;
-}>;
-declare function isMultilineComment(regexp: RegExp | string): boolean;
-/**
- * A set of all characters that are considered whitespace by the '\s' RegExp character class.
- * Taken from [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_expressions/Character_classes).
- */
-declare const whitespaceCharacters: string[];
-declare function isWhitespace(value: RegExp | string): boolean;
-declare function escapeRegExp(value: string): string;
-/**
- * Determines whether the given input has a partial match with the specified regex.
- * @param regex The regex to partially match against
- * @param input The input string
- * @returns Whether any match exists.
- */
-declare function partialMatches(regex: RegExp | string, input: string): boolean;
-/**
- * Builds a partial regex from the input regex. A partial regex is able to match incomplete input strings. E.g.
- * a partial regex constructed from `/ab/` is able to match the string `a` without needing a following `b` character. However it won't match `b` alone.
- * @param regex The input regex to be converted.
- * @returns A partial regex constructed from the input regex.
- */
-declare function partialRegExp(regex: RegExp | string): RegExp;
-declare namespace index_d_exports {
-  export { AbstractAstReflection, AbstractCstNode, AbstractLangiumParser, AbstractParserErrorMessageProvider, AbstractThreadedAsyncParser, AstMetaData, AstNode, AstNodeDescription, AstNodeDescriptionProvider, AstNodeLocator, AstNodeRegionWithAssignments, AstNodeTypesWithCrossReferences, AstNodeWithComment, AstNodeWithTextRegion, AstReflection, AstTypeList, ast_utils_d_exports as AstUtils, AsyncDisposable, AsyncParser, BaseParser, BiMap, BuildOptions, cancellation_d_exports as Cancellation, CommentProvider, CompletionParserResult, CompositeCstNode, CompositeCstNodeImpl, ConfigurationInitializedParams, ConfigurationProvider, ConfigurationSectionUpdate, ConfigurationSectionUpdateListener, ContextCache, CrossReferencesOfAstNodeType, CstNode, CstNodeBuilder, cst_utils_d_exports as CstUtils, DEFAULT_TOKENIZE_OPTIONS, DONE_RESULT, DatatypeSymbol, DeepPartial, DefaultAstNodeDescriptionProvider, DefaultAstNodeLocator, DefaultAsyncParser, DefaultCommentProvider, DefaultConfigurationProvider, DefaultCoreModuleContext, DefaultDocumentBuilder, DefaultDocumentValidator, DefaultHydrator, DefaultIndexManager, DefaultJsonSerializer, DefaultLangiumDocumentFactory, DefaultLangiumDocuments, DefaultLangiumProfiler, DefaultLexer, DefaultLexerErrorMessageProvider, DefaultLinker, DefaultMultiReference, DefaultNameProvider, DefaultReference, DefaultReferenceDescriptionProvider, DefaultReferences, DefaultScopeComputation, DefaultScopeProvider, DefaultServiceRegistry, DefaultSharedCoreModuleContext, DefaultTokenBuilder, DefaultValueConverter, DefaultWorkspaceLock, DefaultWorkspaceManager, Deferred, DehydrateContext, DiagnosticData, DiagnosticInfo, Disposable$1 as Disposable, DisposableCache, DocumentBuildListener, DocumentBuildState, DocumentBuilder, DocumentCache, DocumentPhaseListener, DocumentSegment, DocumentState, DocumentUpdateListener, DocumentValidator, DocumentationProvider, EMPTY_SCOPE, EMPTY_STREAM, Emitter, EmptyFileSystem, EmptyFileSystemProvider, ErrorWithLocation, Event, FileSelector, FileSystemFilter, FileSystemNode, FileSystemProvider, FindReferencesOptions, FlatStream, GenericAstNode, Grammar, ast_d_exports as GrammarAST, GrammarConfig, grammar_utils_d_exports as GrammarUtils, HydrateContext, Hydrator, IParserConfig, IParserDefinitionError, IndentationAwareLexer, IndentationAwareTokenBuilder, IndentationLexingReport, IndentationTokenBuilderOptions, IndexManager, JSDocComment, JSDocDocumentationProvider, JSDocElement, JSDocInline, JSDocLine, JSDocParagraph, JSDocParseOptions, JSDocRenderOptions, JSDocTag, JSDocValue, JsonDeserializeOptions, JsonSerializeOptions, JsonSerializer, LangiumCompletionParser, LangiumCoreServices, LangiumDefaultCoreServices, LangiumDefaultSharedCoreServices, LangiumDocument, LangiumDocumentFactory, LangiumDocuments, LangiumGeneratedCoreServices, LangiumGeneratedSharedCoreServices, LangiumParser, LangiumParserErrorMessageProvider, LangiumProfiler, LangiumSharedCoreServices, LanguageMetaData, LeafCstNode, LeafCstNodeImpl, Lexer$1 as Lexer, LexerResult, LexingDiagnostic, LexingDiagnosticSeverity, LexingMode, LexingReport, Linker, LinkingError, LinkingErrorData, LocalSymbols, MapScope, MaybePromise, MinusOne, Module, MultiCrossReferencesOfAstNodeType, MultiMap, MultiMapScope, MultiReference, MultiReferenceItem, Mutable, NameProvider, NamedAstNode, OperationCancelled, ParseResult, ParserOptions, ParserWorker, PartialLangiumCoreServices, PartialLangiumSharedCoreServices, ProfilingCategory, ProfilingRecord, ProfilingTask, Properties, PropertyMetaData, PropertyType, ReadPriority, Reduction, RefResolving, Reference, ReferenceDescription, ReferenceDescriptionProvider, ReferenceInfo, References, regexp_utils_d_exports as RegExpUtils, ResolvedReference, RootCstNode, RootCstNodeImpl, Scope, ScopeComputation, ScopeOptions, ScopeProvider, ServiceRegistry, SimpleCache, SingleCrossReferencesOfAstNodeType, Stream, StreamImpl, StreamScope, TextDocument, TextDocumentProvider, TokenBuilder, TokenBuilderOptions, TokenizeMode, TokenizeOptions, TreeIterator, TreeStream, TreeStreamImpl, TypeMetaData, URI$1 as URI, UriTrie, UriTrieNode, UriUtils, VALIDATE_EACH_NODE, ValidateSingleNodeOptions, ValidationAcceptor, ValidationCategory, ValidationCheck, ValidationChecks, ValidationOptions, ValidationPreparation, ValidationRegistry, ValidationSeverity, ValueConverter, ValueType, WorkerMessageCallback, WorkerMessagePost, WorkspaceCache, WorkspaceFolder, WorkspaceLock, WorkspaceManager, assertCondition, assertUnreachable, createCompletionParser, createDefaultCoreModule, createDefaultSharedCoreModule, createGrammarConfig, createLangiumParser, createParser, delayNextTick, diagnosticData, eagerLoad, getDiagnosticRange, indentationBuilderDefaultOptions, inject, interruptAndCheck, isAstNode, isAstNodeDescription, isAstNodeWithComment, isCompositeCstNode, isIMultiModeLexerDefinition, isJSDoc, isLeafCstNode, isLinkingError, isMultiReference, isNamed, isOperationCancelled, isReference, isRootCstNode, isTokenTypeArray, isTokenTypeDictionary, loadGrammarFromJson, parseJSDoc, prepareLangiumParser, setInterruptionPeriod, startCancelableOperation, stream, toDiagnosticData, toDiagnosticSeverity };
-}
-//#endregion
-//#region ../../node_modules/.pnpm/vscode-languageserver@10.1.2/node_modules/vscode-languageserver/lib/common/progress.d.ts
 interface WorkDoneProgressReporter {
   begin(title: string, percentage?: number, message?: string, cancellable?: boolean): void;
   report(percentage: number): void;
@@ -14415,22 +11623,16 @@ interface WindowProgress {
 interface ResultProgressReporter<R> {
   report(data: R): void;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/vscode-languageserver@10.1.2/node_modules/vscode-languageserver/lib/common/configuration.d.ts
 interface Configuration {
   getConfiguration(): Promise<any>;
   getConfiguration(section: string): Promise<any>;
   getConfiguration(item: ConfigurationItem): Promise<any>;
   getConfiguration(items: ConfigurationItem[]): Promise<any[]>;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/vscode-languageserver@10.1.2/node_modules/vscode-languageserver/lib/common/workspaceFolder.d.ts
 interface WorkspaceFolders {
   getWorkspaceFolders(): Promise<WorkspaceFolder[] | null>;
   onDidChangeWorkspaceFolders: Event<WorkspaceFoldersChangeEvent>;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/vscode-languageserver@10.1.2/node_modules/vscode-languageserver/lib/common/callHierarchy.d.ts
 /**
  * Shape of the call hierarchy feature
  *
@@ -14443,8 +11645,6 @@ interface CallHierarchy {
     onOutgoingCalls(handler: ServerRequestHandler<CallHierarchyOutgoingCallsParams, CallHierarchyOutgoingCall[] | null, CallHierarchyOutgoingCall[], void>): Disposable;
   };
 }
-//#endregion
-//#region ../../node_modules/.pnpm/vscode-languageserver@10.1.2/node_modules/vscode-languageserver/lib/common/semanticTokens.d.ts
 /**
  * Shape of the semantic token feature
  *
@@ -14479,13 +11679,9 @@ declare class SemanticTokensBuilder$1 {
   canBuildEdits(): boolean;
   buildEdits(): SemanticTokens | SemanticTokensDelta;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/vscode-languageserver@10.1.2/node_modules/vscode-languageserver/lib/common/showDocument.d.ts
 interface ShowDocumentFeatureShape {
   showDocument(params: ShowDocumentParams): Promise<ShowDocumentResult>;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/vscode-languageserver@10.1.2/node_modules/vscode-languageserver/lib/common/fileOperations.d.ts
 /**
  * Shape of the file operations feature
  *
@@ -14499,8 +11695,6 @@ interface FileOperationsFeatureShape {
   onWillRenameFiles(handler: RequestHandler<RenameFilesParams, WorkspaceEdit | null, never>): Disposable;
   onWillDeleteFiles(handler: RequestHandler<DeleteFilesParams, WorkspaceEdit | null, never>): Disposable;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/vscode-languageserver@10.1.2/node_modules/vscode-languageserver/lib/common/linkedEditingRange.d.ts
 /**
  * Shape of the linked editing feature
  *
@@ -14514,8 +11708,6 @@ interface LinkedEditingRangeFeatureShape {
    */
   onLinkedEditingRange(handler: ServerRequestHandler<LinkedEditingRangeParams, LinkedEditingRanges | undefined | null, void, void>): Disposable;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/vscode-languageserver@10.1.2/node_modules/vscode-languageserver/lib/common/typeHierarchy.d.ts
 /**
  * Shape of the type hierarchy feature
  *
@@ -14528,8 +11720,6 @@ interface TypeHierarchyFeatureShape {
     onSubtypes(handler: ServerRequestHandler<TypeHierarchySubtypesParams, TypeHierarchyItem[] | null, TypeHierarchyItem[], void>): Disposable;
   };
 }
-//#endregion
-//#region ../../node_modules/.pnpm/vscode-languageserver@10.1.2/node_modules/vscode-languageserver/lib/common/inlineValue.d.ts
 /**
  * Shape of the inline values feature
  *
@@ -14549,8 +11739,6 @@ interface InlineValueFeatureShape {
     on(handler: ServerRequestHandler<InlineValueParams, InlineValue[] | undefined | null, InlineValue[], void>): Disposable;
   };
 }
-//#endregion
-//#region ../../node_modules/.pnpm/vscode-languageserver@10.1.2/node_modules/vscode-languageserver/lib/common/foldingRange.d.ts
 /**
  * Shape of the folding range feature
  */
@@ -14570,8 +11758,6 @@ interface FoldingRangeFeatureShape {
     on(handler: ServerRequestHandler<FoldingRangeParams, FoldingRange[] | undefined | null, FoldingRange[], void>): Disposable;
   };
 }
-//#endregion
-//#region ../../node_modules/.pnpm/vscode-languageserver@10.1.2/node_modules/vscode-languageserver/lib/common/inlayHint.d.ts
 /**
  * Shape of the inlay hints feature
  *
@@ -14597,8 +11783,6 @@ interface InlayHintFeatureShape {
     resolve(handler: RequestHandler<InlayHint, InlayHint, void>): Disposable;
   };
 }
-//#endregion
-//#region ../../node_modules/.pnpm/vscode-languageserver@10.1.2/node_modules/vscode-languageserver/lib/common/diagnostic.d.ts
 /**
  * Shape of the linked editing feature
  *
@@ -14625,8 +11809,6 @@ interface DiagnosticFeatureShape {
     onWorkspace(handler: ServerRequestHandler<WorkspaceDiagnosticParams, WorkspaceDiagnosticReport, WorkspaceDiagnosticReportPartialResult, DiagnosticServerCancellationData>): Disposable;
   };
 }
-//#endregion
-//#region ../../node_modules/.pnpm/vscode-languageserver@10.1.2/node_modules/vscode-languageserver/lib/common/textDocuments.d.ts
 /**
  * We should use a mapped type to create this from Connection.
  */
@@ -14756,8 +11938,6 @@ declare class TextDocuments$1<T extends {
    */
   listen(connection: TextDocumentConnection$1): Disposable;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/vscode-languageserver@10.1.2/node_modules/vscode-languageserver/lib/common/notebook.d.ts
 /**
  * Shape of the notebooks feature
  *
@@ -14853,8 +12033,6 @@ declare class NotebookDocuments$1<T extends {
   listen(connection: Connection): Disposable;
   private updateCellMap;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/vscode-languageserver@10.1.2/node_modules/vscode-languageserver/lib/common/moniker.d.ts
 /**
  * Shape of the moniker feature
  *
@@ -14865,8 +12043,6 @@ interface MonikerFeatureShape {
     on(handler: ServerRequestHandler<MonikerParams, Moniker[] | null, Moniker[], void>): Disposable;
   };
 }
-//#endregion
-//#region ../../node_modules/.pnpm/vscode-languageserver@10.1.2/node_modules/vscode-languageserver/lib/common/inlineCompletion.d.ts
 /**
  * Shape of the inline completions feature
  *
@@ -14882,8 +12058,6 @@ interface InlineCompletionFeatureShape {
     on(handler: ServerRequestHandler<InlineCompletionParams, InlineCompletionList | InlineCompletionItem[] | undefined | null, InlineCompletionItem[], void>): Disposable;
   };
 }
-//#endregion
-//#region ../../node_modules/.pnpm/vscode-languageserver@10.1.2/node_modules/vscode-languageserver/lib/common/textDocumentContent.d.ts
 /**
  * Shape of the text document content feature
  *
@@ -14895,8 +12069,6 @@ interface TextDocumentContentFeatureShape {
     on(handler: RequestHandler<TextDocumentContentParams, TextDocumentContentResult | null, void>): Disposable;
   };
 }
-//#endregion
-//#region ../../node_modules/.pnpm/vscode-languageserver@10.1.2/node_modules/vscode-languageserver/lib/common/server.d.ts
 interface FeatureBase {
   /**
    * Called to initialize the remote with the given
@@ -15595,8 +12767,6 @@ interface _Connection<PConsole = _, PTracer = _, PTelemetry = _, PClient = _, PW
   dispose(): void;
 }
 interface Connection extends _Connection {}
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/lsp/call-hierarchy-provider.d.ts
 /**
  * Language-specific service for handling call hierarchy requests.
  */
@@ -15605,8 +12775,6 @@ interface CallHierarchyProvider {
   incomingCalls(params: CallHierarchyIncomingCallsParams, cancelToken?: CancellationToken): MaybePromise<CallHierarchyIncomingCall[] | undefined>;
   outgoingCalls(params: CallHierarchyOutgoingCallsParams, cancelToken?: CancellationToken): MaybePromise<CallHierarchyOutgoingCall[] | undefined>;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/lsp/code-action.d.ts
 interface CodeActionProvider {
   /**
    * Handle a code action request.
@@ -15616,13 +12784,9 @@ interface CodeActionProvider {
    */
   getCodeActions(document: LangiumDocument, params: CodeActionParams, cancelToken?: CancellationToken): MaybePromise<Array<Command | CodeAction> | undefined>;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/lsp/code-lens-provider.d.ts
 interface CodeLensProvider {
   provideCodeLens(document: LangiumDocument, params: CodeLensParams, cancelToken?: CancellationToken): MaybePromise<CodeLens[] | undefined>;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/lsp/declaration-provider.d.ts
 /**
  * Language-specific service for handling go to declaration requests
  */
@@ -15634,8 +12798,6 @@ interface DeclarationProvider {
    */
   getDeclaration(document: LangiumDocument, params: DeclarationParams, cancelToken?: CancellationToken): MaybePromise<LocationLink[] | undefined>;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/lsp/definition-provider.d.ts
 /**
  * Language-specific service for handling go to definition requests.
  */
@@ -15653,8 +12815,20 @@ interface DefinitionProvider {
    */
   getDefinition(document: LangiumDocument, params: DefinitionParams, cancelToken?: CancellationToken): MaybePromise<LocationLink[] | undefined>;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/lsp/document-highlight-provider.d.ts
+interface GoToLink {
+  source: CstNode;
+  target: CstNode;
+  targetDocument: LangiumDocument;
+}
+declare class DefaultDefinitionProvider implements DefinitionProvider {
+  protected readonly nameProvider: NameProvider;
+  protected readonly references: References;
+  protected readonly grammarConfig: GrammarConfig;
+  constructor(services: LangiumServices);
+  getDefinition(document: LangiumDocument, params: DefinitionParams, _cancelToken?: CancellationToken): MaybePromise<LocationLink[] | undefined>;
+  protected collectLocationLinks(sourceCstNode: CstNode, _params: DefinitionParams): MaybePromise<LocationLink[] | undefined>;
+  protected findLinks(source: CstNode): GoToLink[];
+}
 /**
  * Language-specific service for handling document highlight requests.
  */
@@ -15682,8 +12856,6 @@ declare class DefaultDocumentHighlightProvider implements DocumentHighlightProvi
    */
   protected createDocumentHighlight(reference: ReferenceDescription): DocumentHighlight;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/lsp/document-link-provider.d.ts
 /**
  * Language-specific service for handling document link requests.
  */
@@ -15696,8 +12868,6 @@ interface DocumentLinkProvider {
    */
   getDocumentLinks(document: LangiumDocument, params: DocumentLinkParams, cancelToken?: CancellationToken): MaybePromise<DocumentLink[]>;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/lsp/node-kind-provider.d.ts
 /**
  * This service consolidates the logic for gathering LSP kind information based on AST nodes or their descriptions.
  */
@@ -15715,8 +12885,6 @@ interface NodeKindProvider {
    */
   getCompletionItemKind(node: AstNode | AstNodeDescription): CompletionItemKind;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/lsp/document-symbol-provider.d.ts
 /**
  * Language-specific service for handling document symbols requests.
  */
@@ -15734,8 +12902,6 @@ interface DocumentSymbolProvider {
    */
   getSymbols(document: LangiumDocument, params: DocumentSymbolParams, cancelToken?: CancellationToken): MaybePromise<DocumentSymbol[]>;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/lsp/document-update-handler.d.ts
 /**
  * Shared service for handling text document changes and watching relevant files.
  */
@@ -15782,14 +12948,34 @@ interface DocumentUpdateHandler {
    */
   onWatchedFilesChange(callback: (params: DidChangeWatchedFilesParams) => void): Disposable;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/lsp/execute-command-handler.d.ts
+declare class DefaultDocumentUpdateHandler implements DocumentUpdateHandler {
+  protected readonly workspaceManager: WorkspaceManager;
+  protected readonly documentBuilder: DocumentBuilder;
+  protected readonly workspaceLock: WorkspaceLock;
+  protected readonly serviceRegistry: ServiceRegistry;
+  protected readonly onWatchedFilesChangeEmitter: Emitter<DidChangeWatchedFilesParams>;
+  constructor(services: LangiumSharedServices);
+  protected registerFileWatcher(services: LangiumSharedServices): void;
+  protected getWatchers(): FileSystemWatcher[];
+  protected fireDocumentUpdate(changed: URI$1[], deleted: URI$1[]): void;
+  didChangeContent(change: TextDocumentChangeEvent<TextDocument>): void;
+  didChangeWatchedFiles(params: DidChangeWatchedFilesParams): void;
+  get onWatchedFilesChange(): Event<DidChangeWatchedFilesParams>;
+}
 interface ExecuteCommandHandler {
   get commands(): string[];
   executeCommand(name: string, args: any[], cancelToken?: CancellationToken): Promise<unknown>;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/lsp/file-operation-handler.d.ts
+type ExecuteCommandFunction = (args: any[], cancelToken: CancellationToken) => MaybePromise<unknown>;
+type ExecuteCommandAcceptor = (name: string, execute: ExecuteCommandFunction) => void;
+declare abstract class AbstractExecuteCommandHandler implements ExecuteCommandHandler {
+  protected registeredCommands: Map<string, ExecuteCommandFunction>;
+  get commands(): string[];
+  constructor();
+  executeCommand(name: string, args: any[], cancelToken?: CancellationToken): Promise<unknown>;
+  protected createCommandAcceptor(): ExecuteCommandAcceptor;
+  abstract registerCommands(acceptor: ExecuteCommandAcceptor): void;
+}
 /**
  * Shared service for handling file changes such as file creation, deletion and renaming.
  * The interface methods are optional, so they are only registered if they are implemented.
@@ -15836,8 +13022,6 @@ interface FileOperationHandler {
    */
   willDeleteFiles?(params: DeleteFilesParams): MaybePromise<WorkspaceEdit | null>;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/lsp/folding-range-provider.d.ts
 /**
  * Language-specific service for handling folding range requests.
  */
@@ -15855,8 +13039,6 @@ interface FoldingRangeProvider {
    */
   getFoldingRanges(document: LangiumDocument, params: FoldingRangeParams, cancelToken?: CancellationToken): MaybePromise<FoldingRange[]>;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/lsp/formatter.d.ts
 /**
  * Language specific service for handling formatting related LSP requests.
  */
@@ -16049,8 +13231,6 @@ interface FormattingMove {
   lines?: number;
 }
 type FormattingCollector = (node: CstNode, mode: 'prepend' | 'append', formatting: FormattingAction) => void;
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/lsp/fuzzy-matcher.d.ts
 /******************************************************************************
  * Copyright 2023 TypeFox GmbH
  * This program and the accompanying materials are made available under the
@@ -16072,8 +13252,6 @@ interface FuzzyMatcher {
    */
   match(query: string, text: string): boolean;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/lsp/hover-provider.d.ts
 /**
  * Language-specific service for handling hover requests.
  */
@@ -16094,8 +13272,6 @@ declare abstract class AstNodeHoverProvider implements HoverProvider {
   protected abstract getAstNodeHoverContent(node: AstNode): MaybePromise<string | undefined>;
   protected getKeywordHoverContent(node: AstNode): MaybePromise<Hover | undefined>;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/lsp/implementation-provider.d.ts
 /**
  * Language-specific service for handling go to implementation requests.
  */
@@ -16105,8 +13281,6 @@ interface ImplementationProvider {
    */
   getImplementation(document: LangiumDocument, params: ImplementationParams, cancelToken?: CancellationToken): MaybePromise<LocationLink[] | undefined>;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/lsp/inlay-hint-provider.d.ts
 /**
  * Provider for the inlay hint LSP type.
  */
@@ -16119,16 +13293,12 @@ interface InlayHintProvider {
    */
   getInlayHints(document: LangiumDocument, params: InlayHintParams, cancelToken?: CancellationToken): MaybePromise<InlayHint[] | undefined>;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/lsp/language-server.d.ts
 interface LanguageServer {
   initialize(params: InitializeParams): Promise<InitializeResult>;
   initialized(params: InitializedParams): void;
   onInitialize(callback: (params: InitializeParams) => void): Disposable;
   onInitialized(callback: (params: InitializedParams) => void): Disposable;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/lsp/references-provider.d.ts
 /**
  * Language-specific service for handling find references requests.
  */
@@ -16146,8 +13316,6 @@ interface ReferencesProvider {
    */
   findReferences(document: LangiumDocument, params: ReferenceParams, cancelToken?: CancellationToken): MaybePromise<Location[]>;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/lsp/rename-provider.d.ts
 /**
  * Language-specific service for handling rename requests and prepare rename requests.
  */
@@ -16177,8 +13345,6 @@ interface RenameProvider {
    */
   prepareRename(document: LangiumDocument, params: TextDocumentPositionParams, cancelToken?: CancellationToken): MaybePromise<Range | undefined>;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/lsp/semantic-token-provider.d.ts
 interface SemanticTokenProvider {
   semanticHighlight(document: LangiumDocument, params: SemanticTokensParams, cancelToken?: CancellationToken): MaybePromise<SemanticTokens>;
   semanticHighlightRange(document: LangiumDocument, params: SemanticTokensRangeParams, cancelToken?: CancellationToken): MaybePromise<SemanticTokens>;
@@ -16279,8 +13445,6 @@ declare abstract class AbstractSemanticTokenProvider implements SemanticTokenPro
   protected highlightKeyword(options: SemanticTokenKeywordOptions): void;
   protected highlightNode(options: SemanticTokenNodeOptions): void;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/lsp/signature-help-provider.d.ts
 /**
  * Language-specific service for handling signature help requests.
  */
@@ -16294,8 +13458,6 @@ interface SignatureHelpProvider {
    */
   get signatureHelpOptions(): SignatureHelpOptions;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/lsp/type-hierarchy-provider.d.ts
 /**
  * Language-specific service for handling type hierarchy requests.
  */
@@ -16304,8 +13466,6 @@ interface TypeHierarchyProvider {
   supertypes(params: TypeHierarchySupertypesParams, cancelToken?: CancellationToken): MaybePromise<TypeHierarchyItem[] | undefined>;
   subtypes(params: TypeHierarchySubtypesParams, cancelToken?: CancellationToken): MaybePromise<TypeHierarchyItem[] | undefined>;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/lsp/type-provider.d.ts
 /**
  * Language-specific service for handling go to type requests.
  */
@@ -16315,8 +13475,6 @@ interface TypeDefinitionProvider {
    */
   getTypeDefinition(document: LangiumDocument, params: TypeDefinitionParams, cancelToken?: CancellationToken): MaybePromise<LocationLink[] | undefined>;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/lsp/workspace-symbol-provider.d.ts
 /**
  * Shared service for handling workspace symbols requests.
  */
@@ -16352,8 +13510,6 @@ declare class DefaultWorkspaceSymbolProvider implements WorkspaceSymbolProvider
   getSymbols(params: WorkspaceSymbolParams, cancelToken?: CancellationToken): Promise<WorkspaceSymbol[]>;
   protected getWorkspaceSymbol(astDescription: AstNodeDescription): WorkspaceSymbol | undefined;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/lsp/normalized-text-documents.d.ts
 type NotebookDocumentChangeEvent = NotebookDocuments$1<{
   uri: DocumentUri;
 }>['onDidChange'] extends Event<infer E> ? E : never;
@@ -16466,8 +13622,6 @@ interface NotebookDocuments<T extends {
    */
   listen(connection: Connection): Disposable;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/lsp/text-document-content-provider.d.ts
 /**
  * Shared service for handling the LSP text document content request.
  * It allows clients to request the content of a text document given its URI.
@@ -16486,8 +13640,6 @@ interface TextDocumentContentProvider {
    */
   provideTextDocumentContent(params: TextDocumentContentParams, cancellationToken: CancellationToken): Promise<TextDocumentContentResult | undefined>;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/lsp/lsp-services.d.ts
 /**
  * Combined Core + LSP services of Langium (total services)
  */
@@ -16544,8 +13696,6 @@ type LangiumSharedLSPServices = {
     readonly NotebookDocuments: NotebookDocuments<TextDocument>;
   };
 };
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/lsp/completion/follow-element-computation.d.ts
 interface NextFeature<T extends AbstractElement = AbstractElement> {
   /**
    * A feature that could appear during completion.
@@ -16560,8 +13710,6 @@ interface NextFeature<T extends AbstractElement = AbstractElement> {
    */
   property?: string;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/langium@4.4.0/node_modules/langium/lib/lsp/completion/completion-provider.d.ts
 type CompletionAcceptor = (context: CompletionContext, value: CompletionValueItem) => void;
 type CompletionValueItem = ({
   label?: string;
@@ -16647,7 +13795,7 @@ declare class DefaultCompletionProvider implements CompletionProvider {
   protected readonly scopeProvider: ScopeProvider;
   protected readonly grammar: Grammar;
   protected readonly nameProvider: NameProvider;
-  protected readonly lexer: Lexer$1;
+  protected readonly lexer: Lexer;
   protected readonly nodeKindProvider: NodeKindProvider;
   protected readonly fuzzyMatcher: FuzzyMatcher;
   protected readonly grammarConfig: GrammarConfig;
@@ -16728,5 +13876,4 @@ declare class DefaultCompletionProvider implements CompletionProvider {
    */
   protected buildCompletionTextEditWithoutInsertReplace(context: CompletionContext, label: string, newText: string): TextEdit | undefined;
 }
-//#endregion
-export { CancellationToken as $, LocalSymbols as A, DefaultScopeProvider as B, Properties as C, Keyword as Ct, DocumentSegment as D, DefaultLangiumDocuments as E, DiagnosticInfo as F, ReferenceDescription as G, MultiMap as H, DefaultScopeComputation as I, cancellation_d_exports as J, DefaultNameProvider as K, DefaultValueConverter as L, DefaultWorkspaceManager as M, DefaultDocumentValidator as N, LangiumDocument as O, ValidationOptions as P, DocumentSymbolParams as Q, ValueType as R, CstNode as S, Range$1 as St, ReferenceInfo as T, URI$1 as Tt, JSDocDocumentationProvider as U, Scope as V, DefaultIndexManager as W, CodeLensParams as X, CodeActionParams as Y, DocumentLinkParams as Z, CodeLensProvider as _, Location as _t, LangiumServices as a, FileSystemNode as at, AstNode as b, TextEdit as bt, AbstractSemanticTokenProvider as c, CodeLens as ct, AbstractFormatter as d, Diagnostic as dt, NotificationType as et, FormattingRegion as f, DocumentHighlight as ft, DefaultDocumentHighlightProvider as g, Hover as gt, DocumentLinkProvider as h, FormattingOptions as ht, NextFeature as i, Disposable$1 as it, BuildOptions as j, LangiumDocumentFactory as k, SemanticTokenAcceptor as l, Command as lt, NodeKindProvider as m, DocumentSymbol as mt, CompletionContext as n, WorkspaceCache as nt, LangiumSharedServices as o, FileSystemProvider as ot, DocumentSymbolProvider as p, DocumentLink as pt, Stream as q, DefaultCompletionProvider as r, AsyncDisposable as rt, DefaultWorkspaceSymbolProvider as s, CodeAction as st, CompletionAcceptor as t, RequestType as tt, AstNodeHoverProvider as u, CompletionItemKind as ut, CodeActionProvider as v, Range as vt, Reference as w, ast_d_exports as wt, AstNodeDescription as x, WorkspaceFolder as xt, index_d_exports as y, SymbolKind as yt, MaybePromise as z };
+export { DefaultIndexManager as $, ReferenceInfo as A, Diagnostic as At, DefaultWorkspaceManager as B, SymbolKind as Bt, TextDocumentChangeEvent as C, FileSystemNode as Ct, CstNode as D, Command as Dt, AstNodeDescription as E, CodeLens as Et, LangiumDocumentFactory as F, Hover as Ft, DefaultScopeComputation as G, TextDocument as Gt, ValidationOptions as H, WorkspaceEdit as Ht, LangiumDocuments as I, Location as It, MaybePromise as J, DefaultValueConverter as K, Keyword as Kt, LocalSymbols as L, LocationLink as Lt, DocumentSegment as M, DocumentLink as Mt, DocumentState as N, DocumentSymbol as Nt, Properties as O, CompletionItemKind as Ot, LangiumDocument as P, FormattingOptions as Pt, JSDocDocumentationProvider as Q, BuildOptions as R, Position as Rt, CodeActionProvider as S, Disposable$1 as St, AstNode as T, CodeAction as Tt, DiagnosticInfo as U, WorkspaceFolder as Ut, DefaultDocumentValidator as V, TextEdit as Vt, ValidationSeverity as W, Range$1 as Wt, Scope as X, DefaultScopeProvider as Y, MultiMap as Z, NodeKindProvider as _, RequestType as _t, LangiumServices as a, CodeLensParams as at, DefaultDefinitionProvider as b, WorkspaceCache as bt, AbstractSemanticTokenProvider as c, DidChangeWatchedFilesParams as ct, AbstractFormatter as d, FileEvent as dt, ReferenceDescription as et, FormattingRegion as f, FileSystemWatcher as ft, DocumentSymbolProvider as g, NotificationType as gt, DefaultDocumentUpdateHandler as h, Disposable as ht, NextFeature as i, CodeActionParams as it, DefaultLangiumDocuments as j, DocumentHighlight as jt, Reference as k, CompletionList as kt, SemanticTokenAcceptor as l, DocumentLinkParams as lt, ExecuteCommandAcceptor as m, Event as mt, CompletionContext as n, DefaultNameProvider as nt, LangiumSharedServices as o, CompletionParams as ot, AbstractExecuteCommandHandler as p, CancellationToken as pt, ValueType as q, URI$1 as qt, DefaultCompletionProvider as r, Stream as rt, DefaultWorkspaceSymbolProvider as s, DefinitionParams as st, CompletionAcceptor as t, AstNodeLocator as tt, AstNodeHoverProvider as u, DocumentSymbolParams as ut, DocumentLinkProvider as v, ContextCache as vt, AbstractAstReflection as w, FileSystemProvider as wt, CodeLensProvider as x, AsyncDisposable as xt, DefaultDocumentHighlightProvider as y, SimpleCache as yt, DefaultDocumentBuilder as z, Range as zt };