@likec4/language-server 1.47.0 → 1.48.0

package/dist/_chunks/LikeC4LanguageServices.d.mts

@@ -0,0 +1,1978 @@
+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 { 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 { GraphvizLayouter, QueueGraphvizLayoter } from "@likec4/layouts";
+import { AdhocViewPredicate, LayoutedProjectsView as LayoutedProjectsView$1 } from "@likec4/core/compute-view";
+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 { CancellationToken as CancellationToken$2 } from "vscode-jsonrpc";
+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 {
+  private parser;
+  private locator;
+  constructor(services: LikeC4Services);
+  getDocumentation(node: AstNode): string | undefined;
+}
+//#endregion
+//#region src/workspace/ProjectsManager.d.ts
+/**
+ * A tagged string that represents a project folder URI
+ * Always has trailing slash.
+ */
+type ProjectFolder = Tagged<string, 'ProjectFolder'>;
+declare function ProjectFolder(folder: URI | string): ProjectFolder;
+interface ProjectData {
+  id: ProjectId$1;
+  config: LikeC4ProjectConfig;
+  folder: ProjectFolder;
+  folderUri: URI;
+  exclude?: {
+    (test: string): boolean;
+  };
+  /**
+   * Resolved include paths with both URI and folder string representations.
+   * These are additional directories that are part of this project.
+   */
+  includePaths?: NonEmptyArray<{
+    uri: URI;
+    folder: ProjectFolder;
+  }>;
+  /**
+   * Normalized include configuration (paths, maxDepth, fileThreshold).
+   */
+  includeConfig: IncludeConfig;
+}
+interface Project {
+  id: ProjectId$1;
+  folderUri: URI;
+  config: LikeC4ProjectConfig;
+  /**
+   * Resolved include paths as URIs (if configured).
+   */
+  includePaths?: NonEmptyReadonlyArray<URI>;
+}
+declare class ProjectsManager {
+  #private;
+  protected services: LikeC4SharedServices;
+  /**
+   * The global project ID used for all documents
+   * that are not part of a specific project.
+   */
+  static readonly DefaultProjectId: ProjectId$1;
+  constructor(services: LikeC4SharedServices);
+  /**
+   * Returns:
+   *  - configured default project ID if set
+   *  - the default project ID if there are no projects.
+   *  - the ID of the only project
+   *  - undefined if there are multiple projects.
+   */
+  get defaultProjectId(): ProjectId$1 | undefined;
+  set defaultProjectId(id: string | ProjectId$1 | undefined);
+  get default(): ProjectData;
+  get all(): NonEmptyReadonlyArray<ProjectId$1>;
+  getProject(arg: ProjectId$1 | LangiumDocument): Project;
+  /**
+   * Returns all projects that include the specified folder, or inside the folder.
+   */
+  findAllProjectsByFolder(folder: URI | string): ProjectData[];
+  /**
+   * Validates and ensures the project ID.
+   * If no project ID is specified, returns default project ID
+   * If there are multiple projects and default project is not set, throws an error
+   */
+  ensureProjectId(projectId?: ProjectId$1 | undefined): ProjectId$1;
+  /**
+   * Validates and ensures the project.
+   */
+  ensureProject(projectId?: ProjectId$1 | undefined): Project;
+  hasMultipleProjects(): boolean;
+  /**
+   * Checks if the specified document should be excluded from processing.
+   */
+  isExcluded(document: LangiumDocument | URI | string): boolean;
+  /**
+   * Checks if the specified document is included by the project:
+   * - if the document belongs to the project and is not excluded
+   * - if the document is included by the project
+   */
+  isIncluded(projectId: ProjectId$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>;
+  /**
+   * 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>;
+  /**
+   * 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;
+  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>;
+  /**
+   * Returns all include paths from all projects.
+   * Used by WorkspaceManager to scan additional directories for C4 files.
+   */
+  getAllIncludePaths(): Array<{
+    projectId: ProjectId$1;
+    includePath: URI;
+    includeConfig: IncludeConfig;
+  }>;
+  /**
+   * Register a listener to be called when the projects configuration has changed.
+   * @returns A disposable that can be used to unregister the callback.
+   */
+  onProjectsUpdate(callback: () => void): Disposable;
+  private getWorkspaceFolder;
+  private notifyListeners;
+}
+//#endregion
+//#region src/filesystem/types.d.ts
+interface FileNode extends FileSystemNode {
+  readonly isFile: true;
+  readonly isDirectory: false;
+}
+interface FileSystemProvider$1 extends FileSystemProvider {
+  /**
+   * Scans the project files for the given URI.
+   * @returns The list of file system entries that are contained within the specified directory.
+   */
+  scanProjectFiles(folderUri: URI): Promise<FileNode[]>;
+  /**
+   * Loads the project config from the given file.
+   * @returns The project config.
+   */
+  loadProjectConfig(filepath: URI): Promise<LikeC4ProjectConfig>;
+  /**
+   * Reads the directory information for the given URI.
+   * @param options.recursive If true, recursively reads the directory,
+   * @param options.maxDepth Maximum depth to traverse when recursive is true (default: Infinity)
+   */
+  readDirectory(uri: URI, options?: {
+    recursive?: boolean;
+    maxDepth?: number;
+  }): Promise<FileNode[]>;
+  /**
+   * Finds all files in the given directory, matching the given filter.
+   */
+  scanDirectory(directory: URI, filter: (filepath: string) => boolean): Promise<FileNode[]>;
+  /**
+   * Writes the content to the file system.
+   * Used by manual layouts.
+   */
+  writeFile(uri: URI, content: string): Promise<void>;
+  /**
+   * Deletes the file from the file system.
+   * Used by manual layouts.
+   * @return true if the file was deleted, false if the file did not exist.
+   */
+  deleteFile(uri: URI): Promise<boolean>;
+}
+interface FileSystemModuleContext extends FileSystemWatcherModuleContext {
+  fileSystemProvider: () => FileSystemProvider$1;
+}
+interface FileSystemWatcherModuleContext {
+  fileSystemWatcher: (services: LikeC4SharedServices) => FileSystemWatcher;
+}
+interface FileSystemWatcher extends AsyncDisposable {
+  /**
+   * Watches a folder for changes and triggers a reload of the documents and projects.
+   */
+  watch(folder: string): void;
+}
+interface LikeC4ManualLayoutsModuleContext {
+  manualLayouts: (services: LikeC4SharedServices) => LikeC4ManualLayouts;
+}
+interface LikeC4ManualLayouts {
+  read(project: Project): Promise<Record<ViewId$1, LayoutedView$1> | null>;
+  write(project: Project, layouted: LayoutedView$1): Promise<Location>;
+  remove(project: Project, view: ViewId$1): Promise<Location | null>;
+  clearCaches(): void;
+}
+//#endregion
+//#region src/filesystem/noop.d.ts
+declare const NoFileSystemWatcher: FileSystemWatcherModuleContext;
+declare const NoFileSystem: FileSystemModuleContext;
+declare const NoLikeC4ManualLayouts: LikeC4ManualLayoutsModuleContext;
+//#endregion
+//#region src/formatting/LikeC4Formatter.d.ts
+type QuoteStyle = 'single' | 'double' | 'ignore' | 'auto';
+interface LikeC4FormatterOptions {
+  quoteStyle: QuoteStyle;
+}
+type ExtendedFormattingCommandType = 'normalizeQuotes';
+interface ExtendedFormattingCommand {
+  type: ExtendedFormattingCommandType;
+  region: FormattingRegion;
+}
+declare class LikeC4Formatter extends AbstractFormatter {
+  protected options: LikeC4FormatterOptions;
+  extendedFormattingCommands: ExtendedFormattingCommand[];
+  constructor(services: LikeC4Services);
+  protected doDocumentFormat(document: LangiumDocument, options: FormattingOptions, range?: Range): TextEdit[];
+  protected format(node: AstNode): void;
+  protected formatTags(node: AstNode): void;
+  protected formatDeploymentRelation(node: AstNode): void;
+  protected formatExtendDeployment(node: AstNode): void;
+  protected formatRelation(node: AstNode): void;
+  protected removeIndentFromTopLevelStatements(node: AstNode): void;
+  protected indentContentInBraces(node: AstNode): void;
+  protected appendKeywordsWithSpace(node: AstNode): void;
+  protected formatView(node: AstNode): void;
+  protected formatLeafProperty(node: AstNode): void;
+  protected formatLinkProperty(node: AstNode): void;
+  protected formatNavigateToProperty(node: AstNode): void;
+  protected formatAutolayoutProperty(node: AstNode): void;
+  protected formatMetadataProperty(node: AstNode): void;
+  protected formatElementDeclaration(node: AstNode): void;
+  protected formatExtendElement(node: AstNode): void;
+  protected formatGlobals(node: AstNode): void;
+  protected formatImports(node: AstNode): void;
+  protected formatSpecificationRule(node: AstNode): void;
+  protected formatWithPredicate(node: AstNode): void;
+  protected formatDeploymentNodeDeclaration(node: AstNode): void;
+  protected formatDeployedInstance(node: AstNode): void;
+  protected formatViewRuleGlobalStyle(node: AstNode): void;
+  protected formatViewRuleGlobalPredicate(node: AstNode): void;
+  protected formatViewRuleGroup(node: AstNode): void;
+  protected formatViewRuleStyle(node: AstNode): void;
+  protected formatWhereExpression(node: AstNode): void;
+  protected formatWhereRelationExpression(node: AstNode): void;
+  protected formatWhereElementExpression(node: AstNode): void;
+  protected formatIncludeExcludeExpressions(node: AstNode): void;
+  protected formatRelationExpression(node: AstNode): void;
+  private findPredicateExpressionRoot;
+  private on;
+  private doExtendedFormatting;
+  protected normalizeQuotes(node: AstNode): void;
+  private quotesNormalizerFactory;
+  private escapeQuotesInternalQuotes;
+  private getAutoQuoteStyle;
+  private onConfigurationUpdate;
+}
+//#endregion
+//#region src/lsp/CodeLensProvider.d.ts
+declare class LikeC4CodeLensProvider implements CodeLensProvider {
+  private services;
+  constructor(services: LikeC4Services);
+  provideCodeLens(doc: LangiumDocument, _params: CodeLensParams, cancelToken?: CancellationToken): 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;
+}
+//#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/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);
+  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;
+}
+//#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;
+}
+//#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/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 {
+  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;
+  }
+}
+declare const idattr: unique symbol;
+declare module './generated/ast' {
+  interface Element {
+    [idattr]?: c4.Fqn | undefined;
+  }
+  interface ElementView {
+    [idattr]?: c4.ViewId | undefined;
+  }
+  interface DynamicView {
+    [idattr]?: c4.ViewId | undefined;
+  }
+  interface DeploymentView {
+    [idattr]?: c4.ViewId | undefined;
+  }
+  interface DeploymentNode {
+    [idattr]?: c4.Fqn | undefined;
+  }
+  interface DeployedInstance {
+    [idattr]?: c4.Fqn | undefined;
+  }
+}
+type ParsedElementStyle = {
+  shape?: c4.ElementShape;
+  icon?: c4.IconUrl;
+  iconColor?: c4.Color;
+  iconSize?: c4.ShapeSize;
+  iconPosition?: c4.IconPosition;
+  color?: c4.Color;
+  border?: c4.BorderStyle;
+  opacity?: number;
+  multiple?: boolean;
+  size?: c4.ShapeSize;
+  padding?: c4.SpacingSize;
+  textSize?: c4.TextSize;
+};
+interface ParsedAstSpecification {
+  tags: Record<c4.Tag, {
+    astPath: string;
+    color?: c4.ColorLiteral;
+  }>;
+  elements: Record<c4.ElementKind, c4.ElementSpecification>;
+  relationships: Record<c4.RelationshipKind, {
+    technology?: string;
+    notation?: string;
+    color?: c4.Color;
+    line?: c4.RelationshipLineType;
+    head?: c4.RelationshipArrowType;
+    tail?: c4.RelationshipArrowType;
+  }>;
+  colors: Record<c4.CustomColor, {
+    color: c4.ColorLiteral;
+  }>;
+  deployments: Record<c4.DeploymentKind, c4.ElementSpecification>;
+}
+interface ParsedAstElement {
+  id: c4.Fqn;
+  astPath: string;
+  kind: c4.ElementKind;
+  title: string;
+  summary?: c4.MarkdownOrString;
+  description?: c4.MarkdownOrString;
+  technology?: string;
+  tags?: c4.NonEmptyArray<c4.Tag>;
+  links?: c4.NonEmptyArray<c4.Link>;
+  style: ParsedElementStyle;
+  metadata?: {
+    [key: string]: string | string[];
+  };
+}
+interface ParsedAstExtend {
+  id: c4.Fqn;
+  astPath: string;
+  tags?: c4.NonEmptyArray<c4.Tag> | null;
+  links?: c4.NonEmptyArray<c4.Link> | null;
+  metadata?: {
+    [key: string]: string | string[];
+  };
+}
+interface ParsedAstExtendRelation {
+  id: c4.RelationId;
+  astPath: string;
+  tags?: c4.NonEmptyArray<c4.Tag> | null;
+  links?: c4.NonEmptyArray<c4.Link> | null;
+  metadata?: {
+    [key: string]: string | string[];
+  };
+}
+interface ParsedAstRelation {
+  id: c4.RelationId;
+  astPath: string;
+  source: c4.FqnRef.ModelRef;
+  target: c4.FqnRef.ModelRef;
+  kind?: c4.RelationshipKind;
+  tags?: c4.NonEmptyArray<c4.Tag>;
+  title: string;
+  description?: c4.MarkdownOrString;
+  technology?: string;
+  color?: c4.Color;
+  line?: c4.RelationshipLineType;
+  head?: c4.RelationshipArrowType;
+  tail?: c4.RelationshipArrowType;
+  links?: c4.NonEmptyArray<c4.Link>;
+  navigateTo?: c4.ViewId;
+  metadata?: {
+    [key: string]: string | string[];
+  };
+}
+type ParsedAstDeployment = Simplify<MergeExclusive<ParsedAstDeployment.Node, ParsedAstDeployment.Instance>>;
+declare namespace ParsedAstDeployment {
+  type Node = c4.DeploymentNode;
+  type Instance = Omit<c4.DeployedInstance, 'element'> & {
+    readonly element: c4.FqnRef.ModelRef;
+  };
+}
+type ParsedAstDeploymentRelation = c4.DeploymentRelationship & {
+  astPath: string;
+};
+type ParsedAstGlobals = Writable<c4.ModelGlobals>;
+interface ParsedAstElementView {
+  id: c4.ViewId;
+  viewOf?: c4.Fqn;
+  extends?: c4.ViewId;
+  astPath: string;
+  title: string | null;
+  description: c4.MarkdownOrString | null;
+  tags: c4.NonEmptyArray<c4.Tag> | null;
+  links: c4.NonEmptyArray<c4.Link> | null;
+  rules: c4.ElementViewRule[];
+  manualLayout?: c4.ViewManualLayout;
+}
+interface ParsedAstDynamicView {
+  id: c4.ViewId;
+  astPath: string;
+  title: string | null;
+  description: c4.MarkdownOrString | null;
+  tags: c4.NonEmptyArray<c4.Tag> | null;
+  links: c4.NonEmptyArray<c4.Link> | null;
+  steps: c4.DynamicViewStep[];
+  rules: Array<c4.DynamicViewRule>;
+  variant: c4.DynamicViewDisplayVariant | undefined;
+  manualLayout?: c4.ViewManualLayout;
+}
+interface ParsedAstDeploymentView {
+  id: c4.ViewId;
+  astPath: string;
+  title: string | null;
+  description: c4.MarkdownOrString | null;
+  tags: c4.NonEmptyArray<c4.Tag> | null;
+  links: c4.NonEmptyArray<c4.Link> | null;
+  rules: Array<c4.DeploymentViewRule>;
+  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;
+}
+type LikeC4AstNode = ValueOf<ConditionalPick<LikeC4AstType, AstNode>>;
+type LikeC4DocumentDiagnostic = Diagnostic & DiagnosticInfo<LikeC4AstNode>;
+interface LikeC4DocumentProps {
+  diagnostics?: Array<LikeC4DocumentDiagnostic>;
+  c4Specification?: ParsedAstSpecification;
+  c4Elements?: ParsedAstElement[];
+  c4ExtendElements?: ParsedAstExtend[];
+  c4ExtendDeployments?: ParsedAstExtend[];
+  c4ExtendRelations?: ParsedAstExtendRelation[];
+  c4Relations?: ParsedAstRelation[];
+  c4Globals?: ParsedAstGlobals;
+  c4Views?: ParsedAstView[];
+  c4Deployments?: ParsedAstDeployment[];
+  c4DeploymentRelations?: ParsedAstDeploymentRelation[];
+  c4Imports?: MultiMap$1<c4.ProjectId, c4.Fqn, Set<c4.Fqn>>;
+}
+type LikeC4GrammarDocument = Omit<LangiumDocument<LikeC4Grammar>, 'diagnostics'>;
+interface LikeC4LangiumDocument extends LikeC4GrammarDocument, LikeC4DocumentProps {
+  likec4ProjectId: c4.ProjectId;
+}
+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/model/fqn-index.d.ts
+declare class FqnIndex<AstNd = Element> extends ADisposable {
+  protected services: LikeC4Services;
+  protected projects: ProjectsManager;
+  protected langiumDocuments: LangiumDocuments;
+  protected documentCache: DefaultWeakMap<LikeC4LangiumDocument, DocumentFqnIndex>;
+  protected workspaceCache: WorkspaceCache<string, AstNodeDescriptionWithFqn[]>;
+  constructor(services: LikeC4Services);
+  private documents;
+  get(document: LikeC4LangiumDocument): DocumentFqnIndex;
+  resolve(reference: Referenceable): Fqn$1;
+  getFqn(el: AstNd): Fqn$1;
+  byFqn(projectId: ProjectId$1, fqn: Fqn$1): Stream<AstNodeDescriptionWithFqn>;
+  rootElements(projectId: ProjectId$1): Stream<AstNodeDescriptionWithFqn>;
+  directChildrenOf(projectId: ProjectId$1, parent: Fqn$1): Stream<AstNodeDescriptionWithFqn>;
+  /**
+   * Returns descedant elements with unique names in the scope
+   */
+  uniqueDescedants(projectId: ProjectId$1, parent: Fqn$1): Stream<AstNodeDescriptionWithFqn>;
+  protected createDocumentIndex(document: LikeC4LangiumDocument): DocumentFqnIndex;
+}
+declare class DocumentFqnIndex {
+  private _rootElements;
+  /**
+   * direct children of elements
+   */
+  private _children;
+  /**
+   * All descendants of an element (unique by name)
+   */
+  private _descendants;
+  /**
+   * All elements by FQN
+   */
+  private _byfqn;
+  readonly projectId: ProjectId$1;
+  static readonly EMPTY: DocumentFqnIndex;
+  constructor(_rootElements: Array<AstNodeDescriptionWithFqn>,
+  /**
+   * direct children of elements
+   */
+
+  _children: MultiMap$1<Fqn$1, AstNodeDescriptionWithFqn>,
+  /**
+   * All descendants of an element (unique by name)
+   */
+
+  _descendants: MultiMap$1<Fqn$1, AstNodeDescriptionWithFqn>,
+  /**
+   * All elements by FQN
+   */
+
+  _byfqn: MultiMap$1<Fqn$1, AstNodeDescriptionWithFqn>, projectId: ProjectId$1);
+  rootElements(): readonly AstNodeDescriptionWithFqn[];
+  byFqn(fqn: Fqn$1): readonly AstNodeDescriptionWithFqn[];
+  children(parent: Fqn$1): readonly AstNodeDescriptionWithFqn[];
+  descendants(nodeName: Fqn$1): readonly AstNodeDescriptionWithFqn[];
+}
+//#endregion
+//#region src/model/deployments-index.d.ts
+declare class DeploymentsIndex extends FqnIndex<DeploymentElement> {
+  protected services: LikeC4Services;
+  protected Names: LikeC4NameProvider;
+  constructor(services: LikeC4Services);
+  protected createDocumentIndex(document: LikeC4LangiumDocument): DocumentFqnIndex;
+}
+//#endregion
+//#region src/model/model-builder.d.ts
+type ModelParsedListener = (docs: URI[]) => void;
+interface LikeC4ModelBuilder extends Disposable {
+  parseModel(projectId?: ProjectId | undefined, cancelToken?: CancellationToken$2): Promise<LikeC4Model<UnknownParsed> | null>;
+  unsafeSyncComputeModel(projectId: ProjectId): LikeC4Model<UnknownComputed>;
+  computeModel(projectId?: ProjectId | undefined, cancelToken?: CancellationToken$2): Promise<LikeC4Model<UnknownComputed>>;
+  onModelParsed(callback: ModelParsedListener): Disposable;
+  clearCache(): void;
+}
+//#endregion
+//#region src/model/model-locator.d.ts
+type ViewLocateResult = {
+  doc: ParsedLikeC4LangiumDocument;
+  view: ParsedAstView;
+  viewAst: LikeC4View;
+};
+declare class LikeC4ModelLocator {
+  private services;
+  private fqnIndex;
+  private deploymentsIndex;
+  private langiumDocuments;
+  private parser;
+  private projects;
+  constructor(services: LikeC4Services);
+  private documents;
+  getParsedElement(...args: [Element] | [c4.Fqn] | [c4.Fqn, c4.ProjectId]): ParsedAstElement | null;
+  locateElement(fqn: c4.Fqn, projectId?: c4.ProjectId | undefined): Location | null;
+  locateDeploymentElement(deploymentFqn: c4.DeploymentFqn, projectId?: c4.ProjectId | undefined): Location | null;
+  locateRelation(relationId: c4.RelationId, projectId?: c4.ProjectId): Location | null;
+  locateViewAst(viewId: c4.ViewId, projectId?: c4.ProjectId | undefined): null | ViewLocateResult;
+  locateView(viewId: c4.ViewId, projectId?: c4.ProjectId): Location | null;
+  locateDocumentTags(documentUri: URI$2, cancelToken?: Cancellation.CancellationToken): Promise<Array<{
+    name: string;
+    color: string;
+    range: Range;
+    isSpecification: boolean;
+  }>>;
+  locateDynamicViewStep(params: {
+    view: c4.ViewId;
+    astPath: string;
+    projectId?: c4.ProjectId | undefined;
+  }): 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;
+//#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 = {
+  /**
+   * The Language Server Protocol connection to use.
+   */
+  connection?: Connection;
+  /**
+   * Whether to enable the file system watcher.
+   * @default true
+   */
+  enableWatcher?: boolean;
+  /**
+   * @default true
+   */
+  enableTelemetry?: boolean;
+  /**
+   * Whether to enable the MCP server.
+   * @default 'sse'
+   */
+  enableMCP?: false | 'stdio' | 'sse' | {
+    port: number;
+  };
+  /**
+   * Whether to enable manual layouts, stored in json5 files.
+   * @default true
+   */
+  enableManualLayouts?: boolean;
+};
+declare function startLanguageServer$1(options?: StartLanguageServerOptions): {
+  shared: LikeC4SharedServices;
+  likec4: LikeC4Services;
+};
+//#endregion
+//#region src/model/parser/Base.d.ts
+declare class BaseParser {
+  readonly services: LikeC4Services;
+  readonly doc: ParsedLikeC4LangiumDocument;
+  isValid: IsValidFn;
+  constructor(services: LikeC4Services, doc: ParsedLikeC4LangiumDocument);
+  get project(): Project;
+  resolveFqn(node: FqnReferenceable): c4.Fqn;
+  getAstNodePath(node: AstNode): string;
+  getMetadata(metadataAstNode: MetadataProperty | undefined): {
+    [key: string]: string | string[];
+  } | undefined;
+  parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): c4.MarkdownOrString | undefined;
+  convertTags<E extends {
+    tags?: Tags;
+  }>(withTags?: E): any;
+  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;
+  parseIconProperty(prop: IconProperty | undefined): c4.IconUrl | undefined;
+  parseImageAlias(value: string): string | undefined;
+  parseColorLiteral(astNode: ColorLiteral): c4.ColorLiteral | undefined;
+  parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
+  parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
+  /**
+   * Parse base properties: title, description and technology
+   *
+   * @param props - body properties (inside '{...}')
+   * @param override - optional, inline properties (right on the node)
+   *                   have higher priority and override body properties
+   */
+  parseBaseProps(props: {
+    title?: MarkdownOrString | undefined;
+    summary?: MarkdownOrString | undefined;
+    description?: MarkdownOrString | undefined;
+    technology?: MarkdownOrString | undefined;
+  }, override?: {
+    title?: string | undefined;
+    summary?: string | undefined;
+    description?: string | undefined;
+    technology?: string | undefined;
+  }): {
+    title?: string;
+    summary?: c4.MarkdownOrString;
+    description?: c4.MarkdownOrString;
+    technology?: string;
+  };
+}
+//#endregion
+//#region src/model/model-parser.d.ts
+declare const DocumentParserFromMixins: {
+  new (...args: any[]): {
+    parseGlobals(): void;
+    parseAndStoreGlobalPredicateGroupOrDynamic(astRule: GlobalPredicateGroup | GlobalDynamicPredicateGroup, id: ProjectId, c4Globals: ParsedAstGlobals): void;
+    parseGlobalPredicateGroup(astRule: GlobalPredicateGroup): ProjectId[];
+    parseGlobalDynamicPredicateGroup(astRule: GlobalDynamicPredicateGroup): ProjectId[];
+    parseGlobalStyleOrGroup(astRule: GlobalStyle | GlobalStyleGroup): ProjectId[];
+    parseViews(): void;
+    parseElementView(astNode: ElementView, additionalStyles: any[]): ParsedAstElementView;
+    parseElementViewRule(astRule: ViewRule): ProjectId;
+    parseViewRulePredicate(astNode: ViewRulePredicate): ProjectId;
+    parseViewRuleGlobalPredicateRef(astRule: ViewRuleGlobalPredicateRef | DynamicViewGlobalPredicateRef): ProjectId;
+    parseViewRuleStyleOrGlobalRef(astRule: ViewRuleStyleOrGlobalRef): any;
+    parseViewRuleGroup(astNode: ViewRuleGroup): ProjectId;
+    parseViewRuleRank(astRule: ViewRuleRank): ProjectId;
+    parseViewRuleStyle(astRule: ViewRuleStyle | GlobalStyle): ProjectId;
+    parseViewRuleGlobalStyle(astRule: ViewRuleGlobalStyle): ProjectId;
+    parseDynamicElementView(astNode: DynamicView, additionalStyles: any[]): ParsedAstDynamicView;
+    parseDynamicViewRule(astRule: DynamicViewRule): ProjectId;
+    parseDynamicViewIncludePredicate(astRule: DynamicViewIncludePredicate): ProjectId;
+    parseDynamicParallelSteps(node: DynamicViewParallelSteps): ProjectId;
+    parseDynamicStep(node: DynamicViewStep): ProjectId | ProjectId;
+    recursiveParseDynamicStepChain(node: DynamicStepChain, callstack?: Array<[source: ProjectId, target: ProjectId]>): ProjectId[];
+    parseDynamicStepSingle(node: DynamicStepSingle): ProjectId;
+    parseAbstractDynamicStep(astnode: AbstractDynamicStep): type_fest0.Writable<type_fest0.Except<ProjectId, "source", {
+      requireExactProps: true;
+    }>>;
+    parsePredicate(astNode: ExpressionV2): ProjectId;
+    parseElementPredicate(astNode: FqnExprOrWith): ProjectId;
+    parseElementPredicateOrWhere(astNode: FqnExprOrWhere): ProjectId;
+    parseElementExpression(astNode: FqnExpr$2): ProjectId;
+    parseElementPredicateWhere(astNode: FqnExprWhere): ProjectId;
+    parseElementPredicateWith(astNode: FqnExprWith): ProjectId;
+    parseRelationPredicate(astNode: RelationExprOrWith): ProjectId;
+    parseRelationPredicateOrWhere(astNode: RelationExprOrWhere): ProjectId;
+    parseRelationPredicateWhere(astNode: RelationExprWhere): ProjectId;
+    parseRelationPredicateWith(astNode: RelationExprWith): ProjectId;
+    parseRelationExpression(astNode: RelationExpr$1): ProjectId;
+    parseFqnRef(astNode: FqnRef$2): ProjectId;
+    parseExpressionV2(astNode: ExpressionV2): ProjectId;
+    parseFqnExprOrWith(astNode: FqnExprOrWith): ProjectId;
+    parseFqnExprWith(astNode: FqnExprWith): ProjectId;
+    parseFqnExprOrWhere(astNode: FqnExprOrWhere): ProjectId;
+    parseFqnExprWhere(astNode: FqnExprWhere): ProjectId;
+    parseFqnExpr(astNode: FqnExpr$2): ProjectId;
+    parseFqnRefExpr(astNode: FqnRefExpr): ProjectId;
+    parseFqnExpressions(astNode: FqnExpressions): ProjectId[];
+    parseRelationExprOrWith(astNode: RelationExprOrWith): ProjectId;
+    parseRelationExprWith(astNode: RelationExprWith): ProjectId;
+    parseCustomRelationProperties(custom: CustomRelationProperties | undefined): type_fest0.Except<ProjectId["customRelation"], "expr">;
+    parseRelationExprOrWhere(astNode: RelationExprOrWhere): ProjectId;
+    parseRelationExprWhere(astNode: RelationExprWhere): ProjectId;
+    parseRelationExpr(astNode: RelationExpr$1): ProjectId;
+    parseInlineKindCondition(astNode: OutgoingRelationExpr): ProjectId | null;
+    wrapInWhere(expr: ProjectId, condition: ProjectId | null): ProjectId;
+    isValid: IsValidFn;
+    readonly services: LikeC4Services;
+    readonly doc: ParsedLikeC4LangiumDocument;
+    get project(): Project;
+    resolveFqn(node: FqnReferenceable): ProjectId;
+    getAstNodePath(node: langium0.AstNode): string;
+    getMetadata(metadataAstNode: MetadataProperty | undefined): {
+      [key: string]: string | string[];
+    } | undefined;
+    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId | undefined;
+    convertTags<E extends {
+      tags?: Tags;
+    }>(withTags?: E | undefined): any;
+    parseTags<E extends {
+      tags?: Tags;
+    }>(withTags?: E): ProjectId<ProjectId> | null;
+    convertLinks(source?: LinkProperty["$container"]): ProjectId[] | undefined;
+    parseLinks(source?: LinkProperty["$container"]): ProjectId[] | undefined;
+    parseIconProperty(prop: IconProperty | undefined): ProjectId | undefined;
+    parseImageAlias(value: string): string | undefined;
+    parseColorLiteral(astNode: ColorLiteral): ProjectId | undefined;
+    parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
+    parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
+    parseBaseProps(props: {
+      title?: MarkdownOrString | undefined;
+      summary?: MarkdownOrString | undefined;
+      description?: MarkdownOrString | undefined;
+      technology?: MarkdownOrString | undefined;
+    }, override?: {
+      title?: string | undefined;
+      summary?: string | undefined;
+      description?: string | undefined;
+      technology?: string | undefined;
+    }): {
+      title?: string;
+      summary?: ProjectId;
+      description?: ProjectId;
+      technology?: string;
+    };
+    parseDeploymentView(astNode: DeploymentView): ParsedAstDeploymentView;
+    parseDeploymentViewRule(astRule: DeploymentViewRule): ProjectId;
+    parseDeploymentViewRulePredicate(astRule: DeploymentViewRulePredicate): ProjectId;
+    parseDeploymentViewRuleStyle(astRule: DeploymentViewRuleStyle): ProjectId;
+    parseDeployment(): void;
+    parseDeploymentNode(astNode: DeploymentNode): ParsedAstDeployment.Node;
+    parseDeployedInstance(astNode: DeployedInstance): ParsedAstDeployment.Instance;
+    parseExtendDeployment(astNode: ExtendDeployment): ParsedAstExtend | null;
+    _resolveDeploymentRelationSource(node: DeploymentRelation): ProjectId;
+    parseDeploymentRelation(astNode: DeploymentRelation): ParsedAstDeploymentRelation;
+  };
+} & {
+  new (...args: any[]): {
+    parseViews(): void;
+    parseElementView(astNode: ElementView, additionalStyles: any[]): ParsedAstElementView;
+    parseElementViewRule(astRule: ViewRule): ProjectId;
+    parseViewRulePredicate(astNode: ViewRulePredicate): ProjectId;
+    parseViewRuleGlobalPredicateRef(astRule: ViewRuleGlobalPredicateRef | DynamicViewGlobalPredicateRef): ProjectId;
+    parseViewRuleStyleOrGlobalRef(astRule: ViewRuleStyleOrGlobalRef): any;
+    parseViewRuleGroup(astNode: ViewRuleGroup): ProjectId;
+    parseViewRuleRank(astRule: ViewRuleRank): ProjectId;
+    parseViewRuleStyle(astRule: ViewRuleStyle | GlobalStyle): ProjectId;
+    parseViewRuleGlobalStyle(astRule: ViewRuleGlobalStyle): ProjectId;
+    parseDynamicElementView(astNode: DynamicView, additionalStyles: any[]): ParsedAstDynamicView;
+    parseDynamicViewRule(astRule: DynamicViewRule): ProjectId;
+    parseDynamicViewIncludePredicate(astRule: DynamicViewIncludePredicate): ProjectId;
+    parseDynamicParallelSteps(node: DynamicViewParallelSteps): ProjectId;
+    parseDynamicStep(node: DynamicViewStep): ProjectId | ProjectId;
+    recursiveParseDynamicStepChain(node: DynamicStepChain, callstack?: Array<[source: ProjectId, target: ProjectId]>): ProjectId[];
+    parseDynamicStepSingle(node: DynamicStepSingle): ProjectId;
+    parseAbstractDynamicStep(astnode: AbstractDynamicStep): type_fest0.Writable<type_fest0.Except<ProjectId, "source", {
+      requireExactProps: true;
+    }>>;
+    parsePredicate(astNode: ExpressionV2): ProjectId;
+    parseElementPredicate(astNode: FqnExprOrWith): ProjectId;
+    parseElementPredicateOrWhere(astNode: FqnExprOrWhere): ProjectId;
+    parseElementExpression(astNode: FqnExpr$2): ProjectId;
+    parseElementPredicateWhere(astNode: FqnExprWhere): ProjectId;
+    parseElementPredicateWith(astNode: FqnExprWith): ProjectId;
+    parseRelationPredicate(astNode: RelationExprOrWith): ProjectId;
+    parseRelationPredicateOrWhere(astNode: RelationExprOrWhere): ProjectId;
+    parseRelationPredicateWhere(astNode: RelationExprWhere): ProjectId;
+    parseRelationPredicateWith(astNode: RelationExprWith): ProjectId;
+    parseRelationExpression(astNode: RelationExpr$1): ProjectId;
+    parseFqnRef(astNode: FqnRef$2): ProjectId;
+    parseExpressionV2(astNode: ExpressionV2): ProjectId;
+    parseFqnExprOrWith(astNode: FqnExprOrWith): ProjectId;
+    parseFqnExprWith(astNode: FqnExprWith): ProjectId;
+    parseFqnExprOrWhere(astNode: FqnExprOrWhere): ProjectId;
+    parseFqnExprWhere(astNode: FqnExprWhere): ProjectId;
+    parseFqnExpr(astNode: FqnExpr$2): ProjectId;
+    parseFqnRefExpr(astNode: FqnRefExpr): ProjectId;
+    parseFqnExpressions(astNode: FqnExpressions): ProjectId[];
+    parseRelationExprOrWith(astNode: RelationExprOrWith): ProjectId;
+    parseRelationExprWith(astNode: RelationExprWith): ProjectId;
+    parseCustomRelationProperties(custom: CustomRelationProperties | undefined): type_fest0.Except<ProjectId["customRelation"], "expr">;
+    parseRelationExprOrWhere(astNode: RelationExprOrWhere): ProjectId;
+    parseRelationExprWhere(astNode: RelationExprWhere): ProjectId;
+    parseRelationExpr(astNode: RelationExpr$1): ProjectId;
+    parseInlineKindCondition(astNode: OutgoingRelationExpr): ProjectId | null;
+    wrapInWhere(expr: ProjectId, condition: ProjectId | null): ProjectId;
+    isValid: IsValidFn;
+    readonly services: LikeC4Services;
+    readonly doc: ParsedLikeC4LangiumDocument;
+    get project(): Project;
+    resolveFqn(node: FqnReferenceable): ProjectId;
+    getAstNodePath(node: langium0.AstNode): string;
+    getMetadata(metadataAstNode: MetadataProperty | undefined): {
+      [key: string]: string | string[];
+    } | undefined;
+    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId | undefined;
+    convertTags<E extends {
+      tags?: Tags;
+    }>(withTags?: E | undefined): any;
+    parseTags<E extends {
+      tags?: Tags;
+    }>(withTags?: E): ProjectId<ProjectId> | null;
+    convertLinks(source?: LinkProperty["$container"]): ProjectId[] | undefined;
+    parseLinks(source?: LinkProperty["$container"]): ProjectId[] | undefined;
+    parseIconProperty(prop: IconProperty | undefined): ProjectId | undefined;
+    parseImageAlias(value: string): string | undefined;
+    parseColorLiteral(astNode: ColorLiteral): ProjectId | undefined;
+    parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
+    parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
+    parseBaseProps(props: {
+      title?: MarkdownOrString | undefined;
+      summary?: MarkdownOrString | undefined;
+      description?: MarkdownOrString | undefined;
+      technology?: MarkdownOrString | undefined;
+    }, override?: {
+      title?: string | undefined;
+      summary?: string | undefined;
+      description?: string | undefined;
+      technology?: string | undefined;
+    }): {
+      title?: string;
+      summary?: ProjectId;
+      description?: ProjectId;
+      technology?: string;
+    };
+    parseDeploymentView(astNode: DeploymentView): ParsedAstDeploymentView;
+    parseDeploymentViewRule(astRule: DeploymentViewRule): ProjectId;
+    parseDeploymentViewRulePredicate(astRule: DeploymentViewRulePredicate): ProjectId;
+    parseDeploymentViewRuleStyle(astRule: DeploymentViewRuleStyle): ProjectId;
+    parseDeployment(): void;
+    parseDeploymentNode(astNode: DeploymentNode): ParsedAstDeployment.Node;
+    parseDeployedInstance(astNode: DeployedInstance): ParsedAstDeployment.Instance;
+    parseExtendDeployment(astNode: ExtendDeployment): ParsedAstExtend | null;
+    _resolveDeploymentRelationSource(node: DeploymentRelation): ProjectId;
+    parseDeploymentRelation(astNode: DeploymentRelation): ParsedAstDeploymentRelation;
+  };
+} & {
+  new (...args: any[]): {
+    parseSpecification(): void;
+    parseElementSpecificationNode(specAst: SpecificationElementKind): {};
+    parseElementSpecificationNode(specAst: SpecificationDeploymentNodeKind): {};
+    isValid: IsValidFn;
+    readonly services: LikeC4Services;
+    readonly doc: ParsedLikeC4LangiumDocument;
+    get project(): Project;
+    resolveFqn(node: FqnReferenceable): ProjectId;
+    getAstNodePath(node: langium0.AstNode): string;
+    getMetadata(metadataAstNode: MetadataProperty | undefined): {
+      [key: string]: string | string[];
+    } | undefined;
+    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId | undefined;
+    convertTags<E extends {
+      tags?: Tags;
+    }>(withTags?: E | undefined): any;
+    parseTags<E extends {
+      tags?: Tags;
+    }>(withTags?: E): ProjectId<ProjectId> | null;
+    convertLinks(source?: LinkProperty["$container"]): ProjectId[] | undefined;
+    parseLinks(source?: LinkProperty["$container"]): ProjectId[] | undefined;
+    parseIconProperty(prop: IconProperty | undefined): ProjectId | undefined;
+    parseImageAlias(value: string): string | undefined;
+    parseColorLiteral(astNode: ColorLiteral): ProjectId | undefined;
+    parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
+    parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
+    parseBaseProps(props: {
+      title?: MarkdownOrString | undefined;
+      summary?: MarkdownOrString | undefined;
+      description?: MarkdownOrString | undefined;
+      technology?: MarkdownOrString | undefined;
+    }, override?: {
+      title?: string | undefined;
+      summary?: string | undefined;
+      description?: string | undefined;
+      technology?: string | undefined;
+    }): {
+      title?: string;
+      summary?: ProjectId;
+      description?: ProjectId;
+      technology?: string;
+    };
+  };
+} & {
+  new (...args: any[]): {
+    parsePredicate(astNode: ExpressionV2): ProjectId;
+    parseElementPredicate(astNode: FqnExprOrWith): ProjectId;
+    parseElementPredicateOrWhere(astNode: FqnExprOrWhere): ProjectId;
+    parseElementExpression(astNode: FqnExpr$2): ProjectId;
+    parseElementPredicateWhere(astNode: FqnExprWhere): ProjectId;
+    parseElementPredicateWith(astNode: FqnExprWith): ProjectId;
+    parseRelationPredicate(astNode: RelationExprOrWith): ProjectId;
+    parseRelationPredicateOrWhere(astNode: RelationExprOrWhere): ProjectId;
+    parseRelationPredicateWhere(astNode: RelationExprWhere): ProjectId;
+    parseRelationPredicateWith(astNode: RelationExprWith): ProjectId;
+    parseRelationExpression(astNode: RelationExpr$1): ProjectId;
+    parseFqnRef(astNode: FqnRef$2): ProjectId;
+    parseExpressionV2(astNode: ExpressionV2): ProjectId;
+    parseFqnExprOrWith(astNode: FqnExprOrWith): ProjectId;
+    parseFqnExprWith(astNode: FqnExprWith): ProjectId;
+    parseFqnExprOrWhere(astNode: FqnExprOrWhere): ProjectId;
+    parseFqnExprWhere(astNode: FqnExprWhere): ProjectId;
+    parseFqnExpr(astNode: FqnExpr$2): ProjectId;
+    parseFqnRefExpr(astNode: FqnRefExpr): ProjectId;
+    parseFqnExpressions(astNode: FqnExpressions): ProjectId[];
+    parseRelationExprOrWith(astNode: RelationExprOrWith): ProjectId;
+    parseRelationExprWith(astNode: RelationExprWith): ProjectId;
+    parseCustomRelationProperties(custom: CustomRelationProperties | undefined): type_fest0.Except<ProjectId["customRelation"], "expr">;
+    parseRelationExprOrWhere(astNode: RelationExprOrWhere): ProjectId;
+    parseRelationExprWhere(astNode: RelationExprWhere): ProjectId;
+    parseRelationExpr(astNode: RelationExpr$1): ProjectId;
+    parseInlineKindCondition(astNode: OutgoingRelationExpr): ProjectId | null;
+    wrapInWhere(expr: ProjectId, condition: ProjectId | null): ProjectId;
+    isValid: IsValidFn;
+    readonly services: LikeC4Services;
+    readonly doc: ParsedLikeC4LangiumDocument;
+    get project(): Project;
+    resolveFqn(node: FqnReferenceable): ProjectId;
+    getAstNodePath(node: langium0.AstNode): string;
+    getMetadata(metadataAstNode: MetadataProperty | undefined): {
+      [key: string]: string | string[];
+    } | undefined;
+    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId | undefined;
+    convertTags<E extends {
+      tags?: Tags;
+    }>(withTags?: E | undefined): any;
+    parseTags<E extends {
+      tags?: Tags;
+    }>(withTags?: E): ProjectId<ProjectId> | null;
+    convertLinks(source?: LinkProperty["$container"]): ProjectId[] | undefined;
+    parseLinks(source?: LinkProperty["$container"]): ProjectId[] | undefined;
+    parseIconProperty(prop: IconProperty | undefined): ProjectId | undefined;
+    parseImageAlias(value: string): string | undefined;
+    parseColorLiteral(astNode: ColorLiteral): ProjectId | undefined;
+    parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
+    parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
+    parseBaseProps(props: {
+      title?: MarkdownOrString | undefined;
+      summary?: MarkdownOrString | undefined;
+      description?: MarkdownOrString | undefined;
+      technology?: MarkdownOrString | undefined;
+    }, override?: {
+      title?: string | undefined;
+      summary?: string | undefined;
+      description?: string | undefined;
+      technology?: string | undefined;
+    }): {
+      title?: string;
+      summary?: ProjectId;
+      description?: ProjectId;
+      technology?: string;
+    };
+  };
+} & {
+  new (...args: any[]): {
+    parseDeploymentView(astNode: DeploymentView): ParsedAstDeploymentView;
+    parseDeploymentViewRule(astRule: DeploymentViewRule): ProjectId;
+    parseDeploymentViewRulePredicate(astRule: DeploymentViewRulePredicate): ProjectId;
+    parseDeploymentViewRuleStyle(astRule: DeploymentViewRuleStyle): ProjectId;
+    parseFqnRef(astNode: FqnRef$2): ProjectId;
+    parseExpressionV2(astNode: ExpressionV2): ProjectId;
+    parseFqnExprOrWith(astNode: FqnExprOrWith): ProjectId;
+    parseFqnExprWith(astNode: FqnExprWith): ProjectId;
+    parseFqnExprOrWhere(astNode: FqnExprOrWhere): ProjectId;
+    parseFqnExprWhere(astNode: FqnExprWhere): ProjectId;
+    parseFqnExpr(astNode: FqnExpr$2): ProjectId;
+    parseFqnRefExpr(astNode: FqnRefExpr): ProjectId;
+    parseFqnExpressions(astNode: FqnExpressions): ProjectId[];
+    parseRelationExprOrWith(astNode: RelationExprOrWith): ProjectId;
+    parseRelationExprWith(astNode: RelationExprWith): ProjectId;
+    parseCustomRelationProperties(custom: CustomRelationProperties | undefined): type_fest0.Except<ProjectId["customRelation"], "expr">;
+    parseRelationExprOrWhere(astNode: RelationExprOrWhere): ProjectId;
+    parseRelationExprWhere(astNode: RelationExprWhere): ProjectId;
+    parseRelationExpr(astNode: RelationExpr$1): ProjectId;
+    parseInlineKindCondition(astNode: OutgoingRelationExpr): ProjectId | null;
+    wrapInWhere(expr: ProjectId, condition: ProjectId | null): ProjectId;
+    isValid: IsValidFn;
+    readonly services: LikeC4Services;
+    readonly doc: ParsedLikeC4LangiumDocument;
+    get project(): Project;
+    resolveFqn(node: FqnReferenceable): ProjectId;
+    getAstNodePath(node: langium0.AstNode): string;
+    getMetadata(metadataAstNode: MetadataProperty | undefined): {
+      [key: string]: string | string[];
+    } | undefined;
+    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId | undefined;
+    convertTags<E extends {
+      tags?: Tags;
+    }>(withTags?: E | undefined): any;
+    parseTags<E extends {
+      tags?: Tags;
+    }>(withTags?: E): ProjectId<ProjectId> | null;
+    convertLinks(source?: LinkProperty["$container"]): ProjectId[] | undefined;
+    parseLinks(source?: LinkProperty["$container"]): ProjectId[] | undefined;
+    parseIconProperty(prop: IconProperty | undefined): ProjectId | undefined;
+    parseImageAlias(value: string): string | undefined;
+    parseColorLiteral(astNode: ColorLiteral): ProjectId | undefined;
+    parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
+    parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
+    parseBaseProps(props: {
+      title?: MarkdownOrString | undefined;
+      summary?: MarkdownOrString | undefined;
+      description?: MarkdownOrString | undefined;
+      technology?: MarkdownOrString | undefined;
+    }, override?: {
+      title?: string | undefined;
+      summary?: string | undefined;
+      description?: string | undefined;
+      technology?: string | undefined;
+    }): {
+      title?: string;
+      summary?: ProjectId;
+      description?: ProjectId;
+      technology?: string;
+    };
+    parseDeployment(): void;
+    parseDeploymentNode(astNode: DeploymentNode): ParsedAstDeployment.Node;
+    parseDeployedInstance(astNode: DeployedInstance): ParsedAstDeployment.Instance;
+    parseExtendDeployment(astNode: ExtendDeployment): ParsedAstExtend | null;
+    _resolveDeploymentRelationSource(node: DeploymentRelation): ProjectId;
+    parseDeploymentRelation(astNode: DeploymentRelation): ParsedAstDeploymentRelation;
+  };
+} & {
+  new (...args: any[]): {
+    parseDeployment(): void;
+    parseDeploymentNode(astNode: DeploymentNode): ParsedAstDeployment.Node;
+    parseDeployedInstance(astNode: DeployedInstance): ParsedAstDeployment.Instance;
+    parseExtendDeployment(astNode: ExtendDeployment): ParsedAstExtend | null;
+    _resolveDeploymentRelationSource(node: DeploymentRelation): ProjectId;
+    parseDeploymentRelation(astNode: DeploymentRelation): ParsedAstDeploymentRelation;
+    parseFqnRef(astNode: FqnRef$2): ProjectId;
+    parseExpressionV2(astNode: ExpressionV2): ProjectId;
+    parseFqnExprOrWith(astNode: FqnExprOrWith): ProjectId;
+    parseFqnExprWith(astNode: FqnExprWith): ProjectId;
+    parseFqnExprOrWhere(astNode: FqnExprOrWhere): ProjectId;
+    parseFqnExprWhere(astNode: FqnExprWhere): ProjectId;
+    parseFqnExpr(astNode: FqnExpr$2): ProjectId;
+    parseFqnRefExpr(astNode: FqnRefExpr): ProjectId;
+    parseFqnExpressions(astNode: FqnExpressions): ProjectId[];
+    parseRelationExprOrWith(astNode: RelationExprOrWith): ProjectId;
+    parseRelationExprWith(astNode: RelationExprWith): ProjectId;
+    parseCustomRelationProperties(custom: CustomRelationProperties | undefined): type_fest0.Except<ProjectId["customRelation"], "expr">;
+    parseRelationExprOrWhere(astNode: RelationExprOrWhere): ProjectId;
+    parseRelationExprWhere(astNode: RelationExprWhere): ProjectId;
+    parseRelationExpr(astNode: RelationExpr$1): ProjectId;
+    parseInlineKindCondition(astNode: OutgoingRelationExpr): ProjectId | null;
+    wrapInWhere(expr: ProjectId, condition: ProjectId | null): ProjectId;
+    isValid: IsValidFn;
+    readonly services: LikeC4Services;
+    readonly doc: ParsedLikeC4LangiumDocument;
+    get project(): Project;
+    resolveFqn(node: FqnReferenceable): ProjectId;
+    getAstNodePath(node: langium0.AstNode): string;
+    getMetadata(metadataAstNode: MetadataProperty | undefined): {
+      [key: string]: string | string[];
+    } | undefined;
+    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId | undefined;
+    convertTags<E extends {
+      tags?: Tags;
+    }>(withTags?: E | undefined): any;
+    parseTags<E extends {
+      tags?: Tags;
+    }>(withTags?: E): ProjectId<ProjectId> | null;
+    convertLinks(source?: LinkProperty["$container"]): ProjectId[] | undefined;
+    parseLinks(source?: LinkProperty["$container"]): ProjectId[] | undefined;
+    parseIconProperty(prop: IconProperty | undefined): ProjectId | undefined;
+    parseImageAlias(value: string): string | undefined;
+    parseColorLiteral(astNode: ColorLiteral): ProjectId | undefined;
+    parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
+    parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
+    parseBaseProps(props: {
+      title?: MarkdownOrString | undefined;
+      summary?: MarkdownOrString | undefined;
+      description?: MarkdownOrString | undefined;
+      technology?: MarkdownOrString | undefined;
+    }, override?: {
+      title?: string | undefined;
+      summary?: string | undefined;
+      description?: string | undefined;
+      technology?: string | undefined;
+    }): {
+      title?: string;
+      summary?: ProjectId;
+      description?: ProjectId;
+      technology?: string;
+    };
+  };
+} & {
+  new (...args: any[]): {
+    parseModel(): void;
+    parseElement(astNode: Element): ParsedAstElement;
+    parseExtendElement(astNode: ExtendElement): ParsedAstExtend | null;
+    parseExtendRelation(astNode: ExtendRelation): ParsedAstExtendRelation | null;
+    _resolveRelationSource(node: Relation): ProjectId | ProjectId;
+    parseRelation(astNode: Relation): ParsedAstRelation;
+    parseFqnRef(astNode: FqnRef$2): ProjectId;
+    parseExpressionV2(astNode: ExpressionV2): ProjectId;
+    parseFqnExprOrWith(astNode: FqnExprOrWith): ProjectId;
+    parseFqnExprWith(astNode: FqnExprWith): ProjectId;
+    parseFqnExprOrWhere(astNode: FqnExprOrWhere): ProjectId;
+    parseFqnExprWhere(astNode: FqnExprWhere): ProjectId;
+    parseFqnExpr(astNode: FqnExpr$2): ProjectId;
+    parseFqnRefExpr(astNode: FqnRefExpr): ProjectId;
+    parseFqnExpressions(astNode: FqnExpressions): ProjectId[];
+    parseRelationExprOrWith(astNode: RelationExprOrWith): ProjectId;
+    parseRelationExprWith(astNode: RelationExprWith): ProjectId;
+    parseCustomRelationProperties(custom: CustomRelationProperties | undefined): type_fest0.Except<ProjectId["customRelation"], "expr">;
+    parseRelationExprOrWhere(astNode: RelationExprOrWhere): ProjectId;
+    parseRelationExprWhere(astNode: RelationExprWhere): ProjectId;
+    parseRelationExpr(astNode: RelationExpr$1): ProjectId;
+    parseInlineKindCondition(astNode: OutgoingRelationExpr): ProjectId | null;
+    wrapInWhere(expr: ProjectId, condition: ProjectId | null): ProjectId;
+    isValid: IsValidFn;
+    readonly services: LikeC4Services;
+    readonly doc: ParsedLikeC4LangiumDocument;
+    get project(): Project;
+    resolveFqn(node: FqnReferenceable): ProjectId;
+    getAstNodePath(node: langium0.AstNode): string;
+    getMetadata(metadataAstNode: MetadataProperty | undefined): {
+      [key: string]: string | string[];
+    } | undefined;
+    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId | undefined;
+    convertTags<E extends {
+      tags?: Tags;
+    }>(withTags?: E | undefined): any;
+    parseTags<E extends {
+      tags?: Tags;
+    }>(withTags?: E): ProjectId<ProjectId> | null;
+    convertLinks(source?: LinkProperty["$container"]): ProjectId[] | undefined;
+    parseLinks(source?: LinkProperty["$container"]): ProjectId[] | undefined;
+    parseIconProperty(prop: IconProperty | undefined): ProjectId | undefined;
+    parseImageAlias(value: string): string | undefined;
+    parseColorLiteral(astNode: ColorLiteral): ProjectId | undefined;
+    parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
+    parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
+    parseBaseProps(props: {
+      title?: MarkdownOrString | undefined;
+      summary?: MarkdownOrString | undefined;
+      description?: MarkdownOrString | undefined;
+      technology?: MarkdownOrString | undefined;
+    }, override?: {
+      title?: string | undefined;
+      summary?: string | undefined;
+      description?: string | undefined;
+      technology?: string | undefined;
+    }): {
+      title?: string;
+      summary?: ProjectId;
+      description?: ProjectId;
+      technology?: string;
+    };
+  };
+} & {
+  new (...args: any[]): {
+    parseImports(): void;
+    isValid: IsValidFn;
+    readonly services: LikeC4Services;
+    readonly doc: ParsedLikeC4LangiumDocument;
+    get project(): Project;
+    resolveFqn(node: FqnReferenceable): ProjectId;
+    getAstNodePath(node: langium0.AstNode): string;
+    getMetadata(metadataAstNode: MetadataProperty | undefined): {
+      [key: string]: string | string[];
+    } | undefined;
+    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId | undefined;
+    convertTags<E extends {
+      tags?: Tags;
+    }>(withTags?: E | undefined): any;
+    parseTags<E extends {
+      tags?: Tags;
+    }>(withTags?: E): ProjectId<ProjectId> | null;
+    convertLinks(source?: LinkProperty["$container"]): ProjectId[] | undefined;
+    parseLinks(source?: LinkProperty["$container"]): ProjectId[] | undefined;
+    parseIconProperty(prop: IconProperty | undefined): ProjectId | undefined;
+    parseImageAlias(value: string): string | undefined;
+    parseColorLiteral(astNode: ColorLiteral): ProjectId | undefined;
+    parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
+    parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
+    parseBaseProps(props: {
+      title?: MarkdownOrString | undefined;
+      summary?: MarkdownOrString | undefined;
+      description?: MarkdownOrString | undefined;
+      technology?: MarkdownOrString | undefined;
+    }, override?: {
+      title?: string | undefined;
+      summary?: string | undefined;
+      description?: string | undefined;
+      technology?: string | undefined;
+    }): {
+      title?: string;
+      summary?: ProjectId;
+      description?: ProjectId;
+      technology?: string;
+    };
+  };
+} & {
+  new (...args: any[]): {
+    parseFqnRef(astNode: FqnRef$2): ProjectId;
+    parseExpressionV2(astNode: ExpressionV2): ProjectId;
+    parseFqnExprOrWith(astNode: FqnExprOrWith): ProjectId;
+    parseFqnExprWith(astNode: FqnExprWith): ProjectId;
+    parseFqnExprOrWhere(astNode: FqnExprOrWhere): ProjectId;
+    parseFqnExprWhere(astNode: FqnExprWhere): ProjectId;
+    parseFqnExpr(astNode: FqnExpr$2): ProjectId;
+    parseFqnRefExpr(astNode: FqnRefExpr): ProjectId;
+    parseFqnExpressions(astNode: FqnExpressions): ProjectId[];
+    parseRelationExprOrWith(astNode: RelationExprOrWith): ProjectId;
+    parseRelationExprWith(astNode: RelationExprWith): ProjectId;
+    parseCustomRelationProperties(custom: CustomRelationProperties | undefined): type_fest0.Except<ProjectId["customRelation"], "expr">;
+    parseRelationExprOrWhere(astNode: RelationExprOrWhere): ProjectId;
+    parseRelationExprWhere(astNode: RelationExprWhere): ProjectId;
+    parseRelationExpr(astNode: RelationExpr$1): ProjectId;
+    parseInlineKindCondition(astNode: OutgoingRelationExpr): ProjectId | null;
+    wrapInWhere(expr: ProjectId, condition: ProjectId | null): ProjectId;
+    isValid: IsValidFn;
+    readonly services: LikeC4Services;
+    readonly doc: ParsedLikeC4LangiumDocument;
+    get project(): Project;
+    resolveFqn(node: FqnReferenceable): ProjectId;
+    getAstNodePath(node: langium0.AstNode): string;
+    getMetadata(metadataAstNode: MetadataProperty | undefined): {
+      [key: string]: string | string[];
+    } | undefined;
+    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId | undefined;
+    convertTags<E extends {
+      tags?: Tags;
+    }>(withTags?: E | undefined): any;
+    parseTags<E extends {
+      tags?: Tags;
+    }>(withTags?: E): ProjectId<ProjectId> | null;
+    convertLinks(source?: LinkProperty["$container"]): ProjectId[] | undefined;
+    parseLinks(source?: LinkProperty["$container"]): ProjectId[] | undefined;
+    parseIconProperty(prop: IconProperty | undefined): ProjectId | undefined;
+    parseImageAlias(value: string): string | undefined;
+    parseColorLiteral(astNode: ColorLiteral): ProjectId | undefined;
+    parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
+    parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
+    parseBaseProps(props: {
+      title?: MarkdownOrString | undefined;
+      summary?: MarkdownOrString | undefined;
+      description?: MarkdownOrString | undefined;
+      technology?: MarkdownOrString | undefined;
+    }, override?: {
+      title?: string | undefined;
+      summary?: string | undefined;
+      description?: string | undefined;
+      technology?: string | undefined;
+    }): {
+      title?: string;
+      summary?: ProjectId;
+      description?: ProjectId;
+      technology?: string;
+    };
+  };
+} & typeof BaseParser;
+declare class DocumentParser extends DocumentParserFromMixins {}
+declare class LikeC4ModelParser {
+  private services;
+  protected cachedParsers: any;
+  constructor(services: LikeC4Services);
+  documents(projectId: ProjectId): Stream<ParsedLikeC4LangiumDocument>;
+  parse(doc: LangiumDocument): ParsedLikeC4LangiumDocument;
+  forDocument(doc: LangiumDocument): DocumentParser;
+  private createParser;
+}
+//#endregion
+//#region src/model/parser/ValueConverter.d.ts
+declare class LikeC4ValueConverter extends DefaultValueConverter {
+  protected runConverter(rule: any, input: string, cstNode: CstNode): ValueType;
+}
+//#endregion
+//#region src/LikeC4LanguageServices.d.ts
+interface LikeC4LanguageServices {
+  readonly views: LikeC4Views;
+  readonly builder: LikeC4ModelBuilder;
+  readonly workspaceUri: URI;
+  readonly projectsManager: ProjectsManager;
+  readonly editor: LikeC4ModelChanges;
+  /**
+   * Returns all projects with relevant documents
+   */
+  projects(): NonEmptyArray<{
+    id: ProjectId;
+    folder: URI;
+    title: string;
+    documents: ReadonlyArray<URI>;
+    config: Readonly<LikeC4ProjectConfig>;
+  }>;
+  /**
+   * Returns project by ID, returns default project if no ID is specified
+   */
+  project(projectId?: ProjectId): {
+    id: ProjectId;
+    folder: URI;
+    title: string;
+    documents: ReadonlyArray<URI>;
+    config: Readonly<LikeC4ProjectConfig>;
+  };
+  /**
+   * Computes and layouts projects overview - a special diagram
+   * that shows all projects and their relationships
+   */
+  projectsOverview(cancelToken?: CancellationToken$2): Promise<LayoutedProjectsView$1>;
+  /**
+   * Returns {@link LikeC4Model} of the specified project, with computed views {@link ComputedView}
+   * Not ready for rendering, but enough to traverse model. Much faster than {@link layoutedModel}
+   *
+   * If no {@link project} is specified, returns for default project
+   */
+  computedModel(project?: ProjectId | undefined, cancelToken?: CancellationToken$2): Promise<LikeC4Model<UnknownComputed>>;
+  /**
+   * Returns {@link LikeC4Model} of the specified project, with layouted views {@link LayoutedView}
+   * Ready for rendering. Applies manual layouts if available.
+   *
+   * If no {@link project} is specified, returns for default project
+   */
+  layoutedModel(project?: ProjectId | undefined, cancelToken?: CancellationToken$2): Promise<LikeC4Model<UnknownLayouted>>;
+  /**
+   * Returns diagrams (i.e. layouted views {@link LayoutedView}) for the specified project
+   * Applies manual layouts if available.
+   *
+   * If no {@link project} is specified, returns diagrams for default project
+   */
+  diagrams(project?: ProjectId | undefined, cancelToken?: CancellationToken$2): Promise<LayoutedView[]>;
+  getErrors(): Array<{
+    message: string;
+    line: number;
+    range: Range;
+    sourceFsPath: string;
+  }>;
+  /**
+   * Returns the location of the specified element, relation, view or deployment element
+   */
+  locate(params: Locate.Params): Locate.Res;
+  dispose(): Promise<void>;
+}
+/**
+ * Public Language Services
+ */
+declare class DefaultLikeC4LanguageServices implements LikeC4LanguageServices {
+  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;
+  };
+  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>;
+}
+//#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 };