likec4 1.48.0 → 1.50.0

package/dist/_chunks/index2.d.mts

@@ -1,266 +1,880 @@
 import { n as ServerOptions, t as McpServer } from "./libs/@modelcontextprotocol/sdk.mjs";
 import { a as LikeC4ProjectConfig, i as IncludeConfig, o as LikeC4ProjectConfigInput } from "./index.mjs";
-import { $ as DefaultLangiumDocuments, A as NotificationType, B as Scope, C as CodeActionParams, Ct as WorkspaceFolder, D as SemanticTokensDeltaParams, E as DocumentSymbolParams, F as DefaultScopeComputation, G as WorkspaceCache, H as DefaultIndexManager, I as DefaultValueConverter, J as AstNode, K as AsyncDisposable, L as ValueType, M as DefaultDocumentValidator, N as ValidationOptions, O as SemanticTokensParams, P as DiagnosticInfo, Q as ReferenceInfo, R as MaybePromise, S as BuildOptions, St as TextEdit, T as DocumentLinkParams, Tt as URI, U as ReferenceDescription, V as DocumentationProvider, W as DefaultNameProvider, X as CstNode, Y as AstNodeDescription, Z as Reference, _ as CodeLensProvider, _t as Location, a as LangiumServices, at as FileSystemNode, b as DefaultWorkspaceManager, bt as SemanticTokensDelta, c as AbstractSemanticTokenProvider, ct as CodeLens, d as AbstractFormatter, dt as Diagnostic, et as LangiumDocument, f as FormattingRegion, ft as DocumentHighlight, g as DefaultDocumentHighlightProvider, gt as Hover, h as DocumentLinkProvider, ht as FormattingOptions, i as NextFeature, it as Stream, j as RequestType, k as SemanticTokensRangeParams, l as SemanticTokenAcceptor, lt as Command, m as NodeKindProvider, mt as DocumentSymbol, n as CompletionContext, nt as PrecomputedScopes, o as LangiumSharedServices, ot as FileSystemProvider, p as DocumentSymbolProvider, pt as DocumentLink, q as Disposable$1, r as DefaultCompletionProvider, rt as CancellationToken$1, s as DefaultWorkspaceSymbolProvider, st as CodeAction, t as CompletionAcceptor, tt as LangiumDocumentFactory, u as AstNodeHoverProvider, ut as CompletionItemKind, v as CodeActionProvider, vt as Range, w as CodeLensParams, wt as Keyword, x as FileSelector, xt as SymbolKind, yt as SemanticTokens, z as DefaultScopeProvider } from "./libs/langium.mjs";
+import { $ as PrecomputedScopes, A as ValidationOptions, B as ReferenceDescription, C as CodeLensParams, Ct as TextEdit, D as SemanticTokensParams, E as SemanticTokensDeltaParams, F as MaybePromise, G as AstNode, H as WorkspaceCache, I as DefaultScopeProvider, J as Reference, K as AstNodeDescription, L as Scope, M as DefaultScopeComputation, N as DefaultValueConverter, O as SemanticTokensRangeParams, P as ValueType, Q as LangiumDocumentFactory, R as JSDocDocumentationProvider, S as CodeActionParams, St as SymbolKind, T as DocumentSymbolParams, U as AsyncDisposable, V as DefaultNameProvider, W as Disposable$1, X as DefaultLangiumDocuments, Y as ReferenceInfo, Z as LangiumDocument, _ as CodeLensProvider, _t as Hover, a as LangiumServices, at as CancellationToken$1, b as FileSelector, bt as SemanticTokens, c as AbstractSemanticTokenProvider, ct as CodeAction, d as AbstractFormatter, dt as CompletionItemKind, et as Stream, f as FormattingRegion, ft as Diagnostic, g as DefaultDocumentHighlightProvider, gt as FormattingOptions, h as DocumentLinkProvider, ht as DocumentSymbol, i as NextFeature, it as URI, j as DiagnosticInfo, k as DefaultDocumentValidator, l as SemanticTokenAcceptor, lt as CodeLens, m as NodeKindProvider, mt as DocumentLink, n as CompletionContext, nt as FileSystemProvider, o as LangiumSharedServices, ot as NotificationType, p as DocumentSymbolProvider, pt as DocumentHighlight, q as CstNode, r as DefaultCompletionProvider, rt as Keyword, s as DefaultWorkspaceSymbolProvider, st as RequestType, t as CompletionAcceptor, tt as FileSystemNode, u as AstNodeHoverProvider, ut as Command, v as CodeActionProvider, vt as Location, w as DocumentLinkParams, wt as WorkspaceFolder, x as BuildOptions, xt as SemanticTokensDelta, y as DefaultWorkspaceManager, yt as Range, z as DefaultIndexManager } from "./libs/langium.mjs";
 import { t as $keywords } from "./libs/ts-graphviz.mjs";
-import { Fqn, LayoutedView, ProjectId, ViewId } from "@likec4/core/types";
+import { ElementModel, LikeC4Model } from "@likec4/core/model";
 import * as c4 from "@likec4/core";
-import { AnyAux, ComputedView, DeploymentFqn, DiagramView, EdgeId, Fqn as Fqn$1, LayoutType, LayoutedView as LayoutedView$1, LikeC4Styles, NonEmptyArray, NonEmptyReadonlyArray, ProjectId as ProjectId$1, RelationId, UnknownComputed, UnknownLayouted, UnknownParsed, ViewChange as ViewChange$1, ViewId as ViewId$1, aux as aux$1 } from "@likec4/core";
+import { AnyAux, ComputedView, DeploymentFqn, DiagramView, EdgeId, Fqn, LayoutType, LayoutedView, LikeC4Styles, NonEmptyArray, NonEmptyReadonlyArray, ProjectId, RelationId, Tag, UnknownComputed, UnknownLayouted, UnknownParsed, ViewChange, ViewId, aux } from "@likec4/core";
+import { LikeC4Styles as LikeC4Styles$1 } from "@likec4/core/styles";
+import { Fqn as Fqn$1, GuardedBy, LayoutedView as LayoutedView$1, ProjectId as ProjectId$1, ViewId as ViewId$1 } from "@likec4/core/types";
 import { DefaultWeakMap, MultiMap } from "@likec4/core/utils";
-import { LikeC4Model } from "@likec4/core/model";
 import { AdhocViewPredicate, ComputedProjectsView, LayoutedProjectsView } from "@likec4/core/compute-view";
 import * as type_fest0 from "type-fest";
 import { ConditionalPick, MergeExclusive, Simplify, Tagged, ValueOf, Writable } from "type-fest";
 
-//#region ../language-server/dist/_chunks/ast.d.mts
-type AnyProperty = DynamicViewProperty | ElementProperty | RelationProperty | StringProperty | ViewProperty;
-declare const AnyProperty = "AnyProperty";
-type ArrowType = 'crow' | 'diamond' | 'dot' | 'none' | 'normal' | 'odiamond' | 'odot' | 'onormal' | 'open' | 'vee';
-type BorderStyleValue = 'none' | LineOptions;
-type ColorLiteral = HexColor | RGBAColor;
-declare const ColorLiteral = "ColorLiteral";
-type CustomColorId = 'element' | 'model' | ArrowType | ElementShape | LineOptions | Participant | string;
-type DeploymentElement = DeployedInstance | DeploymentNode;
-declare const DeploymentElement = "DeploymentElement";
-type DeploymentNodeOrElementKind = DeploymentNodeKind | ElementKind;
-declare const DeploymentNodeOrElementKind = "DeploymentNodeOrElementKind";
-type DeploymentViewRule = DeploymentViewRulePredicate | DeploymentViewRuleStyle | ViewRuleAutoLayout;
-declare const DeploymentViewRule = "DeploymentViewRule";
-type DynamicViewDisplayVariantValue = 'diagram' | 'sequence';
-type DynamicViewProperty = DynamicViewDisplayVariantProperty | ViewProperty;
-declare const DynamicViewProperty = "DynamicViewProperty";
-type DynamicViewRule = DynamicViewGlobalPredicateRef | DynamicViewIncludePredicate | ViewRuleAutoLayout | ViewRuleStyleOrGlobalRef;
-declare const DynamicViewRule = "DynamicViewRule";
-type DynamicViewStep = DynamicStepChain | DynamicStepSingle;
-declare const DynamicViewStep = "DynamicViewStep";
-type ElementProperty = ElementStringProperty | ElementStyleProperty | IconProperty | LinkProperty | MetadataProperty;
-declare const ElementProperty = "ElementProperty";
-type ElementShape = 'browser' | 'bucket' | 'cylinder' | 'document' | 'mobile' | 'person' | 'queue' | 'rectangle' | 'storage';
-type ExpressionV2 = FqnExprOrWith | RelationExprOrWith;
-declare const ExpressionV2 = "ExpressionV2";
-type ExtendElementProperty = LinkProperty | MetadataProperty;
-declare const ExtendElementProperty = "ExtendElementProperty";
-type ExtendRelationProperty = LinkProperty | MetadataProperty;
-declare const ExtendRelationProperty = "ExtendRelationProperty";
-type FqnExpr$2 = ElementKindExpression | ElementTagExpression | FqnRefExpr | WildcardExpression;
-declare const FqnExpr$2 = "FqnExpr";
-type FqnExprOrWhere = FqnExpr$2 | FqnExprWhere;
-declare const FqnExprOrWhere = "FqnExprOrWhere";
-type FqnExprOrWith = FqnExprOrWhere | FqnExprWith;
-declare const FqnExprOrWith = "FqnExprOrWith";
-type FqnReferenceable = Element | ExtendDeployment | ExtendElement | Referenceable;
-declare const FqnReferenceable = "FqnReferenceable";
-type IconId = string;
-type IconPositionValue = 'bottom' | 'left' | 'right' | 'top';
-type Id = 'deployment' | 'element' | 'group' | 'instance' | 'model' | 'node' | ArrowType | DynamicViewDisplayVariantValue | ElementShape | IconPositionValue | LineOptions | Participant | RankValue | SizeValue | ThemeColor | string;
-type LikeC4View = DeploymentView | DynamicView | ElementView;
-declare const LikeC4View = "LikeC4View";
-type LineOptions = 'dashed' | 'dotted' | 'solid';
-type MetadataProperty = MetadataBody;
-declare const MetadataProperty = "MetadataProperty";
-type MetadataValue = MarkdownOrString | MetadataArray;
-declare const MetadataValue = "MetadataValue";
-type ModelReferenceable = Element | Imported;
-declare const ModelReferenceable = "ModelReferenceable";
-type Participant = 'source' | 'target';
-type RankValue = 'max' | 'min' | 'same' | 'sink' | 'source';
-type Referenceable = DeployedInstance | DeploymentNode | Element | Imported;
-declare const Referenceable = "Referenceable";
-type RelationExpr$1 = DirectedRelationExpr | InOutRelationExpr | IncomingRelationExpr | OutgoingRelationExpr;
-declare const RelationExpr$1 = "RelationExpr";
-type RelationExprOrWhere = RelationExpr$1 | RelationExprWhere;
-declare const RelationExprOrWhere = "RelationExprOrWhere";
-type RelationExprOrWith = RelationExprOrWhere | RelationExprWith;
-declare const RelationExprOrWith = "RelationExprOrWith";
-type RelationProperty = LinkProperty | MetadataProperty | RelationNavigateToProperty | RelationStringProperty | RelationStyleProperty;
-declare const RelationProperty = "RelationProperty";
-type RelationshipStyleProperty = ArrowProperty | ColorProperty | LineProperty;
-declare const RelationshipStyleProperty = "RelationshipStyleProperty";
-type SizeProperty = IconSizeProperty | PaddingSizeProperty | ShapeSizeProperty | TextSizeProperty;
-declare const SizeProperty = "SizeProperty";
-type SizeValue = 'large' | 'lg' | 'md' | 'medium' | 'sm' | 'small' | 'xl' | 'xlarge' | 'xs' | 'xsmall';
-type StringProperty = ElementStringProperty | MetadataAttribute | NotationProperty | NotesProperty | RelationStringProperty | SpecificationElementStringProperty | SpecificationRelationshipStringProperty | ViewStringProperty;
-declare const StringProperty = "StringProperty";
-type StyleProperty = BorderProperty | ColorProperty | IconColorProperty | IconPositionProperty | IconProperty | IconSizeProperty | MultipleProperty | OpacityProperty | PaddingSizeProperty | ShapeProperty | ShapeSizeProperty | TextSizeProperty;
-declare const StyleProperty = "StyleProperty";
-type ThemeColor = 'amber' | 'blue' | 'gray' | 'green' | 'indigo' | 'muted' | 'primary' | 'red' | 'secondary' | 'sky' | 'slate';
-type Uri = string;
-type ViewLayoutDirection = 'BottomTop' | 'LeftRight' | 'RightLeft' | 'TopBottom';
-type ViewProperty = LinkProperty | ViewStringProperty;
-declare const ViewProperty = "ViewProperty";
-type ViewRule = ViewRuleAutoLayout | ViewRuleGlobalPredicateRef | ViewRuleGroup | ViewRulePredicate | ViewRuleRank | ViewRuleStyleOrGlobalRef;
-declare const ViewRule = "ViewRule";
-type ViewRuleStyleOrGlobalRef = ViewRuleGlobalStyle | ViewRuleStyle;
-declare const ViewRuleStyleOrGlobalRef = "ViewRuleStyleOrGlobalRef";
-type WhereElement = WhereElementKind | WhereElementTag;
-declare const WhereElement = "WhereElement";
-type WhereElementExpression = WhereBinaryExpression | WhereElement | WhereElementNegation;
-declare const WhereElementExpression = "WhereElementExpression";
-type WhereExpression = WhereElementExpression | WhereRelationExpression;
-declare const WhereExpression = "WhereExpression";
-type WhereKindEqual = WhereElementKind | WhereRelationKind | WhereRelationParticipantKind;
-declare const WhereKindEqual = "WhereKindEqual";
-type WhereRelation = WhereRelationKind | WhereRelationParticipantKind | WhereRelationParticipantTag | WhereRelationTag;
-declare const WhereRelation = "WhereRelation";
-type WhereRelationExpression = WhereBinaryExpression | WhereRelation | WhereRelationNegation;
-declare const WhereRelationExpression = "WhereRelationExpression";
-type WhereTagEqual = WhereElementTag | WhereRelationParticipantTag | WhereRelationTag;
-declare const WhereTagEqual = "WhereTagEqual";
-interface AbstractDynamicStep extends AstNode {
-  readonly $container: DynamicStepChain | DynamicViewBody | DynamicViewParallelSteps;
-  readonly $type: 'AbstractDynamicStep' | 'DynamicStepChain' | 'DynamicStepSingle';
-  custom?: CustomRelationProperties;
-  dotKind?: RelationKindDotRef;
-  kind?: Reference<RelationshipKind>;
-  target: ElementRef;
-  title?: string;
-}
-declare const AbstractDynamicStep = "AbstractDynamicStep";
-interface ArrowProperty extends AstNode {
-  readonly $container: CustomRelationProperties | RelationStyleProperty | SpecificationRelationshipKind;
-  readonly $type: 'ArrowProperty';
-  key: 'head' | 'tail';
-  value: ArrowType;
-}
-declare const ArrowProperty = "ArrowProperty";
-interface BorderProperty extends AstNode {
-  readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleGroup | ViewRuleStyle;
-  readonly $type: 'BorderProperty';
-  key: 'border';
-  value: BorderStyleValue;
-}
-declare const BorderProperty = "BorderProperty";
-interface ColorProperty extends AstNode {
-  readonly $container: CustomElementProperties | CustomRelationProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | RelationStyleProperty | SpecificationRelationshipKind | ViewRuleGroup | ViewRuleStyle;
-  readonly $type: 'ColorProperty';
-  customColor?: Reference<CustomColor>;
-  key: 'color';
-  themeColor?: ThemeColor;
+//#region ../language-server/dist/_chunks/protocol.d.mts
+/**
+ * When server requests to open a likec4 preview panel
+ * (available only in the editor).
+ * (not the best place, but seems to be working)
+ */
+declare namespace DidRequestOpenViewNotification {
+  type Params = {
+    viewId: ViewId;
+    projectId: ProjectId;
+  };
+  const type: NotificationType<Params>;
+  type Type = typeof type;
 }
-declare const ColorProperty = "ColorProperty";
-interface CustomColor extends AstNode {
-  readonly $container: SpecificationColor;
-  readonly $type: 'CustomColor';
-  name: CustomColorId;
+/**
+ * Request to fetch the computed model data
+ * If LSP has multiple projects, the projectId is required.
+ * otherwise throws an error.
+ */
+/**
+ * Request to locate an element, relation, deployment or view.
+ * If LSP has multiple projects, the projectId is required.
+ */
+declare namespace Locate {
+  type Params =
+  /**
+   * Locate an element by its fqn
+   */
+  {
+    element: Fqn;
+    projectId?: string | undefined;
+    property?: string;
+  }
+  /**
+   * Locate a relation by its id
+   */
+  | {
+    projectId?: string | undefined;
+    relation: RelationId;
+  }
+  /**
+   * Locate a deployment by its fqn
+   */
+  | {
+    deployment: DeploymentFqn;
+    projectId?: string | undefined;
+    property?: string;
+  }
+  /**
+   * Locate a step in a dynamic view by its astPath
+   */
+  | {
+    view: ViewId;
+    astPath: string;
+    projectId?: string | undefined;
+  }
+  /**
+   * Locate a view by its id
+   */
+  | {
+    view: ViewId;
+    projectId?: string | undefined;
+  };
+  type Res = Location | null;
+  const req: RequestType<Params, Res, void>;
+  type Req = typeof req;
 }
-declare const CustomColor = "CustomColor";
-interface CustomElementProperties extends AstNode {
-  readonly $container: FqnExprWith;
-  readonly $type: 'CustomElementProperties';
-  props: Array<ElementStringProperty | NavigateToProperty | NotationProperty | StyleProperty>;
+/**
+ * Request to change the view
+ * If LSP has multiple projects, the projectId is required.
+ */
+declare namespace ChangeView {
+  type Params = {
+    viewId: ViewId;
+    change: ViewChange;
+    projectId?: string | undefined;
+  };
+  type Res = {
+    success: true;
+    location: Location | null;
+  } | {
+    success: false;
+    location?: Location | null;
+    error: string;
+  };
+  const req: RequestType<Params, Res, void>;
+  type Req = typeof req;
 }
-declare const CustomElementProperties = "CustomElementProperties";
-interface CustomRelationProperties extends AstNode {
-  readonly $container: AbstractDynamicStep | RelationExprWith;
-  readonly $type: 'CustomRelationProperties';
-  props: Array<NotationProperty | NotesProperty | RelationNavigateToProperty | RelationStringProperty | RelationshipStyleProperty>;
+/**
+ * Request to fetch telemetry metrics
+ */
+//#endregion
+//#region ../layouts/dist/_chunks/GraphvizLayoter.d.mts
+//#region src/graphviz/types.d.ts
+/**
+ * Partially implements CancellationToken interface from vscode-jsonrpc
+ */
+type CancellationToken = {
+  /**
+   * Is `true` when the token has been cancelled, `false` otherwise.
+   */
+  readonly isCancellationRequested: boolean;
+};
+declare module 'ts-graphviz' {
+  namespace GraphAttributeKey {
+    interface $values extends $keywords<'likec4_viewId'> {}
+  }
+  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_project' | 'likec4_level'> {}
+  }
+  namespace EdgeAttributeKey {
+    interface $values extends $keywords<'likec4_id' | 'likec4_project'> {}
+  }
+  namespace Attribute {
+    interface $keys extends $keywords<'likec4_viewId' | 'likec4_type' | 'likec4_path' | 'likec4_id' | 'likec4_project' | 'likec4_level' | 'likec4_depth'> {}
+    interface $types {
+      likec4_viewId: string;
+      likec4_type: 'folder' | 'file' | 'view';
+      likec4_path: string;
+      likec4_id: string;
+      likec4_project: string;
+      likec4_level: number;
+      likec4_depth: number;
+    }
+  }
 }
-declare const CustomRelationProperties = "CustomRelationProperties";
-interface DeployedInstance extends AstNode {
-  readonly $container: DeploymentNodeBody | ExtendDeploymentBody;
-  readonly $type: 'DeployedInstance';
-  body?: DeployedInstanceBody;
-  name?: Id;
-  summary?: string;
-  target: ElementRef;
-  title?: string;
-}
-declare const DeployedInstance = "DeployedInstance";
-interface DeployedInstanceBody extends AstNode {
-  readonly $container: DeployedInstance;
-  readonly $type: 'DeployedInstanceBody';
-  elements: Array<DeploymentRelation>;
-  props: Array<ElementProperty>;
-  tags?: Tags;
+type DotSource = Tagged<string, 'DotSource'>; //#endregion
+//#region src/graphviz/types-dot.d.ts
+type GvNodeName = Tagged<string, 'GvNodeName'>;
+type GvId = Tagged<number, 'GvId'>;
+type Point = [x: number, y: number];
+interface GraphvizJson {
+  name: GvNodeName;
+  directed: boolean;
+  strict: boolean;
+  _draw_: GraphvizJson.Draw[];
+  bb: string;
+  compound: string;
+  fontname: string;
+  fontsize: string;
+  label: string;
+  nodesep: string;
+  outputorder: string;
+  rankdir: string;
+  ranksep: string;
+  splines: string;
+  xdotversion: string;
+  _subgraph_cnt: number;
+  objects?: GraphvizJson.GvObject[];
+  edges?: GraphvizJson.Edge[];
 }
-declare const DeployedInstanceBody = "DeployedInstanceBody";
-interface DeploymentNode extends AstNode {
-  readonly $container: DeploymentNodeBody | ExtendDeploymentBody | ModelDeployments;
-  readonly $type: 'DeploymentNode';
-  body?: DeploymentNodeBody;
-  kind: Reference<DeploymentNodeKind>;
-  name: Id;
-  summary?: string;
-  title?: string;
+declare namespace GraphvizJson {
+  interface Draw {
+    op: string;
+    grad: string;
+    color: string;
+    points: Point[];
+  }
+  interface Draw2 {
+    op: string;
+    grad: string;
+    color: string;
+    points: Point[];
+  }
+  namespace DrawOps {
+    type Style = {
+      op: 'S';
+      style: string;
+    };
+    type BSpline = {
+      op: 'b' | 'B';
+      points: Point[];
+    };
+    type Color = {
+      op: 'c';
+      grad: string;
+      color: string;
+    };
+    type Polygon = {
+      op: 'p' | 'P';
+      points: Point[];
+    };
+  }
+  type DrawOp = DrawOps.Style | DrawOps.BSpline | DrawOps.Color | DrawOps.Polygon;
+  type LabelDrawOps = {
+    op: 'F';
+    size: number;
+    face: string;
+  } | {
+    op: 'c';
+    color: string;
+  } | {
+    op: 't';
+    fontchar: number;
+  } | {
+    op: 'T';
+    pt: Point;
+    align: 'l' | 'r' | 'c';
+    width: number;
+    text: string;
+  };
+  type GvObject = GvNodeObject | GvSubgraph;
+  interface GvSubgraph {
+    bb: string;
+    label?: string;
+    compound: 'true';
+    _ldraw_?: LabelDrawOps[];
+    likec4_type?: 'folder' | 'file';
+    likec4_path?: string;
+    likec4_id?: Fqn;
+    likec4_level?: number;
+    likec4_depth?: number;
+    _gvid: GvId;
+    subgraphs?: GvId[];
+    nodes?: GvId[];
+    edges?: GvId[];
+  }
+  interface GvNodeObject {
+    _draw_: Draw[];
+    _ldraw_?: LabelDrawOps[];
+    likec4_type?: 'folder' | 'file' | 'view';
+    likec4_path?: string;
+    likec4_id?: Fqn;
+    likec4_level?: number;
+    _gvid: GvId;
+    height: string;
+    pos: string;
+    shape: 'rect';
+    width: string;
+    label?: string;
+  }
+  interface Draw3 {
+    op: string;
+    grad: string;
+    color: string;
+    points: Point[];
+  }
+  interface Hdraw {
+    op: string;
+    style: string;
+    grad: string;
+    color: string;
+    points: Point[];
+  }
+  interface Edge {
+    _gvid: GvId;
+    tail: GvId;
+    head: GvId;
+    dir?: 'forward' | 'back' | 'both' | 'none';
+    _draw_: DrawOp[];
+    _hdraw_?: DrawOp[];
+    _tdraw_?: DrawOp[];
+    _ldraw_?: LabelDrawOps[];
+    _tldraw_?: LabelDrawOps[];
+    _hldraw_?: LabelDrawOps[];
+    fontname: string;
+    fontsize: string;
+    likec4_id?: EdgeId;
+    label: string;
+    lp: string;
+    nojustify?: 'true' | 'false';
+    pos?: string;
+  }
+} //#endregion
+//#region src/graphviz/GraphvizLayoter.d.ts
+interface GraphvizPort extends Disposable {
+  get concurrency(): number;
+  unflatten(dot: DotSource): Promise<DotSource>;
+  acyclic(dot: DotSource): Promise<DotSource>;
+  layoutJson(dot: DotSource): Promise<string>;
+  svg(dot: DotSource): Promise<string>;
+  dispose(): void;
 }
-declare const DeploymentNode = "DeploymentNode";
-interface DeploymentNodeBody extends AstNode {
-  readonly $container: DeploymentNode;
-  readonly $type: 'DeploymentNodeBody';
-  elements: Array<DeployedInstance | DeploymentNode | DeploymentRelation>;
-  props: Array<ElementProperty>;
-  tags?: Tags;
+type LayoutTaskParams<A extends aux.Any = aux.Any> = {
+  view: ComputedView<A>;
+  styles: LikeC4Styles;
+};
+type LayoutResult<A extends aux.Any = aux.Any> = {
+  dot: DotSource;
+  diagram: DiagramView<A>;
+};
+declare class GraphvizLayouter implements Disposable {
+  private graphviz;
+  constructor(graphviz?: GraphvizPort);
+  dispose(): void;
+  [Symbol.dispose](): void;
+  get graphvizPort(): GraphvizPort;
+  changePort(graphviz: GraphvizPort): void;
+  dotToJson(dot: DotSource): Promise<GraphvizJson>;
+  layout<A extends AnyAux>(params: LayoutTaskParams<A>): Promise<LayoutResult<A>>;
+  svg<A extends AnyAux>(params: LayoutTaskParams<A>): Promise<{
+    svg: string;
+    dot: DotSource;
+  }>;
+  dot<A extends AnyAux>(params: LayoutTaskParams<A>): Promise<DotSource>;
+  layoutProjectsView(view: ComputedProjectsView): Promise<LayoutedProjectsView>;
+} //#endregion
+//#endregion
+//#region ../layouts/dist/index.d.mts
+//#region src/graphviz/QueueGraphvizLayoter.d.ts
+declare class QueueGraphvizLayoter extends GraphvizLayouter {
+  private queue;
+  private isProcessingBatch;
+  constructor(options?: {
+    graphviz?: GraphvizPort;
+    /**
+     * Concurrency limit.
+     * Minimum: `1`.
+     * @default 2
+     */
+    concurrency?: number;
+    /**
+     * Per-operation timeout in milliseconds. Operations fulfill once `timeout` elapses if they haven't already.
+     * @default 20_000
+     */
+    timeout?: number;
+    /**
+     * Whether or not a timeout is considered an exception.
+     * @default true
+     */
+    throwOnTimeout?: boolean;
+  });
+  private runInQueue;
+  changePort(graphvizPort: GraphvizPort): void;
+  layout<A extends AnyAux>(params: LayoutTaskParams<A>): Promise<LayoutResult<A>>;
+  layoutProjectsView(view: ComputedProjectsView): Promise<LayoutedProjectsView>;
+  batchLayout<A extends AnyAux>(params: {
+    batch: LayoutTaskParams<A>[];
+    cancelToken?: CancellationToken | undefined;
+    onSuccess?: (task: LayoutTaskParams<A>, result: LayoutResult<A>) => void;
+    onError?: (task: LayoutTaskParams<A>, error: unknown) => void;
+  }): Promise<LayoutResult<A>[]>;
+  dispose(): void;
+} //#endregion
+//#region src/graphviz/wasm/GraphvizWasmAdapter.d.ts
+//#endregion
+//#region ../language-server/dist/_chunks/module.d.mts
+//#region src/documentation/documentation-provider.d.ts
+/**
+ * Provides documentation for LikeC4 AST nodes, extending JSDoc parsing
+ * with specialized formatting for deployment nodes, deployed instances, and elements.
+ */
+declare class LikeC4DocumentationProvider extends JSDocDocumentationProvider {
+  private parser;
+  private locator;
+  /**
+   * Creates a new documentation provider.
+   * @param services - The LikeC4 language services.
+   */
+  constructor(services: LikeC4Services);
+  /**
+   * Returns documentation for the given AST node (deployment nodes, deployed instances, elements, or JSDoc fallback).
+   * @param node - The AST node to document.
+   * @returns Formatted documentation string, or undefined if none.
+   */
+  getDocumentation(node: AstNode): string | undefined;
+} //#endregion
+//#region src/workspace/ProjectsManager.d.ts
+type DocOrUri = LangiumDocument | string | URI;
+/**
+ * A tagged string that represents a project folder URI
+ * Always has trailing slash.
+ */
+type ProjectFolder = Tagged<string, 'ProjectFolder'>;
+declare function ProjectFolder(folder: URI | string): ProjectFolder;
+interface Project {
+  id: ProjectId$1;
+  folderUri: URI;
+  config: LikeC4ProjectConfig;
 }
-declare const DeploymentNodeBody = "DeploymentNodeBody";
-interface DeploymentNodeKind extends AstNode {
-  readonly $container: SpecificationDeploymentNodeKind;
-  readonly $type: 'DeploymentNodeKind';
-  name: Id;
-}
-declare const DeploymentNodeKind = "DeploymentNodeKind";
-interface DeploymentRelation extends AstNode {
-  readonly $container: DeployedInstanceBody | DeploymentNodeBody | ExtendDeploymentBody | ModelDeployments;
-  readonly $type: 'DeploymentRelation';
-  body?: DeploymentRelationBody;
-  description?: string;
-  dotKind?: RelationKindDotRef;
-  kind?: Reference<RelationshipKind>;
-  source?: FqnRef$2;
-  tags?: Tags;
-  target: FqnRef$2;
-  technology?: string;
-  title?: string;
+interface ProjectData extends Project {
+  id: ProjectId$1;
+  folder: ProjectFolder;
+  config: LikeC4ProjectConfig;
+  configUri: URI;
+  folderUri: URI;
+  exclude?: {
+    (test: string): boolean;
+  };
+  /**
+   * Resolved include paths with both URI and folder string representations.
+   * These are additional directories that are part of this project.
+   */
+  includePaths?: NonEmptyArray<{
+    uri: URI;
+    folder: ProjectFolder;
+  }>;
+  /**
+   * Normalized include configuration (paths, maxDepth, fileThreshold).
+   */
+  includeConfig: IncludeConfig;
 }
-declare const DeploymentRelation = "DeploymentRelation";
-interface DeploymentRelationBody extends AstNode {
-  readonly $container: DeploymentRelation;
-  readonly $type: 'DeploymentRelationBody';
-  props: Array<RelationProperty>;
-  tags?: Tags;
+type RegisterProjectOptions = {
+  config: LikeC4ProjectConfig | LikeC4ProjectConfigInput;
+} & ({
+  configUri: URI | string;
+} | {
+  folderUri: URI | string;
+});
+declare class ProjectsManager {
+  #private;
+  protected services: LikeC4SharedServices;
+  /**
+   * The global project ID used for all documents
+   * that are not part of a specific project.
+   */
+  static readonly DefaultProjectId: ProjectId$1;
+  constructor(services: LikeC4SharedServices);
+  /**
+   * Returns:
+   *  - configured default project ID if set
+   *  - the default project ID if there are no projects.
+   *  - the ID of the only project
+   *  - undefined if there are multiple projects.
+   */
+  get defaultProjectId(): ProjectId$1 | undefined;
+  set defaultProjectId(id: string | ProjectId$1 | undefined);
+  get default(): ProjectData;
+  get all(): NonEmptyReadonlyArray<ProjectId$1>;
+  getProject(arg: ProjectId$1 | LangiumDocument): ProjectData;
+  /**
+   * Returns all projects that overlap with the specified folder (is parent or child)
+   */
+  findOverlaped(folder: URI | string): ProjectData[];
+  /**
+   * Validates and ensures the project ID.
+   * If no project ID is specified, returns default project ID
+   * If there are multiple projects and default project is not set, throws an error
+   */
+  ensureProjectId(projectId?: ProjectId$1 | undefined): ProjectId$1;
+  /**
+   * Validates and ensures the project.
+   */
+  ensureProject(projectId?: ProjectId$1 | undefined): ProjectData;
+  hasMultipleProjects(): boolean;
+  /**
+   * Checks if the specified document should be excluded from processing.
+   */
+  isExcluded(document: DocOrUri): boolean;
+  isExcluded(projectId: ProjectId$1, document: DocOrUri): boolean;
+  /**
+   * Checks if the specified document is included by the project:
+   * - if the document belongs to the project and is not excluded
+   * - if the document is included by the project
+   */
+  isIncluded(projectId: ProjectId$1, document: LangiumDocument | URI | string): boolean;
+  /**
+   * Registers likec4 project by config file.
+   */
+  registerConfigFile(configUri: URI, cancelToken?: CancellationToken$1): Promise<ProjectData>;
+  /**
+   * Registers (or reloads) likec4 project by config file or config object.
+   * If there is some project registered at same folder, it will be reloaded.
+   */
+  registerProject(opts: RegisterProjectOptions, cancelToken?: CancellationToken$1): Promise<ProjectData>;
+  /**
+   * Determines which project the given document belongs to.
+   * If the document does not belong to any project, returns the default project ID.
+   */
+  ownerProjectId(document: LangiumDocument | URI | string): ProjectId$1;
+  reloadProjects(cancelToken?: CancellationToken$1): Promise<void>;
+  protected _reloadProjects(cancelToken?: CancellationToken$1): Promise<void>;
+  protected uniqueProjectId(name: string): ProjectId$1;
+  protected resetCaches(): void;
+  rebuildProject(projectId: ProjectId$1, cancelToken?: CancellationToken$1): Promise<void>;
+  /**
+   * Returns all include paths from all projects.
+   * Used by WorkspaceManager to scan additional directories for C4 files.
+   */
+  getAllIncludePaths(): Array<{
+    projectId: ProjectId$1;
+    includePath: URI;
+    includeConfig: IncludeConfig;
+  }>;
+  /**
+   * Register a listener to be called when the projects configuration has changed.
+   * @returns A disposable that can be used to unregister the callback.
+   */
+  onProjectsUpdate(callback: () => void): Disposable$1;
+  private getWorkspaceFolder;
+  private notifyListeners;
+  private updateIncludesExcludes;
+} //#endregion
+//#region src/filesystem/types.d.ts
+interface FileNode extends FileSystemNode {
+  readonly isFile: true;
+  readonly isDirectory: false;
 }
-declare const DeploymentRelationBody = "DeploymentRelationBody";
-interface DeploymentView extends AstNode {
-  readonly $container: ModelViews;
-  readonly $type: 'DeploymentView';
-  body?: DeploymentViewBody;
-  name: Id;
+interface FileSystemProvider$1 extends FileSystemProvider {
+  /**
+   * Scans the project files for the given URI.
+   * @returns The list of file system entries that are contained within the specified directory.
+   */
+  scanProjectFiles(folderUri: URI): Promise<FileNode[]>;
+  /**
+   * Loads the project config from the given file.
+   * @returns The project config.
+   * @throws Error if the file does not exist or is not a valid project config.
+   */
+  loadProjectConfig(filepath: URI): Promise<LikeC4ProjectConfig>;
+  /**
+   * Reads the directory information for the given URI.
+   * @param options.recursive If true, recursively reads the directory,
+   * @param options.maxDepth Maximum depth to traverse when recursive is true (default: Infinity)
+   */
+  readDirectory(uri: URI, options?: {
+    recursive?: boolean;
+    maxDepth?: number;
+  }): Promise<FileNode[]>;
+  /**
+   * Finds all files in the given directory, matching the given filter.
+   */
+  scanDirectory(directory: URI, filter: (filepath: string) => boolean): Promise<FileNode[]>;
+  /**
+   * Writes the content to the file system.
+   * Used by manual layouts.
+   */
+  writeFile(uri: URI, content: string): Promise<void>;
+  /**
+   * Deletes the file from the file system.
+   * Used by manual layouts.
+   * @return true if the file was deleted, false if the file did not exist.
+   */
+  deleteFile(uri: URI): Promise<boolean>;
 }
-declare const DeploymentView = "DeploymentView";
-interface DeploymentViewBody extends AstNode {
-  readonly $container: DeploymentView;
-  readonly $type: 'DeploymentViewBody';
-  props: Array<ViewProperty>;
-  rules: Array<DeploymentViewRule>;
-  tags?: Tags;
+interface FileSystemWatcher extends AsyncDisposable {
+  /**
+   * Watches a folder for changes and triggers a reload of the documents and projects.
+   */
+  watch(folder: string): void;
 }
-declare const DeploymentViewBody = "DeploymentViewBody";
-interface DeploymentViewRulePredicate extends AstNode {
-  readonly $container: DeploymentViewBody;
-  readonly $type: 'DeploymentViewRulePredicate';
-  expr: Expressions;
-  isInclude: boolean;
+type ManualLayoutsSnapshot = {
+  hash: string;
+  views: Record<ViewId$1, LayoutedView$1>;
+};
+interface LikeC4ManualLayouts {
+  read(project: Project): Promise<ManualLayoutsSnapshot | null>;
+  write(project: Project, layouted: LayoutedView$1): Promise<Location>;
+  remove(project: Project, view: ViewId$1): Promise<Location | null>;
+  clearCaches(): void;
+} //#endregion
+//#region src/filesystem/noop.d.ts
+//#endregion
+//#region src/formatting/LikeC4Formatter.d.ts
+type QuoteStyle = 'single' | 'double' | 'ignore' | 'auto';
+interface LikeC4FormatterOptions {
+  quoteStyle: QuoteStyle;
 }
-declare const DeploymentViewRulePredicate = "DeploymentViewRulePredicate";
-interface DeploymentViewRuleStyle extends AstNode {
-  readonly $container: DeploymentViewBody;
-  readonly $type: 'DeploymentViewRuleStyle';
-  props: Array<NotationProperty | StyleProperty>;
-  targets: FqnExpressions;
+type ExtendedFormattingCommandType = 'normalizeQuotes';
+interface ExtendedFormattingCommand {
+  type: ExtendedFormattingCommandType;
+  region: FormattingRegion;
 }
-declare const DeploymentViewRuleStyle = "DeploymentViewRuleStyle";
-interface DirectedRelationExpr extends AstNode {
-  readonly $container: Expressions | RelationExprWhere | RelationExprWith;
-  readonly $type: 'DirectedRelationExpr';
-  source: OutgoingRelationExpr;
-  target: FqnExpr$2;
+declare class LikeC4Formatter extends AbstractFormatter {
+  protected options: LikeC4FormatterOptions;
+  extendedFormattingCommands: ExtendedFormattingCommand[];
+  constructor(services: LikeC4Services);
+  protected doDocumentFormat(document: LangiumDocument, options: FormattingOptions, range?: Range): TextEdit[];
+  protected format(node: AstNode): void;
+  protected formatTags(node: AstNode): void;
+  protected formatDeploymentRelation(node: AstNode): void;
+  protected formatExtendDeployment(node: AstNode): void;
+  protected formatRelation(node: AstNode): void;
+  protected removeIndentFromTopLevelStatements(node: AstNode): void;
+  protected indentContentInBraces(node: AstNode): void;
+  protected appendKeywordsWithSpace(node: AstNode): void;
+  protected formatView(node: AstNode): void;
+  protected formatLeafProperty(node: AstNode): void;
+  protected formatLinkProperty(node: AstNode): void;
+  protected formatNavigateToProperty(node: AstNode): void;
+  protected formatAutolayoutProperty(node: AstNode): void;
+  protected formatMetadataProperty(node: AstNode): void;
+  protected formatElementDeclaration(node: AstNode): void;
+  protected formatExtendElement(node: AstNode): void;
+  protected formatGlobals(node: AstNode): void;
+  protected formatImports(node: AstNode): void;
+  protected formatSpecificationRule(node: AstNode): void;
+  protected formatWithPredicate(node: AstNode): void;
+  protected formatDeploymentNodeDeclaration(node: AstNode): void;
+  protected formatDeployedInstance(node: AstNode): void;
+  protected formatViewRuleGlobalStyle(node: AstNode): void;
+  protected formatViewRuleGlobalPredicate(node: AstNode): void;
+  protected formatViewRuleGroup(node: AstNode): void;
+  protected formatViewRuleStyle(node: AstNode): void;
+  protected formatWhereExpression(node: AstNode): void;
+  protected formatWhereRelationExpression(node: AstNode): void;
+  protected formatWhereElementExpression(node: AstNode): void;
+  protected formatIncludeExcludeExpressions(node: AstNode): void;
+  protected formatRelationExpression(node: AstNode): void;
+  private findPredicateExpressionRoot;
+  private on;
+  private doExtendedFormatting;
+  protected normalizeQuotes(node: AstNode): void;
+  private quotesNormalizerFactory;
+  private escapeQuotesInternalQuotes;
+  private getAutoQuoteStyle;
+  private onConfigurationUpdate;
+} //#endregion
+//#region src/mcp/types.d.ts
+interface LikeC4MCPServer {
+  readonly mcp: McpServer;
+  readonly isStarted: boolean;
+  readonly port: number;
+  start(port?: number): Promise<void>;
+  stop(): Promise<void>;
 }
-declare const DirectedRelationExpr = "DirectedRelationExpr";
-interface DynamicView extends AstNode {
-  readonly $container: ModelViews;
-  readonly $type: 'DynamicView';
-  body?: DynamicViewBody;
-  name: Id;
+interface LikeC4MCPServerFactory {
+  create(options?: ServerOptions): McpServer;
 }
-declare const DynamicView = "DynamicView";
+//#endregion
+//#region src/generated/ast.d.ts
+type AnyProperty = DynamicViewProperty | ElementProperty | RelationProperty | StringProperty | ViewProperty;
+declare const AnyProperty = "AnyProperty";
+type ArrowType = 'crow' | 'diamond' | 'dot' | 'none' | 'normal' | 'odiamond' | 'odot' | 'onormal' | 'open' | 'vee';
+type BorderStyleValue = 'none' | LineOptions;
+type ColorLiteral$1 = HexColor | RGBAColor;
+declare const ColorLiteral$1 = "ColorLiteral";
+type CustomColorId = 'element' | 'model' | ArrowType | ElementShape | LineOptions | Participant | string;
+type DeploymentElement = DeployedInstance | DeploymentNode;
+declare const DeploymentElement = "DeploymentElement";
+type DeploymentNodeOrElementKind = DeploymentNodeKind | ElementKind;
+declare const DeploymentNodeOrElementKind = "DeploymentNodeOrElementKind";
+type DeploymentViewRule = DeploymentViewRulePredicate | DeploymentViewRuleStyle | ViewRuleAutoLayout;
+declare const DeploymentViewRule = "DeploymentViewRule";
+type DynamicViewDisplayVariantValue = 'diagram' | 'sequence';
+type DynamicViewProperty = DynamicViewDisplayVariantProperty | ViewProperty;
+declare const DynamicViewProperty = "DynamicViewProperty";
+type DynamicViewRule = DynamicViewGlobalPredicateRef | DynamicViewIncludePredicate | ViewRuleAutoLayout | ViewRuleStyleOrGlobalRef;
+declare const DynamicViewRule = "DynamicViewRule";
+type DynamicViewStep = DynamicStepChain | DynamicStepSingle;
+declare const DynamicViewStep = "DynamicViewStep";
+type ElementProperty = ElementStringProperty | ElementStyleProperty | IconProperty | LinkProperty | MetadataProperty;
+declare const ElementProperty = "ElementProperty";
+type ElementShape = 'browser' | 'bucket' | 'component' | 'cylinder' | 'document' | 'mobile' | 'person' | 'queue' | 'rectangle' | 'storage';
+type ExpressionV2 = FqnExprOrWith | RelationExprOrWith;
+declare const ExpressionV2 = "ExpressionV2";
+type ExtendElementProperty = LinkProperty | MetadataProperty;
+declare const ExtendElementProperty = "ExtendElementProperty";
+type ExtendRelationProperty = LinkProperty | MetadataProperty;
+declare const ExtendRelationProperty = "ExtendRelationProperty";
+type FqnExpr$2 = ElementKindExpression | ElementTagExpression | FqnRefExpr | WildcardExpression;
+declare const FqnExpr$2 = "FqnExpr";
+type FqnExprOrWhere = FqnExpr$2 | FqnExprWhere;
+declare const FqnExprOrWhere = "FqnExprOrWhere";
+type FqnExprOrWith = FqnExprOrWhere | FqnExprWith;
+declare const FqnExprOrWith = "FqnExprOrWith";
+type FqnReferenceable = Element | ExtendDeployment | ExtendElement | Referenceable;
+declare const FqnReferenceable = "FqnReferenceable";
+type IconId = string;
+type IconPositionValue = 'bottom' | 'left' | 'right' | 'top';
+type Id = 'deployment' | 'element' | 'group' | 'instance' | 'model' | 'node' | ArrowType | DynamicViewDisplayVariantValue | ElementShape | IconPositionValue | LineOptions | Participant | RankValue | SizeValue | ThemeColor | string;
+type LikeC4View = DeploymentView | DynamicView | ElementView;
+declare const LikeC4View = "LikeC4View";
+type LineOptions = 'dashed' | 'dotted' | 'solid';
+type MetadataProperty = MetadataBody;
+declare const MetadataProperty = "MetadataProperty";
+type MetadataValue = MarkdownOrString | MetadataArray;
+declare const MetadataValue = "MetadataValue";
+type ModelReferenceable = Element | Imported;
+declare const ModelReferenceable = "ModelReferenceable";
+type Participant = 'source' | 'target';
+type RankValue = 'max' | 'min' | 'same' | 'sink' | 'source';
+type Referenceable = DeployedInstance | DeploymentNode | Element | Imported;
+declare const Referenceable = "Referenceable";
+type RelationExpr$1 = DirectedRelationExpr | InOutRelationExpr | IncomingRelationExpr | OutgoingRelationExpr;
+declare const RelationExpr$1 = "RelationExpr";
+type RelationExprOrWhere = RelationExpr$1 | RelationExprWhere;
+declare const RelationExprOrWhere = "RelationExprOrWhere";
+type RelationExprOrWith = RelationExprOrWhere | RelationExprWith;
+declare const RelationExprOrWith = "RelationExprOrWith";
+type RelationProperty = LinkProperty | MetadataProperty | RelationNavigateToProperty | RelationStringProperty | RelationStyleProperty;
+declare const RelationProperty = "RelationProperty";
+type RelationshipStyleProperty = ArrowProperty | ColorProperty | LineProperty;
+declare const RelationshipStyleProperty = "RelationshipStyleProperty";
+type SizeProperty = IconSizeProperty | PaddingSizeProperty | ShapeSizeProperty | TextSizeProperty;
+declare const SizeProperty = "SizeProperty";
+type SizeValue = 'large' | 'lg' | 'md' | 'medium' | 'sm' | 'small' | 'xl' | 'xlarge' | 'xs' | 'xsmall';
+type StringProperty = ElementStringProperty | MetadataAttribute | NotationProperty | NotesProperty | RelationStringProperty | SpecificationElementStringProperty | SpecificationRelationshipStringProperty | ViewStringProperty;
+declare const StringProperty = "StringProperty";
+type StyleProperty = BorderProperty | ColorProperty | IconColorProperty | IconPositionProperty | IconProperty | IconSizeProperty | MultipleProperty | OpacityProperty | PaddingSizeProperty | ShapeProperty | ShapeSizeProperty | TextSizeProperty;
+declare const StyleProperty = "StyleProperty";
+type ThemeColor = 'amber' | 'blue' | 'gray' | 'green' | 'indigo' | 'muted' | 'primary' | 'red' | 'secondary' | 'sky' | 'slate';
+type Uri = string;
+type ViewLayoutDirection = 'BottomTop' | 'LeftRight' | 'RightLeft' | 'TopBottom';
+type ViewProperty = LinkProperty | ViewStringProperty;
+declare const ViewProperty = "ViewProperty";
+type ViewRule = ViewRuleAutoLayout | ViewRuleGlobalPredicateRef | ViewRuleGroup | ViewRulePredicate | ViewRuleRank | ViewRuleStyleOrGlobalRef;
+declare const ViewRule = "ViewRule";
+type ViewRuleStyleOrGlobalRef = ViewRuleGlobalStyle | ViewRuleStyle;
+declare const ViewRuleStyleOrGlobalRef = "ViewRuleStyleOrGlobalRef";
+type WhereElement = WhereElementKind | WhereElementTag;
+declare const WhereElement = "WhereElement";
+type WhereElementExpression = WhereBinaryExpression | WhereElement | WhereElementNegation;
+declare const WhereElementExpression = "WhereElementExpression";
+type WhereExpression = WhereElementExpression | WhereRelationExpression;
+declare const WhereExpression = "WhereExpression";
+type WhereKindEqual = WhereElementKind | WhereRelationKind | WhereRelationParticipantKind;
+declare const WhereKindEqual = "WhereKindEqual";
+type WhereRelation = WhereRelationKind | WhereRelationParticipantKind | WhereRelationParticipantTag | WhereRelationTag;
+declare const WhereRelation = "WhereRelation";
+type WhereRelationExpression = WhereBinaryExpression | WhereRelation | WhereRelationNegation;
+declare const WhereRelationExpression = "WhereRelationExpression";
+type WhereTagEqual = WhereElementTag | WhereRelationParticipantTag | WhereRelationTag;
+declare const WhereTagEqual = "WhereTagEqual";
+interface AbstractDynamicStep extends AstNode {
+  readonly $container: DynamicStepChain | DynamicViewBody | DynamicViewParallelSteps;
+  readonly $type: 'AbstractDynamicStep' | 'DynamicStepChain' | 'DynamicStepSingle';
+  custom?: CustomRelationProperties;
+  dotKind?: RelationKindDotRef;
+  kind?: Reference<RelationshipKind>;
+  target: ElementRef;
+  title?: string;
+}
+declare const AbstractDynamicStep = "AbstractDynamicStep";
+interface ArrowProperty extends AstNode {
+  readonly $container: CustomRelationProperties | RelationStyleProperty | SpecificationRelationshipKind;
+  readonly $type: 'ArrowProperty';
+  key: 'head' | 'tail';
+  value: ArrowType;
+}
+declare const ArrowProperty = "ArrowProperty";
+interface BorderProperty extends AstNode {
+  readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleGroup | ViewRuleStyle;
+  readonly $type: 'BorderProperty';
+  key: 'border';
+  value: BorderStyleValue;
+}
+declare const BorderProperty = "BorderProperty";
+interface ColorProperty extends AstNode {
+  readonly $container: CustomElementProperties | CustomRelationProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | RelationStyleProperty | SpecificationRelationshipKind | ViewRuleGroup | ViewRuleStyle;
+  readonly $type: 'ColorProperty';
+  customColor?: Reference<CustomColor>;
+  key: 'color';
+  themeColor?: ThemeColor;
+}
+declare const ColorProperty = "ColorProperty";
+interface CustomColor extends AstNode {
+  readonly $container: SpecificationColor;
+  readonly $type: 'CustomColor';
+  name: CustomColorId;
+}
+declare const CustomColor = "CustomColor";
+interface CustomElementProperties extends AstNode {
+  readonly $container: FqnExprWith;
+  readonly $type: 'CustomElementProperties';
+  props: Array<ElementStringProperty | NavigateToProperty | NotationProperty | NotesProperty | StyleProperty>;
+}
+declare const CustomElementProperties = "CustomElementProperties";
+interface CustomRelationProperties extends AstNode {
+  readonly $container: AbstractDynamicStep | RelationExprWith;
+  readonly $type: 'CustomRelationProperties';
+  props: Array<NotationProperty | NotesProperty | RelationNavigateToProperty | RelationStringProperty | RelationshipStyleProperty>;
+}
+declare const CustomRelationProperties = "CustomRelationProperties";
+interface DeployedInstance extends AstNode {
+  readonly $container: DeploymentNodeBody | ExtendDeploymentBody;
+  readonly $type: 'DeployedInstance';
+  body?: DeployedInstanceBody;
+  name?: Id;
+  summary?: string;
+  target: ElementRef;
+  title?: string;
+}
+declare const DeployedInstance = "DeployedInstance";
+interface DeployedInstanceBody extends AstNode {
+  readonly $container: DeployedInstance;
+  readonly $type: 'DeployedInstanceBody';
+  elements: Array<DeploymentRelation>;
+  props: Array<ElementProperty>;
+  tags?: Tags;
+}
+declare const DeployedInstanceBody = "DeployedInstanceBody";
+interface DeploymentNode extends AstNode {
+  readonly $container: DeploymentNodeBody | ExtendDeploymentBody | ModelDeployments;
+  readonly $type: 'DeploymentNode';
+  body?: DeploymentNodeBody;
+  kind: Reference<DeploymentNodeKind>;
+  name: Id;
+  summary?: string;
+  title?: string;
+}
+declare const DeploymentNode = "DeploymentNode";
+interface DeploymentNodeBody extends AstNode {
+  readonly $container: DeploymentNode;
+  readonly $type: 'DeploymentNodeBody';
+  elements: Array<DeployedInstance | DeploymentNode | DeploymentRelation>;
+  props: Array<ElementProperty>;
+  tags?: Tags;
+}
+declare const DeploymentNodeBody = "DeploymentNodeBody";
+interface DeploymentNodeKind extends AstNode {
+  readonly $container: SpecificationDeploymentNodeKind;
+  readonly $type: 'DeploymentNodeKind';
+  name: Id;
+}
+declare const DeploymentNodeKind = "DeploymentNodeKind";
+interface DeploymentRelation extends AstNode {
+  readonly $container: DeployedInstanceBody | DeploymentNodeBody | ExtendDeploymentBody | ModelDeployments;
+  readonly $type: 'DeploymentRelation';
+  body?: DeploymentRelationBody;
+  description?: string;
+  dotKind?: RelationKindDotRef;
+  kind?: Reference<RelationshipKind>;
+  source?: FqnRef$2;
+  tags?: Tags;
+  target: FqnRef$2;
+  technology?: string;
+  title?: string;
+}
+declare const DeploymentRelation = "DeploymentRelation";
+interface DeploymentRelationBody extends AstNode {
+  readonly $container: DeploymentRelation;
+  readonly $type: 'DeploymentRelationBody';
+  props: Array<RelationProperty>;
+  tags?: Tags;
+}
+declare const DeploymentRelationBody = "DeploymentRelationBody";
+interface DeploymentView extends AstNode {
+  readonly $container: ModelViews;
+  readonly $type: 'DeploymentView';
+  body?: DeploymentViewBody;
+  name: Id;
+}
+declare const DeploymentView = "DeploymentView";
+interface DeploymentViewBody extends AstNode {
+  readonly $container: DeploymentView;
+  readonly $type: 'DeploymentViewBody';
+  props: Array<ViewProperty>;
+  rules: Array<DeploymentViewRule>;
+  tags?: Tags;
+}
+declare const DeploymentViewBody = "DeploymentViewBody";
+interface DeploymentViewRulePredicate extends AstNode {
+  readonly $container: DeploymentViewBody;
+  readonly $type: 'DeploymentViewRulePredicate';
+  expr: Expressions;
+  isInclude: boolean;
+}
+declare const DeploymentViewRulePredicate = "DeploymentViewRulePredicate";
+interface DeploymentViewRuleStyle extends AstNode {
+  readonly $container: DeploymentViewBody;
+  readonly $type: 'DeploymentViewRuleStyle';
+  props: Array<NotationProperty | StyleProperty>;
+  targets: FqnExpressions;
+}
+declare const DeploymentViewRuleStyle = "DeploymentViewRuleStyle";
+interface DirectedRelationExpr extends AstNode {
+  readonly $container: Expressions | RelationExprWhere | RelationExprWith;
+  readonly $type: 'DirectedRelationExpr';
+  source: OutgoingRelationExpr;
+  target: FqnExpr$2;
+}
+declare const DirectedRelationExpr = "DirectedRelationExpr";
+interface DynamicView extends AstNode {
+  readonly $container: ModelViews;
+  readonly $type: 'DynamicView';
+  body?: DynamicViewBody;
+  name: Id;
+}
+declare const DynamicView = "DynamicView";
 interface DynamicViewBody extends AstNode {
   readonly $container: DynamicView;
   readonly $type: 'DynamicViewBody';
@@ -685,7 +1299,7 @@ interface NotationProperty extends AstNode {
 }
 declare const NotationProperty = "NotationProperty";
 interface NotesProperty extends AstNode {
-  readonly $container: CustomRelationProperties;
+  readonly $container: CustomElementProperties | CustomRelationProperties;
   readonly $type: 'NotesProperty';
   key: 'notes';
   value: MarkdownOrString;
@@ -808,7 +1422,7 @@ declare const ShapeSizeProperty = "ShapeSizeProperty";
 interface SpecificationColor extends AstNode {
   readonly $container: SpecificationRule;
   readonly $type: 'SpecificationColor';
-  color: ColorLiteral;
+  color: ColorLiteral$1;
   name: CustomColor;
 }
 declare const SpecificationColor = "SpecificationColor";
@@ -863,8 +1477,8 @@ declare const SpecificationRule = "SpecificationRule";
 interface SpecificationTag extends AstNode {
   readonly $container: SpecificationRule;
   readonly $type: 'SpecificationTag';
-  color?: ColorLiteral;
-  tag: Tag;
+  color?: ColorLiteral$1;
+  tag: Tag$1;
 }
 declare const SpecificationTag = "SpecificationTag";
 interface StrictFqnElementRef extends AstNode {
@@ -881,16 +1495,16 @@ interface StrictFqnRef extends AstNode {
   value: Reference<Referenceable>;
 }
 declare const StrictFqnRef = "StrictFqnRef";
-interface Tag extends AstNode {
+interface Tag$1 extends AstNode {
   readonly $container: SpecificationTag;
   readonly $type: 'Tag';
   name: Id;
 }
-declare const Tag = "Tag";
+declare const Tag$1 = "Tag";
 interface TagRef extends AstNode {
   readonly $container: ElementTagExpression | Tags | WhereElementTag | WhereRelationParticipantTag | WhereRelationTag;
   readonly $type: 'TagRef';
-  tag: Reference<Tag>;
+  tag: Reference<Tag$1>;
 }
 declare const TagRef = "TagRef";
 interface Tags extends AstNode {
@@ -1030,1215 +1644,205 @@ interface WhereRelationParticipantTag extends AstNode {
   participant: Participant;
   value: TagRef;
 }
-declare const WhereRelationParticipantTag = "WhereRelationParticipantTag";
-interface WhereRelationTag extends AstNode {
-  readonly $container: RelationExprWhere | WhereBinaryExpression | WhereRelationNegation;
-  readonly $type: 'WhereRelationTag';
-  not: boolean;
-  operator: 'is' | string;
-  value: TagRef;
-}
-declare const WhereRelationTag = "WhereRelationTag";
-interface WildcardExpression extends AstNode {
-  readonly $container: DirectedRelationExpr | Expressions | FqnExprWhere | FqnExprWith | FqnExpressions | IncomingRelationExpr | OutgoingRelationExpr;
-  readonly $type: 'WildcardExpression';
-  isWildcard: boolean;
-}
-declare const WildcardExpression = "WildcardExpression";
-interface DynamicStepChain extends AbstractDynamicStep {
-  readonly $container: DynamicStepChain | DynamicViewBody | DynamicViewParallelSteps;
-  readonly $type: 'DynamicStepChain';
-  source: DynamicStepChain | DynamicStepSingle;
-}
-declare const DynamicStepChain = "DynamicStepChain";
-interface DynamicStepSingle extends AbstractDynamicStep {
-  readonly $container: DynamicStepChain | DynamicViewBody | DynamicViewParallelSteps;
-  readonly $type: 'DynamicStepSingle';
-  isBackward: boolean;
-  source: ElementRef;
-}
-declare const DynamicStepSingle = "DynamicStepSingle";
-type LikeC4AstType = {
-  AbstractDynamicStep: AbstractDynamicStep;
-  AnyProperty: AnyProperty;
-  ArrowProperty: ArrowProperty;
-  BorderProperty: BorderProperty;
-  ColorLiteral: ColorLiteral;
-  ColorProperty: ColorProperty;
-  CustomColor: CustomColor;
-  CustomElementProperties: CustomElementProperties;
-  CustomRelationProperties: CustomRelationProperties;
-  DeployedInstance: DeployedInstance;
-  DeployedInstanceBody: DeployedInstanceBody;
-  DeploymentElement: DeploymentElement;
-  DeploymentNode: DeploymentNode;
-  DeploymentNodeBody: DeploymentNodeBody;
-  DeploymentNodeKind: DeploymentNodeKind;
-  DeploymentNodeOrElementKind: DeploymentNodeOrElementKind;
-  DeploymentRelation: DeploymentRelation;
-  DeploymentRelationBody: DeploymentRelationBody;
-  DeploymentView: DeploymentView;
-  DeploymentViewBody: DeploymentViewBody;
-  DeploymentViewRule: DeploymentViewRule;
-  DeploymentViewRulePredicate: DeploymentViewRulePredicate;
-  DeploymentViewRuleStyle: DeploymentViewRuleStyle;
-  DirectedRelationExpr: DirectedRelationExpr;
-  DynamicStepChain: DynamicStepChain;
-  DynamicStepSingle: DynamicStepSingle;
-  DynamicView: DynamicView;
-  DynamicViewBody: DynamicViewBody;
-  DynamicViewDisplayVariantProperty: DynamicViewDisplayVariantProperty;
-  DynamicViewGlobalPredicateRef: DynamicViewGlobalPredicateRef;
-  DynamicViewIncludePredicate: DynamicViewIncludePredicate;
-  DynamicViewParallelSteps: DynamicViewParallelSteps;
-  DynamicViewProperty: DynamicViewProperty;
-  DynamicViewRef: DynamicViewRef;
-  DynamicViewRule: DynamicViewRule;
-  DynamicViewStep: DynamicViewStep;
-  Element: Element;
-  ElementBody: ElementBody;
-  ElementKind: ElementKind;
-  ElementKindExpression: ElementKindExpression;
-  ElementProperty: ElementProperty;
-  ElementRef: ElementRef;
-  ElementStringProperty: ElementStringProperty;
-  ElementStyleProperty: ElementStyleProperty;
-  ElementTagExpression: ElementTagExpression;
-  ElementView: ElementView;
-  ElementViewBody: ElementViewBody;
-  ElementViewRef: ElementViewRef;
-  ExpressionV2: ExpressionV2;
-  Expressions: Expressions;
-  ExtendDeployment: ExtendDeployment;
-  ExtendDeploymentBody: ExtendDeploymentBody;
-  ExtendElement: ExtendElement;
-  ExtendElementBody: ExtendElementBody;
-  ExtendElementProperty: ExtendElementProperty;
-  ExtendRelation: ExtendRelation;
-  ExtendRelationBody: ExtendRelationBody;
-  ExtendRelationProperty: ExtendRelationProperty;
-  FqnExpr: FqnExpr$2;
-  FqnExprOrWhere: FqnExprOrWhere;
-  FqnExprOrWith: FqnExprOrWith;
-  FqnExprWhere: FqnExprWhere;
-  FqnExprWith: FqnExprWith;
-  FqnExpressions: FqnExpressions;
-  FqnRef: FqnRef$2;
-  FqnRefExpr: FqnRefExpr;
-  FqnReferenceable: FqnReferenceable;
-  GlobalDynamicPredicateGroup: GlobalDynamicPredicateGroup;
-  GlobalPredicateGroup: GlobalPredicateGroup;
-  GlobalStyle: GlobalStyle;
-  GlobalStyleGroup: GlobalStyleGroup;
-  GlobalStyleId: GlobalStyleId;
-  Globals: Globals;
-  HexColor: HexColor;
-  IconColorProperty: IconColorProperty;
-  IconPositionProperty: IconPositionProperty;
-  IconProperty: IconProperty;
-  IconSizeProperty: IconSizeProperty;
-  Imported: Imported;
-  ImportsFromPoject: ImportsFromPoject;
-  InOutRelationExpr: InOutRelationExpr;
-  IncomingRelationExpr: IncomingRelationExpr;
-  LibIcon: LibIcon;
-  LikeC4Grammar: LikeC4Grammar;
-  LikeC4Lib: LikeC4Lib;
-  LikeC4View: LikeC4View;
-  LineProperty: LineProperty;
-  LinkProperty: LinkProperty;
-  MarkdownOrString: MarkdownOrString;
-  MetadataArray: MetadataArray;
-  MetadataAttribute: MetadataAttribute;
-  MetadataBody: MetadataBody;
-  MetadataProperty: MetadataProperty;
-  MetadataValue: MetadataValue;
-  Model: Model;
-  ModelDeployments: ModelDeployments;
-  ModelReferenceable: ModelReferenceable;
-  ModelViews: ModelViews;
-  MultipleProperty: MultipleProperty;
-  NavigateToProperty: NavigateToProperty;
-  NotationProperty: NotationProperty;
-  NotesProperty: NotesProperty;
-  OpacityProperty: OpacityProperty;
-  OutgoingRelationExpr: OutgoingRelationExpr;
-  PaddingSizeProperty: PaddingSizeProperty;
-  RGBAColor: RGBAColor;
-  Referenceable: Referenceable;
-  Relation: Relation;
-  RelationBody: RelationBody;
-  RelationExpr: RelationExpr$1;
-  RelationExprOrWhere: RelationExprOrWhere;
-  RelationExprOrWith: RelationExprOrWith;
-  RelationExprWhere: RelationExprWhere;
-  RelationExprWith: RelationExprWith;
-  RelationKindDotRef: RelationKindDotRef;
-  RelationNavigateToProperty: RelationNavigateToProperty;
-  RelationProperty: RelationProperty;
-  RelationStringProperty: RelationStringProperty;
-  RelationStyleProperty: RelationStyleProperty;
-  RelationshipKind: RelationshipKind;
-  RelationshipStyleProperty: RelationshipStyleProperty;
-  ShapeProperty: ShapeProperty;
-  ShapeSizeProperty: ShapeSizeProperty;
-  SizeProperty: SizeProperty;
-  SpecificationColor: SpecificationColor;
-  SpecificationDeploymentNodeKind: SpecificationDeploymentNodeKind;
-  SpecificationElementKind: SpecificationElementKind;
-  SpecificationElementStringProperty: SpecificationElementStringProperty;
-  SpecificationRelationshipKind: SpecificationRelationshipKind;
-  SpecificationRelationshipStringProperty: SpecificationRelationshipStringProperty;
-  SpecificationRule: SpecificationRule;
-  SpecificationTag: SpecificationTag;
-  StrictFqnElementRef: StrictFqnElementRef;
-  StrictFqnRef: StrictFqnRef;
-  StringProperty: StringProperty;
-  StyleProperty: StyleProperty;
-  Tag: Tag;
-  TagRef: TagRef;
-  Tags: Tags;
-  TextSizeProperty: TextSizeProperty;
-  ViewProperty: ViewProperty;
-  ViewRef: ViewRef;
-  ViewRule: ViewRule;
-  ViewRuleAutoLayout: ViewRuleAutoLayout;
-  ViewRuleGlobalPredicateRef: ViewRuleGlobalPredicateRef;
-  ViewRuleGlobalStyle: ViewRuleGlobalStyle;
-  ViewRuleGroup: ViewRuleGroup;
-  ViewRulePredicate: ViewRulePredicate;
-  ViewRuleRank: ViewRuleRank;
-  ViewRuleStyle: ViewRuleStyle;
-  ViewRuleStyleOrGlobalRef: ViewRuleStyleOrGlobalRef;
-  ViewStringProperty: ViewStringProperty;
-  WhereBinaryExpression: WhereBinaryExpression;
-  WhereElement: WhereElement;
-  WhereElementExpression: WhereElementExpression;
-  WhereElementKind: WhereElementKind;
-  WhereElementNegation: WhereElementNegation;
-  WhereElementTag: WhereElementTag;
-  WhereExpression: WhereExpression;
-  WhereKindEqual: WhereKindEqual;
-  WhereRelation: WhereRelation;
-  WhereRelationExpression: WhereRelationExpression;
-  WhereRelationKind: WhereRelationKind;
-  WhereRelationNegation: WhereRelationNegation;
-  WhereRelationParticipantKind: WhereRelationParticipantKind;
-  WhereRelationParticipantTag: WhereRelationParticipantTag;
-  WhereRelationTag: WhereRelationTag;
-  WhereTagEqual: WhereTagEqual;
-  WildcardExpression: WildcardExpression;
-};
-//#endregion
-//#region ../language-server/dist/_chunks/protocol.d.mts
-/**
- * When server requests to open a likec4 preview panel
- * (available only in the editor).
- * (not the best place, but seems to be working)
- */
-declare namespace DidRequestOpenViewNotification {
-  type Params = {
-    viewId: ViewId$1;
-    projectId: ProjectId$1;
-  };
-  const type: NotificationType<Params>;
-  type Type = typeof type;
-}
-/**
- * Request to fetch the computed model data
- * If LSP has multiple projects, the projectId is required.
- * otherwise throws an error.
- */
-/**
- * Request to locate an element, relation, deployment or view.
- * If LSP has multiple projects, the projectId is required.
- */
-declare namespace Locate {
-  type Params =
-  /**
-   * Locate an element by its fqn
-   */
-  {
-    element: Fqn$1;
-    projectId?: string | undefined;
-    property?: string;
-  }
-  /**
-   * Locate a relation by its id
-   */
-  | {
-    projectId?: string | undefined;
-    relation: RelationId;
-  }
-  /**
-   * Locate a deployment by its fqn
-   */
-  | {
-    deployment: DeploymentFqn;
-    projectId?: string | undefined;
-    property?: string;
-  }
-  /**
-   * Locate a step in a dynamic view by its astPath
-   */
-  | {
-    view: ViewId$1;
-    astPath: string;
-    projectId?: string | undefined;
-  }
-  /**
-   * Locate a view by its id
-   */
-  | {
-    view: ViewId$1;
-    projectId?: string | undefined;
-  };
-  type Res = Location | null;
-  const req: RequestType<Params, Res, void>;
-  type Req = typeof req;
-}
-/**
- * Request to change the view
- * If LSP has multiple projects, the projectId is required.
- */
-declare namespace ChangeView {
-  type Params = {
-    viewId: ViewId$1;
-    change: ViewChange$1;
-    projectId?: string | undefined;
-  };
-  type Res = {
-    success: true;
-    location: Location | null;
-  } | {
-    success: false;
-    location?: Location | null;
-    error: string;
-  };
-  const req: RequestType<Params, Res, void>;
-  type Req = typeof req;
-}
-/**
- * Request to fetch telemetry metrics
- */
-//#endregion
-//#region ../layouts/dist/_chunks/GraphvizLayoter.d.mts
-//#region src/graphviz/types.d.ts
-/**
- * Partially implements CancellationToken interface from vscode-jsonrpc
- */
-type CancellationToken = {
-  /**
-   * Is `true` when the token has been cancelled, `false` otherwise.
-   */
-  readonly isCancellationRequested: boolean;
-};
-declare module 'ts-graphviz' {
-  namespace GraphAttributeKey {
-    interface $values extends $keywords<'likec4_viewId'> {}
-  }
-  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_project' | 'likec4_level'> {}
-  }
-  namespace EdgeAttributeKey {
-    interface $values extends $keywords<'likec4_id' | 'likec4_project'> {}
-  }
-  namespace Attribute {
-    interface $keys extends $keywords<'likec4_viewId' | 'likec4_type' | 'likec4_path' | 'likec4_id' | 'likec4_project' | 'likec4_level' | 'likec4_depth'> {}
-    interface $types {
-      likec4_viewId: string;
-      likec4_type: 'folder' | 'file' | 'view';
-      likec4_path: string;
-      likec4_id: string;
-      likec4_project: string;
-      likec4_level: number;
-      likec4_depth: number;
-    }
-  }
-}
-type DotSource = Tagged<string, 'DotSource'>; //#endregion
-//#region src/graphviz/types-dot.d.ts
-type GvNodeName = Tagged<string, 'GvNodeName'>;
-type GvId = Tagged<number, 'GvId'>;
-type Point = [x: number, y: number];
-interface GraphvizJson {
-  name: GvNodeName;
-  directed: boolean;
-  strict: boolean;
-  _draw_: GraphvizJson.Draw[];
-  bb: string;
-  compound: string;
-  fontname: string;
-  fontsize: string;
-  label: string;
-  nodesep: string;
-  outputorder: string;
-  rankdir: string;
-  ranksep: string;
-  splines: string;
-  xdotversion: string;
-  _subgraph_cnt: number;
-  objects?: GraphvizJson.GvObject[];
-  edges?: GraphvizJson.Edge[];
-}
-declare namespace GraphvizJson {
-  interface Draw {
-    op: string;
-    grad: string;
-    color: string;
-    points: Point[];
-  }
-  interface Draw2 {
-    op: string;
-    grad: string;
-    color: string;
-    points: Point[];
-  }
-  namespace DrawOps {
-    type Style = {
-      op: 'S';
-      style: string;
-    };
-    type BSpline = {
-      op: 'b' | 'B';
-      points: Point[];
-    };
-    type Color = {
-      op: 'c';
-      grad: string;
-      color: string;
-    };
-    type Polygon = {
-      op: 'p' | 'P';
-      points: Point[];
-    };
-  }
-  type DrawOp = DrawOps.Style | DrawOps.BSpline | DrawOps.Color | DrawOps.Polygon;
-  type LabelDrawOps = {
-    op: 'F';
-    size: number;
-    face: string;
-  } | {
-    op: 'c';
-    color: string;
-  } | {
-    op: 't';
-    fontchar: number;
-  } | {
-    op: 'T';
-    pt: Point;
-    align: 'l' | 'r' | 'c';
-    width: number;
-    text: string;
-  };
-  type GvObject = GvNodeObject | GvSubgraph;
-  interface GvSubgraph {
-    bb: string;
-    label?: string;
-    compound: 'true';
-    _ldraw_?: LabelDrawOps[];
-    likec4_type?: 'folder' | 'file';
-    likec4_path?: string;
-    likec4_id?: Fqn$1;
-    likec4_level?: number;
-    likec4_depth?: number;
-    _gvid: GvId;
-    subgraphs?: GvId[];
-    nodes?: GvId[];
-    edges?: GvId[];
-  }
-  interface GvNodeObject {
-    _draw_: Draw[];
-    _ldraw_?: LabelDrawOps[];
-    likec4_type?: 'folder' | 'file' | 'view';
-    likec4_path?: string;
-    likec4_id?: Fqn$1;
-    likec4_level?: number;
-    _gvid: GvId;
-    height: string;
-    pos: string;
-    shape: 'rect';
-    width: string;
-    label?: string;
-  }
-  interface Draw3 {
-    op: string;
-    grad: string;
-    color: string;
-    points: Point[];
-  }
-  interface Hdraw {
-    op: string;
-    style: string;
-    grad: string;
-    color: string;
-    points: Point[];
-  }
-  interface Edge {
-    _gvid: GvId;
-    tail: GvId;
-    head: GvId;
-    dir?: 'forward' | 'back' | 'both' | 'none';
-    _draw_: DrawOp[];
-    _hdraw_?: DrawOp[];
-    _tdraw_?: DrawOp[];
-    _ldraw_?: LabelDrawOps[];
-    _tldraw_?: LabelDrawOps[];
-    _hldraw_?: LabelDrawOps[];
-    fontname: string;
-    fontsize: string;
-    likec4_id?: EdgeId;
-    label: string;
-    lp: string;
-    nojustify?: 'true' | 'false';
-    pos?: string;
-  }
-} //#endregion
-//#region src/graphviz/GraphvizLayoter.d.ts
-interface GraphvizPort extends Disposable {
-  get concurrency(): number;
-  unflatten(dot: DotSource): Promise<DotSource>;
-  acyclic(dot: DotSource): Promise<DotSource>;
-  layoutJson(dot: DotSource): Promise<string>;
-  svg(dot: DotSource): Promise<string>;
-  dispose(): void;
-}
-type LayoutTaskParams<A extends aux$1.Any = aux$1.Any> = {
-  view: ComputedView<A>;
-  styles: LikeC4Styles;
-};
-type LayoutResult<A extends aux$1.Any = aux$1.Any> = {
-  dot: DotSource;
-  diagram: DiagramView<A>;
-};
-declare class GraphvizLayouter implements Disposable {
-  private graphviz;
-  constructor(graphviz?: GraphvizPort);
-  dispose(): void;
-  [Symbol.dispose](): void;
-  get graphvizPort(): GraphvizPort;
-  changePort(graphviz: GraphvizPort): void;
-  dotToJson(dot: DotSource): Promise<GraphvizJson>;
-  layout<A extends AnyAux>(params: LayoutTaskParams<A>): Promise<LayoutResult<A>>;
-  svg<A extends AnyAux>(params: LayoutTaskParams<A>): Promise<{
-    svg: string;
-    dot: DotSource;
-  }>;
-  dot<A extends AnyAux>(params: LayoutTaskParams<A>): Promise<DotSource>;
-  layoutProjectsView(view: ComputedProjectsView): Promise<LayoutedProjectsView>;
-} //#endregion
-//#endregion
-//#region ../layouts/dist/graphviz/QueueGraphvizLayoter.d.mts
-//#region src/graphviz/QueueGraphvizLayoter.d.ts
-declare class QueueGraphvizLayoter extends GraphvizLayouter {
-  private queue;
-  private isProcessingBatch;
-  constructor(options?: {
-    graphviz?: GraphvizPort;
-    /**
-     * Concurrency limit.
-     * Minimum: `1`.
-     * @default 2
-     */
-    concurrency?: number;
-    /**
-     * Per-operation timeout in milliseconds. Operations fulfill once `timeout` elapses if they haven't already.
-     * @default 20_000
-     */
-    timeout?: number;
-    /**
-     * Whether or not a timeout is considered an exception.
-     * @default true
-     */
-    throwOnTimeout?: boolean;
-  });
-  private runInQueue;
-  changePort(graphvizPort: GraphvizPort): void;
-  layout<A extends AnyAux>(params: LayoutTaskParams<A>): Promise<LayoutResult<A>>;
-  layoutProjectsView(view: ComputedProjectsView): Promise<LayoutedProjectsView>;
-  batchLayout<A extends AnyAux>(params: {
-    batch: LayoutTaskParams<A>[];
-    cancelToken?: CancellationToken | undefined;
-    onSuccess?: (task: LayoutTaskParams<A>, result: LayoutResult<A>) => void;
-    onError?: (task: LayoutTaskParams<A>, error: unknown) => void;
-  }): Promise<LayoutResult<A>[]>;
-  dispose(): void;
-} //#endregion
-//#endregion
-//#region ../language-server/dist/_chunks/LikeC4LanguageServices.d.mts
-//#region src/documentation/documentation-provider.d.ts
-declare class LikeC4DocumentationProvider implements DocumentationProvider {
-  private parser;
-  private locator;
-  constructor(services: LikeC4Services);
-  getDocumentation(node: AstNode): string | undefined;
-} //#endregion
-//#region src/workspace/ProjectsManager.d.ts
-/**
- * A tagged string that represents a project folder URI
- * Always has trailing slash.
- */
-type ProjectFolder = Tagged<string, 'ProjectFolder'>;
-declare function ProjectFolder(folder: URI | string): ProjectFolder;
-interface ProjectData {
-  id: ProjectId;
-  config: LikeC4ProjectConfig;
-  folder: ProjectFolder;
-  folderUri: URI;
-  exclude?: {
-    (test: string): boolean;
-  };
-  /**
-   * Resolved include paths with both URI and folder string representations.
-   * These are additional directories that are part of this project.
-   */
-  includePaths?: NonEmptyArray<{
-    uri: URI;
-    folder: ProjectFolder;
-  }>;
-  /**
-   * Normalized include configuration (paths, maxDepth, fileThreshold).
-   */
-  includeConfig: IncludeConfig;
-}
-interface Project {
-  id: ProjectId;
-  folderUri: URI;
-  config: LikeC4ProjectConfig;
-  /**
-   * Resolved include paths as URIs (if configured).
-   */
-  includePaths?: NonEmptyReadonlyArray<URI>;
-}
-declare class ProjectsManager {
-  #private;
-  protected services: LikeC4SharedServices;
-  /**
-   * The global project ID used for all documents
-   * that are not part of a specific project.
-   */
-  static readonly DefaultProjectId: ProjectId;
-  constructor(services: LikeC4SharedServices);
-  /**
-   * Returns:
-   *  - configured default project ID if set
-   *  - the default project ID if there are no projects.
-   *  - the ID of the only project
-   *  - undefined if there are multiple projects.
-   */
-  get defaultProjectId(): ProjectId | undefined;
-  set defaultProjectId(id: string | ProjectId | undefined);
-  get default(): ProjectData;
-  get all(): NonEmptyReadonlyArray<ProjectId>;
-  getProject(arg: ProjectId | LangiumDocument): Project;
-  /**
-   * Returns all projects that include the specified folder, or inside the folder.
-   */
-  findAllProjectsByFolder(folder: URI | string): ProjectData[];
-  /**
-   * Validates and ensures the project ID.
-   * If no project ID is specified, returns default project ID
-   * If there are multiple projects and default project is not set, throws an error
-   */
-  ensureProjectId(projectId?: ProjectId | undefined): ProjectId;
-  /**
-   * Validates and ensures the project.
-   */
-  ensureProject(projectId?: ProjectId | undefined): Project;
-  hasMultipleProjects(): boolean;
-  /**
-   * Checks if the specified document should be excluded from processing.
-   */
-  isExcluded(document: LangiumDocument | URI | string): boolean;
-  /**
-   * Checks if the specified document is included by the project:
-   * - if the document belongs to the project and is not excluded
-   * - if the document is included by the project
-   */
-  isIncluded(projectId: ProjectId, document: LangiumDocument | URI | string): boolean;
-  /**
-   * Checks if it is a config file and it is not excluded by default exclude pattern
-   *
-   * @param entry The file system entry to check
-   */
-  isConfigFile(entry: URI): boolean;
-  /**
-   * Registers likec4 project by config file.
-   */
-  registerConfigFile(configFile: URI, cancelToken?: CancellationToken$1): Promise<ProjectData>;
-  /**
-   * Registers (or reloads) likec4 project by config file or config object.
-   * If there is some project registered at same folder, it will be reloaded.
-   */
-  registerProject(opts: {
-    config: LikeC4ProjectConfig | LikeC4ProjectConfigInput;
-    folderUri: URI | string;
-  }, cancelToken?: CancellationToken$1): Promise<ProjectData>;
-  /**
-   * Determines which project the given document belongs to.
-   * If the document does not belong to any project, returns the default project ID.
-   */
-  belongsTo(document: LangiumDocument | URI | string): ProjectId;
-  reloadProjects(cancelToken?: CancellationToken$1): Promise<void>;
-  protected _reloadProjects(cancelToken?: CancellationToken$1): Promise<void>;
-  protected uniqueProjectId(name: string): ProjectId;
-  protected reset(): void;
-  rebuidProject(projectId: ProjectId, cancelToken?: CancellationToken$1): Promise<void>;
-  protected findProjectForDocument(documentUri: string): ProjectData;
-  protected get mappingsToProject(): WorkspaceCache<string, ProjectData>;
-  /**
-   * The mapping between documents and projects they belong to.
-   * Lazy-created due to initialization order of the LanguageServer
-   */
-  protected get documentBelongsTo(): WorkspaceCache<LangiumDocument, ProjectData>;
-  /**
-   * Returns all include paths from all projects.
-   * Used by WorkspaceManager to scan additional directories for C4 files.
-   */
-  getAllIncludePaths(): Array<{
-    projectId: ProjectId;
-    includePath: URI;
-    includeConfig: IncludeConfig;
-  }>;
-  /**
-   * Register a listener to be called when the projects configuration has changed.
-   * @returns A disposable that can be used to unregister the callback.
-   */
-  onProjectsUpdate(callback: () => void): Disposable$1;
-  private getWorkspaceFolder;
-  private notifyListeners;
-} //#endregion
-//#region src/filesystem/types.d.ts
-interface FileNode extends FileSystemNode {
-  readonly isFile: true;
-  readonly isDirectory: false;
-}
-interface FileSystemProvider$1 extends FileSystemProvider {
-  /**
-   * Scans the project files for the given URI.
-   * @returns The list of file system entries that are contained within the specified directory.
-   */
-  scanProjectFiles(folderUri: URI): Promise<FileNode[]>;
-  /**
-   * Loads the project config from the given file.
-   * @returns The project config.
-   */
-  loadProjectConfig(filepath: URI): Promise<LikeC4ProjectConfig>;
-  /**
-   * Reads the directory information for the given URI.
-   * @param options.recursive If true, recursively reads the directory,
-   * @param options.maxDepth Maximum depth to traverse when recursive is true (default: Infinity)
-   */
-  readDirectory(uri: URI, options?: {
-    recursive?: boolean;
-    maxDepth?: number;
-  }): Promise<FileNode[]>;
-  /**
-   * Finds all files in the given directory, matching the given filter.
-   */
-  scanDirectory(directory: URI, filter: (filepath: string) => boolean): Promise<FileNode[]>;
-  /**
-   * Writes the content to the file system.
-   * Used by manual layouts.
-   */
-  writeFile(uri: URI, content: string): Promise<void>;
-  /**
-   * Deletes the file from the file system.
-   * Used by manual layouts.
-   * @return true if the file was deleted, false if the file did not exist.
-   */
-  deleteFile(uri: URI): Promise<boolean>;
-}
-interface FileSystemWatcher extends AsyncDisposable {
-  /**
-   * Watches a folder for changes and triggers a reload of the documents and projects.
-   */
-  watch(folder: string): void;
-}
-interface LikeC4ManualLayouts {
-  read(project: Project): Promise<Record<ViewId, LayoutedView> | null>;
-  write(project: Project, layouted: LayoutedView): Promise<Location>;
-  remove(project: Project, view: ViewId): Promise<Location | null>;
-  clearCaches(): void;
-} //#endregion
-//#region src/filesystem/noop.d.ts
-//#endregion
-//#region src/formatting/LikeC4Formatter.d.ts
-type QuoteStyle = 'single' | 'double' | 'ignore' | 'auto';
-interface LikeC4FormatterOptions {
-  quoteStyle: QuoteStyle;
-}
-type ExtendedFormattingCommandType = 'normalizeQuotes';
-interface ExtendedFormattingCommand {
-  type: ExtendedFormattingCommandType;
-  region: FormattingRegion;
-}
-declare class LikeC4Formatter extends AbstractFormatter {
-  protected options: LikeC4FormatterOptions;
-  extendedFormattingCommands: ExtendedFormattingCommand[];
-  constructor(services: LikeC4Services);
-  protected doDocumentFormat(document: LangiumDocument, options: FormattingOptions, range?: Range): TextEdit[];
-  protected format(node: AstNode): void;
-  protected formatTags(node: AstNode): void;
-  protected formatDeploymentRelation(node: AstNode): void;
-  protected formatExtendDeployment(node: AstNode): void;
-  protected formatRelation(node: AstNode): void;
-  protected removeIndentFromTopLevelStatements(node: AstNode): void;
-  protected indentContentInBraces(node: AstNode): void;
-  protected appendKeywordsWithSpace(node: AstNode): void;
-  protected formatView(node: AstNode): void;
-  protected formatLeafProperty(node: AstNode): void;
-  protected formatLinkProperty(node: AstNode): void;
-  protected formatNavigateToProperty(node: AstNode): void;
-  protected formatAutolayoutProperty(node: AstNode): void;
-  protected formatMetadataProperty(node: AstNode): void;
-  protected formatElementDeclaration(node: AstNode): void;
-  protected formatExtendElement(node: AstNode): void;
-  protected formatGlobals(node: AstNode): void;
-  protected formatImports(node: AstNode): void;
-  protected formatSpecificationRule(node: AstNode): void;
-  protected formatWithPredicate(node: AstNode): void;
-  protected formatDeploymentNodeDeclaration(node: AstNode): void;
-  protected formatDeployedInstance(node: AstNode): void;
-  protected formatViewRuleGlobalStyle(node: AstNode): void;
-  protected formatViewRuleGlobalPredicate(node: AstNode): void;
-  protected formatViewRuleGroup(node: AstNode): void;
-  protected formatViewRuleStyle(node: AstNode): void;
-  protected formatWhereExpression(node: AstNode): void;
-  protected formatWhereRelationExpression(node: AstNode): void;
-  protected formatWhereElementExpression(node: AstNode): void;
-  protected formatIncludeExcludeExpressions(node: AstNode): void;
-  protected formatRelationExpression(node: AstNode): void;
-  private findPredicateExpressionRoot;
-  private on;
-  private doExtendedFormatting;
-  protected normalizeQuotes(node: AstNode): void;
-  private quotesNormalizerFactory;
-  private escapeQuotesInternalQuotes;
-  private getAutoQuoteStyle;
-  private onConfigurationUpdate;
-} //#endregion
-//#region src/lsp/CodeLensProvider.d.ts
-declare class LikeC4CodeLensProvider implements CodeLensProvider {
-  private services;
-  constructor(services: LikeC4Services);
-  provideCodeLens(doc: LangiumDocument, _params: CodeLensParams, cancelToken?: CancellationToken$1): Promise<CodeLens[] | undefined>;
-} //#endregion
-//#region src/lsp/CompletionProvider.d.ts
-declare class LikeC4CompletionProvider extends DefaultCompletionProvider {
-  protected services: LikeC4Services;
-  constructor(services: LikeC4Services);
-  readonly completionOptions: {
-    triggerCharacters: string[];
-  };
-  protected completionFor(context: CompletionContext, next: NextFeature, acceptor: CompletionAcceptor): MaybePromise<void>;
-  protected completionForKeyword(context: CompletionContext, keyword: Keyword, acceptor: CompletionAcceptor): MaybePromise<void>;
-  protected completionForImportedProject(context: CompletionContext, acceptor: CompletionAcceptor): void;
-} //#endregion
-//#region src/lsp/DocumentHighlightProvider.d.ts
-declare class LikeC4DocumentHighlightProvider extends DefaultDocumentHighlightProvider {
-  /**
-   * Override this method to determine the highlight kind of the given reference.
-   */
-  protected createDocumentHighlight(reference: ReferenceDescription): DocumentHighlight;
-} //#endregion
-//#region src/lsp/DocumentLinkProvider.d.ts
-declare class LikeC4DocumentLinkProvider implements DocumentLinkProvider {
-  private services;
-  constructor(services: LikeC4Services);
-  getDocumentLinks(doc: LangiumDocument, _params: DocumentLinkParams, _cancelToken?: CancellationToken$1): Promise<DocumentLink[]>;
-  resolveLink(doc: LangiumDocument, link: string): string;
-  relativeLink(doc: LangiumDocument, link: string): string | null;
-} //#endregion
-//#region src/references/name-provider.d.ts
-declare class LikeC4NameProvider extends DefaultNameProvider {
-  protected services: LikeC4Services;
-  constructor(services: LikeC4Services);
-  getNameStrict(node: AstNode): string;
-  getName(node: AstNode): string | undefined;
-  getNameNode(node: AstNode): CstNode | undefined;
-} //#endregion
-//#region src/references/scope-computation.d.ts
-type ElementsContainer = Model | ElementBody | ExtendElementBody;
-type DeploymentsContainer = ModelDeployments | DeploymentNodeBody | ExtendDeploymentBody | DeployedInstanceBody;
-declare class LikeC4ScopeComputation extends DefaultScopeComputation {
-  constructor(services: LikeC4Services);
-  computeExports(document: LikeC4LangiumDocument, _cancelToken?: CancellationToken$1): Promise<AstNodeDescription[]>;
-  private exportViews;
-  private exportGlobals;
-  private exportModel;
-  private exportLibrary;
-  private exportSpecification;
-  private exportDeployments;
-  computeLocalScopes(document: LikeC4LangiumDocument, _cancelToken?: CancellationToken$1): Promise<PrecomputedScopes>;
-  protected processContainer(container: ElementsContainer, scopes: PrecomputedScopes, document: LikeC4LangiumDocument): AstNodeDescription[];
-  protected processDeployments(container: DeploymentsContainer, scopes: PrecomputedScopes, document: LikeC4LangiumDocument): AstNodeDescription[];
-} //#endregion
-//#region src/workspace/IndexManager.d.ts
-declare class IndexManager extends DefaultIndexManager {
-  protected services: LikeC4SharedServices;
-  constructor(services: LikeC4SharedServices);
-  updateContent(document: LangiumDocument, cancelToken?: CancellationToken$1): Promise<void>;
-  projectElements(projectId: ProjectId$1, nodeType?: string, uris?: Set<string>): Stream<AstNodeDescription>;
-} //#endregion
-//#region src/workspace/LangiumDocuments.d.ts
-declare class LangiumDocuments extends DefaultLangiumDocuments {
-  protected services: LikeC4SharedServices;
-  constructor(services: LikeC4SharedServices);
-  addDocument(document: LangiumDocument): void;
-  getDocument(uri: URI): LikeC4LangiumDocument | undefined;
-  /**
-   * Returns all known documents, without any filtering.
-   */
-  get allKnownDocuments(): Stream<LangiumDocument>;
-  get all(): Stream<LikeC4LangiumDocument>;
-  /**
-   * Returns all documents, excluding built-in documents and documents excluded by ProjectsManager.
-   */
-  get allExcludingBuiltin(): Stream<LikeC4LangiumDocument>;
-  /**
-   * Returns all documents for a project, including both project documents and documents included by the project.
-   */
-  projectDocuments(projectId: ProjectId$1): Stream<LikeC4LangiumDocument>;
-  groupedByProject(): Record<ProjectId$1, NonEmptyArray<LikeC4LangiumDocument>>;
-  /**
-   * Reset the project IDs of all documents.
-   */
-  resetProjectIds(): void;
-} //#endregion
-//#region src/workspace/WorkspaceManager.d.ts
-declare class LikeC4WorkspaceManager extends DefaultWorkspaceManager {
-  private services;
-  protected readonly documentFactory: LangiumDocumentFactory;
-  protected readonly fileSystemProvider: FileSystemProvider$1;
-  initialBuildOptions: BuildOptions;
-  constructor(services: LikeC4SharedServices);
-  /**
-   * First load all project config files, then load all documents in the workspace.
-   */
-  protected performStartup(folders: WorkspaceFolder[]): Promise<LangiumDocument[]>;
-  /**
-   * Load all additional documents that shall be visible in the context of the given workspace
-   * folders and add them to the collector. This can be used to include built-in libraries of
-   * your language, which can be either loaded from provided files or constructed in memory.
-   */
-  protected loadAdditionalDocuments(folders: WorkspaceFolder[], collector: (document: LangiumDocument) => void): Promise<void>;
-  /**
-   * Determine whether the given folder entry shall be included while indexing the workspace.
-   */
-  protected includeEntry(_workspaceFolder: WorkspaceFolder, entry: FileSystemNode, selector: FileSelector): boolean;
-  workspace(): WorkspaceFolder | null;
-  rebuildAll(cancelToken?: CancellationToken$1): Promise<void>;
-  get workspaceUri(): URI;
-  get workspaceURL(): URL;
-} //#endregion
-//#region src/references/scope-provider.d.ts
-declare class LikeC4ScopeProvider extends DefaultScopeProvider {
-  protected deploymentsIndex: DeploymentsIndex;
-  protected fqnIndex: FqnIndex;
-  protected readonly indexManager: IndexManager;
-  constructor(services: LikeC4Services);
-  getScope(context: ReferenceInfo): Scope;
-  protected genUniqueDescedants(element: Element | DeploymentNode | undefined): Generator<AstNodeDescriptionWithFqn, void, any>;
-  protected genScopeExtendElement({
-    element
-  }: ExtendElement): Generator<AstNodeDescription>;
-  protected genScopeElementView({
-    viewOf,
-    extends: ext
-  }: ElementView): Generator<AstNodeDescription>;
-  protected getScopeForStrictFqnRef(projectId: ProjectId$1, container: StrictFqnRef, context: ReferenceInfo): Scope;
-  protected genScopeExtendDeployment({
-    deploymentNode
-  }: ExtendDeployment): Generator<AstNodeDescription>;
-  protected streamForFqnRef(projectId: ProjectId$1, container: FqnRef$2, context: ReferenceInfo): Stream<AstNodeDescription>;
-  protected genScopeForParentlessFqnRef(projectId: ProjectId$1, container: FqnRef$2, context: ReferenceInfo): Generator<AstNodeDescription>;
-  /**
-   * Computes the scope for a given reference context.
-   *
-   * @param context - The reference information containing the context for which the scope is being computed.
-   * @param referenceType - The type of reference being resolved. Defaults to the reference type derived from the context.
-   * @returns A scope containing the relevant AST node descriptions for the given reference context.
-   *
-   * This method first checks if there are precomputed scopes available in the document. If not, it falls back to the global scope.
-   * It then iterates through the container hierarchy, collecting relevant scopes based on the reference type and container type.
-   * Finally, it combines the collected scopes with the global scope to produce the final scope.
-   */
-  protected computeScope(projectId: ProjectId$1, context: ReferenceInfo, referenceType?: string): Generator<AstNodeDescription>;
-  /**
-   * Create a global scope filtered for the given reference type.
-   */
-  protected getProjectScope(projectId: ProjectId$1, referenceType: string, context: ReferenceInfo): Scope;
-  /**
-   * Create a global scope filtered for the given reference type.
-   */
-  protected getGlobalScope(referenceType: string, context: ReferenceInfo): Scope;
-} //#endregion
-//#region src/lsp/DocumentSymbolProvider.d.ts
-declare class LikeC4DocumentSymbolProvider implements DocumentSymbolProvider {
-  private services;
-  protected readonly nodeKindProvider: NodeKindProvider;
-  protected readonly nameProvider: LikeC4NameProvider;
-  protected readonly parser: LikeC4ModelParser;
-  protected readonly locator: LikeC4ModelLocator;
-  constructor(services: LikeC4Services);
-  getSymbols(doc: LangiumDocument, _params: DocumentSymbolParams, cancelToken?: CancellationToken$1): Promise<DocumentSymbol[]>;
-  protected getLikec4LibSymbol(astLib: LikeC4Lib): DocumentSymbol[];
-  protected getSpecSymbol(astSpec: SpecificationRule): DocumentSymbol[];
-  protected getModelSymbol(astModel: Model): DocumentSymbol[];
-  protected getDeploymentModelSymbol(astModel: ModelDeployments): DocumentSymbol[];
-  protected getElementsSymbol(el: Element | Relation | ExtendElement): DocumentSymbol[];
-  protected getExtendElementSymbol(astElement: ExtendElement): DocumentSymbol[];
-  protected getElementSymbol(astElement: Element): DocumentSymbol[];
-  protected getModelViewsSymbol(astViews: ModelViews): DocumentSymbol[];
-  protected getKindSymbol(astKind: SpecificationElementKind | SpecificationRelationshipKind): DocumentSymbol | null;
-  protected getTagSymbol(astTag: SpecificationTag): DocumentSymbol | null;
-  protected getLibIconSymbol(astTag: LibIcon): DocumentSymbol | null;
-  protected getViewSymbol(astView: LikeC4View): DocumentSymbol[];
-  protected getDeploymentElementSymbol(el: DeploymentElement | DeploymentRelation | ExtendDeployment): DocumentSymbol[];
-  protected getDeploymentNodeSymbol(astElement: DeploymentNode): DocumentSymbol[];
-  protected getDeployedInstanceSymbol(astElement: DeployedInstance): DocumentSymbol[];
-  protected symbolKind(node: AstNode): SymbolKind;
-} //#endregion
-//#region src/lsp/HoverProvider.d.ts
-declare class LikeC4HoverProvider extends AstNodeHoverProvider {
-  private parser;
-  private locator;
-  constructor(services: LikeC4Services);
-  protected getAstNodeHoverContent(node: AstNode): MaybePromise<Hover | undefined>;
-} //#endregion
-//#region src/lsp/CodeActionProvider.d.ts
-type CommandOrCodeAction = Command | CodeAction;
-declare class LikeC4CodeActionProvider implements CodeActionProvider {
-  /**
-   * Handle a code action 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
-   */
-  getCodeActions(document: LangiumDocument, params: CodeActionParams): CommandOrCodeAction[] | undefined;
-} //#endregion
-//#region src/lsp/SemanticTokenProvider.d.ts
-declare class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
-  protected services: LikeC4Services;
-  private rules;
-  constructor(services: LikeC4Services);
-  protected initRules(): void;
-  semanticHighlight(document: LangiumDocument, params: SemanticTokensParams, cancelToken?: CancellationToken$1): Promise<SemanticTokens>;
-  semanticHighlightRange(document: LangiumDocument, params: SemanticTokensRangeParams, cancelToken?: CancellationToken$1): Promise<SemanticTokens>;
-  semanticHighlightDelta(document: LangiumDocument, params: SemanticTokensDeltaParams, cancelToken?: CancellationToken$1): Promise<SemanticTokens | SemanticTokensDelta>;
-  protected ensureState(document: LangiumDocument, cancelToken: CancellationToken$1): Promise<void>;
-  protected highlightElement(node: AstNode, acceptor: SemanticTokenAcceptor): void | undefined | 'prune';
-  private highlightNameAndKind;
-  private highlightView;
-  private mark;
-} //#endregion
-//#region src/mcp/types.d.ts
-interface LikeC4MCPServer {
-  readonly mcp: McpServer;
-  readonly isStarted: boolean;
-  readonly port: number;
-  start(port?: number): Promise<void>;
-  stop(): Promise<void>;
-}
-interface LikeC4MCPServerFactory {
-  create(options?: ServerOptions): McpServer;
-}
-//#endregion
-//#region src/model-change/ModelChanges.d.ts
-declare class LikeC4ModelChanges {
-  private services;
-  private locator;
-  constructor(services: LikeC4Services);
-  applyChange(changeView: ChangeView.Params): Promise<ChangeView.Res>;
-  protected convertToTextEdit({
-    lookup,
-    change
-  }: {
-    lookup: ViewLocateResult;
-    change: Exclude<ViewChange$1, ViewChange$1.SaveViewSnapshot | ViewChange$1.ResetManualLayout>;
-  }): {
-    modifiedRange: Range;
-    edits: TextEdit[];
-  };
-} //#endregion
-//#region src/utils/disposable.d.ts
-declare abstract class ADisposable implements Disposable$1 {
-  protected toDispose: Disposable$1[];
-  protected isDisposed: boolean;
-  onDispose(...disposable: Disposable$1[]): void;
-  dispose(): void;
-  protected throwIfDisposed(): void;
-} //#endregion
-//#region src/Rpc.d.ts
-declare class Rpc extends ADisposable {
-  private services;
-  constructor(services: LikeC4Services);
-  init(): void;
-  openView(params: DidRequestOpenViewNotification.Params): Promise<void>;
-} //#endregion
-//#region src/shared/NodeKindProvider.d.ts
-declare class NodeKindProvider$1 implements NodeKindProvider {
-  private services;
-  constructor(services: LangiumSharedServices);
-  /**
-   * Returns a `SymbolKind` as used by `WorkspaceSymbolProvider` or `DocumentSymbolProvider`.
-   */
-  getSymbolKind(node: AstNode | AstNodeDescription): SymbolKind;
-  /**
-   * Returns a `CompletionItemKind` as used by the `CompletionProvider`.
-   */
-  getCompletionItemKind(node: AstNode | AstNodeDescription): CompletionItemKind;
-} //#endregion
-//#region src/shared/WorkspaceSymbolProvider.d.ts
-declare class WorkspaceSymbolProvider extends DefaultWorkspaceSymbolProvider {} //#endregion
-//#region src/views/LikeC4Views.d.ts
-type GraphvizOut = {
-  readonly dot: string;
-  readonly diagram: LayoutedView$1;
-};
-type GraphvizSvgOut = {
-  readonly id: ViewId$1;
-  readonly dot: string;
-  readonly svg: string;
-};
-type LayoutViewParams = {
-  viewId: ViewId$1;
-  /**
-   * Type of layout to apply
-   * - 'manual' - applies manual layout if any
-   * - 'auto' - returns latest version with drifts from manual layout if any
-   * - undefined - returns latest layout as is
-   */
-  layoutType?: LayoutType | undefined;
-  projectId?: ProjectId$1 | undefined;
-  cancelToken?: CancellationToken$1 | undefined;
-};
-interface LikeC4Views {
-  readonly layouter: GraphvizLayouter;
-  /**
-   * Returns computed views (i.e. views with predicates computed)
-   *
-   * @param projectId - project id, if not specified - uses the default project
-   */
-  computedViews(projectId?: ProjectId$1 | undefined, cancelToken?: CancellationToken$1): Promise<ComputedView[]>;
-  /**
-   * Layouts all views (ignoring any manual snapshots)
-   *
-   * @param projectId - project id, if not specified - uses the default project
-   */
-  layoutAllViews(projectId?: ProjectId$1 | undefined, cancelToken?: CancellationToken$1): Promise<GraphvizOut[]>;
-  /**
-   * Layouts a view.
-   * If layoutType is 'manual' - applies manual layout if any.
-   * If layoutType is 'auto' - returns latest version with drifts from manual layout if any
-   * If not specified - returns latest layout as is
-   *
-   * If view not found in model, but there is a snapshot - it will be returned (with empty DOT)
-   *
-   * @param projectId - project id, if not specified - uses the default project
-   */
-  layoutView(params: LayoutViewParams): Promise<GraphvizOut | null>;
-  /**
-   * Returns diagrams.
-   * If diagram has manual layout, it will be used.
-   * @param projectId - project id, if not specified - uses the default project
-   */
-  diagrams(projectId?: ProjectId$1 | undefined, cancelToken?: CancellationToken$1): Promise<Array<DiagramView>>;
-  /**
-   * Returns all layouted views as Graphviz output (i.e. views with layout computed)
-   * @param projectId - project id, if not specified - uses the default project
-   */
-  viewsAsGraphvizOut(projectId?: ProjectId$1 | undefined, cancelToken?: CancellationToken$1): Promise<Array<GraphvizSvgOut>>;
-  /**
-   * Open view in the preview panel.
-   * (works only if running as a vscode extension)
-   *
-   * @param projectId - project id, if not specified - uses the default project
-   */
-  openView(viewId: ViewId$1, projectId?: ProjectId$1 | undefined): Promise<void>;
-  /**
-   * Computes and layouts an adhoc view (not defined in the model)
-   *
-   * @param projectId - project id, if not specified - uses the default project
-   */
-  adhocView(predicates: AdhocViewPredicate[], projectId?: ProjectId$1 | undefined): Promise<LayoutedView$1>;
-} //#endregion
-//#region src/module.d.ts
-interface LikeC4AddedSharedServices {
-  lsp: {
-    NodeKindProvider: NodeKindProvider$1;
-    WorkspaceSymbolProvider: WorkspaceSymbolProvider;
-  };
-  workspace: {
-    Cache: WorkspaceCache<string, any>;
-    ProjectsManager: ProjectsManager;
-    IndexManager: IndexManager;
-    LangiumDocuments: LangiumDocuments;
-    WorkspaceManager: LikeC4WorkspaceManager;
-    FileSystemProvider: FileSystemProvider$1;
-    FileSystemWatcher: FileSystemWatcher;
-    ManualLayouts: LikeC4ManualLayouts;
-  };
-}
-type LikeC4SharedServices = LangiumSharedServices & LikeC4AddedSharedServices;
-/**
- * Declaration of custom services - add your own service classes here.
- */
-interface LikeC4AddedServices {
-  documentation: {
-    DocumentationProvider: LikeC4DocumentationProvider;
-  };
-  validation: {
-    DocumentValidator: LikeC4DocumentValidator;
-  };
-  Rpc: Rpc;
-  mcp: {
-    Server: LikeC4MCPServer;
-    ServerFactory: LikeC4MCPServerFactory;
-  };
-  likec4: {
-    LanguageServices: LikeC4LanguageServices;
-    Views: LikeC4Views;
-    Layouter: QueueGraphvizLayoter;
-    DeploymentsIndex: DeploymentsIndex;
-    FqnIndex: FqnIndex;
-    ModelParser: LikeC4ModelParser;
-    ModelBuilder: LikeC4ModelBuilder;
-    ModelLocator: LikeC4ModelLocator;
-    ModelChanges: LikeC4ModelChanges;
-  };
-  lsp: {
-    CompletionProvider: LikeC4CompletionProvider;
-    DocumentHighlightProvider: LikeC4DocumentHighlightProvider;
-    DocumentSymbolProvider: LikeC4DocumentSymbolProvider;
-    SemanticTokenProvider: LikeC4SemanticTokenProvider;
-    HoverProvider: LikeC4HoverProvider;
-    CodeLensProvider: LikeC4CodeLensProvider;
-    DocumentLinkProvider: LikeC4DocumentLinkProvider;
-    Formatter: LikeC4Formatter;
-    CodeActionProvider: LikeC4CodeActionProvider;
-  };
-  references: {
-    NameProvider: LikeC4NameProvider;
-    ScopeComputation: LikeC4ScopeComputation;
-    ScopeProvider: LikeC4ScopeProvider;
-  };
-  shared?: LikeC4SharedServices;
-  parser: {
-    ValueConverter: LikeC4ValueConverter;
-  };
+declare const WhereRelationParticipantTag = "WhereRelationParticipantTag";
+interface WhereRelationTag extends AstNode {
+  readonly $container: RelationExprWhere | WhereBinaryExpression | WhereRelationNegation;
+  readonly $type: 'WhereRelationTag';
+  not: boolean;
+  operator: 'is' | string;
+  value: TagRef;
 }
-type LikeC4Services = LangiumServices & LikeC4AddedServices;
-/**
- * Most probably you don't need to use this function directly.
- * Use {@link createLanguageServices} instead.
- * @internal
- */
-//#endregion
+declare const WhereRelationTag = "WhereRelationTag";
+interface WildcardExpression extends AstNode {
+  readonly $container: DirectedRelationExpr | Expressions | FqnExprWhere | FqnExprWith | FqnExpressions | IncomingRelationExpr | OutgoingRelationExpr;
+  readonly $type: 'WildcardExpression';
+  isWildcard: boolean;
+}
+declare const WildcardExpression = "WildcardExpression";
+interface DynamicStepChain extends AbstractDynamicStep {
+  readonly $container: DynamicStepChain | DynamicViewBody | DynamicViewParallelSteps;
+  readonly $type: 'DynamicStepChain';
+  source: DynamicStepChain | DynamicStepSingle;
+}
+declare const DynamicStepChain = "DynamicStepChain";
+interface DynamicStepSingle extends AbstractDynamicStep {
+  readonly $container: DynamicStepChain | DynamicViewBody | DynamicViewParallelSteps;
+  readonly $type: 'DynamicStepSingle';
+  isBackward: boolean;
+  source: ElementRef;
+}
+declare const DynamicStepSingle = "DynamicStepSingle";
+type LikeC4AstType = {
+  AbstractDynamicStep: AbstractDynamicStep;
+  AnyProperty: AnyProperty;
+  ArrowProperty: ArrowProperty;
+  BorderProperty: BorderProperty;
+  ColorLiteral: ColorLiteral$1;
+  ColorProperty: ColorProperty;
+  CustomColor: CustomColor;
+  CustomElementProperties: CustomElementProperties;
+  CustomRelationProperties: CustomRelationProperties;
+  DeployedInstance: DeployedInstance;
+  DeployedInstanceBody: DeployedInstanceBody;
+  DeploymentElement: DeploymentElement;
+  DeploymentNode: DeploymentNode;
+  DeploymentNodeBody: DeploymentNodeBody;
+  DeploymentNodeKind: DeploymentNodeKind;
+  DeploymentNodeOrElementKind: DeploymentNodeOrElementKind;
+  DeploymentRelation: DeploymentRelation;
+  DeploymentRelationBody: DeploymentRelationBody;
+  DeploymentView: DeploymentView;
+  DeploymentViewBody: DeploymentViewBody;
+  DeploymentViewRule: DeploymentViewRule;
+  DeploymentViewRulePredicate: DeploymentViewRulePredicate;
+  DeploymentViewRuleStyle: DeploymentViewRuleStyle;
+  DirectedRelationExpr: DirectedRelationExpr;
+  DynamicStepChain: DynamicStepChain;
+  DynamicStepSingle: DynamicStepSingle;
+  DynamicView: DynamicView;
+  DynamicViewBody: DynamicViewBody;
+  DynamicViewDisplayVariantProperty: DynamicViewDisplayVariantProperty;
+  DynamicViewGlobalPredicateRef: DynamicViewGlobalPredicateRef;
+  DynamicViewIncludePredicate: DynamicViewIncludePredicate;
+  DynamicViewParallelSteps: DynamicViewParallelSteps;
+  DynamicViewProperty: DynamicViewProperty;
+  DynamicViewRef: DynamicViewRef;
+  DynamicViewRule: DynamicViewRule;
+  DynamicViewStep: DynamicViewStep;
+  Element: Element;
+  ElementBody: ElementBody;
+  ElementKind: ElementKind;
+  ElementKindExpression: ElementKindExpression;
+  ElementProperty: ElementProperty;
+  ElementRef: ElementRef;
+  ElementStringProperty: ElementStringProperty;
+  ElementStyleProperty: ElementStyleProperty;
+  ElementTagExpression: ElementTagExpression;
+  ElementView: ElementView;
+  ElementViewBody: ElementViewBody;
+  ElementViewRef: ElementViewRef;
+  ExpressionV2: ExpressionV2;
+  Expressions: Expressions;
+  ExtendDeployment: ExtendDeployment;
+  ExtendDeploymentBody: ExtendDeploymentBody;
+  ExtendElement: ExtendElement;
+  ExtendElementBody: ExtendElementBody;
+  ExtendElementProperty: ExtendElementProperty;
+  ExtendRelation: ExtendRelation;
+  ExtendRelationBody: ExtendRelationBody;
+  ExtendRelationProperty: ExtendRelationProperty;
+  FqnExpr: FqnExpr$2;
+  FqnExprOrWhere: FqnExprOrWhere;
+  FqnExprOrWith: FqnExprOrWith;
+  FqnExprWhere: FqnExprWhere;
+  FqnExprWith: FqnExprWith;
+  FqnExpressions: FqnExpressions;
+  FqnRef: FqnRef$2;
+  FqnRefExpr: FqnRefExpr;
+  FqnReferenceable: FqnReferenceable;
+  GlobalDynamicPredicateGroup: GlobalDynamicPredicateGroup;
+  GlobalPredicateGroup: GlobalPredicateGroup;
+  GlobalStyle: GlobalStyle;
+  GlobalStyleGroup: GlobalStyleGroup;
+  GlobalStyleId: GlobalStyleId;
+  Globals: Globals;
+  HexColor: HexColor;
+  IconColorProperty: IconColorProperty;
+  IconPositionProperty: IconPositionProperty;
+  IconProperty: IconProperty;
+  IconSizeProperty: IconSizeProperty;
+  Imported: Imported;
+  ImportsFromPoject: ImportsFromPoject;
+  InOutRelationExpr: InOutRelationExpr;
+  IncomingRelationExpr: IncomingRelationExpr;
+  LibIcon: LibIcon;
+  LikeC4Grammar: LikeC4Grammar;
+  LikeC4Lib: LikeC4Lib;
+  LikeC4View: LikeC4View;
+  LineProperty: LineProperty;
+  LinkProperty: LinkProperty;
+  MarkdownOrString: MarkdownOrString;
+  MetadataArray: MetadataArray;
+  MetadataAttribute: MetadataAttribute;
+  MetadataBody: MetadataBody;
+  MetadataProperty: MetadataProperty;
+  MetadataValue: MetadataValue;
+  Model: Model;
+  ModelDeployments: ModelDeployments;
+  ModelReferenceable: ModelReferenceable;
+  ModelViews: ModelViews;
+  MultipleProperty: MultipleProperty;
+  NavigateToProperty: NavigateToProperty;
+  NotationProperty: NotationProperty;
+  NotesProperty: NotesProperty;
+  OpacityProperty: OpacityProperty;
+  OutgoingRelationExpr: OutgoingRelationExpr;
+  PaddingSizeProperty: PaddingSizeProperty;
+  RGBAColor: RGBAColor;
+  Referenceable: Referenceable;
+  Relation: Relation;
+  RelationBody: RelationBody;
+  RelationExpr: RelationExpr$1;
+  RelationExprOrWhere: RelationExprOrWhere;
+  RelationExprOrWith: RelationExprOrWith;
+  RelationExprWhere: RelationExprWhere;
+  RelationExprWith: RelationExprWith;
+  RelationKindDotRef: RelationKindDotRef;
+  RelationNavigateToProperty: RelationNavigateToProperty;
+  RelationProperty: RelationProperty;
+  RelationStringProperty: RelationStringProperty;
+  RelationStyleProperty: RelationStyleProperty;
+  RelationshipKind: RelationshipKind;
+  RelationshipStyleProperty: RelationshipStyleProperty;
+  ShapeProperty: ShapeProperty;
+  ShapeSizeProperty: ShapeSizeProperty;
+  SizeProperty: SizeProperty;
+  SpecificationColor: SpecificationColor;
+  SpecificationDeploymentNodeKind: SpecificationDeploymentNodeKind;
+  SpecificationElementKind: SpecificationElementKind;
+  SpecificationElementStringProperty: SpecificationElementStringProperty;
+  SpecificationRelationshipKind: SpecificationRelationshipKind;
+  SpecificationRelationshipStringProperty: SpecificationRelationshipStringProperty;
+  SpecificationRule: SpecificationRule;
+  SpecificationTag: SpecificationTag;
+  StrictFqnElementRef: StrictFqnElementRef;
+  StrictFqnRef: StrictFqnRef;
+  StringProperty: StringProperty;
+  StyleProperty: StyleProperty;
+  Tag: Tag$1;
+  TagRef: TagRef;
+  Tags: Tags;
+  TextSizeProperty: TextSizeProperty;
+  ViewProperty: ViewProperty;
+  ViewRef: ViewRef;
+  ViewRule: ViewRule;
+  ViewRuleAutoLayout: ViewRuleAutoLayout;
+  ViewRuleGlobalPredicateRef: ViewRuleGlobalPredicateRef;
+  ViewRuleGlobalStyle: ViewRuleGlobalStyle;
+  ViewRuleGroup: ViewRuleGroup;
+  ViewRulePredicate: ViewRulePredicate;
+  ViewRuleRank: ViewRuleRank;
+  ViewRuleStyle: ViewRuleStyle;
+  ViewRuleStyleOrGlobalRef: ViewRuleStyleOrGlobalRef;
+  ViewStringProperty: ViewStringProperty;
+  WhereBinaryExpression: WhereBinaryExpression;
+  WhereElement: WhereElement;
+  WhereElementExpression: WhereElementExpression;
+  WhereElementKind: WhereElementKind;
+  WhereElementNegation: WhereElementNegation;
+  WhereElementTag: WhereElementTag;
+  WhereExpression: WhereExpression;
+  WhereKindEqual: WhereKindEqual;
+  WhereRelation: WhereRelation;
+  WhereRelationExpression: WhereRelationExpression;
+  WhereRelationKind: WhereRelationKind;
+  WhereRelationNegation: WhereRelationNegation;
+  WhereRelationParticipantKind: WhereRelationParticipantKind;
+  WhereRelationParticipantTag: WhereRelationParticipantTag;
+  WhereRelationTag: WhereRelationTag;
+  WhereTagEqual: WhereTagEqual;
+  WildcardExpression: WildcardExpression;
+}; //#endregion
 //#region src/validation/DocumentValidator.d.ts
 declare class LikeC4DocumentValidator extends DefaultDocumentValidator {
   protected services: LikeC4Services;
@@ -2249,10 +1853,8 @@ declare class LikeC4DocumentValidator extends DefaultDocumentValidator {
   validateDocument(document: LangiumDocument, options?: ValidationOptions, cancelToken?: CancellationToken$1): Promise<Diagnostic[]>;
 } //#endregion
 //#region src/validation/index.d.ts
-type Guard<N extends AstNode> = (n: AstNode) => n is N;
-type Guarded<G> = G extends Guard<infer N> ? N : never;
-declare const isValidatableAstNode: (n: AstNode) => n is DeploymentView | DynamicView | ElementView | Element | DeployedInstance | DeploymentNode | ImportsFromPoject | Imported | Globals | GlobalPredicateGroup | GlobalDynamicPredicateGroup | GlobalStyle | GlobalStyleGroup | FqnExprWith | DeploymentViewRulePredicate | DynamicViewIncludePredicate | ViewRulePredicate | ViewRuleGroup | RelationExprWith | ElementKindExpression | ElementTagExpression | FqnRefExpr | WildcardExpression | DirectedRelationExpr | FqnExprWhere | IncomingRelationExpr | OutgoingRelationExpr | RelationExprWhere | DeploymentViewRuleStyle | ViewRuleRank | ViewRuleStyle | InOutRelationExpr | DynamicViewParallelSteps | DynamicStepChain | DynamicStepSingle | ViewRuleAutoLayout | LinkProperty | ViewStringProperty | SpecificationDeploymentNodeKind | SpecificationElementKind | ExtendDeployment | DeploymentRelation | ExtendElement | ExtendRelation | Relation | SpecificationRule | BorderProperty | ColorProperty | IconColorProperty | IconPositionProperty | IconProperty | IconSizeProperty | MultipleProperty | OpacityProperty | PaddingSizeProperty | ShapeProperty | ShapeSizeProperty | TextSizeProperty | ElementStyleProperty | SpecificationRelationshipKind | Tags | ViewRuleGlobalPredicateRef | ViewRuleGlobalStyle | DynamicViewGlobalPredicateRef | ArrowProperty | LineProperty | DynamicViewDisplayVariantProperty | MetadataBody | ElementStringProperty | MetadataAttribute | NotationProperty | NotesProperty | RelationStringProperty | SpecificationElementStringProperty | SpecificationRelationshipStringProperty | NavigateToProperty | ElementRef | SpecificationTag | SpecificationColor | HexColor | RGBAColor;
-type ValidatableAstNode = Guarded<typeof isValidatableAstNode>;
+declare const isValidatableAstNode: any;
+type ValidatableAstNode = GuardedBy<typeof isValidatableAstNode>;
 declare function checksFromDiagnostics(doc: LikeC4LangiumDocument): {
   isValid: (n: ValidatableAstNode) => boolean;
   invalidNodes: WeakSet<WeakKey>;
@@ -2326,7 +1928,7 @@ interface ParsedAstElement {
   id: c4.Fqn;
   astPath: string;
   kind: c4.ElementKind;
-  title: string;
+  title?: string;
   summary?: c4.MarkdownOrString;
   description?: c4.MarkdownOrString;
   technology?: string;
@@ -2447,8 +2049,149 @@ interface LikeC4LangiumDocument extends LikeC4GrammarDocument, LikeC4DocumentPro
 }
 interface ParsedLikeC4LangiumDocument extends LikeC4GrammarDocument, Required<LikeC4DocumentProps> {
   likec4ProjectId: c4.ProjectId;
-}
-//#endregion
+} //#endregion
+//#region src/references/name-provider.d.ts
+declare class LikeC4NameProvider extends DefaultNameProvider {
+  protected services: LikeC4Services;
+  constructor(services: LikeC4Services);
+  getNameStrict(node: AstNode): string;
+  getName(node: AstNode): string | undefined;
+  getNameNode(node: AstNode): CstNode | undefined;
+} //#endregion
+//#region src/references/scope-computation.d.ts
+type ElementsContainer = Model | ElementBody | ExtendElementBody;
+type DeploymentsContainer = ModelDeployments | DeploymentNodeBody | ExtendDeploymentBody | DeployedInstanceBody;
+declare class LikeC4ScopeComputation extends DefaultScopeComputation {
+  constructor(services: LikeC4Services);
+  computeExports(document: LikeC4LangiumDocument, _cancelToken?: CancellationToken$1): Promise<AstNodeDescription[]>;
+  private exportViews;
+  private exportGlobals;
+  private exportModel;
+  private exportLibrary;
+  private exportSpecification;
+  private exportDeployments;
+  computeLocalScopes(document: LikeC4LangiumDocument, _cancelToken?: CancellationToken$1): Promise<PrecomputedScopes>;
+  protected processContainer(container: ElementsContainer, scopes: PrecomputedScopes, document: LikeC4LangiumDocument): AstNodeDescription[];
+  protected processDeployments(container: DeploymentsContainer, scopes: PrecomputedScopes, document: LikeC4LangiumDocument): AstNodeDescription[];
+} //#endregion
+//#region src/workspace/IndexManager.d.ts
+declare class IndexManager extends DefaultIndexManager {
+  protected services: LikeC4SharedServices;
+  constructor(services: LikeC4SharedServices);
+  updateContent(document: LangiumDocument, cancelToken?: CancellationToken$1): Promise<void>;
+  projectElements(projectId: ProjectId, nodeType?: string, uris?: Set<string>): Stream<AstNodeDescription>;
+} //#endregion
+//#region src/workspace/LangiumDocuments.d.ts
+declare class LangiumDocuments extends DefaultLangiumDocuments {
+  protected services: LikeC4SharedServices;
+  constructor(services: LikeC4SharedServices);
+  protected get projectsManager(): ProjectsManager;
+  addDocument(document: LangiumDocument): void;
+  getDocument(uri: URI): LangiumDocument | undefined;
+  /**
+   * Returns all user documents
+   */
+  get userDocuments(): Stream<LikeC4LangiumDocument>;
+  /**
+   * Returns all documents (ensures project IDs are set)
+   */
+  get all(): Stream<LangiumDocument>;
+  /**
+   * Returns all documents for a project, including both project documents and documents included by the project.
+   */
+  projectDocuments(projectId: ProjectId): Stream<LikeC4LangiumDocument>;
+  groupedByProject(): Record<ProjectId, NonEmptyArray<LikeC4LangiumDocument>>;
+  /**
+   * Reset the project IDs of all documents.
+   * Returns the URIs
+   */
+  resetProjectIds(): URI[];
+} //#endregion
+//#region src/workspace/WorkspaceManager.d.ts
+declare class LikeC4WorkspaceManager extends DefaultWorkspaceManager {
+  #private;
+  private services;
+  protected readonly documentFactory: LangiumDocumentFactory;
+  protected readonly fileSystemProvider: FileSystemProvider$1;
+  initialBuildOptions: BuildOptions;
+  constructor(services: LikeC4SharedServices);
+  /**
+   * First load all project config files, then load all documents in the workspace.
+   */
+  protected performStartup(folders: WorkspaceFolder[]): Promise<LangiumDocument[]>;
+  /**
+   * Load all additional documents that shall be visible in the context of the given workspace
+   * folders and add them to the collector. This can be used to include built-in libraries of
+   * your language, which can be either loaded from provided files or constructed in memory.
+   */
+  protected loadAdditionalDocuments(folders: WorkspaceFolder[], collector: (document: LangiumDocument) => void): Promise<void>;
+  /**
+   * Determine whether the given folder entry shall be included while indexing the workspace.
+   */
+  protected includeEntry(_: WorkspaceFolder, entry: FileSystemNode, selector: FileSelector): boolean;
+  workspace(): WorkspaceFolder | null;
+  rebuildAll(cancelToken?: CancellationToken$1): Promise<void>;
+  get workspaceUri(): URI;
+  get workspaceURL(): URL;
+  /**
+   * Force clean all caches
+   */
+  forceCleanCaches(): void;
+  /**
+   * Register a listener to be called when caches are force cleaned
+   */
+  onForceCleanCache(listener: () => void): Disposable$1;
+} //#endregion
+//#region src/references/scope-provider.d.ts
+declare class LikeC4ScopeProvider extends DefaultScopeProvider {
+  protected deploymentsIndex: DeploymentsIndex;
+  protected fqnIndex: FqnIndex;
+  protected readonly indexManager: IndexManager;
+  constructor(services: LikeC4Services);
+  getScope(context: ReferenceInfo): Scope;
+  protected genUniqueDescedants(element: Element | DeploymentNode | undefined): Generator<AstNodeDescriptionWithFqn, void, any>;
+  protected genScopeExtendElement({
+    element
+  }: ExtendElement): Generator<AstNodeDescription>;
+  protected genScopeElementView({
+    viewOf,
+    extends: ext
+  }: ElementView): Generator<AstNodeDescription>;
+  protected getScopeForStrictFqnRef(projectId: ProjectId, container: StrictFqnRef, context: ReferenceInfo): Scope;
+  protected genScopeExtendDeployment({
+    deploymentNode
+  }: ExtendDeployment): Generator<AstNodeDescription>;
+  protected streamForFqnRef(projectId: ProjectId, container: FqnRef$2, context: ReferenceInfo): Stream<AstNodeDescription>;
+  protected genScopeForParentlessFqnRef(projectId: ProjectId, container: FqnRef$2, context: ReferenceInfo): Generator<AstNodeDescription>;
+  /**
+   * Computes the scope for a given reference context.
+   *
+   * @param context - The reference information containing the context for which the scope is being computed.
+   * @param referenceType - The type of reference being resolved. Defaults to the reference type derived from the context.
+   * @returns A scope containing the relevant AST node descriptions for the given reference context.
+   *
+   * This method first checks if there are precomputed scopes available in the document. If not, it falls back to the global scope.
+   * It then iterates through the container hierarchy, collecting relevant scopes based on the reference type and container type.
+   * Finally, it combines the collected scopes with the global scope to produce the final scope.
+   */
+  protected computeScope(projectId: ProjectId, context: ReferenceInfo, referenceType?: string): Generator<AstNodeDescription>;
+  /**
+   * Create a global scope filtered for the given reference type.
+   */
+  protected getProjectScope(projectId: ProjectId, referenceType: string, context: ReferenceInfo): Scope;
+  /**
+   * Create a global scope filtered for the given reference type.
+   */
+  protected getGlobalScope(referenceType: string, context: ReferenceInfo): Scope;
+} //#endregion
+//#region src/utils/disposable.d.ts
+declare abstract class ADisposable implements Disposable$1 {
+  protected toDispose: Disposable$1[];
+  protected isDisposed: boolean;
+  onDispose(...disposable: Disposable$1[]): void;
+  dispose(): void;
+  protected throwIfDisposed(): void;
+} //#endregion
 //#region src/model/fqn-index.d.ts
 declare class FqnIndex<AstNd = Element> extends ADisposable {
   protected services: LikeC4Services;
@@ -2456,18 +2199,19 @@ declare class FqnIndex<AstNd = Element> extends ADisposable {
   protected langiumDocuments: LangiumDocuments;
   protected documentCache: DefaultWeakMap<LikeC4LangiumDocument, DocumentFqnIndex>;
   protected workspaceCache: WorkspaceCache<string, AstNodeDescriptionWithFqn[]>;
+  protected logger: any;
   constructor(services: LikeC4Services);
   private documents;
   get(document: LikeC4LangiumDocument): DocumentFqnIndex;
-  resolve(reference: Referenceable): Fqn;
-  getFqn(el: AstNd): Fqn;
-  byFqn(projectId: ProjectId, fqn: Fqn): Stream<AstNodeDescriptionWithFqn>;
-  rootElements(projectId: ProjectId): Stream<AstNodeDescriptionWithFqn>;
-  directChildrenOf(projectId: ProjectId, parent: Fqn): Stream<AstNodeDescriptionWithFqn>;
+  resolve(reference: Referenceable): Fqn$1;
+  getFqn(el: AstNd): Fqn$1;
+  byFqn(projectId: ProjectId$1, fqn: Fqn$1): Stream<AstNodeDescriptionWithFqn>;
+  rootElements(projectId: ProjectId$1): Stream<AstNodeDescriptionWithFqn>;
+  directChildrenOf(projectId: ProjectId$1, parent: Fqn$1): Stream<AstNodeDescriptionWithFqn>;
   /**
    * Returns descedant elements with unique names in the scope
    */
-  uniqueDescedants(projectId: ProjectId, parent: Fqn): Stream<AstNodeDescriptionWithFqn>;
+  uniqueDescedants(projectId: ProjectId$1, parent: Fqn$1): Stream<AstNodeDescriptionWithFqn>;
   protected createDocumentIndex(document: LikeC4LangiumDocument): DocumentFqnIndex;
 }
 declare class DocumentFqnIndex {
@@ -2484,87 +2228,300 @@ declare class DocumentFqnIndex {
    * All elements by FQN
    */
   private _byfqn;
-  readonly projectId: ProjectId;
+  readonly projectId: ProjectId$1;
   static readonly EMPTY: DocumentFqnIndex;
   constructor(_rootElements: Array<AstNodeDescriptionWithFqn>,
   /**
    * direct children of elements
    */
 
-  _children: MultiMap<Fqn, AstNodeDescriptionWithFqn>,
+  _children: MultiMap<Fqn$1, AstNodeDescriptionWithFqn>,
   /**
    * All descendants of an element (unique by name)
    */
 
-  _descendants: MultiMap<Fqn, AstNodeDescriptionWithFqn>,
+  _descendants: MultiMap<Fqn$1, AstNodeDescriptionWithFqn>,
   /**
    * All elements by FQN
    */
-
-  _byfqn: MultiMap<Fqn, AstNodeDescriptionWithFqn>, projectId: ProjectId);
-  rootElements(): readonly AstNodeDescriptionWithFqn[];
-  byFqn(fqn: Fqn): readonly AstNodeDescriptionWithFqn[];
-  children(parent: Fqn): readonly AstNodeDescriptionWithFqn[];
-  descendants(nodeName: Fqn): readonly AstNodeDescriptionWithFqn[];
-} //#endregion
-//#region src/model/deployments-index.d.ts
-declare class DeploymentsIndex extends FqnIndex<DeploymentElement> {
-  protected services: LikeC4Services;
-  protected Names: LikeC4NameProvider;
-  constructor(services: LikeC4Services);
-  protected createDocumentIndex(document: LikeC4LangiumDocument): DocumentFqnIndex;
-} //#endregion
-//#region src/model/model-builder.d.ts
-type ModelParsedListener = (docs: URI[]) => void;
-interface LikeC4ModelBuilder extends Disposable$1 {
-  parseModel(projectId?: ProjectId$1 | undefined, cancelToken?: CancellationToken$1): Promise<LikeC4Model<UnknownParsed> | null>;
-  unsafeSyncComputeModel(projectId: ProjectId$1): LikeC4Model<UnknownComputed>;
-  computeModel(projectId?: ProjectId$1 | undefined, cancelToken?: CancellationToken$1): Promise<LikeC4Model<UnknownComputed>>;
-  onModelParsed(callback: ModelParsedListener): Disposable$1;
-  clearCache(): void;
-} //#endregion
-//#region src/model/model-locator.d.ts
-type ViewLocateResult = {
-  doc: ParsedLikeC4LangiumDocument;
-  view: ParsedAstView;
-  viewAst: LikeC4View;
-};
-declare class LikeC4ModelLocator {
-  private services;
-  private fqnIndex;
-  private deploymentsIndex;
-  private langiumDocuments;
-  private parser;
-  private projects;
-  constructor(services: LikeC4Services);
-  private documents;
-  getParsedElement(...args: [Element] | [c4.Fqn] | [c4.Fqn, c4.ProjectId]): ParsedAstElement | null;
-  locateElement(fqn: c4.Fqn, projectId?: c4.ProjectId | undefined): Location | null;
-  locateDeploymentElement(deploymentFqn: c4.DeploymentFqn, projectId?: c4.ProjectId | undefined): Location | null;
-  locateRelation(relationId: c4.RelationId, projectId?: c4.ProjectId): Location | null;
-  locateViewAst(viewId: c4.ViewId, projectId?: c4.ProjectId | undefined): null | ViewLocateResult;
-  locateView(viewId: c4.ViewId, projectId?: c4.ProjectId): Location | null;
-  locateDocumentTags(documentUri: URI, cancelToken?: CancellationToken$1): Promise<Array<{
-    name: string;
-    color: string;
-    range: Range;
-    isSpecification: boolean;
-  }>>;
-  locateDynamicViewStep(params: {
-    view: c4.ViewId;
-    astPath: string;
-    projectId?: c4.ProjectId | undefined;
-  }): Location | null;
+
+  _byfqn: MultiMap<Fqn$1, AstNodeDescriptionWithFqn>, projectId: ProjectId$1);
+  rootElements(): readonly AstNodeDescriptionWithFqn[];
+  byFqn(fqn: Fqn$1): readonly AstNodeDescriptionWithFqn[];
+  children(parent: Fqn$1): readonly AstNodeDescriptionWithFqn[];
+  descendants(nodeName: Fqn$1): readonly AstNodeDescriptionWithFqn[];
+} //#endregion
+//#region src/model/deployments-index.d.ts
+declare class DeploymentsIndex extends FqnIndex<DeploymentElement> {
+  protected services: LikeC4Services;
+  protected Names: LikeC4NameProvider;
+  protected logger: any;
+  constructor(services: LikeC4Services);
+  protected createDocumentIndex(document: LikeC4LangiumDocument): DocumentFqnIndex;
+} //#endregion
+//#region src/model/builder/MergedSpecification.d.ts
+/**
+ * The `MergedSpecification` class is responsible for merging multiple parsed
+ * LikeC4Langium documents into a single specification. It consolidates tags,
+ * elements, deployments, relationships, and colors from the provided documents
+ * and provides methods to convert parsed models into C4 model elements and relations.
+ */
+declare class MergedSpecification {
+  readonly specs: Omit<ParsedAstSpecification, 'tags'>;
+  readonly tags: Readonly<Record<c4.Tag, c4.TagSpecification>>;
+  readonly globals: c4.ModelGlobals;
+  readonly imports: MultiMap<c4.ProjectId, c4.Fqn, Set<c4.Fqn>>;
+  readonly projectId: c4.ProjectId | undefined;
+  readonly inferTechFromIcon: boolean;
+  constructor(docs: ReadonlyArray<ParsedLikeC4LangiumDocument>, opts?: {
+    inferTechFromIcon?: boolean;
+  });
+  /**
+   * Converts a parsed model into a C4 model element.
+   */
+  toModelElement: ({
+    tags,
+    links,
+    style,
+    id,
+    kind,
+    title,
+    description,
+    technology,
+    summary,
+    metadata
+  }: ParsedAstElement) => c4.Element | null;
+  /**
+   * Converts a parsed model into a C4 model relation.
+   */
+  toModelRelation: ({
+    astPath: _astPath,
+    source,
+    target,
+    kind,
+    links,
+    id,
+    ...model
+  }: ParsedAstRelation) => c4.Relationship | null;
+  /**
+   * Converts a parsed deployment model into a C4 deployment model
+   */
+  toDeploymentElement: (parsed: ParsedAstDeployment) => c4.DeploymentElement | null;
+  /**
+   * Converts a parsed deployment relation into a C4 deployment relation.
+   */
+  toDeploymentRelation: ({
+    astPath: _astPath,
+    source,
+    target,
+    kind,
+    links,
+    id,
+    ...model
+  }: ParsedAstDeploymentRelation) => c4.DeploymentRelationship | null;
+} //#endregion
+//#region src/model/last-seen-artifacts.d.ts
+/**
+ * Provides access to "last seen artifacts" for a given project,
+ * (Results of the last successful parsing)
+ */
+declare class LastSeenArtifacts {
+  #private;
+  constructor(services: LikeC4Services);
+  /**
+   * Cache the last successful merged specification for its project.
+   * @param specification - MergedSpecification to store (by projectId).
+   * @returns The same specification (stores in internal map when projectId is set).
+   */
+  rememberSpecification(specification: MergedSpecification): MergedSpecification;
+  /**
+   * Cache the last successful computed model and its styles for the project.
+   * @param model - LikeC4Model.Computed to store (by projectId).
+   * @returns The same model (stores model and styles in internal maps).
+   */
+  rememberModel<M extends LikeC4Model.Computed>(model: M): M;
+  /**
+   * Returns the last seen merged specification for the given project, if available.
+   * @param projectId - Project id to look up.
+   * @returns MergedSpecification or undefined.
+   */
+  specification(projectId: c4.ProjectId): MergedSpecification | undefined;
+  /**
+   * Returns the last seen styles for the given project, if available.
+   * @param projectId - Project id to look up.
+   * @returns LikeC4Styles or undefined.
+   */
+  styles(projectId: c4.ProjectId): LikeC4Styles$1 | undefined;
+  /**
+   * Returns the last seen computed model for the given project, if available.
+   * @param projectId - Project id to look up.
+   * @returns LikeC4Model.Computed or undefined.
+   */
+  model(projectId: c4.ProjectId): LikeC4Model.Computed | undefined;
+} //#endregion
+//#region src/model/model-builder.d.ts
+type ModelParsedListener = (docs: URI[]) => void;
+interface LikeC4ModelBuilder extends Disposable$1 {
+  parseModel(projectId?: ProjectId | undefined, cancelToken?: CancellationToken$1): Promise<LikeC4Model<UnknownParsed> | null>;
+  unsafeSyncComputeModel(projectId: ProjectId): LikeC4Model<UnknownComputed>;
+  computeModel(projectId?: ProjectId | undefined, cancelToken?: CancellationToken$1): Promise<LikeC4Model<UnknownComputed>>;
+  onModelParsed(callback: ModelParsedListener): Disposable$1;
+  clearCache(): void;
+} //#endregion
+//#region src/model/model-locator.d.ts
+/** Result of locating a view: document, view AST, and view block node. */
+type ViewLocateResult = {
+  doc: ParsedLikeC4LangiumDocument;
+  view: ParsedAstView;
+  viewAst: LikeC4View;
+};
+/**
+ * Locates elements, views, and documents in the LikeC4 model by FQN or AST node.
+ * Used by LSP features (hover, go-to-definition, document tags, etc.).
+ */
+declare class LikeC4ModelLocator {
+  private services;
+  private fqnIndex;
+  private deploymentsIndex;
+  private langiumDocuments;
+  private parser;
+  private projects;
+  constructor(services: LikeC4Services);
+  /**
+   * Returns the parsed documents
+   */
+  private documents;
+  /**
+   * Get parsed element by AST node or by FQN (and optional projectId).
+   * @param args - Either [element AST], [fqn], or [fqn, projectId]
+   * @returns { projectId, element, document } or null if not found
+   */
+  getParsedElement(...args: [Element] | [c4.Fqn] | [c4.Fqn, c4.ProjectId]): null | {
+    projectId: c4.ProjectId;
+    element: ParsedAstElement;
+    document: LangiumDocument;
+  };
+  private findParsedElementByFqnIn;
+  /**
+   * Get LSP Location for an element by FQN (and optional projectId).
+   * @param fqn - Fully qualified name (may include project prefix)
+   * @param projectId - Optional project scope
+   * @returns Location or null
+   */
+  locateElement(fqn: c4.Fqn, projectId?: c4.ProjectId | undefined): Location | null;
+  locateDeploymentElement(deploymentFqn: c4.DeploymentFqn, projectId?: c4.ProjectId | undefined): Location | null;
+  locateRelation(relationId: c4.RelationId, projectId?: c4.ProjectId): Location | null;
+  locateViewAst(viewId: c4.ViewId, projectId?: c4.ProjectId | undefined): null | ViewLocateResult;
+  /**
+   * Get LSP Location for a view by id (and optional projectId).
+   * @param viewId - View id
+   * @param projectId - Optional project scope
+   * @returns Location or null
+   */
+  locateView(viewId: c4.ViewId, projectId?: c4.ProjectId): Location | null;
+  /**
+   * Returns an array of tags with their name, color, range and whether they are defined in the specification or not.
+   * If the document is not linked, it will wait until it is linked before locating the tags.
+   *
+   * If the document does not belong to any project, it will return null.
+   */
+  locateDocumentTags(documentUri: URI, cancelToken?: CancellationToken$1): Promise<null | Array<{
+    name: Tag;
+    color: c4.ColorLiteral;
+    range: Range;
+    isSpecification: boolean;
+  }>>;
+  locateDynamicViewStep(params: {
+    view: c4.ViewId;
+    astPath: string;
+    projectId?: c4.ProjectId | undefined;
+  }): Location | null;
+} //#endregion
+//#region src/mcp/noop.d.ts
+//#endregion
+//#region src/views/LikeC4Views.d.ts
+type GraphvizOut = {
+  readonly dot: string;
+  readonly diagram: LayoutedView;
+};
+type GraphvizSvgOut = {
+  readonly id: ViewId;
+  readonly dot: string;
+  readonly svg: string;
+};
+type LayoutViewParams = {
+  viewId: ViewId;
+  /**
+   * Type of layout to apply
+   * - 'manual' - applies manual layout if any
+   * - 'auto' - returns latest version with drifts from manual layout if any
+   * - undefined - returns latest layout as is
+   */
+  layoutType?: LayoutType | undefined;
+  projectId?: ProjectId | undefined;
+  cancelToken?: CancellationToken$1 | undefined;
+};
+interface LikeC4Views {
+  readonly layouter: GraphvizLayouter;
+  /**
+   * Returns computed views (i.e. views with predicates computed)
+   *
+   * @param projectId - project id, if not specified - uses the default project
+   */
+  computedViews(projectId?: ProjectId | undefined, cancelToken?: CancellationToken$1): Promise<ComputedView[]>;
+  /**
+   * Layouts all views (ignoring any manual snapshots)
+   *
+   * @param projectId - project id, if not specified - uses the default project
+   */
+  layoutAllViews(projectId?: ProjectId | undefined, cancelToken?: CancellationToken$1): Promise<GraphvizOut[]>;
+  /**
+   * Layouts a view.
+   * If layoutType is 'manual' - applies manual layout if any.
+   * If layoutType is 'auto' - returns latest version with drifts from manual layout if any
+   * If not specified - returns latest layout as is
+   *
+   * If view not found in model, but there is a snapshot - it will be returned (with empty DOT)
+   */
+  layoutView(params: LayoutViewParams): Promise<GraphvizOut | null>;
+  /**
+   * Returns diagrams.
+   * If diagram has manual layout, it will be used.
+   * @param projectId - project id, if not specified - uses the default project
+   */
+  diagrams(projectId?: ProjectId | undefined, cancelToken?: CancellationToken$1): Promise<Array<DiagramView>>;
+  /**
+   * Returns all layouted views as Graphviz output (i.e. views with layout computed)
+   * @param projectId - project id, if not specified - uses the default project
+   */
+  viewsAsGraphvizOut(projectId?: ProjectId | undefined, cancelToken?: CancellationToken$1): Promise<Array<GraphvizSvgOut>>;
+  /**
+   * Open view in the preview panel.
+   * (works only if running as a vscode extension)
+   *
+   * @param projectId - project id, if not specified - uses the default project
+   */
+  openView(viewId: ViewId, projectId?: ProjectId | undefined): Promise<void>;
+  /**
+   * Computes and layouts an adhoc view (not defined in the model)
+   *
+   * @param projectId - project id, if not specified - uses the default project
+   */
+  adhocView(predicates: AdhocViewPredicate[], projectId?: ProjectId | undefined): Promise<LayoutedView>;
 } //#endregion
-//#region src/filesystem/LikeC4FileSystem.d.ts
+//#region src/index.d.ts
 //#endregion
 //#region src/model/parser/Base.d.ts
+type ParserLevel = 'base' | 'model' | 'deployment' | 'fqnref' | 'relation' | 'views' | 'globals' | 'imports' | 'specification';
 declare class BaseParser {
   readonly services: LikeC4Services;
   readonly doc: ParsedLikeC4LangiumDocument;
+  readonly project: Project;
   isValid: IsValidFn;
-  constructor(services: LikeC4Services, doc: ParsedLikeC4LangiumDocument);
-  get project(): Project;
+  constructor(services: LikeC4Services, doc: ParsedLikeC4LangiumDocument, project: Project);
+  logError(error: unknown, astNode?: AstNode | Reference<AstNode>, level?: ParserLevel): void;
+  tryParse<N extends AstNode, T>(level: ParserLevel, node: N | undefined, fn: (node: NoInfer<N>) => T | undefined): T | undefined;
+  tryMap<N extends AstNode, T>(level: ParserLevel, iterable: ReadonlyArray<N>, fn: (node: N) => T | undefined): T[];
   resolveFqn(node: FqnReferenceable): c4.Fqn;
   getAstNodePath(node: AstNode): string;
   getMetadata(metadataAstNode: MetadataProperty | undefined): {
@@ -2577,11 +2534,11 @@ declare class BaseParser {
   parseTags<E extends {
     tags?: Tags;
   }>(withTags?: E): c4.NonEmptyArray<c4.Tag> | null;
-  convertLinks(source?: LinkProperty['$container']): c4.Link[] | undefined;
-  parseLinks(source?: LinkProperty['$container']): c4.Link[] | undefined;
+  convertLinks(source?: LinkProperty['$container']): c4.NonEmptyArray<c4.Link> | undefined;
+  parseLinks(source?: LinkProperty['$container']): c4.NonEmptyArray<c4.Link> | undefined;
   parseIconProperty(prop: IconProperty | undefined): c4.IconUrl | undefined;
   parseImageAlias(value: string): string | undefined;
-  parseColorLiteral(astNode: ColorLiteral): c4.ColorLiteral | undefined;
+  parseColorLiteral(astNode: ColorLiteral$1): c4.ColorLiteral | undefined;
   parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
   parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
   /**
@@ -2612,79 +2569,82 @@ declare class BaseParser {
 declare const DocumentParserFromMixins: {
   new (...args: any[]): {
     parseGlobals(): void;
-    parseAndStoreGlobalPredicateGroupOrDynamic(astRule: GlobalPredicateGroup | GlobalDynamicPredicateGroup, id: ProjectId$1, c4Globals: ParsedAstGlobals): void;
-    parseGlobalPredicateGroup(astRule: GlobalPredicateGroup): ProjectId$1[];
-    parseGlobalDynamicPredicateGroup(astRule: GlobalDynamicPredicateGroup): ProjectId$1[];
-    parseGlobalStyleOrGroup(astRule: GlobalStyle | GlobalStyleGroup): ProjectId$1[];
+    parseAndStoreGlobalPredicateGroupOrDynamic(astRule: GlobalPredicateGroup | GlobalDynamicPredicateGroup, id: ProjectId, c4Globals: ParsedAstGlobals): void;
+    parseGlobalPredicateGroup(astRule: GlobalPredicateGroup): ProjectId[];
+    parseGlobalDynamicPredicateGroup(astRule: GlobalDynamicPredicateGroup): ProjectId[];
+    parseGlobalStyleOrGroup(astRule: GlobalStyle | GlobalStyleGroup): ProjectId[];
     parseViews(): void;
     parseElementView(astNode: ElementView, additionalStyles: any[]): ParsedAstElementView;
-    parseElementViewRule(astRule: ViewRule): ProjectId$1;
-    parseViewRulePredicate(astNode: ViewRulePredicate): ProjectId$1;
-    parseViewRuleGlobalPredicateRef(astRule: ViewRuleGlobalPredicateRef | DynamicViewGlobalPredicateRef): ProjectId$1;
+    parseElementViewRule(astRule: ViewRule): ProjectId;
+    parseViewRulePredicate(astNode: ViewRulePredicate): ProjectId;
+    parseViewRuleGlobalPredicateRef(astRule: ViewRuleGlobalPredicateRef | DynamicViewGlobalPredicateRef): ProjectId;
     parseViewRuleStyleOrGlobalRef(astRule: ViewRuleStyleOrGlobalRef): any;
-    parseViewRuleGroup(astNode: ViewRuleGroup): ProjectId$1;
-    parseViewRuleRank(astRule: ViewRuleRank): ProjectId$1;
-    parseViewRuleStyle(astRule: ViewRuleStyle | GlobalStyle): ProjectId$1;
-    parseViewRuleGlobalStyle(astRule: ViewRuleGlobalStyle): ProjectId$1;
+    parseViewRuleGroup(astNode: ViewRuleGroup): ProjectId;
+    parseViewRuleRank(astRule: ViewRuleRank): ProjectId;
+    parseViewRuleStyle(astRule: ViewRuleStyle | GlobalStyle): ProjectId;
+    parseViewRuleGlobalStyle(astRule: ViewRuleGlobalStyle): ProjectId;
     parseDynamicElementView(astNode: DynamicView, additionalStyles: any[]): ParsedAstDynamicView;
-    parseDynamicViewRule(astRule: DynamicViewRule): ProjectId$1;
-    parseDynamicViewIncludePredicate(astRule: DynamicViewIncludePredicate): ProjectId$1;
-    parseDynamicParallelSteps(node: DynamicViewParallelSteps): ProjectId$1;
-    parseDynamicStep(node: DynamicViewStep): ProjectId$1 | ProjectId$1;
-    recursiveParseDynamicStepChain(node: DynamicStepChain, callstack?: Array<[source: ProjectId$1, target: ProjectId$1]>): ProjectId$1[];
-    parseDynamicStepSingle(node: DynamicStepSingle): ProjectId$1;
-    parseAbstractDynamicStep(astnode: AbstractDynamicStep): type_fest0.Writable<type_fest0.Except<ProjectId$1, "source", {
+    parseDynamicViewRule(astRule: DynamicViewRule): ProjectId;
+    parseDynamicViewIncludePredicate(astRule: DynamicViewIncludePredicate): ProjectId;
+    parseDynamicParallelSteps(node: DynamicViewParallelSteps): ProjectId;
+    parseDynamicStep(node: DynamicViewStep): ProjectId | ProjectId;
+    recursiveParseDynamicStepChain(node: DynamicStepChain, callstack?: Array<[source: ProjectId, target: ProjectId]>): ProjectId[];
+    parseDynamicStepSingle(node: DynamicStepSingle): ProjectId;
+    parseAbstractDynamicStep(astnode: AbstractDynamicStep): type_fest0.Writable<type_fest0.Except<ProjectId, "source", {
       requireExactProps: true;
     }>>;
-    parsePredicate(astNode: ExpressionV2): ProjectId$1;
-    parseElementPredicate(astNode: FqnExprOrWith): ProjectId$1;
-    parseElementPredicateOrWhere(astNode: FqnExprOrWhere): ProjectId$1;
-    parseElementExpression(astNode: FqnExpr$2): ProjectId$1;
-    parseElementPredicateWhere(astNode: FqnExprWhere): ProjectId$1;
-    parseElementPredicateWith(astNode: FqnExprWith): ProjectId$1;
-    parseRelationPredicate(astNode: RelationExprOrWith): ProjectId$1;
-    parseRelationPredicateOrWhere(astNode: RelationExprOrWhere): ProjectId$1;
-    parseRelationPredicateWhere(astNode: RelationExprWhere): ProjectId$1;
-    parseRelationPredicateWith(astNode: RelationExprWith): ProjectId$1;
-    parseRelationExpression(astNode: RelationExpr$1): ProjectId$1;
-    parseFqnRef(astNode: FqnRef$2): ProjectId$1;
-    parseExpressionV2(astNode: ExpressionV2): ProjectId$1;
-    parseFqnExprOrWith(astNode: FqnExprOrWith): ProjectId$1;
-    parseFqnExprWith(astNode: FqnExprWith): ProjectId$1;
-    parseFqnExprOrWhere(astNode: FqnExprOrWhere): ProjectId$1;
-    parseFqnExprWhere(astNode: FqnExprWhere): ProjectId$1;
-    parseFqnExpr(astNode: FqnExpr$2): ProjectId$1;
-    parseFqnRefExpr(astNode: FqnRefExpr): ProjectId$1;
-    parseFqnExpressions(astNode: FqnExpressions): ProjectId$1[];
-    parseRelationExprOrWith(astNode: RelationExprOrWith): ProjectId$1;
-    parseRelationExprWith(astNode: RelationExprWith): ProjectId$1;
-    parseCustomRelationProperties(custom: CustomRelationProperties | undefined): type_fest0.Except<ProjectId$1["customRelation"], "expr">;
-    parseRelationExprOrWhere(astNode: RelationExprOrWhere): ProjectId$1;
-    parseRelationExprWhere(astNode: RelationExprWhere): ProjectId$1;
-    parseRelationExpr(astNode: RelationExpr$1): ProjectId$1;
-    parseInlineKindCondition(astNode: OutgoingRelationExpr): ProjectId$1 | null;
-    wrapInWhere(expr: ProjectId$1, condition: ProjectId$1 | null): ProjectId$1;
+    parsePredicate(astNode: ExpressionV2): ProjectId;
+    parseElementPredicate(astNode: FqnExprOrWith): ProjectId;
+    parseElementPredicateOrWhere(astNode: FqnExprOrWhere): ProjectId;
+    parseElementExpression(astNode: FqnExpr$2): ProjectId;
+    parseElementPredicateWhere(astNode: FqnExprWhere): ProjectId;
+    parseElementPredicateWith(astNode: FqnExprWith): ProjectId;
+    parseRelationPredicate(astNode: RelationExprOrWith): ProjectId;
+    parseRelationPredicateOrWhere(astNode: RelationExprOrWhere): ProjectId;
+    parseRelationPredicateWhere(astNode: RelationExprWhere): ProjectId;
+    parseRelationPredicateWith(astNode: RelationExprWith): ProjectId;
+    parseRelationExpression(astNode: RelationExpr$1): ProjectId;
+    parseFqnRef(astNode: FqnRef$2): ProjectId;
+    parseExpressionV2(astNode: ExpressionV2): ProjectId;
+    parseFqnExprOrWith(astNode: FqnExprOrWith): ProjectId;
+    parseFqnExprWith(astNode: FqnExprWith): ProjectId;
+    parseFqnExprOrWhere(astNode: FqnExprOrWhere): ProjectId;
+    parseFqnExprWhere(astNode: FqnExprWhere): ProjectId;
+    parseFqnExpr(astNode: FqnExpr$2): ProjectId;
+    parseFqnRefExpr(astNode: FqnRefExpr): ProjectId;
+    parseFqnExpressions(astNode: FqnExpressions): ProjectId[];
+    parseRelationExprOrWith(astNode: RelationExprOrWith): ProjectId;
+    parseRelationExprWith(astNode: RelationExprWith): ProjectId;
+    parseCustomRelationProperties(custom: CustomRelationProperties | undefined): type_fest0.Except<ProjectId["customRelation"], "expr">;
+    parseRelationExprOrWhere(astNode: RelationExprOrWhere): ProjectId;
+    parseRelationExprWhere(astNode: RelationExprWhere): ProjectId;
+    parseRelationExpr(astNode: RelationExpr$1): ProjectId;
+    parseInlineKindCondition(astNode: OutgoingRelationExpr): ProjectId | null;
+    wrapInWhere(expr: ProjectId, condition: ProjectId | null): ProjectId;
     isValid: IsValidFn;
     readonly services: LikeC4Services;
     readonly doc: ParsedLikeC4LangiumDocument;
-    get project(): Project;
-    resolveFqn(node: FqnReferenceable): ProjectId$1;
+    readonly project: Project;
+    logError(error: unknown, astNode?: AstNode | Reference<AstNode>, level?: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification"): void;
+    tryParse<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", node: N | undefined, fn: (node: NoInfer<N>) => T | undefined): T | undefined;
+    tryMap<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", iterable: ReadonlyArray<N>, fn: (node: N) => T | undefined): T[];
+    resolveFqn(node: FqnReferenceable): ProjectId;
     getAstNodePath(node: AstNode): string;
     getMetadata(metadataAstNode: MetadataProperty | undefined): {
       [key: string]: string | string[];
     } | undefined;
-    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId$1 | undefined;
+    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId | undefined;
     convertTags<E extends {
       tags?: Tags;
     }>(withTags?: E | undefined): any;
     parseTags<E extends {
       tags?: Tags;
-    }>(withTags?: E): ProjectId$1<ProjectId$1> | null;
-    convertLinks(source?: LinkProperty["$container"]): ProjectId$1[] | undefined;
-    parseLinks(source?: LinkProperty["$container"]): ProjectId$1[] | undefined;
-    parseIconProperty(prop: IconProperty | undefined): ProjectId$1 | undefined;
+    }>(withTags?: E): ProjectId<ProjectId> | null;
+    convertLinks(source?: LinkProperty["$container"]): ProjectId<ProjectId> | undefined;
+    parseLinks(source?: LinkProperty["$container"]): ProjectId<ProjectId> | undefined;
+    parseIconProperty(prop: IconProperty | undefined): ProjectId | undefined;
     parseImageAlias(value: string): string | undefined;
-    parseColorLiteral(astNode: ColorLiteral): ProjectId$1 | undefined;
+    parseColorLiteral(astNode: ColorLiteral$1): ProjectId | undefined;
     parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
     parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
     parseBaseProps(props: {
@@ -2699,92 +2659,95 @@ declare const DocumentParserFromMixins: {
       technology?: string | undefined;
     }): {
       title?: string;
-      summary?: ProjectId$1;
-      description?: ProjectId$1;
+      summary?: ProjectId;
+      description?: ProjectId;
       technology?: string;
     };
     parseDeploymentView(astNode: DeploymentView): ParsedAstDeploymentView;
-    parseDeploymentViewRule(astRule: DeploymentViewRule): ProjectId$1;
-    parseDeploymentViewRulePredicate(astRule: DeploymentViewRulePredicate): ProjectId$1;
-    parseDeploymentViewRuleStyle(astRule: DeploymentViewRuleStyle): ProjectId$1;
+    parseDeploymentViewRule(astRule: DeploymentViewRule): ProjectId;
+    parseDeploymentViewRulePredicate(astRule: DeploymentViewRulePredicate): ProjectId;
+    parseDeploymentViewRuleStyle(astRule: DeploymentViewRuleStyle): ProjectId;
     parseDeployment(): void;
     parseDeploymentNode(astNode: DeploymentNode): ParsedAstDeployment.Node;
     parseDeployedInstance(astNode: DeployedInstance): ParsedAstDeployment.Instance;
     parseExtendDeployment(astNode: ExtendDeployment): ParsedAstExtend | null;
-    _resolveDeploymentRelationSource(node: DeploymentRelation): ProjectId$1;
+    _resolveDeploymentRelationSource(node: DeploymentRelation): ProjectId;
     parseDeploymentRelation(astNode: DeploymentRelation): ParsedAstDeploymentRelation;
   };
 } & {
   new (...args: any[]): {
     parseViews(): void;
     parseElementView(astNode: ElementView, additionalStyles: any[]): ParsedAstElementView;
-    parseElementViewRule(astRule: ViewRule): ProjectId$1;
-    parseViewRulePredicate(astNode: ViewRulePredicate): ProjectId$1;
-    parseViewRuleGlobalPredicateRef(astRule: ViewRuleGlobalPredicateRef | DynamicViewGlobalPredicateRef): ProjectId$1;
+    parseElementViewRule(astRule: ViewRule): ProjectId;
+    parseViewRulePredicate(astNode: ViewRulePredicate): ProjectId;
+    parseViewRuleGlobalPredicateRef(astRule: ViewRuleGlobalPredicateRef | DynamicViewGlobalPredicateRef): ProjectId;
     parseViewRuleStyleOrGlobalRef(astRule: ViewRuleStyleOrGlobalRef): any;
-    parseViewRuleGroup(astNode: ViewRuleGroup): ProjectId$1;
-    parseViewRuleRank(astRule: ViewRuleRank): ProjectId$1;
-    parseViewRuleStyle(astRule: ViewRuleStyle | GlobalStyle): ProjectId$1;
-    parseViewRuleGlobalStyle(astRule: ViewRuleGlobalStyle): ProjectId$1;
+    parseViewRuleGroup(astNode: ViewRuleGroup): ProjectId;
+    parseViewRuleRank(astRule: ViewRuleRank): ProjectId;
+    parseViewRuleStyle(astRule: ViewRuleStyle | GlobalStyle): ProjectId;
+    parseViewRuleGlobalStyle(astRule: ViewRuleGlobalStyle): ProjectId;
     parseDynamicElementView(astNode: DynamicView, additionalStyles: any[]): ParsedAstDynamicView;
-    parseDynamicViewRule(astRule: DynamicViewRule): ProjectId$1;
-    parseDynamicViewIncludePredicate(astRule: DynamicViewIncludePredicate): ProjectId$1;
-    parseDynamicParallelSteps(node: DynamicViewParallelSteps): ProjectId$1;
-    parseDynamicStep(node: DynamicViewStep): ProjectId$1 | ProjectId$1;
-    recursiveParseDynamicStepChain(node: DynamicStepChain, callstack?: Array<[source: ProjectId$1, target: ProjectId$1]>): ProjectId$1[];
-    parseDynamicStepSingle(node: DynamicStepSingle): ProjectId$1;
-    parseAbstractDynamicStep(astnode: AbstractDynamicStep): type_fest0.Writable<type_fest0.Except<ProjectId$1, "source", {
+    parseDynamicViewRule(astRule: DynamicViewRule): ProjectId;
+    parseDynamicViewIncludePredicate(astRule: DynamicViewIncludePredicate): ProjectId;
+    parseDynamicParallelSteps(node: DynamicViewParallelSteps): ProjectId;
+    parseDynamicStep(node: DynamicViewStep): ProjectId | ProjectId;
+    recursiveParseDynamicStepChain(node: DynamicStepChain, callstack?: Array<[source: ProjectId, target: ProjectId]>): ProjectId[];
+    parseDynamicStepSingle(node: DynamicStepSingle): ProjectId;
+    parseAbstractDynamicStep(astnode: AbstractDynamicStep): type_fest0.Writable<type_fest0.Except<ProjectId, "source", {
       requireExactProps: true;
     }>>;
-    parsePredicate(astNode: ExpressionV2): ProjectId$1;
-    parseElementPredicate(astNode: FqnExprOrWith): ProjectId$1;
-    parseElementPredicateOrWhere(astNode: FqnExprOrWhere): ProjectId$1;
-    parseElementExpression(astNode: FqnExpr$2): ProjectId$1;
-    parseElementPredicateWhere(astNode: FqnExprWhere): ProjectId$1;
-    parseElementPredicateWith(astNode: FqnExprWith): ProjectId$1;
-    parseRelationPredicate(astNode: RelationExprOrWith): ProjectId$1;
-    parseRelationPredicateOrWhere(astNode: RelationExprOrWhere): ProjectId$1;
-    parseRelationPredicateWhere(astNode: RelationExprWhere): ProjectId$1;
-    parseRelationPredicateWith(astNode: RelationExprWith): ProjectId$1;
-    parseRelationExpression(astNode: RelationExpr$1): ProjectId$1;
-    parseFqnRef(astNode: FqnRef$2): ProjectId$1;
-    parseExpressionV2(astNode: ExpressionV2): ProjectId$1;
-    parseFqnExprOrWith(astNode: FqnExprOrWith): ProjectId$1;
-    parseFqnExprWith(astNode: FqnExprWith): ProjectId$1;
-    parseFqnExprOrWhere(astNode: FqnExprOrWhere): ProjectId$1;
-    parseFqnExprWhere(astNode: FqnExprWhere): ProjectId$1;
-    parseFqnExpr(astNode: FqnExpr$2): ProjectId$1;
-    parseFqnRefExpr(astNode: FqnRefExpr): ProjectId$1;
-    parseFqnExpressions(astNode: FqnExpressions): ProjectId$1[];
-    parseRelationExprOrWith(astNode: RelationExprOrWith): ProjectId$1;
-    parseRelationExprWith(astNode: RelationExprWith): ProjectId$1;
-    parseCustomRelationProperties(custom: CustomRelationProperties | undefined): type_fest0.Except<ProjectId$1["customRelation"], "expr">;
-    parseRelationExprOrWhere(astNode: RelationExprOrWhere): ProjectId$1;
-    parseRelationExprWhere(astNode: RelationExprWhere): ProjectId$1;
-    parseRelationExpr(astNode: RelationExpr$1): ProjectId$1;
-    parseInlineKindCondition(astNode: OutgoingRelationExpr): ProjectId$1 | null;
-    wrapInWhere(expr: ProjectId$1, condition: ProjectId$1 | null): ProjectId$1;
+    parsePredicate(astNode: ExpressionV2): ProjectId;
+    parseElementPredicate(astNode: FqnExprOrWith): ProjectId;
+    parseElementPredicateOrWhere(astNode: FqnExprOrWhere): ProjectId;
+    parseElementExpression(astNode: FqnExpr$2): ProjectId;
+    parseElementPredicateWhere(astNode: FqnExprWhere): ProjectId;
+    parseElementPredicateWith(astNode: FqnExprWith): ProjectId;
+    parseRelationPredicate(astNode: RelationExprOrWith): ProjectId;
+    parseRelationPredicateOrWhere(astNode: RelationExprOrWhere): ProjectId;
+    parseRelationPredicateWhere(astNode: RelationExprWhere): ProjectId;
+    parseRelationPredicateWith(astNode: RelationExprWith): ProjectId;
+    parseRelationExpression(astNode: RelationExpr$1): ProjectId;
+    parseFqnRef(astNode: FqnRef$2): ProjectId;
+    parseExpressionV2(astNode: ExpressionV2): ProjectId;
+    parseFqnExprOrWith(astNode: FqnExprOrWith): ProjectId;
+    parseFqnExprWith(astNode: FqnExprWith): ProjectId;
+    parseFqnExprOrWhere(astNode: FqnExprOrWhere): ProjectId;
+    parseFqnExprWhere(astNode: FqnExprWhere): ProjectId;
+    parseFqnExpr(astNode: FqnExpr$2): ProjectId;
+    parseFqnRefExpr(astNode: FqnRefExpr): ProjectId;
+    parseFqnExpressions(astNode: FqnExpressions): ProjectId[];
+    parseRelationExprOrWith(astNode: RelationExprOrWith): ProjectId;
+    parseRelationExprWith(astNode: RelationExprWith): ProjectId;
+    parseCustomRelationProperties(custom: CustomRelationProperties | undefined): type_fest0.Except<ProjectId["customRelation"], "expr">;
+    parseRelationExprOrWhere(astNode: RelationExprOrWhere): ProjectId;
+    parseRelationExprWhere(astNode: RelationExprWhere): ProjectId;
+    parseRelationExpr(astNode: RelationExpr$1): ProjectId;
+    parseInlineKindCondition(astNode: OutgoingRelationExpr): ProjectId | null;
+    wrapInWhere(expr: ProjectId, condition: ProjectId | null): ProjectId;
     isValid: IsValidFn;
     readonly services: LikeC4Services;
     readonly doc: ParsedLikeC4LangiumDocument;
-    get project(): Project;
-    resolveFqn(node: FqnReferenceable): ProjectId$1;
+    readonly project: Project;
+    logError(error: unknown, astNode?: AstNode | Reference<AstNode>, level?: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification"): void;
+    tryParse<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", node: N | undefined, fn: (node: NoInfer<N>) => T | undefined): T | undefined;
+    tryMap<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", iterable: ReadonlyArray<N>, fn: (node: N) => T | undefined): T[];
+    resolveFqn(node: FqnReferenceable): ProjectId;
     getAstNodePath(node: AstNode): string;
     getMetadata(metadataAstNode: MetadataProperty | undefined): {
       [key: string]: string | string[];
     } | undefined;
-    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId$1 | undefined;
+    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId | undefined;
     convertTags<E extends {
       tags?: Tags;
     }>(withTags?: E | undefined): any;
     parseTags<E extends {
       tags?: Tags;
-    }>(withTags?: E): ProjectId$1<ProjectId$1> | null;
-    convertLinks(source?: LinkProperty["$container"]): ProjectId$1[] | undefined;
-    parseLinks(source?: LinkProperty["$container"]): ProjectId$1[] | undefined;
-    parseIconProperty(prop: IconProperty | undefined): ProjectId$1 | undefined;
+    }>(withTags?: E): ProjectId<ProjectId> | null;
+    convertLinks(source?: LinkProperty["$container"]): ProjectId<ProjectId> | undefined;
+    parseLinks(source?: LinkProperty["$container"]): ProjectId<ProjectId> | undefined;
+    parseIconProperty(prop: IconProperty | undefined): ProjectId | undefined;
     parseImageAlias(value: string): string | undefined;
-    parseColorLiteral(astNode: ColorLiteral): ProjectId$1 | undefined;
+    parseColorLiteral(astNode: ColorLiteral$1): ProjectId | undefined;
     parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
     parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
     parseBaseProps(props: {
@@ -2799,19 +2762,19 @@ declare const DocumentParserFromMixins: {
       technology?: string | undefined;
     }): {
       title?: string;
-      summary?: ProjectId$1;
-      description?: ProjectId$1;
+      summary?: ProjectId;
+      description?: ProjectId;
       technology?: string;
     };
     parseDeploymentView(astNode: DeploymentView): ParsedAstDeploymentView;
-    parseDeploymentViewRule(astRule: DeploymentViewRule): ProjectId$1;
-    parseDeploymentViewRulePredicate(astRule: DeploymentViewRulePredicate): ProjectId$1;
-    parseDeploymentViewRuleStyle(astRule: DeploymentViewRuleStyle): ProjectId$1;
+    parseDeploymentViewRule(astRule: DeploymentViewRule): ProjectId;
+    parseDeploymentViewRulePredicate(astRule: DeploymentViewRulePredicate): ProjectId;
+    parseDeploymentViewRuleStyle(astRule: DeploymentViewRuleStyle): ProjectId;
     parseDeployment(): void;
     parseDeploymentNode(astNode: DeploymentNode): ParsedAstDeployment.Node;
     parseDeployedInstance(astNode: DeployedInstance): ParsedAstDeployment.Instance;
     parseExtendDeployment(astNode: ExtendDeployment): ParsedAstExtend | null;
-    _resolveDeploymentRelationSource(node: DeploymentRelation): ProjectId$1;
+    _resolveDeploymentRelationSource(node: DeploymentRelation): ProjectId;
     parseDeploymentRelation(astNode: DeploymentRelation): ParsedAstDeploymentRelation;
   };
 } & {
@@ -2822,24 +2785,27 @@ declare const DocumentParserFromMixins: {
     isValid: IsValidFn;
     readonly services: LikeC4Services;
     readonly doc: ParsedLikeC4LangiumDocument;
-    get project(): Project;
-    resolveFqn(node: FqnReferenceable): ProjectId$1;
+    readonly project: Project;
+    logError(error: unknown, astNode?: AstNode | Reference<AstNode>, level?: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification"): void;
+    tryParse<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", node: N | undefined, fn: (node: NoInfer<N>) => T | undefined): T | undefined;
+    tryMap<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", iterable: ReadonlyArray<N>, fn: (node: N) => T | undefined): T[];
+    resolveFqn(node: FqnReferenceable): ProjectId;
     getAstNodePath(node: AstNode): string;
     getMetadata(metadataAstNode: MetadataProperty | undefined): {
       [key: string]: string | string[];
     } | undefined;
-    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId$1 | undefined;
+    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId | undefined;
     convertTags<E extends {
       tags?: Tags;
     }>(withTags?: E | undefined): any;
     parseTags<E extends {
       tags?: Tags;
-    }>(withTags?: E): ProjectId$1<ProjectId$1> | null;
-    convertLinks(source?: LinkProperty["$container"]): ProjectId$1[] | undefined;
-    parseLinks(source?: LinkProperty["$container"]): ProjectId$1[] | undefined;
-    parseIconProperty(prop: IconProperty | undefined): ProjectId$1 | undefined;
+    }>(withTags?: E): ProjectId<ProjectId> | null;
+    convertLinks(source?: LinkProperty["$container"]): ProjectId<ProjectId> | undefined;
+    parseLinks(source?: LinkProperty["$container"]): ProjectId<ProjectId> | undefined;
+    parseIconProperty(prop: IconProperty | undefined): ProjectId | undefined;
     parseImageAlias(value: string): string | undefined;
-    parseColorLiteral(astNode: ColorLiteral): ProjectId$1 | undefined;
+    parseColorLiteral(astNode: ColorLiteral$1): ProjectId | undefined;
     parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
     parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
     parseBaseProps(props: {
@@ -2854,62 +2820,65 @@ declare const DocumentParserFromMixins: {
       technology?: string | undefined;
     }): {
       title?: string;
-      summary?: ProjectId$1;
-      description?: ProjectId$1;
+      summary?: ProjectId;
+      description?: ProjectId;
       technology?: string;
     };
   };
 } & {
   new (...args: any[]): {
-    parsePredicate(astNode: ExpressionV2): ProjectId$1;
-    parseElementPredicate(astNode: FqnExprOrWith): ProjectId$1;
-    parseElementPredicateOrWhere(astNode: FqnExprOrWhere): ProjectId$1;
-    parseElementExpression(astNode: FqnExpr$2): ProjectId$1;
-    parseElementPredicateWhere(astNode: FqnExprWhere): ProjectId$1;
-    parseElementPredicateWith(astNode: FqnExprWith): ProjectId$1;
-    parseRelationPredicate(astNode: RelationExprOrWith): ProjectId$1;
-    parseRelationPredicateOrWhere(astNode: RelationExprOrWhere): ProjectId$1;
-    parseRelationPredicateWhere(astNode: RelationExprWhere): ProjectId$1;
-    parseRelationPredicateWith(astNode: RelationExprWith): ProjectId$1;
-    parseRelationExpression(astNode: RelationExpr$1): ProjectId$1;
-    parseFqnRef(astNode: FqnRef$2): ProjectId$1;
-    parseExpressionV2(astNode: ExpressionV2): ProjectId$1;
-    parseFqnExprOrWith(astNode: FqnExprOrWith): ProjectId$1;
-    parseFqnExprWith(astNode: FqnExprWith): ProjectId$1;
-    parseFqnExprOrWhere(astNode: FqnExprOrWhere): ProjectId$1;
-    parseFqnExprWhere(astNode: FqnExprWhere): ProjectId$1;
-    parseFqnExpr(astNode: FqnExpr$2): ProjectId$1;
-    parseFqnRefExpr(astNode: FqnRefExpr): ProjectId$1;
-    parseFqnExpressions(astNode: FqnExpressions): ProjectId$1[];
-    parseRelationExprOrWith(astNode: RelationExprOrWith): ProjectId$1;
-    parseRelationExprWith(astNode: RelationExprWith): ProjectId$1;
-    parseCustomRelationProperties(custom: CustomRelationProperties | undefined): type_fest0.Except<ProjectId$1["customRelation"], "expr">;
-    parseRelationExprOrWhere(astNode: RelationExprOrWhere): ProjectId$1;
-    parseRelationExprWhere(astNode: RelationExprWhere): ProjectId$1;
-    parseRelationExpr(astNode: RelationExpr$1): ProjectId$1;
-    parseInlineKindCondition(astNode: OutgoingRelationExpr): ProjectId$1 | null;
-    wrapInWhere(expr: ProjectId$1, condition: ProjectId$1 | null): ProjectId$1;
+    parsePredicate(astNode: ExpressionV2): ProjectId;
+    parseElementPredicate(astNode: FqnExprOrWith): ProjectId;
+    parseElementPredicateOrWhere(astNode: FqnExprOrWhere): ProjectId;
+    parseElementExpression(astNode: FqnExpr$2): ProjectId;
+    parseElementPredicateWhere(astNode: FqnExprWhere): ProjectId;
+    parseElementPredicateWith(astNode: FqnExprWith): ProjectId;
+    parseRelationPredicate(astNode: RelationExprOrWith): ProjectId;
+    parseRelationPredicateOrWhere(astNode: RelationExprOrWhere): ProjectId;
+    parseRelationPredicateWhere(astNode: RelationExprWhere): ProjectId;
+    parseRelationPredicateWith(astNode: RelationExprWith): ProjectId;
+    parseRelationExpression(astNode: RelationExpr$1): ProjectId;
+    parseFqnRef(astNode: FqnRef$2): ProjectId;
+    parseExpressionV2(astNode: ExpressionV2): ProjectId;
+    parseFqnExprOrWith(astNode: FqnExprOrWith): ProjectId;
+    parseFqnExprWith(astNode: FqnExprWith): ProjectId;
+    parseFqnExprOrWhere(astNode: FqnExprOrWhere): ProjectId;
+    parseFqnExprWhere(astNode: FqnExprWhere): ProjectId;
+    parseFqnExpr(astNode: FqnExpr$2): ProjectId;
+    parseFqnRefExpr(astNode: FqnRefExpr): ProjectId;
+    parseFqnExpressions(astNode: FqnExpressions): ProjectId[];
+    parseRelationExprOrWith(astNode: RelationExprOrWith): ProjectId;
+    parseRelationExprWith(astNode: RelationExprWith): ProjectId;
+    parseCustomRelationProperties(custom: CustomRelationProperties | undefined): type_fest0.Except<ProjectId["customRelation"], "expr">;
+    parseRelationExprOrWhere(astNode: RelationExprOrWhere): ProjectId;
+    parseRelationExprWhere(astNode: RelationExprWhere): ProjectId;
+    parseRelationExpr(astNode: RelationExpr$1): ProjectId;
+    parseInlineKindCondition(astNode: OutgoingRelationExpr): ProjectId | null;
+    wrapInWhere(expr: ProjectId, condition: ProjectId | null): ProjectId;
     isValid: IsValidFn;
     readonly services: LikeC4Services;
     readonly doc: ParsedLikeC4LangiumDocument;
-    get project(): Project;
-    resolveFqn(node: FqnReferenceable): ProjectId$1;
+    readonly project: Project;
+    logError(error: unknown, astNode?: AstNode | Reference<AstNode>, level?: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification"): void;
+    tryParse<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", node: N | undefined, fn: (node: NoInfer<N>) => T | undefined): T | undefined;
+    tryMap<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", iterable: ReadonlyArray<N>, fn: (node: N) => T | undefined): T[];
+    resolveFqn(node: FqnReferenceable): ProjectId;
     getAstNodePath(node: AstNode): string;
     getMetadata(metadataAstNode: MetadataProperty | undefined): {
       [key: string]: string | string[];
     } | undefined;
-    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId$1 | undefined;
+    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId | undefined;
     convertTags<E extends {
       tags?: Tags;
     }>(withTags?: E | undefined): any;
     parseTags<E extends {
       tags?: Tags;
-    }>(withTags?: E): ProjectId$1<ProjectId$1> | null;
-    convertLinks(source?: LinkProperty["$container"]): ProjectId$1[] | undefined;
-    parseLinks(source?: LinkProperty["$container"]): ProjectId$1[] | undefined;
-    parseIconProperty(prop: IconProperty | undefined): ProjectId$1 | undefined;
+    }>(withTags?: E): ProjectId<ProjectId> | null;
+    convertLinks(source?: LinkProperty["$container"]): ProjectId<ProjectId> | undefined;
+    parseLinks(source?: LinkProperty["$container"]): ProjectId<ProjectId> | undefined;
+    parseIconProperty(prop: IconProperty | undefined): ProjectId | undefined;
     parseImageAlias(value: string): string | undefined;
-    parseColorLiteral(astNode: ColorLiteral): ProjectId$1 | undefined;
+    parseColorLiteral(astNode: ColorLiteral$1): ProjectId | undefined;
     parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
     parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
     parseBaseProps(props: {
@@ -2924,55 +2893,58 @@ declare const DocumentParserFromMixins: {
       technology?: string | undefined;
     }): {
       title?: string;
-      summary?: ProjectId$1;
-      description?: ProjectId$1;
+      summary?: ProjectId;
+      description?: ProjectId;
       technology?: string;
     };
   };
 } & {
   new (...args: any[]): {
     parseDeploymentView(astNode: DeploymentView): ParsedAstDeploymentView;
-    parseDeploymentViewRule(astRule: DeploymentViewRule): ProjectId$1;
-    parseDeploymentViewRulePredicate(astRule: DeploymentViewRulePredicate): ProjectId$1;
-    parseDeploymentViewRuleStyle(astRule: DeploymentViewRuleStyle): ProjectId$1;
-    parseFqnRef(astNode: FqnRef$2): ProjectId$1;
-    parseExpressionV2(astNode: ExpressionV2): ProjectId$1;
-    parseFqnExprOrWith(astNode: FqnExprOrWith): ProjectId$1;
-    parseFqnExprWith(astNode: FqnExprWith): ProjectId$1;
-    parseFqnExprOrWhere(astNode: FqnExprOrWhere): ProjectId$1;
-    parseFqnExprWhere(astNode: FqnExprWhere): ProjectId$1;
-    parseFqnExpr(astNode: FqnExpr$2): ProjectId$1;
-    parseFqnRefExpr(astNode: FqnRefExpr): ProjectId$1;
-    parseFqnExpressions(astNode: FqnExpressions): ProjectId$1[];
-    parseRelationExprOrWith(astNode: RelationExprOrWith): ProjectId$1;
-    parseRelationExprWith(astNode: RelationExprWith): ProjectId$1;
-    parseCustomRelationProperties(custom: CustomRelationProperties | undefined): type_fest0.Except<ProjectId$1["customRelation"], "expr">;
-    parseRelationExprOrWhere(astNode: RelationExprOrWhere): ProjectId$1;
-    parseRelationExprWhere(astNode: RelationExprWhere): ProjectId$1;
-    parseRelationExpr(astNode: RelationExpr$1): ProjectId$1;
-    parseInlineKindCondition(astNode: OutgoingRelationExpr): ProjectId$1 | null;
-    wrapInWhere(expr: ProjectId$1, condition: ProjectId$1 | null): ProjectId$1;
+    parseDeploymentViewRule(astRule: DeploymentViewRule): ProjectId;
+    parseDeploymentViewRulePredicate(astRule: DeploymentViewRulePredicate): ProjectId;
+    parseDeploymentViewRuleStyle(astRule: DeploymentViewRuleStyle): ProjectId;
+    parseFqnRef(astNode: FqnRef$2): ProjectId;
+    parseExpressionV2(astNode: ExpressionV2): ProjectId;
+    parseFqnExprOrWith(astNode: FqnExprOrWith): ProjectId;
+    parseFqnExprWith(astNode: FqnExprWith): ProjectId;
+    parseFqnExprOrWhere(astNode: FqnExprOrWhere): ProjectId;
+    parseFqnExprWhere(astNode: FqnExprWhere): ProjectId;
+    parseFqnExpr(astNode: FqnExpr$2): ProjectId;
+    parseFqnRefExpr(astNode: FqnRefExpr): ProjectId;
+    parseFqnExpressions(astNode: FqnExpressions): ProjectId[];
+    parseRelationExprOrWith(astNode: RelationExprOrWith): ProjectId;
+    parseRelationExprWith(astNode: RelationExprWith): ProjectId;
+    parseCustomRelationProperties(custom: CustomRelationProperties | undefined): type_fest0.Except<ProjectId["customRelation"], "expr">;
+    parseRelationExprOrWhere(astNode: RelationExprOrWhere): ProjectId;
+    parseRelationExprWhere(astNode: RelationExprWhere): ProjectId;
+    parseRelationExpr(astNode: RelationExpr$1): ProjectId;
+    parseInlineKindCondition(astNode: OutgoingRelationExpr): ProjectId | null;
+    wrapInWhere(expr: ProjectId, condition: ProjectId | null): ProjectId;
     isValid: IsValidFn;
     readonly services: LikeC4Services;
     readonly doc: ParsedLikeC4LangiumDocument;
-    get project(): Project;
-    resolveFqn(node: FqnReferenceable): ProjectId$1;
+    readonly project: Project;
+    logError(error: unknown, astNode?: AstNode | Reference<AstNode>, level?: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification"): void;
+    tryParse<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", node: N | undefined, fn: (node: NoInfer<N>) => T | undefined): T | undefined;
+    tryMap<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", iterable: ReadonlyArray<N>, fn: (node: N) => T | undefined): T[];
+    resolveFqn(node: FqnReferenceable): ProjectId;
     getAstNodePath(node: AstNode): string;
     getMetadata(metadataAstNode: MetadataProperty | undefined): {
       [key: string]: string | string[];
     } | undefined;
-    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId$1 | undefined;
+    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId | undefined;
     convertTags<E extends {
       tags?: Tags;
     }>(withTags?: E | undefined): any;
     parseTags<E extends {
       tags?: Tags;
-    }>(withTags?: E): ProjectId$1<ProjectId$1> | null;
-    convertLinks(source?: LinkProperty["$container"]): ProjectId$1[] | undefined;
-    parseLinks(source?: LinkProperty["$container"]): ProjectId$1[] | undefined;
-    parseIconProperty(prop: IconProperty | undefined): ProjectId$1 | undefined;
+    }>(withTags?: E): ProjectId<ProjectId> | null;
+    convertLinks(source?: LinkProperty["$container"]): ProjectId<ProjectId> | undefined;
+    parseLinks(source?: LinkProperty["$container"]): ProjectId<ProjectId> | undefined;
+    parseIconProperty(prop: IconProperty | undefined): ProjectId | undefined;
     parseImageAlias(value: string): string | undefined;
-    parseColorLiteral(astNode: ColorLiteral): ProjectId$1 | undefined;
+    parseColorLiteral(astNode: ColorLiteral$1): ProjectId | undefined;
     parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
     parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
     parseBaseProps(props: {
@@ -2987,15 +2959,15 @@ declare const DocumentParserFromMixins: {
       technology?: string | undefined;
     }): {
       title?: string;
-      summary?: ProjectId$1;
-      description?: ProjectId$1;
+      summary?: ProjectId;
+      description?: ProjectId;
       technology?: string;
     };
     parseDeployment(): void;
     parseDeploymentNode(astNode: DeploymentNode): ParsedAstDeployment.Node;
     parseDeployedInstance(astNode: DeployedInstance): ParsedAstDeployment.Instance;
     parseExtendDeployment(astNode: ExtendDeployment): ParsedAstExtend | null;
-    _resolveDeploymentRelationSource(node: DeploymentRelation): ProjectId$1;
+    _resolveDeploymentRelationSource(node: DeploymentRelation): ProjectId;
     parseDeploymentRelation(astNode: DeploymentRelation): ParsedAstDeploymentRelation;
   };
 } & {
@@ -3004,46 +2976,49 @@ declare const DocumentParserFromMixins: {
     parseDeploymentNode(astNode: DeploymentNode): ParsedAstDeployment.Node;
     parseDeployedInstance(astNode: DeployedInstance): ParsedAstDeployment.Instance;
     parseExtendDeployment(astNode: ExtendDeployment): ParsedAstExtend | null;
-    _resolveDeploymentRelationSource(node: DeploymentRelation): ProjectId$1;
+    _resolveDeploymentRelationSource(node: DeploymentRelation): ProjectId;
     parseDeploymentRelation(astNode: DeploymentRelation): ParsedAstDeploymentRelation;
-    parseFqnRef(astNode: FqnRef$2): ProjectId$1;
-    parseExpressionV2(astNode: ExpressionV2): ProjectId$1;
-    parseFqnExprOrWith(astNode: FqnExprOrWith): ProjectId$1;
-    parseFqnExprWith(astNode: FqnExprWith): ProjectId$1;
-    parseFqnExprOrWhere(astNode: FqnExprOrWhere): ProjectId$1;
-    parseFqnExprWhere(astNode: FqnExprWhere): ProjectId$1;
-    parseFqnExpr(astNode: FqnExpr$2): ProjectId$1;
-    parseFqnRefExpr(astNode: FqnRefExpr): ProjectId$1;
-    parseFqnExpressions(astNode: FqnExpressions): ProjectId$1[];
-    parseRelationExprOrWith(astNode: RelationExprOrWith): ProjectId$1;
-    parseRelationExprWith(astNode: RelationExprWith): ProjectId$1;
-    parseCustomRelationProperties(custom: CustomRelationProperties | undefined): type_fest0.Except<ProjectId$1["customRelation"], "expr">;
-    parseRelationExprOrWhere(astNode: RelationExprOrWhere): ProjectId$1;
-    parseRelationExprWhere(astNode: RelationExprWhere): ProjectId$1;
-    parseRelationExpr(astNode: RelationExpr$1): ProjectId$1;
-    parseInlineKindCondition(astNode: OutgoingRelationExpr): ProjectId$1 | null;
-    wrapInWhere(expr: ProjectId$1, condition: ProjectId$1 | null): ProjectId$1;
+    parseFqnRef(astNode: FqnRef$2): ProjectId;
+    parseExpressionV2(astNode: ExpressionV2): ProjectId;
+    parseFqnExprOrWith(astNode: FqnExprOrWith): ProjectId;
+    parseFqnExprWith(astNode: FqnExprWith): ProjectId;
+    parseFqnExprOrWhere(astNode: FqnExprOrWhere): ProjectId;
+    parseFqnExprWhere(astNode: FqnExprWhere): ProjectId;
+    parseFqnExpr(astNode: FqnExpr$2): ProjectId;
+    parseFqnRefExpr(astNode: FqnRefExpr): ProjectId;
+    parseFqnExpressions(astNode: FqnExpressions): ProjectId[];
+    parseRelationExprOrWith(astNode: RelationExprOrWith): ProjectId;
+    parseRelationExprWith(astNode: RelationExprWith): ProjectId;
+    parseCustomRelationProperties(custom: CustomRelationProperties | undefined): type_fest0.Except<ProjectId["customRelation"], "expr">;
+    parseRelationExprOrWhere(astNode: RelationExprOrWhere): ProjectId;
+    parseRelationExprWhere(astNode: RelationExprWhere): ProjectId;
+    parseRelationExpr(astNode: RelationExpr$1): ProjectId;
+    parseInlineKindCondition(astNode: OutgoingRelationExpr): ProjectId | null;
+    wrapInWhere(expr: ProjectId, condition: ProjectId | null): ProjectId;
     isValid: IsValidFn;
     readonly services: LikeC4Services;
     readonly doc: ParsedLikeC4LangiumDocument;
-    get project(): Project;
-    resolveFqn(node: FqnReferenceable): ProjectId$1;
+    readonly project: Project;
+    logError(error: unknown, astNode?: AstNode | Reference<AstNode>, level?: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification"): void;
+    tryParse<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", node: N | undefined, fn: (node: NoInfer<N>) => T | undefined): T | undefined;
+    tryMap<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", iterable: ReadonlyArray<N>, fn: (node: N) => T | undefined): T[];
+    resolveFqn(node: FqnReferenceable): ProjectId;
     getAstNodePath(node: AstNode): string;
     getMetadata(metadataAstNode: MetadataProperty | undefined): {
       [key: string]: string | string[];
     } | undefined;
-    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId$1 | undefined;
+    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId | undefined;
     convertTags<E extends {
       tags?: Tags;
     }>(withTags?: E | undefined): any;
     parseTags<E extends {
       tags?: Tags;
-    }>(withTags?: E): ProjectId$1<ProjectId$1> | null;
-    convertLinks(source?: LinkProperty["$container"]): ProjectId$1[] | undefined;
-    parseLinks(source?: LinkProperty["$container"]): ProjectId$1[] | undefined;
-    parseIconProperty(prop: IconProperty | undefined): ProjectId$1 | undefined;
+    }>(withTags?: E): ProjectId<ProjectId> | null;
+    convertLinks(source?: LinkProperty["$container"]): ProjectId<ProjectId> | undefined;
+    parseLinks(source?: LinkProperty["$container"]): ProjectId<ProjectId> | undefined;
+    parseIconProperty(prop: IconProperty | undefined): ProjectId | undefined;
     parseImageAlias(value: string): string | undefined;
-    parseColorLiteral(astNode: ColorLiteral): ProjectId$1 | undefined;
+    parseColorLiteral(astNode: ColorLiteral$1): ProjectId | undefined;
     parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
     parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
     parseBaseProps(props: {
@@ -3058,8 +3033,8 @@ declare const DocumentParserFromMixins: {
       technology?: string | undefined;
     }): {
       title?: string;
-      summary?: ProjectId$1;
-      description?: ProjectId$1;
+      summary?: ProjectId;
+      description?: ProjectId;
       technology?: string;
     };
   };
@@ -3069,46 +3044,49 @@ declare const DocumentParserFromMixins: {
     parseElement(astNode: Element): ParsedAstElement;
     parseExtendElement(astNode: ExtendElement): ParsedAstExtend | null;
     parseExtendRelation(astNode: ExtendRelation): ParsedAstExtendRelation | null;
-    _resolveRelationSource(node: Relation): ProjectId$1 | ProjectId$1;
+    _resolveRelationSource(node: Relation): ProjectId | ProjectId;
     parseRelation(astNode: Relation): ParsedAstRelation;
-    parseFqnRef(astNode: FqnRef$2): ProjectId$1;
-    parseExpressionV2(astNode: ExpressionV2): ProjectId$1;
-    parseFqnExprOrWith(astNode: FqnExprOrWith): ProjectId$1;
-    parseFqnExprWith(astNode: FqnExprWith): ProjectId$1;
-    parseFqnExprOrWhere(astNode: FqnExprOrWhere): ProjectId$1;
-    parseFqnExprWhere(astNode: FqnExprWhere): ProjectId$1;
-    parseFqnExpr(astNode: FqnExpr$2): ProjectId$1;
-    parseFqnRefExpr(astNode: FqnRefExpr): ProjectId$1;
-    parseFqnExpressions(astNode: FqnExpressions): ProjectId$1[];
-    parseRelationExprOrWith(astNode: RelationExprOrWith): ProjectId$1;
-    parseRelationExprWith(astNode: RelationExprWith): ProjectId$1;
-    parseCustomRelationProperties(custom: CustomRelationProperties | undefined): type_fest0.Except<ProjectId$1["customRelation"], "expr">;
-    parseRelationExprOrWhere(astNode: RelationExprOrWhere): ProjectId$1;
-    parseRelationExprWhere(astNode: RelationExprWhere): ProjectId$1;
-    parseRelationExpr(astNode: RelationExpr$1): ProjectId$1;
-    parseInlineKindCondition(astNode: OutgoingRelationExpr): ProjectId$1 | null;
-    wrapInWhere(expr: ProjectId$1, condition: ProjectId$1 | null): ProjectId$1;
+    parseFqnRef(astNode: FqnRef$2): ProjectId;
+    parseExpressionV2(astNode: ExpressionV2): ProjectId;
+    parseFqnExprOrWith(astNode: FqnExprOrWith): ProjectId;
+    parseFqnExprWith(astNode: FqnExprWith): ProjectId;
+    parseFqnExprOrWhere(astNode: FqnExprOrWhere): ProjectId;
+    parseFqnExprWhere(astNode: FqnExprWhere): ProjectId;
+    parseFqnExpr(astNode: FqnExpr$2): ProjectId;
+    parseFqnRefExpr(astNode: FqnRefExpr): ProjectId;
+    parseFqnExpressions(astNode: FqnExpressions): ProjectId[];
+    parseRelationExprOrWith(astNode: RelationExprOrWith): ProjectId;
+    parseRelationExprWith(astNode: RelationExprWith): ProjectId;
+    parseCustomRelationProperties(custom: CustomRelationProperties | undefined): type_fest0.Except<ProjectId["customRelation"], "expr">;
+    parseRelationExprOrWhere(astNode: RelationExprOrWhere): ProjectId;
+    parseRelationExprWhere(astNode: RelationExprWhere): ProjectId;
+    parseRelationExpr(astNode: RelationExpr$1): ProjectId;
+    parseInlineKindCondition(astNode: OutgoingRelationExpr): ProjectId | null;
+    wrapInWhere(expr: ProjectId, condition: ProjectId | null): ProjectId;
     isValid: IsValidFn;
     readonly services: LikeC4Services;
     readonly doc: ParsedLikeC4LangiumDocument;
-    get project(): Project;
-    resolveFqn(node: FqnReferenceable): ProjectId$1;
+    readonly project: Project;
+    logError(error: unknown, astNode?: AstNode | Reference<AstNode>, level?: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification"): void;
+    tryParse<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", node: N | undefined, fn: (node: NoInfer<N>) => T | undefined): T | undefined;
+    tryMap<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", iterable: ReadonlyArray<N>, fn: (node: N) => T | undefined): T[];
+    resolveFqn(node: FqnReferenceable): ProjectId;
     getAstNodePath(node: AstNode): string;
     getMetadata(metadataAstNode: MetadataProperty | undefined): {
       [key: string]: string | string[];
     } | undefined;
-    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId$1 | undefined;
+    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId | undefined;
     convertTags<E extends {
       tags?: Tags;
     }>(withTags?: E | undefined): any;
     parseTags<E extends {
       tags?: Tags;
-    }>(withTags?: E): ProjectId$1<ProjectId$1> | null;
-    convertLinks(source?: LinkProperty["$container"]): ProjectId$1[] | undefined;
-    parseLinks(source?: LinkProperty["$container"]): ProjectId$1[] | undefined;
-    parseIconProperty(prop: IconProperty | undefined): ProjectId$1 | undefined;
+    }>(withTags?: E): ProjectId<ProjectId> | null;
+    convertLinks(source?: LinkProperty["$container"]): ProjectId<ProjectId> | undefined;
+    parseLinks(source?: LinkProperty["$container"]): ProjectId<ProjectId> | undefined;
+    parseIconProperty(prop: IconProperty | undefined): ProjectId | undefined;
     parseImageAlias(value: string): string | undefined;
-    parseColorLiteral(astNode: ColorLiteral): ProjectId$1 | undefined;
+    parseColorLiteral(astNode: ColorLiteral$1): ProjectId | undefined;
     parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
     parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
     parseBaseProps(props: {
@@ -3123,8 +3101,8 @@ declare const DocumentParserFromMixins: {
       technology?: string | undefined;
     }): {
       title?: string;
-      summary?: ProjectId$1;
-      description?: ProjectId$1;
+      summary?: ProjectId;
+      description?: ProjectId;
       technology?: string;
     };
   };
@@ -3134,24 +3112,27 @@ declare const DocumentParserFromMixins: {
     isValid: IsValidFn;
     readonly services: LikeC4Services;
     readonly doc: ParsedLikeC4LangiumDocument;
-    get project(): Project;
-    resolveFqn(node: FqnReferenceable): ProjectId$1;
+    readonly project: Project;
+    logError(error: unknown, astNode?: AstNode | Reference<AstNode>, level?: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification"): void;
+    tryParse<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", node: N | undefined, fn: (node: NoInfer<N>) => T | undefined): T | undefined;
+    tryMap<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", iterable: ReadonlyArray<N>, fn: (node: N) => T | undefined): T[];
+    resolveFqn(node: FqnReferenceable): ProjectId;
     getAstNodePath(node: AstNode): string;
     getMetadata(metadataAstNode: MetadataProperty | undefined): {
       [key: string]: string | string[];
     } | undefined;
-    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId$1 | undefined;
+    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId | undefined;
     convertTags<E extends {
       tags?: Tags;
     }>(withTags?: E | undefined): any;
     parseTags<E extends {
       tags?: Tags;
-    }>(withTags?: E): ProjectId$1<ProjectId$1> | null;
-    convertLinks(source?: LinkProperty["$container"]): ProjectId$1[] | undefined;
-    parseLinks(source?: LinkProperty["$container"]): ProjectId$1[] | undefined;
-    parseIconProperty(prop: IconProperty | undefined): ProjectId$1 | undefined;
+    }>(withTags?: E): ProjectId<ProjectId> | null;
+    convertLinks(source?: LinkProperty["$container"]): ProjectId<ProjectId> | undefined;
+    parseLinks(source?: LinkProperty["$container"]): ProjectId<ProjectId> | undefined;
+    parseIconProperty(prop: IconProperty | undefined): ProjectId | undefined;
     parseImageAlias(value: string): string | undefined;
-    parseColorLiteral(astNode: ColorLiteral): ProjectId$1 | undefined;
+    parseColorLiteral(astNode: ColorLiteral$1): ProjectId | undefined;
     parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
     parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
     parseBaseProps(props: {
@@ -3166,51 +3147,54 @@ declare const DocumentParserFromMixins: {
       technology?: string | undefined;
     }): {
       title?: string;
-      summary?: ProjectId$1;
-      description?: ProjectId$1;
+      summary?: ProjectId;
+      description?: ProjectId;
       technology?: string;
     };
   };
 } & {
   new (...args: any[]): {
-    parseFqnRef(astNode: FqnRef$2): ProjectId$1;
-    parseExpressionV2(astNode: ExpressionV2): ProjectId$1;
-    parseFqnExprOrWith(astNode: FqnExprOrWith): ProjectId$1;
-    parseFqnExprWith(astNode: FqnExprWith): ProjectId$1;
-    parseFqnExprOrWhere(astNode: FqnExprOrWhere): ProjectId$1;
-    parseFqnExprWhere(astNode: FqnExprWhere): ProjectId$1;
-    parseFqnExpr(astNode: FqnExpr$2): ProjectId$1;
-    parseFqnRefExpr(astNode: FqnRefExpr): ProjectId$1;
-    parseFqnExpressions(astNode: FqnExpressions): ProjectId$1[];
-    parseRelationExprOrWith(astNode: RelationExprOrWith): ProjectId$1;
-    parseRelationExprWith(astNode: RelationExprWith): ProjectId$1;
-    parseCustomRelationProperties(custom: CustomRelationProperties | undefined): type_fest0.Except<ProjectId$1["customRelation"], "expr">;
-    parseRelationExprOrWhere(astNode: RelationExprOrWhere): ProjectId$1;
-    parseRelationExprWhere(astNode: RelationExprWhere): ProjectId$1;
-    parseRelationExpr(astNode: RelationExpr$1): ProjectId$1;
-    parseInlineKindCondition(astNode: OutgoingRelationExpr): ProjectId$1 | null;
-    wrapInWhere(expr: ProjectId$1, condition: ProjectId$1 | null): ProjectId$1;
+    parseFqnRef(astNode: FqnRef$2): ProjectId;
+    parseExpressionV2(astNode: ExpressionV2): ProjectId;
+    parseFqnExprOrWith(astNode: FqnExprOrWith): ProjectId;
+    parseFqnExprWith(astNode: FqnExprWith): ProjectId;
+    parseFqnExprOrWhere(astNode: FqnExprOrWhere): ProjectId;
+    parseFqnExprWhere(astNode: FqnExprWhere): ProjectId;
+    parseFqnExpr(astNode: FqnExpr$2): ProjectId;
+    parseFqnRefExpr(astNode: FqnRefExpr): ProjectId;
+    parseFqnExpressions(astNode: FqnExpressions): ProjectId[];
+    parseRelationExprOrWith(astNode: RelationExprOrWith): ProjectId;
+    parseRelationExprWith(astNode: RelationExprWith): ProjectId;
+    parseCustomRelationProperties(custom: CustomRelationProperties | undefined): type_fest0.Except<ProjectId["customRelation"], "expr">;
+    parseRelationExprOrWhere(astNode: RelationExprOrWhere): ProjectId;
+    parseRelationExprWhere(astNode: RelationExprWhere): ProjectId;
+    parseRelationExpr(astNode: RelationExpr$1): ProjectId;
+    parseInlineKindCondition(astNode: OutgoingRelationExpr): ProjectId | null;
+    wrapInWhere(expr: ProjectId, condition: ProjectId | null): ProjectId;
     isValid: IsValidFn;
     readonly services: LikeC4Services;
     readonly doc: ParsedLikeC4LangiumDocument;
-    get project(): Project;
-    resolveFqn(node: FqnReferenceable): ProjectId$1;
+    readonly project: Project;
+    logError(error: unknown, astNode?: AstNode | Reference<AstNode>, level?: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification"): void;
+    tryParse<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", node: N | undefined, fn: (node: NoInfer<N>) => T | undefined): T | undefined;
+    tryMap<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", iterable: ReadonlyArray<N>, fn: (node: N) => T | undefined): T[];
+    resolveFqn(node: FqnReferenceable): ProjectId;
     getAstNodePath(node: AstNode): string;
     getMetadata(metadataAstNode: MetadataProperty | undefined): {
       [key: string]: string | string[];
     } | undefined;
-    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId$1 | undefined;
+    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId | undefined;
     convertTags<E extends {
       tags?: Tags;
     }>(withTags?: E | undefined): any;
     parseTags<E extends {
       tags?: Tags;
-    }>(withTags?: E): ProjectId$1<ProjectId$1> | null;
-    convertLinks(source?: LinkProperty["$container"]): ProjectId$1[] | undefined;
-    parseLinks(source?: LinkProperty["$container"]): ProjectId$1[] | undefined;
-    parseIconProperty(prop: IconProperty | undefined): ProjectId$1 | undefined;
+    }>(withTags?: E): ProjectId<ProjectId> | null;
+    convertLinks(source?: LinkProperty["$container"]): ProjectId<ProjectId> | undefined;
+    parseLinks(source?: LinkProperty["$container"]): ProjectId<ProjectId> | undefined;
+    parseIconProperty(prop: IconProperty | undefined): ProjectId | undefined;
     parseImageAlias(value: string): string | undefined;
-    parseColorLiteral(astNode: ColorLiteral): ProjectId$1 | undefined;
+    parseColorLiteral(astNode: ColorLiteral$1): ProjectId | undefined;
     parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
     parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
     parseBaseProps(props: {
@@ -3225,8 +3209,8 @@ declare const DocumentParserFromMixins: {
       technology?: string | undefined;
     }): {
       title?: string;
-      summary?: ProjectId$1;
-      description?: ProjectId$1;
+      summary?: ProjectId;
+      description?: ProjectId;
       technology?: string;
     };
   };
@@ -3236,7 +3220,7 @@ declare class LikeC4ModelParser {
   private services;
   protected cachedParsers: any;
   constructor(services: LikeC4Services);
-  documents(projectId: ProjectId$1): Stream<ParsedLikeC4LangiumDocument>;
+  documents(projectId: ProjectId): Stream<ParsedLikeC4LangiumDocument>;
   parse(doc: LangiumDocument): ParsedLikeC4LangiumDocument;
   forDocument(doc: LangiumDocument): DocumentParser;
   private createParser;
@@ -3245,6 +3229,23 @@ declare class LikeC4ModelParser {
 declare class LikeC4ValueConverter extends DefaultValueConverter {
   protected runConverter(rule: any, input: string, cstNode: CstNode): ValueType;
 } //#endregion
+//#region src/model-change/ModelChanges.d.ts
+declare class LikeC4ModelChanges {
+  private services;
+  private locator;
+  constructor(services: LikeC4Services);
+  applyChange(changeView: ChangeView.Params): Promise<ChangeView.Res>;
+  protected convertToTextEdit({
+    lookup,
+    change
+  }: {
+    lookup: ViewLocateResult;
+    change: Exclude<ViewChange, ViewChange.SaveViewSnapshot | ViewChange.ResetManualLayout>;
+  }): {
+    modifiedRange: Range;
+    edits: TextEdit[];
+  };
+} //#endregion
 //#region src/LikeC4LanguageServices.d.ts
 interface LikeC4LanguageServices {
   readonly views: LikeC4Views;
@@ -3252,11 +3253,12 @@ interface LikeC4LanguageServices {
   readonly workspaceUri: URI;
   readonly projectsManager: ProjectsManager;
   readonly editor: LikeC4ModelChanges;
+  readonly mcpServer: LikeC4MCPServer | null;
   /**
    * Returns all projects with relevant documents
    */
   projects(): NonEmptyArray<{
-    id: ProjectId$1;
+    id: ProjectId;
     folder: URI;
     title: string;
     documents: ReadonlyArray<URI>;
@@ -3265,8 +3267,8 @@ interface LikeC4LanguageServices {
   /**
    * Returns project by ID, returns default project if no ID is specified
    */
-  project(projectId?: ProjectId$1): {
-    id: ProjectId$1;
+  project(projectId?: ProjectId): {
+    id: ProjectId;
     folder: URI;
     title: string;
     documents: ReadonlyArray<URI>;
@@ -3283,21 +3285,21 @@ interface LikeC4LanguageServices {
    *
    * If no {@link project} is specified, returns for default project
    */
-  computedModel(project?: ProjectId$1 | undefined, cancelToken?: CancellationToken$1): Promise<LikeC4Model<UnknownComputed>>;
+  computedModel(project?: ProjectId | undefined, cancelToken?: CancellationToken$1): Promise<LikeC4Model<UnknownComputed>>;
   /**
    * Returns {@link LikeC4Model} of the specified project, with layouted views {@link LayoutedView}
    * Ready for rendering. Applies manual layouts if available.
    *
    * If no {@link project} is specified, returns for default project
    */
-  layoutedModel(project?: ProjectId$1 | undefined, cancelToken?: CancellationToken$1): Promise<LikeC4Model<UnknownLayouted>>;
+  layoutedModel(project?: ProjectId | undefined, cancelToken?: CancellationToken$1): Promise<LikeC4Model<UnknownLayouted>>;
   /**
    * Returns diagrams (i.e. layouted views {@link LayoutedView}) for the specified project
    * Applies manual layouts if available.
    *
    * If no {@link project} is specified, returns diagrams for default project
    */
-  diagrams(project?: ProjectId$1 | undefined, cancelToken?: CancellationToken$1): Promise<LayoutedView$1[]>;
+  diagrams(project?: ProjectId | undefined, cancelToken?: CancellationToken$1): Promise<LayoutedView[]>;
   getErrors(): Array<{
     message: string;
     line: number;
@@ -3309,9 +3311,222 @@ interface LikeC4LanguageServices {
    */
   locate(params: Locate.Params): Locate.Res;
   dispose(): Promise<void>;
+} //#endregion
+//#region src/lsp/CodeLensProvider.d.ts
+declare class LikeC4CodeLensProvider implements CodeLensProvider {
+  private services;
+  constructor(services: LikeC4Services);
+  provideCodeLens(doc: LangiumDocument, _params: CodeLensParams, cancelToken?: CancellationToken$1): Promise<CodeLens[] | undefined>;
+} //#endregion
+//#region src/lsp/CompletionProvider.d.ts
+declare class LikeC4CompletionProvider extends DefaultCompletionProvider {
+  protected services: LikeC4Services;
+  constructor(services: LikeC4Services);
+  readonly completionOptions: {
+    triggerCharacters: string[];
+  };
+  protected completionFor(context: CompletionContext, next: NextFeature, acceptor: CompletionAcceptor): MaybePromise<void>;
+  protected completionForKeyword(context: CompletionContext, keyword: Keyword, acceptor: CompletionAcceptor): MaybePromise<void>;
+  protected completionForImportedProject(context: CompletionContext, acceptor: CompletionAcceptor): void;
+} //#endregion
+//#region src/lsp/DocumentHighlightProvider.d.ts
+declare class LikeC4DocumentHighlightProvider extends DefaultDocumentHighlightProvider {
+  /**
+   * Override this method to determine the highlight kind of the given reference.
+   */
+  protected createDocumentHighlight(reference: ReferenceDescription): DocumentHighlight;
+} //#endregion
+//#region src/lsp/DocumentLinkProvider.d.ts
+declare class LikeC4DocumentLinkProvider implements DocumentLinkProvider {
+  private services;
+  constructor(services: LikeC4Services);
+  getDocumentLinks(doc: LangiumDocument, _params: DocumentLinkParams, _cancelToken?: CancellationToken$1): Promise<DocumentLink[]>;
+  resolveLink(doc: LangiumDocument, link: string): string;
+  relativeLink(doc: LangiumDocument, link: string): string | null;
+} //#endregion
+//#region src/lsp/DocumentSymbolProvider.d.ts
+declare class LikeC4DocumentSymbolProvider implements DocumentSymbolProvider {
+  private services;
+  protected readonly nodeKindProvider: NodeKindProvider;
+  protected readonly nameProvider: LikeC4NameProvider;
+  protected readonly parser: LikeC4ModelParser;
+  protected readonly locator: LikeC4ModelLocator;
+  constructor(services: LikeC4Services);
+  getSymbols(doc: LangiumDocument, _params: DocumentSymbolParams, cancelToken?: CancellationToken$1): Promise<DocumentSymbol[]>;
+  protected getLikec4LibSymbol(astLib: LikeC4Lib): DocumentSymbol[];
+  protected getSpecSymbol(astSpec: SpecificationRule): DocumentSymbol[];
+  protected getModelSymbol(astModel: Model): DocumentSymbol[];
+  protected getDeploymentModelSymbol(astModel: ModelDeployments): DocumentSymbol[];
+  protected getElementsSymbol(el: Element | Relation | ExtendElement): DocumentSymbol[];
+  protected getExtendElementSymbol(astElement: ExtendElement): DocumentSymbol[];
+  protected getElementSymbol(astElement: Element): DocumentSymbol[];
+  protected getModelViewsSymbol(astViews: ModelViews): DocumentSymbol[];
+  protected getKindSymbol(astKind: SpecificationElementKind | SpecificationRelationshipKind): DocumentSymbol | null;
+  protected getTagSymbol(astTag: SpecificationTag): DocumentSymbol | null;
+  protected getLibIconSymbol(astTag: LibIcon): DocumentSymbol | null;
+  protected getViewSymbol(astView: LikeC4View): DocumentSymbol[];
+  protected getDeploymentElementSymbol(el: DeploymentElement | DeploymentRelation | ExtendDeployment): DocumentSymbol[];
+  protected getDeploymentNodeSymbol(astElement: DeploymentNode): DocumentSymbol[];
+  protected getDeployedInstanceSymbol(astElement: DeployedInstance): DocumentSymbol[];
+  protected symbolKind(node: AstNode): SymbolKind;
+} //#endregion
+//#region src/lsp/HoverProvider.d.ts
+/**
+ * Provides hover content for LikeC4 AST nodes (elements, tags, relations, etc.)
+ * in the language server. Resolves model references and formats markdown hover text.
+ */
+declare class LikeC4HoverProvider extends AstNodeHoverProvider {
+  protected services: LikeC4Services;
+  private parser;
+  private locator;
+  /** @param services - LikeC4 language services (parser, locator, etc.) */
+  constructor(services: LikeC4Services);
+  protected getAstNodeHoverContent(node: AstNode): MaybePromise<Hover | undefined>;
+  /**
+   * Builds hover content for an element node (title, summary, model details and view links).
+   * @param node - The element AST node to generate hover content for.
+   * @returns Hover information with markdown content, or undefined if element not found.
+   */
+  protected getElementHover(node: Element): MaybePromise<Hover | undefined>;
+  /**
+   * Builds markdown hover content for an element model (relationship counts and links to views).
+   * @param model - The element model containing relationship and view information.
+   * @param projectId - The project identifier for constructing view links.
+   * @returns Markdown string with model details, or undefined if no details available.
+   */
+  protected getElementModelHover(model: ElementModel, projectId: ProjectId): string | undefined;
+  /**
+   * Builds hover content for a deployment node (id, title, kind, summary).
+   * @param node - The deployment node AST node to generate hover content for.
+   * @returns Hover information with markdown content.
+   */
+  protected getDeploymentNodeHover(node: DeploymentNode): MaybePromise<Hover | undefined>;
+  /**
+   * Builds hover content for a deployed instance (instance id, element ref, title and kind).
+   * @param node - The deployed instance AST node to generate hover content for.
+   * @returns Hover information with markdown content showing instance details.
+   */
+  protected getDeployedInstanceHover(node: DeployedInstance): MaybePromise<Hover | undefined>;
+} //#endregion
+//#region src/lsp/CodeActionProvider.d.ts
+type CommandOrCodeAction = Command | CodeAction;
+declare class LikeC4CodeActionProvider implements CodeActionProvider {
+  /**
+   * Handle a code action 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
+   */
+  getCodeActions(document: LangiumDocument, params: CodeActionParams): CommandOrCodeAction[] | undefined;
+} //#endregion
+//#region src/lsp/SemanticTokenProvider.d.ts
+declare class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
+  protected services: LikeC4Services;
+  private rules;
+  constructor(services: LikeC4Services);
+  protected initRules(): void;
+  semanticHighlight(document: LangiumDocument, params: SemanticTokensParams, cancelToken?: CancellationToken$1): Promise<SemanticTokens>;
+  semanticHighlightRange(document: LangiumDocument, params: SemanticTokensRangeParams, cancelToken?: CancellationToken$1): Promise<SemanticTokens>;
+  semanticHighlightDelta(document: LangiumDocument, params: SemanticTokensDeltaParams, cancelToken?: CancellationToken$1): Promise<SemanticTokens | SemanticTokensDelta>;
+  protected ensureState(document: LangiumDocument, cancelToken: CancellationToken$1): Promise<void>;
+  protected highlightElement(node: AstNode, acceptor: SemanticTokenAcceptor): void | undefined | 'prune';
+  private highlightNameAndKind;
+  private highlightView;
+  private mark;
+} //#endregion
+//#region src/Rpc.d.ts
+declare class Rpc extends ADisposable {
+  private services;
+  constructor(services: LikeC4Services);
+  init: () => void;
+  openView(params: DidRequestOpenViewNotification.Params): Promise<void>;
+} //#endregion
+//#region src/shared/NodeKindProvider.d.ts
+declare class NodeKindProvider$1 implements NodeKindProvider {
+  private services;
+  constructor(services: LangiumSharedServices);
+  /**
+   * Returns a `SymbolKind` as used by `WorkspaceSymbolProvider` or `DocumentSymbolProvider`.
+   */
+  getSymbolKind(node: AstNode | AstNodeDescription): SymbolKind;
+  /**
+   * Returns a `CompletionItemKind` as used by the `CompletionProvider`.
+   */
+  getCompletionItemKind(node: AstNode | AstNodeDescription): CompletionItemKind;
+} //#endregion
+//#region src/shared/WorkspaceSymbolProvider.d.ts
+declare class WorkspaceSymbolProvider extends DefaultWorkspaceSymbolProvider {} //#endregion
+//#region src/module.d.ts
+interface LikeC4AddedSharedServices {
+  lsp: {
+    NodeKindProvider: NodeKindProvider$1;
+    WorkspaceSymbolProvider: WorkspaceSymbolProvider;
+  };
+  workspace: {
+    Cache: WorkspaceCache<string, any>;
+    ProjectsManager: ProjectsManager;
+    IndexManager: IndexManager;
+    LangiumDocuments: LangiumDocuments;
+    WorkspaceManager: LikeC4WorkspaceManager;
+    FileSystemProvider: FileSystemProvider$1;
+    FileSystemWatcher: FileSystemWatcher;
+    ManualLayouts: LikeC4ManualLayouts;
+  };
+}
+type LikeC4SharedServices = LangiumSharedServices & LikeC4AddedSharedServices;
+/**
+ * Declaration of custom services - add your own service classes here.
+ */
+interface LikeC4AddedServices {
+  documentation: {
+    DocumentationProvider: LikeC4DocumentationProvider;
+  };
+  validation: {
+    DocumentValidator: LikeC4DocumentValidator;
+  };
+  Rpc: Rpc;
+  mcp: {
+    Server: LikeC4MCPServer;
+    ServerFactory: LikeC4MCPServerFactory;
+  };
+  likec4: {
+    LanguageServices: LikeC4LanguageServices;
+    Views: LikeC4Views;
+    Layouter: QueueGraphvizLayoter;
+    DeploymentsIndex: DeploymentsIndex;
+    FqnIndex: FqnIndex;
+    ModelParser: LikeC4ModelParser;
+    ModelBuilder: LikeC4ModelBuilder;
+    ModelLocator: LikeC4ModelLocator;
+    ModelChanges: LikeC4ModelChanges;
+    LastSeen: LastSeenArtifacts;
+  };
+  lsp: {
+    CompletionProvider: LikeC4CompletionProvider;
+    DocumentHighlightProvider: LikeC4DocumentHighlightProvider;
+    DocumentSymbolProvider: LikeC4DocumentSymbolProvider;
+    SemanticTokenProvider: LikeC4SemanticTokenProvider;
+    HoverProvider: LikeC4HoverProvider;
+    CodeLensProvider: LikeC4CodeLensProvider;
+    DocumentLinkProvider: LikeC4DocumentLinkProvider;
+    Formatter: LikeC4Formatter;
+    CodeActionProvider: LikeC4CodeActionProvider;
+  };
+  references: {
+    NameProvider: LikeC4NameProvider;
+    ScopeComputation: LikeC4ScopeComputation;
+    ScopeProvider: LikeC4ScopeProvider;
+  };
+  shared?: LikeC4SharedServices;
+  parser: {
+    ValueConverter: LikeC4ValueConverter;
+  };
 }
+type LikeC4Services = LangiumServices & LikeC4AddedServices;
 /**
- * Public Language Services
+ * Most probably you don't need to use this function directly.
+ * Use {@link createLanguageServices} instead.
+ * @internal
  */
 //#endregion
-export { ProjectsManager as i, LikeC4Services as n, LikeC4Views as r, LikeC4LanguageServices as t };
+export { LikeC4Views as a, LikeC4SharedServices as i, LikeC4ModelBuilder as n, ProjectsManager as o, LikeC4Services as r, LikeC4LanguageServices as t };