@likec4/language-server 1.47.0 → 1.48.0

package/dist/LikeC4LanguageServices.js

@@ -1,164 +0,0 @@
-import { nonexhaustive, } from '@likec4/core';
-import { computeProjectsView } from '@likec4/core/compute-view';
-import { LikeC4Model } from '@likec4/core/model';
-import { loggable } from '@likec4/log';
-import { URI } from 'langium';
-import { entries, hasAtLeast, indexBy, map, pipe, prop } from 'remeda';
-import { DiagnosticSeverity } from 'vscode-languageserver-types';
-import { logger as mainLogger } from './logger';
-import { ProjectsManager } from './workspace';
-const logger = mainLogger.getChild('LanguageServices');
-/**
- * Public Language Services
- */
-export class DefaultLikeC4LanguageServices {
-    services;
-    builder;
-    editor;
-    projectsManager;
-    constructor(services) {
-        this.services = services;
-        this.builder = services.likec4.ModelBuilder;
-        this.projectsManager = services.shared.workspace.ProjectsManager;
-        this.editor = services.likec4.ModelChanges;
-    }
-    get views() {
-        return this.services.likec4.Views;
-    }
-    get workspaceUri() {
-        return this.services.shared.workspace.WorkspaceManager.workspaceUri;
-    }
-    projects() {
-        const projectsManager = this.services.shared.workspace.ProjectsManager;
-        const projectsWithDocs = pipe(this.services.shared.workspace.LangiumDocuments.groupedByProject(), entries(), map(([projectId, docs]) => {
-            const id = projectId;
-            const { folderUri, config } = projectsManager.getProject(id);
-            return {
-                id,
-                folder: folderUri,
-                title: config.title ?? config.name,
-                documents: map(docs, prop('uri')),
-                config,
-            };
-        }));
-        // if there are multiple projects and default project is set, ensure it is first
-        if (hasAtLeast(projectsWithDocs, 2) && projectsManager.defaultProjectId) {
-            const idx = projectsWithDocs.findIndex(p => p.id === projectsManager.defaultProjectId);
-            if (idx > 0) {
-                const [defaultProject] = projectsWithDocs.splice(idx, 1);
-                return [defaultProject, ...projectsWithDocs];
-            }
-            return projectsWithDocs;
-        }
-        if (hasAtLeast(projectsWithDocs, 1)) {
-            return projectsWithDocs;
-        }
-        const { folderUri, config } = projectsManager.getProject(ProjectsManager.DefaultProjectId);
-        const documents = map(this.services.shared.workspace.LangiumDocuments.projectDocuments(ProjectsManager.DefaultProjectId).toArray(), prop('uri'));
-        return [{
-                id: ProjectsManager.DefaultProjectId,
-                folder: folderUri,
-                title: config.title ?? config.name,
-                documents,
-                config,
-            }];
-    }
-    project(projectId) {
-        projectId = this.projectsManager.ensureProjectId(projectId);
-        const projectsManager = this.services.shared.workspace.ProjectsManager;
-        const { folderUri, config } = projectsManager.getProject(projectId);
-        const documents = map(this.services.shared.workspace.LangiumDocuments.projectDocuments(projectId).toArray(), prop('uri'));
-        return {
-            id: projectId,
-            folder: folderUri,
-            title: config.title ?? config.name,
-            documents,
-            config,
-        };
-    }
-    async diagrams(project, cancelToken) {
-        const projectId = this.projectsManager.ensureProjectId(project);
-        return await this.views.diagrams(projectId, cancelToken);
-    }
-    async computedModel(project, cancelToken) {
-        const projectId = this.projectsManager.ensureProjectId(project);
-        return await this.builder.computeModel(projectId, cancelToken);
-    }
-    async layoutedModel(project, cancelToken) {
-        const projectId = this.projectsManager.ensureProjectId(project);
-        const model = await this.builder.computeModel(projectId, cancelToken);
-        if (!model) {
-            throw new Error('Failed to compute model, empty project?');
-        }
-        const layouted = await this.views.layoutAllViews(projectId, cancelToken);
-        return LikeC4Model.create({
-            ...model.$data,
-            _stage: 'layouted',
-            views: pipe(layouted, map(prop('diagram')), indexBy(prop('id'))),
-        });
-    }
-    async projectsOverview(cancelToken) {
-        const allProjects = this.services.shared.workspace.ProjectsManager.all;
-        const models = [];
-        for (const project of allProjects) {
-            const model = await this.builder.computeModel(project, cancelToken);
-            if (cancelToken?.isCancellationRequested) {
-                throw new Error('Operation cancelled');
-            }
-            if (model === LikeC4Model.EMPTY) {
-                logger.debug(`Project ${project} is empty, skipping`);
-                continue;
-            }
-            models.push(model);
-        }
-        if (!hasAtLeast(models, 1)) {
-            throw new Error('No models found');
-        }
-        const projectsView = computeProjectsView(models);
-        return await this.views.layouter.layoutProjectsView(projectsView);
-    }
-    getErrors() {
-        const docs = this.services.shared.workspace.LangiumDocuments.allExcludingBuiltin.toArray();
-        return docs.flatMap(doc => {
-            return (doc.diagnostics ?? [])
-                .filter(d => d.severity === DiagnosticSeverity.Error)
-                .map(({ message, range }) => ({
-                message,
-                line: range.start.line,
-                range,
-                sourceFsPath: doc.uri.fsPath,
-            }));
-        });
-    }
-    locate(params) {
-        switch (true) {
-            case 'element' in params:
-                return this.services.likec4.ModelLocator.locateElement(params.element, params.projectId);
-            case 'relation' in params:
-                return this.services.likec4.ModelLocator.locateRelation(params.relation, params.projectId);
-            case 'view' in params:
-                return this.services.likec4.ModelLocator.locateView(params.view, params.projectId);
-            case 'deployment' in params:
-                return this.services.likec4.ModelLocator.locateDeploymentElement(params.deployment, params.projectId);
-            default:
-                nonexhaustive(params);
-        }
-    }
-    async dispose() {
-        try {
-            logger.debug('disposing LikeC4LanguageServices');
-            await this.services.shared.workspace.FileSystemWatcher.dispose();
-            if (this.services.mcp.Server.isStarted) {
-                await this.services.mcp.Server.stop();
-            }
-            this.services.Rpc.dispose();
-            this.services.likec4.ModelBuilder.dispose();
-        }
-        catch (e) {
-            logger.error(loggable(e));
-        }
-        finally {
-            logger.debug('LikeC4LanguageServices disposed');
-        }
-    }
-}

package/dist/Rpc.d.ts

@@ -1,9 +0,0 @@
-import type { LikeC4Services } from './module';
-import { DidRequestOpenViewNotification } from './protocol';
-import { ADisposable } from './utils';
-export declare class Rpc extends ADisposable {
-    private services;
-    constructor(services: LikeC4Services);
-    init(): void;
-    openView(params: DidRequestOpenViewNotification.Params): Promise<void>;
-}

package/dist/Rpc.js

@@ -1,276 +0,0 @@
-import { filter, funnel, indexBy, keys, map, mapValues, pipe, sort } from 'remeda';
-import { logger as rootLogger } from './logger';
-import { invariant, nonexhaustive, } from '@likec4/core';
-import { LikeC4Model } from '@likec4/core/model';
-import { Disposable, interruptAndCheck, URI, UriUtils } from 'langium';
-import { DiagnosticSeverity } from 'vscode-languageserver-protocol';
-import { BuildDocuments, ChangeView, DidChangeModelNotification, DidChangeSnapshotNotification, DidRequestOpenViewNotification, FetchComputedModel, FetchLayoutedModel, FetchProjects, FetchTelemetryMetrics, FetchViewsFromAllProjects, GetDocumentTags, LayoutView, Locate, RegisterProject, ReloadProjects, ValidateLayout, } from './protocol';
-import { ADisposable } from './utils';
-const logger = rootLogger.getChild('rpc');
-export class Rpc extends ADisposable {
-    services;
-    constructor(services) {
-        super();
-        this.services = services;
-    }
-    init() {
-        const connection = this.services.shared.lsp.Connection;
-        if (!connection) {
-            logger.info(`no connection, skip init ServerRpc`);
-            return;
-        }
-        logger.info(`init ServerRpc`);
-        const likec4Services = this.services.likec4;
-        const projects = this.services.shared.workspace.ProjectsManager;
-        const LangiumDocuments = this.services.shared.workspace.LangiumDocuments;
-        const DocumentBuilder = this.services.shared.workspace.DocumentBuilder;
-        const notifyModelParsed = funnel((batch) => {
-            if (batch > 1) {
-                logger.debug `send ${'onDidChangeModel'} (${batch} batched)`;
-            }
-            else {
-                logger.debug `send ${'onDidChangeModel'}`;
-            }
-            connection.sendNotification(DidChangeModelNotification.type, '').catch(error => {
-                logger.warn(`[ServerRpc] error sending onDidChangeModel:`, { error });
-                return;
-            });
-        }, {
-            reducer: (accumulator, req) => (accumulator ?? 0) + req,
-            triggerAt: 'end',
-            minQuietPeriodMs: 200,
-            maxBurstDurationMs: 400,
-        });
-        let isFirstBuild = true;
-        this.onDispose(likec4Services.ModelBuilder.onModelParsed(() => notifyModelParsed.call(1)), connection.onRequest(FetchComputedModel.req, async ({ projectId, cleanCaches }, cancelToken) => {
-            logger.debug `received request ${'fetchComputedModel'} for project ${projectId} (cleanCaches: ${cleanCaches})`;
-            if (cleanCaches) {
-                const docs = projectId
-                    ? LangiumDocuments.projectDocuments(projectId)
-                    : LangiumDocuments.allExcludingBuiltin;
-                const uris = docs.toArray().map(d => d.uri);
-                await DocumentBuilder.update(uris, [], cancelToken);
-            }
-            const likec4model = await likec4Services.ModelBuilder.computeModel(projectId, cancelToken);
-            if (likec4model !== LikeC4Model.EMPTY) {
-                return { model: likec4model.$data };
-            }
-            return { model: null };
-        }), connection.onNotification(DidChangeSnapshotNotification.type, async ({ snapshotUri }) => {
-            logger.debug `received notification ${'onDidChangeSnapshot'} for snapshot ${snapshotUri}`;
-            const uri = URI.parse(snapshotUri);
-            await projects.rebuidProject(projects.belongsTo(uri.path));
-        }), connection.onRequest(FetchLayoutedModel.req, async ({ projectId }, cancelToken) => {
-            logger.debug `received request ${'fetchLayoutedModel'} for project ${projectId}`;
-            const model = await likec4Services.LanguageServices.layoutedModel(projectId);
-            if (model === null) {
-                return { model: null };
-            }
-            const diagrams = await likec4Services.Views.diagrams(projectId, cancelToken);
-            return {
-                model: {
-                    ...model.$data,
-                    _stage: 'layouted',
-                    views: indexBy(diagrams, d => d.id),
-                },
-            };
-        }), connection.onRequest(LayoutView.req, async ({ viewId, projectId, layoutType, }, cancelToken) => {
-            logger
-                .debug `received request ${'layoutView'} for ${viewId} from project ${projectId} (layout type: ${layoutType ?? 'not set'})`;
-            const result = await likec4Services.Views.layoutView({
-                viewId,
-                projectId: projectId,
-                layoutType,
-                cancelToken,
-            });
-            return { result };
-        }), connection.onRequest(ValidateLayout.req, async ({ projectId }, cancelToken) => {
-            logger.debug `received request ${'validateLayout'} for project ${projectId}`;
-            const layouts = await likec4Services.Views.layoutAllViews(projectId, cancelToken);
-            const result = reportLayoutDrift(layouts.map(l => l.diagram));
-            return { result };
-        }), connection.onRequest(FetchProjects.req, async () => {
-            logger.debug `received request ${'FetchProjects'}`;
-            const docsByProject = LangiumDocuments.groupedByProject();
-            return {
-                projects: mapValues(docsByProject, (docs, projectId) => {
-                    const { folderUri, config: { name, title, }, } = projects.getProject(projectId);
-                    return {
-                        folder: folderUri.toString(),
-                        config: {
-                            name,
-                            title,
-                        },
-                        docs: map(docs, d => d.uri.toString()),
-                    };
-                }),
-            };
-        }), connection.onRequest(ReloadProjects.req, async (cancelToken) => {
-            logger.debug `received request ${'ReloadProjects'}`;
-            likec4Services.ManualLayouts.clearCaches();
-            await projects.reloadProjects(cancelToken);
-            return;
-        }), connection.onRequest(RegisterProject.req, async (params, cancelToken) => {
-            logger.debug `received request ${'RegisterProject'}`;
-            let project;
-            if ('configUri' in params) {
-                project = await projects.registerConfigFile(URI.parse(params.configUri), cancelToken);
-            }
-            else {
-                project = await projects.registerProject(params, cancelToken);
-            }
-            return { id: project.id };
-        }), connection.onRequest(FetchViewsFromAllProjects.req, async (cancelToken) => {
-            logger.debug `received request ${'FetchViewsFromAllProjects'}`;
-            const views = [];
-            for (const projectId of projects.all) {
-                await interruptAndCheck(cancelToken);
-                try {
-                    const computedViews = await likec4Services.Views.computedViews(projectId, cancelToken);
-                    views.push(...pipe(computedViews, map(v => ({
-                        id: v.id,
-                        title: v.title ?? v.id,
-                        projectId,
-                    })), sort((a, b) => {
-                        if (a.id === 'index') {
-                            return -1;
-                        }
-                        if (b.id === 'index') {
-                            return 1;
-                        }
-                        return a.title.localeCompare(b.title);
-                    })));
-                }
-                catch (error) {
-                    logger.warn(`Failed to fetch views for project ${projectId}:`, { error });
-                }
-            }
-            return { views };
-        }), connection.onRequest(BuildDocuments.req, async ({ docs }, cancelToken) => {
-            const changed = docs.map(d => URI.parse(d));
-            const notChanged = (uri) => changed.every(c => !UriUtils.equals(c, uri));
-            const deleted = LangiumDocuments.allExcludingBuiltin
-                .toArray()
-                .filter(d => notChanged(d.uri))
-                .map(d => d.uri);
-            logger.debug(`[ServerRpc] received request to build:
-  changed (total ${changed.length}):${docs.map(d => '\n    - ' + d).join('')}
-  deleted (total ${deleted.length}):${deleted.map(d => '\n    - ' + d.toString()).join('\n')}`);
-            if (!isFirstBuild && (changed.length + deleted.length) > 0) {
-                await Promise.allSettled([...changed, ...deleted].map(async (d) => {
-                    const uri = d.toString();
-                    logger.debug(`clear diagnostics for ${uri}`);
-                    try {
-                        await connection.sendDiagnostics({
-                            uri,
-                            diagnostics: [],
-                        });
-                    }
-                    catch (e) {
-                        // Ignore
-                        logger.warn(`error clearing diagnostics for ${uri}: ${e}`);
-                    }
-                }));
-            }
-            isFirstBuild = false;
-            await interruptAndCheck(cancelToken);
-            await DocumentBuilder.update(changed, deleted, cancelToken);
-        }), connection.onRequest(Locate.req, params => {
-            logger.debug `received request ${'locate'}, ${params}`;
-            switch (true) {
-                case 'element' in params:
-                    return likec4Services.ModelLocator.locateElement(params.element, params.projectId);
-                case 'relation' in params:
-                    return likec4Services.ModelLocator.locateRelation(params.relation, params.projectId);
-                case 'astPath' in params:
-                    return likec4Services.ModelLocator.locateDynamicViewStep({
-                        view: params.view,
-                        astPath: params.astPath,
-                        projectId: params.projectId,
-                    });
-                case 'view' in params:
-                    return likec4Services.ModelLocator.locateView(params.view, params.projectId);
-                case 'deployment' in params:
-                    return likec4Services.ModelLocator.locateDeploymentElement(params.deployment, params.projectId);
-                default:
-                    nonexhaustive(params);
-            }
-        }), connection.onRequest(ChangeView.req, async (request, cancelToken) => {
-            logger.debug `received request ${'changeView'} of ${request.viewId} from project ${request.projectId}`;
-            const loc = await likec4Services.ModelChanges.applyChange(request);
-            const op = request.change.op;
-            if (request.projectId &&
-                (op === 'save-view-snapshot' || op === 'reset-manual-layout')) {
-                await projects.rebuidProject(request.projectId, cancelToken);
-            }
-            return loc;
-        }), connection.onRequest(FetchTelemetryMetrics.req, async (cancelToken) => {
-            let metrics = null;
-            for (const projectId of projects.all) {
-                try {
-                    const model = await likec4Services.ModelBuilder.computeModel(projectId, cancelToken);
-                    if (model === LikeC4Model.EMPTY) {
-                        continue;
-                    }
-                    metrics ??= {
-                        elementKinds: 0,
-                        deploymentKinds: 0,
-                        relationshipKinds: 0,
-                        tags: 0,
-                        customColors: 0,
-                        elements: 0,
-                        deploymentNodes: 0,
-                        relationships: 0,
-                        views: 0,
-                        projects: 0,
-                    };
-                    metrics.elementKinds += keys(model.specification.elements).length;
-                    metrics.deploymentKinds += keys(model.specification.deployments).length;
-                    metrics.relationshipKinds += keys(model.specification.relationships).length;
-                    metrics.tags += keys(model.specification.tags).length;
-                    metrics.customColors += keys(model.specification.customColors ?? {}).length;
-                    metrics.elements += keys(model.$data.elements).length;
-                    metrics.deploymentNodes += [...model.deployment.nodes()].length;
-                    metrics.relationships += keys(model.$data.relations).length;
-                    metrics.views += keys(model.$data.views).length;
-                    metrics.projects += 1;
-                }
-                catch (err) {
-                    logger.warn(`Error fetching telemetry metrics for project ${projectId}`, { err });
-                }
-            }
-            await interruptAndCheck(cancelToken);
-            return {
-                metrics,
-            };
-        }), connection.onRequest(GetDocumentTags.req, async ({ documentUri }, cancelToken) => {
-            const tags = await likec4Services.ModelLocator.locateDocumentTags(URI.parse(documentUri), cancelToken);
-            return {
-                tags,
-            };
-        }), Disposable.create(() => {
-            notifyModelParsed.cancel();
-        }));
-        function reportLayoutDrift(diagrams) {
-            return pipe(diagrams, filter(d => !!d.hasLayoutDrift), map(d => {
-                const loc = likec4Services.ModelLocator.locateView(d.id);
-                invariant(loc, `View ${d.id} not found`);
-                return {
-                    uri: loc.uri,
-                    viewId: d.id,
-                    severity: DiagnosticSeverity.Warning,
-                    message: `Layout drift detected for view '${d.id}'`,
-                    range: loc.range,
-                };
-            }));
-        }
-    }
-    async openView(params) {
-        const lspConnection = this.services.shared.lsp.Connection;
-        if (!lspConnection) {
-            logger.warn('No LSP connection');
-            return;
-        }
-        await lspConnection.sendNotification(DidRequestOpenViewNotification.type, params);
-    }
-}

package/dist/ast.d.ts

@@ -1,226 +0,0 @@
-import type * as c4 from '@likec4/core';
-import { MultiMap } from '@likec4/core/utils';
-import type { AstNode, AstNodeDescription, DiagnosticInfo, LangiumDocument } from 'langium';
-import type { ConditionalPick, MergeExclusive, Simplify, ValueOf, Writable } from 'type-fest';
-import type { Diagnostic } from 'vscode-languageserver-types';
-import type { LikeC4Grammar } from './generated/ast';
-import * as ast from './generated/ast';
-import type { IsValidFn } from './validation';
-export { ast };
-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;
-    }
-}
-export type ParsedElementStyle = {
-    shape?: c4.ElementShape;
-    icon?: c4.IconUrl;
-    color?: c4.Color;
-    border?: c4.BorderStyle;
-    opacity?: number;
-    multiple?: boolean;
-    size?: c4.ShapeSize;
-    padding?: c4.SpacingSize;
-    textSize?: c4.TextSize;
-};
-export 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>;
-}
-export 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[];
-    };
-}
-export interface ParsedAstExtend {
-    id: c4.Fqn;
-    astPath: string;
-    tags?: c4.NonEmptyArray<c4.Tag> | null;
-    links?: c4.NonEmptyArray<c4.Link> | null;
-    metadata?: {
-        [key: string]: string | string[];
-    };
-}
-export interface ParsedAstExtendRelation {
-    id: c4.RelationId;
-    astPath: string;
-    tags?: c4.NonEmptyArray<c4.Tag> | null;
-    links?: c4.NonEmptyArray<c4.Link> | null;
-    metadata?: {
-        [key: string]: string | string[];
-    };
-}
-export 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[];
-    };
-}
-export type ParsedAstDeployment = Simplify<MergeExclusive<ParsedAstDeployment.Node, ParsedAstDeployment.Instance>>;
-export declare namespace ParsedAstDeployment {
-    type Node = c4.DeploymentNode;
-    type Instance = Omit<c4.DeployedInstance, 'element'> & {
-        readonly element: c4.FqnRef.ModelRef;
-    };
-}
-export type ParsedAstDeploymentRelation = c4.DeploymentRelationship & {
-    astPath: string;
-};
-export type ParsedAstGlobals = Writable<c4.ModelGlobals>;
-export interface ParsedAstElementView {
-    [c4._type]: 'element';
-    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;
-}
-export interface ParsedAstDynamicView {
-    [c4._type]: 'dynamic';
-    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;
-}
-export interface ParsedAstDeploymentView {
-    [c4._type]: 'deployment';
-    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;
-}
-export type ParsedAstView = ParsedAstElementView | ParsedAstDynamicView | ParsedAstDeploymentView;
-export declare const ViewOps: {
-    writeId<T extends ast.LikeC4View>(node: T, id: c4.ViewId): T;
-    readId(node: ast.LikeC4View): c4.ViewId | undefined;
-};
-export declare const ElementOps: {
-    writeId(node: ast.Element | ast.DeploymentElement, id: c4.Fqn | null): ast.Element | ast.DeploymentElement;
-    readId(node: ast.Element | ast.DeploymentElement): c4.Fqn<string> | undefined;
-};
-export interface AstNodeDescriptionWithFqn extends AstNodeDescription {
-    likec4ProjectId: c4.ProjectId;
-    id: c4.Fqn;
-}
-export type LikeC4AstNode = ValueOf<ConditionalPick<ast.LikeC4AstType, AstNode>>;
-type LikeC4DocumentDiagnostic = Diagnostic & DiagnosticInfo<LikeC4AstNode>;
-export 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'>;
-export interface LikeC4LangiumDocument extends LikeC4GrammarDocument, LikeC4DocumentProps {
-    likec4ProjectId: c4.ProjectId;
-}
-export interface ParsedLikeC4LangiumDocument extends LikeC4GrammarDocument, Required<LikeC4DocumentProps> {
-    likec4ProjectId: c4.ProjectId;
-}
-export declare function isLikeC4LangiumDocument(doc: LangiumDocument): doc is LikeC4LangiumDocument;
-export declare function isParsedLikeC4LangiumDocument(doc: LangiumDocument): doc is ParsedLikeC4LangiumDocument;
-export declare function parseMarkdownAsString(node?: ast.MarkdownOrString): string | undefined;
-export declare function parseAstPercent(value: string): number;
-export declare function parseAstOpacityProperty({ value }: ast.OpacityProperty): number;
-export declare function parseAstSizeValue({ value }: {
-    value: ast.SizeValue;
-}): 'xs' | 'sm' | 'md' | 'lg' | 'xl';
-export declare function toRelationshipStyle(props: ast.RelationshipStyleProperty[] | undefined, isValid: IsValidFn): {
-    color?: c4.Color;
-    line?: c4.RelationshipLineType;
-    head?: c4.RelationshipArrowType;
-    tail?: c4.RelationshipArrowType;
-};
-export declare function toColor(astNode: ast.ColorProperty): c4.Color | undefined;
-export declare function toAutoLayout(rule: ast.ViewRuleAutoLayout): c4.ViewRuleAutoLayout;
-export declare function toAstViewLayoutDirection(c4: c4.ViewRuleAutoLayout['direction']): ast.ViewLayoutDirection;
-export declare function getViewRulePredicateContainer<T extends AstNode>(el: T): ast.ViewRulePredicate | ast.DeploymentViewRulePredicate | ast.DynamicViewIncludePredicate | undefined;
-export declare function isFqnRefInsideGlobals(astNode: AstNode): boolean;
-export declare function isFqnRefInsideModel(astNode: AstNode): boolean;
-export declare function isFqnRefInsideDeployment(astNode: AstNode): boolean;