likec4 1.10.0 → 1.11.0

package/dist/index.d.mts

@@ -1,168 +1,4 @@
-/**
-Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive).
-
-@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;
-	}
-}
-
-/**
-Allows creating a union type by combining primitive types and literal types without sacrificing auto-completion in IDEs for the literal type part of the union.
-
-Currently, when a union type of a primitive type is combined with literal types, TypeScript loses all information about the combined literals. Thus, when such type is used in an IDE with autocompletion, no suggestions are made for the declared literals.
-
-This type is a workaround for [Microsoft/TypeScript#29729](https://github.com/Microsoft/TypeScript/issues/29729). It will be removed as soon as it's not needed anymore.
-
-@example
-```
-import type {LiteralUnion} from 'type-fest';
-
-// Before
-
-type Pet = 'dog' | 'cat' | string;
-
-const pet: Pet = '';
-// Start typing in your TypeScript-enabled IDE.
-// You **will not** get auto-completion for `dog` and `cat` literals.
-
-// After
-
-type Pet2 = LiteralUnion<'dog' | 'cat', string>;
-
-const pet: Pet2 = '';
-// You **will** get auto-completion for `dog` and `cat` literals.
-```
-
-@category Type
-*/
-type LiteralUnion<
-	LiteralType,
-	BaseType extends Primitive,
-> = LiteralType | (BaseType & Record<never, never>);
-
-declare const tag$1: unique symbol;
-
-type TagContainer$1<Token> = {
-	readonly [tag$1]: Token;
-};
-
-type Tag$1$1<Token extends PropertyKey, TagMetadata> = TagContainer$1<{[K in Token]: TagMetadata}>;
-
-/**
-Attach a "tag" to an arbitrary type. This allows you to create distinct types, that aren't assignable to one another, for distinct concepts in your program that should not be interchangeable, even if their runtime values have the same type. (See examples.)
-
-A type returned by `Tagged` can be passed to `Tagged` again, to create a type with multiple tags.
-
-[Read more about tagged types.](https://medium.com/@KevinBGreene/surviving-the-typescript-ecosystem-branding-and-type-tagging-6cf6e516523d)
-
-A tag's name is usually a string (and must be a string, number, or symbol), but each application of a tag can also contain an arbitrary type as its "metadata". See {@link GetTagMetadata} for examples and explanation.
-
-A type `A` returned by `Tagged` is assignable to another type `B` returned by `Tagged` if and only if:
-  - the underlying (untagged) type of `A` is assignable to the underlying type of `B`;
-	- `A` contains at least all the tags `B` has;
-	- and the metadata type for each of `A`'s tags is assignable to the metadata type of `B`'s corresponding tag.
-
-There have been several discussions about adding similar features to TypeScript. Unfortunately, nothing has (yet) moved forward:
-	- [Microsoft/TypeScript#202](https://github.com/microsoft/TypeScript/issues/202)
-	- [Microsoft/TypeScript#4895](https://github.com/microsoft/TypeScript/issues/4895)
-	- [Microsoft/TypeScript#33290](https://github.com/microsoft/TypeScript/pull/33290)
-
-@example
-```
-import type {Tagged} from 'type-fest';
-
-type AccountNumber = Tagged<number, 'AccountNumber'>;
-type AccountBalance = Tagged<number, 'AccountBalance'>;
-
-function createAccountNumber(): AccountNumber {
-	// As you can see, casting from a `number` (the underlying type being tagged) is allowed.
-	return 2 as AccountNumber;
-}
-
-function getMoneyForAccount(accountNumber: AccountNumber): AccountBalance {
-	return 4 as AccountBalance;
-}
-
-// This will compile successfully.
-getMoneyForAccount(createAccountNumber());
-
-// But this won't, because it has to be explicitly passed as an `AccountNumber` type!
-// Critically, you could not accidentally use an `AccountBalance` as an `AccountNumber`.
-getMoneyForAccount(2);
-
-// You can also use tagged values like their underlying, untagged type.
-// I.e., this will compile successfully because an `AccountNumber` can be used as a regular `number`.
-// In this sense, the underlying base type is not hidden, which differentiates tagged types from opaque types in other languages.
-const accountNumber = createAccountNumber() + 2;
-```
-
-@example
-```
-import type {Tagged} from 'type-fest';
-
-// You can apply multiple tags to a type by using `Tagged` repeatedly.
-type Url = Tagged<string, 'URL'>;
-type SpecialCacheKey = Tagged<Url, 'SpecialCacheKey'>;
-
-// You can also pass a union of tag names, so this is equivalent to the above, although it doesn't give you the ability to assign distinct metadata to each tag.
-type SpecialCacheKey2 = Tagged<string, 'URL' | 'SpecialCacheKey'>;
-```
-
-@category Type
-*/
-type Tagged$1<Type, TagName extends PropertyKey, TagMetadata = never> = Type & Tag$1$1<TagName, TagMetadata>;
-
-/**
-Revert a tagged type back to its original type by removing all tags.
-
-Why is this necessary?
-
-1. Use a `Tagged` type as object keys
-2. Prevent TS4058 error: "Return type of exported function has or is using name X from external module Y but cannot be named"
-
-@example
-```
-import type {Tagged, UnwrapTagged} from 'type-fest';
-
-type AccountType = Tagged<'SAVINGS' | 'CHECKING', 'AccountType'>;
-
-const moneyByAccountType: Record<UnwrapTagged<AccountType>, number> = {
-	SAVINGS: 99,
-	CHECKING: 0.1
-};
-
-// Without UnwrapTagged, the following expression would throw a type error.
-const money = moneyByAccountType.SAVINGS; // TS error: Property 'SAVINGS' does not exist
-
-// Attempting to pass an non-Tagged type to UnwrapTagged will raise a type error.
-type WontWork = UnwrapTagged<string>;
-```
-
-@category Type
-*/
-type UnwrapTagged<TaggedType extends Tag$1$1<PropertyKey, any>> =
-RemoveAllTags<TaggedType>;
-
-type RemoveAllTags<T> = T extends Tag$1$1<PropertyKey, any>
-	? {
-		[ThisTag in keyof T[typeof tag$1]]: T extends Tagged$1<infer Type, ThisTag, T[typeof tag$1][ThisTag]>
-			? RemoveAllTags<Type>
-			: never
-	}[keyof T[typeof tag$1]]
-	: T;
+import { LiteralUnion, Tagged, UnwrapTagged, IsNumericLiteral, SetRequired, ValueOf, ConditionalPick } from 'type-fest';
 
 declare const ThemeColors: readonly ["amber", "blue", "gray", "slate", "green", "indigo", "muted", "primary", "red", "secondary", "sky"];
 type ThemeColor$1 = typeof ThemeColors[number];
@@ -186,7 +22,7 @@ interface ThemeColorValues {
 }
 
 type NonEmptyArray<T> = [T, ...T[]];
-type IconUrl = Tagged$1<string, 'IconUrl'>;
+type IconUrl = Tagged<string, 'IconUrl'>;
 type CustomColor$1 = string;
 type Point = readonly [x: number, y: number];
 interface XYPoint {
@@ -194,17 +30,17 @@ interface XYPoint {
     y: number;
 }
 
-type Fqn$1 = Tagged$1<string, 'Fqn'>;
+type Fqn$1 = Tagged<string, 'Fqn'>;
 declare const BorderStyles: readonly ["solid", "dashed", "dotted", "none"];
 type BorderStyle = typeof BorderStyles[number];
-type ElementKind$1 = Tagged$1<string, 'ElementKind'>;
+type ElementKind$1 = Tagged<string, 'ElementKind'>;
 declare const ElementShapes: readonly ["rectangle", "person", "browser", "mobile", "cylinder", "storage", "queue"];
 type ElementShape$1 = typeof ElementShapes[number];
 interface ElementStyle {
     border?: BorderStyle;
     opacity?: number;
 }
-type Tag$2 = Tagged$1<string, 'Tag'>;
+type Tag$1 = Tagged<string, 'Tag'>;
 interface Link {
     readonly title?: string;
     readonly url: string;
@@ -216,7 +52,7 @@ interface Element$1 {
     readonly title: string;
     readonly description: string | null;
     readonly technology: string | null;
-    readonly tags: NonEmptyArray<Tag$2> | null;
+    readonly tags: NonEmptyArray<Tag$1> | null;
     readonly links: NonEmptyArray<Link> | null;
     readonly icon?: IconUrl;
     readonly shape?: ElementShape$1;
@@ -271,6 +107,135 @@ 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<string, 'RelationID'>;
+type RelationshipKind$1 = Tagged<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$1>;
+    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;
+    custom?: never;
+    expanded?: never;
+    elementKind?: never;
+    elementTag?: never;
+    isEqual?: never;
+    isDescedants?: never;
+    wildcard?: never;
+    source?: never;
+    target?: never;
+    inout?: never;
+    incoming?: never;
+    outgoing?: never;
+    customRelation?: never;
+}
+interface ElementRefExpr extends Omit<BaseExpr, 'element' | 'isDescedants'> {
+    element: Fqn$1;
+    isDescedants?: boolean;
+}
+interface ExpandedElementExpr extends Omit<BaseExpr, 'expanded'> {
+    expanded: Fqn$1;
+}
+interface CustomElementExpr extends Omit<BaseExpr, 'custom'> {
+    custom: {
+        expr: ElementExpression$1 | ElementWhereExpr;
+        title?: string;
+        description?: string;
+        technology?: string;
+        notation?: string;
+        shape?: ElementShape$1;
+        color?: Color$1;
+        icon?: IconUrl;
+        border?: BorderStyle;
+        opacity?: number;
+        navigateTo?: ViewID$1;
+    };
+}
+interface WildcardExpr extends Omit<BaseExpr, 'wildcard'> {
+    wildcard: true;
+}
+interface ElementKindExpr extends Omit<BaseExpr, 'elementKind' | 'isEqual'> {
+    elementKind: ElementKind$1;
+    isEqual: boolean;
+}
+interface ElementTagExpr extends Omit<BaseExpr, 'elementTag' | 'isEqual'> {
+    elementTag: Tag$1;
+    isEqual: boolean;
+}
+type ElementExpression$1 = ElementRefExpr | WildcardExpr | ElementKindExpr | ElementTagExpr | ExpandedElementExpr;
+interface ElementWhereExpr extends Omit<BaseExpr, 'where'> {
+    where: {
+        expr: ElementExpression$1;
+        condition: WhereOperator<string, string>;
+    };
+}
+type ElementPredicateExpression = ElementExpression$1 | ElementWhereExpr | CustomElementExpr;
+interface RelationExpr extends Omit<BaseExpr, 'source' | 'target'> {
+    source: ElementExpression$1;
+    target: ElementExpression$1;
+    isBidirectional?: boolean;
+}
+interface InOutExpr extends Omit<BaseExpr, 'inout'> {
+    inout: ElementExpression$1;
+}
+interface IncomingExpr extends Omit<BaseExpr, 'incoming'> {
+    incoming: ElementExpression$1;
+}
+interface OutgoingExpr extends Omit<BaseExpr, 'outgoing'> {
+    outgoing: ElementExpression$1;
+}
+type RelationExpression$1 = RelationExpr | InOutExpr | IncomingExpr | OutgoingExpr;
+interface RelationWhereExpr extends Omit<BaseExpr, 'where'> {
+    where: {
+        expr: RelationExpression$1;
+        condition: WhereOperator<string, string>;
+    };
+}
+interface CustomRelationExpr extends Omit<BaseExpr, 'customRelation'> {
+    customRelation: {
+        relation: RelationExpression$1 | RelationWhereExpr;
+        title?: string;
+        description?: string;
+        technology?: string;
+        notation?: string;
+        navigateTo?: ViewID$1;
+        notes?: string;
+        color?: Color$1;
+        line?: RelationshipLineType;
+        head?: RelationshipArrowType;
+        tail?: RelationshipArrowType;
+    };
+}
+type RelationPredicateExpression = RelationExpression$1 | RelationWhereExpr | CustomRelationExpr;
+type Expression$1 = ElementPredicateExpression | RelationPredicateExpression;
+
 type ElementNotation = {
     kinds: ElementKind$1[];
     shape: ElementShape$1;
@@ -278,7 +243,7 @@ type ElementNotation = {
     title: string;
 };
 
-type ViewID$1 = Tagged$1<string, 'ViewID'>;
+type ViewID$1 = Tagged<string, 'ViewID'>;
 type ViewRulePredicate$1 = {
     include: Expression$1[];
     exclude?: never;
@@ -305,7 +270,7 @@ interface BasicView<ViewType extends 'element' | 'dynamic'> {
     readonly id: ViewID$1;
     readonly title: string | null;
     readonly description: string | null;
-    readonly tags: NonEmptyArray<Tag$2> | null;
+    readonly tags: NonEmptyArray<Tag$1> | null;
     readonly links: NonEmptyArray<Link> | null;
     /**
      * URI to the source file of this view.
@@ -371,10 +336,10 @@ type CustomColorDefinitions = {
     [key: string]: ThemeColorValues;
 };
 type LikeC4View$1 = ElementView$1 | DynamicView$1;
-type NodeId = Tagged$1<string, 'Fqn'>;
-type EdgeId$1 = Tagged$1<string, 'EdgeId'>;
+type NodeId = Tagged<string, 'Fqn'>;
+type EdgeId$1 = Tagged<string, 'EdgeId'>;
 type StepEdgeIdLiteral = `step-${number}` | `step-${number}.${number}`;
-type StepEdgeId = Tagged$1<StepEdgeIdLiteral, 'EdgeId'>;
+type StepEdgeId = Tagged<StepEdgeIdLiteral, 'EdgeId'>;
 declare function StepEdgeId(step: number, parallelStep?: number): StepEdgeId;
 declare function isStepEdgeId(id: string): id is StepEdgeId;
 declare function extractStep(id: EdgeId$1): number;
@@ -386,7 +351,7 @@ interface ComputedNode {
     description: string | null;
     technology: string | null;
     notation?: string;
-    tags: NonEmptyArray<Tag$2> | null;
+    tags: NonEmptyArray<Tag$1> | null;
     links: NonEmptyArray<Link> | null;
     children: NodeId[];
     inEdges: EdgeId$1[];
@@ -425,7 +390,7 @@ interface ComputedEdge {
     line?: RelationshipLineType;
     head?: RelationshipArrowType;
     tail?: RelationshipArrowType;
-    tags?: NonEmptyArray<Tag$2>;
+    tags?: NonEmptyArray<Tag$1>;
     navigateTo?: ViewID$1;
     /**
      * If this edge is derived from custom relationship predicate
@@ -518,153 +483,32 @@ 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;
+/**
+ * Parsed elements, relations, and views.
+ */
+interface ParsedLikeC4Model {
+    specification: {
+        tags: Tag$1[];
+        elements: Record<UnwrapTagged<ElementKind$1>, ElementKindSpecification>;
+        relationships: Record<UnwrapTagged<ElementKind$1>, RelationshipKindSpecification>;
     };
+    elements: Record<Fqn$1, Element$1>;
+    relations: Record<RelationID$1, Relation$1>;
+    views: Record<ViewID$1, LikeC4View$1>;
 }
-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;
-    custom?: never;
-    expanded?: never;
-    elementKind?: never;
-    elementTag?: never;
-    isEqual?: never;
-    isDescedants?: never;
-    wildcard?: never;
-    source?: never;
-    target?: never;
-    inout?: never;
-    incoming?: never;
-    outgoing?: never;
-    customRelation?: never;
-}
-interface ElementRefExpr extends Omit<BaseExpr, 'element' | 'isDescedants'> {
-    element: Fqn$1;
-    isDescedants?: boolean;
+/**
+ * Same as `ParsedLikeC4Model` but with computed views.
+ */
+interface ComputedLikeC4Model extends Omit<ParsedLikeC4Model, 'views'> {
+    __?: never;
+    views: Record<ViewID$1, ComputedView>;
 }
-interface ExpandedElementExpr extends Omit<BaseExpr, 'expanded'> {
-    expanded: Fqn$1;
-}
-interface CustomElementExpr extends Omit<BaseExpr, 'custom'> {
-    custom: {
-        expr: ElementExpression$1 | ElementWhereExpr;
-        title?: string;
-        description?: string;
-        technology?: string;
-        notation?: string;
-        shape?: ElementShape$1;
-        color?: Color$1;
-        icon?: IconUrl;
-        border?: BorderStyle;
-        opacity?: number;
-        navigateTo?: ViewID$1;
-    };
-}
-interface WildcardExpr extends Omit<BaseExpr, 'wildcard'> {
-    wildcard: true;
-}
-interface ElementKindExpr extends Omit<BaseExpr, 'elementKind' | 'isEqual'> {
-    elementKind: ElementKind$1;
-    isEqual: boolean;
-}
-interface ElementTagExpr extends Omit<BaseExpr, 'elementTag' | 'isEqual'> {
-    elementTag: Tag$2;
-    isEqual: boolean;
-}
-type ElementExpression$1 = ElementRefExpr | WildcardExpr | ElementKindExpr | ElementTagExpr | ExpandedElementExpr;
-interface ElementWhereExpr extends Omit<BaseExpr, 'where'> {
-    where: {
-        expr: ElementExpression$1;
-        condition: WhereOperator<string, string>;
-    };
-}
-type ElementPredicateExpression = ElementExpression$1 | ElementWhereExpr | CustomElementExpr;
-interface RelationExpr extends Omit<BaseExpr, 'source' | 'target'> {
-    source: ElementExpression$1;
-    target: ElementExpression$1;
-    isBidirectional?: boolean;
-}
-interface InOutExpr extends Omit<BaseExpr, 'inout'> {
-    inout: ElementExpression$1;
-}
-interface IncomingExpr extends Omit<BaseExpr, 'incoming'> {
-    incoming: ElementExpression$1;
-}
-interface OutgoingExpr extends Omit<BaseExpr, 'outgoing'> {
-    outgoing: ElementExpression$1;
-}
-type RelationExpression$1 = RelationExpr | InOutExpr | IncomingExpr | OutgoingExpr;
-interface RelationWhereExpr extends Omit<BaseExpr, 'where'> {
-    where: {
-        expr: RelationExpression$1;
-        condition: WhereOperator<string, string>;
-    };
-}
-interface CustomRelationExpr extends Omit<BaseExpr, 'customRelation'> {
-    customRelation: {
-        relation: RelationExpression$1 | RelationWhereExpr;
-        title?: string;
-        description?: string;
-        technology?: string;
-        notation?: string;
-        navigateTo?: ViewID$1;
-        notes?: string;
-        color?: Color$1;
-        line?: RelationshipLineType;
-        head?: RelationshipArrowType;
-        tail?: RelationshipArrowType;
-    };
-}
-type RelationPredicateExpression = RelationExpression$1 | RelationWhereExpr | CustomRelationExpr;
-type Expression$1 = ElementPredicateExpression | RelationPredicateExpression;
-
-/**
- * Parsed elements, relations, and views.
- */
-interface ParsedLikeC4Model {
-    specification: {
-        tags: Tag$2[];
-        elements: Record<UnwrapTagged<ElementKind$1>, ElementKindSpecification>;
-        relationships: Record<UnwrapTagged<ElementKind$1>, RelationshipKindSpecification>;
-    };
-    elements: Record<Fqn$1, Element$1>;
-    relations: Record<RelationID$1, Relation$1>;
-    views: Record<ViewID$1, LikeC4View$1>;
-}
-/**
- * Same as `ParsedLikeC4Model` but with computed views.
- */
-interface ComputedLikeC4Model extends Omit<ParsedLikeC4Model, 'views'> {
-    views: Record<ViewID$1, ComputedView>;
+/**
+ * Same as `ParsedLikeC4Model` but with layouted views (DiagramView)
+ */
+interface LayoutedLikeC4Model extends Omit<ParsedLikeC4Model, 'views'> {
+    __: 'layouted';
+    views: Record<ViewID$1, DiagramView>;
 }
 
 /**
@@ -728,158 +572,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";
@@ -1145,43 +837,49 @@ type Fqn = LiteralUnion<Fqn$1, string>;
 type RelationID = LiteralUnion<RelationID$1, string>;
 type ViewID = LiteralUnion<ViewID$1, string>;
 type EdgeId = LiteralUnion<EdgeId$1, string>;
+type IncomingFilter = 'all' | 'direct' | 'to-descendants';
+type OutgoingFilter = 'all' | 'direct' | 'from-descendants';
+type ElementOrFqn = Fqn | {
+    id: Fqn;
+};
 
-type ElementOrFqn$1 = Fqn | LikeC4ViewModel.Element;
 /**
  * All methods are view-scoped, i.e. only return elements and connections in the view.
  */
 declare class LikeC4ViewModel {
-    #private;
     readonly view: ComputedView;
-    readonly model: LikeC4Model;
-    constructor(view: ComputedView, model: LikeC4Model);
+    readonly model: LikeC4Model<LikeC4ViewModel>;
+    private _rootElements;
+    private _elements;
+    private _connections;
+    constructor(view: ComputedView, model: LikeC4Model<LikeC4ViewModel>);
     get id(): ViewID$1;
     get title(): string;
-    get viewOf(): LikeC4Model.Element;
-    get tags(): Tag$2[];
+    get viewOf(): LikeC4Model.ElementModel<LikeC4ViewModel>;
+    get tags(): Tag$1[];
     roots(): ReadonlyArray<LikeC4ViewModel.Element>;
     elements(): ReadonlyArray<LikeC4ViewModel.Element>;
     element(id: Fqn): LikeC4ViewModel.Element;
     hasElement(id: Fqn): boolean;
     connections(): ReadonlyArray<LikeC4ViewModel.Connection>;
     connection(id: EdgeId): LikeC4ViewModel.Connection;
-    findConnections(source: ElementOrFqn$1, target: ElementOrFqn$1, direction?: 'both' | 'direct'): ReadonlyArray<LikeC4ViewModel.Connection>;
-    parent(element: ElementOrFqn$1): LikeC4ViewModel.Element | null;
-    children(element: ElementOrFqn$1): ReadonlyArray<LikeC4ViewModel.Element>;
-    siblings(element: ElementOrFqn$1): ReadonlyArray<LikeC4ViewModel.Element>;
+    findConnections(source: ElementOrFqn, target: ElementOrFqn, direction?: 'both' | 'direct'): ReadonlyArray<LikeC4ViewModel.Connection>;
+    parent(element: ElementOrFqn): LikeC4ViewModel.Element | null;
+    children(element: ElementOrFqn): ReadonlyArray<LikeC4ViewModel.Element>;
+    siblings(element: ElementOrFqn): ReadonlyArray<LikeC4ViewModel.Element>;
     /**
      * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
      * (from closest to root)
      */
-    ancestors(element: ElementOrFqn$1): ReadonlyArray<LikeC4ViewModel.Element>;
-    descendants(element: ElementOrFqn$1): ReadonlyArray<LikeC4ViewModel.Element>;
-    incoming(element: ElementOrFqn$1, filter?: 'all' | 'direct' | 'to-descendants'): ReadonlyArray<LikeC4ViewModel.Connection>;
-    incomers(element: ElementOrFqn$1, filter?: 'all' | 'direct' | 'to-descendants'): ReadonlyArray<LikeC4ViewModel.Element>;
+    ancestors(element: ElementOrFqn): ReadonlyArray<LikeC4ViewModel.Element>;
+    descendants(element: ElementOrFqn): ReadonlyArray<LikeC4ViewModel.Element>;
+    incoming(element: ElementOrFqn, filter?: IncomingFilter): ReadonlyArray<LikeC4ViewModel.Connection>;
+    incomers(element: ElementOrFqn, filter?: IncomingFilter): ReadonlyArray<LikeC4ViewModel.Element>;
     /**
      * Outgoing relationships from the element and its descendants
      */
-    outgoing(element: ElementOrFqn$1, filter?: 'all' | 'direct' | 'from-descendants'): ReadonlyArray<LikeC4ViewModel.Connection>;
-    outgoers(element: ElementOrFqn$1, filter?: 'all' | 'direct' | 'from-descendants'): ReadonlyArray<LikeC4ViewModel.Element>;
+    outgoing(element: ElementOrFqn, filter?: OutgoingFilter): ReadonlyArray<LikeC4ViewModel.Connection>;
+    outgoers(element: ElementOrFqn, filter?: OutgoingFilter): ReadonlyArray<LikeC4ViewModel.Element>;
 }
 declare namespace LikeC4ViewModel {
     /**
@@ -1199,8 +897,8 @@ declare namespace LikeC4ViewModel {
         get hasNested(): boolean;
         get shape(): ElementShape$1;
         get color(): Color$1;
-        get tags(): Tag$2[];
-        model(): LikeC4Model.Element;
+        get tags(): Tag$1[];
+        model(): LikeC4Model.ElementModel<LikeC4ViewModel>;
         parent(): LikeC4ViewModel.Element | null;
         metadata(key: string): string | undefined;
         metadata(key: string, defaultValue: string): string;
@@ -1211,8 +909,8 @@ declare namespace LikeC4ViewModel {
         children(): ReadonlyArray<LikeC4ViewModel.Element>;
         incoming(filter?: 'all' | 'direct' | 'to-descendants'): ReadonlyArray<LikeC4ViewModel.Connection>;
         incomers(filter?: 'all' | 'direct' | 'to-descendants'): ReadonlyArray<LikeC4ViewModel.Element>;
-        outgoing(filter?: 'all' | 'direct' | 'from-descendants'): ReadonlyArray<LikeC4ViewModel.Connection>;
-        outgoers(filter?: 'all' | 'direct' | 'from-descendants'): ReadonlyArray<LikeC4ViewModel.Element>;
+        outgoing(filter?: OutgoingFilter): ReadonlyArray<LikeC4ViewModel.Connection>;
+        outgoers(filter?: OutgoingFilter): ReadonlyArray<LikeC4ViewModel.Element>;
         connectionsTo(target: Fqn | LikeC4ViewModel.Element): ReadonlyArray<LikeC4ViewModel.Connection>;
     }
     /**
@@ -1226,102 +924,114 @@ declare namespace LikeC4ViewModel {
         get id(): EdgeId$1;
         get source(): LikeC4ViewModel.Element;
         get target(): LikeC4ViewModel.Element;
-        get tags(): Tag$2[];
+        get tags(): Tag$1[];
         /**
          * Model relationships
          */
-        relationships(): ReadonlyArray<LikeC4Model.Relationship>;
+        relationships(): ReadonlyArray<LikeC4Model.Relationship<LikeC4ViewModel>>;
     }
 }
 
-type ElementOrFqn = Fqn | LikeC4Model.Element;
-declare class LikeC4Model {
-    #private;
-    protected computed: ComputedLikeC4Model;
-    static from(computed: ComputedLikeC4Model): LikeC4Model;
-    protected constructor(computed: ComputedLikeC4Model);
+type PickBySource<Source> = Source extends LikeC4Model.Layouted.SourceModel ? LikeC4Model.Layouted : Source extends LikeC4Model.Computed.SourceModel ? LikeC4Model.Computed : never;
+declare class LikeC4Model<M extends LikeC4Model.ViewModel = LikeC4Model.ViewModel> {
+    readonly type: LikeC4Model.ModelType<M>;
+    readonly sourcemodel: LikeC4Model.SourceModel<M>;
+    private _elements;
+    private _parents;
+    private _children;
+    private _rootElements;
+    private _relations;
+    private _incoming;
+    private _outgoing;
+    private _internal;
+    private _cacheAscendingSiblings;
+    private _views;
+    static create(source: LikeC4Model.SourceModel): PickBySource<typeof source>;
+    static computed(source: ComputedLikeC4Model): LikeC4Model<LikeC4ViewModel>;
+    static layouted(source: LayoutedLikeC4Model): LikeC4Model<LikeC4DiagramModel>;
+    protected constructor(type: LikeC4Model.ModelType<M>, sourcemodel: LikeC4Model.SourceModel<M>, elements: Element$1[], relations: Relation$1[]);
     /**
      * Returns the root elements of the model.
      */
-    roots(): ReadonlyArray<LikeC4Model.Element>;
+    roots(): ReadonlyArray<LikeC4Model.ElementModel<M>>;
     /**
      * Returns all elements in the model.
      */
-    elements(): ReadonlyArray<LikeC4Model.Element>;
+    elements(): ReadonlyArray<LikeC4Model.ElementModel<M>>;
     /**
      * Returns a specific element by its FQN.
      */
-    element(id: Fqn): LikeC4Model.Element;
+    element(id: Fqn): LikeC4Model.ElementModel<M>;
     /**
      * Returns all relationships in the model.
      */
-    relationships(): ReadonlyArray<LikeC4Model.Relationship>;
+    relationships(): ReadonlyArray<LikeC4Model.Relationship<M>>;
     /**
      * Returns a specific relationship by its ID.
      */
-    relationship(id: RelationID): LikeC4Model.Relationship;
+    relationship(id: RelationID): LikeC4Model.Relationship<M>;
     /**
      * Returns all views in the model.
      */
-    views(): ReadonlyArray<LikeC4ViewModel>;
+    views(): ReadonlyArray<M>;
     /**
      * Returns a specific view by its ID.
      */
-    view(viewId: ViewID): LikeC4ViewModel;
+    view(viewId: ViewID): M;
     /**
      * Returns the parent element of given element.
      * @see ancestors
      */
-    parent(element: ElementOrFqn): LikeC4Model.Element | null;
+    parent(element: ElementOrFqn): LikeC4Model.ElementModel<M> | null;
     /**
      * Get all children of the element (only direct children),
      * @see descendants
      */
-    children(element: ElementOrFqn): ReadonlyArray<LikeC4Model.Element>;
+    children(element: ElementOrFqn): ReadonlyArray<LikeC4Model.ElementModel<M>>;
     /**
      * Get all sibling (i.e. same parent)
      */
-    siblings(element: ElementOrFqn): ReadonlyArray<LikeC4Model.Element>;
+    siblings(element: ElementOrFqn): ReadonlyArray<LikeC4Model.ElementModel<M>>;
     /**
      * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
      * (from closest to root)
      */
-    ancestors(element: ElementOrFqn): ReadonlyArray<LikeC4Model.Element>;
+    ancestors(element: ElementOrFqn): ReadonlyArray<LikeC4Model.ElementModel<M>>;
     /**
      * Get all descendant elements (i.e. children, children’s children, etc.)
      */
-    descendants(element: ElementOrFqn): ReadonlyArray<LikeC4Model.Element>;
+    descendants(element: ElementOrFqn): ReadonlyArray<LikeC4Model.ElementModel<M>>;
     /**
      * Incoming relationships to the element and its descendants
      * @see incomers
      */
-    incoming(element: ElementOrFqn, filter?: 'all' | 'direct' | 'to-descendants'): ReadonlyArray<LikeC4Model.Relationship>;
+    incoming(element: ElementOrFqn, filter?: IncomingFilter): ReadonlyArray<LikeC4Model.Relationship<M>>;
     /**
      * Source elements of incoming relationships
      */
-    incomers(element: ElementOrFqn, filter?: 'all' | 'direct' | 'to-descendants'): ReadonlyArray<LikeC4Model.Element>;
+    incomers(element: ElementOrFqn, filter?: IncomingFilter): ReadonlyArray<LikeC4Model.ElementModel<M>>;
     /**
      * Outgoing relationships from the element and its descendants
      * @see outgoers
      */
-    outgoing(element: ElementOrFqn, filter?: 'all' | 'direct' | 'from-descendants'): ReadonlyArray<LikeC4Model.Relationship>;
+    outgoing(element: ElementOrFqn, filter?: OutgoingFilter): ReadonlyArray<LikeC4Model.Relationship<M>>;
     /**
      * Target elements of outgoing relationships
      */
-    outgoers(element: ElementOrFqn, filter?: 'all' | 'direct' | 'from-descendants'): ReadonlyArray<LikeC4Model.Element>;
+    outgoers(element: ElementOrFqn, filter?: OutgoingFilter): ReadonlyArray<LikeC4Model.ElementModel<M>>;
     /**
      * Relationships inside the element, among descendants
      */
-    internal(element: ElementOrFqn): ReadonlyArray<LikeC4Model.Relationship>;
+    internal(element: ElementOrFqn): ReadonlyArray<LikeC4Model.Relationship<M>>;
     /**
      * Resolve siblings of the element and siblings of ancestors
      *  (from closest to root)
      */
-    ascendingSiblings(element: ElementOrFqn): ReadonlyArray<LikeC4Model.Element>;
+    ascendingSiblings(element: ElementOrFqn): ReadonlyArray<LikeC4Model.ElementModel<M>>;
     /**
      * Resolve all views that contain the element
      */
-    viewsWithElement(element: ElementOrFqn): ReadonlyArray<LikeC4ViewModel>;
+    viewsWithElement(element: ElementOrFqn): ReadonlyArray<M>;
     private addElement;
     private addRelation;
     private _childrenOf;
@@ -1330,10 +1040,43 @@ declare class LikeC4Model {
     private _internalOf;
 }
 declare namespace LikeC4Model {
-    class Element {
-        readonly element: Element;
+    function isModel(model: any): model is LikeC4Model;
+    type SourceModel<M extends ViewModel = ViewModel> = M extends LikeC4DiagramModel ? LayoutedLikeC4Model : ComputedLikeC4Model;
+    type ViewModel = LikeC4ViewModel | LikeC4DiagramModel;
+    namespace ViewModel {
+        type Relationship = LikeC4Model.Relationship<ViewModel>;
+        function isLayouted(model: ViewModel): model is LikeC4DiagramModel;
+    }
+    type Computed = LikeC4Model<LikeC4ViewModel>;
+    namespace Computed {
+        type ViewModel = LikeC4ViewModel;
+        type SourceModel = LikeC4Model.SourceModel<ViewModel>;
+    }
+    type Layouted = LikeC4Model<LikeC4DiagramModel>;
+    namespace Layouted {
+        type ViewModel = LikeC4DiagramModel;
+        type SourceModel = LikeC4Model.SourceModel<ViewModel>;
+    }
+    type ModelType<M extends ViewModel = ViewModel> = M extends LikeC4DiagramModel ? 'layouted' : M extends LikeC4ViewModel ? 'computed' : never;
+    function isLayouted(model: LikeC4Model): model is Layouted;
+    class Relationship<M extends ViewModel> {
+        readonly relationship: Relation$1;
+        private model;
+        constructor(relationship: Relation$1, model: LikeC4Model<M>);
+        get id(): RelationID$1;
+        get title(): string;
+        get kind(): RelationshipKind$1;
+        get tags(): Tag$1[];
+        get source(): ElementModel<M>;
+        get target(): ElementModel<M>;
+        metadata(key: string): string | undefined;
+        metadata(key: string, defaultValue: string): string;
+        hasMetadata(key: string): boolean;
+    }
+    class ElementModel<M extends ViewModel> {
+        readonly element: Element$1;
         private model;
-        constructor(element: Element, model: LikeC4Model);
+        constructor(element: Element$1, model: LikeC4Model<M>);
         get id(): Fqn$1;
         get title(): string;
         get kind(): ElementKind$1;
@@ -1341,38 +1084,117 @@ declare namespace LikeC4Model {
         get hasNested(): boolean;
         get shape(): ElementShape$1;
         get color(): Color$1;
-        get tags(): Tag$2[];
-        parent(): LikeC4Model.Element | null;
+        get tags(): Tag$1[];
+        parent(): ElementModel<M> | null;
         metadata(key: string): string | undefined;
         metadata(key: string, defaultValue: string): string;
         hasMetadata(key: string): boolean;
-        ancestors(): readonly Element[];
-        siblings(): readonly Element[];
-        descendants(): readonly Element[];
-        children(): readonly Element[];
+        ancestors(): readonly ElementModel<M>[];
+        siblings(): readonly ElementModel<M>[];
+        descendants(): readonly ElementModel<M>[];
+        children(): readonly ElementModel<M>[];
         /**
          * Views that contain this element
          */
-        views(): readonly LikeC4ViewModel[];
-        incoming(filter?: 'all' | 'direct' | 'to-descendants'): readonly Relationship[];
-        incomers(filter?: 'all' | 'direct' | 'to-descendants'): readonly Element[];
-        outgoing(filter?: 'all' | 'direct' | 'from-descendants'): readonly Relationship[];
-        outgoers(filter?: 'all' | 'direct' | 'from-descendants'): readonly Element[];
-        internal(): readonly Relationship[];
+        views(): readonly M[];
+        incoming(filter?: IncomingFilter): readonly Relationship<M>[];
+        incomers(filter?: IncomingFilter): readonly ElementModel<M>[];
+        outgoing(filter?: OutgoingFilter): readonly Relationship<M>[];
+        outgoers(filter?: OutgoingFilter): readonly ElementModel<M>[];
+        internal(): readonly Relationship<M>[];
     }
-    class Relationship {
-        readonly relationship: Relation$1;
-        private model;
-        constructor(relationship: Relation$1, model: LikeC4Model);
-        get id(): RelationID$1;
+}
+
+/**
+ * All methods are view-scoped, i.e. only return elements and connections in the view.
+ */
+declare class LikeC4DiagramModel {
+    readonly view: DiagramView;
+    readonly model: LikeC4Model.Layouted;
+    private _rootElements;
+    private _elements;
+    private _connections;
+    constructor(view: DiagramView, model: LikeC4Model.Layouted);
+    get isDynamic(): boolean;
+    get id(): ViewID$1;
+    get title(): string;
+    get viewOf(): LikeC4Model.ElementModel<LikeC4DiagramModel>;
+    get tags(): Tag$1[];
+    roots(): ReadonlyArray<LikeC4DiagramModel.Element>;
+    elements(): ReadonlyArray<LikeC4DiagramModel.Element>;
+    element(id: Fqn): LikeC4DiagramModel.Element;
+    hasElement(id: Fqn): boolean;
+    connections(): ReadonlyArray<LikeC4DiagramModel.Connection>;
+    connection(id: EdgeId): LikeC4DiagramModel.Connection;
+    findConnections(source: ElementOrFqn, target: ElementOrFqn, direction?: 'both' | 'direct'): ReadonlyArray<LikeC4DiagramModel.Connection>;
+    parent(element: ElementOrFqn): LikeC4DiagramModel.Element | null;
+    children(element: ElementOrFqn): ReadonlyArray<LikeC4DiagramModel.Element>;
+    siblings(element: ElementOrFqn): ReadonlyArray<LikeC4DiagramModel.Element>;
+    /**
+     * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
+     * (from closest to root)
+     */
+    ancestors(element: ElementOrFqn): ReadonlyArray<LikeC4DiagramModel.Element>;
+    descendants(element: ElementOrFqn): ReadonlyArray<LikeC4DiagramModel.Element>;
+    incoming(element: ElementOrFqn, filter?: IncomingFilter): ReadonlyArray<LikeC4DiagramModel.Connection>;
+    incomers(element: ElementOrFqn, filter?: IncomingFilter): ReadonlyArray<LikeC4DiagramModel.Element>;
+    /**
+     * Outgoing relationships from the element and its descendants
+     */
+    outgoing(element: ElementOrFqn, filter?: OutgoingFilter): ReadonlyArray<LikeC4DiagramModel.Connection>;
+    outgoers(element: ElementOrFqn, filter?: OutgoingFilter): ReadonlyArray<LikeC4DiagramModel.Element>;
+}
+declare namespace LikeC4DiagramModel {
+    /**
+     * Represents an element in the view. (Diagram node)
+     * All methods are view-scoped, i.e. `children` returns only children of the element in the view.
+     */
+    class Element {
+        readonly node: DiagramNode;
+        private view;
+        constructor(node: DiagramNode, view: LikeC4DiagramModel);
+        get id(): NodeId;
         get title(): string;
-        get kind(): RelationshipKind$1;
-        get tags(): Tag$2[];
-        get source(): LikeC4Model.Element;
-        get target(): LikeC4Model.Element;
+        get kind(): ElementKind$1;
+        get isRoot(): boolean;
+        get hasNested(): boolean;
+        get shape(): ElementShape$1;
+        get color(): Color$1;
+        get tags(): Tag$1[];
+        get level(): number;
+        get depth(): number;
+        model(): LikeC4Model.ElementModel<LikeC4DiagramModel>;
+        parent(): LikeC4DiagramModel.Element | null;
         metadata(key: string): string | undefined;
         metadata(key: string, defaultValue: string): string;
         hasMetadata(key: string): boolean;
+        ancestors(): ReadonlyArray<LikeC4DiagramModel.Element>;
+        siblings(): ReadonlyArray<LikeC4DiagramModel.Element>;
+        descendants(): ReadonlyArray<LikeC4DiagramModel.Element>;
+        children(): ReadonlyArray<LikeC4DiagramModel.Element>;
+        incoming(filter?: IncomingFilter): ReadonlyArray<LikeC4DiagramModel.Connection>;
+        incomers(filter?: IncomingFilter): ReadonlyArray<LikeC4DiagramModel.Element>;
+        outgoing(filter?: OutgoingFilter): ReadonlyArray<LikeC4DiagramModel.Connection>;
+        outgoers(filter?: OutgoingFilter): ReadonlyArray<LikeC4DiagramModel.Element>;
+        connectionsTo(target: Fqn | LikeC4DiagramModel.Element): ReadonlyArray<LikeC4DiagramModel.Connection>;
+    }
+    /**
+     * Represents a connection between two elements.
+     * May be source from multiple model relationships.
+     */
+    class Connection {
+        readonly edge: DiagramEdge;
+        private view;
+        constructor(edge: DiagramEdge, view: LikeC4DiagramModel);
+        get id(): EdgeId$1;
+        get source(): LikeC4DiagramModel.Element;
+        get target(): LikeC4DiagramModel.Element;
+        get tags(): Tag$1[];
+        get color(): Color$1;
+        /**
+         * Model relationships
+         */
+        relationships(): ReadonlyArray<LikeC4Model.Relationship<LikeC4DiagramModel>>;
     }
 }
 declare function nameFromFqn(fqn: Fqn$1): string;
@@ -1385,7 +1207,6 @@ declare function isSameHierarchy<E extends {
 declare function isDescendantOf<E extends {
     id: Fqn$1;
 }>(ancestors: E[]): (e: E) => boolean;
-declare function notDescendantOf(ancestors: Element$1[]): (e: Element$1) => boolean;
 declare function commonAncestor(first: Fqn$1, second: Fqn$1): Fqn$1;
 declare function parentFqn(fqn: Fqn$1): Fqn$1 | null;
 /**
@@ -4286,638 +4107,91 @@ declare namespace WorkspaceFolder {
     function is(value: any): value is WorkspaceFolder;
 }
 
-/**
- * @hidden
- */
-type $keywords<T extends string> = {
-  [key in T]: key;
-};
-
-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;
-	}
-}
-
-/**
-Returns a boolean for whether the two given types are equal.
-
-@link https://github.com/microsoft/TypeScript/issues/27024#issuecomment-421529650
-@link https://stackoverflow.com/questions/68961864/how-does-the-equals-work-in-typescript/68963796#68963796
-
-Use-cases:
-- If you want to make a conditional branch based on the result of a comparison of two types.
-
-@example
-```
-import type {IsEqual} from 'type-fest';
-
-// This type returns a boolean for whether the given array includes the given item.
-// `IsEqual` is used to compare the given array at position 0 and the given item and then return true if they are equal.
-type Includes<Value extends readonly any[], Item> =
-	Value extends readonly [Value[0], ...infer rest]
-		? IsEqual<Value[0], Item> extends true
-			? true
-			: Includes<rest, Item>
-		: false;
-```
-
-@category Type Guard
-@category Utilities
-*/
-type IsEqual<A, B> =
-	(<G>() => G extends A ? 1 : 2) extends
-	(<G>() => G extends B ? 1 : 2)
-		? true
-		: false;
+type ParserMethod<ARGS extends unknown[], R> = (...args: ARGS) => R;
 
 /**
-Filter out keys from an object.
-
-Returns `never` if `Exclude` is strictly equal to `Key`.
-Returns `never` if `Key` extends `Exclude`.
-Returns `Key` otherwise.
+ * This class does not actually exist nor is exposed at runtime.
+ * This is just a helper to avoid duplications in the Type Definitions
+ * Of `CstParser` and `EmbeddedActionsParser`
+ */
+declare abstract class BaseParser$1 {
+  /**
+   * This must be called at the end of a Parser constructor.
+   * See: http://chevrotain.io/docs/tutorial/step2_parsing.html#under-the-hood
+   */
+  protected performSelfAnalysis(): void;
 
-@example
-```
-type Filtered = Filter<'foo', 'foo'>;
-//=> never
-```
+  /**
+   * It is recommended to reuse the same Parser instance
+   * by passing an empty array to the input argument
+   * and only later setting the input by using the input property.
+   * See: http://chevrotain.io/docs/FAQ.html#major-performance-benefits
+   *
+   * @param tokenVocabulary - A data structure containing all the Tokens used by the Parser.
+   * @param config - The Parser's configuration.
+   */
+  constructor(tokenVocabulary: TokenVocabulary, config?: IParserConfig);
 
-@example
-```
-type Filtered = Filter<'bar', string>;
-//=> never
-```
+  errors: IRecognitionException[];
 
-@example
-```
-type Filtered = Filter<'bar', 'foo'>;
-//=> 'bar'
-```
+  /**
+   * Flag indicating the Parser is at the recording phase.
+   * Can be used to implement methods similar to {@link BaseParser.ACTION}
+   * Or any other logic to requires knowledge of the recording phase.
+   * See:
+   *   - https://chevrotain.io/docs/guide/internals.html#grammar-recording
+   * to learn more on the recording phase and how Chevrotain works.
+   */
+  RECORDING_PHASE: boolean;
 
-@see {Except}
-*/
-type Filter<KeyType, ExcludeType> = IsEqual<KeyType, ExcludeType> extends true ? never : (KeyType extends ExcludeType ? never : KeyType);
+  /**
+   * Resets the parser state, should be overridden for custom parsers which "carry" additional state.
+   * When overriding, remember to also invoke the super implementation!
+   */
+  reset(): void;
 
-type ExceptOptions = {
-	/**
-	Disallow assigning non-specified properties.
+  getBaseCstVisitorConstructor<IN = any, OUT = any>(): {
+    new (...args: any[]): ICstVisitor<IN, OUT>;
+  };
 
-	Note that any omitted properties in the resulting type will be present in autocomplete as `undefined`.
+  getBaseCstVisitorConstructorWithDefaults<IN = any, OUT = any>(): {
+    new (...args: any[]): ICstVisitor<IN, OUT>;
+  };
 
-	@default false
-	*/
-	requireExactProps?: boolean;
-};
+  getGAstProductions(): Record<string, Rule>;
 
-/**
-Create a type from an object type without certain keys.
+  getSerializedGastProductions(): ISerializedGast[];
 
-We recommend setting the `requireExactProps` option to `true`.
+  /**
+   * @param startRuleName
+   * @param precedingInput - The token vector up to (not including) the content assist point
+   */
+  computeContentAssist(
+    startRuleName: string,
+    precedingInput: IToken[],
+  ): ISyntacticContentAssistPath[];
 
-This type is a stricter version of [`Omit`](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-5.html#the-omit-helper-type). The `Omit` type does not restrict the omitted keys to be keys present on the given type, while `Except` does. The benefits of a stricter type are avoiding typos and allowing the compiler to pick up on rename refactors automatically.
+  /**
+   * @param grammarRule - The rule to try and parse in backtracking mode.
+   * @param args - argument to be passed to the grammar rule execution
+   *
+   * @return a lookahead function that will try to parse the given grammarRule and will return true if succeed.
+   */
+  protected BACKTRACK<T>(
+    grammarRule: (...args: any[]) => T,
+    args?: any[],
+  ): () => boolean;
 
-This type was proposed to the TypeScript team, which declined it, saying they prefer that libraries implement stricter versions of the built-in types ([microsoft/TypeScript#30825](https://github.com/microsoft/TypeScript/issues/30825#issuecomment-523668235)).
-
-@example
-```
-import type {Except} from 'type-fest';
-
-type Foo = {
-	a: number;
-	b: string;
-};
-
-type FooWithoutA = Except<Foo, 'a'>;
-//=> {b: string}
-
-const fooWithoutA: FooWithoutA = {a: 1, b: '2'};
-//=> errors: 'a' does not exist in type '{ b: string; }'
-
-type FooWithoutB = Except<Foo, 'b', {requireExactProps: true}>;
-//=> {a: number} & Partial<Record<"b", never>>
-
-const fooWithoutB: FooWithoutB = {a: 1, b: '2'};
-//=> errors at 'b': Type 'string' is not assignable to type 'undefined'.
-```
-
-@category Object
-*/
-type Except<ObjectType, KeysType extends keyof ObjectType, Options extends ExceptOptions = {requireExactProps: false}> = {
-	[KeyType in keyof ObjectType as Filter<KeyType, KeysType>]: ObjectType[KeyType];
-} & (Options['requireExactProps'] extends true
-	? Partial<Record<KeysType, never>>
-	: {});
-
-/**
-Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
-
-@example
-```
-import type {Simplify} from 'type-fest';
-
-type PositionProps = {
-	top: number;
-	left: number;
-};
-
-type SizeProps = {
-	width: number;
-	height: number;
-};
-
-// In your editor, hovering over `Props` will show a flattened object with all the properties.
-type Props = Simplify<PositionProps & SizeProps>;
-```
-
-Sometimes it is desired to pass a value as a function argument that has a different type. At first inspection it may seem assignable, and then you discover it is not because the `value`'s type definition was defined as an interface. In the following example, `fn` requires an argument of type `Record<string, unknown>`. If the value is defined as a literal, then it is assignable. And if the `value` is defined as type using the `Simplify` utility the value is assignable.  But if the `value` is defined as an interface, it is not assignable because the interface is not sealed and elsewhere a non-string property could be added to the interface.
-
-If the type definition must be an interface (perhaps it was defined in a third-party npm package), then the `value` can be defined as `const value: Simplify<SomeInterface> = ...`. Then `value` will be assignable to the `fn` argument.  Or the `value` can be cast as `Simplify<SomeInterface>` if you can't re-declare the `value`.
-
-@example
-```
-import type {Simplify} from 'type-fest';
-
-interface SomeInterface {
-	foo: number;
-	bar?: string;
-	baz: number | undefined;
-}
-
-type SomeType = {
-	foo: number;
-	bar?: string;
-	baz: number | undefined;
-};
-
-const literal = {foo: 123, bar: 'hello', baz: 456};
-const someType: SomeType = literal;
-const someInterface: SomeInterface = literal;
-
-function fn(object: Record<string, unknown>): void {}
-
-fn(literal); // Good: literal object type is sealed
-fn(someType); // Good: type is sealed
-fn(someInterface); // Error: Index signature for type 'string' is missing in type 'someInterface'. Because `interface` can be re-opened
-fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface` into a `type`
-```
-
-@link https://github.com/microsoft/TypeScript/issues/15300
-@see SimplifyDeep
-@category Object
-*/
-type Simplify<T> = {[KeyType in keyof T]: T[KeyType]} & {};
-
-/**
-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<T> = [T] extends [never] ? true : false;
-
-declare const tag: unique symbol;
-
-type TagContainer<Token> = {
-	readonly [tag]: Token;
-};
-
-type Tag$1<Token extends PropertyKey, TagMetadata> = TagContainer<{[K in Token]: TagMetadata}>;
-
-/**
-Attach a "tag" to an arbitrary type. This allows you to create distinct types, that aren't assignable to one another, for distinct concepts in your program that should not be interchangeable, even if their runtime values have the same type. (See examples.)
-
-A type returned by `Tagged` can be passed to `Tagged` again, to create a type with multiple tags.
-
-[Read more about tagged types.](https://medium.com/@KevinBGreene/surviving-the-typescript-ecosystem-branding-and-type-tagging-6cf6e516523d)
-
-A tag's name is usually a string (and must be a string, number, or symbol), but each application of a tag can also contain an arbitrary type as its "metadata". See {@link GetTagMetadata} for examples and explanation.
-
-A type `A` returned by `Tagged` is assignable to another type `B` returned by `Tagged` if and only if:
-  - the underlying (untagged) type of `A` is assignable to the underlying type of `B`;
-	- `A` contains at least all the tags `B` has;
-	- and the metadata type for each of `A`'s tags is assignable to the metadata type of `B`'s corresponding tag.
-
-There have been several discussions about adding similar features to TypeScript. Unfortunately, nothing has (yet) moved forward:
-	- [Microsoft/TypeScript#202](https://github.com/microsoft/TypeScript/issues/202)
-	- [Microsoft/TypeScript#4895](https://github.com/microsoft/TypeScript/issues/4895)
-	- [Microsoft/TypeScript#33290](https://github.com/microsoft/TypeScript/pull/33290)
-
-@example
-```
-import type {Tagged} from 'type-fest';
-
-type AccountNumber = Tagged<number, 'AccountNumber'>;
-type AccountBalance = Tagged<number, 'AccountBalance'>;
-
-function createAccountNumber(): AccountNumber {
-	// As you can see, casting from a `number` (the underlying type being tagged) is allowed.
-	return 2 as AccountNumber;
-}
-
-function getMoneyForAccount(accountNumber: AccountNumber): AccountBalance {
-	return 4 as AccountBalance;
-}
-
-// This will compile successfully.
-getMoneyForAccount(createAccountNumber());
-
-// But this won't, because it has to be explicitly passed as an `AccountNumber` type!
-// Critically, you could not accidentally use an `AccountBalance` as an `AccountNumber`.
-getMoneyForAccount(2);
-
-// You can also use tagged values like their underlying, untagged type.
-// I.e., this will compile successfully because an `AccountNumber` can be used as a regular `number`.
-// In this sense, the underlying base type is not hidden, which differentiates tagged types from opaque types in other languages.
-const accountNumber = createAccountNumber() + 2;
-```
-
-@example
-```
-import type {Tagged} from 'type-fest';
-
-// You can apply multiple tags to a type by using `Tagged` repeatedly.
-type Url = Tagged<string, 'URL'>;
-type SpecialCacheKey = Tagged<Url, 'SpecialCacheKey'>;
-
-// You can also pass a union of tag names, so this is equivalent to the above, although it doesn't give you the ability to assign distinct metadata to each tag.
-type SpecialCacheKey2 = Tagged<string, 'URL' | 'SpecialCacheKey'>;
-```
-
-@category Type
-*/
-type Tagged<Type, TagName extends PropertyKey, TagMetadata = never> = Type & Tag$1<TagName, TagMetadata>;
-
-/**
-Create a type that makes the given keys required. The remaining keys are kept as is. The sister of the `SetOptional` type.
-
-Use-case: You want to define a single model where the only thing that changes is whether or not some of the keys are required.
-
-@example
-```
-import type {SetRequired} from 'type-fest';
-
-type Foo = {
-	a?: number;
-	b: string;
-	c?: boolean;
-}
-
-type SomeRequired = SetRequired<Foo, 'b' | 'c'>;
-// type SomeRequired = {
-// 	a?: number;
-// 	b: string; // Was already required and still is.
-// 	c: boolean; // Is now required.
-// }
-```
-
-@category Object
-*/
-type SetRequired<BaseType, Keys extends keyof BaseType> =
-	// `extends unknown` is always going to be the case and is used to convert any
-	// union into a [distributive conditional
-	// type](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
-	BaseType extends unknown
-		? Simplify<
-		// Pick just the keys that are optional from the base type.
-		Except<BaseType, Keys> &
-		// Pick the keys that should be required from the base type and make them required.
-		Required<Pick<BaseType, Keys>>
-		>
-		: never;
-
-/**
-Create a union of the given object's values, and optionally specify which keys to get the values from.
-
-Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/31438) if you want to have this type as a built-in in TypeScript.
-
-@example
-```
-// data.json
-{
-	'foo': 1,
-	'bar': 2,
-	'biz': 3
-}
-
-// main.ts
-import type {ValueOf} from 'type-fest';
-import data = require('./data.json');
-
-export function getData(name: string): ValueOf<typeof data> {
-	return data[name];
-}
-
-export function onlyBar(name: string): ValueOf<typeof data, 'bar'> {
-	return data[name];
-}
-
-// file.ts
-import {getData, onlyBar} from './main';
-
-getData('foo');
-//=> 1
-
-onlyBar('foo');
-//=> TypeError ...
-
-onlyBar('bar');
-//=> 2
-```
-
-@category Object
-*/
-type ValueOf<ObjectType, ValueType extends keyof ObjectType = keyof ObjectType> = ObjectType[ValueType];
-
-/**
-An if-else-like type that resolves depending on whether the given type is `never`.
-
-@see {@link IsNever}
-
-@example
-```
-import type {IfNever} from 'type-fest';
-
-type ShouldBeTrue = IfNever<never>;
-//=> true
-
-type ShouldBeBar = IfNever<'not never', 'foo', 'bar'>;
-//=> 'bar'
-```
-
-@category Type Guard
-@category Utilities
-*/
-type IfNever<T, TypeIfNever = true, TypeIfNotNever = false> = (
-	IsNever<T> extends true ? TypeIfNever : TypeIfNotNever
-);
-
-/**
-Extract the keys from a type where the value type of the key extends the given `Condition`.
-
-Internally this is used for the `ConditionalPick` and `ConditionalExcept` types.
-
-@example
-```
-import type {ConditionalKeys} from 'type-fest';
-
-interface Example {
-	a: string;
-	b: string | number;
-	c?: string;
-	d: {};
-}
-
-type StringKeysOnly = ConditionalKeys<Example, string>;
-//=> 'a'
-```
-
-To support partial types, make sure your `Condition` is a union of undefined (for example, `string | undefined`) as demonstrated below.
-
-@example
-```
-import type {ConditionalKeys} from 'type-fest';
-
-type StringKeysAndUndefined = ConditionalKeys<Example, string | undefined>;
-//=> 'a' | 'c'
-```
-
-@category Object
-*/
-type ConditionalKeys<Base, Condition> =
-{
-	// Map through all the keys of the given base type.
-	[Key in keyof Base]-?:
-	// Pick only keys with types extending the given `Condition` type.
-	Base[Key] extends Condition
-	// Retain this key
-	// If the value for the key extends never, only include it if `Condition` also extends never
-		? IfNever<Base[Key], IfNever<Condition, Key, never>, Key>
-	// Discard this key since the condition fails.
-		: never;
-	// Convert the produced object into a union type of the keys which passed the conditional test.
-}[keyof Base];
-
-/**
-Pick keys from the shape that matches the given `Condition`.
-
-This is useful when you want to create a new type from a specific subset of an existing type. For example, you might want to pick all the primitive properties from a class and form a new automatically derived type.
-
-@example
-```
-import type {Primitive, ConditionalPick} from 'type-fest';
-
-class Awesome {
-	name: string;
-	successes: number;
-	failures: bigint;
-
-	run() {}
-}
-
-type PickPrimitivesFromAwesome = ConditionalPick<Awesome, Primitive>;
-//=> {name: string; successes: number; failures: bigint}
-```
-
-@example
-```
-import type {ConditionalPick} from 'type-fest';
-
-interface Example {
-	a: string;
-	b: string | number;
-	c: () => void;
-	d: {};
-}
-
-type StringKeysOnly = ConditionalPick<Example, string>;
-//=> {a: string}
-```
-
-@category Object
-*/
-type ConditionalPick<Base, Condition> = Pick<
-Base,
-ConditionalKeys<Base, Condition>
->;
-
-declare module 'ts-graphviz' {
-    namespace ClusterSubgraphAttributeKey {
-        interface $values extends $keywords<'likec4_type' | 'likec4_path' | 'likec4_id' | 'likec4_level' | 'likec4_depth'> {
-        }
-    }
-    namespace NodeAttributeKey {
-        interface $values extends $keywords<'likec4_type' | 'likec4_path' | 'likec4_id' | 'likec4_level'> {
-        }
-    }
-    namespace EdgeAttributeKey {
-        interface $values extends $keywords<'likec4_id'> {
-        }
-    }
-    namespace Attribute {
-        interface $keys extends $keywords<'likec4_type' | 'likec4_path' | 'likec4_id' | 'likec4_level' | 'likec4_depth'> {
-        }
-        interface $types {
-            likec4_type: 'folder' | 'file' | 'view';
-            likec4_path: string;
-            likec4_id: string;
-            likec4_level: number;
-            likec4_depth: number;
-        }
-    }
-}
-type DotSource = Tagged<string, 'DotSource'>;
-type DotLayoutResult = {
-    dot: DotSource;
-    diagram: DiagramView;
-};
-
-interface GraphvizPort {
-    unflatten(dot: DotSource): Promise<DotSource>;
-    acyclic(dot: DotSource): Promise<DotSource>;
-    layoutJson(dot: DotSource): Promise<string>;
-    svg(dot: DotSource): Promise<string>;
-}
-type LayoutResult = {
-    dot: DotSource;
-    diagram: DiagramView;
-};
-declare class GraphvizLayouter {
-    private graphviz;
-    constructor(graphviz: GraphvizPort);
-    get port(): GraphvizPort;
-    changePort(graphviz: GraphvizPort): void;
-    layout(view: ComputedView): Promise<LayoutResult>;
-    svg(view: ComputedView): Promise<{
-        svg: string;
-        dot: DotSource;
-    }>;
-    dot(computedView: ComputedView): Promise<DotSource>;
-    layoutOverviewGraph(views: ComputedView[]): Promise<OverviewGraph>;
-}
-
-type ParserMethod<ARGS extends unknown[], R> = (...args: ARGS) => R;
-
-/**
- * This class does not actually exist nor is exposed at runtime.
- * This is just a helper to avoid duplications in the Type Definitions
- * Of `CstParser` and `EmbeddedActionsParser`
- */
-declare abstract class BaseParser$1 {
-  /**
-   * This must be called at the end of a Parser constructor.
-   * See: http://chevrotain.io/docs/tutorial/step2_parsing.html#under-the-hood
-   */
-  protected performSelfAnalysis(): void;
-
-  /**
-   * It is recommended to reuse the same Parser instance
-   * by passing an empty array to the input argument
-   * and only later setting the input by using the input property.
-   * See: http://chevrotain.io/docs/FAQ.html#major-performance-benefits
-   *
-   * @param tokenVocabulary - A data structure containing all the Tokens used by the Parser.
-   * @param config - The Parser's configuration.
-   */
-  constructor(tokenVocabulary: TokenVocabulary, config?: IParserConfig);
-
-  errors: IRecognitionException[];
-
-  /**
-   * Flag indicating the Parser is at the recording phase.
-   * Can be used to implement methods similar to {@link BaseParser.ACTION}
-   * Or any other logic to requires knowledge of the recording phase.
-   * See:
-   *   - https://chevrotain.io/docs/guide/internals.html#grammar-recording
-   * to learn more on the recording phase and how Chevrotain works.
-   */
-  RECORDING_PHASE: boolean;
-
-  /**
-   * Resets the parser state, should be overridden for custom parsers which "carry" additional state.
-   * When overriding, remember to also invoke the super implementation!
-   */
-  reset(): void;
-
-  getBaseCstVisitorConstructor<IN = any, OUT = any>(): {
-    new (...args: any[]): ICstVisitor<IN, OUT>;
-  };
-
-  getBaseCstVisitorConstructorWithDefaults<IN = any, OUT = any>(): {
-    new (...args: any[]): ICstVisitor<IN, OUT>;
-  };
-
-  getGAstProductions(): Record<string, Rule>;
-
-  getSerializedGastProductions(): ISerializedGast[];
-
-  /**
-   * @param startRuleName
-   * @param precedingInput - The token vector up to (not including) the content assist point
-   */
-  computeContentAssist(
-    startRuleName: string,
-    precedingInput: IToken[],
-  ): ISyntacticContentAssistPath[];
-
-  /**
-   * @param grammarRule - The rule to try and parse in backtracking mode.
-   * @param args - argument to be passed to the grammar rule execution
-   *
-   * @return a lookahead function that will try to parse the given grammarRule and will return true if succeed.
-   */
-  protected BACKTRACK<T>(
-    grammarRule: (...args: any[]) => T,
-    args?: any[],
-  ): () => boolean;
-
-  /**
-   * The Semantic Actions wrapper.
-   * Should be used to wrap semantic actions that either:
-   * - May fail when executing in "recording phase".
-   * - Have global side effects that should be avoided during "recording phase".
-   *
-   * For more information see:
-   *   - https://chevrotain.io/docs/guide/internals.html#grammar-recording
-   */
-  protected ACTION<T>(impl: () => T): T;
+  /**
+   * The Semantic Actions wrapper.
+   * Should be used to wrap semantic actions that either:
+   * - May fail when executing in "recording phase".
+   * - Have global side effects that should be avoided during "recording phase".
+   *
+   * For more information see:
+   *   - https://chevrotain.io/docs/guide/internals.html#grammar-recording
+   */
+  protected ACTION<T>(impl: () => T): T;
 
   /**
    * Like `CONSUME` with the numerical suffix as a parameter, e.g:
@@ -6716,7 +5990,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!
  ******************************************************************************/
 
@@ -7137,35 +6411,286 @@ declare namespace TextDocument {
      * @returns The updated TextDocument. Note: That's the same document instance passed in as first parameter.
      *
      */
-    function update(document: TextDocument, changes: TextDocumentContentChangeEvent$1[], version: number): TextDocument;
-    function applyEdits(document: TextDocument, edits: TextEdit[]): string;
+    function update(document: TextDocument, changes: TextDocumentContentChangeEvent$1[], version: number): TextDocument;
+    function applyEdits(document: TextDocument, edits: TextEdit[]): string;
+}
+
+/******************************************************************************
+ * 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 FileSystemNode {
+    readonly isFile: boolean;
+    readonly isDirectory: boolean;
+    readonly uri: URI;
+}
+/**
+ * Provides methods to interact with an abstract file system. The default implementation is based on the node.js `fs` API.
+ */
+interface FileSystemProvider {
+    /**
+     * Reads a document asynchronously from a given URI.
+     * @returns The string content of the file with the specified URI.
+     */
+    readFile(uri: URI): Promise<string>;
+    /**
+     * Reads the directory information for the given URI.
+     * @returns The list of file system entries that are contained within the specified directory.
+     */
+    readDirectory(uri: URI): Promise<FileSystemNode[]>;
+}
+
+/******************************************************************************
+ * 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;
+    /**
+     * 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 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 FileSystemNode {
-    readonly isFile: boolean;
-    readonly isDirectory: boolean;
-    readonly uri: URI;
+interface TokenBuilderOptions {
+    caseInsensitive?: boolean;
 }
-/**
- * Provides methods to interact with an abstract file system. The default implementation is based on the node.js `fs` API.
- */
-interface FileSystemProvider {
-    /**
-     * Reads a document asynchronously from a given URI.
-     * @returns The string content of the file with the specified URI.
-     */
-    readFile(uri: URI): Promise<string>;
+interface TokenBuilder {
+    buildTokens(grammar: Grammar, options?: TokenBuilderOptions): TokenVocabulary;
     /**
-     * Reads the directory information for the given URI.
-     * @returns The list of file system entries that are contained within the specified directory.
+     * 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.
      */
-    readDirectory(uri: URI): Promise<FileSystemNode[]>;
+    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;
 }
 
 /******************************************************************************
@@ -7187,10 +6712,15 @@ interface LexerResult {
      */
     hidden: IToken[];
     errors: ILexingError[];
+    report?: LexingReport;
+}
+type TokenizeMode = 'full' | 'partial';
+interface TokenizeOptions {
+    mode?: TokenizeMode;
 }
 interface Lexer {
     readonly definition: TokenTypeDictionary;
-    tokenize(text: string): LexerResult;
+    tokenize(text: string, options?: TokenizeOptions): LexerResult;
 }
 
 /******************************************************************************
@@ -7203,6 +6733,7 @@ type ParseResult<T = AstNode> = {
     value: T;
     parserErrors: IRecognitionException[];
     lexerErrors: ILexingError[];
+    lexerReport?: LexingReport;
 };
 type RuleResult = (args: Args) => any;
 type Args = Record<string, boolean>;
@@ -7402,231 +6933,10 @@ interface ServiceRegistry {
      */
     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;
-    /**
-     * 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.
+     * The full set of registered language services.
      */
-    exclude<Key = T>(other: Iterable<T>, key?: (element: T) => Key): Stream<T>;
+    readonly all: readonly LangiumCoreServices[];
 }
-type FlatStream<T, Depth extends number> = {
-    'done': Stream<T>;
-    'recur': T extends Iterable<infer Content> ? FlatStream<Content, MinusOne<Depth>> : Stream<T>;
-}[Depth extends 0 ? 'done' : 'recur'];
-type MinusOne<N extends number> = [-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20][N];
 
 /******************************************************************************
  * Copyright 2021 TypeFox GmbH
@@ -7849,7 +7159,7 @@ interface DocumentSegment {
  * No implementation object is expected to be offered by `LangiumCoreServices`, but only by `LangiumLSPServices`.
  */
 type TextDocumentProvider = {
-    get(uri: string): TextDocument | undefined;
+    get(uri: string | URI): TextDocument | undefined;
 };
 /**
  * Shared service for creating `LangiumDocument` instances.
@@ -8465,6 +7775,8 @@ interface Linker {
      *
      * @param document A LangiumDocument that shall be linked.
      * @param cancelToken A token for cancelling the operation.
+     *
+     * @throws `OperationCancelled` if a cancellation event is detected
      */
     link(document: LangiumDocument, cancelToken?: CancellationToken): Promise<void>;
     /**
@@ -8546,29 +7858,24 @@ declare class Deferred<T = void> {
  ******************************************************************************/
 
 /**
- * Async parser that allows to cancel the current parsing process.
- * The sync parser implementation is blocking the event loop, which can become quite problematic for large files.
+ * Async parser that allows cancellation of the current parsing process.
  *
- * Note that the default implementation is not actually async. It just wraps the sync parser in a promise.
- * A real implementation would create worker threads or web workers to offload the parsing work.
+ * @remark The sync parser implementation is blocking the event loop, which can become quite problematic for large files.
+ * @remark The default implementation is not actually async. It just wraps the sync parser in a promise. A real implementation would create worker threads or web workers to offload the parsing work.
  */
 interface AsyncParser {
+    /**
+     * Parses the given text and returns the parse result.
+     *
+     * @param text The text to parse.
+     * @param cancelToken A cancellation token that can be used to cancel the parsing process.
+     * @returns A promise that resolves to the parse result.
+     *
+     * @throw `OperationCancelled` if the parsing process is cancelled.
+     */
     parse<T extends AstNode>(text: string, cancelToken: CancellationToken): Promise<ParseResult<T>>;
 }
 
-/******************************************************************************
- * Copyright 2021 TypeFox GmbH
- * This program and the accompanying materials are made available under the
- * terms of the MIT License, which is available in the project root.
- ******************************************************************************/
-
-interface TokenBuilderOptions {
-    caseInsensitive?: boolean;
-}
-interface TokenBuilder {
-    buildTokens(grammar: Grammar, options?: TokenBuilderOptions): TokenVocabulary;
-}
-
 /******************************************************************************
  * Copyright 2021 TypeFox GmbH
  * This program and the accompanying materials are made available under the
@@ -8706,7 +8013,7 @@ declare class DefaultScopeComputation implements ScopeComputation {
      * @param document The document containing the AST node to be exported.
      * @param children A function called with {@link parentNode} as single argument and returning an {@link Iterable} supplying the children to be visited, which must be directly or transitively contained in {@link parentNode}.
      * @param cancelToken Indicates when to cancel the current operation.
-     * @throws `OperationCanceled` if a user action occurs during execution.
+     * @throws `OperationCancelled` if a user action occurs during execution.
      * @returns A list of {@link AstNodeDescription AstNodeDescriptions} to be published to index.
      */
     computeExportsForNode(parentNode: AstNode, document: LangiumDocument<AstNode>, children?: (root: AstNode) => Iterable<AstNode>, cancelToken?: CancellationToken): Promise<AstNodeDescription[]>;
@@ -8794,7 +8101,8 @@ type DiagnosticInfo<N extends AstNode, P extends string = Properties<N>> = {
     /** A data entry field that is preserved between a `textDocument/publishDiagnostics` notification and `textDocument/codeAction` request. */
     data?: unknown;
 };
-type ValidationAcceptor = <N extends AstNode>(severity: 'error' | 'warning' | 'info' | 'hint', message: string, info: DiagnosticInfo<N>) => void;
+type ValidationSeverity = 'error' | 'warning' | 'info' | 'hint';
+type ValidationAcceptor = <N extends AstNode>(severity: ValidationSeverity, message: string, info: DiagnosticInfo<N>) => void;
 type ValidationCheck<T extends AstNode = AstNode> = (node: T, accept: ValidationAcceptor, cancelToken: CancellationToken) => MaybePromise<void>;
 /**
  * A utility type for associating non-primitive AST types to corresponding validation checks. For example:
@@ -8888,6 +8196,9 @@ interface DocumentValidator {
 }
 declare namespace DocumentValidator {
     const LexingError = "lexing-error";
+    const LexingWarning = "lexing-warning";
+    const LexingInfo = "lexing-info";
+    const LexingHint = "lexing-hint";
     const ParsingError = "parsing-error";
     const LinkingError = "linking-error";
 }
@@ -13548,6 +12859,9 @@ interface WorkspaceManager {
      * each language file and stores it locally.
      *
      * @param folders The set of workspace folders to be indexed.
+     * @param cancelToken A cancellation token that can be used to cancel the operation.
+     *
+     * @throws OperationCancelled if a cancellation event has been detected
      */
     initializeWorkspace(folders: WorkspaceFolder[], cancelToken?: CancellationToken): Promise<void>;
 }
@@ -13604,51 +12918,51 @@ declare class DefaultWorkspaceManager implements WorkspaceManager {
  * grammar definition and the language configuration.
  */
 type LangiumGeneratedCoreServices = {
-    Grammar: Grammar;
-    LanguageMetaData: LanguageMetaData;
-    parser: {
-        ParserConfig?: IParserConfig;
+    readonly Grammar: Grammar;
+    readonly LanguageMetaData: LanguageMetaData;
+    readonly parser: {
+        readonly ParserConfig?: IParserConfig;
     };
 };
 /**
  * Core services for a specific language of which Langium provides default implementations.
  */
 type LangiumDefaultCoreServices = {
-    parser: {
-        AsyncParser: AsyncParser;
-        GrammarConfig: GrammarConfig;
-        ValueConverter: ValueConverter;
-        LangiumParser: LangiumParser;
-        ParserErrorMessageProvider: IParserErrorMessageProvider;
-        CompletionParser: LangiumCompletionParser;
-        TokenBuilder: TokenBuilder;
-        Lexer: Lexer;
+    readonly parser: {
+        readonly AsyncParser: AsyncParser;
+        readonly GrammarConfig: GrammarConfig;
+        readonly ValueConverter: ValueConverter;
+        readonly LangiumParser: LangiumParser;
+        readonly ParserErrorMessageProvider: IParserErrorMessageProvider;
+        readonly CompletionParser: LangiumCompletionParser;
+        readonly TokenBuilder: TokenBuilder;
+        readonly Lexer: Lexer;
     };
-    documentation: {
-        CommentProvider: CommentProvider;
-        DocumentationProvider: DocumentationProvider;
+    readonly documentation: {
+        readonly CommentProvider: CommentProvider;
+        readonly DocumentationProvider: DocumentationProvider;
     };
-    references: {
-        Linker: Linker;
-        NameProvider: NameProvider;
-        References: References;
-        ScopeProvider: ScopeProvider;
-        ScopeComputation: ScopeComputation;
+    readonly references: {
+        readonly Linker: Linker;
+        readonly NameProvider: NameProvider;
+        readonly References: References;
+        readonly ScopeProvider: ScopeProvider;
+        readonly ScopeComputation: ScopeComputation;
     };
-    serializer: {
-        Hydrator: Hydrator;
-        JsonSerializer: JsonSerializer;
+    readonly serializer: {
+        readonly Hydrator: Hydrator;
+        readonly JsonSerializer: JsonSerializer;
     };
-    validation: {
-        DocumentValidator: DocumentValidator;
-        ValidationRegistry: ValidationRegistry;
+    readonly validation: {
+        readonly DocumentValidator: DocumentValidator;
+        readonly ValidationRegistry: ValidationRegistry;
     };
-    workspace: {
-        AstNodeLocator: AstNodeLocator;
-        AstNodeDescriptionProvider: AstNodeDescriptionProvider;
-        ReferenceDescriptionProvider: ReferenceDescriptionProvider;
+    readonly workspace: {
+        readonly AstNodeLocator: AstNodeLocator;
+        readonly AstNodeDescriptionProvider: AstNodeDescriptionProvider;
+        readonly ReferenceDescriptionProvider: ReferenceDescriptionProvider;
     };
-    shared: LangiumSharedCoreServices;
+    readonly shared: LangiumSharedCoreServices;
 };
 /**
  * The core set of services available for a language. These are either generated by `langium-cli`
@@ -13660,23 +12974,23 @@ type LangiumCoreServices = LangiumGeneratedCoreServices & LangiumDefaultCoreServ
  * derived from the grammar definition.
  */
 type LangiumGeneratedSharedCoreServices = {
-    AstReflection: AstReflection;
+    readonly AstReflection: AstReflection;
 };
 /**
  * Core services shared between multiple languages where Langium provides default implementations.
  */
 type LangiumDefaultSharedCoreServices = {
-    ServiceRegistry: ServiceRegistry;
-    workspace: {
-        ConfigurationProvider: ConfigurationProvider;
-        DocumentBuilder: DocumentBuilder;
-        FileSystemProvider: FileSystemProvider;
-        IndexManager: IndexManager;
-        LangiumDocuments: LangiumDocuments;
-        LangiumDocumentFactory: LangiumDocumentFactory;
-        TextDocuments?: TextDocumentProvider;
-        WorkspaceLock: WorkspaceLock;
-        WorkspaceManager: WorkspaceManager;
+    readonly ServiceRegistry: ServiceRegistry;
+    readonly workspace: {
+        readonly ConfigurationProvider: ConfigurationProvider;
+        readonly DocumentBuilder: DocumentBuilder;
+        readonly FileSystemProvider: FileSystemProvider;
+        readonly IndexManager: IndexManager;
+        readonly LangiumDocuments: LangiumDocuments;
+        readonly LangiumDocumentFactory: LangiumDocumentFactory;
+        readonly TextDocuments?: TextDocumentProvider;
+        readonly WorkspaceLock: WorkspaceLock;
+        readonly WorkspaceManager: WorkspaceManager;
     };
 };
 /**
@@ -13897,23 +13211,6 @@ interface DiagnosticFeatureShape {
     };
 }
 
-/**
- * We should use a mapped type to create this from Connection.
- */
-interface TextDocumentConnection {
-    onDidOpenTextDocument(handler: NotificationHandler<DidOpenTextDocumentParams>): Disposable$1;
-    onDidChangeTextDocument(handler: NotificationHandler<DidChangeTextDocumentParams>): Disposable$1;
-    onDidCloseTextDocument(handler: NotificationHandler<DidCloseTextDocumentParams>): Disposable$1;
-    onWillSaveTextDocument(handler: NotificationHandler<WillSaveTextDocumentParams>): Disposable$1;
-    onWillSaveTextDocumentWaitUntil(handler: RequestHandler<WillSaveTextDocumentParams, TextEdit$1[] | undefined | null, void>): Disposable$1;
-    onDidSaveTextDocument(handler: NotificationHandler<DidSaveTextDocumentParams>): Disposable$1;
-}
-interface TextDocumentsConfiguration<T extends {
-    uri: DocumentUri$1;
-}> {
-    create(uri: DocumentUri$1, languageId: string, version: number, content: string): T;
-    update(document: T, changes: TextDocumentContentChangeEvent[], version: number): T;
-}
 /**
  * Event to signal changes to a text document.
  */
@@ -13936,96 +13233,6 @@ interface TextDocumentWillSaveEvent<T> {
      */
     reason: TextDocumentSaveReason;
 }
-/**
- * A manager for simple text documents. The manager requires at a minimum that
- * the server registered for the following text document sync events in the
- * initialize handler or via dynamic registration:
- *
- * - open and close events.
- * - change events.
- *
- * Registering for save and will save events is optional.
- */
-declare class TextDocuments<T extends {
-    uri: DocumentUri$1;
-}> {
-    private readonly _configuration;
-    private readonly _syncedDocuments;
-    private readonly _onDidChangeContent;
-    private readonly _onDidOpen;
-    private readonly _onDidClose;
-    private readonly _onDidSave;
-    private readonly _onWillSave;
-    private _willSaveWaitUntil;
-    /**
-     * Create a new text document manager.
-     */
-    constructor(configuration: TextDocumentsConfiguration<T>);
-    /**
-     * An event that fires when a text document managed by this manager
-     * has been opened.
-     */
-    get onDidOpen(): Event<TextDocumentChangeEvent<T>>;
-    /**
-     * An event that fires when a text document managed by this manager
-     * has been opened or the content changes.
-     */
-    get onDidChangeContent(): Event<TextDocumentChangeEvent<T>>;
-    /**
-     * An event that fires when a text document managed by this manager
-     * will be saved.
-     */
-    get onWillSave(): Event<TextDocumentWillSaveEvent<T>>;
-    /**
-     * Sets a handler that will be called if a participant wants to provide
-     * edits during a text document save.
-     */
-    onWillSaveWaitUntil(handler: RequestHandler<TextDocumentWillSaveEvent<T>, TextEdit$1[], void>): void;
-    /**
-     * An event that fires when a text document managed by this manager
-     * has been saved.
-     */
-    get onDidSave(): Event<TextDocumentChangeEvent<T>>;
-    /**
-     * An event that fires when a text document managed by this manager
-     * has been closed.
-     */
-    get onDidClose(): Event<TextDocumentChangeEvent<T>>;
-    /**
-     * Returns the document for the given URI. Returns undefined if
-     * the document is not managed by this instance.
-     *
-     * @param uri The text document's URI to retrieve.
-     * @return the text document or `undefined`.
-     */
-    get(uri: string): T | undefined;
-    /**
-     * Returns all text documents managed by this instance.
-     *
-     * @return all text documents.
-     */
-    all(): T[];
-    /**
-     * Returns the URIs of all text documents managed by this instance.
-     *
-     * @return the URI's of all text documents.
-     */
-    keys(): string[];
-    /**
-     * Listens for `low level` notification on the given connection to
-     * update the text documents managed by this instance.
-     *
-     * Please note that the connection only provides handlers not an event model. Therefore
-     * listening on a connection will overwrite the following handlers on a connection:
-     * `onDidOpenTextDocument`, `onDidChangeTextDocument`, `onDidCloseTextDocument`,
-     * `onWillSaveTextDocument`, `onWillSaveTextDocumentWaitUntil` and `onDidSaveTextDocument`.
-     *
-     * Use the corresponding events on the TextDocuments instance instead.
-     *
-     * @param connection The connection to listen on.
-     */
-    listen(connection: TextDocumentConnection): Disposable$1;
-}
 
 /**
  * Shape of the notebooks feature
@@ -14819,6 +14026,11 @@ interface DefinitionProvider {
     /**
      * Handle a go to definition request.
      *
+     * @param document The document in which the request was triggered.
+     * @param params The parameters of the request.
+     * @param cancelToken A cancellation token that can be used to cancel the request.
+     * @returns A list of location links to the definition(s) of the symbol at the given position.
+     *
      * @throws `OperationCancelled` if cancellation is detected during execution
      * @throws `ResponseError` if an error is detected that should be sent as response to the client
      */
@@ -14838,6 +14050,10 @@ interface DocumentHighlightProvider {
     /**
      * Handle a document highlight request.
      *
+     * @param document The document in which the request was received.
+     * @param params The parameters of the document highlight request.
+     * @param cancelToken A cancellation token that can be used to cancel the request.
+     * @returns The document highlights or `undefined` if no highlights are available.
      * @throws `OperationCancelled` if cancellation is detected during execution
      * @throws `ResponseError` if an error is detected that should be sent as response to the client
      */
@@ -14848,7 +14064,7 @@ declare class DefaultDocumentHighlightProvider implements DocumentHighlightProvi
     protected readonly nameProvider: NameProvider;
     protected readonly grammarConfig: GrammarConfig;
     constructor(services: LangiumServices);
-    getDocumentHighlight(document: LangiumDocument, params: DocumentHighlightParams): MaybePromise<DocumentHighlight[] | undefined>;
+    getDocumentHighlight(document: LangiumDocument, params: DocumentHighlightParams, _cancelToken?: CancellationToken): MaybePromise<DocumentHighlight[] | undefined>;
     /**
     * Override this method to determine the highlight kind of the given reference.
     */
@@ -14911,6 +14127,11 @@ interface DocumentSymbolProvider {
     /**
      * Handle a document symbols request.
      *
+     * @param document The document in the workspace.
+     * @param params The parameters of the request.
+     * @param cancelToken A cancellation token that migh be used to cancel the request.
+     * @returns The symbols for the given document.
+     *
      * @throws `OperationCancelled` if cancellation is detected during execution
      * @throws `ResponseError` if an error is detected that should be sent as response to the client
      */
@@ -14927,17 +14148,40 @@ interface DocumentSymbolProvider {
  * Shared service for handling text document changes and watching relevant files.
  */
 interface DocumentUpdateHandler {
+    /**
+     * A document open event was triggered by the `TextDocuments` service.
+     * @param event The document change event.
+     */
     didOpenDocument?(event: TextDocumentChangeEvent<TextDocument>): void;
     /**
      * A content change event was triggered by the `TextDocuments` service.
+     * @param event The document change event.
      */
     didChangeContent?(event: TextDocumentChangeEvent<TextDocument>): void;
+    /**
+     * A document save event (initiated) was triggered by the `TextDocuments` service.
+     * @param event The document change event.
+     */
     willSaveDocument?(event: TextDocumentWillSaveEvent<TextDocument>): void;
+    /**
+     * A document save event (initiated) was triggered by the `TextDocuments` service.
+     * @param event The document change event.
+     * @returns An array of text edits which will be applied to the document before it is saved.
+     */
     willSaveDocumentWaitUntil?(event: TextDocumentWillSaveEvent<TextDocument>): MaybePromise<TextEdit$1[]>;
+    /**
+     * A document save event (completed) was triggered by the `TextDocuments` service.
+     * @param event The document change event.
+     */
     didSaveDocument?(event: TextDocumentChangeEvent<TextDocument>): void;
+    /**
+     * A document close event was triggered by the `TextDocuments` service.
+     * @param event The document change event.
+     */
     didCloseDocument?(event: TextDocumentChangeEvent<TextDocument>): void;
     /**
      * The client detected changes to files and folders watched by the language client.
+     * @param params The files/folders change event.
      */
     didChangeWatchedFiles?(params: DidChangeWatchedFilesParams): void;
 }
@@ -15019,6 +14263,11 @@ interface FoldingRangeProvider {
     /**
      * Handle a folding range request.
      *
+     * @param document The document to compute folding ranges for
+     * @param params The folding range parameters
+     * @param cancelToken A cancellation token that can be used to cancel the request
+     * @returns The computed folding ranges
+     *
      * @throws `OperationCancelled` if cancellation is detected during execution
      * @throws `ResponseError` if an error is detected that should be sent as response to the client
      */
@@ -15163,6 +14412,11 @@ interface ReferencesProvider {
     /**
      * Handle a find references request.
      *
+     * @param document The document in which to search for references.
+     * @param params The parameters of the find references request.
+     * @param cancelToken A cancellation token that can be used to cancel the request.
+     * @returns The locations of the references.
+     *
      * @throws `OperationCancelled` if cancellation is detected during execution
      * @throws `ResponseError` if an error is detected that should be sent as response to the client
      */
@@ -15182,6 +14436,11 @@ interface RenameProvider {
     /**
      * Handle a rename request.
      *
+     * @param document The document in which the rename request was triggered.
+     * @param params The rename parameters.
+     * @param cancelToken A cancellation token that can be used to cancel the request.
+     * @returns A workspace edit that describes the changes to be applied to the workspace.
+     *
      * @throws `OperationCancelled` if cancellation is detected during execution
      * @throws `ResponseError` if an error is detected that should be sent as response to the client
      */
@@ -15189,6 +14448,11 @@ interface RenameProvider {
     /**
      * Handle a prepare rename request.
      *
+     * @param document The document in which the prepare rename request was triggered.
+     * @param params The prepare rename parameters.
+     * @param cancelToken A cancellation token that can be used to cancel the request.
+     * @returns A range that describes the range of the symbol to be renamed.
+     *
      * @throws `OperationCancelled` if cancellation is detected during execution
      * @throws `ResponseError` if an error is detected that should be sent as response to the client
      */
@@ -15205,6 +14469,9 @@ interface SemanticTokenProvider {
     semanticHighlight(document: LangiumDocument, params: SemanticTokensParams, cancelToken?: CancellationToken): MaybePromise<SemanticTokens>;
     semanticHighlightRange(document: LangiumDocument, params: SemanticTokensRangeParams, cancelToken?: CancellationToken): MaybePromise<SemanticTokens>;
     semanticHighlightDelta(document: LangiumDocument, params: SemanticTokensDeltaParams, cancelToken?: CancellationToken): MaybePromise<SemanticTokens | SemanticTokensDelta>;
+    readonly tokenTypes: Record<string, number>;
+    readonly tokenModifiers: Record<string, number>;
+    readonly semanticTokensOptions: SemanticTokensOptions;
 }
 type SemanticTokenAcceptorOptions<N extends AstNode = AstNode> = ({
     line: number;
@@ -15280,6 +14547,9 @@ declare abstract class AbstractSemanticTokenProvider implements SemanticTokenPro
     protected clientCapabilities?: SemanticTokensClientCapabilities;
     constructor(services: LangiumServices);
     initialize(clientCapabilities?: SemanticTokensClientCapabilities): void;
+    get tokenTypes(): Record<string, number>;
+    get tokenModifiers(): Record<string, number>;
+    get semanticTokensOptions(): SemanticTokensOptions;
     semanticHighlight(document: LangiumDocument, _params: SemanticTokensParams, cancelToken?: CancellationToken): Promise<SemanticTokens>;
     semanticHighlightRange(document: LangiumDocument, params: SemanticTokensRangeParams, cancelToken?: CancellationToken): Promise<SemanticTokens>;
     semanticHighlightDelta(document: LangiumDocument, params: SemanticTokensDeltaParams, cancelToken?: CancellationToken): Promise<SemanticTokens | SemanticTokensDelta>;
@@ -15360,6 +14630,10 @@ interface WorkspaceSymbolProvider$1 {
     /**
      * Handle a workspace symbols request.
      *
+     * @param params workspaces symbols request parameters
+     * @param cancelToken a cancellation token tha can be used to cancel the request
+     * @returns a list of workspace symbols
+     *
      * @throws `OperationCancelled` if cancellation is detected during execution
      * @throws `ResponseError` if an error is detected that should be sent as response to the client
      */
@@ -15367,6 +14641,10 @@ interface WorkspaceSymbolProvider$1 {
     /**
      * Handle a resolve request for a workspace symbol.
      *
+     * @param symbol the workspace symbol to resolve
+     * @param cancelToken a cancellation token tha can be used to cancel the request
+     * @returns the resolved workspace symbol
+     *
      * @throws `OperationCancelled` if cancellation is detected during execution
      * @throws `ResponseError` if an error is detected that should be sent as response to the client
      */
@@ -15381,6 +14659,96 @@ declare class DefaultWorkspaceSymbolProvider implements WorkspaceSymbolProvider$
     protected getWorkspaceSymbol(astDescription: AstNodeDescription): WorkspaceSymbol | undefined;
 }
 
+/******************************************************************************
+ * Copyright 2024 TypeFox GmbH
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License, which is available in the project root.
+ ******************************************************************************/
+
+/**
+ * A manager service that keeps track of all currently opened text documents.
+ *
+ * Designed to be compatible with the `TextDocuments` class in the `vscode-languageserver` package.
+ */
+interface TextDocuments<T extends {
+    uri: string;
+}> {
+    /**
+     * An event that fires when a text document managed by this manager
+     * has been opened.
+     */
+    readonly onDidOpen: Event<TextDocumentChangeEvent<T>>;
+    /**
+     * An event that fires when a text document managed by this manager
+     * has been opened or the content changes.
+     */
+    readonly onDidChangeContent: Event<TextDocumentChangeEvent<T>>;
+    /**
+     * An event that fires when a text document managed by this manager
+     * will be saved.
+     */
+    readonly onWillSave: Event<TextDocumentWillSaveEvent<T>>;
+    /**
+     * Sets a handler that will be called if a participant wants to provide
+     * edits during a text document save.
+     */
+    onWillSaveWaitUntil(handler: RequestHandler<TextDocumentWillSaveEvent<T>, TextEdit$1[], void>): void;
+    /**
+     * An event that fires when a text document managed by this manager
+     * has been saved.
+     */
+    readonly onDidSave: Event<TextDocumentChangeEvent<T>>;
+    /**
+     * An event that fires when a text document managed by this manager
+     * has been closed.
+     */
+    readonly onDidClose: Event<TextDocumentChangeEvent<T>>;
+    /**
+     * Returns the document for the given URI. Returns undefined if
+     * the document is not managed by this instance.
+     *
+     * @param uri The text document's URI to retrieve.
+     * @return the text document or `undefined`.
+     */
+    get(uri: string | URI): T | undefined;
+    /**
+     * Sets the text document managed by this instance.
+     * @param document The text document to add.
+     * @returns `true` if the document didn't exist yet, `false` if it was already present.
+     */
+    set(document: T): boolean;
+    /**
+     * Deletes a text document managed by this instance.
+     */
+    delete(uri: string | URI | T): void;
+    /**
+     * Returns all text documents managed by this instance.
+     *
+     * @return all text documents.
+     */
+    all(): T[];
+    /**
+     * Returns the URIs of all text documents managed by this instance.
+     *
+     * @return the URI's of all text documents.
+     */
+    keys(): string[];
+    /**
+     * Listens for `low level` notification on the given connection to
+     * update the text documents managed by this instance.
+     *
+     * Please note that the connection only provides handlers not an event model. Therefore
+     * listening on a connection will overwrite the following handlers on a connection:
+     * `onDidOpenTextDocument`, `onDidChangeTextDocument`, `onDidCloseTextDocument`,
+     * `onWillSaveTextDocument`, `onWillSaveTextDocumentWaitUntil` and `onDidSaveTextDocument`.
+     *
+     * Use the corresponding events on the TextDocuments instance instead.
+     *
+     * @param connection The connection to listen on.
+     */
+    listen(connection: Connection): Disposable$1;
+}
+
 /******************************************************************************
  * Copyright 2023 TypeFox GmbH
  * This program and the accompanying materials are made available under the
@@ -15399,46 +14767,46 @@ type LangiumSharedServices = LangiumSharedCoreServices & LangiumSharedLSPService
  * LSP services for a specific language of which Langium provides default implementations.
  */
 type LangiumLSPServices = {
-    lsp: {
-        CompletionProvider?: CompletionProvider;
-        DocumentHighlightProvider?: DocumentHighlightProvider;
-        DocumentSymbolProvider?: DocumentSymbolProvider;
-        HoverProvider?: HoverProvider;
-        FoldingRangeProvider?: FoldingRangeProvider;
-        DefinitionProvider?: DefinitionProvider;
-        TypeProvider?: TypeDefinitionProvider;
-        ImplementationProvider?: ImplementationProvider;
-        ReferencesProvider?: ReferencesProvider;
-        CodeActionProvider?: CodeActionProvider;
-        SemanticTokenProvider?: SemanticTokenProvider;
-        RenameProvider?: RenameProvider;
-        Formatter?: Formatter;
-        SignatureHelp?: SignatureHelpProvider;
-        CallHierarchyProvider?: CallHierarchyProvider;
-        TypeHierarchyProvider?: TypeHierarchyProvider;
-        DeclarationProvider?: DeclarationProvider;
-        InlayHintProvider?: InlayHintProvider;
-        CodeLensProvider?: CodeLensProvider;
-        DocumentLinkProvider?: DocumentLinkProvider;
+    readonly lsp: {
+        readonly CompletionProvider?: CompletionProvider;
+        readonly DocumentHighlightProvider?: DocumentHighlightProvider;
+        readonly DocumentSymbolProvider?: DocumentSymbolProvider;
+        readonly HoverProvider?: HoverProvider;
+        readonly FoldingRangeProvider?: FoldingRangeProvider;
+        readonly DefinitionProvider?: DefinitionProvider;
+        readonly TypeProvider?: TypeDefinitionProvider;
+        readonly ImplementationProvider?: ImplementationProvider;
+        readonly ReferencesProvider?: ReferencesProvider;
+        readonly CodeActionProvider?: CodeActionProvider;
+        readonly SemanticTokenProvider?: SemanticTokenProvider;
+        readonly RenameProvider?: RenameProvider;
+        readonly Formatter?: Formatter;
+        readonly SignatureHelp?: SignatureHelpProvider;
+        readonly CallHierarchyProvider?: CallHierarchyProvider;
+        readonly TypeHierarchyProvider?: TypeHierarchyProvider;
+        readonly DeclarationProvider?: DeclarationProvider;
+        readonly InlayHintProvider?: InlayHintProvider;
+        readonly CodeLensProvider?: CodeLensProvider;
+        readonly DocumentLinkProvider?: DocumentLinkProvider;
     };
-    shared: LangiumSharedServices;
+    readonly shared: LangiumSharedServices;
 };
 /**
  * LSP services shared between multiple languages of which Langium provides default implementations.
  */
 type LangiumSharedLSPServices = {
-    lsp: {
-        Connection?: Connection;
-        DocumentUpdateHandler: DocumentUpdateHandler;
-        ExecuteCommandHandler?: ExecuteCommandHandler;
-        FileOperationHandler?: FileOperationHandler;
-        FuzzyMatcher: FuzzyMatcher;
-        LanguageServer: LanguageServer;
-        NodeKindProvider: NodeKindProvider$1;
-        WorkspaceSymbolProvider?: WorkspaceSymbolProvider$1;
+    readonly lsp: {
+        readonly Connection?: Connection;
+        readonly DocumentUpdateHandler: DocumentUpdateHandler;
+        readonly ExecuteCommandHandler?: ExecuteCommandHandler;
+        readonly FileOperationHandler?: FileOperationHandler;
+        readonly FuzzyMatcher: FuzzyMatcher;
+        readonly LanguageServer: LanguageServer;
+        readonly NodeKindProvider: NodeKindProvider$1;
+        readonly WorkspaceSymbolProvider?: WorkspaceSymbolProvider$1;
     };
-    workspace: {
-        TextDocuments: TextDocuments<TextDocument>;
+    readonly workspace: {
+        readonly TextDocuments: TextDocuments<TextDocument>;
     };
 };
 
@@ -15533,6 +14901,10 @@ interface CompletionProvider {
     /**
      * Handle a completion request.
      *
+     * @param document - the document for which the completion request was triggered
+     * @param params - the completion parameters
+     * @param cancelToken - a token that can be used to cancel the request
+     *
      * @throws `OperationCancelled` if cancellation is detected during execution
      * @throws `ResponseError` if an error is detected that should be sent as response to the client
      */
@@ -15555,8 +14927,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.
      *
@@ -15619,8 +14992,35 @@ interface ChangeViewRequestParams {
     change: ViewChange;
 }
 
+declare class LikeC4CodeLensProvider implements CodeLensProvider {
+    private services;
+    constructor(services: LikeC4Services);
+    provideCodeLens(doc: LangiumDocument, _params: CodeLensParams, cancelToken?: CancellationToken): Promise<CodeLens[] | undefined>;
+}
+
+declare class LikeC4CompletionProvider extends DefaultCompletionProvider {
+    readonly completionOptions: {
+        triggerCharacters: string[];
+    };
+}
+
+declare class LikeC4DocumentHighlightProvider extends DefaultDocumentHighlightProvider {
+    /**
+     * Override this method to determine the highlight kind of the given reference.
+     */
+    protected createDocumentHighlight(reference: ReferenceDescription): DocumentHighlight;
+}
+
+declare class LikeC4DocumentLinkProvider implements DocumentLinkProvider {
+    private services;
+    constructor(services: LikeC4Services);
+    getDocumentLinks(doc: LangiumDocument, _params: DocumentLinkParams): MaybePromise<DocumentLink[]>;
+    resolveLink(doc: LangiumDocument, link: string): string;
+    relativeLink(doc: LangiumDocument, link: string): string | null;
+}
+
 /******************************************************************************
- * This file was generated by langium-cli 3.1.1.
+ * This file was generated by langium-cli 3.2.0.
  * DO NOT EDIT MANUALLY!
  ******************************************************************************/
 
@@ -16401,7 +15801,7 @@ type ParsedElementStyle = {
     opacity?: number;
 };
 interface ParsedAstSpecification {
-    tags: Set<Tag$2>;
+    tags: Set<Tag$1>;
     elements: Record<ElementKind$1, {
         technology?: string;
         notation?: string;
@@ -16426,7 +15826,7 @@ interface ParsedAstElement {
     title: string;
     description?: string;
     technology?: string;
-    tags?: NonEmptyArray<Tag$2>;
+    tags?: NonEmptyArray<Tag$1>;
     links?: NonEmptyArray<ParsedLink>;
     style: ParsedElementStyle;
     metadata?: {
@@ -16439,7 +15839,7 @@ interface ParsedAstRelation {
     source: Fqn$1;
     target: Fqn$1;
     kind?: RelationshipKind$1;
-    tags?: NonEmptyArray<Tag$2>;
+    tags?: NonEmptyArray<Tag$1>;
     title: string;
     description?: string;
     technology?: string;
@@ -16461,7 +15861,7 @@ interface ParsedAstElementView {
     astPath: string;
     title: string | null;
     description: string | null;
-    tags: NonEmptyArray<Tag$2> | null;
+    tags: NonEmptyArray<Tag$1> | null;
     links: NonEmptyArray<ParsedLink> | null;
     rules: ViewRule$1[];
     manualLayout?: ViewManualLayout;
@@ -16472,7 +15872,7 @@ interface ParsedAstDynamicView {
     astPath: string;
     title: string | null;
     description: string | null;
-    tags: NonEmptyArray<Tag$2> | null;
+    tags: NonEmptyArray<Tag$1> | null;
     links: NonEmptyArray<ParsedLink> | null;
     steps: DynamicViewStepOrParallel[];
     rules: Array<DynamicViewRule$1>;
@@ -16496,38 +15896,11 @@ interface LikeC4DocumentProps {
     c4Views?: ParsedAstView[];
     c4fqnIndex?: MultiMap<Fqn$1, DocFqnIndexAstNodeDescription>;
 }
-interface LikeC4LangiumDocument extends Omit<LangiumDocument<LikeC4Grammar>, 'diagnostics'>, LikeC4DocumentProps {
-}
-interface FqnIndexedDocument extends Omit<LangiumDocument<LikeC4Grammar>, 'diagnostics'>, SetRequired<LikeC4DocumentProps, 'c4fqnIndex'> {
-}
-interface ParsedLikeC4LangiumDocument extends Omit<LangiumDocument<LikeC4Grammar>, 'diagnostics'>, Required<LikeC4DocumentProps> {
-}
-
-declare class LikeC4CodeLensProvider implements CodeLensProvider {
-    private services;
-    constructor(services: LikeC4Services);
-    provideCodeLens(doc: LangiumDocument, _params: CodeLensParams, cancelToken?: CancellationToken): Promise<CodeLens[] | undefined>;
-}
-
-declare class LikeC4CompletionProvider extends DefaultCompletionProvider {
-    readonly completionOptions: {
-        triggerCharacters: string[];
-    };
-}
-
-declare class LikeC4DocumentHighlightProvider extends DefaultDocumentHighlightProvider {
-    /**
-     * Override this method to determine the highlight kind of the given reference.
-     */
-    protected createDocumentHighlight(reference: ReferenceDescription): DocumentHighlight;
+interface LikeC4LangiumDocument extends Omit<LangiumDocument<LikeC4Grammar>, 'diagnostics'>, LikeC4DocumentProps {
 }
-
-declare class LikeC4DocumentLinkProvider implements DocumentLinkProvider {
-    private services;
-    constructor(services: LikeC4Services);
-    getDocumentLinks(doc: LangiumDocument, _params: DocumentLinkParams): MaybePromise<DocumentLink[]>;
-    resolveLink(doc: LangiumDocument, link: string): string;
-    relativeLink(doc: LangiumDocument, link: string): string | null;
+interface FqnIndexedDocument extends Omit<LangiumDocument<LikeC4Grammar>, 'diagnostics'>, SetRequired<LikeC4DocumentProps, 'c4fqnIndex'> {
+}
+interface ParsedLikeC4LangiumDocument extends Omit<LangiumDocument<LikeC4Grammar>, 'diagnostics'>, Required<LikeC4DocumentProps> {
 }
 
 declare class LikeC4DocumentSymbolProvider implements DocumentSymbolProvider {
@@ -16560,6 +15933,98 @@ declare class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider
     private highlightAstElement;
     private highlightView;
 }
+declare class FqnIndex {
+    private services;
+    protected langiumDocuments: LangiumDocuments;
+    constructor(services: LikeC4Services);
+    get documents(): Stream<FqnIndexedDocument>;
+    private entries;
+    getFqn(el: Element): Fqn$1 | null;
+    byFqn(fqn: Fqn$1): Stream<AstNodeDescription>;
+    directChildrenOf(parent: Fqn$1): Stream<AstNodeDescription>;
+    /**
+     * Returns descedant elements with unique names in the scope
+     */
+    uniqueDescedants(parent: Fqn$1): Stream<AstNodeDescription>;
+}
+
+type ModelParsedListener$1 = (docs: URI[]) => void;
+declare class LikeC4ModelBuilder {
+    private services;
+    private langiumDocuments;
+    private listeners;
+    constructor(services: LikeC4Services);
+    /**
+     * WARNING:
+     * This method is internal and should to be called only when all documents are known to be parsed.
+     * Otherwise, the model may be incomplete.
+     */
+    unsafeSyncBuildModel(): ParsedLikeC4Model | null;
+    buildModel(cancelToken?: CancellationToken): Promise<ParsedLikeC4Model | null>;
+    private previousViews;
+    /**
+     * WARNING:
+     * This method is internal and should to be called only when all documents are known to be parsed.
+     * Otherwise, the model may be incomplete.
+     */
+    unsafeSyncBuildComputedModel(model: ParsedLikeC4Model): ComputedLikeC4Model;
+    buildComputedModel(cancelToken?: CancellationToken): Promise<ComputedLikeC4Model | null>;
+    computeView(viewId: ViewID$1, cancelToken?: CancellationToken): Promise<ComputedView | null>;
+    onModelParsed(callback: ModelParsedListener$1): Disposable;
+    private documents;
+    private notifyListeners;
+}
+
+declare class LikeC4ModelLocator {
+    private services;
+    private fqnIndex;
+    private langiumDocuments;
+    constructor(services: LikeC4Services);
+    private documents;
+    getParsedElement(astNode: Element): ParsedAstElement | null;
+    locateElement(fqn: Fqn$1, _prop?: string): Location | null;
+    locateRelation(relationId: RelationID$1): Location | null;
+    locateViewAst(viewId: ViewID$1): {
+        doc: ParsedLikeC4LangiumDocument;
+        view: ParsedAstView;
+        viewAst: LikeC4View;
+    };
+    locateView(viewId: ViewID$1): Location | null;
+}
+declare class LikeC4ModelParser {
+    private services;
+    private fqnIndex;
+    constructor(services: LikeC4Services);
+    parse(doc: LangiumDocument | LangiumDocument[]): ParsedLikeC4LangiumDocument[];
+    protected parseLikeC4Document(_doc: FqnIndexedDocument): ParsedLikeC4LangiumDocument;
+    private parseSpecification;
+    private parseModel;
+    private parseElement;
+    private parseRelation;
+    private parseViews;
+    private parseViewRulePredicate;
+    private parsePredicate;
+    private parseElementExpressionsIterator;
+    private parseElementPredicate;
+    private parseElementExpr;
+    private parseElementPredicateWith;
+    private parseElementPredicateWhere;
+    private parseRelationPredicate;
+    private parseRelationPredicateWhere;
+    private parseRelationPredicateWith;
+    private parseRelationExpr;
+    private parseViewRule;
+    private parseViewManualLaout;
+    private parseDynamicParallelSteps;
+    private parseDynamicStep;
+    private parseElementView;
+    private parseDynamicElementView;
+    protected resolveFqn(node: Element | ExtendElement): Fqn$1;
+    private getAstNodePath;
+    private getMetadata;
+    private convertTags;
+    private convertLinks;
+}
 
 declare class LikeC4ModelChanges {
     private services;
@@ -16677,97 +16142,63 @@ interface LikeC4AddedServices {
     shared?: LikeC4SharedServices;
 }
 type LikeC4Services = LangiumServices & LikeC4AddedServices;
-declare class FqnIndex {
-    private services;
-    protected langiumDocuments: LangiumDocuments;
-    constructor(services: LikeC4Services);
-    get documents(): Stream<FqnIndexedDocument>;
-    private entries;
-    getFqn(el: Element): Fqn$1 | null;
-    byFqn(fqn: Fqn$1): Stream<AstNodeDescription>;
-    directChildrenOf(parent: Fqn$1): Stream<AstNodeDescription>;
-    /**
-     * Returns descedant elements with unique names in the scope
-     */
-    uniqueDescedants(parent: Fqn$1): Stream<AstNodeDescription>;
-}
 
-type ModelParsedListener$1 = (docs: URI[]) => void;
-declare class LikeC4ModelBuilder {
-    private services;
-    private langiumDocuments;
-    private listeners;
-    constructor(services: LikeC4Services);
-    /**
-     * WARNING:
-     * This method is internal and should to be called only when all documents are known to be parsed.
-     * Otherwise, the model may be incomplete.
-     */
-    unsafeSyncBuildModel(): ParsedLikeC4Model | null;
-    buildModel(cancelToken?: CancellationToken): Promise<ParsedLikeC4Model | null>;
-    private previousViews;
-    /**
-     * WARNING:
-     * This method is internal and should to be called only when all documents are known to be parsed.
-     * Otherwise, the model may be incomplete.
-     */
-    unsafeSyncBuildComputedModel(model: ParsedLikeC4Model): ComputedLikeC4Model;
-    buildComputedModel(cancelToken?: CancellationToken): Promise<ComputedLikeC4Model | null>;
-    computeView(viewId: ViewID$1, cancelToken?: CancellationToken): Promise<ComputedView | null>;
-    onModelParsed(callback: ModelParsedListener$1): Disposable;
-    private documents;
-    private notifyListeners;
+/**
+ * @hidden
+ */
+type $keywords<T extends string> = {
+  [key in T]: key;
+};
+
+declare module 'ts-graphviz' {
+    namespace ClusterSubgraphAttributeKey {
+        interface $values extends $keywords<'likec4_type' | 'likec4_path' | 'likec4_id' | 'likec4_level' | 'likec4_depth'> {
+        }
+    }
+    namespace NodeAttributeKey {
+        interface $values extends $keywords<'likec4_type' | 'likec4_path' | 'likec4_id' | 'likec4_level'> {
+        }
+    }
+    namespace EdgeAttributeKey {
+        interface $values extends $keywords<'likec4_id'> {
+        }
+    }
+    namespace Attribute {
+        interface $keys extends $keywords<'likec4_type' | 'likec4_path' | 'likec4_id' | 'likec4_level' | 'likec4_depth'> {
+        }
+        interface $types {
+            likec4_type: 'folder' | 'file' | 'view';
+            likec4_path: string;
+            likec4_id: string;
+            likec4_level: number;
+            likec4_depth: number;
+        }
+    }
 }
+type DotSource = Tagged<string, 'DotSource'>;
 
-declare class LikeC4ModelLocator {
-    private services;
-    private fqnIndex;
-    private langiumDocuments;
-    constructor(services: LikeC4Services);
-    private documents;
-    getParsedElement(astNode: Element): ParsedAstElement | null;
-    locateElement(fqn: Fqn$1, _prop?: string): Location | null;
-    locateRelation(relationId: RelationID$1): Location | null;
-    locateViewAst(viewId: ViewID$1): {
-        doc: ParsedLikeC4LangiumDocument;
-        view: ParsedAstView;
-        viewAst: LikeC4View;
-    };
-    locateView(viewId: ViewID$1): Location | null;
+interface GraphvizPort {
+    unflatten(dot: DotSource): Promise<DotSource>;
+    acyclic(dot: DotSource): Promise<DotSource>;
+    layoutJson(dot: DotSource): Promise<string>;
+    svg(dot: DotSource): Promise<string>;
 }
-declare class LikeC4ModelParser {
-    private services;
-    private fqnIndex;
-    constructor(services: LikeC4Services);
-    parse(doc: LangiumDocument | LangiumDocument[]): ParsedLikeC4LangiumDocument[];
-    protected parseLikeC4Document(_doc: FqnIndexedDocument): ParsedLikeC4LangiumDocument;
-    private parseSpecification;
-    private parseModel;
-    private parseElement;
-    private parseRelation;
-    private parseViews;
-    private parseViewRulePredicate;
-    private parsePredicate;
-    private parseElementExpressionsIterator;
-    private parseElementPredicate;
-    private parseElementExpr;
-    private parseElementPredicateWith;
-    private parseElementPredicateWhere;
-    private parseRelationPredicate;
-    private parseRelationPredicateWhere;
-    private parseRelationPredicateWith;
-    private parseRelationExpr;
-    private parseViewRule;
-    private parseViewManualLaout;
-    private parseDynamicParallelSteps;
-    private parseDynamicStep;
-    private parseElementView;
-    private parseDynamicElementView;
-    protected resolveFqn(node: Element | ExtendElement): Fqn$1;
-    private getAstNodePath;
-    private getMetadata;
-    private convertTags;
-    private convertLinks;
+type LayoutResult = {
+    dot: DotSource;
+    diagram: DiagramView;
+};
+declare class GraphvizLayouter {
+    private graphviz;
+    constructor(graphviz: GraphvizPort);
+    get port(): GraphvizPort;
+    changePort(graphviz: GraphvizPort): void;
+    layout(view: ComputedView): Promise<LayoutResult>;
+    svg(view: ComputedView): Promise<{
+        svg: string;
+        dot: DotSource;
+    }>;
+    dot(computedView: ComputedView): Promise<DotSource>;
+    layoutOverviewGraph(views: ComputedView[]): Promise<OverviewGraph>;
 }
 
 // This definition file follows a somewhat unusual format. ESTree allows
@@ -17405,8 +16836,12 @@ type CliAddedServices = {
 type CliServices = LikeC4Services & CliAddedServices;
 
 type GraphvizOut = {
+    dot: string;
+    diagram: DiagramView;
+};
+type GraphvizSvgOut = {
     id: ViewID$1;
-    dot: DotSource;
+    dot: string;
     svg: string;
 };
 declare class Views {
@@ -17418,9 +16853,9 @@ declare class Views {
     constructor(services: CliServices);
     private inflightRequest;
     computedViews(): Promise<ComputedView[]>;
-    layoutViews(): Promise<Array<Readonly<DotLayoutResult>>>;
+    layoutViews(): Promise<Array<Readonly<GraphvizOut>>>;
     diagrams(): Promise<Array<DiagramView>>;
-    viewsAsGraphvizOut(): Promise<Array<GraphvizOut>>;
+    viewsAsGraphvizOut(): Promise<Array<GraphvizSvgOut>>;
     overviewGraph(): Promise<OverviewGraph>;
 }
 
@@ -17440,9 +16875,10 @@ type LikeC4Options = {
     throwIfInvalid?: boolean;
     /**
      * Logger to use for the language service.
+     * false - no output
      * @default 'default'
      */
-    logger?: Logger | 'vite' | 'default';
+    logger?: Logger | 'vite' | 'default' | false;
     /**
      * Whether to use the `dot` binary for layouting or the WebAssembly version.
      * @default 'wasm'
@@ -17458,19 +16894,37 @@ declare class LikeC4 {
      * Prevents multiple instances of LikeC4 for the same workspace
      */
     private static likec4Instances;
-    static fromWorkspace(path: string, opts?: LikeC4Options): Promise<LikeC4>;
-    private cachedModel;
+    /**
+     * Initializes a LikeC4 instance from the specified workspace path.
+     * By default in current folder
+     */
+    static fromWorkspace(path?: string, opts?: LikeC4Options): Promise<LikeC4>;
+    private modelComputedRef;
+    private modelLayoutedRef;
     private logger;
     private langiumDocuments;
     readonly views: Views;
     private constructor();
-    computed(): Promise<ComputedLikeC4Model>;
-    model(): LikeC4Model;
     /**
      * Diagram is a computed view, layouted using Graphviz
      * Used in React components
      */
     diagrams(): Promise<DiagramView[]>;
+    /**
+     * @deprecated use computedModel
+     */
+    model(): LikeC4Model.Computed;
+    /**
+     * Synchronously builds architecture model
+     * Only compute views predicates {@link ComputedView} - i.e. no layout
+     * Not ready for rendering, but enough to traverse
+     */
+    computedModel(): LikeC4Model.Computed;
+    /**
+     * Same as {@link computedModel()}, after applies layout
+     * Ready for rendering
+     */
+    layoutedModel(): Promise<LikeC4Model.Layouted>;
     getErrors(): {
         message: string;
         line: number;
@@ -17489,8 +16943,11 @@ declare class LikeC4 {
         changed?: string;
         removed?: string;
     }): Promise<boolean>;
+    /**
+     * @returns a function to dispose the listener
+     */
     onModelUpdate(listener: () => void): () => void;
     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, 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, type LayoutedLikeC4Model, LikeC4, LikeC4DiagramModel, 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$1 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, parentFqn };