@likec4/language-server 1.48.0 → 1.49.0

package/dist/_chunks/{LikeC4LanguageServices.d.mts → index.d.mts}

@@ -1,28 +1,29 @@
-import { $n as ViewLayoutDirection, $t as MetadataBody, A as DynamicView, An as RelationshipStyleProperty, At as IconProperty, B as DynamicViewStep, Bn as SpecificationRelationshipStringProperty, Bt as LikeC4Grammar, Cn as RelationExprWith, D as DirectedRelationExpr, Dn as RelationStringProperty, E as DeploymentViewRuleStyle, Et as IconColorProperty, F as DynamicViewIncludePredicate, Fn as SpecificationColor, Ft as InOutRelationExpr, G as ElementProperty, H as ElementBody, Hn as SpecificationTag, Ht as LikeC4Lib, I as DynamicViewParallelSteps, In as SpecificationDeploymentNodeKind, It as IncomingRelationExpr, J as ElementStringProperty, Jt as LineProperty, K as ElementRef, Kn as StyleProperty, Kt as LikeC4View, Ln as SpecificationElementKind, Lt as LibIcon, M as DynamicViewDisplayVariantProperty, Mn as ShapeSizeProperty, Nt as Imported, O as DynamicStepChain, Or as WildcardExpression, Ot as IconPositionProperty, P as DynamicViewGlobalPredicateRef, Pn as SizeValue, Pt as ImportsFromPoject, Qt as MetadataAttribute, Rn as SpecificationElementStringProperty, S as DeploymentView, Sn as RelationExprWhere, St as GlobalStyleGroup, T as DeploymentViewRulePredicate, Tt as HexColor, V as Element, Vn as SpecificationRule, W as ElementKindExpression, Wn as StrictFqnRef, X as ElementTagExpression, Xn as TextSizeProperty, Xt as MarkdownOrString, Y as ElementStyleProperty, Yn as Tags, Yt as LinkProperty, Z as ElementView, _ as DeploymentNodeBody, _n as Relation, _t as FqnRefExpr, a as BorderProperty, an as ModelViews, ar as ViewRuleGlobalStyle, at as ExtendElementBody, b as DeploymentRelation, bn as RelationExprOrWhere, bt as GlobalPredicateGroup, c as ColorProperty, cn as NotationProperty, cr as ViewRuleRank, dn as OutgoingRelationExpr, dr as ViewStringProperty, dt as FqnExprOrWhere, en as MetadataProperty, et as ExpressionV2, f as CustomRelationProperties, fn as PaddingSizeProperty, ft as FqnExprOrWith, g as DeploymentNode, gn as Referenceable, gt as FqnRef$2, h as DeploymentElement, ht as FqnExpressions, ir as ViewRuleGlobalPredicateRef, it as ExtendElement, jn as ShapeProperty, jt as IconSizeProperty, k as DynamicStepSingle, kt as IconPositionValue, ln as NotesProperty, lr as ViewRuleStyle, m as DeployedInstanceBody, mn as RGBAColor, mt as FqnExprWith, nn as Model, nr as ViewRule, nt as ExtendDeployment, on as MultipleProperty, or as ViewRuleGroup, p as DeployedInstance, pt as FqnExprWhere, r as ArrowProperty, rn as ModelDeployments, rr as ViewRuleAutoLayout, rt as ExtendDeploymentBody, s as ColorLiteral, sn as NavigateToProperty, sr as ViewRulePredicate, st as ExtendRelation, t as AbstractDynamicStep, un as OpacityProperty, ur as ViewRuleStyleOrGlobalRef, ut as FqnExpr$2, vt as FqnReferenceable, w as DeploymentViewRule, wt as Globals, xn as RelationExprOrWith, xt as GlobalStyle, yn as RelationExpr$1, yt as GlobalDynamicPredicateGroup, z as DynamicViewRule, zn as SpecificationRelationshipKind, zt as LikeC4AstType } from "./ast.mjs";
-import { h as Locate, n as ChangeView, o as DidRequestOpenViewNotification } from "./protocol.mjs";
-import { AbstractFormatter, AbstractSemanticTokenProvider, AstNodeHoverProvider, CodeActionProvider, CodeLensProvider, CompletionAcceptor, CompletionContext, DefaultCompletionProvider, DefaultDocumentHighlightProvider, DefaultSharedModuleContext, DefaultWorkspaceSymbolProvider, DocumentLinkProvider, DocumentSymbolProvider, FormattingRegion, LangiumServices, LangiumSharedServices, NextFeature, NodeKindProvider, PartialLangiumServices, SemanticTokenAcceptor } from "langium/lsp";
-import * as langium0 from "langium";
-import { AstNode, AstNodeDescription, AsyncDisposable, BuildOptions, Cancellation, CstNode, DefaultAstNodeDescriptionProvider, DefaultDocumentValidator, DefaultIndexManager, DefaultLangiumDocuments, DefaultNameProvider, DefaultScopeComputation, DefaultScopeProvider, DefaultValueConverter, DefaultWorkspaceManager, DiagnosticInfo, Disposable, DocumentationProvider, FileSelector, FileSystemNode, FileSystemProvider, GrammarAST, LangiumDocument, LangiumDocumentFactory, MaybePromise, Module, PrecomputedScopes, ReferenceDescription, ReferenceInfo, Scope, Stream, URI, ValidationOptions, ValueType, WorkspaceCache } from "langium";
+import { ChangeView, DidRequestOpenViewNotification, Locate } from "../protocol.mjs";
+import { LikeC4Services, LikeC4SharedServices } from "../module.mjs";
+import * as langium from "langium";
+import { AstNode, AstNodeDescription, AsyncDisposable, BuildOptions, Cancellation, CstNode, DefaultAstNodeDescriptionProvider, DefaultDocumentValidator, DefaultIndexManager, DefaultLangiumDocuments, DefaultNameProvider, DefaultScopeComputation, DefaultScopeProvider, DefaultValueConverter, DefaultWorkspaceManager, DiagnosticInfo, Disposable, FileSelector, FileSystemNode, FileSystemProvider, GrammarAST, JSDocDocumentationProvider, LangiumDocument, LangiumDocumentFactory, MaybePromise, PrecomputedScopes, Reference, ReferenceDescription, ReferenceInfo, Scope, SimpleCache, Stream, URI, ValidationOptions, ValueType, WorkspaceCache } from "langium";
 import { DefaultWeakMap, MultiMap as MultiMap$1 } from "@likec4/core/utils";
 import { CompletionItemKind, Diagnostic, DocumentSymbol, FormattingOptions, Hover, Location, Range, SemanticTokens, SemanticTokensDelta, SymbolKind, TextEdit } from "vscode-languageserver-types";
-import { IncludeConfig, LikeC4ProjectConfig, LikeC4ProjectConfigInput } from "@likec4/config";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { LikeC4Model } from "@likec4/core/model";
-import { URI as URI$2 } from "vscode-uri";
-import * as c4 from "@likec4/core";
-import { ComputedView, DiagramView, LayoutType, LayoutedView, NonEmptyArray, NonEmptyReadonlyArray, ProjectId, UnknownComputed, UnknownLayouted, UnknownParsed, ViewChange, ViewId } from "@likec4/core";
-import { CancellationToken, CodeLens, CodeLensParams, Connection, DocumentHighlight, DocumentLink, DocumentLinkParams, DocumentSymbolParams, WorkspaceFolder } from "vscode-languageserver";
+import { AbstractFormatter, AbstractSemanticTokenProvider, AstNodeHoverProvider, CodeActionProvider, CodeLensProvider, CompletionAcceptor, CompletionContext, DefaultCompletionProvider, DefaultDocumentHighlightProvider, DefaultWorkspaceSymbolProvider, DocumentLinkProvider, DocumentSymbolProvider, FormattingRegion, LangiumSharedServices, NextFeature, NodeKindProvider, SemanticTokenAcceptor } from "langium/lsp";
 import { GraphvizLayouter, QueueGraphvizLayoter } from "@likec4/layouts";
+import * as c4 from "@likec4/core";
+import { ComputedView, DiagramView, LayoutType, LayoutedView, NonEmptyArray, NonEmptyReadonlyArray, ProjectId, Tag, UnknownComputed, UnknownLayouted, UnknownParsed, ViewChange, ViewId } from "@likec4/core";
 import { AdhocViewPredicate, LayoutedProjectsView as LayoutedProjectsView$1 } from "@likec4/core/compute-view";
+import { ElementModel, LikeC4Model } from "@likec4/core/model";
+import { IncludeConfig, LikeC4ProjectConfig, LikeC4ProjectConfigInput } from "@likec4/config";
+import { URI as URI$2 } from "vscode-uri";
+import { LikeC4Styles } from "@likec4/core/styles";
+import { CancellationToken, CodeLens, CodeLensParams, DocumentHighlight, DocumentLink, DocumentLinkParams, DocumentSymbolParams, WorkspaceFolder } from "vscode-languageserver";
 import { CancellationToken as CancellationToken$1, CodeAction, CodeActionParams, Command, SemanticTokensDeltaParams, SemanticTokensParams, SemanticTokensRangeParams } from "vscode-languageserver-protocol";
-import { Fqn as Fqn$1, LayoutedView as LayoutedView$1, ProjectId as ProjectId$1, ViewId as ViewId$1 } from "@likec4/core/types";
+import { Fqn as Fqn$1, GuardedBy, LayoutedView as LayoutedView$1, ProjectId as ProjectId$1, ViewId as ViewId$1 } from "@likec4/core/types";
 import { CancellationToken as CancellationToken$2 } from "vscode-jsonrpc";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import * as type_fest0 from "type-fest";
 import { ConditionalPick, MergeExclusive, Simplify, Tagged, ValueOf, Writable } from "type-fest";
 import { ServerOptions } from "@modelcontextprotocol/sdk/server/index.js";
 
 //#region src/documentation/documentation-provider.d.ts
-declare class LikeC4DocumentationProvider implements DocumentationProvider {
+declare class LikeC4DocumentationProvider extends JSDocDocumentationProvider {
   private parser;
   private locator;
   constructor(services: LikeC4Services);
@@ -30,16 +31,23 @@ declare class LikeC4DocumentationProvider implements DocumentationProvider {
 }
 //#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 ProjectData {
+interface Project {
   id: ProjectId$1;
+  folderUri: URI;
   config: LikeC4ProjectConfig;
+}
+interface ProjectData extends Project {
+  id: ProjectId$1;
   folder: ProjectFolder;
+  config: LikeC4ProjectConfig;
+  configUri: URI;
   folderUri: URI;
   exclude?: {
     (test: string): boolean;
@@ -57,15 +65,13 @@ interface ProjectData {
    */
   includeConfig: IncludeConfig;
 }
-interface Project {
-  id: ProjectId$1;
-  folderUri: URI;
-  config: LikeC4ProjectConfig;
-  /**
-   * Resolved include paths as URIs (if configured).
-   */
-  includePaths?: NonEmptyReadonlyArray<URI>;
-}
+type RegisterProjectOptions = {
+  config: LikeC4ProjectConfig | LikeC4ProjectConfigInput;
+} & ({
+  configUri: URI | string;
+} | {
+  folderUri: URI | string;
+});
 declare class ProjectsManager {
   #private;
   protected services: LikeC4SharedServices;
@@ -86,11 +92,11 @@ declare class ProjectsManager {
   set defaultProjectId(id: string | ProjectId$1 | undefined);
   get default(): ProjectData;
   get all(): NonEmptyReadonlyArray<ProjectId$1>;
-  getProject(arg: ProjectId$1 | LangiumDocument): Project;
+  getProject(arg: ProjectId$1 | LangiumDocument): ProjectData;
   /**
-   * Returns all projects that include the specified folder, or inside the folder.
+   * Returns all projects that overlap with the specified folder (is parent or child)
    */
-  findAllProjectsByFolder(folder: URI | string): ProjectData[];
+  findOverlaped(folder: URI | string): ProjectData[];
   /**
    * Validates and ensures the project ID.
    * If no project ID is specified, returns default project ID
@@ -100,53 +106,38 @@ declare class ProjectsManager {
   /**
    * Validates and ensures the project.
    */
-  ensureProject(projectId?: ProjectId$1 | undefined): Project;
+  ensureProject(projectId?: ProjectId$1 | undefined): ProjectData;
   hasMultipleProjects(): boolean;
   /**
    * Checks if the specified document should be excluded from processing.
    */
-  isExcluded(document: LangiumDocument | URI | string): boolean;
+  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;
-  /**
-   * 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?: Cancellation.CancellationToken): Promise<ProjectData>;
+  registerConfigFile(configUri: URI, cancelToken?: Cancellation.CancellationToken): 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?: Cancellation.CancellationToken): Promise<ProjectData>;
+  registerProject(opts: RegisterProjectOptions, cancelToken?: Cancellation.CancellationToken): 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$1;
+  ownerProjectId(document: LangiumDocument | URI | string): ProjectId$1;
   reloadProjects(cancelToken?: Cancellation.CancellationToken): Promise<void>;
   protected _reloadProjects(cancelToken?: Cancellation.CancellationToken): Promise<void>;
   protected uniqueProjectId(name: string): ProjectId$1;
-  protected reset(): void;
-  rebuidProject(projectId: ProjectId$1, cancelToken?: Cancellation.CancellationToken): 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>;
+  protected resetCaches(): void;
+  rebuildProject(projectId: ProjectId$1, cancelToken?: Cancellation.CancellationToken): Promise<void>;
   /**
    * Returns all include paths from all projects.
    * Used by WorkspaceManager to scan additional directories for C4 files.
@@ -163,6 +154,7 @@ declare class ProjectsManager {
   onProjectsUpdate(callback: () => void): Disposable;
   private getWorkspaceFolder;
   private notifyListeners;
+  private updateIncludesExcludes;
 }
 //#endregion
 //#region src/filesystem/types.d.ts
@@ -179,6 +171,7 @@ interface FileSystemProvider$1 extends FileSystemProvider {
   /**
    * 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>;
   /**
@@ -221,8 +214,12 @@ interface FileSystemWatcher extends AsyncDisposable {
 interface LikeC4ManualLayoutsModuleContext {
   manualLayouts: (services: LikeC4SharedServices) => LikeC4ManualLayouts;
 }
+type ManualLayoutsSnapshot = {
+  hash: string;
+  views: Record<ViewId$1, LayoutedView$1>;
+};
 interface LikeC4ManualLayouts {
-  read(project: Project): Promise<Record<ViewId$1, LayoutedView$1> | null>;
+  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;
@@ -233,6 +230,15 @@ declare const NoFileSystemWatcher: FileSystemWatcherModuleContext;
 declare const NoFileSystem: FileSystemModuleContext;
 declare const NoLikeC4ManualLayouts: LikeC4ManualLayoutsModuleContext;
 //#endregion
+//#region src/filesystem/LikeC4FileSystem.d.ts
+declare const WithFileSystem: (ehableWatcher?: boolean) => FileSystemModuleContext;
+//#endregion
+//#region src/filesystem/ChokidarWatcher.d.ts
+declare const WithChokidarWatcher: FileSystemWatcherModuleContext;
+//#endregion
+//#region src/filesystem/LikeC4ManualLayouts.d.ts
+declare const WithLikeC4ManualLayouts: LikeC4ManualLayoutsModuleContext;
+//#endregion
 //#region src/formatting/LikeC4Formatter.d.ts
 type QuoteStyle = 'single' | 'double' | 'ignore' | 'auto';
 interface LikeC4FormatterOptions {
@@ -289,523 +295,1269 @@ declare class LikeC4Formatter extends AbstractFormatter {
   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): 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: GrammarAST.Keyword, acceptor: CompletionAcceptor): MaybePromise<void>;
-  protected completionForImportedProject(context: CompletionContext, acceptor: CompletionAcceptor): void;
+//#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>;
 }
-//#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;
+interface LikeC4MCPServerFactory {
+  create(options?: ServerOptions): McpServer;
 }
-//#endregion
-//#region src/lsp/DocumentLinkProvider.d.ts
-declare class LikeC4DocumentLinkProvider implements DocumentLinkProvider {
-  private services;
-  constructor(services: LikeC4Services);
-  getDocumentLinks(doc: LangiumDocument, _params: DocumentLinkParams, _cancelToken?: CancellationToken): Promise<DocumentLink[]>;
-  resolveLink(doc: LangiumDocument, link: string): string;
-  relativeLink(doc: LangiumDocument, link: string): string | null;
+interface LikeC4MCPServerModuleContext {
+  mcpServer: (services: LikeC4Services) => LikeC4MCPServer;
+  mcpServerFactory: (services: LikeC4Services) => LikeC4MCPServerFactory;
 }
 //#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;
+//#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 langium.AstNode {
+  readonly $container: DynamicStepChain | DynamicViewBody | DynamicViewParallelSteps;
+  readonly $type: 'AbstractDynamicStep' | 'DynamicStepChain' | 'DynamicStepSingle';
+  custom?: CustomRelationProperties;
+  dotKind?: RelationKindDotRef;
+  kind?: langium.Reference<RelationshipKind>;
+  target: ElementRef;
+  title?: string;
+}
+declare const AbstractDynamicStep = "AbstractDynamicStep";
+interface ArrowProperty extends langium.AstNode {
+  readonly $container: CustomRelationProperties | RelationStyleProperty | SpecificationRelationshipKind;
+  readonly $type: 'ArrowProperty';
+  key: 'head' | 'tail';
+  value: ArrowType;
+}
+declare const ArrowProperty = "ArrowProperty";
+interface BorderProperty extends langium.AstNode {
+  readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleGroup | ViewRuleStyle;
+  readonly $type: 'BorderProperty';
+  key: 'border';
+  value: BorderStyleValue;
+}
+declare const BorderProperty = "BorderProperty";
+interface ColorProperty extends langium.AstNode {
+  readonly $container: CustomElementProperties | CustomRelationProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | RelationStyleProperty | SpecificationRelationshipKind | ViewRuleGroup | ViewRuleStyle;
+  readonly $type: 'ColorProperty';
+  customColor?: langium.Reference<CustomColor>;
+  key: 'color';
+  themeColor?: ThemeColor;
+}
+declare const ColorProperty = "ColorProperty";
+interface CustomColor extends langium.AstNode {
+  readonly $container: SpecificationColor;
+  readonly $type: 'CustomColor';
+  name: CustomColorId;
+}
+declare const CustomColor = "CustomColor";
+interface CustomElementProperties extends langium.AstNode {
+  readonly $container: FqnExprWith;
+  readonly $type: 'CustomElementProperties';
+  props: Array<ElementStringProperty | NavigateToProperty | NotationProperty | NotesProperty | StyleProperty>;
+}
+declare const CustomElementProperties = "CustomElementProperties";
+interface CustomRelationProperties extends langium.AstNode {
+  readonly $container: AbstractDynamicStep | RelationExprWith;
+  readonly $type: 'CustomRelationProperties';
+  props: Array<NotationProperty | NotesProperty | RelationNavigateToProperty | RelationStringProperty | RelationshipStyleProperty>;
+}
+declare const CustomRelationProperties = "CustomRelationProperties";
+interface DeployedInstance extends langium.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 langium.AstNode {
+  readonly $container: DeployedInstance;
+  readonly $type: 'DeployedInstanceBody';
+  elements: Array<DeploymentRelation>;
+  props: Array<ElementProperty>;
+  tags?: Tags;
+}
+declare const DeployedInstanceBody = "DeployedInstanceBody";
+interface DeploymentNode extends langium.AstNode {
+  readonly $container: DeploymentNodeBody | ExtendDeploymentBody | ModelDeployments;
+  readonly $type: 'DeploymentNode';
+  body?: DeploymentNodeBody;
+  kind: langium.Reference<DeploymentNodeKind>;
+  name: Id;
+  summary?: string;
+  title?: string;
+}
+declare const DeploymentNode = "DeploymentNode";
+interface DeploymentNodeBody extends langium.AstNode {
+  readonly $container: DeploymentNode;
+  readonly $type: 'DeploymentNodeBody';
+  elements: Array<DeployedInstance | DeploymentNode | DeploymentRelation>;
+  props: Array<ElementProperty>;
+  tags?: Tags;
+}
+declare const DeploymentNodeBody = "DeploymentNodeBody";
+interface DeploymentNodeKind extends langium.AstNode {
+  readonly $container: SpecificationDeploymentNodeKind;
+  readonly $type: 'DeploymentNodeKind';
+  name: Id;
+}
+declare const DeploymentNodeKind = "DeploymentNodeKind";
+interface DeploymentRelation extends langium.AstNode {
+  readonly $container: DeployedInstanceBody | DeploymentNodeBody | ExtendDeploymentBody | ModelDeployments;
+  readonly $type: 'DeploymentRelation';
+  body?: DeploymentRelationBody;
+  description?: string;
+  dotKind?: RelationKindDotRef;
+  kind?: langium.Reference<RelationshipKind>;
+  source?: FqnRef$2;
+  tags?: Tags;
+  target: FqnRef$2;
+  technology?: string;
+  title?: string;
+}
+declare const DeploymentRelation = "DeploymentRelation";
+interface DeploymentRelationBody extends langium.AstNode {
+  readonly $container: DeploymentRelation;
+  readonly $type: 'DeploymentRelationBody';
+  props: Array<RelationProperty>;
+  tags?: Tags;
+}
+declare const DeploymentRelationBody = "DeploymentRelationBody";
+interface DeploymentView extends langium.AstNode {
+  readonly $container: ModelViews;
+  readonly $type: 'DeploymentView';
+  body?: DeploymentViewBody;
+  name: Id;
+}
+declare const DeploymentView = "DeploymentView";
+interface DeploymentViewBody extends langium.AstNode {
+  readonly $container: DeploymentView;
+  readonly $type: 'DeploymentViewBody';
+  props: Array<ViewProperty>;
+  rules: Array<DeploymentViewRule>;
+  tags?: Tags;
+}
+declare const DeploymentViewBody = "DeploymentViewBody";
+interface DeploymentViewRulePredicate extends langium.AstNode {
+  readonly $container: DeploymentViewBody;
+  readonly $type: 'DeploymentViewRulePredicate';
+  expr: Expressions;
+  isInclude: boolean;
+}
+declare const DeploymentViewRulePredicate = "DeploymentViewRulePredicate";
+interface DeploymentViewRuleStyle extends langium.AstNode {
+  readonly $container: DeploymentViewBody;
+  readonly $type: 'DeploymentViewRuleStyle';
+  props: Array<NotationProperty | StyleProperty>;
+  targets: FqnExpressions;
+}
+declare const DeploymentViewRuleStyle = "DeploymentViewRuleStyle";
+interface DirectedRelationExpr extends langium.AstNode {
+  readonly $container: Expressions | RelationExprWhere | RelationExprWith;
+  readonly $type: 'DirectedRelationExpr';
+  source: OutgoingRelationExpr;
+  target: FqnExpr$2;
+}
+declare const DirectedRelationExpr = "DirectedRelationExpr";
+interface DynamicView extends langium.AstNode {
+  readonly $container: ModelViews;
+  readonly $type: 'DynamicView';
+  body?: DynamicViewBody;
+  name: Id;
+}
+declare const DynamicView = "DynamicView";
+interface DynamicViewBody extends langium.AstNode {
+  readonly $container: DynamicView;
+  readonly $type: 'DynamicViewBody';
+  props: Array<DynamicViewProperty>;
+  rules: Array<DynamicViewRule>;
+  steps: Array<DynamicViewParallelSteps | DynamicViewStep>;
+  tags?: Tags;
+}
+declare const DynamicViewBody = "DynamicViewBody";
+interface DynamicViewDisplayVariantProperty extends langium.AstNode {
+  readonly $container: DynamicViewBody;
+  readonly $type: 'DynamicViewDisplayVariantProperty';
+  key: 'variant';
+  value: DynamicViewDisplayVariantValue;
+}
+declare const DynamicViewDisplayVariantProperty = "DynamicViewDisplayVariantProperty";
+interface DynamicViewGlobalPredicateRef extends langium.AstNode {
+  readonly $container: DynamicViewBody;
+  readonly $type: 'DynamicViewGlobalPredicateRef';
+  predicate: langium.Reference<GlobalDynamicPredicateGroup>;
+}
+declare const DynamicViewGlobalPredicateRef = "DynamicViewGlobalPredicateRef";
+interface DynamicViewIncludePredicate extends langium.AstNode {
+  readonly $container: DynamicViewBody | GlobalDynamicPredicateGroup;
+  readonly $type: 'DynamicViewIncludePredicate';
+  exprs: Expressions;
+}
+declare const DynamicViewIncludePredicate = "DynamicViewIncludePredicate";
+interface DynamicViewParallelSteps extends langium.AstNode {
+  readonly $container: DynamicViewBody;
+  readonly $type: 'DynamicViewParallelSteps';
+  steps: Array<DynamicViewStep>;
+}
+declare const DynamicViewParallelSteps = "DynamicViewParallelSteps";
+interface DynamicViewRef extends langium.AstNode {
+  readonly $container: RelationNavigateToProperty;
+  readonly $type: 'DynamicViewRef';
+  view: langium.Reference<DynamicView>;
+}
+declare const DynamicViewRef = "DynamicViewRef";
+interface Element extends langium.AstNode {
+  readonly $container: ElementBody | ExtendElementBody | Model;
+  readonly $type: 'Element';
+  body?: ElementBody;
+  kind: langium.Reference<ElementKind>;
+  name: Id;
+  props: Array<string>;
+}
+declare const Element = "Element";
+interface ElementBody extends langium.AstNode {
+  readonly $container: Element;
+  readonly $type: 'ElementBody';
+  elements: Array<Element | Relation>;
+  props: Array<ElementProperty>;
+  tags?: Tags;
+}
+declare const ElementBody = "ElementBody";
+interface ElementKind extends langium.AstNode {
+  readonly $container: SpecificationElementKind;
+  readonly $type: 'ElementKind';
+  name: Id;
+}
+declare const ElementKind = "ElementKind";
+interface ElementKindExpression extends langium.AstNode {
+  readonly $container: DirectedRelationExpr | Expressions | FqnExprWhere | FqnExprWith | FqnExpressions | IncomingRelationExpr | OutgoingRelationExpr;
+  readonly $type: 'ElementKindExpression';
+  isEqual: boolean;
+  kind: langium.Reference<ElementKind>;
+}
+declare const ElementKindExpression = "ElementKindExpression";
+interface ElementRef extends langium.AstNode {
+  readonly $container: AbstractDynamicStep | DeployedInstance | DynamicStepSingle | ElementView;
+  readonly $type: 'ElementRef';
+  modelElement: FqnRef$2;
+}
+declare const ElementRef = "ElementRef";
+interface ElementStringProperty extends langium.AstNode {
+  readonly $container: CustomElementProperties | DeployedInstanceBody | DeploymentNodeBody | ElementBody;
+  readonly $type: 'ElementStringProperty';
+  key: 'description' | 'summary' | 'technology' | 'title';
+  value: MarkdownOrString;
+}
+declare const ElementStringProperty = "ElementStringProperty";
+interface ElementStyleProperty extends langium.AstNode {
+  readonly $container: DeployedInstanceBody | DeploymentNodeBody | ElementBody | SpecificationDeploymentNodeKind | SpecificationElementKind;
+  readonly $type: 'ElementStyleProperty';
+  key: 'style';
+  props: Array<StyleProperty>;
+}
+declare const ElementStyleProperty = "ElementStyleProperty";
+interface ElementTagExpression extends langium.AstNode {
+  readonly $container: DirectedRelationExpr | Expressions | FqnExprWhere | FqnExprWith | FqnExpressions | IncomingRelationExpr | OutgoingRelationExpr;
+  readonly $type: 'ElementTagExpression';
+  isEqual: boolean;
+  tag: TagRef;
+}
+declare const ElementTagExpression = "ElementTagExpression";
+interface ElementView extends langium.AstNode {
+  readonly $container: ModelViews;
+  readonly $type: 'ElementView';
+  body?: ElementViewBody;
+  extends?: ElementViewRef;
+  name?: Id;
+  viewOf?: ElementRef;
+}
+declare const ElementView = "ElementView";
+interface ElementViewBody extends langium.AstNode {
+  readonly $container: ElementView;
+  readonly $type: 'ElementViewBody';
+  props: Array<ViewProperty>;
+  rules: Array<ViewRule>;
+  tags?: Tags;
+}
+declare const ElementViewBody = "ElementViewBody";
+interface ElementViewRef extends langium.AstNode {
+  readonly $container: ElementView;
+  readonly $type: 'ElementViewRef';
+  view: langium.Reference<ElementView>;
+}
+declare const ElementViewRef = "ElementViewRef";
+interface Expressions extends langium.AstNode {
+  readonly $container: DeploymentViewRulePredicate | DynamicViewIncludePredicate | Expressions | ViewRulePredicate;
+  readonly $type: 'Expressions';
+  prev?: Expressions;
+  value: ExpressionV2;
+}
+declare const Expressions = "Expressions";
+interface ExtendDeployment extends langium.AstNode {
+  readonly $container: ModelDeployments;
+  readonly $type: 'ExtendDeployment';
+  body: ExtendDeploymentBody;
+  deploymentNode: StrictFqnRef;
+}
+declare const ExtendDeployment = "ExtendDeployment";
+interface ExtendDeploymentBody extends langium.AstNode {
+  readonly $container: ExtendDeployment;
+  readonly $type: 'ExtendDeploymentBody';
+  elements: Array<DeployedInstance | DeploymentNode | DeploymentRelation>;
+  props: Array<ExtendElementProperty>;
+  tags?: Tags;
+}
+declare const ExtendDeploymentBody = "ExtendDeploymentBody";
+interface ExtendElement extends langium.AstNode {
+  readonly $container: Model;
+  readonly $type: 'ExtendElement';
+  body: ExtendElementBody;
+  element: StrictFqnElementRef;
+}
+declare const ExtendElement = "ExtendElement";
+interface ExtendElementBody extends langium.AstNode {
+  readonly $container: ExtendElement;
+  readonly $type: 'ExtendElementBody';
+  elements: Array<Element | Relation>;
+  props: Array<ExtendElementProperty>;
+  tags?: Tags;
+}
+declare const ExtendElementBody = "ExtendElementBody";
+interface ExtendRelation extends langium.AstNode {
+  readonly $container: Model;
+  readonly $type: 'ExtendRelation';
+  body: ExtendRelationBody;
+  dotKind?: RelationKindDotRef;
+  kind?: langium.Reference<RelationshipKind>;
+  source: FqnRef$2;
+  target: FqnRef$2;
+  title?: string;
+}
+declare const ExtendRelation = "ExtendRelation";
+interface ExtendRelationBody extends langium.AstNode {
+  readonly $container: ExtendRelation;
+  readonly $type: 'ExtendRelationBody';
+  props: Array<ExtendRelationProperty>;
+  tags?: Tags;
+}
+declare const ExtendRelationBody = "ExtendRelationBody";
+interface FqnExpressions extends langium.AstNode {
+  readonly $container: DeploymentViewRuleStyle | FqnExpressions | GlobalStyle | ViewRuleRank | ViewRuleStyle;
+  readonly $type: 'FqnExpressions';
+  prev?: FqnExpressions;
+  value: FqnExpr$2;
+}
+declare const FqnExpressions = "FqnExpressions";
+interface FqnExprWhere extends langium.AstNode {
+  readonly $container: Expressions | FqnExprWith;
+  readonly $type: 'FqnExprWhere';
+  subject: FqnExpr$2;
+  where?: WhereElementExpression;
+}
+declare const FqnExprWhere = "FqnExprWhere";
+interface FqnExprWith extends langium.AstNode {
+  readonly $container: Expressions;
+  readonly $type: 'FqnExprWith';
+  custom?: CustomElementProperties;
+  subject: FqnExprOrWhere;
+}
+declare const FqnExprWith = "FqnExprWith";
+interface FqnRef$2 extends langium.AstNode {
+  readonly $container: DeploymentRelation | ElementRef | ExtendRelation | FqnRef$2 | FqnRefExpr | Relation;
+  readonly $type: 'FqnRef';
+  parent?: FqnRef$2;
+  value: langium.Reference<Referenceable>;
+}
+declare const FqnRef$2 = "FqnRef";
+interface FqnRefExpr extends langium.AstNode {
+  readonly $container: DirectedRelationExpr | Expressions | FqnExprWhere | FqnExprWith | FqnExpressions | IncomingRelationExpr | OutgoingRelationExpr;
+  readonly $type: 'FqnRefExpr';
+  ref: FqnRef$2;
+  selector?: string;
+}
+declare const FqnRefExpr = "FqnRefExpr";
+interface GlobalDynamicPredicateGroup extends langium.AstNode {
+  readonly $container: Globals;
+  readonly $type: 'GlobalDynamicPredicateGroup';
+  name: string;
+  predicates: Array<DynamicViewIncludePredicate>;
+}
+declare const GlobalDynamicPredicateGroup = "GlobalDynamicPredicateGroup";
+interface GlobalPredicateGroup extends langium.AstNode {
+  readonly $container: Globals;
+  readonly $type: 'GlobalPredicateGroup';
+  name: string;
+  predicates: Array<ViewRulePredicate>;
+}
+declare const GlobalPredicateGroup = "GlobalPredicateGroup";
+interface Globals extends langium.AstNode {
+  readonly $container: LikeC4Grammar;
+  readonly $type: 'Globals';
+  name: 'global';
+  predicates: Array<GlobalDynamicPredicateGroup | GlobalPredicateGroup>;
+  styles: Array<GlobalStyle | GlobalStyleGroup>;
+}
+declare const Globals = "Globals";
+interface GlobalStyle extends langium.AstNode {
+  readonly $container: Globals;
+  readonly $type: 'GlobalStyle';
+  id: GlobalStyleId;
+  props: Array<NotationProperty | StyleProperty>;
+  targets: FqnExpressions;
+}
+declare const GlobalStyle = "GlobalStyle";
+interface GlobalStyleGroup extends langium.AstNode {
+  readonly $container: Globals;
+  readonly $type: 'GlobalStyleGroup';
+  id: GlobalStyleId;
+  styles: Array<ViewRuleStyle>;
+}
+declare const GlobalStyleGroup = "GlobalStyleGroup";
+interface GlobalStyleId extends langium.AstNode {
+  readonly $container: GlobalStyle | GlobalStyleGroup;
+  readonly $type: 'GlobalStyleId';
+  name: string;
+}
+declare const GlobalStyleId = "GlobalStyleId";
+interface HexColor extends langium.AstNode {
+  readonly $container: SpecificationColor | SpecificationTag;
+  readonly $type: 'HexColor';
+  hex: number | string;
+}
+declare const HexColor = "HexColor";
+interface IconColorProperty extends langium.AstNode {
+  readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleStyle;
+  readonly $type: 'IconColorProperty';
+  customColor?: langium.Reference<CustomColor>;
+  key: 'iconColor';
+  themeColor?: ThemeColor;
+}
+declare const IconColorProperty = "IconColorProperty";
+interface IconPositionProperty extends langium.AstNode {
+  readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleStyle;
+  readonly $type: 'IconPositionProperty';
+  key: 'iconPosition';
+  value: IconPositionValue;
 }
-//#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): Promise<AstNodeDescription[]>;
-  private exportViews;
-  private exportGlobals;
-  private exportModel;
-  private exportLibrary;
-  private exportSpecification;
-  private exportDeployments;
-  computeLocalScopes(document: LikeC4LangiumDocument, _cancelToken?: CancellationToken): Promise<PrecomputedScopes>;
-  protected processContainer(container: ElementsContainer, scopes: PrecomputedScopes, document: LikeC4LangiumDocument): AstNodeDescription[];
-  protected processDeployments(container: DeploymentsContainer, scopes: PrecomputedScopes, document: LikeC4LangiumDocument): AstNodeDescription[];
+declare const IconPositionProperty = "IconPositionProperty";
+interface IconProperty extends langium.AstNode {
+  readonly $container: CustomElementProperties | DeployedInstanceBody | DeploymentNodeBody | DeploymentViewRuleStyle | ElementBody | ElementStyleProperty | GlobalStyle | ViewRuleStyle;
+  readonly $type: 'IconProperty';
+  key: 'icon';
+  libicon?: langium.Reference<LibIcon>;
+  value?: 'none' | Uri;
+}
+declare const IconProperty = "IconProperty";
+interface IconSizeProperty extends langium.AstNode {
+  readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleStyle;
+  readonly $type: 'IconSizeProperty';
+  key: 'iconSize';
+  value: SizeValue;
 }
-//#endregion
-//#region src/workspace/IndexManager.d.ts
-declare class IndexManager extends DefaultIndexManager {
-  protected services: LikeC4SharedServices;
-  constructor(services: LikeC4SharedServices);
-  updateContent(document: LangiumDocument, cancelToken?: CancellationToken): Promise<void>;
-  projectElements(projectId: ProjectId, nodeType?: string, uris?: Set<string>): Stream<AstNodeDescription>;
+declare const IconSizeProperty = "IconSizeProperty";
+interface Imported extends langium.AstNode {
+  readonly $container: Imported | ImportsFromPoject;
+  readonly $type: 'Imported';
+  imported: langium.Reference<Element>;
+  prev?: Imported;
+}
+declare const Imported = "Imported";
+interface ImportsFromPoject extends langium.AstNode {
+  readonly $container: LikeC4Grammar;
+  readonly $type: 'ImportsFromPoject';
+  imports: Imported;
+  project: string;
+}
+declare const ImportsFromPoject = "ImportsFromPoject";
+interface IncomingRelationExpr extends langium.AstNode {
+  readonly $container: Expressions | InOutRelationExpr | RelationExprWhere | RelationExprWith;
+  readonly $type: 'IncomingRelationExpr';
+  to: FqnExpr$2;
+}
+declare const IncomingRelationExpr = "IncomingRelationExpr";
+interface InOutRelationExpr extends langium.AstNode {
+  readonly $container: Expressions | RelationExprWhere | RelationExprWith;
+  readonly $type: 'InOutRelationExpr';
+  inout: IncomingRelationExpr;
+}
+declare const InOutRelationExpr = "InOutRelationExpr";
+interface LibIcon extends langium.AstNode {
+  readonly $container: LikeC4Lib;
+  readonly $type: 'LibIcon';
+  name: IconId;
+}
+declare const LibIcon = "LibIcon";
+interface LikeC4Grammar extends langium.AstNode {
+  readonly $type: 'LikeC4Grammar';
+  deployments: Array<ModelDeployments>;
+  globals: Array<Globals>;
+  imports: Array<ImportsFromPoject>;
+  likec4lib: Array<LikeC4Lib>;
+  models: Array<Model>;
+  specifications: Array<SpecificationRule>;
+  views: Array<ModelViews>;
+}
+declare const LikeC4Grammar = "LikeC4Grammar";
+interface LikeC4Lib extends langium.AstNode {
+  readonly $container: LikeC4Grammar;
+  readonly $type: 'LikeC4Lib';
+  icons: Array<LibIcon>;
+}
+declare const LikeC4Lib = "LikeC4Lib";
+interface LineProperty extends langium.AstNode {
+  readonly $container: CustomRelationProperties | RelationStyleProperty | SpecificationRelationshipKind;
+  readonly $type: 'LineProperty';
+  key: 'line';
+  value: LineOptions;
+}
+declare const LineProperty = "LineProperty";
+interface LinkProperty extends langium.AstNode {
+  readonly $container: DeployedInstanceBody | DeploymentNodeBody | DeploymentRelationBody | DeploymentViewBody | DynamicViewBody | ElementBody | ElementViewBody | ExtendDeploymentBody | ExtendElementBody | ExtendRelationBody | RelationBody | SpecificationDeploymentNodeKind | SpecificationElementKind;
+  readonly $type: 'LinkProperty';
+  key: 'link';
+  title?: string;
+  value: Uri;
+}
+declare const LinkProperty = "LinkProperty";
+interface MarkdownOrString extends langium.AstNode {
+  readonly $container: ElementStringProperty | MetadataArray | MetadataAttribute | NotationProperty | NotesProperty | RelationStringProperty | SpecificationElementStringProperty | SpecificationRelationshipStringProperty | ViewStringProperty;
+  readonly $type: 'MarkdownOrString';
+  markdown?: string;
+  text?: string;
+}
+declare const MarkdownOrString = "MarkdownOrString";
+interface MetadataArray extends langium.AstNode {
+  readonly $container: MetadataAttribute;
+  readonly $type: 'MetadataArray';
+  values: Array<MarkdownOrString>;
+}
+declare const MetadataArray = "MetadataArray";
+interface MetadataAttribute extends langium.AstNode {
+  readonly $container: MetadataBody;
+  readonly $type: 'MetadataAttribute';
+  key: string;
+  value: MetadataValue;
+}
+declare const MetadataAttribute = "MetadataAttribute";
+interface MetadataBody extends langium.AstNode {
+  readonly $container: DeployedInstanceBody | DeploymentNodeBody | DeploymentRelationBody | ElementBody | ExtendDeploymentBody | ExtendElementBody | ExtendRelationBody | RelationBody;
+  readonly $type: 'MetadataBody';
+  props: Array<MetadataAttribute>;
+}
+declare const MetadataBody = "MetadataBody";
+interface Model extends langium.AstNode {
+  readonly $container: LikeC4Grammar;
+  readonly $type: 'Model';
+  elements: Array<Element | ExtendElement | ExtendRelation | Relation>;
+  name: 'model';
+}
+declare const Model = "Model";
+interface ModelDeployments extends langium.AstNode {
+  readonly $container: LikeC4Grammar;
+  readonly $type: 'ModelDeployments';
+  elements: Array<DeploymentNode | DeploymentRelation | ExtendDeployment>;
+  name: 'deployment';
+}
+declare const ModelDeployments = "ModelDeployments";
+interface ModelViews extends langium.AstNode {
+  readonly $container: LikeC4Grammar;
+  readonly $type: 'ModelViews';
+  folder?: string;
+  name: 'views';
+  styles: Array<ViewRuleStyleOrGlobalRef>;
+  views: Array<LikeC4View>;
+}
+declare const ModelViews = "ModelViews";
+interface MultipleProperty extends langium.AstNode {
+  readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleStyle;
+  readonly $type: 'MultipleProperty';
+  key: 'multiple';
+  value: boolean;
+}
+declare const MultipleProperty = "MultipleProperty";
+interface NavigateToProperty extends langium.AstNode {
+  readonly $container: CustomElementProperties;
+  readonly $type: 'NavigateToProperty';
+  key: 'navigateTo';
+  value: ViewRef;
+}
+declare const NavigateToProperty = "NavigateToProperty";
+interface NotationProperty extends langium.AstNode {
+  readonly $container: CustomElementProperties | CustomRelationProperties | DeploymentViewRuleStyle | GlobalStyle | ViewRuleStyle;
+  readonly $type: 'NotationProperty';
+  key: 'notation';
+  value: MarkdownOrString;
+}
+declare const NotationProperty = "NotationProperty";
+interface NotesProperty extends langium.AstNode {
+  readonly $container: CustomElementProperties | CustomRelationProperties;
+  readonly $type: 'NotesProperty';
+  key: 'notes';
+  value: MarkdownOrString;
+}
+declare const NotesProperty = "NotesProperty";
+interface OpacityProperty extends langium.AstNode {
+  readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleGroup | ViewRuleStyle;
+  readonly $type: 'OpacityProperty';
+  key: 'opacity';
+  value: string;
+}
+declare const OpacityProperty = "OpacityProperty";
+interface OutgoingRelationExpr extends langium.AstNode {
+  readonly $container: DirectedRelationExpr | Expressions | RelationExprWhere | RelationExprWith;
+  readonly $type: 'OutgoingRelationExpr';
+  dotKind?: RelationKindDotRef;
+  from: FqnExpr$2;
+  isBidirectional: boolean;
+  kind?: langium.Reference<RelationshipKind>;
+}
+declare const OutgoingRelationExpr = "OutgoingRelationExpr";
+interface PaddingSizeProperty extends langium.AstNode {
+  readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleStyle;
+  readonly $type: 'PaddingSizeProperty';
+  key: 'padding';
+  value: SizeValue;
 }
-//#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): Stream<LikeC4LangiumDocument>;
-  groupedByProject(): Record<ProjectId, NonEmptyArray<LikeC4LangiumDocument>>;
-  /**
-   * Reset the project IDs of all documents.
-   */
-  resetProjectIds(): void;
+declare const PaddingSizeProperty = "PaddingSizeProperty";
+interface Relation extends langium.AstNode {
+  readonly $container: ElementBody | ExtendElementBody | Model;
+  readonly $type: 'Relation';
+  body?: RelationBody;
+  description?: string;
+  dotKind?: RelationKindDotRef;
+  kind?: langium.Reference<RelationshipKind>;
+  source?: FqnRef$2;
+  tags?: Tags;
+  target: FqnRef$2;
+  technology?: string;
+  title?: string;
+}
+declare const Relation = "Relation";
+interface RelationBody extends langium.AstNode {
+  readonly $container: Relation;
+  readonly $type: 'RelationBody';
+  props: Array<RelationProperty>;
+  tags?: Tags;
+}
+declare const RelationBody = "RelationBody";
+interface RelationExprWhere extends langium.AstNode {
+  readonly $container: Expressions | RelationExprWith;
+  readonly $type: 'RelationExprWhere';
+  subject: RelationExpr$1;
+  where?: WhereRelationExpression;
+}
+declare const RelationExprWhere = "RelationExprWhere";
+interface RelationExprWith extends langium.AstNode {
+  readonly $container: Expressions;
+  readonly $type: 'RelationExprWith';
+  custom?: CustomRelationProperties;
+  subject: RelationExprOrWhere;
+}
+declare const RelationExprWith = "RelationExprWith";
+interface RelationKindDotRef extends langium.AstNode {
+  readonly $container: AbstractDynamicStep | DeploymentRelation | ExtendRelation | OutgoingRelationExpr | Relation;
+  readonly $type: 'RelationKindDotRef';
+  kind: langium.Reference<RelationshipKind>;
+}
+declare const RelationKindDotRef = "RelationKindDotRef";
+interface RelationNavigateToProperty extends langium.AstNode {
+  readonly $container: CustomRelationProperties | DeploymentRelationBody | RelationBody;
+  readonly $type: 'RelationNavigateToProperty';
+  key: 'navigateTo';
+  value: DynamicViewRef;
+}
+declare const RelationNavigateToProperty = "RelationNavigateToProperty";
+interface RelationshipKind extends langium.AstNode {
+  readonly $container: SpecificationRelationshipKind;
+  readonly $type: 'RelationshipKind';
+  name: Id;
+}
+declare const RelationshipKind = "RelationshipKind";
+interface RelationStringProperty extends langium.AstNode {
+  readonly $container: CustomRelationProperties | DeploymentRelationBody | RelationBody;
+  readonly $type: 'RelationStringProperty';
+  key: 'description' | 'technology' | 'title';
+  value: MarkdownOrString;
+}
+declare const RelationStringProperty = "RelationStringProperty";
+interface RelationStyleProperty extends langium.AstNode {
+  readonly $container: DeploymentRelationBody | RelationBody;
+  readonly $type: 'RelationStyleProperty';
+  key: 'style';
+  props: Array<RelationshipStyleProperty>;
+}
+declare const RelationStyleProperty = "RelationStyleProperty";
+interface RGBAColor extends langium.AstNode {
+  readonly $container: SpecificationColor | SpecificationTag;
+  readonly $type: 'RGBAColor';
+  alpha?: number | string;
+  blue: number;
+  green: number;
+  red: number;
+}
+declare const RGBAColor = "RGBAColor";
+interface ShapeProperty extends langium.AstNode {
+  readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleStyle;
+  readonly $type: 'ShapeProperty';
+  key: 'shape';
+  value: ElementShape;
+}
+declare const ShapeProperty = "ShapeProperty";
+interface ShapeSizeProperty extends langium.AstNode {
+  readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleStyle;
+  readonly $type: 'ShapeSizeProperty';
+  key: 'size';
+  value: SizeValue;
 }
-//#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?: Cancellation.CancellationToken): Promise<void>;
-  get workspaceUri(): URI$2;
-  get workspaceURL(): URL;
+declare const ShapeSizeProperty = "ShapeSizeProperty";
+interface SpecificationColor extends langium.AstNode {
+  readonly $container: SpecificationRule;
+  readonly $type: 'SpecificationColor';
+  color: ColorLiteral$1;
+  name: CustomColor;
+}
+declare const SpecificationColor = "SpecificationColor";
+interface SpecificationDeploymentNodeKind extends langium.AstNode {
+  readonly $container: SpecificationRule;
+  readonly $type: 'SpecificationDeploymentNodeKind';
+  kind: DeploymentNodeKind;
+  props: Array<ElementStyleProperty | LinkProperty | SpecificationElementStringProperty>;
+  tags?: Tags;
+}
+declare const SpecificationDeploymentNodeKind = "SpecificationDeploymentNodeKind";
+interface SpecificationElementKind extends langium.AstNode {
+  readonly $container: SpecificationRule;
+  readonly $type: 'SpecificationElementKind';
+  kind: ElementKind;
+  props: Array<ElementStyleProperty | LinkProperty | SpecificationElementStringProperty>;
+  tags?: Tags;
+}
+declare const SpecificationElementKind = "SpecificationElementKind";
+interface SpecificationElementStringProperty extends langium.AstNode {
+  readonly $container: SpecificationDeploymentNodeKind | SpecificationElementKind;
+  readonly $type: 'SpecificationElementStringProperty';
+  key: 'description' | 'notation' | 'summary' | 'technology' | 'title';
+  value: MarkdownOrString;
+}
+declare const SpecificationElementStringProperty = "SpecificationElementStringProperty";
+interface SpecificationRelationshipKind extends langium.AstNode {
+  readonly $container: SpecificationRule;
+  readonly $type: 'SpecificationRelationshipKind';
+  kind: RelationshipKind;
+  props: Array<RelationshipStyleProperty | SpecificationRelationshipStringProperty>;
+}
+declare const SpecificationRelationshipKind = "SpecificationRelationshipKind";
+interface SpecificationRelationshipStringProperty extends langium.AstNode {
+  readonly $container: SpecificationRelationshipKind;
+  readonly $type: 'SpecificationRelationshipStringProperty';
+  key: 'notation' | 'technology';
+  value: MarkdownOrString;
+}
+declare const SpecificationRelationshipStringProperty = "SpecificationRelationshipStringProperty";
+interface SpecificationRule extends langium.AstNode {
+  readonly $container: LikeC4Grammar;
+  readonly $type: 'SpecificationRule';
+  colors: Array<SpecificationColor>;
+  deploymentNodes: Array<SpecificationDeploymentNodeKind>;
+  elements: Array<SpecificationElementKind>;
+  name: 'specification';
+  relationships: Array<SpecificationRelationshipKind>;
+  tags: Array<SpecificationTag>;
+}
+declare const SpecificationRule = "SpecificationRule";
+interface SpecificationTag extends langium.AstNode {
+  readonly $container: SpecificationRule;
+  readonly $type: 'SpecificationTag';
+  color?: ColorLiteral$1;
+  tag: Tag$1;
+}
+declare const SpecificationTag = "SpecificationTag";
+interface StrictFqnElementRef extends langium.AstNode {
+  readonly $container: ExtendElement | StrictFqnElementRef;
+  readonly $type: 'StrictFqnElementRef';
+  el: langium.Reference<Element>;
+  parent?: StrictFqnElementRef;
+}
+declare const StrictFqnElementRef = "StrictFqnElementRef";
+interface StrictFqnRef extends langium.AstNode {
+  readonly $container: ExtendDeployment | StrictFqnRef;
+  readonly $type: 'StrictFqnRef';
+  parent?: StrictFqnRef;
+  value: langium.Reference<Referenceable>;
+}
+declare const StrictFqnRef = "StrictFqnRef";
+interface Tag$1 extends langium.AstNode {
+  readonly $container: SpecificationTag;
+  readonly $type: 'Tag';
+  name: Id;
+}
+declare const Tag$1 = "Tag";
+interface TagRef extends langium.AstNode {
+  readonly $container: ElementTagExpression | Tags | WhereElementTag | WhereRelationParticipantTag | WhereRelationTag;
+  readonly $type: 'TagRef';
+  tag: langium.Reference<Tag$1>;
+}
+declare const TagRef = "TagRef";
+interface Tags extends langium.AstNode {
+  readonly $container: DeployedInstanceBody | DeploymentNodeBody | DeploymentRelation | DeploymentRelationBody | DeploymentViewBody | DynamicViewBody | ElementBody | ElementViewBody | ExtendDeploymentBody | ExtendElementBody | ExtendRelationBody | Relation | RelationBody | SpecificationDeploymentNodeKind | SpecificationElementKind | Tags;
+  readonly $type: 'Tags';
+  prev?: Tags;
+  values: Array<TagRef>;
+}
+declare const Tags = "Tags";
+interface TextSizeProperty extends langium.AstNode {
+  readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleStyle;
+  readonly $type: 'TextSizeProperty';
+  key: 'textSize';
+  value: SizeValue;
 }
+declare const TextSizeProperty = "TextSizeProperty";
+interface ViewRef extends langium.AstNode {
+  readonly $container: NavigateToProperty;
+  readonly $type: 'ViewRef';
+  view: langium.Reference<LikeC4View>;
+}
+declare const ViewRef = "ViewRef";
+interface ViewRuleAutoLayout extends langium.AstNode {
+  readonly $container: DeploymentViewBody | DynamicViewBody | ElementViewBody;
+  readonly $type: 'ViewRuleAutoLayout';
+  direction: ViewLayoutDirection;
+  nodeSep?: number;
+  rankSep?: number;
+}
+declare const ViewRuleAutoLayout = "ViewRuleAutoLayout";
+interface ViewRuleGlobalPredicateRef extends langium.AstNode {
+  readonly $container: ElementViewBody;
+  readonly $type: 'ViewRuleGlobalPredicateRef';
+  predicate: langium.Reference<GlobalPredicateGroup>;
+}
+declare const ViewRuleGlobalPredicateRef = "ViewRuleGlobalPredicateRef";
+interface ViewRuleGlobalStyle extends langium.AstNode {
+  readonly $container: DynamicViewBody | ElementViewBody | ModelViews;
+  readonly $type: 'ViewRuleGlobalStyle';
+  style: langium.Reference<GlobalStyleId>;
+}
+declare const ViewRuleGlobalStyle = "ViewRuleGlobalStyle";
+interface ViewRuleGroup extends langium.AstNode {
+  readonly $container: ElementViewBody | ViewRuleGroup;
+  readonly $type: 'ViewRuleGroup';
+  groupRules: Array<ViewRuleGroup | ViewRulePredicate>;
+  props: Array<BorderProperty | ColorProperty | OpacityProperty>;
+  title?: string;
+}
+declare const ViewRuleGroup = "ViewRuleGroup";
+interface ViewRulePredicate extends langium.AstNode {
+  readonly $container: ElementViewBody | GlobalPredicateGroup | ViewRuleGroup;
+  readonly $type: 'ViewRulePredicate';
+  exprs: Expressions;
+  isInclude: boolean;
+}
+declare const ViewRulePredicate = "ViewRulePredicate";
+interface ViewRuleRank extends langium.AstNode {
+  readonly $container: ElementViewBody;
+  readonly $type: 'ViewRuleRank';
+  targets: FqnExpressions;
+  value?: RankValue;
+}
+declare const ViewRuleRank = "ViewRuleRank";
+interface ViewRuleStyle extends langium.AstNode {
+  readonly $container: DynamicViewBody | ElementViewBody | GlobalStyleGroup | ModelViews;
+  readonly $type: 'ViewRuleStyle';
+  props: Array<NotationProperty | StyleProperty>;
+  targets: FqnExpressions;
+}
+declare const ViewRuleStyle = "ViewRuleStyle";
+interface ViewStringProperty extends langium.AstNode {
+  readonly $container: DeploymentViewBody | DynamicViewBody | ElementViewBody;
+  readonly $type: 'ViewStringProperty';
+  key: 'description' | 'title';
+  value: MarkdownOrString;
+}
+declare const ViewStringProperty = "ViewStringProperty";
+interface WhereBinaryExpression extends langium.AstNode {
+  readonly $container: FqnExprWhere | RelationExprWhere | WhereBinaryExpression | WhereElementNegation | WhereRelationNegation;
+  readonly $type: 'WhereBinaryExpression';
+  left: WhereElementExpression | WhereRelationExpression;
+  operator: 'and' | 'or';
+  right: WhereElementExpression | WhereRelationExpression;
+}
+declare const WhereBinaryExpression = "WhereBinaryExpression";
+interface WhereElementKind extends langium.AstNode {
+  readonly $container: FqnExprWhere | WhereBinaryExpression | WhereElementNegation;
+  readonly $type: 'WhereElementKind';
+  not: boolean;
+  operator: 'is' | string;
+  value: langium.Reference<DeploymentNodeOrElementKind>;
+}
+declare const WhereElementKind = "WhereElementKind";
+interface WhereElementNegation extends langium.AstNode {
+  readonly $container: FqnExprWhere | WhereBinaryExpression | WhereElementNegation;
+  readonly $type: 'WhereElementNegation';
+  value: WhereElementExpression;
+}
+declare const WhereElementNegation = "WhereElementNegation";
+interface WhereElementTag extends langium.AstNode {
+  readonly $container: FqnExprWhere | WhereBinaryExpression | WhereElementNegation;
+  readonly $type: 'WhereElementTag';
+  not: boolean;
+  operator: 'is' | string;
+  value: TagRef;
+}
+declare const WhereElementTag = "WhereElementTag";
+interface WhereRelationKind extends langium.AstNode {
+  readonly $container: RelationExprWhere | WhereBinaryExpression | WhereRelationNegation;
+  readonly $type: 'WhereRelationKind';
+  not: boolean;
+  operator: 'is' | string;
+  value: langium.Reference<RelationshipKind>;
+}
+declare const WhereRelationKind = "WhereRelationKind";
+interface WhereRelationNegation extends langium.AstNode {
+  readonly $container: RelationExprWhere | WhereBinaryExpression | WhereRelationNegation;
+  readonly $type: 'WhereRelationNegation';
+  value: WhereRelationExpression;
+}
+declare const WhereRelationNegation = "WhereRelationNegation";
+interface WhereRelationParticipantKind extends langium.AstNode {
+  readonly $container: RelationExprWhere | WhereBinaryExpression | WhereRelationNegation;
+  readonly $type: 'WhereRelationParticipantKind';
+  not: boolean;
+  operator: 'is' | string;
+  participant: Participant;
+  value: langium.Reference<DeploymentNodeOrElementKind>;
+}
+declare const WhereRelationParticipantKind = "WhereRelationParticipantKind";
+interface WhereRelationParticipantTag extends langium.AstNode {
+  readonly $container: RelationExprWhere | WhereBinaryExpression | WhereRelationNegation;
+  readonly $type: 'WhereRelationParticipantTag';
+  not: boolean;
+  operator: 'is' | string;
+  participant: Participant;
+  value: TagRef;
+}
+declare const WhereRelationParticipantTag = "WhereRelationParticipantTag";
+interface WhereRelationTag extends langium.AstNode {
+  readonly $container: RelationExprWhere | WhereBinaryExpression | WhereRelationNegation;
+  readonly $type: 'WhereRelationTag';
+  not: boolean;
+  operator: 'is' | string;
+  value: TagRef;
+}
+declare const WhereRelationTag = "WhereRelationTag";
+interface WildcardExpression extends langium.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/references/scope-provider.d.ts
-declare class LikeC4ScopeProvider extends DefaultScopeProvider {
-  protected deploymentsIndex: DeploymentsIndex;
-  protected fqnIndex: FqnIndex;
-  protected readonly indexManager: IndexManager;
+//#region src/validation/DocumentValidator.d.ts
+declare class LikeC4DocumentValidator extends DefaultDocumentValidator {
+  protected services: LikeC4Services;
   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.
+   * If the document is excluded, then we skip validation and return an empty array of diagnostics.
    */
-  protected getGlobalScope(referenceType: string, context: ReferenceInfo): Scope;
+  validateDocument(document: LangiumDocument, options?: ValidationOptions, cancelToken?: Cancellation.CancellationToken): Promise<Diagnostic[]>;
 }
 //#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): 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;
-}
+//#region src/validation/index.d.ts
+declare const isValidatableAstNode: any;
+type ValidatableAstNode = GuardedBy<typeof isValidatableAstNode>;
+declare function checksFromDiagnostics(doc: LikeC4LangiumDocument): {
+  isValid: (n: ValidatableAstNode) => boolean;
+  invalidNodes: WeakSet<WeakKey>;
+};
+type ChecksFromDiagnostics = ReturnType<typeof checksFromDiagnostics>;
+type IsValidFn = ChecksFromDiagnostics['isValid'];
 //#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;
-}
-interface LikeC4MCPServerModuleContext {
-  mcpServer: (services: LikeC4Services) => LikeC4MCPServer;
-  mcpServerFactory: (services: LikeC4Services) => LikeC4MCPServerFactory;
-}
-//#endregion
-//#region src/mcp/index.d.ts
-declare const NoMCPServer: LikeC4MCPServerModuleContext;
-//#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/utils/disposable.d.ts
-declare abstract class ADisposable implements Disposable {
-  protected toDispose: Disposable[];
-  protected isDisposed: boolean;
-  onDispose(...disposable: Disposable[]): 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;
-};
-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 | 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): 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): 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 | undefined, cancelToken?: CancellationToken): 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): 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/module.d.ts
-type LanguageServicesContext = Omit<DefaultSharedModuleContext, 'fileSystemProvider'> & FileSystemModuleContext & LikeC4MCPServerModuleContext & LikeC4ManualLayoutsModuleContext;
-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;
-  };
-}
-type LikeC4Services = LangiumServices & LikeC4AddedServices;
-/**
- * Most probably you don't need to use this function directly.
- * Use {@link createLanguageServices} instead.
- * @internal
- */
-declare function createLikeC4Module(context: LikeC4MCPServerModuleContext): Module<LikeC4Services, PartialLangiumServices & LikeC4AddedServices>;
-/**
- * Create and initialize likec4 language services with the given context
- * @example
- * ```ts
- * const { shared, likec4 } = createLanguageServices({
- *   ...WithFileSystem(enableWatcher = true),
- *   ...WithLikeC4ManualLayouts(),
- *   ...NoMcpServer(),
- * });
- * ```
- *
- * It is possible to extend/override the context with additional modules
- * See Langium documentation for more details (or at the CliContext in packages/likec4/src/language/module.ts).
- */
-declare function createLanguageServices(context: Partial<LanguageServicesContext>): {
-  shared: LikeC4SharedServices;
-  likec4: LikeC4Services;
-};
-declare function createLanguageServices(context: Partial<LanguageServicesContext>): {
-  shared: LikeC4SharedServices;
-  likec4: LikeC4Services;
-};
-declare function createLanguageServices<I1, I extends I1 & LikeC4Services>(context: Partial<LanguageServicesContext>, module: Module<I, I1> | undefined): {
-  shared: LikeC4SharedServices;
-  likec4: I;
-};
-declare function createLanguageServices<I1, I2, I extends I1 & I2 & LikeC4Services>(context: Partial<LanguageServicesContext>, module: Module<I, I1>, module2: Module<I, I2>): {
-  shared: LikeC4SharedServices;
-  likec4: I;
-};
-declare function createLanguageServices<I1, I2, I3, I extends I1 & I2 & I3 & LikeC4Services>(context: Partial<LanguageServicesContext>, module: Module<I, I1>, module2: Module<I, I2>, module3: Module<I, I3>): {
-  shared: LikeC4SharedServices;
-  likec4: I;
-};
-/**
- * Most probably you don't need to use this function directly.
- * Use {@link createLanguageServices} instead.
- * @internal
- */
-declare function createSharedServices(context?: Partial<LanguageServicesContext>): LikeC4SharedServices;
-//#endregion
-//#region src/validation/DocumentValidator.d.ts
-declare class LikeC4DocumentValidator extends DefaultDocumentValidator {
-  protected services: LikeC4Services;
-  constructor(services: LikeC4Services);
-  /**
-   * If the document is excluded, then we skip validation and return an empty array of diagnostics.
-   */
-  validateDocument(document: LangiumDocument, options?: ValidationOptions, cancelToken?: Cancellation.CancellationToken): 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 function checksFromDiagnostics(doc: LikeC4LangiumDocument): {
-  isValid: (n: ValidatableAstNode) => boolean;
-  invalidNodes: WeakSet<WeakKey>;
-};
-type ChecksFromDiagnostics = ReturnType<typeof checksFromDiagnostics>;
-type IsValidFn = ChecksFromDiagnostics['isValid'];
-//#endregion
-//#region src/ast.d.ts
-declare module 'langium' {
-  interface LangiumDocument {
-    likec4ProjectId?: c4.ProjectId;
-  }
-  interface AstNodeDescription {
-    likec4ProjectId?: c4.ProjectId;
-  }
+//#region src/ast.d.ts
+declare module 'langium' {
+  interface LangiumDocument {
+    likec4ProjectId?: c4.ProjectId;
+  }
+  interface AstNodeDescription {
+    likec4ProjectId?: c4.ProjectId;
+  }
 }
 declare const idattr: unique symbol;
 declare module './generated/ast' {
@@ -865,7 +1617,7 @@ interface ParsedAstElement {
   id: c4.Fqn;
   astPath: string;
   kind: c4.ElementKind;
-  title: string;
+  title?: string;
   summary?: c4.MarkdownOrString;
   description?: c4.MarkdownOrString;
   technology?: string;
@@ -960,14 +1712,6 @@ interface ParsedAstDeploymentView {
   manualLayout?: c4.ViewManualLayout;
 }
 type ParsedAstView = ParsedAstElementView | ParsedAstDynamicView | ParsedAstDeploymentView;
-declare const ViewOps: {
-  writeId<T extends LikeC4View>(node: T, id: c4.ViewId): T;
-  readId(node: LikeC4View): c4.ViewId | undefined;
-};
-declare const ElementOps: {
-  writeId(node: Element | DeploymentElement, id: c4.Fqn | null): Element | DeploymentElement;
-  readId(node: Element | DeploymentElement): any;
-};
 interface AstNodeDescriptionWithFqn extends AstNodeDescription {
   likec4ProjectId: c4.ProjectId;
   id: c4.Fqn;
@@ -995,36 +1739,155 @@ interface LikeC4LangiumDocument extends LikeC4GrammarDocument, LikeC4DocumentPro
 interface ParsedLikeC4LangiumDocument extends LikeC4GrammarDocument, Required<LikeC4DocumentProps> {
   likec4ProjectId: c4.ProjectId;
 }
-declare function isLikeC4LangiumDocument(doc: LangiumDocument): doc is LikeC4LangiumDocument;
-declare function isParsedLikeC4LangiumDocument(doc: LangiumDocument): doc is ParsedLikeC4LangiumDocument;
-declare function parseMarkdownAsString(node?: MarkdownOrString): string | undefined;
-declare function parseAstPercent(value: string): number;
-declare function parseAstOpacityProperty({
-  value
-}: OpacityProperty): number;
-declare function parseAstSizeValue({
-  value
-}: {
-  value: SizeValue;
-}): 'xs' | 'sm' | 'md' | 'lg' | 'xl';
-declare function parseAstIconPositionValue({
-  value
-}: {
-  value: IconPositionValue;
-}): c4.IconPosition;
-declare function toRelationshipStyle(props: RelationshipStyleProperty[] | undefined, isValid: IsValidFn): {
-  color?: c4.Color;
-  line?: c4.RelationshipLineType;
-  head?: c4.RelationshipArrowType;
-  tail?: c4.RelationshipArrowType;
-};
-declare function toColor(astNode: ColorProperty | IconColorProperty): c4.Color | undefined;
-declare function toAutoLayout(rule: ViewRuleAutoLayout): c4.ViewRuleAutoLayout;
-declare function toAstViewLayoutDirection(c4: c4.ViewRuleAutoLayout['direction']): ViewLayoutDirection;
-declare function getViewRulePredicateContainer<T extends AstNode>(el: T): ViewRulePredicate | DeploymentViewRulePredicate | DynamicViewIncludePredicate | undefined;
-declare function isFqnRefInsideGlobals(astNode: AstNode): boolean;
-declare function isFqnRefInsideModel(astNode: AstNode): boolean;
-declare function isFqnRefInsideDeployment(astNode: AstNode): boolean;
+//#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): Promise<AstNodeDescription[]>;
+  private exportViews;
+  private exportGlobals;
+  private exportModel;
+  private exportLibrary;
+  private exportSpecification;
+  private exportDeployments;
+  computeLocalScopes(document: LikeC4LangiumDocument, _cancelToken?: CancellationToken): 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): 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?: Cancellation.CancellationToken): Promise<void>;
+  get workspaceUri(): URI$2;
+  get workspaceURL(): URL;
+  /**
+   * Force clean all caches
+   */
+  forceCleanCaches(): void;
+  /**
+   * Register a listener to be called when caches are force cleaned
+   */
+  onForceCleanCache(listener: () => void): Disposable;
+}
+//#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 {
+  protected toDispose: Disposable[];
+  protected isDisposed: boolean;
+  onDispose(...disposable: Disposable[]): void;
+  dispose(): void;
+  protected throwIfDisposed(): void;
+}
 //#endregion
 //#region src/model/fqn-index.d.ts
 declare class FqnIndex<AstNd = Element> extends ADisposable {
@@ -1033,6 +1896,7 @@ 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;
@@ -1089,10 +1953,85 @@ declare class DocumentFqnIndex {
 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$1<c4.ProjectId, c4.Fqn, Set<c4.Fqn>>;
+  readonly projectId: c4.ProjectId | undefined;
+  constructor(docs: ReadonlyArray<ParsedLikeC4LangiumDocument>);
+  /**
+   * 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);
+  rememberSpecification(specification: MergedSpecification): MergedSpecification;
+  rememberModel<M extends LikeC4Model.Computed>(model: M): M;
+  specification(projectId: c4.ProjectId): MergedSpecification | undefined;
+  styles(projectId: c4.ProjectId): LikeC4Styles | 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 {
@@ -1117,16 +2056,30 @@ declare class LikeC4ModelLocator {
   private parser;
   private projects;
   constructor(services: LikeC4Services);
+  /**
+   * Returns the parsed documents
+   */
   private documents;
-  getParsedElement(...args: [Element] | [c4.Fqn] | [c4.Fqn, c4.ProjectId]): ParsedAstElement | null;
+  getParsedElement(...args: [Element] | [c4.Fqn] | [c4.Fqn, c4.ProjectId]): null | {
+    projectId: c4.ProjectId;
+    element: ParsedAstElement;
+    document: LangiumDocument;
+  };
+  private findParsedElementByFqnIn;
   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$2, cancelToken?: Cancellation.CancellationToken): Promise<Array<{
-    name: string;
-    color: string;
+  /**
+   * 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$2, cancelToken?: Cancellation.CancellationToken): Promise<null | Array<{
+    name: Tag;
+    color: c4.ColorLiteral;
     range: Range;
     isSpecification: boolean;
   }>>;
@@ -1137,57 +2090,96 @@ declare class LikeC4ModelLocator {
   }): Location | null;
 }
 //#endregion
-//#region src/filesystem/LikeC4FileSystem.d.ts
-declare const WithFileSystem: (ehableWatcher?: boolean) => FileSystemModuleContext;
-//#endregion
-//#region src/filesystem/LikeC4ManualLayouts.d.ts
-declare const WithLikeC4ManualLayouts: LikeC4ManualLayoutsModuleContext;
+//#region src/mcp/noop.d.ts
+declare const NoMCPServer: LikeC4MCPServerModuleContext;
 //#endregion
 //#region src/mcp/server/WithMCPServer.d.ts
 declare function WithMCPServer(type?: 'stdio' | 'sse' | {
   port: number;
 }): LikeC4MCPServerModuleContext;
 //#endregion
-//#region src/index.d.ts
-type StartLanguageServerOptions = {
+//#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 | 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): 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): Promise<GraphvizOut[]>;
   /**
-   * The Language Server Protocol connection to use.
+   * 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)
    */
-  connection?: Connection;
+  layoutView(params: LayoutViewParams): Promise<GraphvizOut | null>;
   /**
-   * Whether to enable the file system watcher.
-   * @default true
+   * Returns diagrams.
+   * If diagram has manual layout, it will be used.
+   * @param projectId - project id, if not specified - uses the default project
    */
-  enableWatcher?: boolean;
+  diagrams(projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<Array<DiagramView>>;
   /**
-   * @default true
+   * Returns all layouted views as Graphviz output (i.e. views with layout computed)
+   * @param projectId - project id, if not specified - uses the default project
    */
-  enableTelemetry?: boolean;
+  viewsAsGraphvizOut(projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<Array<GraphvizSvgOut>>;
   /**
-   * Whether to enable the MCP server.
-   * @default 'sse'
+   * 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
    */
-  enableMCP?: false | 'stdio' | 'sse' | {
-    port: number;
-  };
+  openView(viewId: ViewId, projectId?: ProjectId | undefined): Promise<void>;
   /**
-   * Whether to enable manual layouts, stored in json5 files.
-   * @default true
+   * Computes and layouts an adhoc view (not defined in the model)
+   *
+   * @param projectId - project id, if not specified - uses the default project
    */
-  enableManualLayouts?: boolean;
-};
-declare function startLanguageServer$1(options?: StartLanguageServerOptions): {
-  shared: LikeC4SharedServices;
-  likec4: LikeC4Services;
-};
+  adhocView(predicates: AdhocViewPredicate[], projectId?: ProjectId | undefined): Promise<LayoutedView>;
+}
 //#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): {
@@ -1200,11 +2192,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;
   /**
@@ -1291,9 +2283,12 @@ declare const DocumentParserFromMixins: {
     isValid: IsValidFn;
     readonly services: LikeC4Services;
     readonly doc: ParsedLikeC4LangiumDocument;
-    get project(): Project;
+    readonly project: Project;
+    logError(error: unknown, astNode?: langium.AstNode | langium.Reference<langium.AstNode>, level?: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification"): void;
+    tryParse<N extends langium.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 langium.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: langium0.AstNode): string;
+    getAstNodePath(node: langium.AstNode): string;
     getMetadata(metadataAstNode: MetadataProperty | undefined): {
       [key: string]: string | string[];
     } | undefined;
@@ -1304,11 +2299,11 @@ declare const DocumentParserFromMixins: {
     parseTags<E extends {
       tags?: Tags;
     }>(withTags?: E): ProjectId<ProjectId> | null;
-    convertLinks(source?: LinkProperty["$container"]): ProjectId[] | undefined;
-    parseLinks(source?: LinkProperty["$container"]): ProjectId[] | undefined;
+    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 | undefined;
+    parseColorLiteral(astNode: ColorLiteral$1): ProjectId | undefined;
     parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
     parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
     parseBaseProps(props: {
@@ -1391,9 +2386,12 @@ declare const DocumentParserFromMixins: {
     isValid: IsValidFn;
     readonly services: LikeC4Services;
     readonly doc: ParsedLikeC4LangiumDocument;
-    get project(): Project;
+    readonly project: Project;
+    logError(error: unknown, astNode?: langium.AstNode | langium.Reference<langium.AstNode>, level?: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification"): void;
+    tryParse<N extends langium.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 langium.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: langium0.AstNode): string;
+    getAstNodePath(node: langium.AstNode): string;
     getMetadata(metadataAstNode: MetadataProperty | undefined): {
       [key: string]: string | string[];
     } | undefined;
@@ -1404,11 +2402,11 @@ declare const DocumentParserFromMixins: {
     parseTags<E extends {
       tags?: Tags;
     }>(withTags?: E): ProjectId<ProjectId> | null;
-    convertLinks(source?: LinkProperty["$container"]): ProjectId[] | undefined;
-    parseLinks(source?: LinkProperty["$container"]): ProjectId[] | undefined;
+    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 | undefined;
+    parseColorLiteral(astNode: ColorLiteral$1): ProjectId | undefined;
     parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
     parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
     parseBaseProps(props: {
@@ -1446,9 +2444,12 @@ declare const DocumentParserFromMixins: {
     isValid: IsValidFn;
     readonly services: LikeC4Services;
     readonly doc: ParsedLikeC4LangiumDocument;
-    get project(): Project;
+    readonly project: Project;
+    logError(error: unknown, astNode?: langium.AstNode | langium.Reference<langium.AstNode>, level?: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification"): void;
+    tryParse<N extends langium.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 langium.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: langium0.AstNode): string;
+    getAstNodePath(node: langium.AstNode): string;
     getMetadata(metadataAstNode: MetadataProperty | undefined): {
       [key: string]: string | string[];
     } | undefined;
@@ -1459,11 +2460,11 @@ declare const DocumentParserFromMixins: {
     parseTags<E extends {
       tags?: Tags;
     }>(withTags?: E): ProjectId<ProjectId> | null;
-    convertLinks(source?: LinkProperty["$container"]): ProjectId[] | undefined;
-    parseLinks(source?: LinkProperty["$container"]): ProjectId[] | undefined;
+    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 | undefined;
+    parseColorLiteral(astNode: ColorLiteral$1): ProjectId | undefined;
     parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
     parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
     parseBaseProps(props: {
@@ -1516,9 +2517,12 @@ declare const DocumentParserFromMixins: {
     isValid: IsValidFn;
     readonly services: LikeC4Services;
     readonly doc: ParsedLikeC4LangiumDocument;
-    get project(): Project;
+    readonly project: Project;
+    logError(error: unknown, astNode?: langium.AstNode | langium.Reference<langium.AstNode>, level?: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification"): void;
+    tryParse<N extends langium.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 langium.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: langium0.AstNode): string;
+    getAstNodePath(node: langium.AstNode): string;
     getMetadata(metadataAstNode: MetadataProperty | undefined): {
       [key: string]: string | string[];
     } | undefined;
@@ -1529,11 +2533,11 @@ declare const DocumentParserFromMixins: {
     parseTags<E extends {
       tags?: Tags;
     }>(withTags?: E): ProjectId<ProjectId> | null;
-    convertLinks(source?: LinkProperty["$container"]): ProjectId[] | undefined;
-    parseLinks(source?: LinkProperty["$container"]): ProjectId[] | undefined;
+    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 | undefined;
+    parseColorLiteral(astNode: ColorLiteral$1): ProjectId | undefined;
     parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
     parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
     parseBaseProps(props: {
@@ -1579,9 +2583,12 @@ declare const DocumentParserFromMixins: {
     isValid: IsValidFn;
     readonly services: LikeC4Services;
     readonly doc: ParsedLikeC4LangiumDocument;
-    get project(): Project;
+    readonly project: Project;
+    logError(error: unknown, astNode?: langium.AstNode | langium.Reference<langium.AstNode>, level?: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification"): void;
+    tryParse<N extends langium.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 langium.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: langium0.AstNode): string;
+    getAstNodePath(node: langium.AstNode): string;
     getMetadata(metadataAstNode: MetadataProperty | undefined): {
       [key: string]: string | string[];
     } | undefined;
@@ -1592,11 +2599,11 @@ declare const DocumentParserFromMixins: {
     parseTags<E extends {
       tags?: Tags;
     }>(withTags?: E): ProjectId<ProjectId> | null;
-    convertLinks(source?: LinkProperty["$container"]): ProjectId[] | undefined;
-    parseLinks(source?: LinkProperty["$container"]): ProjectId[] | undefined;
+    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 | undefined;
+    parseColorLiteral(astNode: ColorLiteral$1): ProjectId | undefined;
     parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
     parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
     parseBaseProps(props: {
@@ -1650,9 +2657,12 @@ declare const DocumentParserFromMixins: {
     isValid: IsValidFn;
     readonly services: LikeC4Services;
     readonly doc: ParsedLikeC4LangiumDocument;
-    get project(): Project;
+    readonly project: Project;
+    logError(error: unknown, astNode?: langium.AstNode | langium.Reference<langium.AstNode>, level?: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification"): void;
+    tryParse<N extends langium.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 langium.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: langium0.AstNode): string;
+    getAstNodePath(node: langium.AstNode): string;
     getMetadata(metadataAstNode: MetadataProperty | undefined): {
       [key: string]: string | string[];
     } | undefined;
@@ -1663,11 +2673,11 @@ declare const DocumentParserFromMixins: {
     parseTags<E extends {
       tags?: Tags;
     }>(withTags?: E): ProjectId<ProjectId> | null;
-    convertLinks(source?: LinkProperty["$container"]): ProjectId[] | undefined;
-    parseLinks(source?: LinkProperty["$container"]): ProjectId[] | undefined;
+    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 | undefined;
+    parseColorLiteral(astNode: ColorLiteral$1): ProjectId | undefined;
     parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
     parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
     parseBaseProps(props: {
@@ -1715,9 +2725,12 @@ declare const DocumentParserFromMixins: {
     isValid: IsValidFn;
     readonly services: LikeC4Services;
     readonly doc: ParsedLikeC4LangiumDocument;
-    get project(): Project;
+    readonly project: Project;
+    logError(error: unknown, astNode?: langium.AstNode | langium.Reference<langium.AstNode>, level?: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification"): void;
+    tryParse<N extends langium.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 langium.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: langium0.AstNode): string;
+    getAstNodePath(node: langium.AstNode): string;
     getMetadata(metadataAstNode: MetadataProperty | undefined): {
       [key: string]: string | string[];
     } | undefined;
@@ -1728,11 +2741,11 @@ declare const DocumentParserFromMixins: {
     parseTags<E extends {
       tags?: Tags;
     }>(withTags?: E): ProjectId<ProjectId> | null;
-    convertLinks(source?: LinkProperty["$container"]): ProjectId[] | undefined;
-    parseLinks(source?: LinkProperty["$container"]): ProjectId[] | undefined;
+    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 | undefined;
+    parseColorLiteral(astNode: ColorLiteral$1): ProjectId | undefined;
     parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
     parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
     parseBaseProps(props: {
@@ -1758,9 +2771,12 @@ declare const DocumentParserFromMixins: {
     isValid: IsValidFn;
     readonly services: LikeC4Services;
     readonly doc: ParsedLikeC4LangiumDocument;
-    get project(): Project;
+    readonly project: Project;
+    logError(error: unknown, astNode?: langium.AstNode | langium.Reference<langium.AstNode>, level?: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification"): void;
+    tryParse<N extends langium.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 langium.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: langium0.AstNode): string;
+    getAstNodePath(node: langium.AstNode): string;
     getMetadata(metadataAstNode: MetadataProperty | undefined): {
       [key: string]: string | string[];
     } | undefined;
@@ -1771,11 +2787,11 @@ declare const DocumentParserFromMixins: {
     parseTags<E extends {
       tags?: Tags;
     }>(withTags?: E): ProjectId<ProjectId> | null;
-    convertLinks(source?: LinkProperty["$container"]): ProjectId[] | undefined;
-    parseLinks(source?: LinkProperty["$container"]): ProjectId[] | undefined;
+    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 | undefined;
+    parseColorLiteral(astNode: ColorLiteral$1): ProjectId | undefined;
     parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
     parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
     parseBaseProps(props: {
@@ -1817,9 +2833,12 @@ declare const DocumentParserFromMixins: {
     isValid: IsValidFn;
     readonly services: LikeC4Services;
     readonly doc: ParsedLikeC4LangiumDocument;
-    get project(): Project;
+    readonly project: Project;
+    logError(error: unknown, astNode?: langium.AstNode | langium.Reference<langium.AstNode>, level?: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification"): void;
+    tryParse<N extends langium.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 langium.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: langium0.AstNode): string;
+    getAstNodePath(node: langium.AstNode): string;
     getMetadata(metadataAstNode: MetadataProperty | undefined): {
       [key: string]: string | string[];
     } | undefined;
@@ -1830,11 +2849,11 @@ declare const DocumentParserFromMixins: {
     parseTags<E extends {
       tags?: Tags;
     }>(withTags?: E): ProjectId<ProjectId> | null;
-    convertLinks(source?: LinkProperty["$container"]): ProjectId[] | undefined;
-    parseLinks(source?: LinkProperty["$container"]): ProjectId[] | undefined;
+    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 | undefined;
+    parseColorLiteral(astNode: ColorLiteral$1): ProjectId | undefined;
     parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
     parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
     parseBaseProps(props: {
@@ -1871,6 +2890,24 @@ 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;
@@ -1878,6 +2915,7 @@ interface LikeC4LanguageServices {
   readonly workspaceUri: URI;
   readonly projectsManager: ProjectsManager;
   readonly editor: LikeC4ModelChanges;
+  readonly mcpServer: LikeC4MCPServer | null;
   /**
    * Returns all projects with relevant documents
    */
@@ -1936,43 +2974,134 @@ interface LikeC4LanguageServices {
   locate(params: Locate.Params): Locate.Res;
   dispose(): Promise<void>;
 }
-/**
- * Public Language Services
- */
-declare class DefaultLikeC4LanguageServices implements LikeC4LanguageServices {
+//#endregion
+//#region src/lsp/CodeLensProvider.d.ts
+declare class LikeC4CodeLensProvider implements CodeLensProvider {
   private services;
-  readonly builder: LikeC4ModelBuilder;
-  readonly editor: LikeC4ModelChanges;
-  readonly projectsManager: ProjectsManager;
   constructor(services: LikeC4Services);
-  get views(): LikeC4Views;
-  get workspaceUri(): URI;
-  projects(): NonEmptyArray<{
-    id: ProjectId;
-    folder: URI;
-    title: string;
-    documents: ReadonlyArray<URI>;
-    config: LikeC4ProjectConfig;
-  }>;
-  project(projectId?: ProjectId): {
-    id: ProjectId;
-    folder: URI;
-    title: string;
-    documents: ReadonlyArray<URI>;
-    config: LikeC4ProjectConfig;
+  provideCodeLens(doc: LangiumDocument, _params: CodeLensParams, cancelToken?: CancellationToken): 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[];
   };
-  diagrams(project?: ProjectId | undefined, cancelToken?: CancellationToken$2): Promise<LayoutedView<UnknownLayouted>[]>;
-  computedModel(project?: ProjectId | undefined, cancelToken?: CancellationToken$2): Promise<LikeC4Model<UnknownComputed>>;
-  layoutedModel(project?: ProjectId | undefined, cancelToken?: CancellationToken$2): Promise<LikeC4Model<UnknownLayouted>>;
-  projectsOverview(cancelToken?: CancellationToken$2): Promise<LayoutedProjectsView$1>;
-  getErrors(): Array<{
-    message: string;
-    line: number;
-    range: Range;
-    sourceFsPath: string;
-  }>;
-  locate(params: Locate.Params): Locate.Res;
-  dispose(): Promise<void>;
+  protected completionFor(context: CompletionContext, next: NextFeature, acceptor: CompletionAcceptor): MaybePromise<void>;
+  protected completionForKeyword(context: CompletionContext, keyword: GrammarAST.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): 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): 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 {
+  protected services: LikeC4Services;
+  private parser;
+  private locator;
+  constructor(services: LikeC4Services);
+  protected getAstNodeHoverContent(node: AstNode): MaybePromise<Hover | undefined>;
+  protected getElementHover(node: Element): MaybePromise<Hover | undefined>;
+  protected getElementModelHover(model: ElementModel, projectId: ProjectId): string | undefined;
+  protected getDeploymentNodeHover(node: DeploymentNode): MaybePromise<Hover | undefined>;
+  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
-export { createLikeC4Module as $, ParsedElementStyle as A, parseAstOpacityProperty as B, ParsedAstElementView as C, ParsedAstRelation as D, ParsedAstGlobals as E, isFqnRefInsideGlobals as F, toAutoLayout as G, parseAstSizeValue as H, isFqnRefInsideModel as I, LanguageServicesContext as J, toColor as K, isLikeC4LangiumDocument as L, ViewOps as M, getViewRulePredicateContainer as N, ParsedAstSpecification as O, isFqnRefInsideDeployment as P, createLanguageServices as Q, isParsedLikeC4LangiumDocument as R, ParsedAstElement as S, ParsedAstExtendRelation as T, parseMarkdownAsString as U, parseAstPercent as V, toAstViewLayoutDirection as W, LikeC4Services as X, LikeC4AddedServices as Y, LikeC4SharedServices as Z, LikeC4LangiumDocument as _, LikeC4ManualLayoutsModuleContext as _t, startLanguageServer$1 as a, LikeC4MCPServerModuleContext as at, ParsedAstDeploymentView as b, ProjectsManager as bt, WithFileSystem as c, NoFileSystem as ct, LikeC4ModelBuilder as d, FileNode as dt, createSharedServices as et, FqnIndex as f, FileSystemModuleContext as ft, LikeC4DocumentProps as g, LikeC4ManualLayouts as gt, LikeC4AstNode as h, FileSystemWatcherModuleContext as ht, LikeC4ModelParser as i, LikeC4MCPServerFactory as it, ParsedLikeC4LangiumDocument as j, ParsedAstView as k, LikeC4ModelLocator as l, NoFileSystemWatcher as lt, ElementOps as m, FileSystemWatcher as mt, LikeC4LanguageServices as n, NoMCPServer as nt, WithMCPServer as o, LikeC4WorkspaceManager as ot, AstNodeDescriptionWithFqn as p, FileSystemProvider$1 as pt, toRelationshipStyle as q, DocumentParser as r, LikeC4MCPServer as rt, WithLikeC4ManualLayouts as s, LangiumDocuments as st, DefaultLikeC4LanguageServices as t, LikeC4Views as tt, ViewLocateResult as u, NoLikeC4ManualLayouts as ut, ParsedAstDeployment as v, Project as vt, ParsedAstExtend as w, ParsedAstDynamicView as x, ParsedAstDeploymentRelation as y, ProjectData as yt, parseAstIconPositionValue as z };
+//#region src/shared/WorkspaceSymbolProvider.d.ts
+declare class WorkspaceSymbolProvider extends DefaultWorkspaceSymbolProvider {}
+//#endregion
+export { ProjectsManager as $, LikeC4ScopeComputation as A, NoFileSystem as B, LastSeenArtifacts as C, LikeC4WorkspaceManager as D, LikeC4ScopeProvider as E, LikeC4MCPServerModuleContext as F, FileSystemProvider$1 as G, NoLikeC4ManualLayouts as H, LikeC4Formatter as I, LikeC4ManualLayouts as J, FileSystemWatcher as K, WithLikeC4ManualLayouts as L, LikeC4DocumentValidator as M, LikeC4MCPServer as N, LangiumDocuments as O, LikeC4MCPServerFactory as P, ProjectData as Q, WithChokidarWatcher as R, LikeC4ModelBuilder as S, FqnIndex as T, FileNode as U, NoFileSystemWatcher as V, FileSystemModuleContext as W, ManualLayoutsSnapshot as X, LikeC4ManualLayoutsModuleContext as Y, Project as Z, LikeC4Views as _, LikeC4CodeActionProvider as a, LikeC4ModelLocator as b, LikeC4DocumentLinkProvider as c, LikeC4CodeLensProvider as d, LikeC4DocumentationProvider as et, LikeC4LanguageServices as f, LikeC4ModelParser as g, DocumentParser as h, LikeC4SemanticTokenProvider as i, LikeC4NameProvider as j, IndexManager as k, LikeC4DocumentHighlightProvider as l, LikeC4ValueConverter as m, NodeKindProvider$1 as n, LikeC4HoverProvider as o, LikeC4ModelChanges as p, FileSystemWatcherModuleContext as q, Rpc as r, LikeC4DocumentSymbolProvider as s, WorkspaceSymbolProvider as t, LikeC4CompletionProvider as u, WithMCPServer as v, DeploymentsIndex as w, ViewLocateResult as x, NoMCPServer as y, WithFileSystem as z };