@likec4/language-server 0.33.1 → 0.35.0

package/dist/model/model-parser.js

@@ -0,0 +1,293 @@
+import { InvalidModelError, invariant, isNonEmptyArray, nonexhaustive } from '@likec4/core';
+import { DocumentState, getDocument, interruptAndCheck } from 'langium';
+import objectHash from 'object-hash';
+import stripIndent from 'strip-indent';
+import { Disposable } from 'vscode-languageserver-protocol';
+import { ElementViewOps, ast, cleanParsedModel, isLikeC4LangiumDocument, resolveRelationPoints, streamModel, toAutoLayout, toElementStyle, toElementStyleExcludeDefaults } from '../ast';
+import { elementRef, strictElementRefFqn } from '../elementRef';
+import { logError, logWarnError, logger } from '../logger';
+import { printDocs } from '../utils';
+export class LikeC4ModelParser {
+    services;
+    fqnIndex;
+    listeners = [];
+    constructor(services) {
+        this.services = services;
+        this.fqnIndex = services.likec4.FqnIndex;
+        services.shared.workspace.DocumentBuilder.onBuildPhase(DocumentState.Validated, async (docs, cancelToken) => await this.onValidated(docs, cancelToken));
+    }
+    onParsed(callback) {
+        this.listeners.push(callback);
+        return Disposable.create(() => {
+            const index = this.listeners.indexOf(callback);
+            if (index >= 0) {
+                this.listeners.splice(index, 1);
+            }
+        });
+    }
+    async onValidated(docs, cancelToken) {
+        let countOfChangedDocs = 0;
+        logger.debug(`[ModelParser] onValidated (${docs.length} docs)\n${printDocs(docs)}`);
+        for (const doc of docs) {
+            if (!isLikeC4LangiumDocument(doc)) {
+                continue;
+            }
+            countOfChangedDocs++;
+            try {
+                await this.parseDocument(doc, cancelToken);
+            }
+            catch (cause) {
+                logError(new InvalidModelError(`Error parsing document ${doc.uri.toString()}`, { cause }));
+            }
+        }
+        if (countOfChangedDocs > 0) {
+            this.notifyListeners();
+        }
+    }
+    async parseDocument(doc, cancelToken) {
+        const { elements, relations, views, specification } = cleanParsedModel(doc);
+        const specs = doc.parseResult.value.specification?.specs.filter(ast.isSpecificationElementKind);
+        if (specs) {
+            for (const { kind, style } of specs) {
+                if (kind.name in specification.kinds) {
+                    logger.warn(`Duplicate specification for kind ${kind.name}`);
+                    continue;
+                }
+                try {
+                    specification.kinds[kind.name] = toElementStyleExcludeDefaults(style?.props);
+                }
+                catch (e) {
+                    logWarnError(e);
+                }
+            }
+        }
+        await interruptAndCheck(cancelToken);
+        for (const el of streamModel(doc)) {
+            if (ast.isElement(el)) {
+                try {
+                    elements.push(this.parseElement(el));
+                }
+                catch (e) {
+                    logWarnError(e);
+                }
+                continue;
+            }
+            if (ast.isRelation(el)) {
+                try {
+                    relations.push(this.parseRelation(el));
+                }
+                catch (e) {
+                    logWarnError(e);
+                }
+                continue;
+            }
+            nonexhaustive(el);
+        }
+        await interruptAndCheck(cancelToken);
+        const docviews = doc.parseResult.value.views?.views;
+        if (docviews) {
+            for (const view of docviews) {
+                try {
+                    const v = this.parseElementView(view);
+                    ElementViewOps.writeId(view, v.id);
+                    views.push(v);
+                }
+                catch (e) {
+                    logWarnError(e);
+                }
+            }
+        }
+        // const prevHash = doc.c4hash ?? ''
+        // doc.c4hash = c4hash(doc)
+        // return prevHash !== doc.c4hash
+    }
+    parseElement(astNode) {
+        const id = this.resolveFqn(astNode);
+        invariant(astNode.kind.ref, 'Element kind is not resolved: ' + astNode.name);
+        const kind = astNode.kind.ref.name;
+        const tags = this.convertTags(astNode.body);
+        const stylePropsAst = astNode.body?.props.find(ast.isStyleProperties)?.props;
+        const styleProps = toElementStyleExcludeDefaults(stylePropsAst);
+        const astPath = this.getAstNodePath(astNode);
+        let [title, description, technology] = astNode.props;
+        const bodyProps = astNode.body?.props.filter((p) => ast.isElementStringProperty(p)) ?? [];
+        title = title ?? bodyProps.find(p => p.key === 'title')?.value;
+        description = description ?? bodyProps.find(p => p.key === 'description')?.value;
+        technology = technology ?? bodyProps.find(p => p.key === 'technology')?.value;
+        const links = astNode.body?.props.filter(ast.isLinkProperty).map(p => p.value);
+        return {
+            id,
+            kind,
+            astPath,
+            title: title ? stripIndent(title).trim() : astNode.name,
+            ...(tags && { tags }),
+            ...(links && isNonEmptyArray(links) && { links }),
+            ...(technology && { technology }),
+            ...(description && { description: stripIndent(description).trim() }),
+            ...styleProps
+        };
+    }
+    parseRelation(astNode) {
+        const coupling = resolveRelationPoints(astNode);
+        const target = this.resolveFqn(coupling.target);
+        const source = this.resolveFqn(coupling.source);
+        const hashdata = {
+            astPath: this.getAstNodePath(astNode),
+            source,
+            target
+        };
+        const id = objectHash(hashdata);
+        const title = astNode.title ?? astNode.body?.props.find(p => p.key === 'title')?.value ?? '';
+        return {
+            id,
+            ...hashdata,
+            title
+        };
+    }
+    parseElementExpression(astNode) {
+        if (ast.isWildcardExpression(astNode)) {
+            return {
+                wildcard: true
+            };
+        }
+        if (ast.isElementKindExpression(astNode)) {
+            invariant(astNode.kind.ref, 'ElementKindExpression kind is not resolved: ' + astNode.$cstNode?.text);
+            return {
+                elementKind: astNode.kind.ref.name,
+                isEqual: astNode.isEqual
+            };
+        }
+        if (ast.isElementTagExpression(astNode)) {
+            invariant(astNode.tag.ref, 'ElementTagExpression tag is not resolved: ' + astNode.$cstNode?.text);
+            return {
+                elementTag: astNode.tag.ref.name,
+                isEqual: astNode.isEqual
+            };
+        }
+        if (ast.isElementRefExpression(astNode)) {
+            const element = elementRef(astNode.id);
+            invariant(element, 'Element not found ' + astNode.id.$cstNode?.text);
+            return {
+                element: this.resolveFqn(element),
+                isDescedants: astNode.isDescedants
+            };
+        }
+        nonexhaustive(astNode);
+    }
+    parseExpression(astNode) {
+        if (ast.isElementExpression(astNode)) {
+            return this.parseElementExpression(astNode);
+        }
+        if (ast.isIncomingExpression(astNode)) {
+            return {
+                incoming: this.parseElementExpression(astNode.target)
+            };
+        }
+        if (ast.isOutgoingExpression(astNode)) {
+            return {
+                outgoing: this.parseElementExpression(astNode.source)
+            };
+        }
+        if (ast.isInOutExpression(astNode)) {
+            return {
+                inout: this.parseElementExpression(astNode.inout.target)
+            };
+        }
+        if (ast.isRelationExpression(astNode)) {
+            return {
+                source: this.parseElementExpression(astNode.source),
+                target: this.parseElementExpression(astNode.target)
+            };
+        }
+        nonexhaustive(astNode);
+    }
+    parseViewRule(astRule) {
+        if (ast.isViewRuleExpression(astRule)) {
+            const exprs = astRule.expressions.map(n => this.parseExpression(n));
+            return {
+                isInclude: astRule.isInclude,
+                exprs
+            };
+        }
+        if (ast.isViewRuleStyle(astRule)) {
+            const styleProps = toElementStyle(astRule.props);
+            return {
+                targets: astRule.targets.map(n => this.parseElementExpression(n)),
+                style: {
+                    ...styleProps
+                }
+            };
+        }
+        if (ast.isViewRuleAutoLayout(astRule)) {
+            return {
+                autoLayout: toAutoLayout(astRule.direction)
+            };
+        }
+        nonexhaustive(astRule);
+    }
+    parseElementView(astNode) {
+        const viewOfEl = astNode.viewOf && elementRef(astNode.viewOf);
+        const viewOf = viewOfEl && this.resolveFqn(viewOfEl);
+        const astPath = this.getAstNodePath(astNode);
+        let id = astNode.name;
+        if (!id) {
+            const doc = getDocument(astNode).uri.toString();
+            id = objectHash({
+                doc,
+                astPath,
+                viewOf: viewOf ?? null
+            });
+        }
+        const title = astNode.props.find(p => p.key === 'title')?.value;
+        const description = astNode.props.find(p => p.key === 'description')?.value;
+        const tags = this.convertTags(astNode);
+        const links = astNode.props.filter(ast.isLinkProperty).map(p => p.value);
+        return {
+            id,
+            astPath,
+            ...(viewOf && { viewOf }),
+            ...(title && { title }),
+            ...(description && { description }),
+            ...(tags && { tags }),
+            ...(links && isNonEmptyArray(links) && { links }),
+            rules: astNode.rules.flatMap(n => {
+                try {
+                    return this.parseViewRule(n);
+                }
+                catch (e) {
+                    logWarnError(e);
+                    return [];
+                }
+            })
+        };
+    }
+    resolveFqn(node) {
+        if (ast.isExtendElement(node)) {
+            return strictElementRefFqn(node.element);
+        }
+        const fqn = this.fqnIndex.getFqn(node);
+        invariant(fqn, `Not indexed element: ${this.getAstNodePath(node)}`);
+        return fqn;
+    }
+    getAstNodePath(node) {
+        return this.services.workspace.AstNodeLocator.getAstNodePath(node);
+    }
+    convertTags(withTags) {
+        if (!withTags) {
+            return null;
+        }
+        const tags = withTags.tags?.value.flatMap(({ ref }) => (ref ? ref.name : []));
+        return tags && isNonEmptyArray(tags) ? tags : null;
+    }
+    notifyListeners() {
+        for (const listener of this.listeners) {
+            try {
+                listener();
+            }
+            catch (e) {
+                logError(e);
+            }
+        }
+    }
+}
+//# sourceMappingURL=model-parser.js.map

package/dist/module.d.ts

@@ -1,12 +1,13 @@
 import type { DefaultSharedModuleContext, LangiumServices, LangiumSharedServices, Module, PartialLangiumServices } from 'langium';
 import { LikeC4DocumentSymbolProvider } from './lsp';
-import { FqnIndex, LikeC4ModelBuilder, LikeC4ModelLocator } from './model';
+import { FqnIndex, LikeC4ModelBuilder, LikeC4ModelLocator, LikeC4ModelParser } from './model';
 /**
  * Declaration of custom services - add your own service classes here.
  */
 export interface LikeC4AddedServices {
     likec4: {
         FqnIndex: FqnIndex;
+        ModelParser: LikeC4ModelParser;
         ModelBuilder: LikeC4ModelBuilder;
         ModelLocator: LikeC4ModelLocator;
     };

package/dist/module.js

@@ -1,25 +1,29 @@
 import { EmptyFileSystem, createDefaultModule, createDefaultSharedModule, inject } from 'langium';
 import { LikeC4GeneratedModule, LikeC4GeneratedSharedModule } from './generated/module';
-import { logger } from './logger';
-import { LikeC4DocumentSymbolProvider, LikeC4HoverProvider, LikeC4SemanticTokenProvider } from './lsp';
-import { FqnIndex, LikeC4ModelBuilder, LikeC4ModelLocator } from './model';
+import { LikeC4CodeLensProvider, LikeC4DocumentLinkProvider, LikeC4DocumentSymbolProvider, LikeC4HoverProvider, LikeC4SemanticTokenProvider } from './lsp';
+import { FqnIndex, LikeC4ModelBuilder, LikeC4ModelLocator, LikeC4ModelParser } from './model';
 import { LikeC4ScopeComputation, LikeC4ScopeProvider } from './references';
 import { registerProtocolHandlers } from './registerProtocolHandlers';
-import { LikeC4CodeLensProvider, LikeC4DocumentLinkProvider, LikeC4WorkspaceManager } from './shared';
+import { LikeC4WorkspaceManager } from './shared';
 import { registerValidationChecks } from './validation';
+import { logger } from './logger';
+import { serializeError } from '@likec4/core';
 function bind(Type) {
     return (services) => new Type(services);
 }
 export const LikeC4Module = {
     likec4: {
         FqnIndex: bind(FqnIndex),
+        ModelParser: bind(LikeC4ModelParser),
         ModelBuilder: bind(LikeC4ModelBuilder),
         ModelLocator: bind(LikeC4ModelLocator)
     },
     lsp: {
         DocumentSymbolProvider: bind(LikeC4DocumentSymbolProvider),
         SemanticTokenProvider: bind(LikeC4SemanticTokenProvider),
-        HoverProvider: bind(LikeC4HoverProvider)
+        HoverProvider: bind(LikeC4HoverProvider),
+        CodeLensProvider: bind(LikeC4CodeLensProvider),
+        DocumentLinkProvider: bind(LikeC4DocumentLinkProvider)
     },
     //
     //   // Formatter: bind(LikeC4Formatter),
@@ -31,44 +35,31 @@ export const LikeC4Module = {
     }
 };
 const LikeC4SharedModule = {
-    ...LikeC4GeneratedSharedModule,
     workspace: {
         WorkspaceManager: services => new LikeC4WorkspaceManager(services)
-    },
-    lsp: {
-        CodeLensProvider: services => new LikeC4CodeLensProvider(services),
-        DocumentLinkProvider: services => new LikeC4DocumentLinkProvider(services)
     }
 };
 export function createLanguageServices(context) {
     const connection = context?.connection;
     if (connection) {
-        const log = (method) => (message) => {
-            try {
-                console[method](message);
-                connection.console[method](String(message));
-                if (method === 'error') {
-                    connection.telemetry.logEvent({ eventName: 'error', message });
-                }
-            }
-            catch (error) {
-                console.error(error);
+        // eslint-disable-next-line @typescript-eslint/unbound-method
+        const original = logger.error.bind(logger);
+        logger.error = (arg) => {
+            if (typeof arg === 'string') {
+                original(arg);
+                connection.telemetry.logEvent({ eventName: 'error', error: arg });
+                return;
             }
-        };
-        logger.log = log('log');
-        logger.info = log('info');
-        logger.warn = log('warn');
-        logger.error = log('error');
-        logger.trace = logger.debug = (message) => {
-            console.debug(message);
-            connection.tracer.log(message);
+            const { message, error } = serializeError(arg);
+            original(error);
+            connection.telemetry.logEvent({ eventName: 'error', error: message });
         };
     }
     const moduleContext = {
         ...EmptyFileSystem,
         ...context
     };
-    const shared = inject(createDefaultSharedModule(moduleContext), LikeC4SharedModule);
+    const shared = inject(createDefaultSharedModule(moduleContext), LikeC4GeneratedSharedModule, LikeC4SharedModule);
     const likec4 = inject(createDefaultModule({ shared }), LikeC4GeneratedModule, LikeC4Module);
     shared.ServiceRegistry.register(likec4);
     registerValidationChecks(likec4);

package/dist/protocol.d.ts

@@ -4,17 +4,15 @@ import { NotificationType, RequestType0, RequestType } from 'vscode-languageserv
 interface BuildDocumentsParams {
     docs: DocumentUri[];
 }
-export interface LocateElementParams {
+export type LocateParams = {
     element: Fqn;
     property?: string;
-}
-export declare const locateElement: RequestType<LocateElementParams, Location | null, void>;
-export declare const locateRelation: RequestType<{
-    id: RelationID;
-}, Location | null, void>;
-export declare const locateView: RequestType<{
-    id: ViewID;
-}, Location | null, void>;
+} | {
+    relation: RelationID;
+} | {
+    view: ViewID;
+};
+export declare const locate: RequestType<LocateParams, Location | null, void>;
 export declare const Rpc: {
     readonly onDidChangeModel: NotificationType<string>;
     readonly fetchModel: RequestType0<{
@@ -24,13 +22,7 @@ export declare const Rpc: {
         docs: DocumentUri[];
     }, void>;
     readonly buildDocuments: RequestType<BuildDocumentsParams, void, void>;
-    readonly locateElement: RequestType<LocateElementParams, Location | null, void>;
-    readonly locateRelation: RequestType<{
-        id: RelationID;
-    }, Location | null, void>;
-    readonly locateView: RequestType<{
-        id: ViewID;
-    }, Location | null, void>;
+    readonly locate: RequestType<LocateParams, Location | null, void>;
 };
 export {};
 //# sourceMappingURL=protocol.d.ts.map

package/dist/protocol.js

@@ -6,17 +6,13 @@ const onDidChangeModel = new NotificationType('likec4/onDidChangeModel');
 const fetchModel = new RequestType0('likec4/fetchModel');
 const rebuild = new RequestType0('likec4/rebuildModel');
 const buildDocuments = new RequestType('likec4/buildDocuments');
-export const locateElement = new RequestType('likec4/locateElement');
-export const locateRelation = new RequestType('likec4/locateRelation');
-export const locateView = new RequestType('likec4/locateView');
+export const locate = new RequestType('likec4/locate');
 //#endregion
 export const Rpc = {
     onDidChangeModel,
     fetchModel,
     rebuild,
     buildDocuments,
-    locateElement,
-    locateRelation,
-    locateView
+    locate
 };
 //# sourceMappingURL=protocol.js.map

package/dist/references/scope-computation.js

@@ -1,6 +1,7 @@
 import { DefaultScopeComputation, MultiMap } from 'langium';
 import { ast } from '../ast';
 import { isEmpty } from 'remeda';
+import { nonexhaustive } from '@likec4/core';
 export class LikeC4ScopeComputation extends DefaultScopeComputation {
     services;
     constructor(services) {
@@ -12,15 +13,20 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
         const docExports = [];
         if (specification && specification.specs.length > 0) {
             for (const spec of specification.specs) {
-                if (ast.isSpecificationElementKind(spec) && spec.kind && !isEmpty(spec.kind.name)) {
-                    docExports.push(this.descriptions.createDescription(spec.kind, spec.kind.name, document));
+                if (ast.isSpecificationElementKind(spec)) {
+                    if (spec.kind && !isEmpty(spec.kind.name)) {
+                        docExports.push(this.descriptions.createDescription(spec.kind, spec.kind.name, document));
+                    }
                     continue;
                 }
-                if (ast.isSpecificationTag(spec) && spec.tag && !isEmpty(spec.tag.name)) {
-                    docExports.push(this.descriptions.createDescription(spec.tag, spec.tag.name, document));
-                    docExports.push(this.descriptions.createDescription(spec.tag, '#' + spec.tag.name, document));
+                if (ast.isSpecificationTag(spec)) {
+                    if (spec.tag && !isEmpty(spec.tag.name)) {
+                        docExports.push(this.descriptions.createDescription(spec.tag, spec.tag.name, document));
+                        docExports.push(this.descriptions.createDescription(spec.tag, '#' + spec.tag.name, document));
+                    }
                     continue;
                 }
+                nonexhaustive(spec);
             }
         }
         // Only root model elements are exported

package/dist/references/scope-provider.js

@@ -1,11 +1,18 @@
-import { DONE_RESULT, DefaultScopeProvider, EMPTY_STREAM, StreamImpl, StreamScope, getDocument, stream } from 'langium';
+import { DONE_RESULT, DefaultScopeProvider, EMPTY_STREAM, StreamImpl, StreamScope, getDocument, stream, findNodeForProperty, toDocumentSegment } from 'langium';
 import { ast } from '../ast';
 import { elementRef, isElementRefHead, parentStrictElementRef } from '../elementRef';
-import { logger } from '../logger';
+import { logError } from '../logger';
 function toAstNodeDescription(entry) {
+    const $cstNode = findNodeForProperty(entry.el.$cstNode, 'name');
     return {
         documentUri: entry.doc.uri,
         name: entry.name,
+        ...(entry.el.$cstNode && {
+            selectionSegment: toDocumentSegment(entry.el.$cstNode)
+        }),
+        ...($cstNode && {
+            nameSegment: toDocumentSegment($cstNode)
+        }),
         path: entry.path,
         type: ast.Element
     };
@@ -71,8 +78,7 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
             return this.computeScope(container, referenceType);
         }
         catch (e) {
-            // console.error(e)
-            logger.error(e);
+            logError(e);
             return this.getGlobalScope(referenceType);
         }
     }

package/dist/registerProtocolHandlers.js

@@ -1,6 +1,8 @@
 import { URI } from 'vscode-uri';
-import { logger } from './logger';
+import { logger, logError } from './logger';
 import { Rpc } from './protocol';
+import { nonexhaustive } from '@likec4/core';
+import { isLikeC4LangiumDocument } from './ast';
 export function registerProtocolHandlers(services) {
     const connection = services.shared.lsp.Connection;
     if (!connection) {
@@ -16,13 +18,25 @@ export function registerProtocolHandlers(services) {
         }
         catch (e) {
             model = null;
-            logger.error(e);
+            logError(e);
         }
         return Promise.resolve({ model });
     });
     connection.onRequest(Rpc.rebuild, async (cancelToken) => {
-        const changed = LangiumDocuments.all.map(d => d.uri).toArray();
-        logger.debug(`Rebuild all documents: [
+        const changed = LangiumDocuments.all
+            .map(d => {
+            // clean up any computed properties
+            if (isLikeC4LangiumDocument(d)) {
+                delete d.c4Specification;
+                delete d.c4Elements;
+                delete d.c4Relations;
+                delete d.c4Views;
+                delete d.c4fqns;
+            }
+            return d.uri;
+        })
+            .toArray();
+        logger.debug(`[ProtocolHandlers] rebuild all documents: [
       ${changed.map(d => d.toString()).join('\n      ')}
     ]`);
         await services.shared.workspace.DocumentBuilder.update(changed, [], cancelToken);
@@ -32,12 +46,11 @@ export function registerProtocolHandlers(services) {
     });
     connection.onRequest(Rpc.buildDocuments, async ({ docs }, cancelToken) => {
         if (docs.length === 0) {
-            logger.debug(`Received empty request to rebuild`);
+            logger.debug(`[ProtocolHandlers] received empty request to rebuild`);
             return;
         }
-        logger.debug(`Received request to rebuild: [
-      ${docs.join('\n      ')}
-    ]`);
+        logger.debug(`[ProtocolHandlers] received request to buildDocuments:
+  - ${docs.join('\n  - ')}`);
         const changed = [];
         for (const d of docs) {
             try {
@@ -51,7 +64,7 @@ export function registerProtocolHandlers(services) {
                 }
             }
             catch (e) {
-                logger.error(e);
+                logError(e);
             }
         }
         if (changed.length !== docs.length) {
@@ -67,14 +80,17 @@ We rebuild: [
         }
         await services.shared.workspace.DocumentBuilder.update(changed, [], cancelToken);
     });
-    connection.onRequest(Rpc.locateElement, ({ element, property }) => {
-        return modelLocator.locateElement(element, property ?? 'name');
-    });
-    connection.onRequest(Rpc.locateRelation, ({ id }) => {
-        return modelLocator.locateRelation(id);
-    });
-    connection.onRequest(Rpc.locateView, ({ id }) => {
-        return modelLocator.locateView(id);
+    connection.onRequest(Rpc.locate, params => {
+        if ('element' in params) {
+            return modelLocator.locateElement(params.element, params.property ?? 'name');
+        }
+        if ('relation' in params) {
+            return modelLocator.locateRelation(params.relation);
+        }
+        if ('view' in params) {
+            return modelLocator.locateView(params.view);
+        }
+        nonexhaustive(params);
     });
 }
 //# sourceMappingURL=registerProtocolHandlers.js.map

package/dist/shared/index.d.ts

@@ -1,4 +1,2 @@
-export * from './CodeLensProvider';
 export * from './WorkspaceManager';
-export * from './DocumentLinkProvider';
 //# sourceMappingURL=index.d.ts.map

package/dist/shared/index.js

@@ -1,4 +1,2 @@
-export * from './CodeLensProvider';
 export * from './WorkspaceManager';
-export * from './DocumentLinkProvider';
 //# sourceMappingURL=index.js.map

package/dist/test/testServices.d.ts

@@ -1,8 +1,8 @@
 import type { LikeC4LangiumDocument } from '../ast';
-export declare function createTestServices(): {
+export declare function createTestServices(workspace?: string): {
     services: import("../module").LikeC4Services;
     parse: (input: string, uri?: string) => Promise<LikeC4LangiumDocument>;
-    validate: (input: string | LikeC4LangiumDocument) => Promise<{
+    validate: (input: string | LikeC4LangiumDocument, uri?: string) => Promise<{
         document: LikeC4LangiumDocument;
         diagnostics: import("vscode-languageserver-types").Diagnostic[];
         errors: string[];