likec4 1.9.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;
@@ -208,6 +208,7 @@ type Tag$2 = Tagged$1<string, 'Tag'>;
 interface Link {
     readonly title?: string;
     readonly url: string;
+    readonly relative?: string;
 }
 interface Element$1 {
     readonly id: Fqn$1;
@@ -270,37 +271,6 @@ type OrOperator<Tag, Kind> = Omit<AllNever, 'or'> & {
 };
 type WhereOperator<Tag, Kind> = TagEqual<Tag> | KindEqual<Kind> | NotOperator<Tag, Kind> | AndOperator<Tag, Kind> | OrOperator<Tag, Kind>;
 
-type RelationID$1 = Tagged$1<string, 'RelationID'>;
-type RelationshipKind$1 = Tagged$1<string, 'RelationshipKind'>;
-type RelationshipLineType = 'dashed' | 'solid' | 'dotted';
-type RelationshipArrowType = 'none' | 'normal' | 'onormal' | 'dot' | 'odot' | 'diamond' | 'odiamond' | 'crow' | 'open' | 'vee';
-interface Relation$1 {
-    readonly id: RelationID$1;
-    readonly source: Fqn$1;
-    readonly target: Fqn$1;
-    readonly title: string;
-    readonly description?: string;
-    readonly technology?: string;
-    readonly tags?: NonEmptyArray<Tag$2>;
-    readonly kind?: RelationshipKind$1;
-    readonly color?: Color$1;
-    readonly line?: RelationshipLineType;
-    readonly head?: RelationshipArrowType;
-    readonly tail?: RelationshipArrowType;
-    readonly links?: NonEmptyArray<Link>;
-    readonly metadata?: {
-        [key: string]: string;
-    };
-}
-interface RelationshipKindSpecification {
-    readonly technology?: string;
-    readonly notation?: string;
-    readonly color?: Color$1;
-    readonly line?: RelationshipLineType;
-    readonly head?: RelationshipArrowType;
-    readonly tail?: RelationshipArrowType;
-}
-
 type ElementNotation = {
     kinds: ElementKind$1[];
     shape: ElementShape$1;
@@ -375,31 +345,37 @@ interface DynamicViewStep$1 {
     readonly description?: string;
     readonly technology?: string;
     readonly notation?: string;
+    readonly notes?: string;
     readonly color?: Color$1;
     readonly line?: RelationshipLineType;
     readonly head?: RelationshipArrowType;
     readonly tail?: RelationshipArrowType;
     readonly isBackward?: boolean;
+    readonly navigateTo?: ViewID$1;
+    __parallel?: never;
 }
+interface DynamicViewParallelSteps$1 {
+    readonly __parallel: DynamicViewStep$1[];
+}
+type DynamicViewStepOrParallel = DynamicViewStep$1 | DynamicViewParallelSteps$1;
 type DynamicViewIncludeRule = {
     include: ElementPredicateExpression[];
 };
 type DynamicViewRule$1 = DynamicViewIncludeRule | ViewRuleStyle$1 | ViewRuleAutoLayout$1;
 interface DynamicView$1 extends BasicView<'dynamic'> {
     readonly __: 'dynamic';
-    readonly steps: DynamicViewStep$1[];
+    readonly steps: DynamicViewStepOrParallel[];
     readonly rules: DynamicViewRule$1[];
 }
 type CustomColorDefinitions = {
     [key: string]: ThemeColorValues;
 };
 type LikeC4View$1 = ElementView$1 | DynamicView$1;
-declare function isDynamicView(view: LikeC4View$1): view is DynamicView$1;
 type NodeId = Tagged$1<string, 'Fqn'>;
 type EdgeId$1 = Tagged$1<string, 'EdgeId'>;
-type StepEdgeIdLiteral = `step-${number}`;
+type StepEdgeIdLiteral = `step-${number}` | `step-${number}.${number}`;
 type StepEdgeId = Tagged$1<StepEdgeIdLiteral, 'EdgeId'>;
-declare function StepEdgeId(step: number): StepEdgeId;
+declare function StepEdgeId(step: number, parallelStep?: number): StepEdgeId;
 declare function isStepEdgeId(id: string): id is StepEdgeId;
 declare function extractStep(id: EdgeId$1): number;
 interface ComputedNode {
@@ -443,11 +419,14 @@ interface ComputedEdge {
     technology?: string;
     relations: RelationID$1[];
     kind?: RelationshipKind$1;
+    notation?: string;
+    notes?: string;
     color?: Color$1;
     line?: RelationshipLineType;
     head?: RelationshipArrowType;
     tail?: RelationshipArrowType;
     tags?: NonEmptyArray<Tag$2>;
+    navigateTo?: ViewID$1;
     /**
      * If this edge is derived from custom relationship predicate
      */
@@ -539,6 +518,38 @@ type ViewManualLayout = {
     }>;
 };
 
+type RelationID$1 = Tagged$1<string, 'RelationID'>;
+type RelationshipKind$1 = Tagged$1<string, 'RelationshipKind'>;
+type RelationshipLineType = 'dashed' | 'solid' | 'dotted';
+type RelationshipArrowType = 'none' | 'normal' | 'onormal' | 'dot' | 'odot' | 'diamond' | 'odiamond' | 'crow' | 'open' | 'vee';
+interface Relation$1 {
+    readonly id: RelationID$1;
+    readonly source: Fqn$1;
+    readonly target: Fqn$1;
+    readonly title: string;
+    readonly description?: string;
+    readonly technology?: string;
+    readonly tags?: NonEmptyArray<Tag$2>;
+    readonly kind?: RelationshipKind$1;
+    readonly color?: Color$1;
+    readonly line?: RelationshipLineType;
+    readonly head?: RelationshipArrowType;
+    readonly tail?: RelationshipArrowType;
+    readonly links?: NonEmptyArray<Link>;
+    readonly navigateTo?: ViewID$1;
+    readonly metadata?: {
+        [key: string]: string;
+    };
+}
+interface RelationshipKindSpecification {
+    readonly technology?: string;
+    readonly notation?: string;
+    readonly color?: Color$1;
+    readonly line?: RelationshipLineType;
+    readonly head?: RelationshipArrowType;
+    readonly tail?: RelationshipArrowType;
+}
+
 interface BaseExpr {
     where?: never;
     element?: never;
@@ -625,6 +636,8 @@ interface CustomRelationExpr extends Omit<BaseExpr, 'customRelation'> {
         description?: string;
         technology?: string;
         notation?: string;
+        navigateTo?: ViewID$1;
+        notes?: string;
         color?: Color$1;
         line?: RelationshipLineType;
         head?: RelationshipArrowType;
@@ -715,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";
@@ -1390,49 +1251,222 @@ declare function ancestorsFqn(fqn: Fqn$1): Fqn$1[];
  *                    - Positive number if a is deeper than b.
  *                    - Negative number if b is deeper than a.
  */
-declare function compareFqnHierarchically<T extends string = string>(a: T, b: T): number;
+declare function compareFqnHierarchically<T extends string = string>(a: T, b: T): -1 | 0 | 1;
 declare function compareByFqnHierarchically<T extends {
     id: string;
-}>(a: T, b: T): number;
+}>(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
+@category Type
+*/
+type Primitive =
+	| null
+	| undefined
+	| string
+	| number
+	| boolean
+	| symbol
+	| bigint;
+
+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;
+
+/**
+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
@@ -1479,7 +1513,7 @@ declare function hasAtLeast(minimum: number): (data: IterableContainer) => boole
 declare const compareRelations: <T extends {
     source: string;
     target: string;
-}>(a: T, b: T) => number;
+}>(a: T, b: T) => 0 | 1 | -1;
 
 /**
  * A tagging type for string properties that are actually document URIs.
@@ -6703,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!
  ******************************************************************************/
 
@@ -7156,28 +7190,284 @@ 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.
+     * 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.
      *
-     * Note that Langium requires the optional properties
-     * `startLine`, `startColumn`, `endOffset`, `endLine` and `endColumn` to be set on each token.
+     * @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.
      */
-    tokens: IToken[];
+    toMap<K = T, V = T>(keyFn?: (e: T) => K, valueFn?: (e: T) => V): Map<K, V>;
     /**
-     * Contains hidden tokens, usually comments.
+     * Returns a string representation of a stream.
      */
-    hidden: IToken[];
-    errors: ILexingError[];
-}
+    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[];
+    /**
+     * Contains hidden tokens, usually comments.
+     */
+    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;
 }
 
 /******************************************************************************
@@ -7190,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>;
@@ -7372,248 +7663,27 @@ declare class ChevrotainWrapper extends EmbeddedActionsParser {
 
 /**
  * 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;
+ * 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
@@ -7836,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.
@@ -8452,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>;
     /**
@@ -8533,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
@@ -8693,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[]>;
@@ -8781,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:
@@ -8875,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";
 }
@@ -13535,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>;
 }
@@ -13591,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`
@@ -13647,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;
     };
 };
 /**
@@ -13884,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.
  */
@@ -13923,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
@@ -14806,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
      */
@@ -14825,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
      */
@@ -14835,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.
     */
@@ -14898,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
      */
@@ -14914,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;
 }
@@ -15006,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
      */
@@ -15150,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
      */
@@ -15169,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
      */
@@ -15176,21 +15195,16 @@ 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
      */
     prepareRename(document: LangiumDocument, params: TextDocumentPositionParams, cancelToken?: CancellationToken): MaybePromise<Range$1 | undefined>;
 }
-declare class DefaultRenameProvider implements RenameProvider {
-    protected readonly references: References;
-    protected readonly nameProvider: NameProvider;
-    protected readonly grammarConfig: GrammarConfig;
-    constructor(services: LangiumServices);
-    rename(document: LangiumDocument, params: RenameParams): Promise<WorkspaceEdit | undefined>;
-    prepareRename(document: LangiumDocument, params: TextDocumentPositionParams): MaybePromise<Range$1 | undefined>;
-    protected renameNodeRange(doc: LangiumDocument, position: Position$2): Range$1 | undefined;
-    protected isNameNode(leafNode: CstNode | undefined): boolean | undefined;
-}
 
 /******************************************************************************
  * Copyright 2022 TypeFox GmbH
@@ -15202,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;
@@ -15277,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>;
@@ -15357,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
      */
@@ -15364,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
      */
@@ -15378,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
@@ -15396,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>;
     };
 };
 
@@ -15530,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
      */
@@ -15552,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.
      *
@@ -15617,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!
  ******************************************************************************/
 
@@ -15651,11 +15774,11 @@ type RelationPredicate = RelationPredicateOrWhere | RelationPredicateWith;
 declare const RelationPredicate = "RelationPredicate";
 type RelationPredicateOrWhere = RelationExpression | RelationPredicateWhere;
 declare const RelationPredicateOrWhere = "RelationPredicateOrWhere";
-type RelationProperty = LinkProperty | MetadataProperty | RelationStringProperty | RelationStyleProperty;
+type RelationProperty = LinkProperty | MetadataProperty | RelationNavigateToProperty | RelationStringProperty | RelationStyleProperty;
 declare const RelationProperty = "RelationProperty";
 type RelationshipStyleProperty = ArrowProperty | ColorProperty | LineProperty;
 declare const RelationshipStyleProperty = "RelationshipStyleProperty";
-type StringProperty = ElementStringProperty | MetadataAttribute | NotationProperty | RelationStringProperty | SpecificationElementStringProperty | SpecificationRelationshipStringProperty | ViewStringProperty;
+type StringProperty = ElementStringProperty | MetadataAttribute | NotationProperty | NotesProperty | RelationStringProperty | SpecificationElementStringProperty | SpecificationRelationshipStringProperty | ViewStringProperty;
 declare const StringProperty = "StringProperty";
 type StyleProperty = BorderProperty | ColorProperty | IconProperty | OpacityProperty | ShapeProperty;
 declare const StyleProperty = "StyleProperty";
@@ -15719,7 +15842,7 @@ declare const CustomElementProperties = "CustomElementProperties";
 interface CustomRelationProperties extends AstNode {
     readonly $container: DynamicViewStep | RelationPredicateWith;
     readonly $type: 'CustomRelationProperties';
-    props: Array<NotationProperty | RelationStringProperty | RelationshipStyleProperty>;
+    props: Array<NotationProperty | NotesProperty | RelationNavigateToProperty | RelationStringProperty | RelationshipStyleProperty>;
 }
 declare const CustomRelationProperties = "CustomRelationProperties";
 interface DirectedRelationExpression extends AstNode {
@@ -15741,7 +15864,7 @@ interface DynamicViewBody extends AstNode {
     readonly $type: 'DynamicViewBody';
     props: Array<ViewProperty>;
     rules: Array<DynamicViewRule>;
-    steps: Array<DynamicViewStep>;
+    steps: Array<DynamicViewParallelSteps | DynamicViewStep>;
     tags?: Tags;
 }
 declare const DynamicViewBody = "DynamicViewBody";
@@ -15751,6 +15874,12 @@ interface DynamicViewIncludePredicate extends AstNode {
     predicates: DynamicViewPredicateIterator;
 }
 declare const DynamicViewIncludePredicate = "DynamicViewIncludePredicate";
+interface DynamicViewParallelSteps extends AstNode {
+    readonly $container: DynamicViewBody;
+    readonly $type: 'DynamicViewParallelSteps';
+    steps: Array<DynamicViewStep>;
+}
+declare const DynamicViewParallelSteps = "DynamicViewParallelSteps";
 interface DynamicViewPredicateIterator extends AstNode {
     readonly $container: DynamicViewIncludePredicate | DynamicViewPredicateIterator;
     readonly $type: 'DynamicViewPredicateIterator';
@@ -15758,8 +15887,14 @@ interface DynamicViewPredicateIterator extends AstNode {
     value: ElementPredicate;
 }
 declare const DynamicViewPredicateIterator = "DynamicViewPredicateIterator";
+interface DynamicViewRef extends AstNode {
+    readonly $container: RelationNavigateToProperty;
+    readonly $type: 'DynamicViewRef';
+    view: Reference<DynamicView>;
+}
+declare const DynamicViewRef = "DynamicViewRef";
 interface DynamicViewStep extends AstNode {
-    readonly $container: DynamicViewBody;
+    readonly $container: DynamicViewBody | DynamicViewParallelSteps;
     readonly $type: 'DynamicViewStep';
     custom?: CustomRelationProperties;
     isBackward: boolean;
@@ -16011,6 +16146,13 @@ interface NotationProperty extends AstNode {
     value: string;
 }
 declare const NotationProperty = "NotationProperty";
+interface NotesProperty extends AstNode {
+    readonly $container: CustomRelationProperties;
+    readonly $type: 'NotesProperty';
+    key: 'notes';
+    value: string;
+}
+declare const NotesProperty = "NotesProperty";
 interface OpacityProperty extends AstNode {
     readonly $container: CustomElementProperties | ElementStyleProperty | ViewRuleStyle;
     readonly $type: 'OpacityProperty';
@@ -16052,6 +16194,13 @@ interface RelationBody extends AstNode {
     tags?: Tags;
 }
 declare const RelationBody = "RelationBody";
+interface RelationNavigateToProperty extends AstNode {
+    readonly $container: CustomRelationProperties | RelationBody;
+    readonly $type: 'RelationNavigateToProperty';
+    key: 'navigateTo';
+    value: DynamicViewRef;
+}
+declare const RelationNavigateToProperty = "RelationNavigateToProperty";
 interface RelationPredicateWhere extends AstNode {
     readonly $container: Predicates | RelationPredicateWith;
     readonly $type: 'RelationPredicateWhere';
@@ -16252,7 +16401,9 @@ type LikeC4AstType = {
     DynamicView: DynamicView;
     DynamicViewBody: DynamicViewBody;
     DynamicViewIncludePredicate: DynamicViewIncludePredicate;
+    DynamicViewParallelSteps: DynamicViewParallelSteps;
     DynamicViewPredicateIterator: DynamicViewPredicateIterator;
+    DynamicViewRef: DynamicViewRef;
     DynamicViewRule: DynamicViewRule;
     DynamicViewStep: DynamicViewStep;
     Element: Element;
@@ -16296,6 +16447,7 @@ type LikeC4AstType = {
     ModelViews: ModelViews;
     NavigateToProperty: NavigateToProperty;
     NotationProperty: NotationProperty;
+    NotesProperty: NotesProperty;
     OpacityProperty: OpacityProperty;
     OutgoingRelationExpression: OutgoingRelationExpression;
     Predicate: Predicate;
@@ -16303,6 +16455,7 @@ type LikeC4AstType = {
     Relation: Relation;
     RelationBody: RelationBody;
     RelationExpression: RelationExpression;
+    RelationNavigateToProperty: RelationNavigateToProperty;
     RelationPredicate: RelationPredicate;
     RelationPredicateOrWhere: RelationPredicateOrWhere;
     RelationPredicateWhere: RelationPredicateWhere;
@@ -16415,6 +16568,7 @@ interface ParsedAstRelation {
     head?: RelationshipArrowType;
     tail?: RelationshipArrowType;
     links?: NonEmptyArray<ParsedLink>;
+    navigateTo?: ViewID$1;
     metadata?: {
         [key: string]: string;
     };
@@ -16440,7 +16594,7 @@ interface ParsedAstDynamicView {
     description: string | null;
     tags: NonEmptyArray<Tag$2> | null;
     links: NonEmptyArray<ParsedLink> | null;
-    steps: DynamicViewStep$1[];
+    steps: DynamicViewStepOrParallel[];
     rules: Array<DynamicViewRule$1>;
     manualLayout?: ViewManualLayout;
 }
@@ -16493,6 +16647,7 @@ declare class LikeC4DocumentLinkProvider implements DocumentLinkProvider {
     constructor(services: LikeC4Services);
     getDocumentLinks(doc: LangiumDocument, _params: DocumentLinkParams): MaybePromise<DocumentLink[]>;
     resolveLink(doc: LangiumDocument, link: string): string;
+    relativeLink(doc: LangiumDocument, link: string): string | null;
 }
 
 declare class LikeC4DocumentSymbolProvider implements DocumentSymbolProvider {
@@ -16520,10 +16675,6 @@ declare class LikeC4HoverProvider extends AstNodeHoverProvider {
     protected getAstNodeHoverContent(node: AstNode): MaybePromise<Hover | undefined>;
 }
 
-declare class LikeC4RenameProvider extends DefaultRenameProvider {
-    constructor(services: LikeC4Services);
-}
-
 declare class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
     protected highlightElement(node: AstNode, acceptor: SemanticTokenAcceptor): void | undefined | 'prune';
     private highlightAstElement;
@@ -16631,7 +16782,6 @@ interface LikeC4AddedServices {
         ModelChanges: LikeC4ModelChanges;
     };
     lsp: {
-        RenameProvider: LikeC4RenameProvider;
         CompletionProvider: LikeC4CompletionProvider;
         DocumentHighlightProvider: LikeC4DocumentHighlightProvider;
         DocumentSymbolProvider: LikeC4DocumentSymbolProvider;
@@ -16729,6 +16879,7 @@ declare class LikeC4ModelParser {
     private parseRelationExpr;
     private parseViewRule;
     private parseViewManualLaout;
+    private parseDynamicParallelSteps;
     private parseDynamicStep;
     private parseElementView;
     private parseDynamicElementView;
@@ -17357,7 +17508,7 @@ declare class CliWorkspace {
     private services;
     private isInitialized;
     constructor(services: CliServices);
-    initForWorkspace(workspacePath: string): Promise<void>;
+    initWorkspace(workspace: WorkspaceFolder): Promise<void>;
     init(): Promise<void>;
 }
 
@@ -17462,4 +17613,4 @@ declare class LikeC4 {
     dispose(): void;
 }
 
-export { type AutoLayoutDirection, type BBox, BorderStyles, type Color$1 as Color, type ComputedDynamicView, type ComputedEdge, type ComputedElementView, type ComputedLikeC4Model, type ComputedNode, type ComputedView, type DiagramEdge, type DiagramNode, type DiagramView, type DynamicView$1 as DynamicView, type EdgeId$1 as EdgeId, type Element$1 as Element, ElementColors, type ElementKind$1 as ElementKind, ElementShapes, type ElementView$1 as ElementView, type Fqn$1 as Fqn, type HexColorLiteral, LikeC4, LikeC4Model, type LikeC4View$1 as LikeC4View, LikeC4ViewModel, type NodeId, type ParsedLikeC4Model, type Point, type Relation$1 as Relation, type RelationExpr, type RelationID$1 as RelationID, RelationshipColors, StepEdgeId, type Tag$2 as Tag, type ThemeColor$1 as ThemeColor, type ViewID$1 as ViewID, type XYPoint, ancestorsFqn, commonAncestor, compareByFqnHierarchically, compareFqnHierarchically, compareRelations, defaultTheme, extractStep, hasAtLeast, invariant, isAncestor, isComputedDynamicView, isDescendantOf, isDynamicView, isSameHierarchy, isStepEdgeId, nameFromFqn, nonNullable, nonexhaustive, notDescendantOf, parentFqn };
+export { type AutoLayoutDirection, type BBox, BorderStyles, type Color$1 as Color, type ComputedDynamicView, type ComputedEdge, type ComputedElementView, type ComputedLikeC4Model, type ComputedNode, type ComputedView, type DiagramEdge, type DiagramNode, type DiagramView, type DynamicView$1 as DynamicView, type EdgeId$1 as EdgeId, type Element$1 as Element, ElementColors, type ElementKind$1 as ElementKind, ElementShapes, type ElementView$1 as ElementView, type Fqn$1 as Fqn, type HexColorLiteral, LikeC4, LikeC4Model, type LikeC4View$1 as LikeC4View, LikeC4ViewModel, type NodeId, type ParsedLikeC4Model, type Point, type Relation$1 as Relation, type RelationExpr, type RelationID$1 as RelationID, RelationshipColors, StepEdgeId, type Tag$2 as Tag, type ThemeColor$1 as ThemeColor, type ViewID$1 as ViewID, type XYPoint, ancestorsFqn, commonAncestor, compareByFqnHierarchically, compareFqnHierarchically, compareRelations, defaultTheme, extractStep, hasAtLeast, invariant, isAncestor, isComputedDynamicView, isDescendantOf, isSameHierarchy, isStepEdgeId, nameFromFqn, nonNullable, nonexhaustive, notDescendantOf, parentFqn };