@likec4/language-server 1.47.0 → 1.49.0

package/dist/model/model-parser.js

@@ -1,133 +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 { DefaultWeakMap, invariant, MultiMap } from '@likec4/core/utils';
-import { DocumentState, UriUtils } from 'langium';
-import { pipe } from 'remeda';
-import { DiagnosticSeverity } from 'vscode-languageserver-types';
-import { isLikeC4LangiumDocument } from '../ast';
-import { logger as rootLogger, logWarnError } from '../logger';
-import { BaseParser } from './parser/Base';
-import { DeploymentModelParser } from './parser/DeploymentModelParser';
-import { DeploymentViewParser } from './parser/DeploymentViewParser';
-import { ExpressionV2Parser } from './parser/FqnRefParser';
-import { GlobalsParser } from './parser/GlobalsParser';
-import { ImportsParser } from './parser/ImportsParser';
-import { ModelParser } from './parser/ModelParser';
-import { PredicatesParser } from './parser/PredicatesParser';
-import { SpecificationParser } from './parser/SpecificationParser';
-import { ViewsParser } from './parser/ViewsParser';
-const DocumentParserFromMixins = pipe(BaseParser, ExpressionV2Parser, ImportsParser, ModelParser, DeploymentModelParser, DeploymentViewParser, PredicatesParser, SpecificationParser, ViewsParser, GlobalsParser);
-export class DocumentParser extends DocumentParserFromMixins {
-}
-const logger = rootLogger.getChild('ModelParser');
-export class LikeC4ModelParser {
-    services;
-    cachedParsers = new DefaultWeakMap((doc) => this.createParser(doc));
-    constructor(services) {
-        this.services = services;
-        services.shared.workspace.DocumentBuilder.onDocumentPhase(DocumentState.Linked, async (doc) => {
-            if (this.cachedParsers.has(doc)) {
-                logger.trace('Linked: clear cached parser {projectId} document {doc}', {
-                    projectId: doc.likec4ProjectId,
-                    doc: UriUtils.basename(doc.uri),
-                });
-                this.cachedParsers.delete(doc);
-            }
-        });
-        services.shared.workspace.DocumentBuilder.onBuildPhase(DocumentState.Linked, async (docs) => {
-            for (const doc of docs) {
-                if (services.shared.workspace.ProjectsManager.isExcluded(doc)) {
-                    continue;
-                }
-                try {
-                    // Force create parser for linked document (if not yet created)
-                    this.parse(doc);
-                }
-                catch (error) {
-                    logWarnError(error);
-                }
-            }
-        });
-        // We need to clean up cached parser when document is validated and has errors
-        // Because after that parser takes into account validation results
-        services.shared.workspace.DocumentBuilder.onDocumentPhase(DocumentState.Validated, async (doc) => {
-            if (doc.diagnostics?.some(d => d.severity === DiagnosticSeverity.Error) && this.cachedParsers.has(doc)) {
-                logger.trace('Validated: clear cached parser {projectId} document {doc} because of errors', {
-                    projectId: doc.likec4ProjectId,
-                    doc: UriUtils.basename(doc.uri),
-                });
-                this.cachedParsers.delete(doc);
-            }
-        });
-    }
-    documents(projectId) {
-        return this.services.shared.workspace.LangiumDocuments.projectDocuments(projectId).map(d => this.parse(d));
-    }
-    parse(doc) {
-        const parser = this.forDocument(doc);
-        return parser.doc;
-    }
-    forDocument(doc) {
-        return this.cachedParsers.get(doc);
-    }
-    createParser(doc) {
-        invariant(isLikeC4LangiumDocument(doc), `Document ${doc.uri.toString()} is not a LikeC4 document`);
-        const docbasename = UriUtils.basename(doc.uri);
-        if (doc.likec4ProjectId) {
-            logger.trace(`create parser {projectId} document {doc}`, {
-                projectId: doc.likec4ProjectId,
-                doc: docbasename,
-            });
-        }
-        else {
-            logger.warn(`create parser for document without project {doc}`, { doc: doc.uri.fsPath });
-        }
-        if (doc.state < DocumentState.Linked) {
-            logger.warn(`Document {doc} is not linked, state is {state}`, {
-                doc: docbasename,
-                state: doc.state,
-            });
-        }
-        const props = {
-            c4Specification: {
-                tags: {},
-                elements: {},
-                relationships: {},
-                colors: {},
-                deployments: {},
-            },
-            c4Elements: [],
-            c4ExtendElements: [],
-            c4ExtendDeployments: [],
-            c4ExtendRelations: [],
-            c4Relations: [],
-            c4Deployments: [],
-            c4DeploymentRelations: [],
-            c4Globals: {
-                predicates: {},
-                dynamicPredicates: {},
-                styles: {},
-            },
-            c4Views: [],
-            c4Imports: new MultiMap(Set),
-        };
-        doc = Object.assign(doc, props);
-        const parser = new DocumentParser(this.services, doc);
-        try {
-            parser.parseSpecification();
-            parser.parseImports();
-            parser.parseModel();
-            parser.parseGlobals();
-            parser.parseDeployment();
-            parser.parseViews();
-        }
-        catch (error) {
-            throw new Error(`Error parsing document ${doc.uri.fsPath}`, { cause: error });
-        }
-        return parser;
-    }
-}

package/dist/model/parser/Base.d.ts

@@ -1,69 +0,0 @@
-import type * as c4 from '@likec4/core';
-import { type MarkdownOrString } from '@likec4/core';
-import type { AstNode } from 'langium';
-import { type ParsedElementStyle, type ParsedLikeC4LangiumDocument, ast } from '../../ast';
-import type { LikeC4Services } from '../../module';
-import { type IsValidFn } from '../../validation';
-import type { Project } from '../../workspace/ProjectsManager';
-export type GConstructor<T = {}> = new (...args: any[]) => T;
-export declare function toSingleLine(str: string): string;
-export declare function toSingleLine(str: string | undefined | null): string | undefined;
-export declare function toSingleLine(str: ast.MarkdownOrString): MarkdownOrString;
-export declare function toSingleLine(str: ast.MarkdownOrString | undefined | null): MarkdownOrString | undefined;
-export declare function toSingleLine(str: ast.MarkdownOrString | string): MarkdownOrString | string;
-export declare function toSingleLine(str: ast.MarkdownOrString | string | undefined | null): MarkdownOrString | string | undefined;
-export declare function removeIndent(str: string): string;
-export declare function removeIndent(str: string | undefined): string | undefined;
-export declare function removeIndent(str: ast.MarkdownOrString): MarkdownOrString;
-export declare function removeIndent(str: ast.MarkdownOrString | undefined): MarkdownOrString | undefined;
-export declare function removeIndent(str: ast.MarkdownOrString | string): MarkdownOrString | string;
-export type Base = GConstructor<BaseParser>;
-export declare class BaseParser {
-    readonly services: LikeC4Services;
-    readonly doc: ParsedLikeC4LangiumDocument;
-    isValid: IsValidFn;
-    constructor(services: LikeC4Services, doc: ParsedLikeC4LangiumDocument);
-    get project(): Project;
-    resolveFqn(node: ast.FqnReferenceable): c4.Fqn;
-    getAstNodePath(node: AstNode): string;
-    getMetadata(metadataAstNode: ast.MetadataProperty | undefined): {
-        [key: string]: string | string[];
-    } | undefined;
-    parseMarkdownOrString(markdownOrString: ast.MarkdownOrString | undefined): c4.MarkdownOrString | undefined;
-    convertTags<E extends {
-        tags?: ast.Tags;
-    }>(withTags?: E): c4.NonEmptyArray<c4.Tag<string>> | null;
-    parseTags<E extends {
-        tags?: ast.Tags;
-    }>(withTags?: E): c4.NonEmptyArray<c4.Tag> | null;
-    convertLinks(source?: ast.LinkProperty['$container']): c4.Link[] | undefined;
-    parseLinks(source?: ast.LinkProperty['$container']): c4.Link[] | undefined;
-    parseIconProperty(prop: ast.IconProperty | undefined): c4.IconUrl | undefined;
-    parseImageAlias(value: string): string | undefined;
-    parseColorLiteral(astNode: ast.ColorLiteral): c4.ColorLiteral | undefined;
-    parseElementStyle(elementProps: Array<ast.ElementProperty> | ast.ElementStyleProperty | undefined): ParsedElementStyle;
-    parseStyleProps(styleProps: Array<ast.StyleProperty> | undefined): ParsedElementStyle;
-    /**
-     * Parse base properties: title, description and technology
-     *
-     * @param props - body properties (inside '{...}')
-     * @param override - optional, inline properties (right on the node)
-     *                   have higher priority and override body properties
-     */
-    parseBaseProps(props: {
-        title?: ast.MarkdownOrString | undefined;
-        summary?: ast.MarkdownOrString | undefined;
-        description?: ast.MarkdownOrString | undefined;
-        technology?: ast.MarkdownOrString | undefined;
-    }, override?: {
-        title?: string | undefined;
-        summary?: string | undefined;
-        description?: string | undefined;
-        technology?: string | undefined;
-    }): {
-        title?: string;
-        summary?: c4.MarkdownOrString;
-        description?: c4.MarkdownOrString;
-        technology?: string;
-    };
-}

package/dist/model/parser/Base.js

@@ -1,382 +0,0 @@
-import { exact, GlobalFqn, isNonEmptyArray, memoizeProp, nonexhaustive, nonNullable, } from '@likec4/core';
-import { filter, flatMap, groupBy, isArray, isBoolean, isEmpty, isNumber, isString, isTruthy, mapValues, pipe, unique, } from 'remeda';
-import { dedent } from 'strip-indent';
-import { hasLeadingSlash, hasProtocol, isRelative, joinRelativeURL, joinURL } from 'ufo';
-import { ast, parseAstOpacityProperty, parseAstPercent, parseAstSizeValue, parseMarkdownAsString, toColor, } from '../../ast';
-import { serverLogger } from '../../logger';
-import { projectIdFrom } from '../../utils';
-import { readStrictFqn } from '../../utils/elementRef';
-import { checksFromDiagnostics } from '../../validation';
-const logger = serverLogger.getChild('BaseParser');
-export function toSingleLine(str) {
-    if (str === null || str === undefined) {
-        return undefined;
-    }
-    const without = removeIndent(str);
-    if (isString(without)) {
-        return without.split('\n').join(' ');
-    }
-    if ('md' in without) {
-        return {
-            md: without.md.split('\n').join('  '),
-        };
-    }
-    return {
-        txt: without.txt.split('\n').join(' '),
-    };
-}
-// export function removeIndent(str: ast.MarkdownOrString | string): MarkdownOrString | string
-export function removeIndent(str) {
-    if (str === null || str === undefined) {
-        return undefined;
-    }
-    switch (true) {
-        case isString(str):
-            return dedent(str).trim();
-        case ast.isMarkdownOrString(str) && isTruthy(str.markdown):
-            return {
-                md: dedent(str.markdown).trim(),
-            };
-        case ast.isMarkdownOrString(str) && isTruthy(str.text):
-            return {
-                txt: dedent(str.text).trim(),
-            };
-        default:
-            return undefined;
-    }
-}
-export class BaseParser {
-    services;
-    doc;
-    isValid;
-    constructor(services, doc) {
-        this.services = services;
-        this.doc = doc;
-        // do nothing
-        this.isValid = checksFromDiagnostics(doc).isValid;
-    }
-    get project() {
-        return memoizeProp(this, 'project', () => this.services.shared.workspace.ProjectsManager.getProject(this.doc));
-    }
-    resolveFqn(node) {
-        if (ast.isImported(node)) {
-            const project = projectIdFrom(node);
-            const fqn = this.resolveFqn(nonNullable(node.imported.ref, `FqnRef is empty of imported: ${node.$cstNode?.text}`));
-            this.doc.c4Imports.set(project, fqn);
-            return GlobalFqn(project, fqn);
-        }
-        if (ast.isExtendElement(node)) {
-            return readStrictFqn(node.element);
-        }
-        if (ast.isExtendDeployment(node)) {
-            return readStrictFqn(node.deploymentNode);
-        }
-        if (ast.isDeploymentElement(node)) {
-            return this.services.likec4.DeploymentsIndex.getFqn(node);
-        }
-        return this.services.likec4.FqnIndex.getFqn(node);
-    }
-    getAstNodePath(node) {
-        return this.services.workspace.AstNodeLocator.getAstNodePath(node);
-    }
-    getMetadata(metadataAstNode) {
-        if (!metadataAstNode || !this.isValid(metadataAstNode) || isEmpty(metadataAstNode.props)) {
-            return undefined;
-        }
-        // Helper function to extract string values from MetadataValue
-        const extractValues = (value) => {
-            if (ast.isMarkdownOrString(value)) {
-                const mdOrStr = removeIndent(value);
-                if (!mdOrStr)
-                    return [];
-                // Handle both string and MarkdownOrString types
-                if (typeof mdOrStr === 'string') {
-                    return isTruthy(mdOrStr) ? [mdOrStr] : [];
-                }
-                else {
-                    // MarkdownOrString object with txt or md property
-                    const strValue = mdOrStr.md || mdOrStr.txt;
-                    return isTruthy(strValue) ? [strValue] : [];
-                }
-            }
-            else if (ast.isMetadataArray(value)) {
-                return value.values
-                    .map(v => removeIndent(v))
-                    .map(v => {
-                    if (typeof v === 'string') {
-                        return v;
-                    }
-                    else {
-                        // MarkdownOrString object
-                        return v.md || v.txt;
-                    }
-                })
-                    .filter(isTruthy);
-            }
-            return [];
-        };
-        // Transform metadata attributes into key-value pairs
-        const keyValuePairs = pipe(metadataAstNode.props, flatMap(p => extractValues(p.value).map(v => [p.key, v])), filter(([_, value]) => isTruthy(value)));
-        if (isEmpty(keyValuePairs)) {
-            return undefined;
-        }
-        // Group by key to handle duplicate keys
-        const groupedData = pipe(keyValuePairs, groupBy(([key]) => key), mapValues(pairs => pairs.map(([_, value]) => value)));
-        // Convert to final format: single values as string, multiple values as string[]
-        const data = {};
-        for (const [key, values] of Object.entries(groupedData)) {
-            if (values && values.length > 0) {
-                data[key] = values.length === 1 ? values[0] : values;
-            }
-        }
-        return isEmpty(data) ? undefined : data;
-    }
-    parseMarkdownOrString(markdownOrString) {
-        if (ast.isMarkdownOrString(markdownOrString)) {
-            return removeIndent(markdownOrString);
-        }
-        return undefined;
-    }
-    convertTags(withTags) {
-        return this.parseTags(withTags);
-    }
-    parseTags(withTags) {
-        let iter = withTags?.tags;
-        if (!iter) {
-            return null;
-        }
-        let tags = [];
-        while (iter) {
-            try {
-                if (this.isValid(iter)) {
-                    const values = iter.values.map(t => t.tag.ref?.name).filter(isTruthy);
-                    if (values.length > 0) {
-                        tags.push(...values);
-                    }
-                }
-            }
-            catch {
-                // ignore
-            }
-            iter = iter.prev;
-        }
-        return isNonEmptyArray(tags) ? unique(tags) : null;
-    }
-    convertLinks(source) {
-        return this.parseLinks(source);
-    }
-    parseLinks(source) {
-        if (!source?.props || source.props.length === 0) {
-            return undefined;
-        }
-        return pipe(source.props, filter(ast.isLinkProperty), flatMap(p => {
-            if (!this.isValid(p)) {
-                return [];
-            }
-            const url = p.value;
-            if (isTruthy(url)) {
-                const title = isTruthy(p.title) ? toSingleLine(p.title) : undefined;
-                const relative = this.services.lsp.DocumentLinkProvider.relativeLink(this.doc, url);
-                return {
-                    url,
-                    ...(title && { title }),
-                    ...(relative && relative !== url && { relative }),
-                };
-            }
-            return [];
-        }));
-    }
-    parseIconProperty(prop) {
-        if (!prop || !this.isValid(prop)) {
-            return undefined;
-        }
-        const { libicon, value } = prop;
-        switch (true) {
-            case !!libicon: {
-                const name = libicon.ref?.name;
-                if (!name) {
-                    logger.warn(`Library icon ${libicon.$refText} is not a valid library icon`);
-                    return undefined;
-                }
-                return name;
-            }
-            case value && value === 'none': {
-                return value;
-            }
-            case value && hasProtocol(value): {
-                if (value.startsWith('file:')) {
-                    logger.warn(`Icon property '${value}' used the 'file' protocol which is not supported`);
-                    return undefined;
-                }
-                return value;
-            }
-            case value && value.startsWith('@'): {
-                return this.parseImageAlias(value);
-            }
-            case value && isRelative(value): {
-                return joinRelativeURL(this.doc.uri.toString(), '../', value);
-            }
-            case value && hasLeadingSlash(value): {
-                return joinURL(this.project.folderUri.toString(), value);
-            }
-            default: {
-                logger.warn(`Icon property '${value}' is not a valid URL, library icon, image alias or 'none'`);
-                return undefined;
-            }
-        }
-    }
-    parseImageAlias(value) {
-        // Extract the alias name (e.g., '@infra' from '@infra/backend.svg')
-        const slashIndex = value.indexOf('/');
-        const aliasName = slashIndex > 0 ? value.substring(0, slashIndex) : value;
-        const remainingPath = slashIndex > 0 ? value.substring(slashIndex + 1) : '';
-        // Get imageAliases from project config, or use default '@' -> './images' mapping
-        const imageAliases = { '@': './images', ...this.project.config.imageAliases };
-        // Look up the alias path
-        const aliasPath = imageAliases[aliasName];
-        if (!aliasPath) {
-            logger.warn(`Image alias "${aliasName}" not found in project configuration`);
-            return undefined;
-        }
-        // Combine the alias path with the remaining path
-        const fullPath = remainingPath ? joinURL(aliasPath, remainingPath) : aliasPath;
-        // Make it relative to the **project root**, not the current document.
-        return joinURL(this.project.folderUri.toString(), fullPath);
-    }
-    parseColorLiteral(astNode) {
-        if (!this.isValid(astNode)) {
-            return undefined;
-        }
-        if (ast.isHexColor(astNode)) {
-            return `#${astNode.hex}`;
-        }
-        if (ast.isRGBAColor(astNode)) {
-            let alpha = isNumber(astNode.alpha) ? astNode.alpha : undefined;
-            if (isString(astNode.alpha)) {
-                alpha = parseAstPercent(astNode.alpha) / 100;
-            }
-            if (alpha !== undefined) {
-                return `rgba(${astNode.red},${astNode.green},${astNode.blue},${alpha})`;
-            }
-            return `rgb(${astNode.red},${astNode.green},${astNode.blue})`;
-        }
-        nonexhaustive(astNode);
-    }
-    parseElementStyle(elementProps) {
-        if (!elementProps) {
-            return {};
-        }
-        if (isArray(elementProps)) {
-            const style = this.parseStyleProps(elementProps.find(ast.isElementStyleProperty)?.props);
-            // Property on element has higher priority than from style
-            try {
-                const iconProp = this.parseIconProperty(elementProps.find(ast.isIconProperty));
-                if (iconProp) {
-                    style.icon = iconProp;
-                }
-            }
-            catch (err) {
-                logger.warn('Failed to parse icon property on element', { err });
-            }
-            return style;
-        }
-        return this.parseStyleProps(elementProps.props);
-    }
-    parseStyleProps(styleProps) {
-        const result = {};
-        if (!styleProps || styleProps.length === 0) {
-            return result;
-        }
-        for (const prop of styleProps) {
-            if (!this.isValid(prop)) {
-                continue;
-            }
-            try {
-                switch (true) {
-                    case ast.isBorderProperty(prop): {
-                        if (isTruthy(prop.value)) {
-                            result.border = prop.value;
-                        }
-                        break;
-                    }
-                    case ast.isColorProperty(prop): {
-                        const color = toColor(prop);
-                        if (isTruthy(color)) {
-                            result.color = color;
-                        }
-                        break;
-                    }
-                    case ast.isShapeProperty(prop): {
-                        if (isTruthy(prop.value)) {
-                            result.shape = prop.value;
-                        }
-                        break;
-                    }
-                    case ast.isIconProperty(prop): {
-                        const icon = this.parseIconProperty(prop);
-                        if (isTruthy(icon)) {
-                            result.icon = icon;
-                        }
-                        break;
-                    }
-                    case ast.isOpacityProperty(prop): {
-                        result.opacity = parseAstOpacityProperty(prop);
-                        break;
-                    }
-                    case ast.isMultipleProperty(prop): {
-                        result.multiple = isBoolean(prop.value) ? prop.value : false;
-                        break;
-                    }
-                    case ast.isShapeSizeProperty(prop): {
-                        if (isTruthy(prop.value)) {
-                            result.size = parseAstSizeValue(prop);
-                        }
-                        break;
-                    }
-                    case ast.isPaddingSizeProperty(prop): {
-                        if (isTruthy(prop.value)) {
-                            result.padding = parseAstSizeValue(prop);
-                        }
-                        break;
-                    }
-                    case ast.isTextSizeProperty(prop): {
-                        if (isTruthy(prop.value)) {
-                            result.textSize = parseAstSizeValue(prop);
-                        }
-                        break;
-                    }
-                    default:
-                        nonexhaustive(prop);
-                }
-            }
-            catch (err) {
-                logger.warn('Failed to parse style property', { err });
-            }
-        }
-        return exact(result);
-    }
-    /**
-     * Parse base properties: title, description and technology
-     *
-     * @param props - body properties (inside '{...}')
-     * @param override - optional, inline properties (right on the node)
-     *                   have higher priority and override body properties
-     */
-    parseBaseProps(props, override) {
-        const title = removeIndent(override?.title ?? parseMarkdownAsString(props.title));
-        const description = override?.description
-            ? { txt: removeIndent(override.description) }
-            : this.parseMarkdownOrString(props.description);
-        const summary = override?.summary
-            ? { txt: removeIndent(override.summary) }
-            : this.parseMarkdownOrString(props.summary);
-        const technology = toSingleLine(override?.technology) ??
-            removeIndent(parseMarkdownAsString(props.technology));
-        return exact({
-            title,
-            summary,
-            description,
-            technology,
-        });
-    }
-}

package/dist/model/parser/DeploymentModelParser.d.ts

@@ -1,71 +0,0 @@
-import type * as c4 from '@likec4/core';
-import { FqnRef } from '@likec4/core';
-import { type ParsedAstDeployment, type ParsedAstDeploymentRelation, type ParsedAstExtend, ast } from '../../ast';
-import type { WithExpressionV2 } from './FqnRefParser';
-export type WithDeploymentModel = ReturnType<typeof DeploymentModelParser>;
-export declare function DeploymentModelParser<TBase extends WithExpressionV2>(B: TBase): {
-    new (...args: any[]): {
-        parseDeployment(): void;
-        parseDeploymentNode(astNode: ast.DeploymentNode): ParsedAstDeployment.Node;
-        parseDeployedInstance(astNode: ast.DeployedInstance): ParsedAstDeployment.Instance;
-        parseExtendDeployment(astNode: ast.ExtendDeployment): ParsedAstExtend | null;
-        _resolveDeploymentRelationSource(node: ast.DeploymentRelation): FqnRef;
-        parseDeploymentRelation(astNode: ast.DeploymentRelation): ParsedAstDeploymentRelation;
-        parseFqnRef(astNode: ast.FqnRef): c4.FqnRef;
-        parseExpressionV2(astNode: ast.ExpressionV2): c4.Expression;
-        parseFqnExprOrWith(astNode: ast.FqnExprOrWith): c4.FqnExpr.Any;
-        parseFqnExprWith(astNode: ast.FqnExprWith): c4.FqnExpr.Custom;
-        parseFqnExprOrWhere(astNode: ast.FqnExprOrWhere): c4.FqnExpr.OrWhere;
-        parseFqnExprWhere(astNode: ast.FqnExprWhere): c4.FqnExpr.Where;
-        parseFqnExpr(astNode: ast.FqnExpr): c4.FqnExpr;
-        parseFqnRefExpr(astNode: ast.FqnRefExpr): c4.FqnExpr.NonWildcard;
-        parseFqnExpressions(astNode: ast.FqnExpressions): c4.FqnExpr[];
-        parseRelationExprOrWith(astNode: ast.RelationExprOrWith): c4.RelationExpr.Any;
-        parseRelationExprWith(astNode: ast.RelationExprWith): c4.RelationExpr.Custom;
-        parseCustomRelationProperties(custom: ast.CustomRelationProperties | undefined): import("type-fest").Except<c4.RelationExpr.Custom["customRelation"], "expr">;
-        parseRelationExprOrWhere(astNode: ast.RelationExprOrWhere): c4.RelationExpr.OrWhere;
-        parseRelationExprWhere(astNode: ast.RelationExprWhere): c4.RelationExpr.Where;
-        parseRelationExpr(astNode: ast.RelationExpr): c4.RelationExpr.OrWhere;
-        parseInlineKindCondition(astNode: ast.OutgoingRelationExpr): c4.WhereOperator | null;
-        wrapInWhere(expr: c4.RelationExpr, condition: c4.WhereOperator | null): c4.RelationExpr.OrWhere;
-        isValid: import("../../validation").IsValidFn;
-        readonly services: import("../..").LikeC4Services;
-        readonly doc: import("../../ast").ParsedLikeC4LangiumDocument;
-        get project(): import("../../workspace").Project;
-        resolveFqn(node: ast.FqnReferenceable): c4.Fqn;
-        getAstNodePath(node: import("langium").AstNode): string;
-        getMetadata(metadataAstNode: ast.MetadataProperty | undefined): {
-            [key: string]: string | string[];
-        } | undefined;
-        parseMarkdownOrString(markdownOrString: ast.MarkdownOrString | undefined): c4.MarkdownOrString | undefined;
-        convertTags<E extends {
-            tags?: ast.Tags;
-        }>(withTags?: E | undefined): c4.NonEmptyArray<c4.Tag<string>> | null;
-        parseTags<E extends {
-            tags?: ast.Tags;
-        }>(withTags?: E): c4.NonEmptyArray<c4.Tag> | null;
-        convertLinks(source?: ast.LinkProperty["$container"]): c4.Link[] | undefined;
-        parseLinks(source?: ast.LinkProperty["$container"]): c4.Link[] | undefined;
-        parseIconProperty(prop: ast.IconProperty | undefined): c4.IconUrl | undefined;
-        parseImageAlias(value: string): string | undefined;
-        parseColorLiteral(astNode: ast.ColorLiteral): c4.ColorLiteral | undefined;
-        parseElementStyle(elementProps: Array<ast.ElementProperty> | ast.ElementStyleProperty | undefined): import("../../ast").ParsedElementStyle;
-        parseStyleProps(styleProps: Array<ast.StyleProperty> | undefined): import("../../ast").ParsedElementStyle;
-        parseBaseProps(props: {
-            title?: ast.MarkdownOrString | undefined;
-            summary?: ast.MarkdownOrString | undefined;
-            description?: ast.MarkdownOrString | undefined;
-            technology?: ast.MarkdownOrString | undefined;
-        }, override?: {
-            title?: string | undefined;
-            summary?: string | undefined;
-            description?: string | undefined;
-            technology?: string | undefined;
-        }): {
-            title?: string;
-            summary?: c4.MarkdownOrString;
-            description?: c4.MarkdownOrString;
-            technology?: string;
-        };
-    };
-} & TBase;