@likec4/language-server 1.47.0 → 1.49.0

package/dist/model/fqn-index.d.ts

@@ -1,61 +0,0 @@
-import { type ProjectId, Fqn } from '@likec4/core/types';
-import { DefaultWeakMap, MultiMap } from '@likec4/core/utils';
-import { type Stream, WorkspaceCache } from 'langium';
-import { type AstNodeDescriptionWithFqn, type LikeC4LangiumDocument, ast } from '../ast';
-import type { LikeC4Services } from '../module';
-import { ADisposable } from '../utils';
-import { type LangiumDocuments, ProjectsManager } from '../workspace';
-export declare class FqnIndex<AstNd = ast.Element> extends ADisposable {
-    protected services: LikeC4Services;
-    protected projects: ProjectsManager;
-    protected langiumDocuments: LangiumDocuments;
-    protected documentCache: DefaultWeakMap<LikeC4LangiumDocument, DocumentFqnIndex>;
-    protected workspaceCache: WorkspaceCache<string, AstNodeDescriptionWithFqn[]>;
-    constructor(services: LikeC4Services);
-    private documents;
-    get(document: LikeC4LangiumDocument): DocumentFqnIndex;
-    resolve(reference: ast.Referenceable): Fqn;
-    getFqn(el: AstNd): Fqn;
-    byFqn(projectId: ProjectId, fqn: Fqn): Stream<AstNodeDescriptionWithFqn>;
-    rootElements(projectId: ProjectId): Stream<AstNodeDescriptionWithFqn>;
-    directChildrenOf(projectId: ProjectId, parent: Fqn): Stream<AstNodeDescriptionWithFqn>;
-    /**
-     * Returns descedant elements with unique names in the scope
-     */
-    uniqueDescedants(projectId: ProjectId, parent: Fqn): Stream<AstNodeDescriptionWithFqn>;
-    protected createDocumentIndex(document: LikeC4LangiumDocument): DocumentFqnIndex;
-}
-export 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;
-    static readonly EMPTY: DocumentFqnIndex;
-    constructor(_rootElements: Array<AstNodeDescriptionWithFqn>, 
-    /**
-     * direct children of elements
-     */
-    _children: MultiMap<Fqn, AstNodeDescriptionWithFqn>, 
-    /**
-     * All descendants of an element (unique by name)
-     */
-    _descendants: MultiMap<Fqn, AstNodeDescriptionWithFqn>, 
-    /**
-     * All elements by FQN
-     */
-    _byfqn: MultiMap<Fqn, AstNodeDescriptionWithFqn>, projectId: ProjectId);
-    rootElements(): readonly AstNodeDescriptionWithFqn[];
-    byFqn(fqn: Fqn): readonly AstNodeDescriptionWithFqn[];
-    children(parent: Fqn): readonly AstNodeDescriptionWithFqn[];
-    descendants(nodeName: Fqn): readonly AstNodeDescriptionWithFqn[];
-}

package/dist/model/fqn-index.js

@@ -1,253 +0,0 @@
-// SPDX-License-Identifier: MIT
-//
-// Copyright (c) 2023-2025 Denis Davydkov
-// Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-//
-// Portions of this file have been modified by NVIDIA CORPORATION & AFFILIATES.
-import { invariant, nonNullable } from '@likec4/core';
-import { Fqn } from '@likec4/core/types';
-import { ancestorsFqn, compareNatural, DefaultWeakMap, MultiMap, sortNaturalByFqn } from '@likec4/core/utils';
-import { AstUtils, DocumentState, stream, WorkspaceCache, } from 'langium';
-import { isDefined, isEmpty, isTruthy } from 'remeda';
-import { ast, ElementOps, isLikeC4LangiumDocument, } from '../ast';
-import { logWarnError } from '../logger';
-import { ADisposable } from '../utils';
-import { readStrictFqn } from '../utils/elementRef';
-import { ProjectsManager } from '../workspace';
-export class FqnIndex extends ADisposable {
-    services;
-    projects;
-    langiumDocuments;
-    documentCache;
-    workspaceCache;
-    constructor(services) {
-        super();
-        this.services = services;
-        this.langiumDocuments = services.shared.workspace.LangiumDocuments;
-        this.projects = services.shared.workspace.ProjectsManager;
-        this.documentCache = new DefaultWeakMap(doc => this.createDocumentIndex(doc));
-        this.workspaceCache = new WorkspaceCache(services.shared, DocumentState.IndexedContent);
-        this.onDispose(services.shared.workspace.DocumentBuilder.onDocumentPhase(DocumentState.IndexedContent, (doc) => {
-            if (isLikeC4LangiumDocument(doc)) {
-                this.documentCache.delete(doc);
-            }
-        }));
-    }
-    documents(projectId) {
-        return this.langiumDocuments.projectDocuments(projectId).filter((d) => isLikeC4LangiumDocument(d)
-            && d.state >= DocumentState.IndexedContent);
-    }
-    get(document) {
-        if (document.state < DocumentState.IndexedContent) {
-            logWarnError(`Document ${document.uri.path} is not indexed`);
-        }
-        return this.documentCache.get(document);
-    }
-    resolve(reference) {
-        if (reference.$type === 'Imported') {
-            return this.getFqn(reference.imported.ref);
-        }
-        if (reference.$type === 'Element') {
-            return this.getFqn(reference);
-        }
-        return this.services.likec4.DeploymentsIndex.getFqn(reference);
-    }
-    getFqn(el) {
-        invariant(ast.isElement(el) || ast.isDeploymentElement(el));
-        let id = ElementOps.readId(el);
-        if (isTruthy(id)) {
-            return id;
-        }
-        // Document index is not yet created
-        const doc = AstUtils.getDocument(el);
-        invariant(isLikeC4LangiumDocument(doc));
-        // Ensure the document is indexed
-        this.get(doc);
-        // This will create the document index
-        return nonNullable(ElementOps.readId(el), 'Element fqn must be set, invalid state');
-    }
-    byFqn(projectId, fqn) {
-        return stream(this.workspaceCache.get(`${projectId}:fqn:${fqn}`, () => {
-            return this
-                .documents(projectId)
-                .flatMap(doc => {
-                return this.get(doc).byFqn(fqn);
-            })
-                .toArray();
-        }));
-    }
-    rootElements(projectId) {
-        return stream(this.workspaceCache.get(`${projectId}:rootElements`, () => {
-            const allchildren = this.documents(projectId)
-                .reduce((map, doc) => {
-                this.get(doc).rootElements().forEach(desc => {
-                    map.set(desc.name, desc);
-                });
-                return map;
-            }, new MultiMap());
-            return uniqueByName(allchildren);
-        }));
-    }
-    directChildrenOf(projectId, parent) {
-        return stream(this.workspaceCache.get(`${projectId}:directChildrenOf:${parent}`, () => {
-            const allchildren = this.documents(projectId)
-                .reduce((map, doc) => {
-                this.get(doc).children(parent).forEach(desc => {
-                    map.set(desc.name, desc);
-                });
-                return map;
-            }, new MultiMap());
-            return uniqueByName(allchildren);
-        }));
-    }
-    /**
-     * Returns descedant elements with unique names in the scope
-     */
-    uniqueDescedants(projectId, parent) {
-        return stream(this.workspaceCache.get(`${projectId}:uniqueDescedants:${parent}`, () => {
-            const { children, descendants } = this.documents(projectId)
-                .reduce((map, doc) => {
-                const docIndex = this.get(doc);
-                docIndex.children(parent).forEach(desc => {
-                    map.children.set(desc.name, desc);
-                });
-                docIndex.descendants(parent).forEach(desc => {
-                    map.descendants.set(desc.name, desc);
-                });
-                return map;
-            }, {
-                children: new MultiMap(),
-                descendants: new MultiMap(),
-            });
-            const uniqueChildren = uniqueByName(children);
-            const uniqueDescendants = [...descendants.associations()]
-                .flatMap(([_name, descs]) => descs.length === 1 && !children.has(_name) ? descs : []);
-            return [
-                ...uniqueChildren,
-                ...sortNaturalByFqn(uniqueDescendants),
-            ];
-        }));
-    }
-    createDocumentIndex(document) {
-        const rootElements = document.parseResult.value.models.flatMap(m => m.elements);
-        if (rootElements.length === 0) {
-            return DocumentFqnIndex.EMPTY;
-        }
-        const projectId = document.likec4ProjectId ?? this.projects.belongsTo(document);
-        const root = new Array();
-        const children = new MultiMap();
-        const descendants = new MultiMap();
-        const byfqn = new MultiMap();
-        const Descriptions = this.services.workspace.AstNodeDescriptionProvider;
-        const createAndSaveDescription = (node, name, fqn) => {
-            const desc = Object.assign(Descriptions.createDescription(node, name, document), {
-                id: fqn,
-                likec4ProjectId: projectId,
-            });
-            ElementOps.writeId(node, fqn);
-            byfqn.set(fqn, desc);
-            return desc;
-        };
-        const traverseNode = (el, parentFqn) => {
-            let thisFqn;
-            if (ast.isElement(el)) {
-                thisFqn = Fqn(el.name, parentFqn);
-                const desc = createAndSaveDescription(el, el.name, thisFqn);
-                if (!parentFqn) {
-                    root.push(desc);
-                }
-                else {
-                    children.set(parentFqn, desc);
-                }
-            }
-            else {
-                thisFqn = readStrictFqn(el.element);
-            }
-            let _nested = [];
-            if (isDefined(el.body) && !isEmpty(el.body.elements)) {
-                for (const child of el.body.elements) {
-                    if (!ast.isRelation(child) && !ast.isExtendRelation(child)) {
-                        try {
-                            _nested.push(...traverseNode(child, thisFqn));
-                        }
-                        catch (e) {
-                            logWarnError(e);
-                        }
-                    }
-                }
-            }
-            const directChildren = children.get(thisFqn) ?? [];
-            _nested = [
-                ...directChildren,
-                ..._nested,
-            ];
-            for (const child of _nested) {
-                descendants.set(thisFqn, child);
-            }
-            if (ast.isExtendElement(el)) {
-                for (const ancestor of ancestorsFqn(thisFqn)) {
-                    for (const child of _nested) {
-                        descendants.set(ancestor, child);
-                    }
-                }
-            }
-            return descendants.get(thisFqn) ?? [];
-        };
-        for (const node of rootElements) {
-            try {
-                if (ast.isRelation(node) || ast.isExtendRelation(node)) {
-                    continue;
-                }
-                traverseNode(node, null);
-            }
-            catch (e) {
-                logWarnError(e);
-            }
-        }
-        return new DocumentFqnIndex(root, children, descendants, byfqn, projectId);
-    }
-}
-function uniqueByName(multimap) {
-    return [...multimap.associations()]
-        .flatMap(([_name, descs]) => (descs.length === 1 ? descs : []))
-        .sort((a, b) => compareNatural(a.name, b.name));
-}
-export class DocumentFqnIndex {
-    _rootElements;
-    _children;
-    _descendants;
-    _byfqn;
-    projectId;
-    static EMPTY = new DocumentFqnIndex([], new MultiMap(), new MultiMap(), new MultiMap(), ProjectsManager.DefaultProjectId);
-    constructor(_rootElements, 
-    /**
-     * direct children of elements
-     */
-    _children, 
-    /**
-     * All descendants of an element (unique by name)
-     */
-    _descendants, 
-    /**
-     * All elements by FQN
-     */
-    _byfqn, projectId) {
-        this._rootElements = _rootElements;
-        this._children = _children;
-        this._descendants = _descendants;
-        this._byfqn = _byfqn;
-        this.projectId = projectId;
-    }
-    rootElements() {
-        return this._rootElements;
-    }
-    byFqn(fqn) {
-        return this._byfqn.get(fqn) ?? [];
-    }
-    children(parent) {
-        return this._children.get(parent) ?? [];
-    }
-    descendants(nodeName) {
-        return this._descendants.get(nodeName) ?? [];
-    }
-}

package/dist/model/index.d.ts

@@ -1,6 +0,0 @@
-export * from './deployments-index';
-export * from './fqn-index';
-export * from './model-builder';
-export * from './model-locator';
-export * from './model-parser';
-export * from './parser/ValueConverter';

package/dist/model/index.js

@@ -1,6 +0,0 @@
-export * from './deployments-index';
-export * from './fqn-index';
-export * from './model-builder';
-export * from './model-locator';
-export * from './model-parser';
-export * from './parser/ValueConverter';

package/dist/model/model-builder.d.ts

@@ -1,54 +0,0 @@
-import { type LayoutedView, type ProjectId, type UnknownComputed, type UnknownParsed, type ViewId } from '@likec4/core';
-import { LikeC4Model } from '@likec4/core/model';
-import type * as c4 from '@likec4/core/types';
-import { type URI, Disposable } from 'langium';
-import type { CancellationToken } from 'vscode-jsonrpc';
-import type { LikeC4Services } from '../module';
-import { ADisposable } from '../utils';
-type ModelParsedListener = (docs: URI[]) => void;
-type ManualLayouts = Record<ViewId, LayoutedView> | null;
-export interface LikeC4ModelBuilder extends Disposable {
-    parseModel(projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<LikeC4Model<UnknownParsed> | null>;
-    unsafeSyncComputeModel(projectId: ProjectId): LikeC4Model<UnknownComputed>;
-    computeModel(projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<LikeC4Model<UnknownComputed>>;
-    onModelParsed(callback: ModelParsedListener): Disposable;
-    clearCache(): void;
-}
-export declare class DefaultLikeC4ModelBuilder extends ADisposable implements LikeC4ModelBuilder {
-    private projects;
-    private parser;
-    private listeners;
-    private cache;
-    private DocumentBuilder;
-    private manualLayouts;
-    private mutex;
-    constructor(services: LikeC4Services);
-    /**
-     * WARNING:
-     * This method is internal and should to be called only when all documents are known to be parsed.
-     * Otherwise, the model may be incomplete.
-     *
-     * To avoid circular dependencies, we do not resolve imports here.
-     */
-    private unsafeSyncParseModelData;
-    /**
-     * To avoid circular dependencies, first we parse all documents and then we join them.
-     */
-    private unsafeSyncJoinedModelData;
-    parseModel(projectId?: c4.ProjectId | undefined, cancelToken?: CancellationToken): Promise<LikeC4Model<UnknownParsed>>;
-    private previousViews;
-    /**
-     * WARNING:
-     * This method is internal and should to be called only when all documents are known to be parsed.
-     * Otherwise, the model may be incomplete.
-     *
-     * @internal
-     */
-    unsafeSyncComputeModel(projectId: c4.ProjectId, manualLayouts?: ManualLayouts): LikeC4Model<UnknownComputed>;
-    computeModel(projectId?: c4.ProjectId | undefined, cancelToken?: CancellationToken): Promise<LikeC4Model<UnknownComputed>>;
-    onModelParsed(callback: ModelParsedListener): Disposable;
-    clearCache(): void;
-    private documents;
-    private notifyListeners;
-}
-export {};

package/dist/model/model-builder.js

@@ -1,233 +0,0 @@
-import { _stage, } from '@likec4/core';
-import { computeView } from '@likec4/core/compute-view';
-import { LikeC4Model } from '@likec4/core/model';
-import { loggable } from '@likec4/log';
-import { deepEqual as eq } from 'fast-equals';
-import { Disposable, DocumentState, interruptAndCheck, WorkspaceCache, } from 'langium';
-import { hasAtLeast, isEmpty, mapToObj, values, } from 'remeda';
-import { isLikeC4Builtin } from '../likec4lib';
-import { logger as mainLogger } from '../logger';
-import { ADisposable, performanceMark } from '../utils';
-import { assignNavigateTo } from '../view-utils';
-import { buildModelData } from './builder/buildModel';
-const parsedWithoutImportsCacheKey = (projectId) => `parsed-without-imports-${projectId}`;
-const parsedModelCacheKey = (projectId) => `parsed-model-${projectId}`;
-const computedModelCacheKey = (projectId) => `computed-model-${projectId}`;
-const builderLogger = mainLogger.getChild('model-builder');
-export class DefaultLikeC4ModelBuilder extends ADisposable {
-    projects;
-    parser;
-    listeners = [];
-    cache;
-    DocumentBuilder;
-    manualLayouts;
-    mutex;
-    constructor(services) {
-        super();
-        this.projects = services.shared.workspace.ProjectsManager;
-        this.parser = services.likec4.ModelParser;
-        this.cache = services.shared.workspace.Cache;
-        this.DocumentBuilder = services.shared.workspace.DocumentBuilder;
-        this.mutex = services.shared.workspace.WorkspaceLock;
-        this.manualLayouts = services.likec4.ManualLayouts;
-        this.onDispose(this.DocumentBuilder.onUpdate((_changed, deleted) => {
-            if (deleted.length > 0) {
-                this.notifyListeners(deleted);
-            }
-        }));
-        this.onDispose(this.DocumentBuilder.onBuildPhase(DocumentState.Validated, (docs, _cancelToken) => {
-            const validated = docs.flatMap(d => isLikeC4Builtin(d.uri) || this.projects.isExcluded(d) ? [] : d.uri);
-            if (validated.length > 0) {
-                this.notifyListeners(validated);
-            }
-        }));
-        builderLogger.debug `created`;
-    }
-    /**
-     * WARNING:
-     * This method is internal and should to be called only when all documents are known to be parsed.
-     * Otherwise, the model may be incomplete.
-     *
-     * To avoid circular dependencies, we do not resolve imports here.
-     */
-    unsafeSyncParseModelData(projectId) {
-        const cache = this.cache;
-        const key = parsedWithoutImportsCacheKey(projectId);
-        return cache.get(key, () => {
-            const logger = builderLogger.getChild(projectId);
-            try {
-                const project = this.projects.getProject(projectId);
-                const docs = this.documents(projectId);
-                if (docs.length === 0) {
-                    logger.debug `unsafeSyncParseModelData: skipped due to no documents`;
-                    return null;
-                }
-                logger.debug `unsafeSyncParseModelData: completed`;
-                return buildModelData(project, docs);
-            }
-            catch (err) {
-                builderLogger.warn(`unsafeSyncParseModelData failed for project ${projectId}`, { err });
-                return null;
-            }
-        });
-    }
-    /**
-     * To avoid circular dependencies, first we parse all documents and then we join them.
-     */
-    unsafeSyncJoinedModelData(projectId) {
-        const logger = builderLogger.getChild(projectId);
-        const result = this.unsafeSyncParseModelData(projectId);
-        if (!result) {
-            return null;
-        }
-        if (result.imports.size === 0) {
-            return result.data;
-        }
-        logger.debug `processing imports of ${projectId}`;
-        const imports = [...result.imports.associations()].reduce((acc, [projectId, fqns]) => {
-            if (fqns.size === 0) {
-                return acc;
-            }
-            const anotherProject = this.unsafeSyncParseModelData(projectId);
-            if (anotherProject) {
-                const imported = [...fqns].flatMap(fqn => anotherProject.data.elements[fqn] ?? []);
-                if (hasAtLeast(imported, 1)) {
-                    acc[projectId] = structuredClone(imported);
-                }
-            }
-            return acc;
-        }, {});
-        return {
-            ...result.data,
-            imports,
-        };
-    }
-    async parseModel(projectId, cancelToken) {
-        projectId = this.projects.ensureProjectId(projectId);
-        const logger = builderLogger.getChild(projectId);
-        const cache = this.cache;
-        const t0 = performanceMark();
-        return await this.mutex.read(async () => {
-            if (cancelToken?.isCancellationRequested) {
-                await interruptAndCheck(cancelToken);
-            }
-            const key = parsedModelCacheKey(projectId);
-            if (cache.has(key)) {
-                logger.debug `parseModel from cache`;
-            }
-            return cache.get(key, () => {
-                const parsedModel = this.unsafeSyncJoinedModelData(projectId);
-                if (!parsedModel) {
-                    logger.debug `parseModel: returning EMPTY`;
-                    return LikeC4Model.EMPTY.asParsed;
-                }
-                logger.debug `parseModel in ${t0.pretty}`;
-                return LikeC4Model.create(parsedModel);
-            });
-        });
-    }
-    previousViews = {};
-    /**
-     * WARNING:
-     * This method is internal and should to be called only when all documents are known to be parsed.
-     * Otherwise, the model may be incomplete.
-     *
-     * @internal
-     */
-    unsafeSyncComputeModel(projectId, manualLayouts) {
-        const cache = this.cache;
-        const hasManualLayouts = !!manualLayouts && !isEmpty(manualLayouts);
-        const key = computedModelCacheKey(projectId) + (hasManualLayouts ? '+manualLayouts' : '');
-        return cache.get(key, () => {
-            const logger = builderLogger.getChild(projectId);
-            const parsedModelData = this.unsafeSyncJoinedModelData(projectId);
-            if (!parsedModelData) {
-                logger.debug `unsafeSyncComputeModel: returning EMPTY`;
-                return LikeC4Model.EMPTY.asComputed;
-            }
-            const parsedModel = LikeC4Model.create(parsedModelData);
-            const allViews = [];
-            for (const view of values(parsedModelData.views)) {
-                const result = computeView(view, parsedModel);
-                if (!result.isSuccess) {
-                    logger.warn(loggable(result.error));
-                    continue;
-                }
-                if (manualLayouts?.[view.id]) {
-                    Object.assign(result.view, 
-                    // satisfies enforces that the object has the property
-                    { hasManualLayout: true });
-                }
-                allViews.push(result.view);
-            }
-            assignNavigateTo(allViews);
-            const views = mapToObj(allViews, v => {
-                const key = computedViewKey(projectId, v.id);
-                const previous = this.previousViews[key];
-                const view = previous && eq(v, previous) ? previous : v;
-                this.previousViews[key] = view;
-                return [v.id, view];
-            });
-            const data = {
-                ...parsedModelData,
-                [_stage]: 'computed',
-                views,
-            };
-            if (hasManualLayouts) {
-                data.manualLayouts = manualLayouts;
-            }
-            logger.debug(`unsafeSyncComputeModel${hasManualLayouts ? ' with manual layouts' : ''}: completed`);
-            return LikeC4Model.create(data);
-        });
-    }
-    async computeModel(projectId, cancelToken) {
-        projectId = this.projects.ensureProjectId(projectId);
-        const logger = builderLogger.getChild(projectId);
-        const t0 = performanceMark();
-        return await this.mutex.read(async () => {
-            if (cancelToken?.isCancellationRequested) {
-                await interruptAndCheck(cancelToken);
-            }
-            const project = this.projects.getProject(projectId);
-            const manualLayouts = await this.manualLayouts.read(project);
-            const result = this.unsafeSyncComputeModel(projectId, manualLayouts);
-            if (result === LikeC4Model.EMPTY) {
-                logger.debug(`computeModel returned EMPTY`);
-            }
-            else if (t0.ms > 10) {
-                logger.debug(`computeModel completed in ${t0.pretty}`);
-            }
-            return result;
-        });
-    }
-    onModelParsed(callback) {
-        this.listeners.push(callback);
-        return Disposable.create(() => {
-            const index = this.listeners.indexOf(callback);
-            if (index >= 0) {
-                this.listeners.splice(index, 1);
-            }
-        });
-    }
-    clearCache() {
-        builderLogger.debug(`clearCache`);
-        this.cache.clear();
-        this.previousViews = {};
-    }
-    documents(projectId) {
-        return this.parser.documents(projectId).toArray();
-    }
-    notifyListeners(docs) {
-        for (const listener of this.listeners) {
-            try {
-                listener(docs);
-            }
-            catch (e) {
-                builderLogger.warn(loggable(e));
-            }
-        }
-    }
-}
-function computedViewKey(projectId, viewId) {
-    return `computed-view-${projectId}-${viewId}`;
-}

package/dist/model/model-locator.d.ts

@@ -1,39 +0,0 @@
-import type * as c4 from '@likec4/core';
-import type { Cancellation } from 'langium';
-import type { Location, Range } from 'vscode-languageserver-types';
-import { URI } from 'vscode-uri';
-import type { ParsedAstElement, ParsedAstView, ParsedLikeC4LangiumDocument } from '../ast';
-import { ast } from '../ast';
-import type { LikeC4Services } from '../module';
-export type ViewLocateResult = {
-    doc: ParsedLikeC4LangiumDocument;
-    view: ParsedAstView;
-    viewAst: ast.LikeC4View;
-};
-export declare class LikeC4ModelLocator {
-    private services;
-    private fqnIndex;
-    private deploymentsIndex;
-    private langiumDocuments;
-    private parser;
-    private projects;
-    constructor(services: LikeC4Services);
-    private documents;
-    getParsedElement(...args: [ast.Element] | [c4.Fqn] | [c4.Fqn, c4.ProjectId]): ParsedAstElement | null;
-    locateElement(fqn: c4.Fqn, projectId?: c4.ProjectId | undefined): Location | null;
-    locateDeploymentElement(deploymentFqn: c4.DeploymentFqn, projectId?: c4.ProjectId | undefined): Location | null;
-    locateRelation(relationId: c4.RelationId, projectId?: c4.ProjectId): Location | null;
-    locateViewAst(viewId: c4.ViewId, projectId?: c4.ProjectId | undefined): null | ViewLocateResult;
-    locateView(viewId: c4.ViewId, projectId?: c4.ProjectId): Location | null;
-    locateDocumentTags(documentUri: URI, cancelToken?: Cancellation.CancellationToken): Promise<Array<{
-        name: string;
-        color: string;
-        range: Range;
-        isSpecification: boolean;
-    }>>;
-    locateDynamicViewStep(params: {
-        view: c4.ViewId;
-        astPath: string;
-        projectId?: c4.ProjectId | undefined;
-    }): Location | null;
-}