@likec4/language-server 1.49.0 → 1.51.0

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

@@ -1,11 +1,10 @@
-import { ChangeView, DidRequestOpenViewNotification, Locate } from "../protocol.mjs";
-import { LikeC4Services, LikeC4SharedServices } from "../module.mjs";
+import { h as Locate, n as ChangeView, o as DidRequestOpenViewNotification } from "./protocol.mjs";
 import * as langium from "langium";
-import { AstNode, AstNodeDescription, AsyncDisposable, BuildOptions, Cancellation, CstNode, DefaultAstNodeDescriptionProvider, DefaultDocumentValidator, DefaultIndexManager, DefaultLangiumDocuments, DefaultNameProvider, DefaultScopeComputation, DefaultScopeProvider, DefaultValueConverter, DefaultWorkspaceManager, DiagnosticInfo, Disposable, FileSelector, FileSystemNode, FileSystemProvider, GrammarAST, JSDocDocumentationProvider, LangiumDocument, LangiumDocumentFactory, MaybePromise, PrecomputedScopes, Reference, ReferenceDescription, ReferenceInfo, Scope, SimpleCache, Stream, URI, ValidationOptions, ValueType, WorkspaceCache } from "langium";
+import { AstNode, AstNodeDescription, AsyncDisposable, BuildOptions, Cancellation, CstNode, DefaultAstNodeDescriptionProvider, DefaultDocumentValidator, DefaultIndexManager, DefaultLangiumDocuments, DefaultNameProvider, DefaultScopeComputation, DefaultScopeProvider, DefaultValueConverter, DefaultWorkspaceManager, DiagnosticInfo, Disposable, FileSelector, FileSystemNode, FileSystemProvider, GrammarAST, JSDocDocumentationProvider, LangiumDocument, LangiumDocumentFactory, MaybePromise, Module, PrecomputedScopes, Reference, ReferenceDescription, ReferenceInfo, Scope, SimpleCache, Stream, URI, ValidationOptions, ValueType, WorkspaceCache } from "langium";
 import { DefaultWeakMap, MultiMap as MultiMap$1 } from "@likec4/core/utils";
-import { CompletionItemKind, Diagnostic, DocumentSymbol, FormattingOptions, Hover, Location, Range, SemanticTokens, SemanticTokensDelta, SymbolKind, TextEdit } from "vscode-languageserver-types";
-import { AbstractFormatter, AbstractSemanticTokenProvider, AstNodeHoverProvider, CodeActionProvider, CodeLensProvider, CompletionAcceptor, CompletionContext, DefaultCompletionProvider, DefaultDocumentHighlightProvider, DefaultWorkspaceSymbolProvider, DocumentLinkProvider, DocumentSymbolProvider, FormattingRegion, LangiumSharedServices, NextFeature, NodeKindProvider, SemanticTokenAcceptor } from "langium/lsp";
-import { GraphvizLayouter, QueueGraphvizLayoter } from "@likec4/layouts";
+import { CompletionItemKind, Diagnostic, DocumentSymbol, FormattingOptions, Hover, Location, Range, SymbolKind, TextEdit } from "vscode-languageserver-types";
+import { AbstractFormatter, AbstractSemanticTokenProvider, AstNodeHoverProvider, CodeActionProvider, CodeLensProvider, CompletionAcceptor, CompletionContext, DefaultCompletionProvider, DefaultDocumentHighlightProvider, DefaultSharedModuleContext, DefaultWorkspaceSymbolProvider, DocumentLinkProvider, DocumentSymbolProvider, FormattingRegion, LangiumServices, LangiumSharedServices, NextFeature, NodeKindProvider, PartialLangiumServices, SemanticTokenAcceptor } from "langium/lsp";
+import { GraphvizLayouter, GraphvizPort, QueueGraphvizLayoter } from "@likec4/layouts";
 import * as c4 from "@likec4/core";
 import { ComputedView, DiagramView, LayoutType, LayoutedView, NonEmptyArray, NonEmptyReadonlyArray, ProjectId, Tag, UnknownComputed, UnknownLayouted, UnknownParsed, ViewChange, ViewId } from "@likec4/core";
 import { AdhocViewPredicate, LayoutedProjectsView as LayoutedProjectsView$1 } from "@likec4/core/compute-view";
@@ -13,28 +12,41 @@ import { ElementModel, LikeC4Model } from "@likec4/core/model";
 import { IncludeConfig, LikeC4ProjectConfig, LikeC4ProjectConfigInput } from "@likec4/config";
 import { URI as URI$2 } from "vscode-uri";
 import { LikeC4Styles } from "@likec4/core/styles";
-import { CancellationToken, CodeLens, CodeLensParams, DocumentHighlight, DocumentLink, DocumentLinkParams, DocumentSymbolParams, WorkspaceFolder } from "vscode-languageserver";
-import { CancellationToken as CancellationToken$1, CodeAction, CodeActionParams, Command, SemanticTokensDeltaParams, SemanticTokensParams, SemanticTokensRangeParams } from "vscode-languageserver-protocol";
+import { CancellationToken, CodeLens, CodeLensParams, Connection, DocumentHighlight, DocumentLink, DocumentLinkParams, DocumentSymbolParams, WorkspaceFolder } from "vscode-languageserver";
+import { CodeAction, CodeActionParams, Command } from "vscode-languageserver-protocol";
 import { Fqn as Fqn$1, GuardedBy, LayoutedView as LayoutedView$1, ProjectId as ProjectId$1, ViewId as ViewId$1 } from "@likec4/core/types";
-import { CancellationToken as CancellationToken$2 } from "vscode-jsonrpc";
+import { CancellationToken as CancellationToken$1 } from "vscode-jsonrpc";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import * as type_fest0 from "type-fest";
 import { ConditionalPick, MergeExclusive, Simplify, Tagged, ValueOf, Writable } from "type-fest";
 import { ServerOptions } from "@modelcontextprotocol/sdk/server/index.js";
 
 //#region src/documentation/documentation-provider.d.ts
+/**
+ * Provides documentation for LikeC4 AST nodes, extending JSDoc parsing
+ * with specialized formatting for deployment nodes, deployed instances, and elements.
+ */
 declare class LikeC4DocumentationProvider extends JSDocDocumentationProvider {
   private parser;
   private locator;
+  /**
+   * Creates a new documentation provider.
+   * @param services - The LikeC4 language services.
+   */
   constructor(services: LikeC4Services);
+  /**
+   * Returns documentation for the given AST node (deployment nodes, deployed instances, elements, or JSDoc fallback).
+   * @param node - The AST node to document.
+   * @returns Formatted documentation string, or undefined if none.
+   */
   getDocumentation(node: AstNode): string | undefined;
 }
 //#endregion
 //#region src/workspace/ProjectsManager.d.ts
 type DocOrUri = LangiumDocument | string | URI;
 /**
- * A tagged string that represents a project folder URI
- * Always has trailing slash.
+ * A tagged string that represents a project folder URI (with trailing slash).
+ * Used in `startsWith` checks to determine if a document belongs to a project.
  */
 type ProjectFolder = Tagged<string, 'ProjectFolder'>;
 declare function ProjectFolder(folder: URI | string): ProjectFolder;
@@ -155,6 +167,7 @@ declare class ProjectsManager {
   private getWorkspaceFolder;
   private notifyListeners;
   private updateIncludesExcludes;
+  private warnIfConfigOverride;
 }
 //#endregion
 //#region src/filesystem/types.d.ts
@@ -312,7 +325,7 @@ interface LikeC4MCPServerModuleContext {
 }
 //#endregion
 //#region src/generated/ast.d.ts
-type AnyProperty = DynamicViewProperty | ElementProperty | RelationProperty | StringProperty | ViewProperty;
+type AnyProperty = DynamicViewProperty | ElementProperty | NavigateToProperty | NotationProperty | NotesProperty | RelationProperty | RelationshipStyleProperty | StringProperty | StyleProperty | ViewProperty;
 declare const AnyProperty = "AnyProperty";
 type ArrowType = 'crow' | 'diamond' | 'dot' | 'none' | 'normal' | 'odiamond' | 'odot' | 'onormal' | 'open' | 'vee';
 type BorderStyleValue = 'none' | LineOptions;
@@ -1971,7 +1984,10 @@ declare class MergedSpecification {
   readonly globals: c4.ModelGlobals;
   readonly imports: MultiMap$1<c4.ProjectId, c4.Fqn, Set<c4.Fqn>>;
   readonly projectId: c4.ProjectId | undefined;
-  constructor(docs: ReadonlyArray<ParsedLikeC4LangiumDocument>);
+  readonly inferTechFromIcon: boolean;
+  constructor(docs: ReadonlyArray<ParsedLikeC4LangiumDocument>, opts?: {
+    inferTechFromIcon?: boolean;
+  });
   /**
    * Converts a parsed model into a C4 model element.
    */
@@ -2025,29 +2041,59 @@ declare class MergedSpecification {
 declare class LastSeenArtifacts {
   #private;
   constructor(services: LikeC4Services);
+  /**
+   * Cache the last successful merged specification for its project.
+   * @param specification - MergedSpecification to store (by projectId).
+   * @returns The same specification (stores in internal map when projectId is set).
+   */
   rememberSpecification(specification: MergedSpecification): MergedSpecification;
+  /**
+   * Cache the last successful computed model and its styles for the project.
+   * @param model - LikeC4Model.Computed to store (by projectId).
+   * @returns The same model (stores model and styles in internal maps).
+   */
   rememberModel<M extends LikeC4Model.Computed>(model: M): M;
+  /**
+   * Returns the last seen merged specification for the given project, if available.
+   * @param projectId - Project id to look up.
+   * @returns MergedSpecification or undefined.
+   */
   specification(projectId: c4.ProjectId): MergedSpecification | undefined;
+  /**
+   * Returns the last seen styles for the given project, if available.
+   * @param projectId - Project id to look up.
+   * @returns LikeC4Styles or undefined.
+   */
   styles(projectId: c4.ProjectId): LikeC4Styles | undefined;
+  /**
+   * Returns the last seen computed model for the given project, if available.
+   * @param projectId - Project id to look up.
+   * @returns LikeC4Model.Computed or undefined.
+   */
   model(projectId: c4.ProjectId): LikeC4Model.Computed | undefined;
 }
 //#endregion
 //#region src/model/model-builder.d.ts
 type ModelParsedListener = (docs: URI[]) => void;
 interface LikeC4ModelBuilder extends Disposable {
-  parseModel(projectId?: ProjectId | undefined, cancelToken?: CancellationToken$2): Promise<LikeC4Model<UnknownParsed> | null>;
+  parseModel(projectId?: ProjectId | undefined, cancelToken?: CancellationToken$1): Promise<LikeC4Model<UnknownParsed> | null>;
   unsafeSyncComputeModel(projectId: ProjectId): LikeC4Model<UnknownComputed>;
-  computeModel(projectId?: ProjectId | undefined, cancelToken?: CancellationToken$2): Promise<LikeC4Model<UnknownComputed>>;
+  computeModel(projectId?: ProjectId | undefined, cancelToken?: CancellationToken$1): Promise<LikeC4Model<UnknownComputed>>;
   onModelParsed(callback: ModelParsedListener): Disposable;
   clearCache(): void;
 }
 //#endregion
 //#region src/model/model-locator.d.ts
+/** Result of locating a view: document, view AST, and view block node. */
 type ViewLocateResult = {
   doc: ParsedLikeC4LangiumDocument;
   view: ParsedAstView;
   viewAst: LikeC4View;
 };
+/**
+ * Locates elements, views, and documents in the LikeC4 model by FQN or AST node.
+ * Used by LSP features (hover, go-to-definition, document tags, etc.).
+ */
 declare class LikeC4ModelLocator {
   private services;
   private fqnIndex;
@@ -2060,16 +2106,33 @@ declare class LikeC4ModelLocator {
    * Returns the parsed documents
    */
   private documents;
+  /**
+   * Get parsed element by AST node or by FQN (and optional projectId).
+   * @param args - Either [element AST], [fqn], or [fqn, projectId]
+   * @returns { projectId, element, document } or null if not found
+   */
   getParsedElement(...args: [Element] | [c4.Fqn] | [c4.Fqn, c4.ProjectId]): null | {
     projectId: c4.ProjectId;
     element: ParsedAstElement;
     document: LangiumDocument;
   };
   private findParsedElementByFqnIn;
+  /**
+   * Get LSP Location for an element by FQN (and optional projectId).
+   * @param fqn - Fully qualified name (may include project prefix)
+   * @param projectId - Optional project scope
+   * @returns Location or null
+   */
   locateElement(fqn: c4.Fqn, projectId?: c4.ProjectId | undefined): Location | null;
   locateDeploymentElement(deploymentFqn: c4.DeploymentFqn, projectId?: c4.ProjectId | undefined): Location | null;
   locateRelation(relationId: c4.RelationId, projectId?: c4.ProjectId): Location | null;
   locateViewAst(viewId: c4.ViewId, projectId?: c4.ProjectId | undefined): null | ViewLocateResult;
+  /**
+   * Get LSP Location for a view by id (and optional projectId).
+   * @param viewId - View id
+   * @param projectId - Optional project scope
+   * @returns Location or null
+   */
   locateView(viewId: c4.ViewId, projectId?: c4.ProjectId): Location | null;
   /**
    * Returns an array of tags with their name, color, range and whether they are defined in the specification or not.
@@ -2169,6 +2232,101 @@ interface LikeC4Views {
   adhocView(predicates: AdhocViewPredicate[], projectId?: ProjectId | undefined): Promise<LayoutedView>;
 }
 //#endregion
+//#region src/views/index.d.ts
+interface LikeC4ViewsModuleContext {
+  graphviz: (services: LikeC4Services) => GraphvizPort;
+}
+declare const WithWasmGraphviz: LikeC4ViewsModuleContext;
+declare function WithGraphviz(graphviz: GraphvizPort): LikeC4ViewsModuleContext;
+//#endregion
+//#region src/configureLogger.d.ts
+type ConfigureLanguageServerLoggerOptions = {
+  /**
+   * The LSP connection if available
+   * (used by Telemetry)
+   */
+  lspConnection?: Connection | undefined;
+  /**
+   * Whether to use stderr for logging instead of stdout.
+   * @default false
+   */
+  useStdErr?: boolean;
+  /**
+   * The log level to use.
+   * @default 'warning'
+   */
+  logLevel?: 'trace' | 'debug' | 'info' | 'warning' | 'error' | undefined;
+  /**
+   * @default true
+   */
+  enableTelemetry?: boolean;
+  /**
+   * Enable non-blocking logging (async).
+   * @default false
+   */
+  nonBlocking?: boolean;
+  /**
+   * Whether to use colors in logging.
+   * @default false
+   */
+  colors?: boolean;
+};
+declare function configureLanguageServerLogger({
+  lspConnection: connection,
+  enableTelemetry,
+  useStdErr,
+  logLevel: lowestLevel,
+  nonBlocking,
+  colors
+}?: ConfigureLanguageServerLoggerOptions): void;
+//#endregion
+//#region src/index.d.ts
+interface StartLanguageServerOptions {
+  /**
+   * The Language Server Protocol connection to use.
+   */
+  connection?: Connection;
+  /**
+   * Whether to enable the file system watcher.
+   * @default true
+   */
+  enableWatcher?: boolean;
+  /**
+   * Whether to enable the MCP server.
+   * @default 'sse'
+   */
+  enableMCP?: false | 'stdio' | 'sse' | {
+    port: number;
+  };
+  /**
+   * Whether to enable manual layouts, stored in json5 files.
+   * @default true
+   */
+  enableManualLayouts?: boolean;
+  /**
+   * Whether to use the `dot` binary for layouting or the WebAssembly version.
+   * If {@link connection} is set, {@link ConfigurableLayouter} is started
+   * and this option controls the default layouter implementation used by it.
+   *
+   * @default 'wasm'
+   */
+  graphviz?: 'wasm' | 'binary';
+  /**
+   * Whether to configure the logger.
+   *
+   * - `false` - don't configure the logger
+   * - `'console'` - configure the logger with console sink
+   * - `'stderr'` - configure the logger with stderr sink
+   *
+   * @default false
+   */
+  configureLogger?: false | 'console' | 'stderr';
+}
+declare function startLanguageServer$1(options?: StartLanguageServerOptions): {
+  shared: LikeC4SharedServices;
+  likec4: LikeC4Services;
+};
+//#endregion
 //#region src/model/parser/Base.d.ts
 type ParserLevel = 'base' | 'model' | 'deployment' | 'fqnref' | 'relation' | 'views' | 'globals' | 'imports' | 'specification';
 declare class BaseParser {
@@ -2940,28 +3098,28 @@ interface LikeC4LanguageServices {
    * Computes and layouts projects overview - a special diagram
    * that shows all projects and their relationships
    */
-  projectsOverview(cancelToken?: CancellationToken$2): Promise<LayoutedProjectsView$1>;
+  projectsOverview(cancelToken?: CancellationToken$1): Promise<LayoutedProjectsView$1>;
   /**
    * Returns {@link LikeC4Model} of the specified project, with computed views {@link ComputedView}
    * Not ready for rendering, but enough to traverse model. Much faster than {@link layoutedModel}
    *
    * If no {@link project} is specified, returns for default project
    */
-  computedModel(project?: ProjectId | undefined, cancelToken?: CancellationToken$2): Promise<LikeC4Model<UnknownComputed>>;
+  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$2): Promise<LikeC4Model<UnknownLayouted>>;
+  layoutedModel(project?: ProjectId | undefined, cancelToken?: CancellationToken$1): Promise<LikeC4Model<UnknownLayouted>>;
   /**
    * Returns diagrams (i.e. layouted views {@link LayoutedView}) for the specified project
    * Applies manual layouts if available.
    *
    * If no {@link project} is specified, returns diagrams for default project
    */
-  diagrams(project?: ProjectId | undefined, cancelToken?: CancellationToken$2): Promise<LayoutedView[]>;
+  diagrams(project?: ProjectId | undefined, cancelToken?: CancellationToken$1): Promise<LayoutedView[]>;
   getErrors(): Array<{
     message: string;
     line: number;
@@ -3039,15 +3197,41 @@ declare class LikeC4DocumentSymbolProvider implements DocumentSymbolProvider {
 }
 //#endregion
 //#region src/lsp/HoverProvider.d.ts
+/**
+ * Provides hover content for LikeC4 AST nodes (elements, tags, relations, etc.)
+ * in the language server. Resolves model references and formats markdown hover text.
+ */
 declare class LikeC4HoverProvider extends AstNodeHoverProvider {
   protected services: LikeC4Services;
   private parser;
   private locator;
+  /** @param services - LikeC4 language services (parser, locator, etc.) */
   constructor(services: LikeC4Services);
   protected getAstNodeHoverContent(node: AstNode): MaybePromise<Hover | undefined>;
+  /**
+   * Builds hover content for an element node (title, summary, model details and view links).
+   * @param node - The element AST node to generate hover content for.
+   * @returns Hover information with markdown content, or undefined if element not found.
+   */
   protected getElementHover(node: Element): MaybePromise<Hover | undefined>;
+  /**
+   * Builds markdown hover content for an element model (relationship counts and links to views).
+   * @param model - The element model containing relationship and view information.
+   * @param projectId - The project identifier for constructing view links.
+   * @returns Markdown string with model details, or undefined if no details available.
+   */
   protected getElementModelHover(model: ElementModel, projectId: ProjectId): string | undefined;
+  /**
+   * Builds hover content for a deployment node (id, title, kind, summary).
+   * @param node - The deployment node AST node to generate hover content for.
+   * @returns Hover information with markdown content.
+   */
   protected getDeploymentNodeHover(node: DeploymentNode): MaybePromise<Hover | undefined>;
+  /**
+   * Builds hover content for a deployed instance (instance id, element ref, title and kind).
+   * @param node - The deployed instance AST node to generate hover content for.
+   * @returns Hover information with markdown content showing instance details.
+   */
   protected getDeployedInstanceHover(node: DeployedInstance): MaybePromise<Hover | undefined>;
 }
 //#endregion
@@ -3069,10 +3253,6 @@ declare class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider
   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;
@@ -3104,4 +3284,126 @@ declare class NodeKindProvider$1 implements NodeKindProvider {
 //#region src/shared/WorkspaceSymbolProvider.d.ts
 declare class WorkspaceSymbolProvider extends DefaultWorkspaceSymbolProvider {}
 //#endregion
-export { ProjectsManager as $, LikeC4ScopeComputation as A, NoFileSystem as B, LastSeenArtifacts as C, LikeC4WorkspaceManager as D, LikeC4ScopeProvider as E, LikeC4MCPServerModuleContext as F, FileSystemProvider$1 as G, NoLikeC4ManualLayouts as H, LikeC4Formatter as I, LikeC4ManualLayouts as J, FileSystemWatcher as K, WithLikeC4ManualLayouts as L, LikeC4DocumentValidator as M, LikeC4MCPServer as N, LangiumDocuments as O, LikeC4MCPServerFactory as P, ProjectData as Q, WithChokidarWatcher as R, LikeC4ModelBuilder as S, FqnIndex as T, FileNode as U, NoFileSystemWatcher as V, FileSystemModuleContext as W, ManualLayoutsSnapshot as X, LikeC4ManualLayoutsModuleContext as Y, Project as Z, LikeC4Views as _, LikeC4CodeActionProvider as a, LikeC4ModelLocator as b, LikeC4DocumentLinkProvider as c, LikeC4CodeLensProvider as d, LikeC4DocumentationProvider as et, LikeC4LanguageServices as f, LikeC4ModelParser as g, DocumentParser as h, LikeC4SemanticTokenProvider as i, LikeC4NameProvider as j, IndexManager as k, LikeC4DocumentHighlightProvider as l, LikeC4ValueConverter as m, NodeKindProvider$1 as n, LikeC4HoverProvider as o, LikeC4ModelChanges as p, FileSystemWatcherModuleContext as q, Rpc as r, LikeC4DocumentSymbolProvider as s, WorkspaceSymbolProvider as t, LikeC4CompletionProvider as u, WithMCPServer as v, DeploymentsIndex as w, ViewLocateResult as x, NoMCPServer as y, WithFileSystem as z };
+//#region src/module.d.ts
+interface LikeC4AddedSharedServices {
+  lsp: {
+    NodeKindProvider: NodeKindProvider$1;
+    WorkspaceSymbolProvider: WorkspaceSymbolProvider;
+  };
+  workspace: {
+    Cache: WorkspaceCache<string, any>;
+    ProjectsManager: ProjectsManager;
+    IndexManager: IndexManager;
+    LangiumDocuments: LangiumDocuments;
+    WorkspaceManager: LikeC4WorkspaceManager;
+    FileSystemProvider: FileSystemProvider$1;
+    FileSystemWatcher: FileSystemWatcher;
+    ManualLayouts: LikeC4ManualLayouts;
+  };
+}
+type LikeC4SharedServices = LangiumSharedServices & LikeC4AddedSharedServices;
+type LikeC4SharedModuleContext = Omit<DefaultSharedModuleContext, 'fileSystemProvider'> & FileSystemModuleContext & LikeC4ManualLayoutsModuleContext;
+/**
+ * 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;
+    Graphviz: GraphvizPort;
+    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;
+type LikeC4ServicesContext = LikeC4MCPServerModuleContext & LikeC4ViewsModuleContext;
+/**
+ * Most probably you don't need to use this function directly.
+ * Use {@link createLanguageServices} instead.
+ * @internal
+ */
+declare function createLikeC4Module(context: LikeC4ServicesContext): Module<LikeC4Services, PartialLangiumServices & LikeC4AddedServices>;
+type LanguageServicesContext = LikeC4SharedModuleContext & LikeC4ServicesContext;
+/**
+ * Create and initialize likec4 language services with the given context
+ * @example
+ * ```ts
+ * const { shared, likec4 } = createLanguageServices({
+ *   ...WithFileSystem(enableWatcher = true),
+ *   ...WithLikeC4ManualLayouts(),
+ *   ...NoMcpServer(),
+ * });
+ * ```
+ *
+ * It is possible to extend/override the context with additional modules
+ * See Langium documentation for more details (or at the CliContext in packages/likec4/src/language/module.ts).
+ */
+declare function createLanguageServices(): {
+  shared: LikeC4SharedServices;
+  likec4: LikeC4Services;
+};
+declare function createLanguageServices(context: Partial<LanguageServicesContext>): {
+  shared: LikeC4SharedServices;
+  likec4: LikeC4Services;
+};
+declare function createLanguageServices(context: Partial<LanguageServicesContext>): {
+  shared: LikeC4SharedServices;
+  likec4: LikeC4Services;
+};
+declare function createLanguageServices<I1, I extends I1 & LikeC4Services>(context: Partial<LanguageServicesContext>, module: Module<I, I1> | undefined): {
+  shared: LikeC4SharedServices;
+  likec4: I;
+};
+declare function createLanguageServices<I1, I2, I extends I1 & I2 & LikeC4Services>(context: Partial<LanguageServicesContext>, module: Module<I, I1>, module2: Module<I, I2>): {
+  shared: LikeC4SharedServices;
+  likec4: I;
+};
+declare function createLanguageServices<I1, I2, I3, I extends I1 & I2 & I3 & LikeC4Services>(context: Partial<LanguageServicesContext>, module: Module<I, I1>, module2: Module<I, I2>, module3: Module<I, I3>): {
+  shared: LikeC4SharedServices;
+  likec4: I;
+};
+/**
+ * Most probably you don't need to use this function directly.
+ * Use {@link createLanguageServices} instead.
+ * @internal
+ */
+declare function createSharedServices(context?: Partial<LanguageServicesContext>): LikeC4SharedServices;
+//#endregion
+export { LikeC4MCPServerModuleContext as A, FileSystemWatcher as B, ViewLocateResult as C, LangiumDocuments as D, LikeC4WorkspaceManager as E, NoFileSystemWatcher as F, Project as G, LikeC4ManualLayouts as H, NoLikeC4ManualLayouts as I, ProjectData as K, FileNode as L, WithChokidarWatcher as M, WithFileSystem as N, LikeC4MCPServer as O, NoFileSystem as P, FileSystemModuleContext as R, LikeC4ModelLocator as S, FqnIndex as T, LikeC4ManualLayoutsModuleContext as U, FileSystemWatcherModuleContext as V, ManualLayoutsSnapshot as W, WithGraphviz as _, LikeC4SharedModuleContext as a, WithMCPServer as b, createLikeC4Module as c, DocumentParser as d, LikeC4ModelParser as f, LikeC4ViewsModuleContext as g, configureLanguageServerLogger as h, LikeC4ServicesContext as i, WithLikeC4ManualLayouts as j, LikeC4MCPServerFactory as k, createSharedServices as l, ConfigureLanguageServerLoggerOptions as m, LikeC4AddedServices as n, LikeC4SharedServices as o, startLanguageServer$1 as p, ProjectsManager as q, LikeC4Services as r, createLanguageServices as s, LanguageServicesContext as t, LikeC4LanguageServices as u, WithWasmGraphviz as v, LikeC4ModelBuilder as w, NoMCPServer as x, LikeC4Views as y, FileSystemProvider$1 as z };