likec4 1.59.2 → 1.59.4

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

@@ -1,5 +1,54 @@
-import { i as __name } from "../rolldown-runtime.mjs";
-import { DSLMethodOpts, EmbeddedActionsParser, ILexerErrorMessageProvider, ILexingError, IOrAlt, IParserConfig, IParserErrorMessageProvider, IRecognitionException, IRuleConfig, IToken, TokenType, TokenTypeDictionary, TokenVocabulary } from "chevrotain";
+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/langium@3.5.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 {
+  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@3.5.0/node_modules/langium/lib/languages/grammar-config.d.ts
 interface GrammarConfig {
   /**
@@ -11,6 +60,11 @@ 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/vscode-uri@3.1.0/node_modules/vscode-uri/lib/umd/uri.d.ts
 /**
@@ -155,43 +209,138 @@ interface UriComponents {
   fragment: string;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/langium@3.5.0/node_modules/langium/lib/languages/generated/ast.d.ts
+//#region ../../node_modules/.pnpm/vscode-uri@3.1.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@3.5.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;
+}
+declare namespace ast_d_exports {
+  export { AbstractElement, AbstractRule, AbstractType, Action, Alternatives, ArrayLiteral, ArrayType, Assignment, BooleanLiteral, CharacterRange, Condition, Conjunction, CrossReference, Disjunction, EndOfFile, FeatureName, Grammar, GrammarImport, Group, InferredType, 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, TerminalGroup, TerminalRule, TerminalRuleCall, Type, TypeAttribute, TypeDefinition, UnionType, UnorderedGroup, UntilToken, ValueLiteral, Wildcard, isAbstractElement, isAbstractRule, isAbstractType, isAction, isAlternatives, isArrayLiteral, isArrayType, isAssignment, isBooleanLiteral, isCharacterRange, isCondition, isConjunction, isCrossReference, isDisjunction, isEndOfFile, isFeatureName, isGrammar, isGrammarImport, isGroup, isInferredType, isInterface, isKeyword, isNamedArgument, isNegatedToken, isNegation, isNumberLiteral, isParameter, isParameterReference, isParserRule, isPrimitiveType, isReferenceType, isRegexToken, isReturnType, isRuleCall, isSimpleType, isStringLiteral, isTerminalAlternatives, 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" | "[" | "]" | "bigint" | "boolean" | "current" | "entry" | "extends" | "false" | "fragment" | "grammar" | "hidden" | "import" | "infer" | "infers" | "interface" | "number" | "returns" | "string" | "terminal" | "true" | "type" | "with" | "{" | "|" | "}";
+type LangiumGrammarTokenNames = LangiumGrammarTerminalNames | LangiumGrammarKeywordNames;
 type AbstractRule = ParserRule | TerminalRule;
 declare const AbstractRule = "AbstractRule";
+declare function isAbstractRule(item: unknown): item is AbstractRule;
 type AbstractType = InferredType | Interface | ParserRule | Type;
 declare const AbstractType = "AbstractType";
+declare function isAbstractType(item: unknown): item is AbstractType;
 type Condition = BooleanLiteral | Conjunction | Disjunction | Negation | ParameterReference;
 declare const Condition = "Condition";
+declare function isCondition(item: unknown): item is Condition;
 type FeatureName = 'current' | 'entry' | 'extends' | 'false' | 'fragment' | 'grammar' | 'hidden' | 'import' | 'infer' | 'infers' | 'interface' | 'returns' | 'terminal' | 'true' | 'type' | 'with' | PrimitiveType | string;
+declare function isFeatureName(item: unknown): item is FeatureName;
 type PrimitiveType = 'Date' | 'bigint' | 'boolean' | 'number' | 'string';
+declare function isPrimitiveType(item: unknown): item is PrimitiveType;
 type TypeDefinition = ArrayType | ReferenceType | SimpleType | UnionType;
 declare const TypeDefinition = "TypeDefinition";
+declare function isTypeDefinition(item: unknown): item is TypeDefinition;
 type ValueLiteral = ArrayLiteral | BooleanLiteral | NumberLiteral | StringLiteral;
 declare const ValueLiteral = "ValueLiteral";
+declare function isValueLiteral(item: unknown): item is ValueLiteral;
 interface AbstractElement extends AstNode {
   readonly $type: 'AbstractElement' | 'Action' | 'Alternatives' | 'Assignment' | 'CharacterRange' | 'CrossReference' | 'EndOfFile' | 'Group' | 'Keyword' | 'NegatedToken' | 'RegexToken' | 'RuleCall' | 'TerminalAlternatives' | 'TerminalGroup' | 'TerminalRuleCall' | 'UnorderedGroup' | 'UntilToken' | 'Wildcard';
   cardinality?: '*' | '+' | '?';
   lookahead?: '?!' | '?<!' | '?<=' | '?=';
 }
 declare const AbstractElement = "AbstractElement";
+declare function isAbstractElement(item: unknown): item is AbstractElement;
 interface ArrayLiteral extends AstNode {
   readonly $container: ArrayLiteral | TypeAttribute;
   readonly $type: 'ArrayLiteral';
   elements: Array<ValueLiteral>;
 }
 declare const ArrayLiteral = "ArrayLiteral";
+declare function isArrayLiteral(item: unknown): item is ArrayLiteral;
 interface ArrayType extends AstNode {
   readonly $container: ArrayType | ReferenceType | Type | TypeAttribute | UnionType;
   readonly $type: 'ArrayType';
   elementType: TypeDefinition;
 }
 declare const ArrayType = "ArrayType";
+declare function isArrayType(item: unknown): item is ArrayType;
 interface BooleanLiteral extends AstNode {
   readonly $container: ArrayLiteral | Conjunction | Disjunction | Group | NamedArgument | Negation | TypeAttribute;
   readonly $type: 'BooleanLiteral';
   true: boolean;
 }
 declare const BooleanLiteral = "BooleanLiteral";
+declare function isBooleanLiteral(item: unknown): item is BooleanLiteral;
 interface Conjunction extends AstNode {
   readonly $container: Conjunction | Disjunction | Group | NamedArgument | Negation;
   readonly $type: 'Conjunction';
@@ -199,6 +348,7 @@ interface Conjunction extends AstNode {
   right: Condition;
 }
 declare const Conjunction = "Conjunction";
+declare function isConjunction(item: unknown): item is Conjunction;
 interface Disjunction extends AstNode {
   readonly $container: Conjunction | Disjunction | Group | NamedArgument | Negation;
   readonly $type: 'Disjunction';
@@ -206,6 +356,7 @@ interface Disjunction extends AstNode {
   right: Condition;
 }
 declare const Disjunction = "Disjunction";
+declare function isDisjunction(item: unknown): item is Disjunction;
 interface Grammar extends AstNode {
   readonly $type: 'Grammar';
   definesHiddenTokens: boolean;
@@ -219,18 +370,21 @@ interface Grammar extends AstNode {
   usedGrammars: Array<Reference<Grammar>>;
 }
 declare const Grammar = "Grammar";
+declare function isGrammar(item: unknown): item is Grammar;
 interface GrammarImport extends AstNode {
   readonly $container: Grammar;
   readonly $type: 'GrammarImport';
   path: string;
 }
 declare const GrammarImport = "GrammarImport";
+declare function isGrammarImport(item: unknown): item is GrammarImport;
 interface InferredType extends AstNode {
   readonly $container: Action | ParserRule;
   readonly $type: 'InferredType';
   name: string;
 }
 declare const InferredType = "InferredType";
+declare function isInferredType(item: unknown): item is InferredType;
 interface Interface extends AstNode {
   readonly $container: Grammar;
   readonly $type: 'Interface';
@@ -239,6 +393,7 @@ interface Interface extends AstNode {
   superTypes: Array<Reference<AbstractType>>;
 }
 declare const Interface = "Interface";
+declare function isInterface(item: unknown): item is Interface;
 interface NamedArgument extends AstNode {
   readonly $container: RuleCall;
   readonly $type: 'NamedArgument';
@@ -247,30 +402,35 @@ interface NamedArgument extends AstNode {
   value: Condition;
 }
 declare const NamedArgument = "NamedArgument";
+declare function isNamedArgument(item: unknown): item is NamedArgument;
 interface Negation extends AstNode {
   readonly $container: Conjunction | Disjunction | Group | NamedArgument | Negation;
   readonly $type: 'Negation';
   value: Condition;
 }
 declare const Negation = "Negation";
+declare function isNegation(item: unknown): item is Negation;
 interface NumberLiteral extends AstNode {
   readonly $container: ArrayLiteral | TypeAttribute;
   readonly $type: 'NumberLiteral';
   value: number;
 }
 declare const NumberLiteral = "NumberLiteral";
+declare function isNumberLiteral(item: unknown): item is NumberLiteral;
 interface Parameter extends AstNode {
   readonly $container: ParserRule;
   readonly $type: 'Parameter';
   name: string;
 }
 declare const Parameter = "Parameter";
+declare function isParameter(item: unknown): item is Parameter;
 interface ParameterReference extends AstNode {
   readonly $container: Conjunction | Disjunction | Group | NamedArgument | Negation;
   readonly $type: 'ParameterReference';
   parameter: Reference<Parameter>;
 }
 declare const ParameterReference = "ParameterReference";
+declare function isParameterReference(item: unknown): item is ParameterReference;
 interface ParserRule extends AstNode {
   readonly $container: Grammar;
   readonly $type: 'ParserRule';
@@ -287,18 +447,21 @@ interface ParserRule extends AstNode {
   wildcard: boolean;
 }
 declare const ParserRule = "ParserRule";
+declare function isParserRule(item: unknown): item is ParserRule;
 interface ReferenceType extends AstNode {
   readonly $container: ArrayType | ReferenceType | Type | TypeAttribute | UnionType;
   readonly $type: 'ReferenceType';
   referenceType: TypeDefinition;
 }
 declare const ReferenceType = "ReferenceType";
-interface ReturnType extends AstNode {
+declare function isReferenceType(item: unknown): item is ReferenceType;
+interface ReturnType$1 extends AstNode {
   readonly $container: TerminalRule;
   readonly $type: 'ReturnType';
   name: PrimitiveType | string;
 }
-declare const ReturnType = "ReturnType";
+declare const ReturnType$1 = "ReturnType";
+declare function isReturnType(item: unknown): item is ReturnType$1;
 interface SimpleType extends AstNode {
   readonly $container: ArrayType | ReferenceType | Type | TypeAttribute | UnionType;
   readonly $type: 'SimpleType';
@@ -307,12 +470,14 @@ interface SimpleType extends AstNode {
   typeRef?: Reference<AbstractType>;
 }
 declare const SimpleType = "SimpleType";
+declare function isSimpleType(item: unknown): item is SimpleType;
 interface StringLiteral extends AstNode {
   readonly $container: ArrayLiteral | TypeAttribute;
   readonly $type: 'StringLiteral';
   value: string;
 }
 declare const StringLiteral = "StringLiteral";
+declare function isStringLiteral(item: unknown): item is StringLiteral;
 interface TerminalRule extends AstNode {
   readonly $container: Grammar;
   readonly $type: 'TerminalRule';
@@ -320,9 +485,10 @@ interface TerminalRule extends AstNode {
   fragment: boolean;
   hidden: boolean;
   name: string;
-  type?: ReturnType;
+  type?: ReturnType$1;
 }
 declare const TerminalRule = "TerminalRule";
+declare function isTerminalRule(item: unknown): item is TerminalRule;
 interface Type extends AstNode {
   readonly $container: Grammar;
   readonly $type: 'Type';
@@ -330,6 +496,7 @@ interface Type extends AstNode {
   type: TypeDefinition;
 }
 declare const Type = "Type";
+declare function isType(item: unknown): item is Type;
 interface TypeAttribute extends AstNode {
   readonly $container: Interface;
   readonly $type: 'TypeAttribute';
@@ -339,12 +506,14 @@ interface TypeAttribute extends AstNode {
   type: TypeDefinition;
 }
 declare const TypeAttribute = "TypeAttribute";
+declare function isTypeAttribute(item: unknown): item is TypeAttribute;
 interface UnionType extends AstNode {
   readonly $container: ArrayType | ReferenceType | Type | TypeAttribute | UnionType;
   readonly $type: 'UnionType';
   types: Array<TypeDefinition>;
 }
 declare const UnionType = "UnionType";
+declare function isUnionType(item: unknown): item is UnionType;
 interface Action extends AbstractElement {
   readonly $type: 'Action';
   feature?: FeatureName;
@@ -353,12 +522,28 @@ interface Action extends AbstractElement {
   type?: Reference<AbstractType>;
 }
 declare const Action = "Action";
+declare function isAction(item: unknown): item is Action;
+interface Alternatives extends AbstractElement {
+  readonly $type: 'Alternatives';
+  elements: Array<AbstractElement>;
+}
+declare const Alternatives = "Alternatives";
+declare function isAlternatives(item: unknown): item is Alternatives;
+interface Assignment extends AbstractElement {
+  readonly $type: 'Assignment';
+  feature: FeatureName;
+  operator: '+=' | '=' | '?=';
+  terminal: AbstractElement;
+}
+declare const Assignment = "Assignment";
+declare function isAssignment(item: unknown): item is Assignment;
 interface CharacterRange extends AbstractElement {
   readonly $type: 'CharacterRange';
   left: Keyword;
   right?: Keyword;
 }
 declare const CharacterRange = "CharacterRange";
+declare function isCharacterRange(item: unknown): item is CharacterRange;
 interface CrossReference extends AbstractElement {
   readonly $type: 'CrossReference';
   deprecatedSyntax: boolean;
@@ -366,24 +551,135 @@ interface CrossReference extends AbstractElement {
   type: Reference<AbstractType>;
 }
 declare const CrossReference = "CrossReference";
+declare function isCrossReference(item: unknown): item is CrossReference;
+interface EndOfFile extends AbstractElement {
+  readonly $type: 'EndOfFile';
+}
+declare const EndOfFile = "EndOfFile";
+declare function isEndOfFile(item: unknown): item is EndOfFile;
 interface Group extends AbstractElement {
   readonly $type: 'Group';
   elements: Array<AbstractElement>;
   guardCondition?: Condition;
 }
 declare const Group = "Group";
+declare function isGroup(item: unknown): item is Group;
 interface Keyword extends AbstractElement {
   readonly $container: CharacterRange;
   readonly $type: 'Keyword';
   value: string;
 }
 declare const Keyword = "Keyword";
+declare function isKeyword(item: unknown): item is Keyword;
+interface NegatedToken extends AbstractElement {
+  readonly $type: 'NegatedToken';
+  terminal: AbstractElement;
+}
+declare const NegatedToken = "NegatedToken";
+declare function isNegatedToken(item: unknown): item is NegatedToken;
+interface RegexToken extends AbstractElement {
+  readonly $type: 'RegexToken';
+  regex: string;
+}
+declare const RegexToken = "RegexToken";
+declare function isRegexToken(item: unknown): item is RegexToken;
 interface RuleCall extends AbstractElement {
   readonly $type: 'RuleCall';
   arguments: Array<NamedArgument>;
   rule: Reference<AbstractRule>;
 }
 declare const RuleCall = "RuleCall";
+declare function isRuleCall(item: unknown): item is RuleCall;
+interface TerminalAlternatives extends AbstractElement {
+  readonly $type: 'TerminalAlternatives';
+  elements: Array<AbstractElement>;
+}
+declare const TerminalAlternatives = "TerminalAlternatives";
+declare function isTerminalAlternatives(item: unknown): item is TerminalAlternatives;
+interface TerminalGroup extends AbstractElement {
+  readonly $type: 'TerminalGroup';
+  elements: Array<AbstractElement>;
+}
+declare const TerminalGroup = "TerminalGroup";
+declare function isTerminalGroup(item: unknown): item is TerminalGroup;
+interface TerminalRuleCall extends AbstractElement {
+  readonly $type: 'TerminalRuleCall';
+  rule: Reference<TerminalRule>;
+}
+declare const TerminalRuleCall = "TerminalRuleCall";
+declare function isTerminalRuleCall(item: unknown): item is TerminalRuleCall;
+interface UnorderedGroup extends AbstractElement {
+  readonly $type: 'UnorderedGroup';
+  elements: Array<AbstractElement>;
+}
+declare const UnorderedGroup = "UnorderedGroup";
+declare function isUnorderedGroup(item: unknown): item is UnorderedGroup;
+interface UntilToken extends AbstractElement {
+  readonly $type: 'UntilToken';
+  terminal: AbstractElement;
+}
+declare const UntilToken = "UntilToken";
+declare function isUntilToken(item: unknown): item is UntilToken;
+interface Wildcard extends AbstractElement {
+  readonly $type: 'Wildcard';
+}
+declare const Wildcard = "Wildcard";
+declare function isWildcard(item: unknown): item is Wildcard;
+type LangiumGrammarAstType = {
+  AbstractElement: AbstractElement;
+  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;
+  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;
+  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 {
+  getAllTypes(): string[];
+  protected computeIsSubtype(subtype: string, supertype: string): boolean;
+  getReferenceType(refInfo: ReferenceInfo): string;
+  getTypeMetaData(type: string): TypeMetaData;
+}
+declare const reflection: LangiumGrammarAstReflection;
 //#endregion
 //#region ../../node_modules/.pnpm/vscode-languageserver-textdocument@1.0.11/node_modules/vscode-languageserver-textdocument/lib/esm/main.d.ts
 /**
@@ -3376,6 +3672,7 @@ interface FileSystemNode {
   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.
  */
@@ -3391,6 +3688,13 @@ interface FileSystemProvider {
    */
   readDirectory(uri: URI$1): Promise<FileSystemNode[]>;
 }
+declare class EmptyFileSystemProvider implements FileSystemProvider {
+  readFile(): Promise<string>;
+  readDirectory(): Promise<FileSystemNode[]>;
+}
+declare const EmptyFileSystem: {
+  fileSystemProvider: () => EmptyFileSystemProvider;
+};
 //#endregion
 //#region ../../node_modules/.pnpm/langium@3.5.0/node_modules/langium/lib/utils/stream.d.ts
 /******************************************************************************
@@ -3613,6 +3917,114 @@ 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@3.5.0/node_modules/langium/lib/parser/token-builder.d.ts
 interface TokenBuilderOptions {
@@ -3638,8 +4050,29 @@ 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@3.5.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.
@@ -3659,10 +4092,33 @@ type TokenizeMode = 'full' | 'partial';
 interface TokenizeOptions {
   mode?: TokenizeMode;
 }
-interface Lexer {
+declare const DEFAULT_TOKENIZE_OPTIONS: TokenizeOptions;
+interface Lexer$1 {
   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@3.5.0/node_modules/langium/lib/parser/langium-parser.d.ts
 type ParseResult<T = AstNode> = {
@@ -3671,6 +4127,7 @@ type ParseResult<T = AstNode> = {
   lexerErrors: ILexingError[];
   lexerReport?: LexingReport;
 };
+declare const DatatypeSymbol: unique symbol;
 type RuleResult = (args: Args) => any;
 type Args = Record<string, boolean>;
 type RuleImpl = (args: Args) => any;
@@ -3737,7 +4194,7 @@ interface BaseParser {
   getRuleStack(): number[];
 }
 declare abstract class AbstractLangiumParser implements BaseParser {
-  protected readonly lexer: Lexer;
+  protected readonly lexer: Lexer$1;
   protected readonly wrapper: ChevrotainWrapper;
   protected _unorderedGroups: Map<string, boolean[]>;
   protected allRules: Map<string, RuleResult>;
@@ -3798,6 +4255,44 @@ 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[];
@@ -3866,6 +4361,25 @@ 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 singleton?: LangiumCoreServices;
+  protected readonly languageIdMap: Map<string, LangiumCoreServices>;
+  protected readonly fileExtensionMap: Map<string, LangiumCoreServices>;
+  protected readonly fileNameMap: Map<string, LangiumCoreServices>;
+  /**
+   * @deprecated 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@3.5.0/node_modules/langium/lib/utils/collections.d.ts
 /**
@@ -3939,6 +4453,18 @@ 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/vscode-jsonrpc@8.2.0/node_modules/vscode-jsonrpc/lib/common/disposable.d.ts
 interface Disposable$1 {
@@ -3968,6 +4494,28 @@ interface Event<T> {
 declare namespace Event {
   const None: Event<any>;
 }
+interface EmitterOptions {
+  onFirstListenerAdd?: Function;
+  onLastListenerRemove?: Function;
+}
+declare class Emitter<T> {
+  private _options?;
+  private static _noop;
+  private _event;
+  private _callbacks;
+  constructor(_options?: EmitterOptions | undefined);
+  /**
+   * For the public to allow to subscribe
+   * to events from this Emitter
+   */
+  get event(): Event<T>;
+  /**
+   * To be kept private to fire an event to
+   * subscribers
+   */
+  fire(event: T): any;
+  dispose(): void;
+}
 //#endregion
 //#region ../../node_modules/.pnpm/vscode-jsonrpc@8.2.0/node_modules/vscode-jsonrpc/lib/common/cancellation.d.ts
 /**
@@ -3990,6 +4538,19 @@ declare namespace CancellationToken {
   const Cancelled: CancellationToken;
   function is(value: any): value is CancellationToken;
 }
+interface AbstractCancellationTokenSource extends Disposable$1 {
+  token: CancellationToken;
+  cancel(): void;
+}
+declare class CancellationTokenSource implements AbstractCancellationTokenSource {
+  private _token;
+  get token(): CancellationToken;
+  cancel(): void;
+  dispose(): void;
+}
+declare namespace cancellation_d_exports {
+  export { AbstractCancellationTokenSource, CancellationToken, CancellationTokenSource };
+}
 //#endregion
 //#region ../../node_modules/.pnpm/langium@3.5.0/node_modules/langium/lib/workspace/documents.d.ts
 /**
@@ -4117,6 +4678,38 @@ 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>>;
+  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 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.
  */
@@ -4190,8 +4783,9 @@ declare class DefaultLangiumDocuments implements LangiumDocuments {
   invalidateDocument(uri: URI$1): LangiumDocument | undefined;
   deleteDocument(uri: URI$1): LangiumDocument | undefined;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/langium@3.5.0/node_modules/langium/lib/syntax-tree.d.ts
+declare namespace syntax_tree_d_exports {
+  export { AbstractAstReflection, AstNode, AstNodeDescription, AstNodeTypesWithCrossReferences, AstReflection, AstTypeList, CompositeCstNode, CrossReferencesOfAstNodeType, CstNode, GenericAstNode, LeafCstNode, LinkingError, Mutable, Properties, PropertyType, Reference, ReferenceInfo, ResolvedReference, RootCstNode, TypeMetaData, TypeProperty, isAstNode, isAstNodeDescription, isCompositeCstNode, isLeafCstNode, isLinkingError, isReference, isRootCstNode };
+}
 /**
  * A node in the Abstract Syntax Tree (AST).
  */
@@ -4209,6 +4803,10 @@ 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.
@@ -4233,6 +4831,10 @@ interface Reference<T extends AstNode = AstNode> {
   /** The node description for the AstNode returned by `ref`  */
   readonly $nodeDescription?: AstNodeDescription;
 }
+declare function isReference(obj: unknown): obj is Reference;
+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.
  */
@@ -4256,6 +4858,7 @@ 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.
@@ -4273,6 +4876,7 @@ interface LinkingError extends ReferenceInfo {
   message: string;
   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.
@@ -4285,6 +4889,21 @@ interface AstReflection {
   isInstance(node: unknown, type: string): boolean;
   isSubtype(subtype: string, supertype: string): boolean;
 }
+/**
+ * An abstract implementation of the {@link AstReflection} interface.
+ * Serves to cache subtype computation results to improve performance throughout different parts of Langium.
+ */
+declare abstract class AbstractAstReflection implements AstReflection {
+  protected subtypes: Record<string, Record<string, boolean | undefined>>;
+  protected allSubtypes: Record<string, string[] | undefined>;
+  abstract getAllTypes(): string[];
+  abstract getReferenceType(refInfo: ReferenceInfo): string;
+  abstract getTypeMetaData(type: string): TypeMetaData;
+  protected abstract computeIsSubtype(subtype: string, supertype: string): boolean;
+  isInstance(node: unknown, type: string): boolean;
+  isSubtype(subtype: string, supertype: string): boolean;
+  getAllSubTypes(type: string): string[];
+}
 /**
  * Represents runtime meta data about a meta model type.
  */
@@ -4339,9 +4958,46 @@ interface CompositeCstNode extends CstNode {
   /** @deprecated use `content` instead. */
   readonly children: 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];
+/**
+ * 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> = ExtractKeysOfValueType<N, Reference | Reference[]>;
+/**
+ * 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@3.5.0/node_modules/langium/lib/documentation/comment-provider.d.ts
 /**
@@ -4355,6 +5011,11 @@ 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@3.5.0/node_modules/langium/lib/utils/disposable.d.ts
 /******************************************************************************
@@ -4410,6 +5071,25 @@ 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.
@@ -4427,6 +5107,10 @@ declare class WorkspaceCache<K, V> extends SimpleCache<K, V> {
 }
 //#endregion
 //#region ../../node_modules/.pnpm/langium@3.5.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`.
  */
@@ -4471,6 +5155,13 @@ 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@3.5.0/node_modules/langium/lib/workspace/ast-descriptions.d.ts
 /**
@@ -4489,6 +5180,12 @@ 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.
  */
@@ -4522,6 +5219,12 @@ 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 createDescription(refInfo: ReferenceInfo): ReferenceDescription | undefined;
+}
 //#endregion
 //#region ../../node_modules/.pnpm/langium@3.5.0/node_modules/langium/lib/workspace/index-manager.d.ts
 /**
@@ -4611,6 +5314,12 @@ declare class DefaultIndexManager implements IndexManager {
 }
 //#endregion
 //#region ../../node_modules/.pnpm/langium@3.5.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 {
   /**
@@ -4640,6 +5349,20 @@ interface JSDocTag extends JSDocValue {
   readonly content: JSDocParagraph;
   readonly inline: boolean;
 }
+interface JSDocParseOptions {
+  /**
+   * 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`.
@@ -4660,6 +5383,22 @@ 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@3.5.0/node_modules/langium/lib/documentation/documentation-provider.d.ts
 /**
@@ -4728,6 +5467,28 @@ interface Scope {
 interface ScopeOptions {
   caseInsensitive?: 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;
+  constructor(elements: Stream<AstNodeDescription>, outerScope?: Scope, options?: ScopeOptions);
+  getAllElements(): Stream<AstNodeDescription>;
+  getElement(name: string): AstNodeDescription | undefined;
+}
+declare class MapScope implements Scope {
+  readonly elements: Map<string, AstNodeDescription>;
+  readonly outerScope?: Scope;
+  readonly caseInsensitive: boolean;
+  constructor(elements: Iterable<AstNodeDescription>, outerScope?: Scope, options?: ScopeOptions);
+  getElement(name: string): AstNodeDescription | undefined;
+  getAllElements(): Stream<AstNodeDescription>;
+}
+declare const EMPTY_SCOPE: Scope;
 //#endregion
 //#region ../../node_modules/.pnpm/langium@3.5.0/node_modules/langium/lib/references/scope-provider.d.ts
 /**
@@ -4812,6 +5573,25 @@ interface Linker {
    */
   buildReference(node: AstNode, property: string, refNode: CstNode | undefined, refText: string): Reference;
 }
+declare class DefaultLinker implements Linker {
+  protected readonly reflection: AstReflection;
+  protected readonly scopeProvider: ScopeProvider;
+  protected readonly astNodeLocator: AstNodeLocator;
+  protected readonly langiumDocuments: () => LangiumDocuments;
+  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;
+  buildReference(node: AstNode, property: string, refNode: CstNode | undefined, refText: string): Reference;
+  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@3.5.0/node_modules/langium/lib/serializer/hydrator.d.ts
 /**
@@ -4828,9 +5608,79 @@ interface Hydrator {
    */
   hydrate<T extends AstNode = AstNode>(result: ParseResult<object>): ParseResult<T>;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/langium@3.5.0/node_modules/langium/lib/utils/promise-utils.d.ts
-type MaybePromise<T> = T | Promise<T>;
+interface DehydrateContext {
+  astNodes: Map<AstNode, any>;
+  cstNodes: Map<CstNode, any>;
+}
+interface HydrateContext {
+  astNodes: Map<any, AstNode>;
+  cstNodes: Map<any, 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>;
+  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@3.5.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.
@@ -4861,6 +5711,55 @@ 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@3.5.0/node_modules/langium/lib/parser/value-converter.d.ts
 /**
@@ -4927,6 +5826,16 @@ interface FindReferencesOptions {
    */
   includeDeclaration?: boolean;
 }
+declare class DefaultReferences implements References {
+  protected readonly nameProvider: NameProvider;
+  protected readonly index: IndexManager;
+  protected readonly nodeLocator: AstNodeLocator;
+  constructor(services: LangiumCoreServices);
+  findDeclaration(sourceCstNode: CstNode): AstNode | undefined;
+  findDeclarationNode(sourceCstNode: CstNode): CstNode | undefined;
+  findReferences(targetNode: AstNode, options: FindReferencesOptions): Stream<ReferenceDescription>;
+  protected getReferenceToSelf(targetNode: AstNode): ReferenceDescription | undefined;
+}
 //#endregion
 //#region ../../node_modules/.pnpm/langium@3.5.0/node_modules/langium/lib/references/scope-computation.d.ts
 /**
@@ -5027,6 +5936,37 @@ 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.
  */
@@ -5042,6 +5982,35 @@ 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;
+  /** 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 | undefined;
+  protected getRefNode(root: AstNode, uri: string, uriConverter?: (uri: string) => URI$1): AstNode | string;
+}
 //#endregion
 //#region ../../node_modules/.pnpm/langium@3.5.0/node_modules/langium/lib/validation/validation-registry.d.ts
 type DiagnosticInfo<N extends AstNode, P extends string = Properties<N>> = {
@@ -5066,6 +6035,21 @@ 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>;
@@ -5226,6 +6210,15 @@ 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";
@@ -5234,6 +6227,11 @@ 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/vscode-jsonrpc@8.2.0/node_modules/vscode-jsonrpc/lib/common/messages.d.ts
 interface ResponseErrorLiteral<D = void> {
@@ -9723,6 +10721,37 @@ 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 settings: Record<string, Record<string, any>>;
+  protected workspaceConfig: boolean;
+  protected onConfigurationSectionUpdateEmitter: Emitter<ConfigurationSectionUpdate>;
+  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@3.5.0/node_modules/langium/lib/workspace/document-builder.d.ts
 interface BuildOptions {
@@ -9741,6 +10770,16 @@ interface BuildOptions {
    */
   validation?: boolean | ValidationOptions;
 }
+interface DocumentBuildState {
+  /** Whether a document has completed its last build process. */
+  completed: boolean;
+  /** The options used for the last build process. */
+  options: BuildOptions;
+  /** Additional information about the last build result. */
+  result?: {
+    validationChecks?: ValidationCategory[];
+  };
+}
 /**
  * Shared-service for building and updating `LangiumDocument`s.
  */
@@ -9808,6 +10847,91 @@ interface DocumentBuilder {
 type DocumentUpdateListener = (changed: URI$1[], deleted: URI$1[]) => void | Promise<void>;
 type DocumentBuildListener = (built: LangiumDocument[], cancelToken: CancellationToken) => void | Promise<void>;
 type DocumentPhaseListener = (built: LangiumDocument, cancelToken: CancellationToken) => void | Promise<void>;
+declare class DefaultDocumentBuilder implements DocumentBuilder {
+  updateBuildOptions: BuildOptions;
+  protected readonly langiumDocuments: LangiumDocuments;
+  protected readonly langiumDocumentFactory: LangiumDocumentFactory;
+  protected readonly textDocuments: TextDocumentProvider | undefined;
+  protected readonly indexManager: IndexManager;
+  protected readonly serviceRegistry: ServiceRegistry;
+  protected readonly updateListeners: DocumentUpdateListener[];
+  protected readonly buildPhaseListeners: MultiMap<DocumentState, DocumentBuildListener>;
+  protected readonly documentPhaseListeners: MultiMap<DocumentState, DocumentPhaseListener>;
+  protected readonly buildState: Map<string, DocumentBuildState>;
+  protected readonly documentBuildWaiters: Map<string, Deferred<void>>;
+  protected currentState: DocumentState;
+  constructor(services: LangiumSharedCoreServices);
+  build<T extends AstNode>(documents: Array<LangiumDocument<T>>, options?: BuildOptions, cancelToken?: CancellationToken): Promise<void>;
+  update(changed: URI$1[], deleted: URI$1[], cancelToken?: CancellationToken): Promise<void>;
+  protected emitUpdate(changed: URI$1[], deleted: URI$1[]): Promise<void>;
+  /**
+   * Sort the given documents by priority. By default, documents with an open text document are prioritized.
+   * This is useful to ensure that visible documents show their diagnostics before all other documents.
+   *
+   * This improves the responsiveness in large workspaces as users usually don't care about diagnostics
+   * in files that are currently not opened in the editor.
+   */
+  protected sortDocuments(documents: LangiumDocument[]): LangiumDocument[];
+  private hasTextDocument;
+  /**
+   * Check whether the given document should be relinked after changes were found in the given URIs.
+   */
+  protected shouldRelink(document: LangiumDocument, changedUris: Set<string>): boolean;
+  onUpdate(callback: DocumentUpdateListener): Disposable;
+  /**
+   * Build the given documents by stepping through all build phases. If a document's state indicates
+   * that a certain build phase is already done, the phase is skipped for that document.
+   *
+   * @param documents The documents to build.
+   * @param options the {@link BuildOptions} to use.
+   * @param cancelToken A cancellation token that can be used to cancel the build.
+   * @returns A promise that resolves when the build is done.
+   */
+  protected buildDocuments(documents: LangiumDocument[], options: BuildOptions, cancelToken: CancellationToken): Promise<void>;
+  /**
+   * Runs prior to beginning the build process to update the {@link DocumentBuildState} for each document
+   *
+   * @param documents collection of documents to be built
+   * @param options the {@link BuildOptions} to use
+   */
+  protected prepareBuild(documents: LangiumDocument[], options: BuildOptions): void;
+  /**
+   * Runs a cancelable operation on a set of documents to bring them to a specified {@link DocumentState}.
+   *
+   * @param documents The array of documents to process.
+   * @param targetState The target {@link DocumentState} to bring the documents to.
+   * @param cancelToken A token that can be used to cancel the operation.
+   * @param callback A function to be called for each document.
+   * @returns A promise that resolves when all documents have been processed or the operation is canceled.
+   * @throws Will throw `OperationCancelled` if the operation is canceled via a `CancellationToken`.
+   */
+  protected runCancelable(documents: LangiumDocument[], targetState: DocumentState, cancelToken: CancellationToken, callback: (document: LangiumDocument) => MaybePromise<unknown>): Promise<void>;
+  onBuildPhase(targetState: DocumentState, callback: DocumentBuildListener): Disposable;
+  onDocumentPhase(targetState: DocumentState, callback: DocumentPhaseListener): Disposable;
+  waitUntil(state: DocumentState, cancelToken?: CancellationToken): Promise<void>;
+  waitUntil(state: DocumentState, uri?: URI$1, cancelToken?: CancellationToken): Promise<URI$1 | undefined>;
+  protected notifyDocumentPhase(document: LangiumDocument, state: DocumentState, cancelToken: CancellationToken): Promise<void>;
+  protected notifyBuildPhase(documents: LangiumDocument[], state: DocumentState, cancelToken: CancellationToken): Promise<void>;
+  /**
+   * Determine whether the given document should be linked during a build. The default
+   * implementation checks the `eagerLinking` property of the build options. If it's set to `true`
+   * or `undefined`, the document is included in the linking phase. This also affects the
+   * references indexing phase, which depends on eager linking.
+   */
+  protected shouldLink(document: LangiumDocument): boolean;
+  /**
+   * Determine whether the given document should be validated during a build. The default
+   * implementation checks the `validation` property of the build options. If it's set to `true`
+   * or a `ValidationOptions` object, the document is included in the validation phase.
+   */
+  protected shouldValidate(document: LangiumDocument): boolean;
+  /**
+   * Run validation checks on the given document and store the resulting diagnostics in the document.
+   * If the document already contains diagnostics, the new ones are added to the list.
+   */
+  protected validate(document: LangiumDocument, cancelToken: CancellationToken): Promise<void>;
+  protected getBuildOptions(document: LangiumDocument): BuildOptions;
+}
 //#endregion
 //#region ../../node_modules/.pnpm/langium@3.5.0/node_modules/langium/lib/workspace/workspace-lock.d.ts
 /**
@@ -9837,6 +10961,17 @@ interface WorkspaceLock {
    */
   cancelWrite(): void;
 }
+declare class DefaultWorkspaceLock implements WorkspaceLock {
+  private previousTokenSource;
+  private writeQueue;
+  private readQueue;
+  private done;
+  write(action: (token: CancellationToken) => MaybePromise<void>): Promise<void>;
+  read<T>(action: () => MaybePromise<T>): Promise<T>;
+  private enqueue;
+  private performNextOperation;
+  cancelWrite(): void;
+}
 //#endregion
 //#region ../../node_modules/.pnpm/langium@3.5.0/node_modules/langium/lib/workspace/workspace-manager.d.ts
 /**
@@ -9955,7 +11090,7 @@ type LangiumDefaultCoreServices = {
     readonly LexerErrorMessageProvider: ILexerErrorMessageProvider;
     readonly CompletionParser: LangiumCompletionParser;
     readonly TokenBuilder: TokenBuilder;
-    readonly Lexer: Lexer;
+    readonly Lexer: Lexer$1;
   };
   readonly documentation: {
     readonly CommentProvider: CommentProvider;
@@ -10017,6 +11152,632 @@ 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@3.5.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@3.5.0/node_modules/langium/lib/parser/completion-parser-builder.d.ts
+declare function createCompletionParser(services: LangiumCoreServices): LangiumCompletionParser;
+//#endregion
+//#region ../../node_modules/.pnpm/langium@3.5.0/node_modules/langium/lib/parser/cst-node-builder.d.ts
+declare class CstNodeBuilder {
+  private rootNode;
+  private nodeStack;
+  get current(): CompositeCstNodeImpl;
+  buildRootNode(input: string): RootCstNode;
+  buildCompositeNode(feature: AbstractElement): CompositeCstNode;
+  buildLeafNode(token: IToken, feature?: AbstractElement): LeafCstNode;
+  removeNode(node: CstNode): void;
+  addHiddenNodes(tokens: IToken[]): void;
+  construct(item: {
+    $type: string | symbol | undefined;
+    $cstNode: CstNode;
+  }): void;
+}
+declare abstract class AbstractCstNode implements CstNode {
+  abstract get offset(): number;
+  abstract get length(): number;
+  abstract get end(): number;
+  abstract get range(): Range;
+  container?: CompositeCstNode;
+  grammarSource?: AbstractElement;
+  root: RootCstNode;
+  private _astNode?;
+  /** @deprecated use `container` instead. */
+  get parent(): CompositeCstNode | undefined;
+  /** @deprecated use `grammarSource` instead. */
+  get feature(): AbstractElement | undefined;
+  get hidden(): boolean;
+  get astNode(): AstNode;
+  set astNode(value: AstNode | undefined);
+  /** @deprecated use `astNode` instead. */
+  get element(): AstNode;
+  get text(): string;
+}
+declare class LeafCstNodeImpl extends AbstractCstNode implements LeafCstNode {
+  get offset(): number;
+  get length(): number;
+  get end(): number;
+  get hidden(): boolean;
+  get tokenType(): TokenType;
+  get range(): Range;
+  private _hidden;
+  private _offset;
+  private _length;
+  private _range;
+  private _tokenType;
+  constructor(offset: number, length: number, range: Range, tokenType: TokenType, hidden?: boolean);
+}
+declare class CompositeCstNodeImpl extends AbstractCstNode implements CompositeCstNode {
+  readonly content: CstNode[];
+  private _rangeCache?;
+  /** @deprecated use `content` instead. */
+  get children(): CstNode[];
+  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@3.5.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@3.5.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@3.5.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@3.5.0/node_modules/langium/lib/utils/errors.d.ts
+declare class ErrorWithLocation extends Error {
+  constructor(node: CstNode | undefined, message: string);
+}
+declare function assertUnreachable(_: never): never;
+//#endregion
+//#region ../../node_modules/.pnpm/langium@3.5.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, findLocalReferences, findRootNode, getContainerOfType, getDocument, 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): 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;
+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>;
+/**
+ * Returns a Stream of references to the target node from the AstNode tree
+ *
+ * @param targetNode AstNode we are looking for
+ * @param lookup AstNode where we search for references. If not provided, the root node of the document is used as the default value
+ */
+declare function findLocalReferences(targetNode: AstNode, lookup?: AstNode): Stream<Reference>;
+/**
+ * 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.
+ *
+ * References are copied without resolved cross reference. The specified function is used to rebuild them.
+ */
+declare function copyAstNode<T extends AstNode = AstNode>(node: T, buildReference: (node: AstNode, property: string, refNode: CstNode | undefined, refText: string) => Reference<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, getInteriorNodes, getNextNode, getPreviousNode, getStartlineNode, inRange, isChildNode, isCommentNode, streamCst, toDocumentSegment, tokenToRange };
+}
+/**
+ * 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;
+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): TerminalRule[];
+/**
+ * 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: ParserRule): 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, 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, DefaultLexer, DefaultLexerErrorMessageProvider, DefaultLinker, DefaultNameProvider, DefaultReferenceDescriptionProvider, DefaultReferences, DefaultScopeComputation, DefaultScopeProvider, DefaultServiceRegistry, DefaultSharedCoreModuleContext, DefaultTokenBuilder, DefaultValueConverter, DefaultWorkspaceLock, DefaultWorkspaceManager, Deferred, DehydrateContext, DiagnosticData, DiagnosticInfo, Disposable, DisposableCache, DocumentBuildListener, DocumentBuildState, DocumentBuilder, DocumentCache, DocumentPhaseListener, DocumentSegment, DocumentState, DocumentUpdateListener, DocumentValidator, DocumentationProvider, EMPTY_SCOPE, EMPTY_STREAM, Emitter, EmitterOptions, 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, LangiumSharedCoreServices, LanguageMetaData, LeafCstNode, LeafCstNodeImpl, Lexer$1 as Lexer, LexerResult, LexingDiagnostic, LexingDiagnosticSeverity, LexingMode, LexingReport, Linker, LinkingError, LinkingErrorData, MapScope, MaybePromise, MinusOne, Module, MultiMap, Mutable, NameProvider, NamedAstNode, OperationCancelled, ParseResult, ParserOptions, ParserWorker, PartialLangiumCoreServices, PartialLangiumSharedCoreServices, PrecomputedScopes, Properties, PropertyType, Reduction, Reference, ReferenceDescription, ReferenceDescriptionProvider, ReferenceInfo, References, regexp_utils_d_exports as RegExpUtils, ResolvedReference, RootCstNode, RootCstNodeImpl, Scope, ScopeComputation, ScopeOptions, ScopeProvider, ServiceRegistry, SimpleCache, Stream, StreamImpl, StreamScope, TextDocument, TextDocumentProvider, TokenBuilder, TokenBuilderOptions, TokenizeMode, TokenizeOptions, TreeIterator, TreeStream, TreeStreamImpl, TypeMetaData, TypeProperty, URI$1 as URI, UriUtils, ValidationAcceptor, ValidationCategory, ValidationCheck, ValidationChecks, ValidationOptions, ValidationPreparation, ValidationRegistry, ValidationSeverity, ValueConverter, ValueType, WorkerMessageCallback, WorkerMessagePost, WorkspaceCache, WorkspaceFolder, WorkspaceLock, WorkspaceManager, assertUnreachable, createCompletionParser, createDefaultCoreModule, createDefaultSharedCoreModule, createGrammarConfig, createLangiumParser, createParser, delayNextTick, diagnosticData, eagerLoad, getDiagnosticRange, indentationBuilderDefaultOptions, inject, interruptAndCheck, isAstNode, isAstNodeDescription, isAstNodeWithComment, isCompositeCstNode, isIMultiModeLexerDefinition, isJSDoc, isLeafCstNode, isLinkingError, isNamed, isOperationCancelled, isReference, isRootCstNode, isTokenTypeArray, isTokenTypeDictionary, loadGrammarFromJson, parseJSDoc, prepareLangiumParser, setInterruptionPeriod, startCancelableOperation, stream, toDiagnosticData, toDiagnosticSeverity };
+}
 //#endregion
 //#region ../../node_modules/.pnpm/vscode-languageserver@9.0.1/node_modules/vscode-languageserver/lib/common/progress.d.ts
 interface WorkDoneProgressReporter {
@@ -12058,7 +13819,7 @@ declare class DefaultCompletionProvider implements CompletionProvider {
   protected readonly scopeProvider: ScopeProvider;
   protected readonly grammar: Grammar;
   protected readonly nameProvider: NameProvider;
-  protected readonly lexer: Lexer;
+  protected readonly lexer: Lexer$1;
   protected readonly nodeKindProvider: NodeKindProvider;
   protected readonly fuzzyMatcher: FuzzyMatcher;
   protected readonly grammarConfig: GrammarConfig;
@@ -12123,4 +13884,4 @@ declare class DefaultCompletionProvider implements CompletionProvider {
   protected buildCompletionTextEdit(context: CompletionContext, label: string, newText: string): TextEdit | undefined;
 }
 //#endregion
-export { Stream as $, DefaultScopeComputation as A, WorkspaceCache as B, DocumentLinkParams as C, DefaultDocumentValidator as D, RequestType as E, Scope as F, CstNode as G, Disposable as H, JSDocDocumentationProvider as I, DefaultLangiumDocuments as J, Reference as K, DefaultIndexManager as L, ValueType as M, MaybePromise as N, ValidationOptions as O, DefaultScopeProvider as P, CancellationToken as Q, ReferenceDescription as R, CodeLensParams as S, NotificationType as T, AstNode as U, AsyncDisposable as V, AstNodeDescription as W, LangiumDocumentFactory as X, LangiumDocument as Y, PrecomputedScopes as Z, CodeLensProvider as _, Keyword as _t, LangiumServices as a, CompletionItemKind as at, BuildOptions as b, AbstractSemanticTokenProvider as c, DocumentLink as ct, AbstractFormatter as d, Hover as dt, FileSystemNode as et, FormattingRegion as f, Location as ft, DefaultDocumentHighlightProvider as g, WorkspaceFolder as gt, DocumentLinkProvider as h, TextEdit as ht, NextFeature as i, Command as it, DefaultValueConverter as j, DiagnosticInfo as k, SemanticTokenAcceptor as l, DocumentSymbol as lt, NodeKindProvider as m, SymbolKind as mt, CompletionContext as n, CodeAction as nt, LangiumSharedServices as o, Diagnostic as ot, DocumentSymbolProvider as p, Range as pt, ReferenceInfo as q, DefaultCompletionProvider as r, CodeLens as rt, DefaultWorkspaceSymbolProvider as s, DocumentHighlight as st, CompletionAcceptor as t, FileSystemProvider as tt, AstNodeHoverProvider as u, FormattingOptions as ut, CodeActionProvider as v, URI$1 as vt, DocumentSymbolParams as w, CodeActionParams as x, DefaultWorkspaceManager as y, DefaultNameProvider as z };
+export { cancellation_d_exports as $, DiagnosticInfo as A, DefaultNameProvider as B, CodeLensParams as C, RequestType as D, NotificationType as E, DefaultScopeProvider as F, AstNodeDescription as G, AsyncDisposable as H, Scope as I, ReferenceInfo as J, CstNode as K, JSDocDocumentationProvider as L, DefaultValueConverter as M, ValueType as N, DefaultDocumentValidator as O, MaybePromise as P, PrecomputedScopes as Q, DefaultIndexManager as R, CodeActionParams as S, DocumentSymbolParams as T, Disposable as U, WorkspaceCache as V, AstNode as W, LangiumDocument as X, DefaultLangiumDocuments as Y, LangiumDocumentFactory as Z, CodeLensProvider as _, TextEdit as _t, LangiumServices as a, CodeLens as at, DefaultWorkspaceManager as b, ast_d_exports as bt, AbstractSemanticTokenProvider as c, Diagnostic as ct, AbstractFormatter as d, DocumentSymbol as dt, CancellationToken as et, FormattingRegion as f, FormattingOptions as ft, DefaultDocumentHighlightProvider as g, SymbolKind as gt, DocumentLinkProvider as h, Range as ht, NextFeature as i, CodeAction as it, DefaultScopeComputation as j, ValidationOptions as k, SemanticTokenAcceptor as l, DocumentHighlight as lt, NodeKindProvider as m, Location as mt, CompletionContext as n, FileSystemNode as nt, LangiumSharedServices as o, Command as ot, DocumentSymbolProvider as p, Hover as pt, Reference as q, DefaultCompletionProvider as r, FileSystemProvider as rt, DefaultWorkspaceSymbolProvider as s, CompletionItemKind as st, CompletionAcceptor as t, Stream as tt, AstNodeHoverProvider as u, DocumentLink as ut, CodeActionProvider as v, WorkspaceFolder as vt, DocumentLinkParams as w, BuildOptions as x, URI$1 as xt, index_d_exports as y, Keyword as yt, ReferenceDescription as z };