likec4 1.47.0 → 1.49.0

package/dist/_chunks/index2.d.mts

@@ -0,0 +1,3442 @@
+import { n as ServerOptions, t as McpServer } from "./libs/@modelcontextprotocol/sdk.mjs";
+import { a as LikeC4ProjectConfig, i as IncludeConfig, o as LikeC4ProjectConfigInput } from "./index.mjs";
+import { $ as PrecomputedScopes, A as ValidationOptions, B as ReferenceDescription, C as CodeLensParams, Ct as TextEdit, D as SemanticTokensParams, E as SemanticTokensDeltaParams, F as MaybePromise, G as AstNode, H as WorkspaceCache, I as DefaultScopeProvider, J as Reference, K as AstNodeDescription, L as Scope, M as DefaultScopeComputation, N as DefaultValueConverter, O as SemanticTokensRangeParams, P as ValueType, Q as LangiumDocumentFactory, R as JSDocDocumentationProvider, S as CodeActionParams, St as SymbolKind, T as DocumentSymbolParams, U as AsyncDisposable, V as DefaultNameProvider, W as Disposable$1, X as DefaultLangiumDocuments, Y as ReferenceInfo, Z as LangiumDocument, _ as CodeLensProvider, _t as Hover, a as LangiumServices, at as CancellationToken$1, b as FileSelector, bt as SemanticTokens, c as AbstractSemanticTokenProvider, ct as CodeAction, d as AbstractFormatter, dt as CompletionItemKind, et as Stream, f as FormattingRegion, ft as Diagnostic, g as DefaultDocumentHighlightProvider, gt as FormattingOptions, h as DocumentLinkProvider, ht as DocumentSymbol, i as NextFeature, it as URI, j as DiagnosticInfo, k as DefaultDocumentValidator, l as SemanticTokenAcceptor, lt as CodeLens, m as NodeKindProvider, mt as DocumentLink, n as CompletionContext, nt as FileSystemProvider, o as LangiumSharedServices, ot as NotificationType, p as DocumentSymbolProvider, pt as DocumentHighlight, q as CstNode, r as DefaultCompletionProvider, rt as Keyword, s as DefaultWorkspaceSymbolProvider, st as RequestType, t as CompletionAcceptor, tt as FileSystemNode, u as AstNodeHoverProvider, ut as Command, v as CodeActionProvider, vt as Location, w as DocumentLinkParams, wt as WorkspaceFolder, x as BuildOptions, xt as SemanticTokensDelta, y as DefaultWorkspaceManager, yt as Range, z as DefaultIndexManager } from "./libs/langium.mjs";
+import { t as $keywords } from "./libs/ts-graphviz.mjs";
+import { ElementModel, LikeC4Model } from "@likec4/core/model";
+import * as c4 from "@likec4/core";
+import { AnyAux, ComputedView, DeploymentFqn, DiagramView, EdgeId, Fqn, LayoutType, LayoutedView, LikeC4Styles, NonEmptyArray, NonEmptyReadonlyArray, ProjectId, RelationId, Tag, UnknownComputed, UnknownLayouted, UnknownParsed, ViewChange, ViewId, aux } from "@likec4/core";
+import { LikeC4Styles as LikeC4Styles$1 } from "@likec4/core/styles";
+import { Fqn as Fqn$1, GuardedBy, LayoutedView as LayoutedView$1, ProjectId as ProjectId$1, ViewId as ViewId$1 } from "@likec4/core/types";
+import { DefaultWeakMap, MultiMap } from "@likec4/core/utils";
+import { AdhocViewPredicate, ComputedProjectsView, LayoutedProjectsView } from "@likec4/core/compute-view";
+import * as type_fest0 from "type-fest";
+import { ConditionalPick, MergeExclusive, Simplify, Tagged, ValueOf, Writable } from "type-fest";
+
+//#region ../language-server/dist/protocol.d.mts
+/**
+ * When server requests to open a likec4 preview panel
+ * (available only in the editor).
+ * (not the best place, but seems to be working)
+ */
+declare namespace DidRequestOpenViewNotification {
+  type Params = {
+    viewId: ViewId;
+    projectId: ProjectId;
+  };
+  const type: NotificationType<Params>;
+  type Type = typeof type;
+}
+/**
+ * Request to fetch the computed model data
+ * If LSP has multiple projects, the projectId is required.
+ * otherwise throws an error.
+ */
+/**
+ * Request to locate an element, relation, deployment or view.
+ * If LSP has multiple projects, the projectId is required.
+ */
+declare namespace Locate {
+  type Params =
+  /**
+   * Locate an element by its fqn
+   */
+  {
+    element: Fqn;
+    projectId?: string | undefined;
+    property?: string;
+  }
+  /**
+   * Locate a relation by its id
+   */
+  | {
+    projectId?: string | undefined;
+    relation: RelationId;
+  }
+  /**
+   * Locate a deployment by its fqn
+   */
+  | {
+    deployment: DeploymentFqn;
+    projectId?: string | undefined;
+    property?: string;
+  }
+  /**
+   * Locate a step in a dynamic view by its astPath
+   */
+  | {
+    view: ViewId;
+    astPath: string;
+    projectId?: string | undefined;
+  }
+  /**
+   * Locate a view by its id
+   */
+  | {
+    view: ViewId;
+    projectId?: string | undefined;
+  };
+  type Res = Location | null;
+  const req: RequestType<Params, Res, void>;
+  type Req = typeof req;
+}
+/**
+ * Request to change the view
+ * If LSP has multiple projects, the projectId is required.
+ */
+declare namespace ChangeView {
+  type Params = {
+    viewId: ViewId;
+    change: ViewChange;
+    projectId?: string | undefined;
+  };
+  type Res = {
+    success: true;
+    location: Location | null;
+  } | {
+    success: false;
+    location?: Location | null;
+    error: string;
+  };
+  const req: RequestType<Params, Res, void>;
+  type Req = typeof req;
+}
+/**
+ * Request to fetch telemetry metrics
+ */
+//#endregion
+//#region ../layouts/dist/_chunks/GraphvizLayoter.d.mts
+//#region src/graphviz/types.d.ts
+/**
+ * Partially implements CancellationToken interface from vscode-jsonrpc
+ */
+type CancellationToken = {
+  /**
+   * Is `true` when the token has been cancelled, `false` otherwise.
+   */
+  readonly isCancellationRequested: boolean;
+};
+declare module 'ts-graphviz' {
+  namespace GraphAttributeKey {
+    interface $values extends $keywords<'likec4_viewId'> {}
+  }
+  namespace ClusterSubgraphAttributeKey {
+    interface $values extends $keywords<'likec4_type' | 'likec4_path' | 'likec4_id' | 'likec4_level' | 'likec4_depth'> {}
+  }
+  namespace NodeAttributeKey {
+    interface $values extends $keywords<'likec4_type' | 'likec4_path' | 'likec4_id' | 'likec4_project' | 'likec4_level'> {}
+  }
+  namespace EdgeAttributeKey {
+    interface $values extends $keywords<'likec4_id' | 'likec4_project'> {}
+  }
+  namespace Attribute {
+    interface $keys extends $keywords<'likec4_viewId' | 'likec4_type' | 'likec4_path' | 'likec4_id' | 'likec4_project' | 'likec4_level' | 'likec4_depth'> {}
+    interface $types {
+      likec4_viewId: string;
+      likec4_type: 'folder' | 'file' | 'view';
+      likec4_path: string;
+      likec4_id: string;
+      likec4_project: string;
+      likec4_level: number;
+      likec4_depth: number;
+    }
+  }
+}
+type DotSource = Tagged<string, 'DotSource'>; //#endregion
+//#region src/graphviz/types-dot.d.ts
+type GvNodeName = Tagged<string, 'GvNodeName'>;
+type GvId = Tagged<number, 'GvId'>;
+type Point = [x: number, y: number];
+interface GraphvizJson {
+  name: GvNodeName;
+  directed: boolean;
+  strict: boolean;
+  _draw_: GraphvizJson.Draw[];
+  bb: string;
+  compound: string;
+  fontname: string;
+  fontsize: string;
+  label: string;
+  nodesep: string;
+  outputorder: string;
+  rankdir: string;
+  ranksep: string;
+  splines: string;
+  xdotversion: string;
+  _subgraph_cnt: number;
+  objects?: GraphvizJson.GvObject[];
+  edges?: GraphvizJson.Edge[];
+}
+declare namespace GraphvizJson {
+  interface Draw {
+    op: string;
+    grad: string;
+    color: string;
+    points: Point[];
+  }
+  interface Draw2 {
+    op: string;
+    grad: string;
+    color: string;
+    points: Point[];
+  }
+  namespace DrawOps {
+    type Style = {
+      op: 'S';
+      style: string;
+    };
+    type BSpline = {
+      op: 'b' | 'B';
+      points: Point[];
+    };
+    type Color = {
+      op: 'c';
+      grad: string;
+      color: string;
+    };
+    type Polygon = {
+      op: 'p' | 'P';
+      points: Point[];
+    };
+  }
+  type DrawOp = DrawOps.Style | DrawOps.BSpline | DrawOps.Color | DrawOps.Polygon;
+  type LabelDrawOps = {
+    op: 'F';
+    size: number;
+    face: string;
+  } | {
+    op: 'c';
+    color: string;
+  } | {
+    op: 't';
+    fontchar: number;
+  } | {
+    op: 'T';
+    pt: Point;
+    align: 'l' | 'r' | 'c';
+    width: number;
+    text: string;
+  };
+  type GvObject = GvNodeObject | GvSubgraph;
+  interface GvSubgraph {
+    bb: string;
+    label?: string;
+    compound: 'true';
+    _ldraw_?: LabelDrawOps[];
+    likec4_type?: 'folder' | 'file';
+    likec4_path?: string;
+    likec4_id?: Fqn;
+    likec4_level?: number;
+    likec4_depth?: number;
+    _gvid: GvId;
+    subgraphs?: GvId[];
+    nodes?: GvId[];
+    edges?: GvId[];
+  }
+  interface GvNodeObject {
+    _draw_: Draw[];
+    _ldraw_?: LabelDrawOps[];
+    likec4_type?: 'folder' | 'file' | 'view';
+    likec4_path?: string;
+    likec4_id?: Fqn;
+    likec4_level?: number;
+    _gvid: GvId;
+    height: string;
+    pos: string;
+    shape: 'rect';
+    width: string;
+    label?: string;
+  }
+  interface Draw3 {
+    op: string;
+    grad: string;
+    color: string;
+    points: Point[];
+  }
+  interface Hdraw {
+    op: string;
+    style: string;
+    grad: string;
+    color: string;
+    points: Point[];
+  }
+  interface Edge {
+    _gvid: GvId;
+    tail: GvId;
+    head: GvId;
+    dir?: 'forward' | 'back' | 'both' | 'none';
+    _draw_: DrawOp[];
+    _hdraw_?: DrawOp[];
+    _tdraw_?: DrawOp[];
+    _ldraw_?: LabelDrawOps[];
+    _tldraw_?: LabelDrawOps[];
+    _hldraw_?: LabelDrawOps[];
+    fontname: string;
+    fontsize: string;
+    likec4_id?: EdgeId;
+    label: string;
+    lp: string;
+    nojustify?: 'true' | 'false';
+    pos?: string;
+  }
+} //#endregion
+//#region src/graphviz/GraphvizLayoter.d.ts
+interface GraphvizPort extends Disposable {
+  get concurrency(): number;
+  unflatten(dot: DotSource): Promise<DotSource>;
+  acyclic(dot: DotSource): Promise<DotSource>;
+  layoutJson(dot: DotSource): Promise<string>;
+  svg(dot: DotSource): Promise<string>;
+  dispose(): void;
+}
+type LayoutTaskParams<A extends aux.Any = aux.Any> = {
+  view: ComputedView<A>;
+  styles: LikeC4Styles;
+};
+type LayoutResult<A extends aux.Any = aux.Any> = {
+  dot: DotSource;
+  diagram: DiagramView<A>;
+};
+declare class GraphvizLayouter implements Disposable {
+  private graphviz;
+  constructor(graphviz?: GraphvizPort);
+  dispose(): void;
+  [Symbol.dispose](): void;
+  get graphvizPort(): GraphvizPort;
+  changePort(graphviz: GraphvizPort): void;
+  dotToJson(dot: DotSource): Promise<GraphvizJson>;
+  layout<A extends AnyAux>(params: LayoutTaskParams<A>): Promise<LayoutResult<A>>;
+  svg<A extends AnyAux>(params: LayoutTaskParams<A>): Promise<{
+    svg: string;
+    dot: DotSource;
+  }>;
+  dot<A extends AnyAux>(params: LayoutTaskParams<A>): Promise<DotSource>;
+  layoutProjectsView(view: ComputedProjectsView): Promise<LayoutedProjectsView>;
+} //#endregion
+//#endregion
+//#region ../layouts/dist/index.d.mts
+//#region src/graphviz/QueueGraphvizLayoter.d.ts
+declare class QueueGraphvizLayoter extends GraphvizLayouter {
+  private queue;
+  private isProcessingBatch;
+  constructor(options?: {
+    graphviz?: GraphvizPort;
+    /**
+     * Concurrency limit.
+     * Minimum: `1`.
+     * @default 2
+     */
+    concurrency?: number;
+    /**
+     * Per-operation timeout in milliseconds. Operations fulfill once `timeout` elapses if they haven't already.
+     * @default 20_000
+     */
+    timeout?: number;
+    /**
+     * Whether or not a timeout is considered an exception.
+     * @default true
+     */
+    throwOnTimeout?: boolean;
+  });
+  private runInQueue;
+  changePort(graphvizPort: GraphvizPort): void;
+  layout<A extends AnyAux>(params: LayoutTaskParams<A>): Promise<LayoutResult<A>>;
+  layoutProjectsView(view: ComputedProjectsView): Promise<LayoutedProjectsView>;
+  batchLayout<A extends AnyAux>(params: {
+    batch: LayoutTaskParams<A>[];
+    cancelToken?: CancellationToken | undefined;
+    onSuccess?: (task: LayoutTaskParams<A>, result: LayoutResult<A>) => void;
+    onError?: (task: LayoutTaskParams<A>, error: unknown) => void;
+  }): Promise<LayoutResult<A>[]>;
+  dispose(): void;
+} //#endregion
+//#region src/graphviz/wasm/GraphvizWasmAdapter.d.ts
+//#endregion
+//#region ../language-server/dist/module.d.mts
+interface LikeC4AddedSharedServices {
+  lsp: {
+    NodeKindProvider: NodeKindProvider$1;
+    WorkspaceSymbolProvider: WorkspaceSymbolProvider;
+  };
+  workspace: {
+    Cache: WorkspaceCache<string, any>;
+    ProjectsManager: ProjectsManager;
+    IndexManager: IndexManager;
+    LangiumDocuments: LangiumDocuments;
+    WorkspaceManager: LikeC4WorkspaceManager;
+    FileSystemProvider: FileSystemProvider$1;
+    FileSystemWatcher: FileSystemWatcher;
+    ManualLayouts: LikeC4ManualLayouts;
+  };
+}
+type LikeC4SharedServices = LangiumSharedServices & LikeC4AddedSharedServices;
+/**
+ * Declaration of custom services - add your own service classes here.
+ */
+interface LikeC4AddedServices {
+  documentation: {
+    DocumentationProvider: LikeC4DocumentationProvider;
+  };
+  validation: {
+    DocumentValidator: LikeC4DocumentValidator;
+  };
+  Rpc: Rpc;
+  mcp: {
+    Server: LikeC4MCPServer;
+    ServerFactory: LikeC4MCPServerFactory;
+  };
+  likec4: {
+    LanguageServices: LikeC4LanguageServices;
+    Views: LikeC4Views;
+    Layouter: QueueGraphvizLayoter;
+    DeploymentsIndex: DeploymentsIndex;
+    FqnIndex: FqnIndex;
+    ModelParser: LikeC4ModelParser;
+    ModelBuilder: LikeC4ModelBuilder;
+    ModelLocator: LikeC4ModelLocator;
+    ModelChanges: LikeC4ModelChanges;
+    LastSeen: LastSeenArtifacts;
+  };
+  lsp: {
+    CompletionProvider: LikeC4CompletionProvider;
+    DocumentHighlightProvider: LikeC4DocumentHighlightProvider;
+    DocumentSymbolProvider: LikeC4DocumentSymbolProvider;
+    SemanticTokenProvider: LikeC4SemanticTokenProvider;
+    HoverProvider: LikeC4HoverProvider;
+    CodeLensProvider: LikeC4CodeLensProvider;
+    DocumentLinkProvider: LikeC4DocumentLinkProvider;
+    Formatter: LikeC4Formatter;
+    CodeActionProvider: LikeC4CodeActionProvider;
+  };
+  references: {
+    NameProvider: LikeC4NameProvider;
+    ScopeComputation: LikeC4ScopeComputation;
+    ScopeProvider: LikeC4ScopeProvider;
+  };
+  shared?: LikeC4SharedServices;
+  parser: {
+    ValueConverter: LikeC4ValueConverter;
+  };
+}
+type LikeC4Services = LangiumServices & LikeC4AddedServices;
+/**
+ * Most probably you don't need to use this function directly.
+ * Use {@link createLanguageServices} instead.
+ * @internal
+ */
+//#endregion
+//#region ../language-server/dist/_chunks/index.d.mts
+//#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?: CancellationToken$1): Promise<ProjectData>;
+  /**
+   * Registers (or reloads) likec4 project by config file or config object.
+   * If there is some project registered at same folder, it will be reloaded.
+   */
+  registerProject(opts: RegisterProjectOptions, cancelToken?: CancellationToken$1): Promise<ProjectData>;
+  /**
+   * Determines which project the given document belongs to.
+   * If the document does not belong to any project, returns the default project ID.
+   */
+  ownerProjectId(document: LangiumDocument | URI | string): ProjectId$1;
+  reloadProjects(cancelToken?: CancellationToken$1): Promise<void>;
+  protected _reloadProjects(cancelToken?: CancellationToken$1): Promise<void>;
+  protected uniqueProjectId(name: string): ProjectId$1;
+  protected resetCaches(): void;
+  rebuildProject(projectId: ProjectId$1, cancelToken?: CancellationToken$1): Promise<void>;
+  /**
+   * Returns all include paths from all projects.
+   * Used by WorkspaceManager to scan additional directories for C4 files.
+   */
+  getAllIncludePaths(): Array<{
+    projectId: ProjectId$1;
+    includePath: URI;
+    includeConfig: IncludeConfig;
+  }>;
+  /**
+   * Register a listener to be called when the projects configuration has changed.
+   * @returns A disposable that can be used to unregister the callback.
+   */
+  onProjectsUpdate(callback: () => void): Disposable$1;
+  private getWorkspaceFolder;
+  private notifyListeners;
+  private updateIncludesExcludes;
+} //#endregion
+//#region src/filesystem/types.d.ts
+interface FileNode extends FileSystemNode {
+  readonly isFile: true;
+  readonly isDirectory: false;
+}
+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 FileSystemWatcher extends AsyncDisposable {
+  /**
+   * Watches a folder for changes and triggers a reload of the documents and projects.
+   */
+  watch(folder: string): void;
+}
+type ManualLayoutsSnapshot = {
+  hash: string;
+  views: Record<ViewId$1, LayoutedView$1>;
+};
+interface LikeC4ManualLayouts {
+  read(project: Project): Promise<ManualLayoutsSnapshot | null>;
+  write(project: Project, layouted: LayoutedView$1): Promise<Location>;
+  remove(project: Project, view: ViewId$1): Promise<Location | null>;
+  clearCaches(): void;
+} //#endregion
+//#region src/filesystem/noop.d.ts
+//#endregion
+//#region src/formatting/LikeC4Formatter.d.ts
+type QuoteStyle = 'single' | 'double' | 'ignore' | 'auto';
+interface LikeC4FormatterOptions {
+  quoteStyle: QuoteStyle;
+}
+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;
+}
+//#endregion
+//#region src/generated/ast.d.ts
+type AnyProperty = DynamicViewProperty | ElementProperty | RelationProperty | StringProperty | ViewProperty;
+declare const AnyProperty = "AnyProperty";
+type ArrowType = 'crow' | 'diamond' | 'dot' | 'none' | 'normal' | 'odiamond' | 'odot' | 'onormal' | 'open' | 'vee';
+type BorderStyleValue = 'none' | LineOptions;
+type ColorLiteral$1 = HexColor | RGBAColor;
+declare const ColorLiteral$1 = "ColorLiteral";
+type CustomColorId = 'element' | 'model' | ArrowType | ElementShape | LineOptions | Participant | string;
+type DeploymentElement = DeployedInstance | DeploymentNode;
+declare const DeploymentElement = "DeploymentElement";
+type DeploymentNodeOrElementKind = DeploymentNodeKind | ElementKind;
+declare const DeploymentNodeOrElementKind = "DeploymentNodeOrElementKind";
+type DeploymentViewRule = DeploymentViewRulePredicate | DeploymentViewRuleStyle | ViewRuleAutoLayout;
+declare const DeploymentViewRule = "DeploymentViewRule";
+type DynamicViewDisplayVariantValue = 'diagram' | 'sequence';
+type DynamicViewProperty = DynamicViewDisplayVariantProperty | ViewProperty;
+declare const DynamicViewProperty = "DynamicViewProperty";
+type DynamicViewRule = DynamicViewGlobalPredicateRef | DynamicViewIncludePredicate | ViewRuleAutoLayout | ViewRuleStyleOrGlobalRef;
+declare const DynamicViewRule = "DynamicViewRule";
+type DynamicViewStep = DynamicStepChain | DynamicStepSingle;
+declare const DynamicViewStep = "DynamicViewStep";
+type ElementProperty = ElementStringProperty | ElementStyleProperty | IconProperty | LinkProperty | MetadataProperty;
+declare const ElementProperty = "ElementProperty";
+type ElementShape = 'browser' | 'bucket' | 'component' | 'cylinder' | 'document' | 'mobile' | 'person' | 'queue' | 'rectangle' | 'storage';
+type ExpressionV2 = FqnExprOrWith | RelationExprOrWith;
+declare const ExpressionV2 = "ExpressionV2";
+type ExtendElementProperty = LinkProperty | MetadataProperty;
+declare const ExtendElementProperty = "ExtendElementProperty";
+type ExtendRelationProperty = LinkProperty | MetadataProperty;
+declare const ExtendRelationProperty = "ExtendRelationProperty";
+type FqnExpr$2 = ElementKindExpression | ElementTagExpression | FqnRefExpr | WildcardExpression;
+declare const FqnExpr$2 = "FqnExpr";
+type FqnExprOrWhere = FqnExpr$2 | FqnExprWhere;
+declare const FqnExprOrWhere = "FqnExprOrWhere";
+type FqnExprOrWith = FqnExprOrWhere | FqnExprWith;
+declare const FqnExprOrWith = "FqnExprOrWith";
+type FqnReferenceable = Element | ExtendDeployment | ExtendElement | Referenceable;
+declare const FqnReferenceable = "FqnReferenceable";
+type IconId = string;
+type IconPositionValue = 'bottom' | 'left' | 'right' | 'top';
+type Id = 'deployment' | 'element' | 'group' | 'instance' | 'model' | 'node' | ArrowType | DynamicViewDisplayVariantValue | ElementShape | IconPositionValue | LineOptions | Participant | RankValue | SizeValue | ThemeColor | string;
+type LikeC4View = DeploymentView | DynamicView | ElementView;
+declare const LikeC4View = "LikeC4View";
+type LineOptions = 'dashed' | 'dotted' | 'solid';
+type MetadataProperty = MetadataBody;
+declare const MetadataProperty = "MetadataProperty";
+type MetadataValue = MarkdownOrString | MetadataArray;
+declare const MetadataValue = "MetadataValue";
+type ModelReferenceable = Element | Imported;
+declare const ModelReferenceable = "ModelReferenceable";
+type Participant = 'source' | 'target';
+type RankValue = 'max' | 'min' | 'same' | 'sink' | 'source';
+type Referenceable = DeployedInstance | DeploymentNode | Element | Imported;
+declare const Referenceable = "Referenceable";
+type RelationExpr$1 = DirectedRelationExpr | InOutRelationExpr | IncomingRelationExpr | OutgoingRelationExpr;
+declare const RelationExpr$1 = "RelationExpr";
+type RelationExprOrWhere = RelationExpr$1 | RelationExprWhere;
+declare const RelationExprOrWhere = "RelationExprOrWhere";
+type RelationExprOrWith = RelationExprOrWhere | RelationExprWith;
+declare const RelationExprOrWith = "RelationExprOrWith";
+type RelationProperty = LinkProperty | MetadataProperty | RelationNavigateToProperty | RelationStringProperty | RelationStyleProperty;
+declare const RelationProperty = "RelationProperty";
+type RelationshipStyleProperty = ArrowProperty | ColorProperty | LineProperty;
+declare const RelationshipStyleProperty = "RelationshipStyleProperty";
+type SizeProperty = IconSizeProperty | PaddingSizeProperty | ShapeSizeProperty | TextSizeProperty;
+declare const SizeProperty = "SizeProperty";
+type SizeValue = 'large' | 'lg' | 'md' | 'medium' | 'sm' | 'small' | 'xl' | 'xlarge' | 'xs' | 'xsmall';
+type StringProperty = ElementStringProperty | MetadataAttribute | NotationProperty | NotesProperty | RelationStringProperty | SpecificationElementStringProperty | SpecificationRelationshipStringProperty | ViewStringProperty;
+declare const StringProperty = "StringProperty";
+type StyleProperty = BorderProperty | ColorProperty | IconColorProperty | IconPositionProperty | IconProperty | IconSizeProperty | MultipleProperty | OpacityProperty | PaddingSizeProperty | ShapeProperty | ShapeSizeProperty | TextSizeProperty;
+declare const StyleProperty = "StyleProperty";
+type ThemeColor = 'amber' | 'blue' | 'gray' | 'green' | 'indigo' | 'muted' | 'primary' | 'red' | 'secondary' | 'sky' | 'slate';
+type Uri = string;
+type ViewLayoutDirection = 'BottomTop' | 'LeftRight' | 'RightLeft' | 'TopBottom';
+type ViewProperty = LinkProperty | ViewStringProperty;
+declare const ViewProperty = "ViewProperty";
+type ViewRule = ViewRuleAutoLayout | ViewRuleGlobalPredicateRef | ViewRuleGroup | ViewRulePredicate | ViewRuleRank | ViewRuleStyleOrGlobalRef;
+declare const ViewRule = "ViewRule";
+type ViewRuleStyleOrGlobalRef = ViewRuleGlobalStyle | ViewRuleStyle;
+declare const ViewRuleStyleOrGlobalRef = "ViewRuleStyleOrGlobalRef";
+type WhereElement = WhereElementKind | WhereElementTag;
+declare const WhereElement = "WhereElement";
+type WhereElementExpression = WhereBinaryExpression | WhereElement | WhereElementNegation;
+declare const WhereElementExpression = "WhereElementExpression";
+type WhereExpression = WhereElementExpression | WhereRelationExpression;
+declare const WhereExpression = "WhereExpression";
+type WhereKindEqual = WhereElementKind | WhereRelationKind | WhereRelationParticipantKind;
+declare const WhereKindEqual = "WhereKindEqual";
+type WhereRelation = WhereRelationKind | WhereRelationParticipantKind | WhereRelationParticipantTag | WhereRelationTag;
+declare const WhereRelation = "WhereRelation";
+type WhereRelationExpression = WhereBinaryExpression | WhereRelation | WhereRelationNegation;
+declare const WhereRelationExpression = "WhereRelationExpression";
+type WhereTagEqual = WhereElementTag | WhereRelationParticipantTag | WhereRelationTag;
+declare const WhereTagEqual = "WhereTagEqual";
+interface AbstractDynamicStep extends AstNode {
+  readonly $container: DynamicStepChain | DynamicViewBody | DynamicViewParallelSteps;
+  readonly $type: 'AbstractDynamicStep' | 'DynamicStepChain' | 'DynamicStepSingle';
+  custom?: CustomRelationProperties;
+  dotKind?: RelationKindDotRef;
+  kind?: Reference<RelationshipKind>;
+  target: ElementRef;
+  title?: string;
+}
+declare const AbstractDynamicStep = "AbstractDynamicStep";
+interface ArrowProperty extends AstNode {
+  readonly $container: CustomRelationProperties | RelationStyleProperty | SpecificationRelationshipKind;
+  readonly $type: 'ArrowProperty';
+  key: 'head' | 'tail';
+  value: ArrowType;
+}
+declare const ArrowProperty = "ArrowProperty";
+interface BorderProperty extends AstNode {
+  readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleGroup | ViewRuleStyle;
+  readonly $type: 'BorderProperty';
+  key: 'border';
+  value: BorderStyleValue;
+}
+declare const BorderProperty = "BorderProperty";
+interface ColorProperty extends AstNode {
+  readonly $container: CustomElementProperties | CustomRelationProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | RelationStyleProperty | SpecificationRelationshipKind | ViewRuleGroup | ViewRuleStyle;
+  readonly $type: 'ColorProperty';
+  customColor?: Reference<CustomColor>;
+  key: 'color';
+  themeColor?: ThemeColor;
+}
+declare const ColorProperty = "ColorProperty";
+interface CustomColor extends AstNode {
+  readonly $container: SpecificationColor;
+  readonly $type: 'CustomColor';
+  name: CustomColorId;
+}
+declare const CustomColor = "CustomColor";
+interface CustomElementProperties extends AstNode {
+  readonly $container: FqnExprWith;
+  readonly $type: 'CustomElementProperties';
+  props: Array<ElementStringProperty | NavigateToProperty | NotationProperty | NotesProperty | StyleProperty>;
+}
+declare const CustomElementProperties = "CustomElementProperties";
+interface CustomRelationProperties extends AstNode {
+  readonly $container: AbstractDynamicStep | RelationExprWith;
+  readonly $type: 'CustomRelationProperties';
+  props: Array<NotationProperty | NotesProperty | RelationNavigateToProperty | RelationStringProperty | RelationshipStyleProperty>;
+}
+declare const CustomRelationProperties = "CustomRelationProperties";
+interface DeployedInstance extends AstNode {
+  readonly $container: DeploymentNodeBody | ExtendDeploymentBody;
+  readonly $type: 'DeployedInstance';
+  body?: DeployedInstanceBody;
+  name?: Id;
+  summary?: string;
+  target: ElementRef;
+  title?: string;
+}
+declare const DeployedInstance = "DeployedInstance";
+interface DeployedInstanceBody extends AstNode {
+  readonly $container: DeployedInstance;
+  readonly $type: 'DeployedInstanceBody';
+  elements: Array<DeploymentRelation>;
+  props: Array<ElementProperty>;
+  tags?: Tags;
+}
+declare const DeployedInstanceBody = "DeployedInstanceBody";
+interface DeploymentNode extends AstNode {
+  readonly $container: DeploymentNodeBody | ExtendDeploymentBody | ModelDeployments;
+  readonly $type: 'DeploymentNode';
+  body?: DeploymentNodeBody;
+  kind: Reference<DeploymentNodeKind>;
+  name: Id;
+  summary?: string;
+  title?: string;
+}
+declare const DeploymentNode = "DeploymentNode";
+interface DeploymentNodeBody extends AstNode {
+  readonly $container: DeploymentNode;
+  readonly $type: 'DeploymentNodeBody';
+  elements: Array<DeployedInstance | DeploymentNode | DeploymentRelation>;
+  props: Array<ElementProperty>;
+  tags?: Tags;
+}
+declare const DeploymentNodeBody = "DeploymentNodeBody";
+interface DeploymentNodeKind extends AstNode {
+  readonly $container: SpecificationDeploymentNodeKind;
+  readonly $type: 'DeploymentNodeKind';
+  name: Id;
+}
+declare const DeploymentNodeKind = "DeploymentNodeKind";
+interface DeploymentRelation extends AstNode {
+  readonly $container: DeployedInstanceBody | DeploymentNodeBody | ExtendDeploymentBody | ModelDeployments;
+  readonly $type: 'DeploymentRelation';
+  body?: DeploymentRelationBody;
+  description?: string;
+  dotKind?: RelationKindDotRef;
+  kind?: Reference<RelationshipKind>;
+  source?: FqnRef$2;
+  tags?: Tags;
+  target: FqnRef$2;
+  technology?: string;
+  title?: string;
+}
+declare const DeploymentRelation = "DeploymentRelation";
+interface DeploymentRelationBody extends AstNode {
+  readonly $container: DeploymentRelation;
+  readonly $type: 'DeploymentRelationBody';
+  props: Array<RelationProperty>;
+  tags?: Tags;
+}
+declare const DeploymentRelationBody = "DeploymentRelationBody";
+interface DeploymentView extends AstNode {
+  readonly $container: ModelViews;
+  readonly $type: 'DeploymentView';
+  body?: DeploymentViewBody;
+  name: Id;
+}
+declare const DeploymentView = "DeploymentView";
+interface DeploymentViewBody extends AstNode {
+  readonly $container: DeploymentView;
+  readonly $type: 'DeploymentViewBody';
+  props: Array<ViewProperty>;
+  rules: Array<DeploymentViewRule>;
+  tags?: Tags;
+}
+declare const DeploymentViewBody = "DeploymentViewBody";
+interface DeploymentViewRulePredicate extends AstNode {
+  readonly $container: DeploymentViewBody;
+  readonly $type: 'DeploymentViewRulePredicate';
+  expr: Expressions;
+  isInclude: boolean;
+}
+declare const DeploymentViewRulePredicate = "DeploymentViewRulePredicate";
+interface DeploymentViewRuleStyle extends AstNode {
+  readonly $container: DeploymentViewBody;
+  readonly $type: 'DeploymentViewRuleStyle';
+  props: Array<NotationProperty | StyleProperty>;
+  targets: FqnExpressions;
+}
+declare const DeploymentViewRuleStyle = "DeploymentViewRuleStyle";
+interface DirectedRelationExpr extends AstNode {
+  readonly $container: Expressions | RelationExprWhere | RelationExprWith;
+  readonly $type: 'DirectedRelationExpr';
+  source: OutgoingRelationExpr;
+  target: FqnExpr$2;
+}
+declare const DirectedRelationExpr = "DirectedRelationExpr";
+interface DynamicView extends AstNode {
+  readonly $container: ModelViews;
+  readonly $type: 'DynamicView';
+  body?: DynamicViewBody;
+  name: Id;
+}
+declare const DynamicView = "DynamicView";
+interface DynamicViewBody extends AstNode {
+  readonly $container: DynamicView;
+  readonly $type: 'DynamicViewBody';
+  props: Array<DynamicViewProperty>;
+  rules: Array<DynamicViewRule>;
+  steps: Array<DynamicViewParallelSteps | DynamicViewStep>;
+  tags?: Tags;
+}
+declare const DynamicViewBody = "DynamicViewBody";
+interface DynamicViewDisplayVariantProperty extends AstNode {
+  readonly $container: DynamicViewBody;
+  readonly $type: 'DynamicViewDisplayVariantProperty';
+  key: 'variant';
+  value: DynamicViewDisplayVariantValue;
+}
+declare const DynamicViewDisplayVariantProperty = "DynamicViewDisplayVariantProperty";
+interface DynamicViewGlobalPredicateRef extends AstNode {
+  readonly $container: DynamicViewBody;
+  readonly $type: 'DynamicViewGlobalPredicateRef';
+  predicate: Reference<GlobalDynamicPredicateGroup>;
+}
+declare const DynamicViewGlobalPredicateRef = "DynamicViewGlobalPredicateRef";
+interface DynamicViewIncludePredicate extends AstNode {
+  readonly $container: DynamicViewBody | GlobalDynamicPredicateGroup;
+  readonly $type: 'DynamicViewIncludePredicate';
+  exprs: Expressions;
+}
+declare const DynamicViewIncludePredicate = "DynamicViewIncludePredicate";
+interface DynamicViewParallelSteps extends AstNode {
+  readonly $container: DynamicViewBody;
+  readonly $type: 'DynamicViewParallelSteps';
+  steps: Array<DynamicViewStep>;
+}
+declare const DynamicViewParallelSteps = "DynamicViewParallelSteps";
+interface DynamicViewRef extends AstNode {
+  readonly $container: RelationNavigateToProperty;
+  readonly $type: 'DynamicViewRef';
+  view: Reference<DynamicView>;
+}
+declare const DynamicViewRef = "DynamicViewRef";
+interface Element extends AstNode {
+  readonly $container: ElementBody | ExtendElementBody | Model;
+  readonly $type: 'Element';
+  body?: ElementBody;
+  kind: Reference<ElementKind>;
+  name: Id;
+  props: Array<string>;
+}
+declare const Element = "Element";
+interface ElementBody extends AstNode {
+  readonly $container: Element;
+  readonly $type: 'ElementBody';
+  elements: Array<Element | Relation>;
+  props: Array<ElementProperty>;
+  tags?: Tags;
+}
+declare const ElementBody = "ElementBody";
+interface ElementKind extends AstNode {
+  readonly $container: SpecificationElementKind;
+  readonly $type: 'ElementKind';
+  name: Id;
+}
+declare const ElementKind = "ElementKind";
+interface ElementKindExpression extends AstNode {
+  readonly $container: DirectedRelationExpr | Expressions | FqnExprWhere | FqnExprWith | FqnExpressions | IncomingRelationExpr | OutgoingRelationExpr;
+  readonly $type: 'ElementKindExpression';
+  isEqual: boolean;
+  kind: Reference<ElementKind>;
+}
+declare const ElementKindExpression = "ElementKindExpression";
+interface ElementRef extends AstNode {
+  readonly $container: AbstractDynamicStep | DeployedInstance | DynamicStepSingle | ElementView;
+  readonly $type: 'ElementRef';
+  modelElement: FqnRef$2;
+}
+declare const ElementRef = "ElementRef";
+interface ElementStringProperty extends AstNode {
+  readonly $container: CustomElementProperties | DeployedInstanceBody | DeploymentNodeBody | ElementBody;
+  readonly $type: 'ElementStringProperty';
+  key: 'description' | 'summary' | 'technology' | 'title';
+  value: MarkdownOrString;
+}
+declare const ElementStringProperty = "ElementStringProperty";
+interface ElementStyleProperty extends AstNode {
+  readonly $container: DeployedInstanceBody | DeploymentNodeBody | ElementBody | SpecificationDeploymentNodeKind | SpecificationElementKind;
+  readonly $type: 'ElementStyleProperty';
+  key: 'style';
+  props: Array<StyleProperty>;
+}
+declare const ElementStyleProperty = "ElementStyleProperty";
+interface ElementTagExpression extends AstNode {
+  readonly $container: DirectedRelationExpr | Expressions | FqnExprWhere | FqnExprWith | FqnExpressions | IncomingRelationExpr | OutgoingRelationExpr;
+  readonly $type: 'ElementTagExpression';
+  isEqual: boolean;
+  tag: TagRef;
+}
+declare const ElementTagExpression = "ElementTagExpression";
+interface ElementView extends AstNode {
+  readonly $container: ModelViews;
+  readonly $type: 'ElementView';
+  body?: ElementViewBody;
+  extends?: ElementViewRef;
+  name?: Id;
+  viewOf?: ElementRef;
+}
+declare const ElementView = "ElementView";
+interface ElementViewBody extends AstNode {
+  readonly $container: ElementView;
+  readonly $type: 'ElementViewBody';
+  props: Array<ViewProperty>;
+  rules: Array<ViewRule>;
+  tags?: Tags;
+}
+declare const ElementViewBody = "ElementViewBody";
+interface ElementViewRef extends AstNode {
+  readonly $container: ElementView;
+  readonly $type: 'ElementViewRef';
+  view: Reference<ElementView>;
+}
+declare const ElementViewRef = "ElementViewRef";
+interface Expressions extends AstNode {
+  readonly $container: DeploymentViewRulePredicate | DynamicViewIncludePredicate | Expressions | ViewRulePredicate;
+  readonly $type: 'Expressions';
+  prev?: Expressions;
+  value: ExpressionV2;
+}
+declare const Expressions = "Expressions";
+interface ExtendDeployment extends AstNode {
+  readonly $container: ModelDeployments;
+  readonly $type: 'ExtendDeployment';
+  body: ExtendDeploymentBody;
+  deploymentNode: StrictFqnRef;
+}
+declare const ExtendDeployment = "ExtendDeployment";
+interface ExtendDeploymentBody extends AstNode {
+  readonly $container: ExtendDeployment;
+  readonly $type: 'ExtendDeploymentBody';
+  elements: Array<DeployedInstance | DeploymentNode | DeploymentRelation>;
+  props: Array<ExtendElementProperty>;
+  tags?: Tags;
+}
+declare const ExtendDeploymentBody = "ExtendDeploymentBody";
+interface ExtendElement extends AstNode {
+  readonly $container: Model;
+  readonly $type: 'ExtendElement';
+  body: ExtendElementBody;
+  element: StrictFqnElementRef;
+}
+declare const ExtendElement = "ExtendElement";
+interface ExtendElementBody extends AstNode {
+  readonly $container: ExtendElement;
+  readonly $type: 'ExtendElementBody';
+  elements: Array<Element | Relation>;
+  props: Array<ExtendElementProperty>;
+  tags?: Tags;
+}
+declare const ExtendElementBody = "ExtendElementBody";
+interface ExtendRelation extends AstNode {
+  readonly $container: Model;
+  readonly $type: 'ExtendRelation';
+  body: ExtendRelationBody;
+  dotKind?: RelationKindDotRef;
+  kind?: Reference<RelationshipKind>;
+  source: FqnRef$2;
+  target: FqnRef$2;
+  title?: string;
+}
+declare const ExtendRelation = "ExtendRelation";
+interface ExtendRelationBody extends AstNode {
+  readonly $container: ExtendRelation;
+  readonly $type: 'ExtendRelationBody';
+  props: Array<ExtendRelationProperty>;
+  tags?: Tags;
+}
+declare const ExtendRelationBody = "ExtendRelationBody";
+interface FqnExpressions extends AstNode {
+  readonly $container: DeploymentViewRuleStyle | FqnExpressions | GlobalStyle | ViewRuleRank | ViewRuleStyle;
+  readonly $type: 'FqnExpressions';
+  prev?: FqnExpressions;
+  value: FqnExpr$2;
+}
+declare const FqnExpressions = "FqnExpressions";
+interface FqnExprWhere extends AstNode {
+  readonly $container: Expressions | FqnExprWith;
+  readonly $type: 'FqnExprWhere';
+  subject: FqnExpr$2;
+  where?: WhereElementExpression;
+}
+declare const FqnExprWhere = "FqnExprWhere";
+interface FqnExprWith extends AstNode {
+  readonly $container: Expressions;
+  readonly $type: 'FqnExprWith';
+  custom?: CustomElementProperties;
+  subject: FqnExprOrWhere;
+}
+declare const FqnExprWith = "FqnExprWith";
+interface FqnRef$2 extends AstNode {
+  readonly $container: DeploymentRelation | ElementRef | ExtendRelation | FqnRef$2 | FqnRefExpr | Relation;
+  readonly $type: 'FqnRef';
+  parent?: FqnRef$2;
+  value: Reference<Referenceable>;
+}
+declare const FqnRef$2 = "FqnRef";
+interface FqnRefExpr extends 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 AstNode {
+  readonly $container: Globals;
+  readonly $type: 'GlobalDynamicPredicateGroup';
+  name: string;
+  predicates: Array<DynamicViewIncludePredicate>;
+}
+declare const GlobalDynamicPredicateGroup = "GlobalDynamicPredicateGroup";
+interface GlobalPredicateGroup extends AstNode {
+  readonly $container: Globals;
+  readonly $type: 'GlobalPredicateGroup';
+  name: string;
+  predicates: Array<ViewRulePredicate>;
+}
+declare const GlobalPredicateGroup = "GlobalPredicateGroup";
+interface Globals extends AstNode {
+  readonly $container: LikeC4Grammar;
+  readonly $type: 'Globals';
+  name: 'global';
+  predicates: Array<GlobalDynamicPredicateGroup | GlobalPredicateGroup>;
+  styles: Array<GlobalStyle | GlobalStyleGroup>;
+}
+declare const Globals = "Globals";
+interface GlobalStyle extends AstNode {
+  readonly $container: Globals;
+  readonly $type: 'GlobalStyle';
+  id: GlobalStyleId;
+  props: Array<NotationProperty | StyleProperty>;
+  targets: FqnExpressions;
+}
+declare const GlobalStyle = "GlobalStyle";
+interface GlobalStyleGroup extends AstNode {
+  readonly $container: Globals;
+  readonly $type: 'GlobalStyleGroup';
+  id: GlobalStyleId;
+  styles: Array<ViewRuleStyle>;
+}
+declare const GlobalStyleGroup = "GlobalStyleGroup";
+interface GlobalStyleId extends AstNode {
+  readonly $container: GlobalStyle | GlobalStyleGroup;
+  readonly $type: 'GlobalStyleId';
+  name: string;
+}
+declare const GlobalStyleId = "GlobalStyleId";
+interface HexColor extends AstNode {
+  readonly $container: SpecificationColor | SpecificationTag;
+  readonly $type: 'HexColor';
+  hex: number | string;
+}
+declare const HexColor = "HexColor";
+interface IconColorProperty extends AstNode {
+  readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleStyle;
+  readonly $type: 'IconColorProperty';
+  customColor?: Reference<CustomColor>;
+  key: 'iconColor';
+  themeColor?: ThemeColor;
+}
+declare const IconColorProperty = "IconColorProperty";
+interface IconPositionProperty extends AstNode {
+  readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleStyle;
+  readonly $type: 'IconPositionProperty';
+  key: 'iconPosition';
+  value: IconPositionValue;
+}
+declare const IconPositionProperty = "IconPositionProperty";
+interface IconProperty extends AstNode {
+  readonly $container: CustomElementProperties | DeployedInstanceBody | DeploymentNodeBody | DeploymentViewRuleStyle | ElementBody | ElementStyleProperty | GlobalStyle | ViewRuleStyle;
+  readonly $type: 'IconProperty';
+  key: 'icon';
+  libicon?: Reference<LibIcon>;
+  value?: 'none' | Uri;
+}
+declare const IconProperty = "IconProperty";
+interface IconSizeProperty extends AstNode {
+  readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleStyle;
+  readonly $type: 'IconSizeProperty';
+  key: 'iconSize';
+  value: SizeValue;
+}
+declare const IconSizeProperty = "IconSizeProperty";
+interface Imported extends AstNode {
+  readonly $container: Imported | ImportsFromPoject;
+  readonly $type: 'Imported';
+  imported: Reference<Element>;
+  prev?: Imported;
+}
+declare const Imported = "Imported";
+interface ImportsFromPoject extends AstNode {
+  readonly $container: LikeC4Grammar;
+  readonly $type: 'ImportsFromPoject';
+  imports: Imported;
+  project: string;
+}
+declare const ImportsFromPoject = "ImportsFromPoject";
+interface IncomingRelationExpr extends AstNode {
+  readonly $container: Expressions | InOutRelationExpr | RelationExprWhere | RelationExprWith;
+  readonly $type: 'IncomingRelationExpr';
+  to: FqnExpr$2;
+}
+declare const IncomingRelationExpr = "IncomingRelationExpr";
+interface InOutRelationExpr extends AstNode {
+  readonly $container: Expressions | RelationExprWhere | RelationExprWith;
+  readonly $type: 'InOutRelationExpr';
+  inout: IncomingRelationExpr;
+}
+declare const InOutRelationExpr = "InOutRelationExpr";
+interface LibIcon extends AstNode {
+  readonly $container: LikeC4Lib;
+  readonly $type: 'LibIcon';
+  name: IconId;
+}
+declare const LibIcon = "LibIcon";
+interface LikeC4Grammar extends 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 AstNode {
+  readonly $container: LikeC4Grammar;
+  readonly $type: 'LikeC4Lib';
+  icons: Array<LibIcon>;
+}
+declare const LikeC4Lib = "LikeC4Lib";
+interface LineProperty extends AstNode {
+  readonly $container: CustomRelationProperties | RelationStyleProperty | SpecificationRelationshipKind;
+  readonly $type: 'LineProperty';
+  key: 'line';
+  value: LineOptions;
+}
+declare const LineProperty = "LineProperty";
+interface LinkProperty extends 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 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 AstNode {
+  readonly $container: MetadataAttribute;
+  readonly $type: 'MetadataArray';
+  values: Array<MarkdownOrString>;
+}
+declare const MetadataArray = "MetadataArray";
+interface MetadataAttribute extends AstNode {
+  readonly $container: MetadataBody;
+  readonly $type: 'MetadataAttribute';
+  key: string;
+  value: MetadataValue;
+}
+declare const MetadataAttribute = "MetadataAttribute";
+interface MetadataBody extends AstNode {
+  readonly $container: DeployedInstanceBody | DeploymentNodeBody | DeploymentRelationBody | ElementBody | ExtendDeploymentBody | ExtendElementBody | ExtendRelationBody | RelationBody;
+  readonly $type: 'MetadataBody';
+  props: Array<MetadataAttribute>;
+}
+declare const MetadataBody = "MetadataBody";
+interface Model extends AstNode {
+  readonly $container: LikeC4Grammar;
+  readonly $type: 'Model';
+  elements: Array<Element | ExtendElement | ExtendRelation | Relation>;
+  name: 'model';
+}
+declare const Model = "Model";
+interface ModelDeployments extends AstNode {
+  readonly $container: LikeC4Grammar;
+  readonly $type: 'ModelDeployments';
+  elements: Array<DeploymentNode | DeploymentRelation | ExtendDeployment>;
+  name: 'deployment';
+}
+declare const ModelDeployments = "ModelDeployments";
+interface ModelViews extends AstNode {
+  readonly $container: LikeC4Grammar;
+  readonly $type: 'ModelViews';
+  folder?: string;
+  name: 'views';
+  styles: Array<ViewRuleStyleOrGlobalRef>;
+  views: Array<LikeC4View>;
+}
+declare const ModelViews = "ModelViews";
+interface MultipleProperty extends AstNode {
+  readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleStyle;
+  readonly $type: 'MultipleProperty';
+  key: 'multiple';
+  value: boolean;
+}
+declare const MultipleProperty = "MultipleProperty";
+interface NavigateToProperty extends AstNode {
+  readonly $container: CustomElementProperties;
+  readonly $type: 'NavigateToProperty';
+  key: 'navigateTo';
+  value: ViewRef;
+}
+declare const NavigateToProperty = "NavigateToProperty";
+interface NotationProperty extends AstNode {
+  readonly $container: CustomElementProperties | CustomRelationProperties | DeploymentViewRuleStyle | GlobalStyle | ViewRuleStyle;
+  readonly $type: 'NotationProperty';
+  key: 'notation';
+  value: MarkdownOrString;
+}
+declare const NotationProperty = "NotationProperty";
+interface NotesProperty extends AstNode {
+  readonly $container: CustomElementProperties | CustomRelationProperties;
+  readonly $type: 'NotesProperty';
+  key: 'notes';
+  value: MarkdownOrString;
+}
+declare const NotesProperty = "NotesProperty";
+interface OpacityProperty extends AstNode {
+  readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleGroup | ViewRuleStyle;
+  readonly $type: 'OpacityProperty';
+  key: 'opacity';
+  value: string;
+}
+declare const OpacityProperty = "OpacityProperty";
+interface OutgoingRelationExpr extends AstNode {
+  readonly $container: DirectedRelationExpr | Expressions | RelationExprWhere | RelationExprWith;
+  readonly $type: 'OutgoingRelationExpr';
+  dotKind?: RelationKindDotRef;
+  from: FqnExpr$2;
+  isBidirectional: boolean;
+  kind?: Reference<RelationshipKind>;
+}
+declare const OutgoingRelationExpr = "OutgoingRelationExpr";
+interface PaddingSizeProperty extends AstNode {
+  readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleStyle;
+  readonly $type: 'PaddingSizeProperty';
+  key: 'padding';
+  value: SizeValue;
+}
+declare const PaddingSizeProperty = "PaddingSizeProperty";
+interface Relation extends AstNode {
+  readonly $container: ElementBody | ExtendElementBody | Model;
+  readonly $type: 'Relation';
+  body?: RelationBody;
+  description?: string;
+  dotKind?: RelationKindDotRef;
+  kind?: Reference<RelationshipKind>;
+  source?: FqnRef$2;
+  tags?: Tags;
+  target: FqnRef$2;
+  technology?: string;
+  title?: string;
+}
+declare const Relation = "Relation";
+interface RelationBody extends AstNode {
+  readonly $container: Relation;
+  readonly $type: 'RelationBody';
+  props: Array<RelationProperty>;
+  tags?: Tags;
+}
+declare const RelationBody = "RelationBody";
+interface RelationExprWhere extends AstNode {
+  readonly $container: Expressions | RelationExprWith;
+  readonly $type: 'RelationExprWhere';
+  subject: RelationExpr$1;
+  where?: WhereRelationExpression;
+}
+declare const RelationExprWhere = "RelationExprWhere";
+interface RelationExprWith extends AstNode {
+  readonly $container: Expressions;
+  readonly $type: 'RelationExprWith';
+  custom?: CustomRelationProperties;
+  subject: RelationExprOrWhere;
+}
+declare const RelationExprWith = "RelationExprWith";
+interface RelationKindDotRef extends AstNode {
+  readonly $container: AbstractDynamicStep | DeploymentRelation | ExtendRelation | OutgoingRelationExpr | Relation;
+  readonly $type: 'RelationKindDotRef';
+  kind: Reference<RelationshipKind>;
+}
+declare const RelationKindDotRef = "RelationKindDotRef";
+interface RelationNavigateToProperty extends AstNode {
+  readonly $container: CustomRelationProperties | DeploymentRelationBody | RelationBody;
+  readonly $type: 'RelationNavigateToProperty';
+  key: 'navigateTo';
+  value: DynamicViewRef;
+}
+declare const RelationNavigateToProperty = "RelationNavigateToProperty";
+interface RelationshipKind extends AstNode {
+  readonly $container: SpecificationRelationshipKind;
+  readonly $type: 'RelationshipKind';
+  name: Id;
+}
+declare const RelationshipKind = "RelationshipKind";
+interface RelationStringProperty extends AstNode {
+  readonly $container: CustomRelationProperties | DeploymentRelationBody | RelationBody;
+  readonly $type: 'RelationStringProperty';
+  key: 'description' | 'technology' | 'title';
+  value: MarkdownOrString;
+}
+declare const RelationStringProperty = "RelationStringProperty";
+interface RelationStyleProperty extends AstNode {
+  readonly $container: DeploymentRelationBody | RelationBody;
+  readonly $type: 'RelationStyleProperty';
+  key: 'style';
+  props: Array<RelationshipStyleProperty>;
+}
+declare const RelationStyleProperty = "RelationStyleProperty";
+interface RGBAColor extends AstNode {
+  readonly $container: SpecificationColor | SpecificationTag;
+  readonly $type: 'RGBAColor';
+  alpha?: number | string;
+  blue: number;
+  green: number;
+  red: number;
+}
+declare const RGBAColor = "RGBAColor";
+interface ShapeProperty extends AstNode {
+  readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleStyle;
+  readonly $type: 'ShapeProperty';
+  key: 'shape';
+  value: ElementShape;
+}
+declare const ShapeProperty = "ShapeProperty";
+interface ShapeSizeProperty extends AstNode {
+  readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleStyle;
+  readonly $type: 'ShapeSizeProperty';
+  key: 'size';
+  value: SizeValue;
+}
+declare const ShapeSizeProperty = "ShapeSizeProperty";
+interface SpecificationColor extends AstNode {
+  readonly $container: SpecificationRule;
+  readonly $type: 'SpecificationColor';
+  color: ColorLiteral$1;
+  name: CustomColor;
+}
+declare const SpecificationColor = "SpecificationColor";
+interface SpecificationDeploymentNodeKind extends AstNode {
+  readonly $container: SpecificationRule;
+  readonly $type: 'SpecificationDeploymentNodeKind';
+  kind: DeploymentNodeKind;
+  props: Array<ElementStyleProperty | LinkProperty | SpecificationElementStringProperty>;
+  tags?: Tags;
+}
+declare const SpecificationDeploymentNodeKind = "SpecificationDeploymentNodeKind";
+interface SpecificationElementKind extends AstNode {
+  readonly $container: SpecificationRule;
+  readonly $type: 'SpecificationElementKind';
+  kind: ElementKind;
+  props: Array<ElementStyleProperty | LinkProperty | SpecificationElementStringProperty>;
+  tags?: Tags;
+}
+declare const SpecificationElementKind = "SpecificationElementKind";
+interface SpecificationElementStringProperty extends AstNode {
+  readonly $container: SpecificationDeploymentNodeKind | SpecificationElementKind;
+  readonly $type: 'SpecificationElementStringProperty';
+  key: 'description' | 'notation' | 'summary' | 'technology' | 'title';
+  value: MarkdownOrString;
+}
+declare const SpecificationElementStringProperty = "SpecificationElementStringProperty";
+interface SpecificationRelationshipKind extends AstNode {
+  readonly $container: SpecificationRule;
+  readonly $type: 'SpecificationRelationshipKind';
+  kind: RelationshipKind;
+  props: Array<RelationshipStyleProperty | SpecificationRelationshipStringProperty>;
+}
+declare const SpecificationRelationshipKind = "SpecificationRelationshipKind";
+interface SpecificationRelationshipStringProperty extends AstNode {
+  readonly $container: SpecificationRelationshipKind;
+  readonly $type: 'SpecificationRelationshipStringProperty';
+  key: 'notation' | 'technology';
+  value: MarkdownOrString;
+}
+declare const SpecificationRelationshipStringProperty = "SpecificationRelationshipStringProperty";
+interface SpecificationRule extends 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 AstNode {
+  readonly $container: SpecificationRule;
+  readonly $type: 'SpecificationTag';
+  color?: ColorLiteral$1;
+  tag: Tag$1;
+}
+declare const SpecificationTag = "SpecificationTag";
+interface StrictFqnElementRef extends AstNode {
+  readonly $container: ExtendElement | StrictFqnElementRef;
+  readonly $type: 'StrictFqnElementRef';
+  el: Reference<Element>;
+  parent?: StrictFqnElementRef;
+}
+declare const StrictFqnElementRef = "StrictFqnElementRef";
+interface StrictFqnRef extends AstNode {
+  readonly $container: ExtendDeployment | StrictFqnRef;
+  readonly $type: 'StrictFqnRef';
+  parent?: StrictFqnRef;
+  value: Reference<Referenceable>;
+}
+declare const StrictFqnRef = "StrictFqnRef";
+interface Tag$1 extends AstNode {
+  readonly $container: SpecificationTag;
+  readonly $type: 'Tag';
+  name: Id;
+}
+declare const Tag$1 = "Tag";
+interface TagRef extends AstNode {
+  readonly $container: ElementTagExpression | Tags | WhereElementTag | WhereRelationParticipantTag | WhereRelationTag;
+  readonly $type: 'TagRef';
+  tag: Reference<Tag$1>;
+}
+declare const TagRef = "TagRef";
+interface Tags extends 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 AstNode {
+  readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleStyle;
+  readonly $type: 'TextSizeProperty';
+  key: 'textSize';
+  value: SizeValue;
+}
+declare const TextSizeProperty = "TextSizeProperty";
+interface ViewRef extends AstNode {
+  readonly $container: NavigateToProperty;
+  readonly $type: 'ViewRef';
+  view: Reference<LikeC4View>;
+}
+declare const ViewRef = "ViewRef";
+interface ViewRuleAutoLayout extends AstNode {
+  readonly $container: DeploymentViewBody | DynamicViewBody | ElementViewBody;
+  readonly $type: 'ViewRuleAutoLayout';
+  direction: ViewLayoutDirection;
+  nodeSep?: number;
+  rankSep?: number;
+}
+declare const ViewRuleAutoLayout = "ViewRuleAutoLayout";
+interface ViewRuleGlobalPredicateRef extends AstNode {
+  readonly $container: ElementViewBody;
+  readonly $type: 'ViewRuleGlobalPredicateRef';
+  predicate: Reference<GlobalPredicateGroup>;
+}
+declare const ViewRuleGlobalPredicateRef = "ViewRuleGlobalPredicateRef";
+interface ViewRuleGlobalStyle extends AstNode {
+  readonly $container: DynamicViewBody | ElementViewBody | ModelViews;
+  readonly $type: 'ViewRuleGlobalStyle';
+  style: Reference<GlobalStyleId>;
+}
+declare const ViewRuleGlobalStyle = "ViewRuleGlobalStyle";
+interface ViewRuleGroup extends 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 AstNode {
+  readonly $container: ElementViewBody | GlobalPredicateGroup | ViewRuleGroup;
+  readonly $type: 'ViewRulePredicate';
+  exprs: Expressions;
+  isInclude: boolean;
+}
+declare const ViewRulePredicate = "ViewRulePredicate";
+interface ViewRuleRank extends AstNode {
+  readonly $container: ElementViewBody;
+  readonly $type: 'ViewRuleRank';
+  targets: FqnExpressions;
+  value?: RankValue;
+}
+declare const ViewRuleRank = "ViewRuleRank";
+interface ViewRuleStyle extends AstNode {
+  readonly $container: DynamicViewBody | ElementViewBody | GlobalStyleGroup | ModelViews;
+  readonly $type: 'ViewRuleStyle';
+  props: Array<NotationProperty | StyleProperty>;
+  targets: FqnExpressions;
+}
+declare const ViewRuleStyle = "ViewRuleStyle";
+interface ViewStringProperty extends AstNode {
+  readonly $container: DeploymentViewBody | DynamicViewBody | ElementViewBody;
+  readonly $type: 'ViewStringProperty';
+  key: 'description' | 'title';
+  value: MarkdownOrString;
+}
+declare const ViewStringProperty = "ViewStringProperty";
+interface WhereBinaryExpression extends 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 AstNode {
+  readonly $container: FqnExprWhere | WhereBinaryExpression | WhereElementNegation;
+  readonly $type: 'WhereElementKind';
+  not: boolean;
+  operator: 'is' | string;
+  value: Reference<DeploymentNodeOrElementKind>;
+}
+declare const WhereElementKind = "WhereElementKind";
+interface WhereElementNegation extends AstNode {
+  readonly $container: FqnExprWhere | WhereBinaryExpression | WhereElementNegation;
+  readonly $type: 'WhereElementNegation';
+  value: WhereElementExpression;
+}
+declare const WhereElementNegation = "WhereElementNegation";
+interface WhereElementTag extends AstNode {
+  readonly $container: FqnExprWhere | WhereBinaryExpression | WhereElementNegation;
+  readonly $type: 'WhereElementTag';
+  not: boolean;
+  operator: 'is' | string;
+  value: TagRef;
+}
+declare const WhereElementTag = "WhereElementTag";
+interface WhereRelationKind extends AstNode {
+  readonly $container: RelationExprWhere | WhereBinaryExpression | WhereRelationNegation;
+  readonly $type: 'WhereRelationKind';
+  not: boolean;
+  operator: 'is' | string;
+  value: Reference<RelationshipKind>;
+}
+declare const WhereRelationKind = "WhereRelationKind";
+interface WhereRelationNegation extends AstNode {
+  readonly $container: RelationExprWhere | WhereBinaryExpression | WhereRelationNegation;
+  readonly $type: 'WhereRelationNegation';
+  value: WhereRelationExpression;
+}
+declare const WhereRelationNegation = "WhereRelationNegation";
+interface WhereRelationParticipantKind extends AstNode {
+  readonly $container: RelationExprWhere | WhereBinaryExpression | WhereRelationNegation;
+  readonly $type: 'WhereRelationParticipantKind';
+  not: boolean;
+  operator: 'is' | string;
+  participant: Participant;
+  value: Reference<DeploymentNodeOrElementKind>;
+}
+declare const WhereRelationParticipantKind = "WhereRelationParticipantKind";
+interface WhereRelationParticipantTag extends 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 AstNode {
+  readonly $container: RelationExprWhere | WhereBinaryExpression | WhereRelationNegation;
+  readonly $type: 'WhereRelationTag';
+  not: boolean;
+  operator: 'is' | string;
+  value: TagRef;
+}
+declare const WhereRelationTag = "WhereRelationTag";
+interface WildcardExpression extends AstNode {
+  readonly $container: DirectedRelationExpr | Expressions | FqnExprWhere | FqnExprWith | FqnExpressions | IncomingRelationExpr | OutgoingRelationExpr;
+  readonly $type: 'WildcardExpression';
+  isWildcard: boolean;
+}
+declare const WildcardExpression = "WildcardExpression";
+interface DynamicStepChain extends AbstractDynamicStep {
+  readonly $container: DynamicStepChain | DynamicViewBody | DynamicViewParallelSteps;
+  readonly $type: 'DynamicStepChain';
+  source: DynamicStepChain | DynamicStepSingle;
+}
+declare const DynamicStepChain = "DynamicStepChain";
+interface DynamicStepSingle extends AbstractDynamicStep {
+  readonly $container: DynamicStepChain | DynamicViewBody | DynamicViewParallelSteps;
+  readonly $type: 'DynamicStepSingle';
+  isBackward: boolean;
+  source: ElementRef;
+}
+declare const DynamicStepSingle = "DynamicStepSingle";
+type LikeC4AstType = {
+  AbstractDynamicStep: AbstractDynamicStep;
+  AnyProperty: AnyProperty;
+  ArrowProperty: ArrowProperty;
+  BorderProperty: BorderProperty;
+  ColorLiteral: ColorLiteral$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?: CancellationToken$1): 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<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$1): Promise<AstNodeDescription[]>;
+  private exportViews;
+  private exportGlobals;
+  private exportModel;
+  private exportLibrary;
+  private exportSpecification;
+  private exportDeployments;
+  computeLocalScopes(document: LikeC4LangiumDocument, _cancelToken?: CancellationToken$1): Promise<PrecomputedScopes>;
+  protected processContainer(container: ElementsContainer, scopes: PrecomputedScopes, document: LikeC4LangiumDocument): AstNodeDescription[];
+  protected processDeployments(container: DeploymentsContainer, scopes: PrecomputedScopes, document: LikeC4LangiumDocument): AstNodeDescription[];
+} //#endregion
+//#region src/workspace/IndexManager.d.ts
+declare class IndexManager extends DefaultIndexManager {
+  protected services: LikeC4SharedServices;
+  constructor(services: LikeC4SharedServices);
+  updateContent(document: LangiumDocument, cancelToken?: CancellationToken$1): Promise<void>;
+  projectElements(projectId: ProjectId, nodeType?: string, uris?: Set<string>): Stream<AstNodeDescription>;
+} //#endregion
+//#region src/workspace/LangiumDocuments.d.ts
+declare class LangiumDocuments extends DefaultLangiumDocuments {
+  protected services: LikeC4SharedServices;
+  constructor(services: LikeC4SharedServices);
+  protected get projectsManager(): ProjectsManager;
+  addDocument(document: LangiumDocument): void;
+  getDocument(uri: URI): LangiumDocument | undefined;
+  /**
+   * Returns all user documents
+   */
+  get userDocuments(): Stream<LikeC4LangiumDocument>;
+  /**
+   * Returns all documents (ensures project IDs are set)
+   */
+  get all(): Stream<LangiumDocument>;
+  /**
+   * Returns all documents for a project, including both project documents and documents included by the project.
+   */
+  projectDocuments(projectId: ProjectId): Stream<LikeC4LangiumDocument>;
+  groupedByProject(): Record<ProjectId, NonEmptyArray<LikeC4LangiumDocument>>;
+  /**
+   * Reset the project IDs of all documents.
+   * Returns the URIs
+   */
+  resetProjectIds(): URI[];
+} //#endregion
+//#region src/workspace/WorkspaceManager.d.ts
+declare class LikeC4WorkspaceManager extends DefaultWorkspaceManager {
+  #private;
+  private services;
+  protected readonly documentFactory: LangiumDocumentFactory;
+  protected readonly fileSystemProvider: FileSystemProvider$1;
+  initialBuildOptions: BuildOptions;
+  constructor(services: LikeC4SharedServices);
+  /**
+   * First load all project config files, then load all documents in the workspace.
+   */
+  protected performStartup(folders: WorkspaceFolder[]): Promise<LangiumDocument[]>;
+  /**
+   * Load all additional documents that shall be visible in the context of the given workspace
+   * folders and add them to the collector. This can be used to include built-in libraries of
+   * your language, which can be either loaded from provided files or constructed in memory.
+   */
+  protected loadAdditionalDocuments(folders: WorkspaceFolder[], collector: (document: LangiumDocument) => void): Promise<void>;
+  /**
+   * Determine whether the given folder entry shall be included while indexing the workspace.
+   */
+  protected includeEntry(_: WorkspaceFolder, entry: FileSystemNode, selector: FileSelector): boolean;
+  workspace(): WorkspaceFolder | null;
+  rebuildAll(cancelToken?: CancellationToken$1): Promise<void>;
+  get workspaceUri(): URI;
+  get workspaceURL(): URL;
+  /**
+   * Force clean all caches
+   */
+  forceCleanCaches(): void;
+  /**
+   * Register a listener to be called when caches are force cleaned
+   */
+  onForceCleanCache(listener: () => void): Disposable$1;
+} //#endregion
+//#region src/references/scope-provider.d.ts
+declare class LikeC4ScopeProvider extends DefaultScopeProvider {
+  protected deploymentsIndex: DeploymentsIndex;
+  protected fqnIndex: FqnIndex;
+  protected readonly indexManager: IndexManager;
+  constructor(services: LikeC4Services);
+  getScope(context: ReferenceInfo): Scope;
+  protected genUniqueDescedants(element: Element | DeploymentNode | undefined): Generator<AstNodeDescriptionWithFqn, void, any>;
+  protected genScopeExtendElement({
+    element
+  }: ExtendElement): Generator<AstNodeDescription>;
+  protected genScopeElementView({
+    viewOf,
+    extends: ext
+  }: ElementView): Generator<AstNodeDescription>;
+  protected getScopeForStrictFqnRef(projectId: ProjectId, container: StrictFqnRef, context: ReferenceInfo): Scope;
+  protected genScopeExtendDeployment({
+    deploymentNode
+  }: ExtendDeployment): Generator<AstNodeDescription>;
+  protected streamForFqnRef(projectId: ProjectId, container: FqnRef$2, context: ReferenceInfo): Stream<AstNodeDescription>;
+  protected genScopeForParentlessFqnRef(projectId: ProjectId, container: FqnRef$2, context: ReferenceInfo): Generator<AstNodeDescription>;
+  /**
+   * Computes the scope for a given reference context.
+   *
+   * @param context - The reference information containing the context for which the scope is being computed.
+   * @param referenceType - The type of reference being resolved. Defaults to the reference type derived from the context.
+   * @returns A scope containing the relevant AST node descriptions for the given reference context.
+   *
+   * This method first checks if there are precomputed scopes available in the document. If not, it falls back to the global scope.
+   * It then iterates through the container hierarchy, collecting relevant scopes based on the reference type and container type.
+   * Finally, it combines the collected scopes with the global scope to produce the final scope.
+   */
+  protected computeScope(projectId: ProjectId, context: ReferenceInfo, referenceType?: string): Generator<AstNodeDescription>;
+  /**
+   * Create a global scope filtered for the given reference type.
+   */
+  protected getProjectScope(projectId: ProjectId, referenceType: string, context: ReferenceInfo): Scope;
+  /**
+   * Create a global scope filtered for the given reference type.
+   */
+  protected getGlobalScope(referenceType: string, context: ReferenceInfo): Scope;
+} //#endregion
+//#region src/utils/disposable.d.ts
+declare abstract class ADisposable implements Disposable$1 {
+  protected toDispose: Disposable$1[];
+  protected isDisposed: boolean;
+  onDispose(...disposable: Disposable$1[]): void;
+  dispose(): void;
+  protected throwIfDisposed(): void;
+} //#endregion
+//#region src/model/fqn-index.d.ts
+declare class FqnIndex<AstNd = Element> extends ADisposable {
+  protected services: LikeC4Services;
+  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<Fqn$1, AstNodeDescriptionWithFqn>,
+  /**
+   * All descendants of an element (unique by name)
+   */
+
+  _descendants: MultiMap<Fqn$1, AstNodeDescriptionWithFqn>,
+  /**
+   * All elements by FQN
+   */
+
+  _byfqn: MultiMap<Fqn$1, AstNodeDescriptionWithFqn>, projectId: ProjectId$1);
+  rootElements(): readonly AstNodeDescriptionWithFqn[];
+  byFqn(fqn: Fqn$1): readonly AstNodeDescriptionWithFqn[];
+  children(parent: Fqn$1): readonly AstNodeDescriptionWithFqn[];
+  descendants(nodeName: Fqn$1): readonly AstNodeDescriptionWithFqn[];
+} //#endregion
+//#region src/model/deployments-index.d.ts
+declare class DeploymentsIndex extends FqnIndex<DeploymentElement> {
+  protected services: LikeC4Services;
+  protected Names: LikeC4NameProvider;
+  protected logger: any;
+  constructor(services: LikeC4Services);
+  protected createDocumentIndex(document: LikeC4LangiumDocument): DocumentFqnIndex;
+} //#endregion
+//#region src/model/builder/MergedSpecification.d.ts
+/**
+ * The `MergedSpecification` class is responsible for merging multiple parsed
+ * LikeC4Langium documents into a single specification. It consolidates tags,
+ * elements, deployments, relationships, and colors from the provided documents
+ * and provides methods to convert parsed models into C4 model elements and relations.
+ */
+declare class MergedSpecification {
+  readonly specs: Omit<ParsedAstSpecification, 'tags'>;
+  readonly tags: Readonly<Record<c4.Tag, c4.TagSpecification>>;
+  readonly globals: c4.ModelGlobals;
+  readonly imports: MultiMap<c4.ProjectId, c4.Fqn, Set<c4.Fqn>>;
+  readonly projectId: c4.ProjectId | undefined;
+  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$1 | undefined;
+  model(projectId: c4.ProjectId): LikeC4Model.Computed | undefined;
+} //#endregion
+//#region src/model/model-builder.d.ts
+type ModelParsedListener = (docs: URI[]) => void;
+interface LikeC4ModelBuilder extends Disposable$1 {
+  parseModel(projectId?: ProjectId | undefined, cancelToken?: CancellationToken$1): Promise<LikeC4Model<UnknownParsed> | null>;
+  unsafeSyncComputeModel(projectId: ProjectId): LikeC4Model<UnknownComputed>;
+  computeModel(projectId?: ProjectId | undefined, cancelToken?: CancellationToken$1): Promise<LikeC4Model<UnknownComputed>>;
+  onModelParsed(callback: ModelParsedListener): Disposable$1;
+  clearCache(): void;
+} //#endregion
+//#region src/model/model-locator.d.ts
+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, cancelToken?: CancellationToken$1): Promise<null | Array<{
+    name: Tag;
+    color: c4.ColorLiteral;
+    range: Range;
+    isSpecification: boolean;
+  }>>;
+  locateDynamicViewStep(params: {
+    view: c4.ViewId;
+    astPath: string;
+    projectId?: c4.ProjectId | undefined;
+  }): Location | null;
+} //#endregion
+//#region src/mcp/noop.d.ts
+//#endregion
+//#region src/views/LikeC4Views.d.ts
+type GraphvizOut = {
+  readonly dot: string;
+  readonly diagram: LayoutedView;
+};
+type GraphvizSvgOut = {
+  readonly id: ViewId;
+  readonly dot: string;
+  readonly svg: string;
+};
+type LayoutViewParams = {
+  viewId: ViewId;
+  /**
+   * Type of layout to apply
+   * - 'manual' - applies manual layout if any
+   * - 'auto' - returns latest version with drifts from manual layout if any
+   * - undefined - returns latest layout as is
+   */
+  layoutType?: LayoutType | undefined;
+  projectId?: ProjectId | undefined;
+  cancelToken?: CancellationToken$1 | undefined;
+};
+interface LikeC4Views {
+  readonly layouter: GraphvizLayouter;
+  /**
+   * Returns computed views (i.e. views with predicates computed)
+   *
+   * @param projectId - project id, if not specified - uses the default project
+   */
+  computedViews(projectId?: ProjectId | undefined, cancelToken?: CancellationToken$1): Promise<ComputedView[]>;
+  /**
+   * Layouts all views (ignoring any manual snapshots)
+   *
+   * @param projectId - project id, if not specified - uses the default project
+   */
+  layoutAllViews(projectId?: ProjectId | undefined, cancelToken?: CancellationToken$1): Promise<GraphvizOut[]>;
+  /**
+   * Layouts a view.
+   * If layoutType is 'manual' - applies manual layout if any.
+   * If layoutType is 'auto' - returns latest version with drifts from manual layout if any
+   * If not specified - returns latest layout as is
+   *
+   * If view not found in model, but there is a snapshot - it will be returned (with empty DOT)
+   */
+  layoutView(params: LayoutViewParams): Promise<GraphvizOut | null>;
+  /**
+   * Returns diagrams.
+   * If diagram has manual layout, it will be used.
+   * @param projectId - project id, if not specified - uses the default project
+   */
+  diagrams(projectId?: ProjectId | undefined, cancelToken?: CancellationToken$1): Promise<Array<DiagramView>>;
+  /**
+   * Returns all layouted views as Graphviz output (i.e. views with layout computed)
+   * @param projectId - project id, if not specified - uses the default project
+   */
+  viewsAsGraphvizOut(projectId?: ProjectId | undefined, cancelToken?: CancellationToken$1): Promise<Array<GraphvizSvgOut>>;
+  /**
+   * Open view in the preview panel.
+   * (works only if running as a vscode extension)
+   *
+   * @param projectId - project id, if not specified - uses the default project
+   */
+  openView(viewId: ViewId, projectId?: ProjectId | undefined): Promise<void>;
+  /**
+   * Computes and layouts an adhoc view (not defined in the model)
+   *
+   * @param projectId - project id, if not specified - uses the default project
+   */
+  adhocView(predicates: AdhocViewPredicate[], projectId?: ProjectId | undefined): Promise<LayoutedView>;
+} //#endregion
+//#region src/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?: AstNode | Reference<AstNode>, level?: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification"): void;
+    tryParse<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", node: N | undefined, fn: (node: NoInfer<N>) => T | undefined): T | undefined;
+    tryMap<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", iterable: ReadonlyArray<N>, fn: (node: N) => T | undefined): T[];
+    resolveFqn(node: FqnReferenceable): ProjectId;
+    getAstNodePath(node: AstNode): string;
+    getMetadata(metadataAstNode: MetadataProperty | undefined): {
+      [key: string]: string | string[];
+    } | undefined;
+    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId | 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?: AstNode | Reference<AstNode>, level?: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification"): void;
+    tryParse<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", node: N | undefined, fn: (node: NoInfer<N>) => T | undefined): T | undefined;
+    tryMap<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", iterable: ReadonlyArray<N>, fn: (node: N) => T | undefined): T[];
+    resolveFqn(node: FqnReferenceable): ProjectId;
+    getAstNodePath(node: AstNode): string;
+    getMetadata(metadataAstNode: MetadataProperty | undefined): {
+      [key: string]: string | string[];
+    } | undefined;
+    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId | 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?: AstNode | Reference<AstNode>, level?: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification"): void;
+    tryParse<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", node: N | undefined, fn: (node: NoInfer<N>) => T | undefined): T | undefined;
+    tryMap<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", iterable: ReadonlyArray<N>, fn: (node: N) => T | undefined): T[];
+    resolveFqn(node: FqnReferenceable): ProjectId;
+    getAstNodePath(node: AstNode): string;
+    getMetadata(metadataAstNode: MetadataProperty | undefined): {
+      [key: string]: string | string[];
+    } | undefined;
+    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId | 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?: AstNode | Reference<AstNode>, level?: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification"): void;
+    tryParse<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", node: N | undefined, fn: (node: NoInfer<N>) => T | undefined): T | undefined;
+    tryMap<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", iterable: ReadonlyArray<N>, fn: (node: N) => T | undefined): T[];
+    resolveFqn(node: FqnReferenceable): ProjectId;
+    getAstNodePath(node: AstNode): string;
+    getMetadata(metadataAstNode: MetadataProperty | undefined): {
+      [key: string]: string | string[];
+    } | undefined;
+    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId | 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?: AstNode | Reference<AstNode>, level?: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification"): void;
+    tryParse<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", node: N | undefined, fn: (node: NoInfer<N>) => T | undefined): T | undefined;
+    tryMap<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", iterable: ReadonlyArray<N>, fn: (node: N) => T | undefined): T[];
+    resolveFqn(node: FqnReferenceable): ProjectId;
+    getAstNodePath(node: AstNode): string;
+    getMetadata(metadataAstNode: MetadataProperty | undefined): {
+      [key: string]: string | string[];
+    } | undefined;
+    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId | 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?: AstNode | Reference<AstNode>, level?: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification"): void;
+    tryParse<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", node: N | undefined, fn: (node: NoInfer<N>) => T | undefined): T | undefined;
+    tryMap<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", iterable: ReadonlyArray<N>, fn: (node: N) => T | undefined): T[];
+    resolveFqn(node: FqnReferenceable): ProjectId;
+    getAstNodePath(node: AstNode): string;
+    getMetadata(metadataAstNode: MetadataProperty | undefined): {
+      [key: string]: string | string[];
+    } | undefined;
+    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId | 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?: AstNode | Reference<AstNode>, level?: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification"): void;
+    tryParse<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", node: N | undefined, fn: (node: NoInfer<N>) => T | undefined): T | undefined;
+    tryMap<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", iterable: ReadonlyArray<N>, fn: (node: N) => T | undefined): T[];
+    resolveFqn(node: FqnReferenceable): ProjectId;
+    getAstNodePath(node: AstNode): string;
+    getMetadata(metadataAstNode: MetadataProperty | undefined): {
+      [key: string]: string | string[];
+    } | undefined;
+    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId | 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?: AstNode | Reference<AstNode>, level?: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification"): void;
+    tryParse<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", node: N | undefined, fn: (node: NoInfer<N>) => T | undefined): T | undefined;
+    tryMap<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", iterable: ReadonlyArray<N>, fn: (node: N) => T | undefined): T[];
+    resolveFqn(node: FqnReferenceable): ProjectId;
+    getAstNodePath(node: AstNode): string;
+    getMetadata(metadataAstNode: MetadataProperty | undefined): {
+      [key: string]: string | string[];
+    } | undefined;
+    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId | 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?: AstNode | Reference<AstNode>, level?: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification"): void;
+    tryParse<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", node: N | undefined, fn: (node: NoInfer<N>) => T | undefined): T | undefined;
+    tryMap<N extends AstNode, T>(level: "base" | "model" | "deployment" | "fqnref" | "relation" | "views" | "globals" | "imports" | "specification", iterable: ReadonlyArray<N>, fn: (node: N) => T | undefined): T[];
+    resolveFqn(node: FqnReferenceable): ProjectId;
+    getAstNodePath(node: AstNode): string;
+    getMetadata(metadataAstNode: MetadataProperty | undefined): {
+      [key: string]: string | string[];
+    } | undefined;
+    parseMarkdownOrString(markdownOrString: MarkdownOrString | undefined): ProjectId | 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$1): Promise<LayoutedProjectsView>;
+  /**
+   * 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$1): Promise<LikeC4Model<UnknownComputed>>;
+  /**
+   * Returns {@link LikeC4Model} of the specified project, with layouted views {@link LayoutedView}
+   * Ready for rendering. Applies manual layouts if available.
+   *
+   * If no {@link project} is specified, returns for default project
+   */
+  layoutedModel(project?: ProjectId | undefined, cancelToken?: CancellationToken$1): Promise<LikeC4Model<UnknownLayouted>>;
+  /**
+   * Returns diagrams (i.e. layouted views {@link LayoutedView}) for the specified project
+   * Applies manual layouts if available.
+   *
+   * If no {@link project} is specified, returns diagrams for default project
+   */
+  diagrams(project?: ProjectId | undefined, cancelToken?: CancellationToken$1): 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$1): Promise<CodeLens[] | undefined>;
+} //#endregion
+//#region src/lsp/CompletionProvider.d.ts
+declare class LikeC4CompletionProvider extends DefaultCompletionProvider {
+  protected services: LikeC4Services;
+  constructor(services: LikeC4Services);
+  readonly completionOptions: {
+    triggerCharacters: string[];
+  };
+  protected completionFor(context: CompletionContext, next: NextFeature, acceptor: CompletionAcceptor): MaybePromise<void>;
+  protected completionForKeyword(context: CompletionContext, keyword: Keyword, acceptor: CompletionAcceptor): MaybePromise<void>;
+  protected completionForImportedProject(context: CompletionContext, acceptor: CompletionAcceptor): void;
+} //#endregion
+//#region src/lsp/DocumentHighlightProvider.d.ts
+declare class LikeC4DocumentHighlightProvider extends DefaultDocumentHighlightProvider {
+  /**
+   * Override this method to determine the highlight kind of the given reference.
+   */
+  protected createDocumentHighlight(reference: ReferenceDescription): DocumentHighlight;
+} //#endregion
+//#region src/lsp/DocumentLinkProvider.d.ts
+declare class LikeC4DocumentLinkProvider implements DocumentLinkProvider {
+  private services;
+  constructor(services: LikeC4Services);
+  getDocumentLinks(doc: LangiumDocument, _params: DocumentLinkParams, _cancelToken?: CancellationToken$1): Promise<DocumentLink[]>;
+  resolveLink(doc: LangiumDocument, link: string): string;
+  relativeLink(doc: LangiumDocument, link: string): string | null;
+} //#endregion
+//#region src/lsp/DocumentSymbolProvider.d.ts
+declare class LikeC4DocumentSymbolProvider implements DocumentSymbolProvider {
+  private services;
+  protected readonly nodeKindProvider: NodeKindProvider;
+  protected readonly nameProvider: LikeC4NameProvider;
+  protected readonly parser: LikeC4ModelParser;
+  protected readonly locator: LikeC4ModelLocator;
+  constructor(services: LikeC4Services);
+  getSymbols(doc: LangiumDocument, _params: DocumentSymbolParams, cancelToken?: CancellationToken$1): Promise<DocumentSymbol[]>;
+  protected getLikec4LibSymbol(astLib: LikeC4Lib): DocumentSymbol[];
+  protected getSpecSymbol(astSpec: SpecificationRule): DocumentSymbol[];
+  protected getModelSymbol(astModel: Model): DocumentSymbol[];
+  protected getDeploymentModelSymbol(astModel: ModelDeployments): DocumentSymbol[];
+  protected getElementsSymbol(el: Element | Relation | ExtendElement): DocumentSymbol[];
+  protected getExtendElementSymbol(astElement: ExtendElement): DocumentSymbol[];
+  protected getElementSymbol(astElement: Element): DocumentSymbol[];
+  protected getModelViewsSymbol(astViews: ModelViews): DocumentSymbol[];
+  protected getKindSymbol(astKind: SpecificationElementKind | SpecificationRelationshipKind): DocumentSymbol | null;
+  protected getTagSymbol(astTag: SpecificationTag): DocumentSymbol | null;
+  protected getLibIconSymbol(astTag: LibIcon): DocumentSymbol | null;
+  protected getViewSymbol(astView: LikeC4View): DocumentSymbol[];
+  protected getDeploymentElementSymbol(el: DeploymentElement | DeploymentRelation | ExtendDeployment): DocumentSymbol[];
+  protected getDeploymentNodeSymbol(astElement: DeploymentNode): DocumentSymbol[];
+  protected getDeployedInstanceSymbol(astElement: DeployedInstance): DocumentSymbol[];
+  protected symbolKind(node: AstNode): SymbolKind;
+} //#endregion
+//#region src/lsp/HoverProvider.d.ts
+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
+//#endregion
+export { LikeC4Services as a, ProjectsManager as i, LikeC4ModelBuilder as n, LikeC4SharedServices as o, LikeC4Views as r, LikeC4LanguageServices as t };