@likec4/language-server 1.47.0 → 1.49.0

package/dist/_chunks/index.d.mts

@@ -0,0 +1,3107 @@
+import { ChangeView, DidRequestOpenViewNotification, Locate } from "../protocol.mjs";
+import { LikeC4Services, LikeC4SharedServices } from "../module.mjs";
+import * as langium from "langium";
+import { AstNode, AstNodeDescription, AsyncDisposable, BuildOptions, Cancellation, CstNode, DefaultAstNodeDescriptionProvider, DefaultDocumentValidator, DefaultIndexManager, DefaultLangiumDocuments, DefaultNameProvider, DefaultScopeComputation, DefaultScopeProvider, DefaultValueConverter, DefaultWorkspaceManager, DiagnosticInfo, Disposable, FileSelector, FileSystemNode, FileSystemProvider, GrammarAST, JSDocDocumentationProvider, LangiumDocument, LangiumDocumentFactory, MaybePromise, PrecomputedScopes, Reference, ReferenceDescription, ReferenceInfo, Scope, SimpleCache, Stream, URI, ValidationOptions, ValueType, WorkspaceCache } from "langium";
+import { DefaultWeakMap, MultiMap as MultiMap$1 } from "@likec4/core/utils";
+import { CompletionItemKind, Diagnostic, DocumentSymbol, FormattingOptions, Hover, Location, Range, SemanticTokens, SemanticTokensDelta, SymbolKind, TextEdit } from "vscode-languageserver-types";
+import { AbstractFormatter, AbstractSemanticTokenProvider, AstNodeHoverProvider, CodeActionProvider, CodeLensProvider, CompletionAcceptor, CompletionContext, DefaultCompletionProvider, DefaultDocumentHighlightProvider, DefaultWorkspaceSymbolProvider, DocumentLinkProvider, DocumentSymbolProvider, FormattingRegion, LangiumSharedServices, NextFeature, NodeKindProvider, SemanticTokenAcceptor } from "langium/lsp";
+import { GraphvizLayouter, QueueGraphvizLayoter } from "@likec4/layouts";
+import * as c4 from "@likec4/core";
+import { ComputedView, DiagramView, LayoutType, LayoutedView, NonEmptyArray, NonEmptyReadonlyArray, ProjectId, Tag, UnknownComputed, UnknownLayouted, UnknownParsed, ViewChange, ViewId } from "@likec4/core";
+import { AdhocViewPredicate, LayoutedProjectsView as LayoutedProjectsView$1 } from "@likec4/core/compute-view";
+import { ElementModel, LikeC4Model } from "@likec4/core/model";
+import { IncludeConfig, LikeC4ProjectConfig, LikeC4ProjectConfigInput } from "@likec4/config";
+import { URI as URI$2 } from "vscode-uri";
+import { LikeC4Styles } from "@likec4/core/styles";
+import { CancellationToken, CodeLens, CodeLensParams, DocumentHighlight, DocumentLink, DocumentLinkParams, DocumentSymbolParams, WorkspaceFolder } from "vscode-languageserver";
+import { CancellationToken as CancellationToken$1, CodeAction, CodeActionParams, Command, SemanticTokensDeltaParams, SemanticTokensParams, SemanticTokensRangeParams } from "vscode-languageserver-protocol";
+import { Fqn as Fqn$1, GuardedBy, LayoutedView as LayoutedView$1, ProjectId as ProjectId$1, ViewId as ViewId$1 } from "@likec4/core/types";
+import { CancellationToken as CancellationToken$2 } from "vscode-jsonrpc";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as type_fest0 from "type-fest";
+import { ConditionalPick, MergeExclusive, Simplify, Tagged, ValueOf, Writable } from "type-fest";
+import { ServerOptions } from "@modelcontextprotocol/sdk/server/index.js";
+
+//#region src/documentation/documentation-provider.d.ts
+declare class LikeC4DocumentationProvider extends JSDocDocumentationProvider {
+  private parser;
+  private locator;
+  constructor(services: LikeC4Services);
+  getDocumentation(node: AstNode): string | undefined;
+}
+//#endregion
+//#region src/workspace/ProjectsManager.d.ts
+type DocOrUri = LangiumDocument | string | URI;
+/**
+ * A tagged string that represents a project folder URI
+ * Always has trailing slash.
+ */
+type ProjectFolder = Tagged<string, 'ProjectFolder'>;
+declare function ProjectFolder(folder: URI | string): ProjectFolder;
+interface Project {
+  id: ProjectId$1;
+  folderUri: URI;
+  config: LikeC4ProjectConfig;
+}
+interface ProjectData extends Project {
+  id: ProjectId$1;
+  folder: ProjectFolder;
+  config: LikeC4ProjectConfig;
+  configUri: URI;
+  folderUri: URI;
+  exclude?: {
+    (test: string): boolean;
+  };
+  /**
+   * Resolved include paths with both URI and folder string representations.
+   * These are additional directories that are part of this project.
+   */
+  includePaths?: NonEmptyArray<{
+    uri: URI;
+    folder: ProjectFolder;
+  }>;
+  /**
+   * Normalized include configuration (paths, maxDepth, fileThreshold).
+   */
+  includeConfig: IncludeConfig;
+}
+type RegisterProjectOptions = {
+  config: LikeC4ProjectConfig | LikeC4ProjectConfigInput;
+} & ({
+  configUri: URI | string;
+} | {
+  folderUri: URI | string;
+});
+declare class ProjectsManager {
+  #private;
+  protected services: LikeC4SharedServices;
+  /**
+   * The global project ID used for all documents
+   * that are not part of a specific project.
+   */
+  static readonly DefaultProjectId: ProjectId$1;
+  constructor(services: LikeC4SharedServices);
+  /**
+   * Returns:
+   *  - configured default project ID if set
+   *  - the default project ID if there are no projects.
+   *  - the ID of the only project
+   *  - undefined if there are multiple projects.
+   */
+  get defaultProjectId(): ProjectId$1 | undefined;
+  set defaultProjectId(id: string | ProjectId$1 | undefined);
+  get default(): ProjectData;
+  get all(): NonEmptyReadonlyArray<ProjectId$1>;
+  getProject(arg: ProjectId$1 | LangiumDocument): ProjectData;
+  /**
+   * Returns all projects that overlap with the specified folder (is parent or child)
+   */
+  findOverlaped(folder: URI | string): ProjectData[];
+  /**
+   * Validates and ensures the project ID.
+   * If no project ID is specified, returns default project ID
+   * If there are multiple projects and default project is not set, throws an error
+   */
+  ensureProjectId(projectId?: ProjectId$1 | undefined): ProjectId$1;
+  /**
+   * Validates and ensures the project.
+   */
+  ensureProject(projectId?: ProjectId$1 | undefined): ProjectData;
+  hasMultipleProjects(): boolean;
+  /**
+   * Checks if the specified document should be excluded from processing.
+   */
+  isExcluded(document: DocOrUri): boolean;
+  isExcluded(projectId: ProjectId$1, document: DocOrUri): boolean;
+  /**
+   * Checks if the specified document is included by the project:
+   * - if the document belongs to the project and is not excluded
+   * - if the document is included by the project
+   */
+  isIncluded(projectId: ProjectId$1, document: LangiumDocument | URI | string): boolean;
+  /**
+   * Registers likec4 project by config file.
+   */
+  registerConfigFile(configUri: URI, cancelToken?: 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: RegisterProjectOptions, cancelToken?: Cancellation.CancellationToken): Promise<ProjectData>;
+  /**
+   * Determines which project the given document belongs to.
+   * If the document does not belong to any project, returns the default project ID.
+   */
+  ownerProjectId(document: LangiumDocument | URI | string): ProjectId$1;
+  reloadProjects(cancelToken?: Cancellation.CancellationToken): Promise<void>;
+  protected _reloadProjects(cancelToken?: Cancellation.CancellationToken): Promise<void>;
+  protected uniqueProjectId(name: string): ProjectId$1;
+  protected resetCaches(): void;
+  rebuildProject(projectId: ProjectId$1, cancelToken?: Cancellation.CancellationToken): Promise<void>;
+  /**
+   * Returns all include paths from all projects.
+   * Used by WorkspaceManager to scan additional directories for C4 files.
+   */
+  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;
+  private updateIncludesExcludes;
+}
+//#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.
+   * @throws Error if the file does not exist or is not a valid project config.
+   */
+  loadProjectConfig(filepath: URI): Promise<LikeC4ProjectConfig>;
+  /**
+   * Reads the directory information for the given URI.
+   * @param options.recursive If true, recursively reads the directory,
+   * @param options.maxDepth Maximum depth to traverse when recursive is true (default: Infinity)
+   */
+  readDirectory(uri: URI, options?: {
+    recursive?: boolean;
+    maxDepth?: number;
+  }): Promise<FileNode[]>;
+  /**
+   * Finds all files in the given directory, matching the given filter.
+   */
+  scanDirectory(directory: URI, filter: (filepath: string) => boolean): Promise<FileNode[]>;
+  /**
+   * Writes the content to the file system.
+   * Used by manual layouts.
+   */
+  writeFile(uri: URI, content: string): Promise<void>;
+  /**
+   * Deletes the file from the file system.
+   * Used by manual layouts.
+   * @return true if the file was deleted, false if the file did not exist.
+   */
+  deleteFile(uri: URI): Promise<boolean>;
+}
+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;
+}
+type ManualLayoutsSnapshot = {
+  hash: string;
+  views: Record<ViewId$1, LayoutedView$1>;
+};
+interface LikeC4ManualLayouts {
+  read(project: Project): Promise<ManualLayoutsSnapshot | null>;
+  write(project: Project, layouted: LayoutedView$1): Promise<Location>;
+  remove(project: Project, view: ViewId$1): Promise<Location | null>;
+  clearCaches(): void;
+}
+//#endregion
+//#region src/filesystem/noop.d.ts
+declare const NoFileSystemWatcher: FileSystemWatcherModuleContext;
+declare const NoFileSystem: FileSystemModuleContext;
+declare const NoLikeC4ManualLayouts: LikeC4ManualLayoutsModuleContext;
+//#endregion
+//#region src/filesystem/LikeC4FileSystem.d.ts
+declare const WithFileSystem: (ehableWatcher?: boolean) => FileSystemModuleContext;
+//#endregion
+//#region src/filesystem/ChokidarWatcher.d.ts
+declare const WithChokidarWatcher: FileSystemWatcherModuleContext;
+//#endregion
+//#region src/filesystem/LikeC4ManualLayouts.d.ts
+declare const WithLikeC4ManualLayouts: LikeC4ManualLayoutsModuleContext;
+//#endregion
+//#region src/formatting/LikeC4Formatter.d.ts
+type QuoteStyle = 'single' | 'double' | 'ignore' | 'auto';
+interface LikeC4FormatterOptions {
+  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/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/generated/ast.d.ts
+type AnyProperty = DynamicViewProperty | ElementProperty | RelationProperty | StringProperty | ViewProperty;
+declare const AnyProperty = "AnyProperty";
+type ArrowType = 'crow' | 'diamond' | 'dot' | 'none' | 'normal' | 'odiamond' | 'odot' | 'onormal' | 'open' | 'vee';
+type BorderStyleValue = 'none' | LineOptions;
+type ColorLiteral$1 = HexColor | RGBAColor;
+declare const ColorLiteral$1 = "ColorLiteral";
+type CustomColorId = 'element' | 'model' | ArrowType | ElementShape | LineOptions | Participant | string;
+type DeploymentElement = DeployedInstance | DeploymentNode;
+declare const DeploymentElement = "DeploymentElement";
+type DeploymentNodeOrElementKind = DeploymentNodeKind | ElementKind;
+declare const DeploymentNodeOrElementKind = "DeploymentNodeOrElementKind";
+type DeploymentViewRule = DeploymentViewRulePredicate | DeploymentViewRuleStyle | ViewRuleAutoLayout;
+declare const DeploymentViewRule = "DeploymentViewRule";
+type DynamicViewDisplayVariantValue = 'diagram' | 'sequence';
+type DynamicViewProperty = DynamicViewDisplayVariantProperty | ViewProperty;
+declare const DynamicViewProperty = "DynamicViewProperty";
+type DynamicViewRule = DynamicViewGlobalPredicateRef | DynamicViewIncludePredicate | ViewRuleAutoLayout | ViewRuleStyleOrGlobalRef;
+declare const DynamicViewRule = "DynamicViewRule";
+type DynamicViewStep = DynamicStepChain | DynamicStepSingle;
+declare const DynamicViewStep = "DynamicViewStep";
+type ElementProperty = ElementStringProperty | ElementStyleProperty | IconProperty | LinkProperty | MetadataProperty;
+declare const ElementProperty = "ElementProperty";
+type ElementShape = 'browser' | 'bucket' | 'component' | 'cylinder' | 'document' | 'mobile' | 'person' | 'queue' | 'rectangle' | 'storage';
+type ExpressionV2 = FqnExprOrWith | RelationExprOrWith;
+declare const ExpressionV2 = "ExpressionV2";
+type ExtendElementProperty = LinkProperty | MetadataProperty;
+declare const ExtendElementProperty = "ExtendElementProperty";
+type ExtendRelationProperty = LinkProperty | MetadataProperty;
+declare const ExtendRelationProperty = "ExtendRelationProperty";
+type FqnExpr$2 = ElementKindExpression | ElementTagExpression | FqnRefExpr | WildcardExpression;
+declare const FqnExpr$2 = "FqnExpr";
+type FqnExprOrWhere = FqnExpr$2 | FqnExprWhere;
+declare const FqnExprOrWhere = "FqnExprOrWhere";
+type FqnExprOrWith = FqnExprOrWhere | FqnExprWith;
+declare const FqnExprOrWith = "FqnExprOrWith";
+type FqnReferenceable = Element | ExtendDeployment | ExtendElement | Referenceable;
+declare const FqnReferenceable = "FqnReferenceable";
+type IconId = string;
+type IconPositionValue = 'bottom' | 'left' | 'right' | 'top';
+type Id = 'deployment' | 'element' | 'group' | 'instance' | 'model' | 'node' | ArrowType | DynamicViewDisplayVariantValue | ElementShape | IconPositionValue | LineOptions | Participant | RankValue | SizeValue | ThemeColor | string;
+type LikeC4View = DeploymentView | DynamicView | ElementView;
+declare const LikeC4View = "LikeC4View";
+type LineOptions = 'dashed' | 'dotted' | 'solid';
+type MetadataProperty = MetadataBody;
+declare const MetadataProperty = "MetadataProperty";
+type MetadataValue = MarkdownOrString | MetadataArray;
+declare const MetadataValue = "MetadataValue";
+type ModelReferenceable = Element | Imported;
+declare const ModelReferenceable = "ModelReferenceable";
+type Participant = 'source' | 'target';
+type RankValue = 'max' | 'min' | 'same' | 'sink' | 'source';
+type Referenceable = DeployedInstance | DeploymentNode | Element | Imported;
+declare const Referenceable = "Referenceable";
+type RelationExpr$1 = DirectedRelationExpr | InOutRelationExpr | IncomingRelationExpr | OutgoingRelationExpr;
+declare const RelationExpr$1 = "RelationExpr";
+type RelationExprOrWhere = RelationExpr$1 | RelationExprWhere;
+declare const RelationExprOrWhere = "RelationExprOrWhere";
+type RelationExprOrWith = RelationExprOrWhere | RelationExprWith;
+declare const RelationExprOrWith = "RelationExprOrWith";
+type RelationProperty = LinkProperty | MetadataProperty | RelationNavigateToProperty | RelationStringProperty | RelationStyleProperty;
+declare const RelationProperty = "RelationProperty";
+type RelationshipStyleProperty = ArrowProperty | ColorProperty | LineProperty;
+declare const RelationshipStyleProperty = "RelationshipStyleProperty";
+type SizeProperty = IconSizeProperty | PaddingSizeProperty | ShapeSizeProperty | TextSizeProperty;
+declare const SizeProperty = "SizeProperty";
+type SizeValue = 'large' | 'lg' | 'md' | 'medium' | 'sm' | 'small' | 'xl' | 'xlarge' | 'xs' | 'xsmall';
+type StringProperty = ElementStringProperty | MetadataAttribute | NotationProperty | NotesProperty | RelationStringProperty | SpecificationElementStringProperty | SpecificationRelationshipStringProperty | ViewStringProperty;
+declare const StringProperty = "StringProperty";
+type StyleProperty = BorderProperty | ColorProperty | IconColorProperty | IconPositionProperty | IconProperty | IconSizeProperty | MultipleProperty | OpacityProperty | PaddingSizeProperty | ShapeProperty | ShapeSizeProperty | TextSizeProperty;
+declare const StyleProperty = "StyleProperty";
+type ThemeColor = 'amber' | 'blue' | 'gray' | 'green' | 'indigo' | 'muted' | 'primary' | 'red' | 'secondary' | 'sky' | 'slate';
+type Uri = string;
+type ViewLayoutDirection = 'BottomTop' | 'LeftRight' | 'RightLeft' | 'TopBottom';
+type ViewProperty = LinkProperty | ViewStringProperty;
+declare const ViewProperty = "ViewProperty";
+type ViewRule = ViewRuleAutoLayout | ViewRuleGlobalPredicateRef | ViewRuleGroup | ViewRulePredicate | ViewRuleRank | ViewRuleStyleOrGlobalRef;
+declare const ViewRule = "ViewRule";
+type ViewRuleStyleOrGlobalRef = ViewRuleGlobalStyle | ViewRuleStyle;
+declare const ViewRuleStyleOrGlobalRef = "ViewRuleStyleOrGlobalRef";
+type WhereElement = WhereElementKind | WhereElementTag;
+declare const WhereElement = "WhereElement";
+type WhereElementExpression = WhereBinaryExpression | WhereElement | WhereElementNegation;
+declare const WhereElementExpression = "WhereElementExpression";
+type WhereExpression = WhereElementExpression | WhereRelationExpression;
+declare const WhereExpression = "WhereExpression";
+type WhereKindEqual = WhereElementKind | WhereRelationKind | WhereRelationParticipantKind;
+declare const WhereKindEqual = "WhereKindEqual";
+type WhereRelation = WhereRelationKind | WhereRelationParticipantKind | WhereRelationParticipantTag | WhereRelationTag;
+declare const WhereRelation = "WhereRelation";
+type WhereRelationExpression = WhereBinaryExpression | WhereRelation | WhereRelationNegation;
+declare const WhereRelationExpression = "WhereRelationExpression";
+type WhereTagEqual = WhereElementTag | WhereRelationParticipantTag | WhereRelationTag;
+declare const WhereTagEqual = "WhereTagEqual";
+interface AbstractDynamicStep extends langium.AstNode {
+  readonly $container: DynamicStepChain | DynamicViewBody | DynamicViewParallelSteps;
+  readonly $type: 'AbstractDynamicStep' | 'DynamicStepChain' | 'DynamicStepSingle';
+  custom?: CustomRelationProperties;
+  dotKind?: RelationKindDotRef;
+  kind?: langium.Reference<RelationshipKind>;
+  target: ElementRef;
+  title?: string;
+}
+declare const AbstractDynamicStep = "AbstractDynamicStep";
+interface ArrowProperty extends langium.AstNode {
+  readonly $container: CustomRelationProperties | RelationStyleProperty | SpecificationRelationshipKind;
+  readonly $type: 'ArrowProperty';
+  key: 'head' | 'tail';
+  value: ArrowType;
+}
+declare const ArrowProperty = "ArrowProperty";
+interface BorderProperty extends langium.AstNode {
+  readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleGroup | ViewRuleStyle;
+  readonly $type: 'BorderProperty';
+  key: 'border';
+  value: BorderStyleValue;
+}
+declare const BorderProperty = "BorderProperty";
+interface ColorProperty extends langium.AstNode {
+  readonly $container: CustomElementProperties | CustomRelationProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | RelationStyleProperty | SpecificationRelationshipKind | ViewRuleGroup | ViewRuleStyle;
+  readonly $type: 'ColorProperty';
+  customColor?: langium.Reference<CustomColor>;
+  key: 'color';
+  themeColor?: ThemeColor;
+}
+declare const ColorProperty = "ColorProperty";
+interface CustomColor extends langium.AstNode {
+  readonly $container: SpecificationColor;
+  readonly $type: 'CustomColor';
+  name: CustomColorId;
+}
+declare const CustomColor = "CustomColor";
+interface CustomElementProperties extends langium.AstNode {
+  readonly $container: FqnExprWith;
+  readonly $type: 'CustomElementProperties';
+  props: Array<ElementStringProperty | NavigateToProperty | NotationProperty | NotesProperty | StyleProperty>;
+}
+declare const CustomElementProperties = "CustomElementProperties";
+interface CustomRelationProperties extends langium.AstNode {
+  readonly $container: AbstractDynamicStep | RelationExprWith;
+  readonly $type: 'CustomRelationProperties';
+  props: Array<NotationProperty | NotesProperty | RelationNavigateToProperty | RelationStringProperty | RelationshipStyleProperty>;
+}
+declare const CustomRelationProperties = "CustomRelationProperties";
+interface DeployedInstance extends langium.AstNode {
+  readonly $container: DeploymentNodeBody | ExtendDeploymentBody;
+  readonly $type: 'DeployedInstance';
+  body?: DeployedInstanceBody;
+  name?: Id;
+  summary?: string;
+  target: ElementRef;
+  title?: string;
+}
+declare const DeployedInstance = "DeployedInstance";
+interface DeployedInstanceBody extends langium.AstNode {
+  readonly $container: DeployedInstance;
+  readonly $type: 'DeployedInstanceBody';
+  elements: Array<DeploymentRelation>;
+  props: Array<ElementProperty>;
+  tags?: Tags;
+}
+declare const DeployedInstanceBody = "DeployedInstanceBody";
+interface DeploymentNode extends langium.AstNode {
+  readonly $container: DeploymentNodeBody | ExtendDeploymentBody | ModelDeployments;
+  readonly $type: 'DeploymentNode';
+  body?: DeploymentNodeBody;
+  kind: langium.Reference<DeploymentNodeKind>;
+  name: Id;
+  summary?: string;
+  title?: string;
+}
+declare const DeploymentNode = "DeploymentNode";
+interface DeploymentNodeBody extends langium.AstNode {
+  readonly $container: DeploymentNode;
+  readonly $type: 'DeploymentNodeBody';
+  elements: Array<DeployedInstance | DeploymentNode | DeploymentRelation>;
+  props: Array<ElementProperty>;
+  tags?: Tags;
+}
+declare const DeploymentNodeBody = "DeploymentNodeBody";
+interface DeploymentNodeKind extends langium.AstNode {
+  readonly $container: SpecificationDeploymentNodeKind;
+  readonly $type: 'DeploymentNodeKind';
+  name: Id;
+}
+declare const DeploymentNodeKind = "DeploymentNodeKind";
+interface DeploymentRelation extends langium.AstNode {
+  readonly $container: DeployedInstanceBody | DeploymentNodeBody | ExtendDeploymentBody | ModelDeployments;
+  readonly $type: 'DeploymentRelation';
+  body?: DeploymentRelationBody;
+  description?: string;
+  dotKind?: RelationKindDotRef;
+  kind?: langium.Reference<RelationshipKind>;
+  source?: FqnRef$2;
+  tags?: Tags;
+  target: FqnRef$2;
+  technology?: string;
+  title?: string;
+}
+declare const DeploymentRelation = "DeploymentRelation";
+interface DeploymentRelationBody extends langium.AstNode {
+  readonly $container: DeploymentRelation;
+  readonly $type: 'DeploymentRelationBody';
+  props: Array<RelationProperty>;
+  tags?: Tags;
+}
+declare const DeploymentRelationBody = "DeploymentRelationBody";
+interface DeploymentView extends langium.AstNode {
+  readonly $container: ModelViews;
+  readonly $type: 'DeploymentView';
+  body?: DeploymentViewBody;
+  name: Id;
+}
+declare const DeploymentView = "DeploymentView";
+interface DeploymentViewBody extends langium.AstNode {
+  readonly $container: DeploymentView;
+  readonly $type: 'DeploymentViewBody';
+  props: Array<ViewProperty>;
+  rules: Array<DeploymentViewRule>;
+  tags?: Tags;
+}
+declare const DeploymentViewBody = "DeploymentViewBody";
+interface DeploymentViewRulePredicate extends langium.AstNode {
+  readonly $container: DeploymentViewBody;
+  readonly $type: 'DeploymentViewRulePredicate';
+  expr: Expressions;
+  isInclude: boolean;
+}
+declare const DeploymentViewRulePredicate = "DeploymentViewRulePredicate";
+interface DeploymentViewRuleStyle extends langium.AstNode {
+  readonly $container: DeploymentViewBody;
+  readonly $type: 'DeploymentViewRuleStyle';
+  props: Array<NotationProperty | StyleProperty>;
+  targets: FqnExpressions;
+}
+declare const DeploymentViewRuleStyle = "DeploymentViewRuleStyle";
+interface DirectedRelationExpr extends langium.AstNode {
+  readonly $container: Expressions | RelationExprWhere | RelationExprWith;
+  readonly $type: 'DirectedRelationExpr';
+  source: OutgoingRelationExpr;
+  target: FqnExpr$2;
+}
+declare const DirectedRelationExpr = "DirectedRelationExpr";
+interface DynamicView extends langium.AstNode {
+  readonly $container: ModelViews;
+  readonly $type: 'DynamicView';
+  body?: DynamicViewBody;
+  name: Id;
+}
+declare const DynamicView = "DynamicView";
+interface DynamicViewBody extends langium.AstNode {
+  readonly $container: DynamicView;
+  readonly $type: 'DynamicViewBody';
+  props: Array<DynamicViewProperty>;
+  rules: Array<DynamicViewRule>;
+  steps: Array<DynamicViewParallelSteps | DynamicViewStep>;
+  tags?: Tags;
+}
+declare const DynamicViewBody = "DynamicViewBody";
+interface DynamicViewDisplayVariantProperty extends langium.AstNode {
+  readonly $container: DynamicViewBody;
+  readonly $type: 'DynamicViewDisplayVariantProperty';
+  key: 'variant';
+  value: DynamicViewDisplayVariantValue;
+}
+declare const DynamicViewDisplayVariantProperty = "DynamicViewDisplayVariantProperty";
+interface DynamicViewGlobalPredicateRef extends langium.AstNode {
+  readonly $container: DynamicViewBody;
+  readonly $type: 'DynamicViewGlobalPredicateRef';
+  predicate: langium.Reference<GlobalDynamicPredicateGroup>;
+}
+declare const DynamicViewGlobalPredicateRef = "DynamicViewGlobalPredicateRef";
+interface DynamicViewIncludePredicate extends langium.AstNode {
+  readonly $container: DynamicViewBody | GlobalDynamicPredicateGroup;
+  readonly $type: 'DynamicViewIncludePredicate';
+  exprs: Expressions;
+}
+declare const DynamicViewIncludePredicate = "DynamicViewIncludePredicate";
+interface DynamicViewParallelSteps extends langium.AstNode {
+  readonly $container: DynamicViewBody;
+  readonly $type: 'DynamicViewParallelSteps';
+  steps: Array<DynamicViewStep>;
+}
+declare const DynamicViewParallelSteps = "DynamicViewParallelSteps";
+interface DynamicViewRef extends langium.AstNode {
+  readonly $container: RelationNavigateToProperty;
+  readonly $type: 'DynamicViewRef';
+  view: langium.Reference<DynamicView>;
+}
+declare const DynamicViewRef = "DynamicViewRef";
+interface Element extends langium.AstNode {
+  readonly $container: ElementBody | ExtendElementBody | Model;
+  readonly $type: 'Element';
+  body?: ElementBody;
+  kind: langium.Reference<ElementKind>;
+  name: Id;
+  props: Array<string>;
+}
+declare const Element = "Element";
+interface ElementBody extends langium.AstNode {
+  readonly $container: Element;
+  readonly $type: 'ElementBody';
+  elements: Array<Element | Relation>;
+  props: Array<ElementProperty>;
+  tags?: Tags;
+}
+declare const ElementBody = "ElementBody";
+interface ElementKind extends langium.AstNode {
+  readonly $container: SpecificationElementKind;
+  readonly $type: 'ElementKind';
+  name: Id;
+}
+declare const ElementKind = "ElementKind";
+interface ElementKindExpression extends langium.AstNode {
+  readonly $container: DirectedRelationExpr | Expressions | FqnExprWhere | FqnExprWith | FqnExpressions | IncomingRelationExpr | OutgoingRelationExpr;
+  readonly $type: 'ElementKindExpression';
+  isEqual: boolean;
+  kind: langium.Reference<ElementKind>;
+}
+declare const ElementKindExpression = "ElementKindExpression";
+interface ElementRef extends langium.AstNode {
+  readonly $container: AbstractDynamicStep | DeployedInstance | DynamicStepSingle | ElementView;
+  readonly $type: 'ElementRef';
+  modelElement: FqnRef$2;
+}
+declare const ElementRef = "ElementRef";
+interface ElementStringProperty extends langium.AstNode {
+  readonly $container: CustomElementProperties | DeployedInstanceBody | DeploymentNodeBody | ElementBody;
+  readonly $type: 'ElementStringProperty';
+  key: 'description' | 'summary' | 'technology' | 'title';
+  value: MarkdownOrString;
+}
+declare const ElementStringProperty = "ElementStringProperty";
+interface ElementStyleProperty extends langium.AstNode {
+  readonly $container: DeployedInstanceBody | DeploymentNodeBody | ElementBody | SpecificationDeploymentNodeKind | SpecificationElementKind;
+  readonly $type: 'ElementStyleProperty';
+  key: 'style';
+  props: Array<StyleProperty>;
+}
+declare const ElementStyleProperty = "ElementStyleProperty";
+interface ElementTagExpression extends langium.AstNode {
+  readonly $container: DirectedRelationExpr | Expressions | FqnExprWhere | FqnExprWith | FqnExpressions | IncomingRelationExpr | OutgoingRelationExpr;
+  readonly $type: 'ElementTagExpression';
+  isEqual: boolean;
+  tag: TagRef;
+}
+declare const ElementTagExpression = "ElementTagExpression";
+interface ElementView extends langium.AstNode {
+  readonly $container: ModelViews;
+  readonly $type: 'ElementView';
+  body?: ElementViewBody;
+  extends?: ElementViewRef;
+  name?: Id;
+  viewOf?: ElementRef;
+}
+declare const ElementView = "ElementView";
+interface ElementViewBody extends langium.AstNode {
+  readonly $container: ElementView;
+  readonly $type: 'ElementViewBody';
+  props: Array<ViewProperty>;
+  rules: Array<ViewRule>;
+  tags?: Tags;
+}
+declare const ElementViewBody = "ElementViewBody";
+interface ElementViewRef extends langium.AstNode {
+  readonly $container: ElementView;
+  readonly $type: 'ElementViewRef';
+  view: langium.Reference<ElementView>;
+}
+declare const ElementViewRef = "ElementViewRef";
+interface Expressions extends langium.AstNode {
+  readonly $container: DeploymentViewRulePredicate | DynamicViewIncludePredicate | Expressions | ViewRulePredicate;
+  readonly $type: 'Expressions';
+  prev?: Expressions;
+  value: ExpressionV2;
+}
+declare const Expressions = "Expressions";
+interface ExtendDeployment extends langium.AstNode {
+  readonly $container: ModelDeployments;
+  readonly $type: 'ExtendDeployment';
+  body: ExtendDeploymentBody;
+  deploymentNode: StrictFqnRef;
+}
+declare const ExtendDeployment = "ExtendDeployment";
+interface ExtendDeploymentBody extends langium.AstNode {
+  readonly $container: ExtendDeployment;
+  readonly $type: 'ExtendDeploymentBody';
+  elements: Array<DeployedInstance | DeploymentNode | DeploymentRelation>;
+  props: Array<ExtendElementProperty>;
+  tags?: Tags;
+}
+declare const ExtendDeploymentBody = "ExtendDeploymentBody";
+interface ExtendElement extends langium.AstNode {
+  readonly $container: Model;
+  readonly $type: 'ExtendElement';
+  body: ExtendElementBody;
+  element: StrictFqnElementRef;
+}
+declare const ExtendElement = "ExtendElement";
+interface ExtendElementBody extends langium.AstNode {
+  readonly $container: ExtendElement;
+  readonly $type: 'ExtendElementBody';
+  elements: Array<Element | Relation>;
+  props: Array<ExtendElementProperty>;
+  tags?: Tags;
+}
+declare const ExtendElementBody = "ExtendElementBody";
+interface ExtendRelation extends langium.AstNode {
+  readonly $container: Model;
+  readonly $type: 'ExtendRelation';
+  body: ExtendRelationBody;
+  dotKind?: RelationKindDotRef;
+  kind?: langium.Reference<RelationshipKind>;
+  source: FqnRef$2;
+  target: FqnRef$2;
+  title?: string;
+}
+declare const ExtendRelation = "ExtendRelation";
+interface ExtendRelationBody extends langium.AstNode {
+  readonly $container: ExtendRelation;
+  readonly $type: 'ExtendRelationBody';
+  props: Array<ExtendRelationProperty>;
+  tags?: Tags;
+}
+declare const ExtendRelationBody = "ExtendRelationBody";
+interface FqnExpressions extends langium.AstNode {
+  readonly $container: DeploymentViewRuleStyle | FqnExpressions | GlobalStyle | ViewRuleRank | ViewRuleStyle;
+  readonly $type: 'FqnExpressions';
+  prev?: FqnExpressions;
+  value: FqnExpr$2;
+}
+declare const FqnExpressions = "FqnExpressions";
+interface FqnExprWhere extends langium.AstNode {
+  readonly $container: Expressions | FqnExprWith;
+  readonly $type: 'FqnExprWhere';
+  subject: FqnExpr$2;
+  where?: WhereElementExpression;
+}
+declare const FqnExprWhere = "FqnExprWhere";
+interface FqnExprWith extends langium.AstNode {
+  readonly $container: Expressions;
+  readonly $type: 'FqnExprWith';
+  custom?: CustomElementProperties;
+  subject: FqnExprOrWhere;
+}
+declare const FqnExprWith = "FqnExprWith";
+interface FqnRef$2 extends langium.AstNode {
+  readonly $container: DeploymentRelation | ElementRef | ExtendRelation | FqnRef$2 | FqnRefExpr | Relation;
+  readonly $type: 'FqnRef';
+  parent?: FqnRef$2;
+  value: langium.Reference<Referenceable>;
+}
+declare const FqnRef$2 = "FqnRef";
+interface FqnRefExpr extends langium.AstNode {
+  readonly $container: DirectedRelationExpr | Expressions | FqnExprWhere | FqnExprWith | FqnExpressions | IncomingRelationExpr | OutgoingRelationExpr;
+  readonly $type: 'FqnRefExpr';
+  ref: FqnRef$2;
+  selector?: string;
+}
+declare const FqnRefExpr = "FqnRefExpr";
+interface GlobalDynamicPredicateGroup extends langium.AstNode {
+  readonly $container: Globals;
+  readonly $type: 'GlobalDynamicPredicateGroup';
+  name: string;
+  predicates: Array<DynamicViewIncludePredicate>;
+}
+declare const GlobalDynamicPredicateGroup = "GlobalDynamicPredicateGroup";
+interface GlobalPredicateGroup extends langium.AstNode {
+  readonly $container: Globals;
+  readonly $type: 'GlobalPredicateGroup';
+  name: string;
+  predicates: Array<ViewRulePredicate>;
+}
+declare const GlobalPredicateGroup = "GlobalPredicateGroup";
+interface Globals extends langium.AstNode {
+  readonly $container: LikeC4Grammar;
+  readonly $type: 'Globals';
+  name: 'global';
+  predicates: Array<GlobalDynamicPredicateGroup | GlobalPredicateGroup>;
+  styles: Array<GlobalStyle | GlobalStyleGroup>;
+}
+declare const Globals = "Globals";
+interface GlobalStyle extends langium.AstNode {
+  readonly $container: Globals;
+  readonly $type: 'GlobalStyle';
+  id: GlobalStyleId;
+  props: Array<NotationProperty | StyleProperty>;
+  targets: FqnExpressions;
+}
+declare const GlobalStyle = "GlobalStyle";
+interface GlobalStyleGroup extends langium.AstNode {
+  readonly $container: Globals;
+  readonly $type: 'GlobalStyleGroup';
+  id: GlobalStyleId;
+  styles: Array<ViewRuleStyle>;
+}
+declare const GlobalStyleGroup = "GlobalStyleGroup";
+interface GlobalStyleId extends langium.AstNode {
+  readonly $container: GlobalStyle | GlobalStyleGroup;
+  readonly $type: 'GlobalStyleId';
+  name: string;
+}
+declare const GlobalStyleId = "GlobalStyleId";
+interface HexColor extends langium.AstNode {
+  readonly $container: SpecificationColor | SpecificationTag;
+  readonly $type: 'HexColor';
+  hex: number | string;
+}
+declare const HexColor = "HexColor";
+interface IconColorProperty extends langium.AstNode {
+  readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleStyle;
+  readonly $type: 'IconColorProperty';
+  customColor?: langium.Reference<CustomColor>;
+  key: 'iconColor';
+  themeColor?: ThemeColor;
+}
+declare const IconColorProperty = "IconColorProperty";
+interface IconPositionProperty extends langium.AstNode {
+  readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleStyle;
+  readonly $type: 'IconPositionProperty';
+  key: 'iconPosition';
+  value: IconPositionValue;
+}
+declare const IconPositionProperty = "IconPositionProperty";
+interface IconProperty extends langium.AstNode {
+  readonly $container: CustomElementProperties | DeployedInstanceBody | DeploymentNodeBody | DeploymentViewRuleStyle | ElementBody | ElementStyleProperty | GlobalStyle | ViewRuleStyle;
+  readonly $type: 'IconProperty';
+  key: 'icon';
+  libicon?: langium.Reference<LibIcon>;
+  value?: 'none' | Uri;
+}
+declare const IconProperty = "IconProperty";
+interface IconSizeProperty extends langium.AstNode {
+  readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleStyle;
+  readonly $type: 'IconSizeProperty';
+  key: 'iconSize';
+  value: SizeValue;
+}
+declare const IconSizeProperty = "IconSizeProperty";
+interface Imported extends langium.AstNode {
+  readonly $container: Imported | ImportsFromPoject;
+  readonly $type: 'Imported';
+  imported: langium.Reference<Element>;
+  prev?: Imported;
+}
+declare const Imported = "Imported";
+interface ImportsFromPoject extends langium.AstNode {
+  readonly $container: LikeC4Grammar;
+  readonly $type: 'ImportsFromPoject';
+  imports: Imported;
+  project: string;
+}
+declare const ImportsFromPoject = "ImportsFromPoject";
+interface IncomingRelationExpr extends langium.AstNode {
+  readonly $container: Expressions | InOutRelationExpr | RelationExprWhere | RelationExprWith;
+  readonly $type: 'IncomingRelationExpr';
+  to: FqnExpr$2;
+}
+declare const IncomingRelationExpr = "IncomingRelationExpr";
+interface InOutRelationExpr extends langium.AstNode {
+  readonly $container: Expressions | RelationExprWhere | RelationExprWith;
+  readonly $type: 'InOutRelationExpr';
+  inout: IncomingRelationExpr;
+}
+declare const InOutRelationExpr = "InOutRelationExpr";
+interface LibIcon extends langium.AstNode {
+  readonly $container: LikeC4Lib;
+  readonly $type: 'LibIcon';
+  name: IconId;
+}
+declare const LibIcon = "LibIcon";
+interface LikeC4Grammar extends langium.AstNode {
+  readonly $type: 'LikeC4Grammar';
+  deployments: Array<ModelDeployments>;
+  globals: Array<Globals>;
+  imports: Array<ImportsFromPoject>;
+  likec4lib: Array<LikeC4Lib>;
+  models: Array<Model>;
+  specifications: Array<SpecificationRule>;
+  views: Array<ModelViews>;
+}
+declare const LikeC4Grammar = "LikeC4Grammar";
+interface LikeC4Lib extends langium.AstNode {
+  readonly $container: LikeC4Grammar;
+  readonly $type: 'LikeC4Lib';
+  icons: Array<LibIcon>;
+}
+declare const LikeC4Lib = "LikeC4Lib";
+interface LineProperty extends langium.AstNode {
+  readonly $container: CustomRelationProperties | RelationStyleProperty | SpecificationRelationshipKind;
+  readonly $type: 'LineProperty';
+  key: 'line';
+  value: LineOptions;
+}
+declare const LineProperty = "LineProperty";
+interface LinkProperty extends langium.AstNode {
+  readonly $container: DeployedInstanceBody | DeploymentNodeBody | DeploymentRelationBody | DeploymentViewBody | DynamicViewBody | ElementBody | ElementViewBody | ExtendDeploymentBody | ExtendElementBody | ExtendRelationBody | RelationBody | SpecificationDeploymentNodeKind | SpecificationElementKind;
+  readonly $type: 'LinkProperty';
+  key: 'link';
+  title?: string;
+  value: Uri;
+}
+declare const LinkProperty = "LinkProperty";
+interface MarkdownOrString extends langium.AstNode {
+  readonly $container: ElementStringProperty | MetadataArray | MetadataAttribute | NotationProperty | NotesProperty | RelationStringProperty | SpecificationElementStringProperty | SpecificationRelationshipStringProperty | ViewStringProperty;
+  readonly $type: 'MarkdownOrString';
+  markdown?: string;
+  text?: string;
+}
+declare const MarkdownOrString = "MarkdownOrString";
+interface MetadataArray extends langium.AstNode {
+  readonly $container: MetadataAttribute;
+  readonly $type: 'MetadataArray';
+  values: Array<MarkdownOrString>;
+}
+declare const MetadataArray = "MetadataArray";
+interface MetadataAttribute extends langium.AstNode {
+  readonly $container: MetadataBody;
+  readonly $type: 'MetadataAttribute';
+  key: string;
+  value: MetadataValue;
+}
+declare const MetadataAttribute = "MetadataAttribute";
+interface MetadataBody extends langium.AstNode {
+  readonly $container: DeployedInstanceBody | DeploymentNodeBody | DeploymentRelationBody | ElementBody | ExtendDeploymentBody | ExtendElementBody | ExtendRelationBody | RelationBody;
+  readonly $type: 'MetadataBody';
+  props: Array<MetadataAttribute>;
+}
+declare const MetadataBody = "MetadataBody";
+interface Model extends langium.AstNode {
+  readonly $container: LikeC4Grammar;
+  readonly $type: 'Model';
+  elements: Array<Element | ExtendElement | ExtendRelation | Relation>;
+  name: 'model';
+}
+declare const Model = "Model";
+interface ModelDeployments extends langium.AstNode {
+  readonly $container: LikeC4Grammar;
+  readonly $type: 'ModelDeployments';
+  elements: Array<DeploymentNode | DeploymentRelation | ExtendDeployment>;
+  name: 'deployment';
+}
+declare const ModelDeployments = "ModelDeployments";
+interface ModelViews extends langium.AstNode {
+  readonly $container: LikeC4Grammar;
+  readonly $type: 'ModelViews';
+  folder?: string;
+  name: 'views';
+  styles: Array<ViewRuleStyleOrGlobalRef>;
+  views: Array<LikeC4View>;
+}
+declare const ModelViews = "ModelViews";
+interface MultipleProperty extends langium.AstNode {
+  readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleStyle;
+  readonly $type: 'MultipleProperty';
+  key: 'multiple';
+  value: boolean;
+}
+declare const MultipleProperty = "MultipleProperty";
+interface NavigateToProperty extends langium.AstNode {
+  readonly $container: CustomElementProperties;
+  readonly $type: 'NavigateToProperty';
+  key: 'navigateTo';
+  value: ViewRef;
+}
+declare const NavigateToProperty = "NavigateToProperty";
+interface NotationProperty extends langium.AstNode {
+  readonly $container: CustomElementProperties | CustomRelationProperties | DeploymentViewRuleStyle | GlobalStyle | ViewRuleStyle;
+  readonly $type: 'NotationProperty';
+  key: 'notation';
+  value: MarkdownOrString;
+}
+declare const NotationProperty = "NotationProperty";
+interface NotesProperty extends langium.AstNode {
+  readonly $container: CustomElementProperties | CustomRelationProperties;
+  readonly $type: 'NotesProperty';
+  key: 'notes';
+  value: MarkdownOrString;
+}
+declare const NotesProperty = "NotesProperty";
+interface OpacityProperty extends langium.AstNode {
+  readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleGroup | ViewRuleStyle;
+  readonly $type: 'OpacityProperty';
+  key: 'opacity';
+  value: string;
+}
+declare const OpacityProperty = "OpacityProperty";
+interface OutgoingRelationExpr extends langium.AstNode {
+  readonly $container: DirectedRelationExpr | Expressions | RelationExprWhere | RelationExprWith;
+  readonly $type: 'OutgoingRelationExpr';
+  dotKind?: RelationKindDotRef;
+  from: FqnExpr$2;
+  isBidirectional: boolean;
+  kind?: langium.Reference<RelationshipKind>;
+}
+declare const OutgoingRelationExpr = "OutgoingRelationExpr";
+interface PaddingSizeProperty extends langium.AstNode {
+  readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleStyle;
+  readonly $type: 'PaddingSizeProperty';
+  key: 'padding';
+  value: SizeValue;
+}
+declare const PaddingSizeProperty = "PaddingSizeProperty";
+interface Relation extends langium.AstNode {
+  readonly $container: ElementBody | ExtendElementBody | Model;
+  readonly $type: 'Relation';
+  body?: RelationBody;
+  description?: string;
+  dotKind?: RelationKindDotRef;
+  kind?: langium.Reference<RelationshipKind>;
+  source?: FqnRef$2;
+  tags?: Tags;
+  target: FqnRef$2;
+  technology?: string;
+  title?: string;
+}
+declare const Relation = "Relation";
+interface RelationBody extends langium.AstNode {
+  readonly $container: Relation;
+  readonly $type: 'RelationBody';
+  props: Array<RelationProperty>;
+  tags?: Tags;
+}
+declare const RelationBody = "RelationBody";
+interface RelationExprWhere extends langium.AstNode {
+  readonly $container: Expressions | RelationExprWith;
+  readonly $type: 'RelationExprWhere';
+  subject: RelationExpr$1;
+  where?: WhereRelationExpression;
+}
+declare const RelationExprWhere = "RelationExprWhere";
+interface RelationExprWith extends langium.AstNode {
+  readonly $container: Expressions;
+  readonly $type: 'RelationExprWith';
+  custom?: CustomRelationProperties;
+  subject: RelationExprOrWhere;
+}
+declare const RelationExprWith = "RelationExprWith";
+interface RelationKindDotRef extends langium.AstNode {
+  readonly $container: AbstractDynamicStep | DeploymentRelation | ExtendRelation | OutgoingRelationExpr | Relation;
+  readonly $type: 'RelationKindDotRef';
+  kind: langium.Reference<RelationshipKind>;
+}
+declare const RelationKindDotRef = "RelationKindDotRef";
+interface RelationNavigateToProperty extends langium.AstNode {
+  readonly $container: CustomRelationProperties | DeploymentRelationBody | RelationBody;
+  readonly $type: 'RelationNavigateToProperty';
+  key: 'navigateTo';
+  value: DynamicViewRef;
+}
+declare const RelationNavigateToProperty = "RelationNavigateToProperty";
+interface RelationshipKind extends langium.AstNode {
+  readonly $container: SpecificationRelationshipKind;
+  readonly $type: 'RelationshipKind';
+  name: Id;
+}
+declare const RelationshipKind = "RelationshipKind";
+interface RelationStringProperty extends langium.AstNode {
+  readonly $container: CustomRelationProperties | DeploymentRelationBody | RelationBody;
+  readonly $type: 'RelationStringProperty';
+  key: 'description' | 'technology' | 'title';
+  value: MarkdownOrString;
+}
+declare const RelationStringProperty = "RelationStringProperty";
+interface RelationStyleProperty extends langium.AstNode {
+  readonly $container: DeploymentRelationBody | RelationBody;
+  readonly $type: 'RelationStyleProperty';
+  key: 'style';
+  props: Array<RelationshipStyleProperty>;
+}
+declare const RelationStyleProperty = "RelationStyleProperty";
+interface RGBAColor extends langium.AstNode {
+  readonly $container: SpecificationColor | SpecificationTag;
+  readonly $type: 'RGBAColor';
+  alpha?: number | string;
+  blue: number;
+  green: number;
+  red: number;
+}
+declare const RGBAColor = "RGBAColor";
+interface ShapeProperty extends langium.AstNode {
+  readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleStyle;
+  readonly $type: 'ShapeProperty';
+  key: 'shape';
+  value: ElementShape;
+}
+declare const ShapeProperty = "ShapeProperty";
+interface ShapeSizeProperty extends langium.AstNode {
+  readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleStyle;
+  readonly $type: 'ShapeSizeProperty';
+  key: 'size';
+  value: SizeValue;
+}
+declare const ShapeSizeProperty = "ShapeSizeProperty";
+interface SpecificationColor extends langium.AstNode {
+  readonly $container: SpecificationRule;
+  readonly $type: 'SpecificationColor';
+  color: ColorLiteral$1;
+  name: CustomColor;
+}
+declare const SpecificationColor = "SpecificationColor";
+interface SpecificationDeploymentNodeKind extends langium.AstNode {
+  readonly $container: SpecificationRule;
+  readonly $type: 'SpecificationDeploymentNodeKind';
+  kind: DeploymentNodeKind;
+  props: Array<ElementStyleProperty | LinkProperty | SpecificationElementStringProperty>;
+  tags?: Tags;
+}
+declare const SpecificationDeploymentNodeKind = "SpecificationDeploymentNodeKind";
+interface SpecificationElementKind extends langium.AstNode {
+  readonly $container: SpecificationRule;
+  readonly $type: 'SpecificationElementKind';
+  kind: ElementKind;
+  props: Array<ElementStyleProperty | LinkProperty | SpecificationElementStringProperty>;
+  tags?: Tags;
+}
+declare const SpecificationElementKind = "SpecificationElementKind";
+interface SpecificationElementStringProperty extends langium.AstNode {
+  readonly $container: SpecificationDeploymentNodeKind | SpecificationElementKind;
+  readonly $type: 'SpecificationElementStringProperty';
+  key: 'description' | 'notation' | 'summary' | 'technology' | 'title';
+  value: MarkdownOrString;
+}
+declare const SpecificationElementStringProperty = "SpecificationElementStringProperty";
+interface SpecificationRelationshipKind extends langium.AstNode {
+  readonly $container: SpecificationRule;
+  readonly $type: 'SpecificationRelationshipKind';
+  kind: RelationshipKind;
+  props: Array<RelationshipStyleProperty | SpecificationRelationshipStringProperty>;
+}
+declare const SpecificationRelationshipKind = "SpecificationRelationshipKind";
+interface SpecificationRelationshipStringProperty extends langium.AstNode {
+  readonly $container: SpecificationRelationshipKind;
+  readonly $type: 'SpecificationRelationshipStringProperty';
+  key: 'notation' | 'technology';
+  value: MarkdownOrString;
+}
+declare const SpecificationRelationshipStringProperty = "SpecificationRelationshipStringProperty";
+interface SpecificationRule extends langium.AstNode {
+  readonly $container: LikeC4Grammar;
+  readonly $type: 'SpecificationRule';
+  colors: Array<SpecificationColor>;
+  deploymentNodes: Array<SpecificationDeploymentNodeKind>;
+  elements: Array<SpecificationElementKind>;
+  name: 'specification';
+  relationships: Array<SpecificationRelationshipKind>;
+  tags: Array<SpecificationTag>;
+}
+declare const SpecificationRule = "SpecificationRule";
+interface SpecificationTag extends langium.AstNode {
+  readonly $container: SpecificationRule;
+  readonly $type: 'SpecificationTag';
+  color?: ColorLiteral$1;
+  tag: Tag$1;
+}
+declare const SpecificationTag = "SpecificationTag";
+interface StrictFqnElementRef extends langium.AstNode {
+  readonly $container: ExtendElement | StrictFqnElementRef;
+  readonly $type: 'StrictFqnElementRef';
+  el: langium.Reference<Element>;
+  parent?: StrictFqnElementRef;
+}
+declare const StrictFqnElementRef = "StrictFqnElementRef";
+interface StrictFqnRef extends langium.AstNode {
+  readonly $container: ExtendDeployment | StrictFqnRef;
+  readonly $type: 'StrictFqnRef';
+  parent?: StrictFqnRef;
+  value: langium.Reference<Referenceable>;
+}
+declare const StrictFqnRef = "StrictFqnRef";
+interface Tag$1 extends langium.AstNode {
+  readonly $container: SpecificationTag;
+  readonly $type: 'Tag';
+  name: Id;
+}
+declare const Tag$1 = "Tag";
+interface TagRef extends langium.AstNode {
+  readonly $container: ElementTagExpression | Tags | WhereElementTag | WhereRelationParticipantTag | WhereRelationTag;
+  readonly $type: 'TagRef';
+  tag: langium.Reference<Tag$1>;
+}
+declare const TagRef = "TagRef";
+interface Tags extends langium.AstNode {
+  readonly $container: DeployedInstanceBody | DeploymentNodeBody | DeploymentRelation | DeploymentRelationBody | DeploymentViewBody | DynamicViewBody | ElementBody | ElementViewBody | ExtendDeploymentBody | ExtendElementBody | ExtendRelationBody | Relation | RelationBody | SpecificationDeploymentNodeKind | SpecificationElementKind | Tags;
+  readonly $type: 'Tags';
+  prev?: Tags;
+  values: Array<TagRef>;
+}
+declare const Tags = "Tags";
+interface TextSizeProperty extends langium.AstNode {
+  readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleStyle;
+  readonly $type: 'TextSizeProperty';
+  key: 'textSize';
+  value: SizeValue;
+}
+declare const TextSizeProperty = "TextSizeProperty";
+interface ViewRef extends langium.AstNode {
+  readonly $container: NavigateToProperty;
+  readonly $type: 'ViewRef';
+  view: langium.Reference<LikeC4View>;
+}
+declare const ViewRef = "ViewRef";
+interface ViewRuleAutoLayout extends langium.AstNode {
+  readonly $container: DeploymentViewBody | DynamicViewBody | ElementViewBody;
+  readonly $type: 'ViewRuleAutoLayout';
+  direction: ViewLayoutDirection;
+  nodeSep?: number;
+  rankSep?: number;
+}
+declare const ViewRuleAutoLayout = "ViewRuleAutoLayout";
+interface ViewRuleGlobalPredicateRef extends langium.AstNode {
+  readonly $container: ElementViewBody;
+  readonly $type: 'ViewRuleGlobalPredicateRef';
+  predicate: langium.Reference<GlobalPredicateGroup>;
+}
+declare const ViewRuleGlobalPredicateRef = "ViewRuleGlobalPredicateRef";
+interface ViewRuleGlobalStyle extends langium.AstNode {
+  readonly $container: DynamicViewBody | ElementViewBody | ModelViews;
+  readonly $type: 'ViewRuleGlobalStyle';
+  style: langium.Reference<GlobalStyleId>;
+}
+declare const ViewRuleGlobalStyle = "ViewRuleGlobalStyle";
+interface ViewRuleGroup extends langium.AstNode {
+  readonly $container: ElementViewBody | ViewRuleGroup;
+  readonly $type: 'ViewRuleGroup';
+  groupRules: Array<ViewRuleGroup | ViewRulePredicate>;
+  props: Array<BorderProperty | ColorProperty | OpacityProperty>;
+  title?: string;
+}
+declare const ViewRuleGroup = "ViewRuleGroup";
+interface ViewRulePredicate extends langium.AstNode {
+  readonly $container: ElementViewBody | GlobalPredicateGroup | ViewRuleGroup;
+  readonly $type: 'ViewRulePredicate';
+  exprs: Expressions;
+  isInclude: boolean;
+}
+declare const ViewRulePredicate = "ViewRulePredicate";
+interface ViewRuleRank extends langium.AstNode {
+  readonly $container: ElementViewBody;
+  readonly $type: 'ViewRuleRank';
+  targets: FqnExpressions;
+  value?: RankValue;
+}
+declare const ViewRuleRank = "ViewRuleRank";
+interface ViewRuleStyle extends langium.AstNode {
+  readonly $container: DynamicViewBody | ElementViewBody | GlobalStyleGroup | ModelViews;
+  readonly $type: 'ViewRuleStyle';
+  props: Array<NotationProperty | StyleProperty>;
+  targets: FqnExpressions;
+}
+declare const ViewRuleStyle = "ViewRuleStyle";
+interface ViewStringProperty extends langium.AstNode {
+  readonly $container: DeploymentViewBody | DynamicViewBody | ElementViewBody;
+  readonly $type: 'ViewStringProperty';
+  key: 'description' | 'title';
+  value: MarkdownOrString;
+}
+declare const ViewStringProperty = "ViewStringProperty";
+interface WhereBinaryExpression extends langium.AstNode {
+  readonly $container: FqnExprWhere | RelationExprWhere | WhereBinaryExpression | WhereElementNegation | WhereRelationNegation;
+  readonly $type: 'WhereBinaryExpression';
+  left: WhereElementExpression | WhereRelationExpression;
+  operator: 'and' | 'or';
+  right: WhereElementExpression | WhereRelationExpression;
+}
+declare const WhereBinaryExpression = "WhereBinaryExpression";
+interface WhereElementKind extends langium.AstNode {
+  readonly $container: FqnExprWhere | WhereBinaryExpression | WhereElementNegation;
+  readonly $type: 'WhereElementKind';
+  not: boolean;
+  operator: 'is' | string;
+  value: langium.Reference<DeploymentNodeOrElementKind>;
+}
+declare const WhereElementKind = "WhereElementKind";
+interface WhereElementNegation extends langium.AstNode {
+  readonly $container: FqnExprWhere | WhereBinaryExpression | WhereElementNegation;
+  readonly $type: 'WhereElementNegation';
+  value: WhereElementExpression;
+}
+declare const WhereElementNegation = "WhereElementNegation";
+interface WhereElementTag extends langium.AstNode {
+  readonly $container: FqnExprWhere | WhereBinaryExpression | WhereElementNegation;
+  readonly $type: 'WhereElementTag';
+  not: boolean;
+  operator: 'is' | string;
+  value: TagRef;
+}
+declare const WhereElementTag = "WhereElementTag";
+interface WhereRelationKind extends langium.AstNode {
+  readonly $container: RelationExprWhere | WhereBinaryExpression | WhereRelationNegation;
+  readonly $type: 'WhereRelationKind';
+  not: boolean;
+  operator: 'is' | string;
+  value: langium.Reference<RelationshipKind>;
+}
+declare const WhereRelationKind = "WhereRelationKind";
+interface WhereRelationNegation extends langium.AstNode {
+  readonly $container: RelationExprWhere | WhereBinaryExpression | WhereRelationNegation;
+  readonly $type: 'WhereRelationNegation';
+  value: WhereRelationExpression;
+}
+declare const WhereRelationNegation = "WhereRelationNegation";
+interface WhereRelationParticipantKind extends langium.AstNode {
+  readonly $container: RelationExprWhere | WhereBinaryExpression | WhereRelationNegation;
+  readonly $type: 'WhereRelationParticipantKind';
+  not: boolean;
+  operator: 'is' | string;
+  participant: Participant;
+  value: langium.Reference<DeploymentNodeOrElementKind>;
+}
+declare const WhereRelationParticipantKind = "WhereRelationParticipantKind";
+interface WhereRelationParticipantTag extends langium.AstNode {
+  readonly $container: RelationExprWhere | WhereBinaryExpression | WhereRelationNegation;
+  readonly $type: 'WhereRelationParticipantTag';
+  not: boolean;
+  operator: 'is' | string;
+  participant: Participant;
+  value: TagRef;
+}
+declare const WhereRelationParticipantTag = "WhereRelationParticipantTag";
+interface WhereRelationTag extends langium.AstNode {
+  readonly $container: RelationExprWhere | WhereBinaryExpression | WhereRelationNegation;
+  readonly $type: 'WhereRelationTag';
+  not: boolean;
+  operator: 'is' | string;
+  value: TagRef;
+}
+declare const WhereRelationTag = "WhereRelationTag";
+interface WildcardExpression extends langium.AstNode {
+  readonly $container: DirectedRelationExpr | Expressions | FqnExprWhere | FqnExprWith | FqnExpressions | IncomingRelationExpr | OutgoingRelationExpr;
+  readonly $type: 'WildcardExpression';
+  isWildcard: boolean;
+}
+declare const WildcardExpression = "WildcardExpression";
+interface DynamicStepChain extends AbstractDynamicStep {
+  readonly $container: DynamicStepChain | DynamicViewBody | DynamicViewParallelSteps;
+  readonly $type: 'DynamicStepChain';
+  source: DynamicStepChain | DynamicStepSingle;
+}
+declare const DynamicStepChain = "DynamicStepChain";
+interface DynamicStepSingle extends AbstractDynamicStep {
+  readonly $container: DynamicStepChain | DynamicViewBody | DynamicViewParallelSteps;
+  readonly $type: 'DynamicStepSingle';
+  isBackward: boolean;
+  source: ElementRef;
+}
+declare const DynamicStepSingle = "DynamicStepSingle";
+type LikeC4AstType = {
+  AbstractDynamicStep: AbstractDynamicStep;
+  AnyProperty: AnyProperty;
+  ArrowProperty: ArrowProperty;
+  BorderProperty: BorderProperty;
+  ColorLiteral: ColorLiteral$1;
+  ColorProperty: ColorProperty;
+  CustomColor: CustomColor;
+  CustomElementProperties: CustomElementProperties;
+  CustomRelationProperties: CustomRelationProperties;
+  DeployedInstance: DeployedInstance;
+  DeployedInstanceBody: DeployedInstanceBody;
+  DeploymentElement: DeploymentElement;
+  DeploymentNode: DeploymentNode;
+  DeploymentNodeBody: DeploymentNodeBody;
+  DeploymentNodeKind: DeploymentNodeKind;
+  DeploymentNodeOrElementKind: DeploymentNodeOrElementKind;
+  DeploymentRelation: DeploymentRelation;
+  DeploymentRelationBody: DeploymentRelationBody;
+  DeploymentView: DeploymentView;
+  DeploymentViewBody: DeploymentViewBody;
+  DeploymentViewRule: DeploymentViewRule;
+  DeploymentViewRulePredicate: DeploymentViewRulePredicate;
+  DeploymentViewRuleStyle: DeploymentViewRuleStyle;
+  DirectedRelationExpr: DirectedRelationExpr;
+  DynamicStepChain: DynamicStepChain;
+  DynamicStepSingle: DynamicStepSingle;
+  DynamicView: DynamicView;
+  DynamicViewBody: DynamicViewBody;
+  DynamicViewDisplayVariantProperty: DynamicViewDisplayVariantProperty;
+  DynamicViewGlobalPredicateRef: DynamicViewGlobalPredicateRef;
+  DynamicViewIncludePredicate: DynamicViewIncludePredicate;
+  DynamicViewParallelSteps: DynamicViewParallelSteps;
+  DynamicViewProperty: DynamicViewProperty;
+  DynamicViewRef: DynamicViewRef;
+  DynamicViewRule: DynamicViewRule;
+  DynamicViewStep: DynamicViewStep;
+  Element: Element;
+  ElementBody: ElementBody;
+  ElementKind: ElementKind;
+  ElementKindExpression: ElementKindExpression;
+  ElementProperty: ElementProperty;
+  ElementRef: ElementRef;
+  ElementStringProperty: ElementStringProperty;
+  ElementStyleProperty: ElementStyleProperty;
+  ElementTagExpression: ElementTagExpression;
+  ElementView: ElementView;
+  ElementViewBody: ElementViewBody;
+  ElementViewRef: ElementViewRef;
+  ExpressionV2: ExpressionV2;
+  Expressions: Expressions;
+  ExtendDeployment: ExtendDeployment;
+  ExtendDeploymentBody: ExtendDeploymentBody;
+  ExtendElement: ExtendElement;
+  ExtendElementBody: ExtendElementBody;
+  ExtendElementProperty: ExtendElementProperty;
+  ExtendRelation: ExtendRelation;
+  ExtendRelationBody: ExtendRelationBody;
+  ExtendRelationProperty: ExtendRelationProperty;
+  FqnExpr: FqnExpr$2;
+  FqnExprOrWhere: FqnExprOrWhere;
+  FqnExprOrWith: FqnExprOrWith;
+  FqnExprWhere: FqnExprWhere;
+  FqnExprWith: FqnExprWith;
+  FqnExpressions: FqnExpressions;
+  FqnRef: FqnRef$2;
+  FqnRefExpr: FqnRefExpr;
+  FqnReferenceable: FqnReferenceable;
+  GlobalDynamicPredicateGroup: GlobalDynamicPredicateGroup;
+  GlobalPredicateGroup: GlobalPredicateGroup;
+  GlobalStyle: GlobalStyle;
+  GlobalStyleGroup: GlobalStyleGroup;
+  GlobalStyleId: GlobalStyleId;
+  Globals: Globals;
+  HexColor: HexColor;
+  IconColorProperty: IconColorProperty;
+  IconPositionProperty: IconPositionProperty;
+  IconProperty: IconProperty;
+  IconSizeProperty: IconSizeProperty;
+  Imported: Imported;
+  ImportsFromPoject: ImportsFromPoject;
+  InOutRelationExpr: InOutRelationExpr;
+  IncomingRelationExpr: IncomingRelationExpr;
+  LibIcon: LibIcon;
+  LikeC4Grammar: LikeC4Grammar;
+  LikeC4Lib: LikeC4Lib;
+  LikeC4View: LikeC4View;
+  LineProperty: LineProperty;
+  LinkProperty: LinkProperty;
+  MarkdownOrString: MarkdownOrString;
+  MetadataArray: MetadataArray;
+  MetadataAttribute: MetadataAttribute;
+  MetadataBody: MetadataBody;
+  MetadataProperty: MetadataProperty;
+  MetadataValue: MetadataValue;
+  Model: Model;
+  ModelDeployments: ModelDeployments;
+  ModelReferenceable: ModelReferenceable;
+  ModelViews: ModelViews;
+  MultipleProperty: MultipleProperty;
+  NavigateToProperty: NavigateToProperty;
+  NotationProperty: NotationProperty;
+  NotesProperty: NotesProperty;
+  OpacityProperty: OpacityProperty;
+  OutgoingRelationExpr: OutgoingRelationExpr;
+  PaddingSizeProperty: PaddingSizeProperty;
+  RGBAColor: RGBAColor;
+  Referenceable: Referenceable;
+  Relation: Relation;
+  RelationBody: RelationBody;
+  RelationExpr: RelationExpr$1;
+  RelationExprOrWhere: RelationExprOrWhere;
+  RelationExprOrWith: RelationExprOrWith;
+  RelationExprWhere: RelationExprWhere;
+  RelationExprWith: RelationExprWith;
+  RelationKindDotRef: RelationKindDotRef;
+  RelationNavigateToProperty: RelationNavigateToProperty;
+  RelationProperty: RelationProperty;
+  RelationStringProperty: RelationStringProperty;
+  RelationStyleProperty: RelationStyleProperty;
+  RelationshipKind: RelationshipKind;
+  RelationshipStyleProperty: RelationshipStyleProperty;
+  ShapeProperty: ShapeProperty;
+  ShapeSizeProperty: ShapeSizeProperty;
+  SizeProperty: SizeProperty;
+  SpecificationColor: SpecificationColor;
+  SpecificationDeploymentNodeKind: SpecificationDeploymentNodeKind;
+  SpecificationElementKind: SpecificationElementKind;
+  SpecificationElementStringProperty: SpecificationElementStringProperty;
+  SpecificationRelationshipKind: SpecificationRelationshipKind;
+  SpecificationRelationshipStringProperty: SpecificationRelationshipStringProperty;
+  SpecificationRule: SpecificationRule;
+  SpecificationTag: SpecificationTag;
+  StrictFqnElementRef: StrictFqnElementRef;
+  StrictFqnRef: StrictFqnRef;
+  StringProperty: StringProperty;
+  StyleProperty: StyleProperty;
+  Tag: Tag$1;
+  TagRef: TagRef;
+  Tags: Tags;
+  TextSizeProperty: TextSizeProperty;
+  ViewProperty: ViewProperty;
+  ViewRef: ViewRef;
+  ViewRule: ViewRule;
+  ViewRuleAutoLayout: ViewRuleAutoLayout;
+  ViewRuleGlobalPredicateRef: ViewRuleGlobalPredicateRef;
+  ViewRuleGlobalStyle: ViewRuleGlobalStyle;
+  ViewRuleGroup: ViewRuleGroup;
+  ViewRulePredicate: ViewRulePredicate;
+  ViewRuleRank: ViewRuleRank;
+  ViewRuleStyle: ViewRuleStyle;
+  ViewRuleStyleOrGlobalRef: ViewRuleStyleOrGlobalRef;
+  ViewStringProperty: ViewStringProperty;
+  WhereBinaryExpression: WhereBinaryExpression;
+  WhereElement: WhereElement;
+  WhereElementExpression: WhereElementExpression;
+  WhereElementKind: WhereElementKind;
+  WhereElementNegation: WhereElementNegation;
+  WhereElementTag: WhereElementTag;
+  WhereExpression: WhereExpression;
+  WhereKindEqual: WhereKindEqual;
+  WhereRelation: WhereRelation;
+  WhereRelationExpression: WhereRelationExpression;
+  WhereRelationKind: WhereRelationKind;
+  WhereRelationNegation: WhereRelationNegation;
+  WhereRelationParticipantKind: WhereRelationParticipantKind;
+  WhereRelationParticipantTag: WhereRelationParticipantTag;
+  WhereRelationTag: WhereRelationTag;
+  WhereTagEqual: WhereTagEqual;
+  WildcardExpression: WildcardExpression;
+};
+//#endregion
+//#region src/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
+declare const isValidatableAstNode: any;
+type ValidatableAstNode = GuardedBy<typeof isValidatableAstNode>;
+declare function checksFromDiagnostics(doc: LikeC4LangiumDocument): {
+  isValid: (n: ValidatableAstNode) => boolean;
+  invalidNodes: WeakSet<WeakKey>;
+};
+type ChecksFromDiagnostics = ReturnType<typeof checksFromDiagnostics>;
+type IsValidFn = ChecksFromDiagnostics['isValid'];
+//#endregion
+//#region src/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;
+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;
+}
+//#endregion
+//#region src/references/name-provider.d.ts
+declare class LikeC4NameProvider extends DefaultNameProvider {
+  protected services: LikeC4Services;
+  constructor(services: LikeC4Services);
+  getNameStrict(node: AstNode): string;
+  getName(node: AstNode): string | undefined;
+  getNameNode(node: AstNode): CstNode | undefined;
+}
+//#endregion
+//#region src/references/scope-computation.d.ts
+type ElementsContainer = Model | ElementBody | ExtendElementBody;
+type DeploymentsContainer = ModelDeployments | DeploymentNodeBody | ExtendDeploymentBody | DeployedInstanceBody;
+declare class LikeC4ScopeComputation extends DefaultScopeComputation {
+  constructor(services: LikeC4Services);
+  computeExports(document: LikeC4LangiumDocument, _cancelToken?: CancellationToken): Promise<AstNodeDescription[]>;
+  private exportViews;
+  private exportGlobals;
+  private exportModel;
+  private exportLibrary;
+  private exportSpecification;
+  private exportDeployments;
+  computeLocalScopes(document: LikeC4LangiumDocument, _cancelToken?: CancellationToken): Promise<PrecomputedScopes>;
+  protected processContainer(container: ElementsContainer, scopes: PrecomputedScopes, document: LikeC4LangiumDocument): AstNodeDescription[];
+  protected processDeployments(container: DeploymentsContainer, scopes: PrecomputedScopes, document: LikeC4LangiumDocument): AstNodeDescription[];
+}
+//#endregion
+//#region src/workspace/IndexManager.d.ts
+declare class IndexManager extends DefaultIndexManager {
+  protected services: LikeC4SharedServices;
+  constructor(services: LikeC4SharedServices);
+  updateContent(document: LangiumDocument, cancelToken?: CancellationToken): Promise<void>;
+  projectElements(projectId: ProjectId, nodeType?: string, uris?: Set<string>): Stream<AstNodeDescription>;
+}
+//#endregion
+//#region src/workspace/LangiumDocuments.d.ts
+declare class LangiumDocuments extends DefaultLangiumDocuments {
+  protected services: LikeC4SharedServices;
+  constructor(services: LikeC4SharedServices);
+  protected get projectsManager(): ProjectsManager;
+  addDocument(document: LangiumDocument): void;
+  getDocument(uri: URI): LangiumDocument | undefined;
+  /**
+   * Returns all user documents
+   */
+  get userDocuments(): Stream<LikeC4LangiumDocument>;
+  /**
+   * Returns all documents (ensures project IDs are set)
+   */
+  get all(): Stream<LangiumDocument>;
+  /**
+   * Returns all documents for a project, including both project documents and documents included by the project.
+   */
+  projectDocuments(projectId: ProjectId): Stream<LikeC4LangiumDocument>;
+  groupedByProject(): Record<ProjectId, NonEmptyArray<LikeC4LangiumDocument>>;
+  /**
+   * Reset the project IDs of all documents.
+   * Returns the URIs
+   */
+  resetProjectIds(): URI[];
+}
+//#endregion
+//#region src/workspace/WorkspaceManager.d.ts
+declare class LikeC4WorkspaceManager extends DefaultWorkspaceManager {
+  #private;
+  private services;
+  protected readonly documentFactory: LangiumDocumentFactory;
+  protected readonly fileSystemProvider: FileSystemProvider$1;
+  initialBuildOptions: BuildOptions;
+  constructor(services: LikeC4SharedServices);
+  /**
+   * First load all project config files, then load all documents in the workspace.
+   */
+  protected performStartup(folders: WorkspaceFolder[]): Promise<LangiumDocument[]>;
+  /**
+   * Load all additional documents that shall be visible in the context of the given workspace
+   * folders and add them to the collector. This can be used to include built-in libraries of
+   * your language, which can be either loaded from provided files or constructed in memory.
+   */
+  protected loadAdditionalDocuments(folders: WorkspaceFolder[], collector: (document: LangiumDocument) => void): Promise<void>;
+  /**
+   * Determine whether the given folder entry shall be included while indexing the workspace.
+   */
+  protected includeEntry(_: WorkspaceFolder, entry: FileSystemNode, selector: FileSelector): boolean;
+  workspace(): WorkspaceFolder | null;
+  rebuildAll(cancelToken?: Cancellation.CancellationToken): Promise<void>;
+  get workspaceUri(): URI$2;
+  get workspaceURL(): URL;
+  /**
+   * Force clean all caches
+   */
+  forceCleanCaches(): void;
+  /**
+   * Register a listener to be called when caches are force cleaned
+   */
+  onForceCleanCache(listener: () => void): Disposable;
+}
+//#endregion
+//#region src/references/scope-provider.d.ts
+declare class LikeC4ScopeProvider extends DefaultScopeProvider {
+  protected deploymentsIndex: DeploymentsIndex;
+  protected fqnIndex: FqnIndex;
+  protected readonly indexManager: IndexManager;
+  constructor(services: LikeC4Services);
+  getScope(context: ReferenceInfo): Scope;
+  protected genUniqueDescedants(element: Element | DeploymentNode | undefined): Generator<AstNodeDescriptionWithFqn, void, any>;
+  protected genScopeExtendElement({
+    element
+  }: ExtendElement): Generator<AstNodeDescription>;
+  protected genScopeElementView({
+    viewOf,
+    extends: ext
+  }: ElementView): Generator<AstNodeDescription>;
+  protected getScopeForStrictFqnRef(projectId: ProjectId, container: StrictFqnRef, context: ReferenceInfo): Scope;
+  protected genScopeExtendDeployment({
+    deploymentNode
+  }: ExtendDeployment): Generator<AstNodeDescription>;
+  protected streamForFqnRef(projectId: ProjectId, container: FqnRef$2, context: ReferenceInfo): Stream<AstNodeDescription>;
+  protected genScopeForParentlessFqnRef(projectId: ProjectId, container: FqnRef$2, context: ReferenceInfo): Generator<AstNodeDescription>;
+  /**
+   * Computes the scope for a given reference context.
+   *
+   * @param context - The reference information containing the context for which the scope is being computed.
+   * @param referenceType - The type of reference being resolved. Defaults to the reference type derived from the context.
+   * @returns A scope containing the relevant AST node descriptions for the given reference context.
+   *
+   * This method first checks if there are precomputed scopes available in the document. If not, it falls back to the global scope.
+   * It then iterates through the container hierarchy, collecting relevant scopes based on the reference type and container type.
+   * Finally, it combines the collected scopes with the global scope to produce the final scope.
+   */
+  protected computeScope(projectId: ProjectId, context: ReferenceInfo, referenceType?: string): Generator<AstNodeDescription>;
+  /**
+   * Create a global scope filtered for the given reference type.
+   */
+  protected getProjectScope(projectId: ProjectId, referenceType: string, context: ReferenceInfo): Scope;
+  /**
+   * Create a global scope filtered for the given reference type.
+   */
+  protected getGlobalScope(referenceType: string, context: ReferenceInfo): Scope;
+}
+//#endregion
+//#region src/utils/disposable.d.ts
+declare abstract class ADisposable implements Disposable {
+  protected toDispose: Disposable[];
+  protected isDisposed: boolean;
+  onDispose(...disposable: Disposable[]): void;
+  dispose(): void;
+  protected throwIfDisposed(): void;
+}
+//#endregion
+//#region src/model/fqn-index.d.ts
+declare class FqnIndex<AstNd = Element> extends ADisposable {
+  protected services: LikeC4Services;
+  protected projects: ProjectsManager;
+  protected langiumDocuments: LangiumDocuments;
+  protected documentCache: DefaultWeakMap<LikeC4LangiumDocument, DocumentFqnIndex>;
+  protected workspaceCache: WorkspaceCache<string, AstNodeDescriptionWithFqn[]>;
+  protected logger: any;
+  constructor(services: LikeC4Services);
+  private documents;
+  get(document: LikeC4LangiumDocument): DocumentFqnIndex;
+  resolve(reference: Referenceable): Fqn$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;
+  protected logger: any;
+  constructor(services: LikeC4Services);
+  protected createDocumentIndex(document: LikeC4LangiumDocument): DocumentFqnIndex;
+}
+//#endregion
+//#region src/model/builder/MergedSpecification.d.ts
+/**
+ * The `MergedSpecification` class is responsible for merging multiple parsed
+ * LikeC4Langium documents into a single specification. It consolidates tags,
+ * elements, deployments, relationships, and colors from the provided documents
+ * and provides methods to convert parsed models into C4 model elements and relations.
+ */
+declare class MergedSpecification {
+  readonly specs: Omit<ParsedAstSpecification, 'tags'>;
+  readonly tags: Readonly<Record<c4.Tag, c4.TagSpecification>>;
+  readonly globals: c4.ModelGlobals;
+  readonly imports: MultiMap$1<c4.ProjectId, c4.Fqn, Set<c4.Fqn>>;
+  readonly projectId: c4.ProjectId | undefined;
+  constructor(docs: ReadonlyArray<ParsedLikeC4LangiumDocument>);
+  /**
+   * Converts a parsed model into a C4 model element.
+   */
+  toModelElement: ({
+    tags,
+    links,
+    style,
+    id,
+    kind,
+    title,
+    description,
+    technology,
+    summary,
+    metadata
+  }: ParsedAstElement) => c4.Element | null;
+  /**
+   * Converts a parsed model into a C4 model relation.
+   */
+  toModelRelation: ({
+    astPath: _astPath,
+    source,
+    target,
+    kind,
+    links,
+    id,
+    ...model
+  }: ParsedAstRelation) => c4.Relationship | null;
+  /**
+   * Converts a parsed deployment model into a C4 deployment model
+   */
+  toDeploymentElement: (parsed: ParsedAstDeployment) => c4.DeploymentElement | null;
+  /**
+   * Converts a parsed deployment relation into a C4 deployment relation.
+   */
+  toDeploymentRelation: ({
+    astPath: _astPath,
+    source,
+    target,
+    kind,
+    links,
+    id,
+    ...model
+  }: ParsedAstDeploymentRelation) => c4.DeploymentRelationship | null;
+}
+//#endregion
+//#region src/model/last-seen-artifacts.d.ts
+/**
+ * Provides access to "last seen artifacts" for a given project,
+ * (Results of the last successful parsing)
+ */
+declare class LastSeenArtifacts {
+  #private;
+  constructor(services: LikeC4Services);
+  rememberSpecification(specification: MergedSpecification): MergedSpecification;
+  rememberModel<M extends LikeC4Model.Computed>(model: M): M;
+  specification(projectId: c4.ProjectId): MergedSpecification | undefined;
+  styles(projectId: c4.ProjectId): LikeC4Styles | undefined;
+  model(projectId: c4.ProjectId): LikeC4Model.Computed | undefined;
+}
+//#endregion
+//#region src/model/model-builder.d.ts
+type ModelParsedListener = (docs: URI[]) => void;
+interface LikeC4ModelBuilder extends Disposable {
+  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);
+  /**
+   * Returns the parsed documents
+   */
+  private documents;
+  getParsedElement(...args: [Element] | [c4.Fqn] | [c4.Fqn, c4.ProjectId]): null | {
+    projectId: c4.ProjectId;
+    element: ParsedAstElement;
+    document: LangiumDocument;
+  };
+  private findParsedElementByFqnIn;
+  locateElement(fqn: c4.Fqn, projectId?: c4.ProjectId | undefined): Location | null;
+  locateDeploymentElement(deploymentFqn: c4.DeploymentFqn, projectId?: c4.ProjectId | undefined): Location | null;
+  locateRelation(relationId: c4.RelationId, projectId?: c4.ProjectId): Location | null;
+  locateViewAst(viewId: c4.ViewId, projectId?: c4.ProjectId | undefined): null | ViewLocateResult;
+  locateView(viewId: c4.ViewId, projectId?: c4.ProjectId): Location | null;
+  /**
+   * Returns an array of tags with their name, color, range and whether they are defined in the specification or not.
+   * If the document is not linked, it will wait until it is linked before locating the tags.
+   *
+   * If the document does not belong to any project, it will return null.
+   */
+  locateDocumentTags(documentUri: URI$2, cancelToken?: Cancellation.CancellationToken): Promise<null | Array<{
+    name: Tag;
+    color: c4.ColorLiteral;
+    range: Range;
+    isSpecification: boolean;
+  }>>;
+  locateDynamicViewStep(params: {
+    view: c4.ViewId;
+    astPath: string;
+    projectId?: c4.ProjectId | undefined;
+  }): Location | null;
+}
+//#endregion
+//#region src/mcp/noop.d.ts
+declare const NoMCPServer: LikeC4MCPServerModuleContext;
+//#endregion
+//#region src/mcp/server/WithMCPServer.d.ts
+declare function WithMCPServer(type?: 'stdio' | 'sse' | {
+  port: number;
+}): LikeC4MCPServerModuleContext;
+//#endregion
+//#region src/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)
+   */
+  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/model/parser/Base.d.ts
+type ParserLevel = 'base' | 'model' | 'deployment' | 'fqnref' | 'relation' | 'views' | 'globals' | 'imports' | 'specification';
+declare class BaseParser {
+  readonly services: LikeC4Services;
+  readonly doc: ParsedLikeC4LangiumDocument;
+  readonly project: Project;
+  isValid: IsValidFn;
+  constructor(services: LikeC4Services, doc: ParsedLikeC4LangiumDocument, project: Project);
+  logError(error: unknown, astNode?: AstNode | Reference<AstNode>, level?: ParserLevel): void;
+  tryParse<N extends AstNode, T>(level: ParserLevel, node: N | undefined, fn: (node: NoInfer<N>) => T | undefined): T | undefined;
+  tryMap<N extends AstNode, T>(level: ParserLevel, iterable: ReadonlyArray<N>, fn: (node: N) => T | undefined): T[];
+  resolveFqn(node: FqnReferenceable): c4.Fqn;
+  getAstNodePath(node: AstNode): string;
+  getMetadata(metadataAstNode: MetadataProperty | undefined): {
+    [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.NonEmptyArray<c4.Link> | undefined;
+  parseLinks(source?: LinkProperty['$container']): c4.NonEmptyArray<c4.Link> | undefined;
+  parseIconProperty(prop: IconProperty | undefined): c4.IconUrl | undefined;
+  parseImageAlias(value: string): string | undefined;
+  parseColorLiteral(astNode: ColorLiteral$1): 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;
+    readonly project: Project;
+    logError(error: unknown, astNode?: langium.AstNode | langium.Reference<langium.AstNode>, level?: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification"): void;
+    tryParse<N extends langium.AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", node: N | undefined, fn: (node: NoInfer<N>) => T | undefined): T | undefined;
+    tryMap<N extends langium.AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", iterable: ReadonlyArray<N>, fn: (node: N) => T | undefined): T[];
+    resolveFqn(node: FqnReferenceable): ProjectId;
+    getAstNodePath(node: langium.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<ProjectId> | undefined;
+    parseLinks(source?: LinkProperty["$container"]): ProjectId<ProjectId> | undefined;
+    parseIconProperty(prop: IconProperty | undefined): ProjectId | undefined;
+    parseImageAlias(value: string): string | undefined;
+    parseColorLiteral(astNode: ColorLiteral$1): 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;
+    readonly project: Project;
+    logError(error: unknown, astNode?: langium.AstNode | langium.Reference<langium.AstNode>, level?: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification"): void;
+    tryParse<N extends langium.AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", node: N | undefined, fn: (node: NoInfer<N>) => T | undefined): T | undefined;
+    tryMap<N extends langium.AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", iterable: ReadonlyArray<N>, fn: (node: N) => T | undefined): T[];
+    resolveFqn(node: FqnReferenceable): ProjectId;
+    getAstNodePath(node: langium.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<ProjectId> | undefined;
+    parseLinks(source?: LinkProperty["$container"]): ProjectId<ProjectId> | undefined;
+    parseIconProperty(prop: IconProperty | undefined): ProjectId | undefined;
+    parseImageAlias(value: string): string | undefined;
+    parseColorLiteral(astNode: ColorLiteral$1): 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;
+    readonly project: Project;
+    logError(error: unknown, astNode?: langium.AstNode | langium.Reference<langium.AstNode>, level?: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification"): void;
+    tryParse<N extends langium.AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", node: N | undefined, fn: (node: NoInfer<N>) => T | undefined): T | undefined;
+    tryMap<N extends langium.AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", iterable: ReadonlyArray<N>, fn: (node: N) => T | undefined): T[];
+    resolveFqn(node: FqnReferenceable): ProjectId;
+    getAstNodePath(node: langium.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<ProjectId> | undefined;
+    parseLinks(source?: LinkProperty["$container"]): ProjectId<ProjectId> | undefined;
+    parseIconProperty(prop: IconProperty | undefined): ProjectId | undefined;
+    parseImageAlias(value: string): string | undefined;
+    parseColorLiteral(astNode: ColorLiteral$1): 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;
+    readonly project: Project;
+    logError(error: unknown, astNode?: langium.AstNode | langium.Reference<langium.AstNode>, level?: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification"): void;
+    tryParse<N extends langium.AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", node: N | undefined, fn: (node: NoInfer<N>) => T | undefined): T | undefined;
+    tryMap<N extends langium.AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", iterable: ReadonlyArray<N>, fn: (node: N) => T | undefined): T[];
+    resolveFqn(node: FqnReferenceable): ProjectId;
+    getAstNodePath(node: langium.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<ProjectId> | undefined;
+    parseLinks(source?: LinkProperty["$container"]): ProjectId<ProjectId> | undefined;
+    parseIconProperty(prop: IconProperty | undefined): ProjectId | undefined;
+    parseImageAlias(value: string): string | undefined;
+    parseColorLiteral(astNode: ColorLiteral$1): 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;
+    readonly project: Project;
+    logError(error: unknown, astNode?: langium.AstNode | langium.Reference<langium.AstNode>, level?: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification"): void;
+    tryParse<N extends langium.AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", node: N | undefined, fn: (node: NoInfer<N>) => T | undefined): T | undefined;
+    tryMap<N extends langium.AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", iterable: ReadonlyArray<N>, fn: (node: N) => T | undefined): T[];
+    resolveFqn(node: FqnReferenceable): ProjectId;
+    getAstNodePath(node: langium.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<ProjectId> | undefined;
+    parseLinks(source?: LinkProperty["$container"]): ProjectId<ProjectId> | undefined;
+    parseIconProperty(prop: IconProperty | undefined): ProjectId | undefined;
+    parseImageAlias(value: string): string | undefined;
+    parseColorLiteral(astNode: ColorLiteral$1): 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;
+    readonly project: Project;
+    logError(error: unknown, astNode?: langium.AstNode | langium.Reference<langium.AstNode>, level?: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification"): void;
+    tryParse<N extends langium.AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", node: N | undefined, fn: (node: NoInfer<N>) => T | undefined): T | undefined;
+    tryMap<N extends langium.AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", iterable: ReadonlyArray<N>, fn: (node: N) => T | undefined): T[];
+    resolveFqn(node: FqnReferenceable): ProjectId;
+    getAstNodePath(node: langium.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<ProjectId> | undefined;
+    parseLinks(source?: LinkProperty["$container"]): ProjectId<ProjectId> | undefined;
+    parseIconProperty(prop: IconProperty | undefined): ProjectId | undefined;
+    parseImageAlias(value: string): string | undefined;
+    parseColorLiteral(astNode: ColorLiteral$1): 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;
+    readonly project: Project;
+    logError(error: unknown, astNode?: langium.AstNode | langium.Reference<langium.AstNode>, level?: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification"): void;
+    tryParse<N extends langium.AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", node: N | undefined, fn: (node: NoInfer<N>) => T | undefined): T | undefined;
+    tryMap<N extends langium.AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", iterable: ReadonlyArray<N>, fn: (node: N) => T | undefined): T[];
+    resolveFqn(node: FqnReferenceable): ProjectId;
+    getAstNodePath(node: langium.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<ProjectId> | undefined;
+    parseLinks(source?: LinkProperty["$container"]): ProjectId<ProjectId> | undefined;
+    parseIconProperty(prop: IconProperty | undefined): ProjectId | undefined;
+    parseImageAlias(value: string): string | undefined;
+    parseColorLiteral(astNode: ColorLiteral$1): 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;
+    readonly project: Project;
+    logError(error: unknown, astNode?: langium.AstNode | langium.Reference<langium.AstNode>, level?: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification"): void;
+    tryParse<N extends langium.AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", node: N | undefined, fn: (node: NoInfer<N>) => T | undefined): T | undefined;
+    tryMap<N extends langium.AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", iterable: ReadonlyArray<N>, fn: (node: N) => T | undefined): T[];
+    resolveFqn(node: FqnReferenceable): ProjectId;
+    getAstNodePath(node: langium.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<ProjectId> | undefined;
+    parseLinks(source?: LinkProperty["$container"]): ProjectId<ProjectId> | undefined;
+    parseIconProperty(prop: IconProperty | undefined): ProjectId | undefined;
+    parseImageAlias(value: string): string | undefined;
+    parseColorLiteral(astNode: ColorLiteral$1): 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;
+    readonly project: Project;
+    logError(error: unknown, astNode?: langium.AstNode | langium.Reference<langium.AstNode>, level?: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification"): void;
+    tryParse<N extends langium.AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", node: N | undefined, fn: (node: NoInfer<N>) => T | undefined): T | undefined;
+    tryMap<N extends langium.AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", iterable: ReadonlyArray<N>, fn: (node: N) => T | undefined): T[];
+    resolveFqn(node: FqnReferenceable): ProjectId;
+    getAstNodePath(node: langium.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<ProjectId> | undefined;
+    parseLinks(source?: LinkProperty["$container"]): ProjectId<ProjectId> | undefined;
+    parseIconProperty(prop: IconProperty | undefined): ProjectId | undefined;
+    parseImageAlias(value: string): string | undefined;
+    parseColorLiteral(astNode: ColorLiteral$1): 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/model-change/ModelChanges.d.ts
+declare class LikeC4ModelChanges {
+  private services;
+  private locator;
+  constructor(services: LikeC4Services);
+  applyChange(changeView: ChangeView.Params): Promise<ChangeView.Res>;
+  protected convertToTextEdit({
+    lookup,
+    change
+  }: {
+    lookup: ViewLocateResult;
+    change: Exclude<ViewChange, ViewChange.SaveViewSnapshot | ViewChange.ResetManualLayout>;
+  }): {
+    modifiedRange: Range;
+    edits: TextEdit[];
+  };
+}
+//#endregion
+//#region src/LikeC4LanguageServices.d.ts
+interface LikeC4LanguageServices {
+  readonly views: LikeC4Views;
+  readonly builder: LikeC4ModelBuilder;
+  readonly workspaceUri: URI;
+  readonly projectsManager: ProjectsManager;
+  readonly editor: LikeC4ModelChanges;
+  readonly mcpServer: LikeC4MCPServer | null;
+  /**
+   * 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>;
+}
+//#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/lsp/DocumentSymbolProvider.d.ts
+declare class LikeC4DocumentSymbolProvider implements DocumentSymbolProvider {
+  private services;
+  protected readonly nodeKindProvider: NodeKindProvider;
+  protected readonly nameProvider: LikeC4NameProvider;
+  protected readonly parser: LikeC4ModelParser;
+  protected readonly locator: LikeC4ModelLocator;
+  constructor(services: LikeC4Services);
+  getSymbols(doc: LangiumDocument, _params: DocumentSymbolParams, cancelToken?: CancellationToken): Promise<DocumentSymbol[]>;
+  protected getLikec4LibSymbol(astLib: LikeC4Lib): DocumentSymbol[];
+  protected getSpecSymbol(astSpec: SpecificationRule): DocumentSymbol[];
+  protected getModelSymbol(astModel: Model): DocumentSymbol[];
+  protected getDeploymentModelSymbol(astModel: ModelDeployments): DocumentSymbol[];
+  protected getElementsSymbol(el: Element | Relation | ExtendElement): DocumentSymbol[];
+  protected getExtendElementSymbol(astElement: ExtendElement): DocumentSymbol[];
+  protected getElementSymbol(astElement: Element): DocumentSymbol[];
+  protected getModelViewsSymbol(astViews: ModelViews): DocumentSymbol[];
+  protected getKindSymbol(astKind: SpecificationElementKind | SpecificationRelationshipKind): DocumentSymbol | null;
+  protected getTagSymbol(astTag: SpecificationTag): DocumentSymbol | null;
+  protected getLibIconSymbol(astTag: LibIcon): DocumentSymbol | null;
+  protected getViewSymbol(astView: LikeC4View): DocumentSymbol[];
+  protected getDeploymentElementSymbol(el: DeploymentElement | DeploymentRelation | ExtendDeployment): DocumentSymbol[];
+  protected getDeploymentNodeSymbol(astElement: DeploymentNode): DocumentSymbol[];
+  protected getDeployedInstanceSymbol(astElement: DeployedInstance): DocumentSymbol[];
+  protected symbolKind(node: AstNode): SymbolKind;
+}
+//#endregion
+//#region src/lsp/HoverProvider.d.ts
+declare class LikeC4HoverProvider extends AstNodeHoverProvider {
+  protected services: LikeC4Services;
+  private parser;
+  private locator;
+  constructor(services: LikeC4Services);
+  protected getAstNodeHoverContent(node: AstNode): MaybePromise<Hover | undefined>;
+  protected getElementHover(node: Element): MaybePromise<Hover | undefined>;
+  protected getElementModelHover(model: ElementModel, projectId: ProjectId): string | undefined;
+  protected getDeploymentNodeHover(node: DeploymentNode): MaybePromise<Hover | undefined>;
+  protected getDeployedInstanceHover(node: DeployedInstance): MaybePromise<Hover | undefined>;
+}
+//#endregion
+//#region src/lsp/CodeActionProvider.d.ts
+type CommandOrCodeAction = Command | CodeAction;
+declare class LikeC4CodeActionProvider implements CodeActionProvider {
+  /**
+   * Handle a code action request.
+   *
+   * @throws `OperationCancelled` if cancellation is detected during execution
+   * @throws `ResponseError` if an error is detected that should be sent as response to the client
+   */
+  getCodeActions(document: LangiumDocument, params: CodeActionParams): CommandOrCodeAction[] | undefined;
+}
+//#endregion
+//#region src/lsp/SemanticTokenProvider.d.ts
+declare class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
+  protected services: LikeC4Services;
+  private rules;
+  constructor(services: LikeC4Services);
+  protected initRules(): void;
+  semanticHighlight(document: LangiumDocument, params: SemanticTokensParams, cancelToken?: CancellationToken$1): Promise<SemanticTokens>;
+  semanticHighlightRange(document: LangiumDocument, params: SemanticTokensRangeParams, cancelToken?: CancellationToken$1): Promise<SemanticTokens>;
+  semanticHighlightDelta(document: LangiumDocument, params: SemanticTokensDeltaParams, cancelToken?: CancellationToken$1): Promise<SemanticTokens | SemanticTokensDelta>;
+  protected ensureState(document: LangiumDocument, cancelToken: CancellationToken$1): Promise<void>;
+  protected highlightElement(node: AstNode, acceptor: SemanticTokenAcceptor): void | undefined | 'prune';
+  private highlightNameAndKind;
+  private highlightView;
+  private mark;
+}
+//#endregion
+//#region src/Rpc.d.ts
+declare class Rpc extends ADisposable {
+  private services;
+  constructor(services: LikeC4Services);
+  init: () => void;
+  openView(params: DidRequestOpenViewNotification.Params): Promise<void>;
+}
+//#endregion
+//#region src/shared/NodeKindProvider.d.ts
+declare class NodeKindProvider$1 implements NodeKindProvider {
+  private services;
+  constructor(services: LangiumSharedServices);
+  /**
+   * Returns a `SymbolKind` as used by `WorkspaceSymbolProvider` or `DocumentSymbolProvider`.
+   */
+  getSymbolKind(node: AstNode | AstNodeDescription): SymbolKind;
+  /**
+   * Returns a `CompletionItemKind` as used by the `CompletionProvider`.
+   */
+  getCompletionItemKind(node: AstNode | AstNodeDescription): CompletionItemKind;
+}
+//#endregion
+//#region src/shared/WorkspaceSymbolProvider.d.ts
+declare class WorkspaceSymbolProvider extends DefaultWorkspaceSymbolProvider {}
+//#endregion
+export { ProjectsManager as $, LikeC4ScopeComputation as A, NoFileSystem as B, LastSeenArtifacts as C, LikeC4WorkspaceManager as D, LikeC4ScopeProvider as E, LikeC4MCPServerModuleContext as F, FileSystemProvider$1 as G, NoLikeC4ManualLayouts as H, LikeC4Formatter as I, LikeC4ManualLayouts as J, FileSystemWatcher as K, WithLikeC4ManualLayouts as L, LikeC4DocumentValidator as M, LikeC4MCPServer as N, LangiumDocuments as O, LikeC4MCPServerFactory as P, ProjectData as Q, WithChokidarWatcher as R, LikeC4ModelBuilder as S, FqnIndex as T, FileNode as U, NoFileSystemWatcher as V, FileSystemModuleContext as W, ManualLayoutsSnapshot as X, LikeC4ManualLayoutsModuleContext as Y, Project as Z, LikeC4Views as _, LikeC4CodeActionProvider as a, LikeC4ModelLocator as b, LikeC4DocumentLinkProvider as c, LikeC4CodeLensProvider as d, LikeC4DocumentationProvider as et, LikeC4LanguageServices as f, LikeC4ModelParser as g, DocumentParser as h, LikeC4SemanticTokenProvider as i, LikeC4NameProvider as j, IndexManager as k, LikeC4DocumentHighlightProvider as l, LikeC4ValueConverter as m, NodeKindProvider$1 as n, LikeC4HoverProvider as o, LikeC4ModelChanges as p, FileSystemWatcherModuleContext as q, Rpc as r, LikeC4DocumentSymbolProvider as s, WorkspaceSymbolProvider as t, LikeC4CompletionProvider as u, WithMCPServer as v, DeploymentsIndex as w, ViewLocateResult as x, NoMCPServer as y, WithFileSystem as z };