likec4 1.10.0 → 1.10.1

package/dist/index.d.mts

@@ -3,7 +3,7 @@ Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/
 
 @category Type
 */
-type Primitive =
+type Primitive$1 =
 	| null
 	| undefined
 	| string
@@ -50,7 +50,7 @@ const pet: Pet2 = '';
 */
 type LiteralUnion<
 	LiteralType,
-	BaseType extends Primitive,
+	BaseType extends Primitive$1,
 > = LiteralType | (BaseType & Record<never, never>);
 
 declare const tag$1: unique symbol;
@@ -728,158 +728,6 @@ declare namespace ViewChange {
 }
 type ViewChange = ViewChange.ChangeElementStyle | ViewChange.SaveManualLayout | ViewChange.ChangeAutoLayout;
 
-type Numeric = number | bigint;
-
-/**
-Returns a boolean for whether the given type is `never`.
-
-@link https://github.com/microsoft/TypeScript/issues/31751#issuecomment-498526919
-@link https://stackoverflow.com/a/53984913/10292952
-@link https://www.zhenghao.io/posts/ts-never
-
-Useful in type utilities, such as checking if something does not occur.
-
-@example
-```
-import type {IsNever, And} from 'type-fest';
-
-// https://github.com/andnp/SimplyTyped/blob/master/src/types/strings.ts
-type AreStringsEqual<A extends string, B extends string> =
-	And<
-		IsNever<Exclude<A, B>> extends true ? true : false,
-		IsNever<Exclude<B, A>> extends true ? true : false
-	>;
-
-type EndIfEqual<I extends string, O extends string> =
-	AreStringsEqual<I, O> extends true
-		? never
-		: void;
-
-function endIfEqual<I extends string, O extends string>(input: I, output: O): EndIfEqual<I, O> {
-	if (input === output) {
-		process.exit(0);
-	}
-}
-
-endIfEqual('abc', 'abc');
-//=> never
-
-endIfEqual('abc', '123');
-//=> void
-```
-
-@category Type Guard
-@category Utilities
-*/
-type IsNever$1<T> = [T] extends [never] ? true : false;
-
-/**
-Returns a boolean for whether the given type `T` is the specified `LiteralType`.
-
-@link https://stackoverflow.com/a/52806744/10292952
-
-@example
-```
-LiteralCheck<1, number>
-//=> true
-
-LiteralCheck<number, number>
-//=> false
-
-LiteralCheck<1, string>
-//=> false
-```
-*/
-type LiteralCheck<T, LiteralType extends Primitive> = (
-	IsNever$1<T> extends false // Must be wider than `never`
-		? [T] extends [LiteralType & infer U] // Remove any branding
-			? [U] extends [LiteralType] // Must be narrower than `LiteralType`
-				? [LiteralType] extends [U] // Cannot be wider than `LiteralType`
-					? false
-					: true
-				: false
-			: false
-		: false
-);
-
-/**
-Returns a boolean for whether the given type `T` is one of the specified literal types in `LiteralUnionType`.
-
-@example
-```
-LiteralChecks<1, Numeric>
-//=> true
-
-LiteralChecks<1n, Numeric>
-//=> true
-
-LiteralChecks<bigint, Numeric>
-//=> false
-```
-*/
-type LiteralChecks<T, LiteralUnionType> = (
-	// Conditional type to force union distribution.
-	// If `T` is none of the literal types in the union `LiteralUnionType`, then `LiteralCheck<T, LiteralType>` will evaluate to `false` for the whole union.
-	// If `T` is one of the literal types in the union, it will evaluate to `boolean` (i.e. `true | false`)
-	IsNotFalse<LiteralUnionType extends Primitive
-		? LiteralCheck<T, LiteralUnionType>
-		: never
-	>
-);
-
-/**
-Returns a boolean for whether the given type is a `number` or `bigint` [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
-
-Useful for:
-	- providing strongly-typed functions when given literal arguments
-	- type utilities, such as when constructing parsers and ASTs
-
-@example
-```
-import type {IsNumericLiteral} from 'type-fest';
-
-// https://github.com/inocan-group/inferred-types/blob/master/src/types/boolean-logic/EndsWith.ts
-type EndsWith<TValue, TEndsWith extends string> =
-	TValue extends string
-		? IsStringLiteral<TEndsWith> extends true
-			? IsStringLiteral<TValue> extends true
-				? TValue extends `${string}${TEndsWith}`
-					? true
-					: false
-				: boolean
-			: boolean
-		: TValue extends number
-			? IsNumericLiteral<TValue> extends true
-				? EndsWith<`${TValue}`, TEndsWith>
-				: false
-			: false;
-
-function endsWith<Input extends string | number, End extends string>(input: Input, end: End) {
-	return `${input}`.endsWith(end) as EndsWith<Input, End>;
-}
-
-endsWith('abc', 'c');
-//=> true
-
-endsWith(123456, '456');
-//=> true
-
-const end = '123' as string;
-
-endsWith('abc123', end);
-//=> boolean
-```
-
-@category Type Guard
-@category Utilities
-*/
-type IsNumericLiteral<T> = LiteralChecks<T, Numeric>;
-
-/**
-Returns a boolean for whether the given `boolean` is not `false`.
-*/
-type IsNotFalse<T extends boolean> = [T] extends [false] ? false : true;
-
 declare const ElementColors: {
     readonly primary: {
         fill: "#3b82f6";
@@ -1409,94 +1257,267 @@ declare function compareByFqnHierarchically<T extends {
 }>(a: T, b: T): 0 | 1 | -1;
 
 /**
- * This should only be used for defining generics which extend any kind of JS
- * array under the hood, this includes arrays *AND* tuples (of the form [x, y],
- * and of the form [x, ...y[]], etc...), and their readonly equivalent. This
- * allows us to be more inclusive to what functions can process.
- *
- * @example map<T extends ArrayLike>(items: T) { ... }
- *
- * We would've named this `ArrayLike`, but that's already used by typescript...
- * @see This was inspired by the type-definition of Promise.all (https://github.com/microsoft/TypeScript/blob/1df5717b120cddd325deab8b0f2b2c3eecaf2b01/src/lib/es2015.promise.d.ts#L21)
- */
-type IterableContainer<T = unknown> = ReadonlyArray<T> | readonly [];
+Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive).
 
-type ArraySetRequired<T extends IterableContainer, Min extends number, Iteration extends ReadonlyArray<unknown> = []> = number extends Min ? never : Iteration["length"] extends Min ? T : T extends readonly [] ? never : T extends [infer Head, ...infer Rest] ? [
-    Head,
-    ...ArraySetRequired<Rest, Min, [unknown, ...Iteration]>
-] : T extends readonly [infer Head, ...infer Rest] ? readonly [
-    Head,
-    ...ArraySetRequired<Rest, Min, [unknown, ...Iteration]>
-] : T extends Array<infer Item> ? [
-    Item,
-    ...ArraySetRequired<T, Min, [unknown, ...Iteration]>
-] : T extends ReadonlyArray<infer Item> ? readonly [
-    Item,
-    ...ArraySetRequired<T, Min, [unknown, ...Iteration]>
-] : never;
-/**
- * Checks if the given array has at least the defined number of elements. When
- * the minimum used is a literal (e.g. `3`) the output is refined accordingly so
- * that those indices are defined when accessing the array even when using
- * typescript's 'noUncheckedIndexAccess'.
- *
- * @param data - The input array.
- * @param minimum - The minimum number of elements the array must have.
- * @returns True if the array's length is *at least* `minimum`. When `minimum`
- * is a literal value, the output is narrowed to ensure the first items are
- * guaranteed.
- * @signature
- *   R.hasAtLeast(data, minimum)
- * @example
- *   R.hasAtLeast([], 4); // => false
- *
- *   const data: number[] = [1,2,3,4];
- *   R.hasAtLeast(data, 1); // => true
- *   data[0]; // 1, with type `number`
- * @dataFirst
- * @category Array
- */
-declare function hasAtLeast<T extends IterableContainer, N extends number>(data: IterableContainer | T, minimum: IsNumericLiteral<N> extends true ? N : never): data is ArraySetRequired<T, N>;
-declare function hasAtLeast(data: IterableContainer, minimum: number): boolean;
-/**
- * Checks if the given array has at least the defined number of elements. When
- * the minimum used is a literal (e.g. `3`) the output is refined accordingly so
- * that those indices are defined when accessing the array even when using
- * typescript's 'noUncheckedIndexAccess'.
- *
- * @param minimum - The minimum number of elements the array must have.
- * @returns True if the array's length is *at least* `minimum`. When `minimum`
- * is a literal value, the output is narrowed to ensure the first items are
- * guaranteed.
- * @signature
- *   R.hasAtLeast(minimum)(data)
- * @example
- *   R.pipe([], R.hasAtLeast(4)); // => false
- *
- *   const data = [[1,2], [3], [4,5]];
- *   R.pipe(
- *     data,
- *     R.filter(R.hasAtLeast(2)),
- *     R.map(([, second]) => second),
- *   ); // => [2,5], with type `number[]`
- * @dataLast
- * @category Array
- */
-declare function hasAtLeast<N extends number>(minimum: IsNumericLiteral<N> extends true ? N : never): <T extends IterableContainer>(data: IterableContainer | T) => data is ArraySetRequired<T, N>;
-declare function hasAtLeast(minimum: number): (data: IterableContainer) => boolean;
+@category Type
+*/
+type Primitive =
+	| null
+	| undefined
+	| string
+	| number
+	| boolean
+	| symbol
+	| bigint;
 
-/**
- * Compares two relations hierarchically.
- * From the most general (implicit) to the most specific.
- */
-declare const compareRelations: <T extends {
-    source: string;
-    target: string;
-}>(a: T, b: T) => 0 | 1 | -1;
+declare global {
+	// eslint-disable-next-line @typescript-eslint/consistent-type-definitions -- It has to be an `interface` so that it can be merged.
+	interface SymbolConstructor {
+		readonly observable: symbol;
+	}
+}
+
+type Numeric = number | bigint;
 
 /**
- * A tagging type for string properties that are actually document URIs.
- */
+Returns a boolean for whether the given type is `never`.
+
+@link https://github.com/microsoft/TypeScript/issues/31751#issuecomment-498526919
+@link https://stackoverflow.com/a/53984913/10292952
+@link https://www.zhenghao.io/posts/ts-never
+
+Useful in type utilities, such as checking if something does not occur.
+
+@example
+```
+import type {IsNever, And} from 'type-fest';
+
+// https://github.com/andnp/SimplyTyped/blob/master/src/types/strings.ts
+type AreStringsEqual<A extends string, B extends string> =
+	And<
+		IsNever<Exclude<A, B>> extends true ? true : false,
+		IsNever<Exclude<B, A>> extends true ? true : false
+	>;
+
+type EndIfEqual<I extends string, O extends string> =
+	AreStringsEqual<I, O> extends true
+		? never
+		: void;
+
+function endIfEqual<I extends string, O extends string>(input: I, output: O): EndIfEqual<I, O> {
+	if (input === output) {
+		process.exit(0);
+	}
+}
+
+endIfEqual('abc', 'abc');
+//=> never
+
+endIfEqual('abc', '123');
+//=> void
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsNever$1<T> = [T] extends [never] ? true : false;
+
+/**
+Returns a boolean for whether the given type `T` is the specified `LiteralType`.
+
+@link https://stackoverflow.com/a/52806744/10292952
+
+@example
+```
+LiteralCheck<1, number>
+//=> true
+
+LiteralCheck<number, number>
+//=> false
+
+LiteralCheck<1, string>
+//=> false
+```
+*/
+type LiteralCheck<T, LiteralType extends Primitive> = (
+	IsNever$1<T> extends false // Must be wider than `never`
+		? [T] extends [LiteralType & infer U] // Remove any branding
+			? [U] extends [LiteralType] // Must be narrower than `LiteralType`
+				? [LiteralType] extends [U] // Cannot be wider than `LiteralType`
+					? false
+					: true
+				: false
+			: false
+		: false
+);
+
+/**
+Returns a boolean for whether the given type `T` is one of the specified literal types in `LiteralUnionType`.
+
+@example
+```
+LiteralChecks<1, Numeric>
+//=> true
+
+LiteralChecks<1n, Numeric>
+//=> true
+
+LiteralChecks<bigint, Numeric>
+//=> false
+```
+*/
+type LiteralChecks<T, LiteralUnionType> = (
+	// Conditional type to force union distribution.
+	// If `T` is none of the literal types in the union `LiteralUnionType`, then `LiteralCheck<T, LiteralType>` will evaluate to `false` for the whole union.
+	// If `T` is one of the literal types in the union, it will evaluate to `boolean` (i.e. `true | false`)
+	IsNotFalse<LiteralUnionType extends Primitive
+		? LiteralCheck<T, LiteralUnionType>
+		: never
+	>
+);
+
+/**
+Returns a boolean for whether the given type is a `number` or `bigint` [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
+
+Useful for:
+	- providing strongly-typed functions when given literal arguments
+	- type utilities, such as when constructing parsers and ASTs
+
+@example
+```
+import type {IsNumericLiteral} from 'type-fest';
+
+// https://github.com/inocan-group/inferred-types/blob/master/src/types/boolean-logic/EndsWith.ts
+type EndsWith<TValue, TEndsWith extends string> =
+	TValue extends string
+		? IsStringLiteral<TEndsWith> extends true
+			? IsStringLiteral<TValue> extends true
+				? TValue extends `${string}${TEndsWith}`
+					? true
+					: false
+				: boolean
+			: boolean
+		: TValue extends number
+			? IsNumericLiteral<TValue> extends true
+				? EndsWith<`${TValue}`, TEndsWith>
+				: false
+			: false;
+
+function endsWith<Input extends string | number, End extends string>(input: Input, end: End) {
+	return `${input}`.endsWith(end) as EndsWith<Input, End>;
+}
+
+endsWith('abc', 'c');
+//=> true
+
+endsWith(123456, '456');
+//=> true
+
+const end = '123' as string;
+
+endsWith('abc123', end);
+//=> boolean
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsNumericLiteral<T> = LiteralChecks<T, Numeric>;
+
+/**
+Returns a boolean for whether the given `boolean` is not `false`.
+*/
+type IsNotFalse<T extends boolean> = [T] extends [false] ? false : true;
+
+/**
+ * This should only be used for defining generics which extend any kind of JS
+ * array under the hood, this includes arrays *AND* tuples (of the form [x, y],
+ * and of the form [x, ...y[]], etc...), and their readonly equivalent. This
+ * allows us to be more inclusive to what functions can process.
+ *
+ * @example map<T extends ArrayLike>(items: T) { ... }
+ *
+ * We would've named this `ArrayLike`, but that's already used by typescript...
+ * @see This was inspired by the type-definition of Promise.all (https://github.com/microsoft/TypeScript/blob/1df5717b120cddd325deab8b0f2b2c3eecaf2b01/src/lib/es2015.promise.d.ts#L21)
+ */
+type IterableContainer<T = unknown> = ReadonlyArray<T> | readonly [];
+
+type ArraySetRequired<T extends IterableContainer, Min extends number, Iteration extends ReadonlyArray<unknown> = []> = number extends Min ? never : Iteration["length"] extends Min ? T : T extends readonly [] ? never : T extends [infer Head, ...infer Rest] ? [
+    Head,
+    ...ArraySetRequired<Rest, Min, [unknown, ...Iteration]>
+] : T extends readonly [infer Head, ...infer Rest] ? readonly [
+    Head,
+    ...ArraySetRequired<Rest, Min, [unknown, ...Iteration]>
+] : T extends Array<infer Item> ? [
+    Item,
+    ...ArraySetRequired<T, Min, [unknown, ...Iteration]>
+] : T extends ReadonlyArray<infer Item> ? readonly [
+    Item,
+    ...ArraySetRequired<T, Min, [unknown, ...Iteration]>
+] : never;
+/**
+ * Checks if the given array has at least the defined number of elements. When
+ * the minimum used is a literal (e.g. `3`) the output is refined accordingly so
+ * that those indices are defined when accessing the array even when using
+ * typescript's 'noUncheckedIndexAccess'.
+ *
+ * @param data - The input array.
+ * @param minimum - The minimum number of elements the array must have.
+ * @returns True if the array's length is *at least* `minimum`. When `minimum`
+ * is a literal value, the output is narrowed to ensure the first items are
+ * guaranteed.
+ * @signature
+ *   R.hasAtLeast(data, minimum)
+ * @example
+ *   R.hasAtLeast([], 4); // => false
+ *
+ *   const data: number[] = [1,2,3,4];
+ *   R.hasAtLeast(data, 1); // => true
+ *   data[0]; // 1, with type `number`
+ * @dataFirst
+ * @category Array
+ */
+declare function hasAtLeast<T extends IterableContainer, N extends number>(data: IterableContainer | T, minimum: IsNumericLiteral<N> extends true ? N : never): data is ArraySetRequired<T, N>;
+declare function hasAtLeast(data: IterableContainer, minimum: number): boolean;
+/**
+ * Checks if the given array has at least the defined number of elements. When
+ * the minimum used is a literal (e.g. `3`) the output is refined accordingly so
+ * that those indices are defined when accessing the array even when using
+ * typescript's 'noUncheckedIndexAccess'.
+ *
+ * @param minimum - The minimum number of elements the array must have.
+ * @returns True if the array's length is *at least* `minimum`. When `minimum`
+ * is a literal value, the output is narrowed to ensure the first items are
+ * guaranteed.
+ * @signature
+ *   R.hasAtLeast(minimum)(data)
+ * @example
+ *   R.pipe([], R.hasAtLeast(4)); // => false
+ *
+ *   const data = [[1,2], [3], [4,5]];
+ *   R.pipe(
+ *     data,
+ *     R.filter(R.hasAtLeast(2)),
+ *     R.map(([, second]) => second),
+ *   ); // => [2,5], with type `number[]`
+ * @dataLast
+ * @category Array
+ */
+declare function hasAtLeast<N extends number>(minimum: IsNumericLiteral<N> extends true ? N : never): <T extends IterableContainer>(data: IterableContainer | T) => data is ArraySetRequired<T, N>;
+declare function hasAtLeast(minimum: number): (data: IterableContainer) => boolean;
+
+/**
+ * Compares two relations hierarchically.
+ * From the most general (implicit) to the most specific.
+ */
+declare const compareRelations: <T extends {
+    source: string;
+    target: string;
+}>(a: T, b: T) => 0 | 1 | -1;
+
+/**
+ * A tagging type for string properties that are actually document URIs.
+ */
 type DocumentUri$1 = string;
 declare namespace DocumentUri$1 {
     function is(value: any): value is DocumentUri$1;
@@ -6716,7 +6737,7 @@ interface UriComponents {
 }
 
 /******************************************************************************
- * This file was generated by langium-cli 3.1.0.
+ * This file was generated by langium-cli 3.2.0.
  * DO NOT EDIT MANUALLY!
  ******************************************************************************/
 
@@ -7169,16 +7190,267 @@ interface FileSystemProvider {
 }
 
 /******************************************************************************
- * Copyright 2022 TypeFox GmbH
+ * 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.
  ******************************************************************************/
-
-interface LexerResult {
+/**
+ * A stream is a read-only sequence of values. While the contents of an array can be accessed
+ * both sequentially and randomly (via index), a stream allows only sequential access.
+ *
+ * The advantage of this is that a stream can be evaluated lazily, so it does not require
+ * to store intermediate values. This can boost performance when a large sequence is
+ * processed via filtering, mapping etc. and accessed at most once. However, lazy
+ * evaluation means that all processing is repeated when you access the sequence multiple
+ * times; in such a case, it may be better to store the resulting sequence into an array.
+ */
+interface Stream<T> extends Iterable<T> {
     /**
-     * A list of all tokens that were lexed from the input.
-     *
-     * Note that Langium requires the optional properties
+     * Returns an iterator for this stream. This is the same as calling the `Symbol.iterator` function property.
+     */
+    iterator(): IterableIterator<T>;
+    /**
+     * Determines whether this stream contains no elements.
+     */
+    isEmpty(): boolean;
+    /**
+     * Determines the number of elements in this stream.
+     */
+    count(): number;
+    /**
+     * Collects all elements of this stream into an array.
+     */
+    toArray(): T[];
+    /**
+     * Collects all elements of this stream into a Set.
+     */
+    toSet(): Set<T>;
+    /**
+     * Collects all elements of this stream into a Map, applying the provided functions to determine keys and values.
+     *
+     * @param keyFn The function to derive map keys. If omitted, the stream elements are used as keys.
+     * @param valueFn The function to derive map values. If omitted, the stream elements are used as values.
+     */
+    toMap<K = T, V = T>(keyFn?: (e: T) => K, valueFn?: (e: T) => V): Map<K, V>;
+    /**
+     * Returns a string representation of a stream.
+     */
+    toString(): string;
+    /**
+     * Combines two streams by returning a new stream that yields all elements of this stream and the other stream.
+     *
+     * @param other Stream to be concatenated with this one.
+     */
+    concat<T2>(other: Iterable<T2>): Stream<T | T2>;
+    /**
+     * Adds all elements of the stream into a string, separated by the specified separator string.
+     *
+     * @param separator A string used to separate one element of the stream from the next in the resulting string.
+     *        If omitted, the steam elements are separated with a comma.
+     */
+    join(separator?: string): string;
+    /**
+     * Returns the index of the first occurrence of a value in the stream, or -1 if it is not present.
+     *
+     * @param searchElement The value to locate in the array.
+     * @param fromIndex The stream index at which to begin the search. If fromIndex is omitted, the search
+     *        starts at index 0.
+     */
+    indexOf(searchElement: T, fromIndex?: number): number;
+    /**
+     * Determines whether all members of the stream satisfy the specified test.
+     *
+     * @param predicate This method calls the predicate function for each element in the stream until the
+     *        predicate returns a value which is coercible to the Boolean value `false`, or until the end
+     *        of the stream.
+     */
+    every<S extends T>(predicate: (value: T) => value is S): this is Stream<S>;
+    every(predicate: (value: T) => unknown): boolean;
+    /**
+     * Determines whether any member of the stream satisfies the specified test.
+     *
+     * @param predicate This method calls the predicate function for each element in the stream until the
+     *        predicate returns a value which is coercible to the Boolean value `true`, or until the end
+     *        of the stream.
+     */
+    some(predicate: (value: T) => unknown): boolean;
+    /**
+     * Performs the specified action for each element in the stream.
+     *
+     * @param callbackfn Function called once for each element in the stream.
+     */
+    forEach(callbackfn: (value: T, index: number) => void): void;
+    /**
+     * Returns a stream that yields the results of calling the specified callback function on each element
+     * of the stream. The function is called when the resulting stream elements are actually accessed, so
+     * accessing the resulting stream multiple times means the function is also called multiple times for
+     * each element of the stream.
+     *
+     * @param callbackfn Lazily evaluated function mapping stream elements.
+     */
+    map<U>(callbackfn: (value: T) => U): Stream<U>;
+    /**
+     * Returns the elements of the stream that meet the condition specified in a callback function.
+     * The function is called when the resulting stream elements are actually accessed, so accessing the
+     * resulting stream multiple times means the function is also called multiple times for each element
+     * of the stream.
+     *
+     * @param predicate Lazily evaluated function checking a condition on stream elements.
+     */
+    filter<S extends T>(predicate: (value: T) => value is S): Stream<S>;
+    filter(predicate: (value: T) => unknown): Stream<T>;
+    /**
+     * Returns the elements of the stream that are _non-nullable_, which means they are neither `undefined`
+     * nor `null`.
+     */
+    nonNullable(): Stream<NonNullable<T>>;
+    /**
+     * Calls the specified callback function for all elements in the stream. The return value of the
+     * callback function is the accumulated result, and is provided as an argument in the next call to
+     * the callback function.
+     *
+     * @param callbackfn This method calls the function once for each element in the stream, providing
+     *        the previous and current values of the reduction.
+     * @param initialValue If specified, `initialValue` is used as the initial value to start the
+     *        accumulation. The first call to the function provides this value as an argument instead
+     *        of a stream value.
+     */
+    reduce(callbackfn: (previousValue: T, currentValue: T) => T): T | undefined;
+    reduce<U = T>(callbackfn: (previousValue: U, currentValue: T) => U, initialValue: U): U;
+    /**
+     * Calls the specified callback function for all elements in the stream, in descending order.
+     * The return value of the callback function is the accumulated result, and is provided as an
+     * argument in the next call to the callback function.
+     *
+     * @param callbackfn This method calls the function once for each element in the stream, providing
+     *        the previous and current values of the reduction.
+     * @param initialValue If specified, `initialValue` is used as the initial value to start the
+     *        accumulation. The first call to the function provides this value as an argument instead
+     *        of an array value.
+     */
+    reduceRight(callbackfn: (previousValue: T, currentValue: T) => T): T | undefined;
+    reduceRight<U = T>(callbackfn: (previousValue: U, currentValue: T) => U, initialValue: U): U;
+    /**
+     * Returns the value of the first element in the stream that meets the condition, or `undefined`
+     * if there is no such element.
+     *
+     * @param predicate This method calls `predicate` once for each element of the stream, in ascending
+     *        order, until it finds one where `predicate` returns a value which is coercible to the
+     *        Boolean value `true`.
+     */
+    find<S extends T>(predicate: (value: T) => value is S): S | undefined;
+    find(predicate: (value: T) => unknown): T | undefined;
+    /**
+     * Returns the index of the first element in the stream that meets the condition, or `-1`
+     * if there is no such element.
+     *
+     * @param predicate This method calls `predicate` once for each element of the stream, in ascending
+     *        order, until it finds one where `predicate` returns a value which is coercible to the
+     *        Boolean value `true`.
+     */
+    findIndex(predicate: (value: T) => unknown): number;
+    /**
+     * Determines whether the stream includes a certain element, returning `true` or `false` as appropriate.
+     *
+     * @param searchElement The element to search for.
+     */
+    includes(searchElement: T): boolean;
+    /**
+     * Calls a defined callback function on each element of the stream and then flattens the result into
+     * a new stream. This is identical to a `map` followed by `flat` with depth 1.
+     *
+     * @param callbackfn Lazily evaluated function mapping stream elements.
+     */
+    flatMap<U>(callbackfn: (value: T) => U | Iterable<U>): Stream<U>;
+    /**
+     * Returns a new stream with all sub-stream or sub-array elements concatenated into it recursively up
+     * to the specified depth.
+     *
+     * @param depth The maximum recursion depth. Defaults to 1.
+     */
+    flat<D extends number = 1>(depth?: D): FlatStream<T, D>;
+    /**
+     * Returns the first element in the stream, or `undefined` if the stream is empty.
+     */
+    head(): T | undefined;
+    /**
+     * Returns a stream that skips the first `skipCount` elements from this stream.
+     *
+     * @param skipCount The number of elements to skip. If this is larger than the number of elements in
+     *        the stream, an empty stream is returned. Defaults to 1.
+     */
+    tail(skipCount?: number): Stream<T>;
+    /**
+     * Returns a stream consisting of the elements of this stream, truncated to be no longer than `maxSize`
+     * in length.
+     *
+     * @param maxSize The number of elements the stream should be limited to
+     */
+    limit(maxSize: number): Stream<T>;
+    /**
+     * Returns a stream containing only the distinct elements from this stream.
+     * Equality is determined with the same rules as a standard `Set`.
+     *
+     * @param by A function returning the key used to check equality with a previous stream element.
+     *        If omitted, the stream elements themselves are used for comparison.
+     */
+    distinct<Key = T>(by?: (element: T) => Key): Stream<T>;
+    /**
+     * Returns a stream that contains all elements that don't exist in the {@link other} iterable.
+     * Equality is determined with the same rules as a standard `Set`.
+     * @param other The elements that should be exluded from this stream.
+     * @param key A function returning the key used to check quality.
+     *        If omitted, the stream elements themselves are used for comparison.
+     */
+    exclude<Key = T>(other: Iterable<T>, key?: (element: T) => Key): Stream<T>;
+}
+type FlatStream<T, Depth extends number> = {
+    'done': Stream<T>;
+    '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];
+
+/******************************************************************************
+ * 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.
+ ******************************************************************************/
+
+interface TokenBuilderOptions {
+    caseInsensitive?: boolean;
+}
+interface TokenBuilder {
+    buildTokens(grammar: Grammar, options?: TokenBuilderOptions): TokenVocabulary;
+    /**
+     * Produces a lexing report for the given text that was just tokenized using the tokens provided by this builder.
+     *
+     * @param text The text that was tokenized.
+     */
+    flushLexingReport?(text: string): LexingReport;
+}
+/**
+ * A custom lexing report that can be produced by the token builder during the lexing process.
+ * Adopters need to ensure that the any custom fields are serializable so they can be sent across worker threads.
+ */
+interface LexingReport {
+    diagnostics: LexingDiagnostic[];
+}
+type LexingDiagnosticSeverity = 'error' | 'warning' | 'info' | 'hint';
+interface LexingDiagnostic extends ILexingError {
+    severity?: LexingDiagnosticSeverity;
+}
+
+/******************************************************************************
+ * Copyright 2022 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.
+ ******************************************************************************/
+
+interface LexerResult {
+    /**
+     * A list of all tokens that were lexed from the input.
+     *
+     * Note that Langium requires the optional properties
      * `startLine`, `startColumn`, `endOffset`, `endLine` and `endColumn` to be set on each token.
      */
     tokens: IToken[];
@@ -7187,10 +7459,15 @@ interface LexerResult {
      */
     hidden: IToken[];
     errors: ILexingError[];
+    report?: LexingReport;
+}
+type TokenizeMode = 'full' | 'partial';
+interface TokenizeOptions {
+    mode?: TokenizeMode;
 }
 interface Lexer {
     readonly definition: TokenTypeDictionary;
-    tokenize(text: string): LexerResult;
+    tokenize(text: string, options?: TokenizeOptions): LexerResult;
 }
 
 /******************************************************************************
@@ -7203,6 +7480,7 @@ type ParseResult<T = AstNode> = {
     value: T;
     parserErrors: IRecognitionException[];
     lexerErrors: ILexingError[];
+    lexerReport?: LexingReport;
 };
 type RuleResult = (args: Args) => any;
 type Args = Record<string, boolean>;
@@ -7365,268 +7643,47 @@ declare class LangiumCompletionParser extends AbstractLangiumParser {
  */
 declare class ChevrotainWrapper extends EmbeddedActionsParser {
     definitionErrors: IParserDefinitionError[];
-    constructor(tokens: TokenVocabulary, config?: IParserConfig);
-    get IS_RECORDING(): boolean;
-    DEFINE_RULE(name: string, impl: RuleImpl): RuleResult;
-    wrapSelfAnalysis(): void;
-    wrapConsume(idx: number, tokenType: TokenType): IToken;
-    wrapSubrule(idx: number, rule: RuleResult, args: Args): unknown;
-    wrapOr(idx: number, choices: Array<IOrAlt<any>>): void;
-    wrapOption(idx: number, callback: DSLMethodOpts<unknown>): void;
-    wrapMany(idx: number, callback: DSLMethodOpts<unknown>): void;
-    wrapAtLeastOne(idx: number, callback: DSLMethodOpts<unknown>): void;
-}
-
-/******************************************************************************
- * 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.
- ******************************************************************************/
-
-/**
- * The service registry provides access to the language-specific {@link LangiumCoreServices} optionally including LSP-related services.
- * These are resolved via the URI of a text document.
- */
-interface ServiceRegistry {
-    /**
-     * Register a language via its injected services.
-     */
-    register(language: LangiumCoreServices): void;
-    /**
-     * Retrieve the language-specific services for the given URI. In case only one language is
-     * registered, it may be used regardless of the URI format.
-     */
-    getServices(uri: URI): LangiumCoreServices;
-    /**
-     * Check whether services are available for the given URI.
-     */
-    hasServices(uri: URI): boolean;
-    /**
-     * The full set of registered language services.
-     */
-    readonly all: readonly LangiumCoreServices[];
-}
-
-/******************************************************************************
- * 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 stream is a read-only sequence of values. While the contents of an array can be accessed
- * both sequentially and randomly (via index), a stream allows only sequential access.
- *
- * The advantage of this is that a stream can be evaluated lazily, so it does not require
- * to store intermediate values. This can boost performance when a large sequence is
- * processed via filtering, mapping etc. and accessed at most once. However, lazy
- * evaluation means that all processing is repeated when you access the sequence multiple
- * times; in such a case, it may be better to store the resulting sequence into an array.
- */
-interface Stream<T> extends Iterable<T> {
-    /**
-     * Returns an iterator for this stream. This is the same as calling the `Symbol.iterator` function property.
-     */
-    iterator(): IterableIterator<T>;
-    /**
-     * Determines whether this stream contains no elements.
-     */
-    isEmpty(): boolean;
-    /**
-     * Determines the number of elements in this stream.
-     */
-    count(): number;
-    /**
-     * Collects all elements of this stream into an array.
-     */
-    toArray(): T[];
-    /**
-     * Collects all elements of this stream into a Set.
-     */
-    toSet(): Set<T>;
-    /**
-     * Collects all elements of this stream into a Map, applying the provided functions to determine keys and values.
-     *
-     * @param keyFn The function to derive map keys. If omitted, the stream elements are used as keys.
-     * @param valueFn The function to derive map values. If omitted, the stream elements are used as values.
-     */
-    toMap<K = T, V = T>(keyFn?: (e: T) => K, valueFn?: (e: T) => V): Map<K, V>;
-    /**
-     * Returns a string representation of a stream.
-     */
-    toString(): string;
-    /**
-     * Combines two streams by returning a new stream that yields all elements of this stream and the other stream.
-     *
-     * @param other Stream to be concatenated with this one.
-     */
-    concat<T2>(other: Iterable<T2>): Stream<T | T2>;
-    /**
-     * Adds all elements of the stream into a string, separated by the specified separator string.
-     *
-     * @param separator A string used to separate one element of the stream from the next in the resulting string.
-     *        If omitted, the steam elements are separated with a comma.
-     */
-    join(separator?: string): string;
-    /**
-     * Returns the index of the first occurrence of a value in the stream, or -1 if it is not present.
-     *
-     * @param searchElement The value to locate in the array.
-     * @param fromIndex The stream index at which to begin the search. If fromIndex is omitted, the search
-     *        starts at index 0.
-     */
-    indexOf(searchElement: T, fromIndex?: number): number;
-    /**
-     * Determines whether all members of the stream satisfy the specified test.
-     *
-     * @param predicate This method calls the predicate function for each element in the stream until the
-     *        predicate returns a value which is coercible to the Boolean value `false`, or until the end
-     *        of the stream.
-     */
-    every<S extends T>(predicate: (value: T) => value is S): this is Stream<S>;
-    every(predicate: (value: T) => unknown): boolean;
-    /**
-     * Determines whether any member of the stream satisfies the specified test.
-     *
-     * @param predicate This method calls the predicate function for each element in the stream until the
-     *        predicate returns a value which is coercible to the Boolean value `true`, or until the end
-     *        of the stream.
-     */
-    some(predicate: (value: T) => unknown): boolean;
-    /**
-     * Performs the specified action for each element in the stream.
-     *
-     * @param callbackfn Function called once for each element in the stream.
-     */
-    forEach(callbackfn: (value: T, index: number) => void): void;
-    /**
-     * Returns a stream that yields the results of calling the specified callback function on each element
-     * of the stream. The function is called when the resulting stream elements are actually accessed, so
-     * accessing the resulting stream multiple times means the function is also called multiple times for
-     * each element of the stream.
-     *
-     * @param callbackfn Lazily evaluated function mapping stream elements.
-     */
-    map<U>(callbackfn: (value: T) => U): Stream<U>;
-    /**
-     * Returns the elements of the stream that meet the condition specified in a callback function.
-     * The function is called when the resulting stream elements are actually accessed, so accessing the
-     * resulting stream multiple times means the function is also called multiple times for each element
-     * of the stream.
-     *
-     * @param predicate Lazily evaluated function checking a condition on stream elements.
-     */
-    filter<S extends T>(predicate: (value: T) => value is S): Stream<S>;
-    filter(predicate: (value: T) => unknown): Stream<T>;
-    /**
-     * Returns the elements of the stream that are _non-nullable_, which means they are neither `undefined`
-     * nor `null`.
-     */
-    nonNullable(): Stream<NonNullable<T>>;
-    /**
-     * Calls the specified callback function for all elements in the stream. The return value of the
-     * callback function is the accumulated result, and is provided as an argument in the next call to
-     * the callback function.
-     *
-     * @param callbackfn This method calls the function once for each element in the stream, providing
-     *        the previous and current values of the reduction.
-     * @param initialValue If specified, `initialValue` is used as the initial value to start the
-     *        accumulation. The first call to the function provides this value as an argument instead
-     *        of a stream value.
-     */
-    reduce(callbackfn: (previousValue: T, currentValue: T) => T): T | undefined;
-    reduce<U = T>(callbackfn: (previousValue: U, currentValue: T) => U, initialValue: U): U;
-    /**
-     * Calls the specified callback function for all elements in the stream, in descending order.
-     * The return value of the callback function is the accumulated result, and is provided as an
-     * argument in the next call to the callback function.
-     *
-     * @param callbackfn This method calls the function once for each element in the stream, providing
-     *        the previous and current values of the reduction.
-     * @param initialValue If specified, `initialValue` is used as the initial value to start the
-     *        accumulation. The first call to the function provides this value as an argument instead
-     *        of an array value.
-     */
-    reduceRight(callbackfn: (previousValue: T, currentValue: T) => T): T | undefined;
-    reduceRight<U = T>(callbackfn: (previousValue: U, currentValue: T) => U, initialValue: U): U;
-    /**
-     * Returns the value of the first element in the stream that meets the condition, or `undefined`
-     * if there is no such element.
-     *
-     * @param predicate This method calls `predicate` once for each element of the stream, in ascending
-     *        order, until it finds one where `predicate` returns a value which is coercible to the
-     *        Boolean value `true`.
-     */
-    find<S extends T>(predicate: (value: T) => value is S): S | undefined;
-    find(predicate: (value: T) => unknown): T | undefined;
-    /**
-     * Returns the index of the first element in the stream that meets the condition, or `-1`
-     * if there is no such element.
-     *
-     * @param predicate This method calls `predicate` once for each element of the stream, in ascending
-     *        order, until it finds one where `predicate` returns a value which is coercible to the
-     *        Boolean value `true`.
-     */
-    findIndex(predicate: (value: T) => unknown): number;
-    /**
-     * Determines whether the stream includes a certain element, returning `true` or `false` as appropriate.
-     *
-     * @param searchElement The element to search for.
-     */
-    includes(searchElement: T): boolean;
-    /**
-     * Calls a defined callback function on each element of the stream and then flattens the result into
-     * a new stream. This is identical to a `map` followed by `flat` with depth 1.
-     *
-     * @param callbackfn Lazily evaluated function mapping stream elements.
-     */
-    flatMap<U>(callbackfn: (value: T) => U | Iterable<U>): Stream<U>;
-    /**
-     * Returns a new stream with all sub-stream or sub-array elements concatenated into it recursively up
-     * to the specified depth.
-     *
-     * @param depth The maximum recursion depth. Defaults to 1.
-     */
-    flat<D extends number = 1>(depth?: D): FlatStream<T, D>;
-    /**
-     * Returns the first element in the stream, or `undefined` if the stream is empty.
-     */
-    head(): T | undefined;
+    constructor(tokens: TokenVocabulary, config?: IParserConfig);
+    get IS_RECORDING(): boolean;
+    DEFINE_RULE(name: string, impl: RuleImpl): RuleResult;
+    wrapSelfAnalysis(): void;
+    wrapConsume(idx: number, tokenType: TokenType): IToken;
+    wrapSubrule(idx: number, rule: RuleResult, args: Args): unknown;
+    wrapOr(idx: number, choices: Array<IOrAlt<any>>): void;
+    wrapOption(idx: number, callback: DSLMethodOpts<unknown>): void;
+    wrapMany(idx: number, callback: DSLMethodOpts<unknown>): void;
+    wrapAtLeastOne(idx: number, callback: DSLMethodOpts<unknown>): void;
+}
+
+/******************************************************************************
+ * 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.
+ ******************************************************************************/
+
+/**
+ * The service registry provides access to the language-specific {@link LangiumCoreServices} optionally including LSP-related services.
+ * These are resolved via the URI of a text document.
+ */
+interface ServiceRegistry {
     /**
-     * Returns a stream that skips the first `skipCount` elements from this stream.
-     *
-     * @param skipCount The number of elements to skip. If this is larger than the number of elements in
-     *        the stream, an empty stream is returned. Defaults to 1.
+     * Register a language via its injected services.
      */
-    tail(skipCount?: number): Stream<T>;
+    register(language: LangiumCoreServices): void;
     /**
-     * Returns a stream consisting of the elements of this stream, truncated to be no longer than `maxSize`
-     * in length.
-     *
-     * @param maxSize The number of elements the stream should be limited to
+     * Retrieve the language-specific services for the given URI. In case only one language is
+     * registered, it may be used regardless of the URI format.
      */
-    limit(maxSize: number): Stream<T>;
+    getServices(uri: URI): LangiumCoreServices;
     /**
-     * Returns a stream containing only the distinct elements from this stream.
-     * Equality is determined with the same rules as a standard `Set`.
-     *
-     * @param by A function returning the key used to check equality with a previous stream element.
-     *        If omitted, the stream elements themselves are used for comparison.
+     * Check whether services are available for the given URI.
      */
-    distinct<Key = T>(by?: (element: T) => Key): Stream<T>;
+    hasServices(uri: URI): boolean;
     /**
-     * Returns a stream that contains all elements that don't exist in the {@link other} iterable.
-     * Equality is determined with the same rules as a standard `Set`.
-     * @param other The elements that should be exluded from this stream.
-     * @param key A function returning the key used to check quality.
-     *        If omitted, the stream elements themselves are used for comparison.
+     * The full set of registered language services.
      */
-    exclude<Key = T>(other: Iterable<T>, key?: (element: T) => Key): Stream<T>;
+    readonly all: readonly LangiumCoreServices[];
 }
-type FlatStream<T, Depth extends number> = {
-    'done': Stream<T>;
-    '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];
 
 /******************************************************************************
  * Copyright 2021 TypeFox GmbH
@@ -7849,7 +7906,7 @@ interface DocumentSegment {
  * No implementation object is expected to be offered by `LangiumCoreServices`, but only by `LangiumLSPServices`.
  */
 type TextDocumentProvider = {
-    get(uri: string): TextDocument | undefined;
+    get(uri: string | URI): TextDocument | undefined;
 };
 /**
  * Shared service for creating `LangiumDocument` instances.
@@ -8465,6 +8522,8 @@ interface Linker {
      *
      * @param document A LangiumDocument that shall be linked.
      * @param cancelToken A token for cancelling the operation.
+     *
+     * @throws `OperationCancelled` if a cancellation event is detected
      */
     link(document: LangiumDocument, cancelToken?: CancellationToken): Promise<void>;
     /**
@@ -8546,29 +8605,24 @@ declare class Deferred<T = void> {
  ******************************************************************************/
 
 /**
- * Async parser that allows to cancel the current parsing process.
- * The sync parser implementation is blocking the event loop, which can become quite problematic for large files.
+ * Async parser that allows cancellation of the current parsing process.
  *
- * Note that the default implementation is not actually async. It just wraps the sync parser in a promise.
- * A real implementation would create worker threads or web workers to offload the parsing work.
+ * @remark The sync parser implementation is blocking the event loop, which can become quite problematic for large files.
+ * @remark The default implementation is not actually async. It just wraps the sync parser in a promise. A real implementation would create worker threads or web workers to offload the parsing work.
  */
 interface AsyncParser {
+    /**
+     * Parses the given text and returns the parse result.
+     *
+     * @param text The text to parse.
+     * @param cancelToken A cancellation token that can be used to cancel the parsing process.
+     * @returns A promise that resolves to the parse result.
+     *
+     * @throw `OperationCancelled` if the parsing process is cancelled.
+     */
     parse<T extends AstNode>(text: string, cancelToken: CancellationToken): Promise<ParseResult<T>>;
 }
 
-/******************************************************************************
- * 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.
- ******************************************************************************/
-
-interface TokenBuilderOptions {
-    caseInsensitive?: boolean;
-}
-interface TokenBuilder {
-    buildTokens(grammar: Grammar, options?: TokenBuilderOptions): TokenVocabulary;
-}
-
 /******************************************************************************
  * Copyright 2021 TypeFox GmbH
  * This program and the accompanying materials are made available under the
@@ -8706,7 +8760,7 @@ declare class DefaultScopeComputation implements ScopeComputation {
      * @param document The document containing the AST node to be exported.
      * @param children A function called with {@link parentNode} as single argument and returning an {@link Iterable} supplying the children to be visited, which must be directly or transitively contained in {@link parentNode}.
      * @param cancelToken Indicates when to cancel the current operation.
-     * @throws `OperationCanceled` if a user action occurs during execution.
+     * @throws `OperationCancelled` if a user action occurs during execution.
      * @returns A list of {@link AstNodeDescription AstNodeDescriptions} to be published to index.
      */
     computeExportsForNode(parentNode: AstNode, document: LangiumDocument<AstNode>, children?: (root: AstNode) => Iterable<AstNode>, cancelToken?: CancellationToken): Promise<AstNodeDescription[]>;
@@ -8794,7 +8848,8 @@ 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;
 };
-type ValidationAcceptor = <N extends AstNode>(severity: 'error' | 'warning' | 'info' | 'hint', message: string, info: DiagnosticInfo<N>) => void;
+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>;
 /**
  * A utility type for associating non-primitive AST types to corresponding validation checks. For example:
@@ -8888,6 +8943,9 @@ interface DocumentValidator {
 }
 declare namespace DocumentValidator {
     const LexingError = "lexing-error";
+    const LexingWarning = "lexing-warning";
+    const LexingInfo = "lexing-info";
+    const LexingHint = "lexing-hint";
     const ParsingError = "parsing-error";
     const LinkingError = "linking-error";
 }
@@ -13548,6 +13606,9 @@ interface WorkspaceManager {
      * each language file and stores it locally.
      *
      * @param folders The set of workspace folders to be indexed.
+     * @param cancelToken A cancellation token that can be used to cancel the operation.
+     *
+     * @throws OperationCancelled if a cancellation event has been detected
      */
     initializeWorkspace(folders: WorkspaceFolder[], cancelToken?: CancellationToken): Promise<void>;
 }
@@ -13604,51 +13665,51 @@ declare class DefaultWorkspaceManager implements WorkspaceManager {
  * grammar definition and the language configuration.
  */
 type LangiumGeneratedCoreServices = {
-    Grammar: Grammar;
-    LanguageMetaData: LanguageMetaData;
-    parser: {
-        ParserConfig?: IParserConfig;
+    readonly Grammar: Grammar;
+    readonly LanguageMetaData: LanguageMetaData;
+    readonly parser: {
+        readonly ParserConfig?: IParserConfig;
     };
 };
 /**
  * Core services for a specific language of which Langium provides default implementations.
  */
 type LangiumDefaultCoreServices = {
-    parser: {
-        AsyncParser: AsyncParser;
-        GrammarConfig: GrammarConfig;
-        ValueConverter: ValueConverter;
-        LangiumParser: LangiumParser;
-        ParserErrorMessageProvider: IParserErrorMessageProvider;
-        CompletionParser: LangiumCompletionParser;
-        TokenBuilder: TokenBuilder;
-        Lexer: Lexer;
+    readonly parser: {
+        readonly AsyncParser: AsyncParser;
+        readonly GrammarConfig: GrammarConfig;
+        readonly ValueConverter: ValueConverter;
+        readonly LangiumParser: LangiumParser;
+        readonly ParserErrorMessageProvider: IParserErrorMessageProvider;
+        readonly CompletionParser: LangiumCompletionParser;
+        readonly TokenBuilder: TokenBuilder;
+        readonly Lexer: Lexer;
     };
-    documentation: {
-        CommentProvider: CommentProvider;
-        DocumentationProvider: DocumentationProvider;
+    readonly documentation: {
+        readonly CommentProvider: CommentProvider;
+        readonly DocumentationProvider: DocumentationProvider;
     };
-    references: {
-        Linker: Linker;
-        NameProvider: NameProvider;
-        References: References;
-        ScopeProvider: ScopeProvider;
-        ScopeComputation: ScopeComputation;
+    readonly references: {
+        readonly Linker: Linker;
+        readonly NameProvider: NameProvider;
+        readonly References: References;
+        readonly ScopeProvider: ScopeProvider;
+        readonly ScopeComputation: ScopeComputation;
     };
-    serializer: {
-        Hydrator: Hydrator;
-        JsonSerializer: JsonSerializer;
+    readonly serializer: {
+        readonly Hydrator: Hydrator;
+        readonly JsonSerializer: JsonSerializer;
     };
-    validation: {
-        DocumentValidator: DocumentValidator;
-        ValidationRegistry: ValidationRegistry;
+    readonly validation: {
+        readonly DocumentValidator: DocumentValidator;
+        readonly ValidationRegistry: ValidationRegistry;
     };
-    workspace: {
-        AstNodeLocator: AstNodeLocator;
-        AstNodeDescriptionProvider: AstNodeDescriptionProvider;
-        ReferenceDescriptionProvider: ReferenceDescriptionProvider;
+    readonly workspace: {
+        readonly AstNodeLocator: AstNodeLocator;
+        readonly AstNodeDescriptionProvider: AstNodeDescriptionProvider;
+        readonly ReferenceDescriptionProvider: ReferenceDescriptionProvider;
     };
-    shared: LangiumSharedCoreServices;
+    readonly shared: LangiumSharedCoreServices;
 };
 /**
  * The core set of services available for a language. These are either generated by `langium-cli`
@@ -13660,23 +13721,23 @@ type LangiumCoreServices = LangiumGeneratedCoreServices & LangiumDefaultCoreServ
  * derived from the grammar definition.
  */
 type LangiumGeneratedSharedCoreServices = {
-    AstReflection: AstReflection;
+    readonly AstReflection: AstReflection;
 };
 /**
  * Core services shared between multiple languages where Langium provides default implementations.
  */
 type LangiumDefaultSharedCoreServices = {
-    ServiceRegistry: ServiceRegistry;
-    workspace: {
-        ConfigurationProvider: ConfigurationProvider;
-        DocumentBuilder: DocumentBuilder;
-        FileSystemProvider: FileSystemProvider;
-        IndexManager: IndexManager;
-        LangiumDocuments: LangiumDocuments;
-        LangiumDocumentFactory: LangiumDocumentFactory;
-        TextDocuments?: TextDocumentProvider;
-        WorkspaceLock: WorkspaceLock;
-        WorkspaceManager: WorkspaceManager;
+    readonly ServiceRegistry: ServiceRegistry;
+    readonly workspace: {
+        readonly ConfigurationProvider: ConfigurationProvider;
+        readonly DocumentBuilder: DocumentBuilder;
+        readonly FileSystemProvider: FileSystemProvider;
+        readonly IndexManager: IndexManager;
+        readonly LangiumDocuments: LangiumDocuments;
+        readonly LangiumDocumentFactory: LangiumDocumentFactory;
+        readonly TextDocuments?: TextDocumentProvider;
+        readonly WorkspaceLock: WorkspaceLock;
+        readonly WorkspaceManager: WorkspaceManager;
     };
 };
 /**
@@ -13897,23 +13958,6 @@ interface DiagnosticFeatureShape {
     };
 }
 
-/**
- * We should use a mapped type to create this from Connection.
- */
-interface TextDocumentConnection {
-    onDidOpenTextDocument(handler: NotificationHandler<DidOpenTextDocumentParams>): Disposable$1;
-    onDidChangeTextDocument(handler: NotificationHandler<DidChangeTextDocumentParams>): Disposable$1;
-    onDidCloseTextDocument(handler: NotificationHandler<DidCloseTextDocumentParams>): Disposable$1;
-    onWillSaveTextDocument(handler: NotificationHandler<WillSaveTextDocumentParams>): Disposable$1;
-    onWillSaveTextDocumentWaitUntil(handler: RequestHandler<WillSaveTextDocumentParams, TextEdit$1[] | undefined | null, void>): Disposable$1;
-    onDidSaveTextDocument(handler: NotificationHandler<DidSaveTextDocumentParams>): Disposable$1;
-}
-interface TextDocumentsConfiguration<T extends {
-    uri: DocumentUri$1;
-}> {
-    create(uri: DocumentUri$1, languageId: string, version: number, content: string): T;
-    update(document: T, changes: TextDocumentContentChangeEvent[], version: number): T;
-}
 /**
  * Event to signal changes to a text document.
  */
@@ -13936,96 +13980,6 @@ interface TextDocumentWillSaveEvent<T> {
      */
     reason: TextDocumentSaveReason;
 }
-/**
- * A manager for simple text documents. The manager requires at a minimum that
- * the server registered for the following text document sync events in the
- * initialize handler or via dynamic registration:
- *
- * - open and close events.
- * - change events.
- *
- * Registering for save and will save events is optional.
- */
-declare class TextDocuments<T extends {
-    uri: DocumentUri$1;
-}> {
-    private readonly _configuration;
-    private readonly _syncedDocuments;
-    private readonly _onDidChangeContent;
-    private readonly _onDidOpen;
-    private readonly _onDidClose;
-    private readonly _onDidSave;
-    private readonly _onWillSave;
-    private _willSaveWaitUntil;
-    /**
-     * Create a new text document manager.
-     */
-    constructor(configuration: TextDocumentsConfiguration<T>);
-    /**
-     * An event that fires when a text document managed by this manager
-     * has been opened.
-     */
-    get onDidOpen(): Event<TextDocumentChangeEvent<T>>;
-    /**
-     * An event that fires when a text document managed by this manager
-     * has been opened or the content changes.
-     */
-    get onDidChangeContent(): Event<TextDocumentChangeEvent<T>>;
-    /**
-     * An event that fires when a text document managed by this manager
-     * will be saved.
-     */
-    get onWillSave(): Event<TextDocumentWillSaveEvent<T>>;
-    /**
-     * Sets a handler that will be called if a participant wants to provide
-     * edits during a text document save.
-     */
-    onWillSaveWaitUntil(handler: RequestHandler<TextDocumentWillSaveEvent<T>, TextEdit$1[], void>): void;
-    /**
-     * An event that fires when a text document managed by this manager
-     * has been saved.
-     */
-    get onDidSave(): Event<TextDocumentChangeEvent<T>>;
-    /**
-     * An event that fires when a text document managed by this manager
-     * has been closed.
-     */
-    get onDidClose(): Event<TextDocumentChangeEvent<T>>;
-    /**
-     * Returns the document for the given URI. Returns undefined if
-     * the document is not managed by this instance.
-     *
-     * @param uri The text document's URI to retrieve.
-     * @return the text document or `undefined`.
-     */
-    get(uri: string): T | undefined;
-    /**
-     * Returns all text documents managed by this instance.
-     *
-     * @return all text documents.
-     */
-    all(): T[];
-    /**
-     * Returns the URIs of all text documents managed by this instance.
-     *
-     * @return the URI's of all text documents.
-     */
-    keys(): string[];
-    /**
-     * Listens for `low level` notification on the given connection to
-     * update the text documents managed by this instance.
-     *
-     * Please note that the connection only provides handlers not an event model. Therefore
-     * listening on a connection will overwrite the following handlers on a connection:
-     * `onDidOpenTextDocument`, `onDidChangeTextDocument`, `onDidCloseTextDocument`,
-     * `onWillSaveTextDocument`, `onWillSaveTextDocumentWaitUntil` and `onDidSaveTextDocument`.
-     *
-     * Use the corresponding events on the TextDocuments instance instead.
-     *
-     * @param connection The connection to listen on.
-     */
-    listen(connection: TextDocumentConnection): Disposable$1;
-}
 
 /**
  * Shape of the notebooks feature
@@ -14819,6 +14773,11 @@ interface DefinitionProvider {
     /**
      * Handle a go to definition request.
      *
+     * @param document The document in which the request was triggered.
+     * @param params The parameters of the request.
+     * @param cancelToken A cancellation token that can be used to cancel the request.
+     * @returns A list of location links to the definition(s) of the symbol at the given position.
+     *
      * @throws `OperationCancelled` if cancellation is detected during execution
      * @throws `ResponseError` if an error is detected that should be sent as response to the client
      */
@@ -14838,6 +14797,10 @@ interface DocumentHighlightProvider {
     /**
      * Handle a document highlight request.
      *
+     * @param document The document in which the request was received.
+     * @param params The parameters of the document highlight request.
+     * @param cancelToken A cancellation token that can be used to cancel the request.
+     * @returns The document highlights or `undefined` if no highlights are available.
      * @throws `OperationCancelled` if cancellation is detected during execution
      * @throws `ResponseError` if an error is detected that should be sent as response to the client
      */
@@ -14848,7 +14811,7 @@ declare class DefaultDocumentHighlightProvider implements DocumentHighlightProvi
     protected readonly nameProvider: NameProvider;
     protected readonly grammarConfig: GrammarConfig;
     constructor(services: LangiumServices);
-    getDocumentHighlight(document: LangiumDocument, params: DocumentHighlightParams): MaybePromise<DocumentHighlight[] | undefined>;
+    getDocumentHighlight(document: LangiumDocument, params: DocumentHighlightParams, _cancelToken?: CancellationToken): MaybePromise<DocumentHighlight[] | undefined>;
     /**
     * Override this method to determine the highlight kind of the given reference.
     */
@@ -14911,6 +14874,11 @@ interface DocumentSymbolProvider {
     /**
      * Handle a document symbols request.
      *
+     * @param document The document in the workspace.
+     * @param params The parameters of the request.
+     * @param cancelToken A cancellation token that migh be used to cancel the request.
+     * @returns The symbols for the given document.
+     *
      * @throws `OperationCancelled` if cancellation is detected during execution
      * @throws `ResponseError` if an error is detected that should be sent as response to the client
      */
@@ -14927,17 +14895,40 @@ interface DocumentSymbolProvider {
  * Shared service for handling text document changes and watching relevant files.
  */
 interface DocumentUpdateHandler {
+    /**
+     * A document open event was triggered by the `TextDocuments` service.
+     * @param event The document change event.
+     */
     didOpenDocument?(event: TextDocumentChangeEvent<TextDocument>): void;
     /**
      * A content change event was triggered by the `TextDocuments` service.
+     * @param event The document change event.
      */
     didChangeContent?(event: TextDocumentChangeEvent<TextDocument>): void;
+    /**
+     * A document save event (initiated) was triggered by the `TextDocuments` service.
+     * @param event The document change event.
+     */
     willSaveDocument?(event: TextDocumentWillSaveEvent<TextDocument>): void;
+    /**
+     * A document save event (initiated) was triggered by the `TextDocuments` service.
+     * @param event The document change event.
+     * @returns An array of text edits which will be applied to the document before it is saved.
+     */
     willSaveDocumentWaitUntil?(event: TextDocumentWillSaveEvent<TextDocument>): MaybePromise<TextEdit$1[]>;
+    /**
+     * A document save event (completed) was triggered by the `TextDocuments` service.
+     * @param event The document change event.
+     */
     didSaveDocument?(event: TextDocumentChangeEvent<TextDocument>): void;
+    /**
+     * A document close event was triggered by the `TextDocuments` service.
+     * @param event The document change event.
+     */
     didCloseDocument?(event: TextDocumentChangeEvent<TextDocument>): void;
     /**
      * The client detected changes to files and folders watched by the language client.
+     * @param params The files/folders change event.
      */
     didChangeWatchedFiles?(params: DidChangeWatchedFilesParams): void;
 }
@@ -15019,6 +15010,11 @@ interface FoldingRangeProvider {
     /**
      * Handle a folding range request.
      *
+     * @param document The document to compute folding ranges for
+     * @param params The folding range parameters
+     * @param cancelToken A cancellation token that can be used to cancel the request
+     * @returns The computed folding ranges
+     *
      * @throws `OperationCancelled` if cancellation is detected during execution
      * @throws `ResponseError` if an error is detected that should be sent as response to the client
      */
@@ -15163,6 +15159,11 @@ interface ReferencesProvider {
     /**
      * Handle a find references request.
      *
+     * @param document The document in which to search for references.
+     * @param params The parameters of the find references request.
+     * @param cancelToken A cancellation token that can be used to cancel the request.
+     * @returns The locations of the references.
+     *
      * @throws `OperationCancelled` if cancellation is detected during execution
      * @throws `ResponseError` if an error is detected that should be sent as response to the client
      */
@@ -15182,6 +15183,11 @@ interface RenameProvider {
     /**
      * Handle a rename request.
      *
+     * @param document The document in which the rename request was triggered.
+     * @param params The rename parameters.
+     * @param cancelToken A cancellation token that can be used to cancel the request.
+     * @returns A workspace edit that describes the changes to be applied to the workspace.
+     *
      * @throws `OperationCancelled` if cancellation is detected during execution
      * @throws `ResponseError` if an error is detected that should be sent as response to the client
      */
@@ -15189,6 +15195,11 @@ interface RenameProvider {
     /**
      * Handle a prepare rename request.
      *
+     * @param document The document in which the prepare rename request was triggered.
+     * @param params The prepare rename parameters.
+     * @param cancelToken A cancellation token that can be used to cancel the request.
+     * @returns A range that describes the range of the symbol to be renamed.
+     *
      * @throws `OperationCancelled` if cancellation is detected during execution
      * @throws `ResponseError` if an error is detected that should be sent as response to the client
      */
@@ -15205,6 +15216,9 @@ interface SemanticTokenProvider {
     semanticHighlight(document: LangiumDocument, params: SemanticTokensParams, cancelToken?: CancellationToken): MaybePromise<SemanticTokens>;
     semanticHighlightRange(document: LangiumDocument, params: SemanticTokensRangeParams, cancelToken?: CancellationToken): MaybePromise<SemanticTokens>;
     semanticHighlightDelta(document: LangiumDocument, params: SemanticTokensDeltaParams, cancelToken?: CancellationToken): MaybePromise<SemanticTokens | SemanticTokensDelta>;
+    readonly tokenTypes: Record<string, number>;
+    readonly tokenModifiers: Record<string, number>;
+    readonly semanticTokensOptions: SemanticTokensOptions;
 }
 type SemanticTokenAcceptorOptions<N extends AstNode = AstNode> = ({
     line: number;
@@ -15280,6 +15294,9 @@ declare abstract class AbstractSemanticTokenProvider implements SemanticTokenPro
     protected clientCapabilities?: SemanticTokensClientCapabilities;
     constructor(services: LangiumServices);
     initialize(clientCapabilities?: SemanticTokensClientCapabilities): void;
+    get tokenTypes(): Record<string, number>;
+    get tokenModifiers(): Record<string, number>;
+    get semanticTokensOptions(): SemanticTokensOptions;
     semanticHighlight(document: LangiumDocument, _params: SemanticTokensParams, cancelToken?: CancellationToken): Promise<SemanticTokens>;
     semanticHighlightRange(document: LangiumDocument, params: SemanticTokensRangeParams, cancelToken?: CancellationToken): Promise<SemanticTokens>;
     semanticHighlightDelta(document: LangiumDocument, params: SemanticTokensDeltaParams, cancelToken?: CancellationToken): Promise<SemanticTokens | SemanticTokensDelta>;
@@ -15360,6 +15377,10 @@ interface WorkspaceSymbolProvider$1 {
     /**
      * Handle a workspace symbols request.
      *
+     * @param params workspaces symbols request parameters
+     * @param cancelToken a cancellation token tha can be used to cancel the request
+     * @returns a list of workspace symbols
+     *
      * @throws `OperationCancelled` if cancellation is detected during execution
      * @throws `ResponseError` if an error is detected that should be sent as response to the client
      */
@@ -15367,6 +15388,10 @@ interface WorkspaceSymbolProvider$1 {
     /**
      * Handle a resolve request for a workspace symbol.
      *
+     * @param symbol the workspace symbol to resolve
+     * @param cancelToken a cancellation token tha can be used to cancel the request
+     * @returns the resolved workspace symbol
+     *
      * @throws `OperationCancelled` if cancellation is detected during execution
      * @throws `ResponseError` if an error is detected that should be sent as response to the client
      */
@@ -15381,6 +15406,96 @@ declare class DefaultWorkspaceSymbolProvider implements WorkspaceSymbolProvider$
     protected getWorkspaceSymbol(astDescription: AstNodeDescription): WorkspaceSymbol | undefined;
 }
 
+/******************************************************************************
+ * Copyright 2024 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 manager service that keeps track of all currently opened text documents.
+ *
+ * Designed to be compatible with the `TextDocuments` class in the `vscode-languageserver` package.
+ */
+interface TextDocuments<T extends {
+    uri: string;
+}> {
+    /**
+     * An event that fires when a text document managed by this manager
+     * has been opened.
+     */
+    readonly onDidOpen: Event<TextDocumentChangeEvent<T>>;
+    /**
+     * An event that fires when a text document managed by this manager
+     * has been opened or the content changes.
+     */
+    readonly onDidChangeContent: Event<TextDocumentChangeEvent<T>>;
+    /**
+     * An event that fires when a text document managed by this manager
+     * will be saved.
+     */
+    readonly onWillSave: Event<TextDocumentWillSaveEvent<T>>;
+    /**
+     * Sets a handler that will be called if a participant wants to provide
+     * edits during a text document save.
+     */
+    onWillSaveWaitUntil(handler: RequestHandler<TextDocumentWillSaveEvent<T>, TextEdit$1[], void>): void;
+    /**
+     * An event that fires when a text document managed by this manager
+     * has been saved.
+     */
+    readonly onDidSave: Event<TextDocumentChangeEvent<T>>;
+    /**
+     * An event that fires when a text document managed by this manager
+     * has been closed.
+     */
+    readonly onDidClose: Event<TextDocumentChangeEvent<T>>;
+    /**
+     * Returns the document for the given URI. Returns undefined if
+     * the document is not managed by this instance.
+     *
+     * @param uri The text document's URI to retrieve.
+     * @return the text document or `undefined`.
+     */
+    get(uri: string | URI): T | undefined;
+    /**
+     * Sets the text document managed by this instance.
+     * @param document The text document to add.
+     * @returns `true` if the document didn't exist yet, `false` if it was already present.
+     */
+    set(document: T): boolean;
+    /**
+     * Deletes a text document managed by this instance.
+     */
+    delete(uri: string | URI | T): void;
+    /**
+     * Returns all text documents managed by this instance.
+     *
+     * @return all text documents.
+     */
+    all(): T[];
+    /**
+     * Returns the URIs of all text documents managed by this instance.
+     *
+     * @return the URI's of all text documents.
+     */
+    keys(): string[];
+    /**
+     * Listens for `low level` notification on the given connection to
+     * update the text documents managed by this instance.
+     *
+     * Please note that the connection only provides handlers not an event model. Therefore
+     * listening on a connection will overwrite the following handlers on a connection:
+     * `onDidOpenTextDocument`, `onDidChangeTextDocument`, `onDidCloseTextDocument`,
+     * `onWillSaveTextDocument`, `onWillSaveTextDocumentWaitUntil` and `onDidSaveTextDocument`.
+     *
+     * Use the corresponding events on the TextDocuments instance instead.
+     *
+     * @param connection The connection to listen on.
+     */
+    listen(connection: Connection): Disposable$1;
+}
+
 /******************************************************************************
  * Copyright 2023 TypeFox GmbH
  * This program and the accompanying materials are made available under the
@@ -15399,46 +15514,46 @@ type LangiumSharedServices = LangiumSharedCoreServices & LangiumSharedLSPService
  * LSP services for a specific language of which Langium provides default implementations.
  */
 type LangiumLSPServices = {
-    lsp: {
-        CompletionProvider?: CompletionProvider;
-        DocumentHighlightProvider?: DocumentHighlightProvider;
-        DocumentSymbolProvider?: DocumentSymbolProvider;
-        HoverProvider?: HoverProvider;
-        FoldingRangeProvider?: FoldingRangeProvider;
-        DefinitionProvider?: DefinitionProvider;
-        TypeProvider?: TypeDefinitionProvider;
-        ImplementationProvider?: ImplementationProvider;
-        ReferencesProvider?: ReferencesProvider;
-        CodeActionProvider?: CodeActionProvider;
-        SemanticTokenProvider?: SemanticTokenProvider;
-        RenameProvider?: RenameProvider;
-        Formatter?: Formatter;
-        SignatureHelp?: SignatureHelpProvider;
-        CallHierarchyProvider?: CallHierarchyProvider;
-        TypeHierarchyProvider?: TypeHierarchyProvider;
-        DeclarationProvider?: DeclarationProvider;
-        InlayHintProvider?: InlayHintProvider;
-        CodeLensProvider?: CodeLensProvider;
-        DocumentLinkProvider?: DocumentLinkProvider;
+    readonly lsp: {
+        readonly CompletionProvider?: CompletionProvider;
+        readonly DocumentHighlightProvider?: DocumentHighlightProvider;
+        readonly DocumentSymbolProvider?: DocumentSymbolProvider;
+        readonly HoverProvider?: HoverProvider;
+        readonly FoldingRangeProvider?: FoldingRangeProvider;
+        readonly DefinitionProvider?: DefinitionProvider;
+        readonly TypeProvider?: TypeDefinitionProvider;
+        readonly ImplementationProvider?: ImplementationProvider;
+        readonly ReferencesProvider?: ReferencesProvider;
+        readonly CodeActionProvider?: CodeActionProvider;
+        readonly SemanticTokenProvider?: SemanticTokenProvider;
+        readonly RenameProvider?: RenameProvider;
+        readonly Formatter?: Formatter;
+        readonly SignatureHelp?: SignatureHelpProvider;
+        readonly CallHierarchyProvider?: CallHierarchyProvider;
+        readonly TypeHierarchyProvider?: TypeHierarchyProvider;
+        readonly DeclarationProvider?: DeclarationProvider;
+        readonly InlayHintProvider?: InlayHintProvider;
+        readonly CodeLensProvider?: CodeLensProvider;
+        readonly DocumentLinkProvider?: DocumentLinkProvider;
     };
-    shared: LangiumSharedServices;
+    readonly shared: LangiumSharedServices;
 };
 /**
  * LSP services shared between multiple languages of which Langium provides default implementations.
  */
 type LangiumSharedLSPServices = {
-    lsp: {
-        Connection?: Connection;
-        DocumentUpdateHandler: DocumentUpdateHandler;
-        ExecuteCommandHandler?: ExecuteCommandHandler;
-        FileOperationHandler?: FileOperationHandler;
-        FuzzyMatcher: FuzzyMatcher;
-        LanguageServer: LanguageServer;
-        NodeKindProvider: NodeKindProvider$1;
-        WorkspaceSymbolProvider?: WorkspaceSymbolProvider$1;
+    readonly lsp: {
+        readonly Connection?: Connection;
+        readonly DocumentUpdateHandler: DocumentUpdateHandler;
+        readonly ExecuteCommandHandler?: ExecuteCommandHandler;
+        readonly FileOperationHandler?: FileOperationHandler;
+        readonly FuzzyMatcher: FuzzyMatcher;
+        readonly LanguageServer: LanguageServer;
+        readonly NodeKindProvider: NodeKindProvider$1;
+        readonly WorkspaceSymbolProvider?: WorkspaceSymbolProvider$1;
     };
-    workspace: {
-        TextDocuments: TextDocuments<TextDocument>;
+    readonly workspace: {
+        readonly TextDocuments: TextDocuments<TextDocument>;
     };
 };
 
@@ -15533,6 +15648,10 @@ interface CompletionProvider {
     /**
      * Handle a completion request.
      *
+     * @param document - the document for which the completion request was triggered
+     * @param params - the completion parameters
+     * @param cancelToken - a token that can be used to cancel the request
+     *
      * @throws `OperationCancelled` if cancellation is detected during execution
      * @throws `ResponseError` if an error is detected that should be sent as response to the client
      */
@@ -15555,8 +15674,9 @@ declare class DefaultCompletionProvider implements CompletionProvider {
     protected readonly fuzzyMatcher: FuzzyMatcher;
     protected readonly grammarConfig: GrammarConfig;
     protected readonly astReflection: AstReflection;
+    readonly completionOptions?: CompletionProviderOptions;
     constructor(services: LangiumServices);
-    getCompletion(document: LangiumDocument, params: CompletionParams): Promise<CompletionList | undefined>;
+    getCompletion(document: LangiumDocument, params: CompletionParams, _cancelToken?: CancellationToken): Promise<CompletionList | undefined>;
     /**
      * The completion algorithm could yield the same reference/keyword multiple times.
      *
@@ -15620,7 +15740,7 @@ interface ChangeViewRequestParams {
 }
 
 /******************************************************************************
- * This file was generated by langium-cli 3.1.1.
+ * This file was generated by langium-cli 3.2.0.
  * DO NOT EDIT MANUALLY!
  ******************************************************************************/