@likec4/language-server 1.18.0 → 1.19.0

package/dist/model/parser/Base.js

@@ -0,0 +1,87 @@
+import { invariant, isNonEmptyArray } from "@likec4/core";
+import { filter, flatMap, isNonNullish, isTruthy, mapToObj, pipe } from "remeda";
+import stripIndent from "strip-indent";
+import { ast } from "../../ast.js";
+import { getFqnElementRef } from "../../utils/elementRef.js";
+import { checksFromDiagnostics } from "../../validation/index.js";
+export function toSingleLine(str) {
+  return isNonNullish(str) ? removeIndent(str).split("\n").join(" ") : void 0;
+}
+export function removeIndent(str) {
+  return isNonNullish(str) ? stripIndent(str).trim() : void 0;
+}
+export class BaseParser {
+  constructor(services, doc) {
+    this.services = services;
+    this.doc = doc;
+    this.isValid = checksFromDiagnostics(doc).isValid;
+  }
+  isValid;
+  resolveFqn(node) {
+    if (ast.isDeploymentElement(node)) {
+      return this.services.likec4.DeploymentsIndex.getFqn(node);
+    }
+    if (ast.isExtendElement(node)) {
+      return getFqnElementRef(node.element);
+    }
+    const fqn = this.services.likec4.FqnIndex.getFqn(node);
+    invariant(fqn, `Not indexed element: ${this.getAstNodePath(node)}`);
+    return fqn;
+  }
+  getAstNodePath(node) {
+    return this.services.workspace.AstNodeLocator.getAstNodePath(node);
+  }
+  getMetadata(metadataAstNode) {
+    if (!metadataAstNode || !this.isValid(metadataAstNode)) {
+      return void 0;
+    }
+    return mapToObj(metadataAstNode.props, (p) => [p.key, removeIndent(p.value)]);
+  }
+  convertTags(withTags) {
+    return this.parseTags(withTags);
+  }
+  parseTags(withTags) {
+    let iter = withTags?.tags;
+    if (!iter) {
+      return null;
+    }
+    const tags = [];
+    while (iter) {
+      try {
+        if (this.isValid(iter)) {
+          const values = iter.values.map((t) => t.ref?.name).filter(isTruthy);
+          if (values.length > 0) {
+            tags.push(...values);
+          }
+        }
+      } catch (e) {
+      }
+      iter = iter.prev;
+    }
+    tags.reverse();
+    return isNonEmptyArray(tags) ? tags : null;
+  }
+  convertLinks(source) {
+    return this.parseLinks(source);
+  }
+  parseLinks(source) {
+    if (!source?.props || source.props.length === 0) {
+      return void 0;
+    }
+    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) : void 0;
+          return title ? { url, title } : { url };
+        }
+        return [];
+      })
+    );
+  }
+}

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

@@ -0,0 +1,33 @@
+import type * as c4 from '@likec4/core';
+import { type ParsedAstDeployment, type ParsedAstDeploymentRelation, 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;
+        parseDeploymentRelation(astNode: ast.DeploymentRelation): ParsedAstDeploymentRelation;
+        parseFqnRef(astNode: ast.FqnRef): c4.FqnRef;
+        parseFqnExpr(astNode: ast.FqnExpr): c4.FqnExpr;
+        parseFqnRefExpr(astNode: ast.FqnRefExpr): c4.FqnExpr.NonWildcard;
+        parseFqnExpressions(astNode: ast.FqnExpressions): c4.FqnExpr[];
+        parseRelationExpr(astNode: ast.RelationExpr): c4.RelationExpr;
+        isValid: import("../../validation").IsValidFn;
+        readonly services: import("../..").LikeC4Services;
+        readonly doc: import("../../ast").ParsedLikeC4LangiumDocument;
+        resolveFqn(node: ast.FqnReferenceable): c4.Fqn;
+        getAstNodePath(node: c4): any;
+        getMetadata(metadataAstNode: ast.MetadataProperty | undefined): {
+            [key: string]: string;
+        } | undefined;
+        convertTags<E extends {
+            tags?: ast.Tags;
+        }>(withTags?: E | undefined): any;
+        parseTags<E extends {
+            tags?: ast.Tags;
+        }>(withTags?: E): c4.NonEmptyArray<c4.Tag> | null;
+        convertLinks(source?: ast.LinkProperty["$container"]): import("../../ast").ParsedLink[] | undefined;
+        parseLinks(source?: ast.LinkProperty["$container"]): import("../../ast").ParsedLink[] | undefined;
+    };
+} & TBase;

package/dist/model/parser/DeploymentModelParser.js

@@ -0,0 +1,162 @@
+import { FqnRef, isNonEmptyArray, nameFromFqn, nonexhaustive, nonNullable } from "@likec4/core";
+import { filter, first, isTruthy, map, mapToObj, pipe } from "remeda";
+import {
+  ast,
+  streamDeploymentModel,
+  toElementStyle,
+  toRelationshipStyleExcludeDefaults
+} from "../../ast.js";
+import { logWarnError } from "../../logger.js";
+import { elementRef } from "../../utils/elementRef.js";
+import { stringHash } from "../../utils/stringHash.js";
+import { removeIndent, toSingleLine } from "./Base.js";
+export function DeploymentModelParser(B) {
+  return class DeploymentModelParser extends B {
+    parseDeployment() {
+      const doc = this.doc;
+      for (const el of streamDeploymentModel(doc)) {
+        try {
+          switch (true) {
+            case ast.isDeploymentRelation(el): {
+              if (this.isValid(el)) {
+                doc.c4DeploymentRelations.push(this.parseDeploymentRelation(el));
+              }
+              break;
+            }
+            case ast.isDeployedInstance(el):
+              doc.c4Deployments.push(this.parseDeployedInstance(el));
+              break;
+            case ast.isDeploymentNode(el): {
+              doc.c4Deployments.push(this.parseDeploymentNode(el));
+              break;
+            }
+            default:
+              nonexhaustive(el);
+          }
+        } catch (e) {
+          logWarnError(e);
+        }
+      }
+    }
+    parseDeploymentNode(astNode) {
+      const isValid = this.isValid;
+      const id = this.resolveFqn(astNode);
+      const kind = nonNullable(astNode.kind.ref, "DeploymentKind not resolved").name;
+      const tags = this.convertTags(astNode.body);
+      const stylePropsAst = astNode.body?.props.find(ast.isElementStyleProperty)?.props;
+      const style = toElementStyle(stylePropsAst, isValid);
+      const metadata = this.getMetadata(astNode.body?.props.find(ast.isMetadataProperty));
+      const bodyProps = pipe(
+        astNode.body?.props ?? [],
+        filter(isValid),
+        filter(ast.isElementStringProperty),
+        mapToObj((p) => [p.key, p.value || void 0])
+      );
+      const title = removeIndent(astNode.title ?? bodyProps.title);
+      const description = removeIndent(bodyProps.description);
+      const technology = toSingleLine(bodyProps.technology);
+      const links = this.convertLinks(astNode.body);
+      const iconProp = astNode.body?.props.find(ast.isIconProperty);
+      if (iconProp && isValid(iconProp)) {
+        const value = iconProp.libicon?.ref?.name ?? iconProp.value;
+        if (isTruthy(value)) {
+          style.icon = value;
+        }
+      }
+      return {
+        id,
+        kind,
+        title: title ?? nameFromFqn(id),
+        ...metadata && { metadata },
+        ...tags && { tags },
+        ...links && isNonEmptyArray(links) && { links },
+        ...isTruthy(technology) && { technology },
+        ...isTruthy(description) && { description },
+        style
+      };
+    }
+    parseDeployedInstance(astNode) {
+      const isValid = this.isValid;
+      const id = this.resolveFqn(astNode);
+      const element = this.resolveFqn(nonNullable(elementRef(astNode.element), "DeployedInstance element not found"));
+      const tags = this.convertTags(astNode.body);
+      const stylePropsAst = astNode.body?.props.find(ast.isElementStyleProperty)?.props;
+      const style = toElementStyle(stylePropsAst, isValid);
+      const metadata = this.getMetadata(astNode.body?.props.find(ast.isMetadataProperty));
+      const bodyProps = pipe(
+        astNode.body?.props ?? [],
+        filter(isValid),
+        filter(ast.isElementStringProperty),
+        mapToObj((p) => [p.key, p.value || void 0])
+      );
+      const title = removeIndent(astNode.title ?? bodyProps.title);
+      const description = removeIndent(bodyProps.description);
+      const technology = toSingleLine(bodyProps.technology);
+      const links = this.convertLinks(astNode.body);
+      const iconProp = astNode.body?.props.find(ast.isIconProperty);
+      if (iconProp && isValid(iconProp)) {
+        const value = iconProp.libicon?.ref?.name ?? iconProp.value;
+        if (isTruthy(value)) {
+          style.icon = value;
+        }
+      }
+      return {
+        id,
+        element,
+        ...metadata && { metadata },
+        ...title && { title },
+        ...tags && { tags },
+        ...links && isNonEmptyArray(links) && { links },
+        ...isTruthy(technology) && { technology },
+        ...isTruthy(description) && { description },
+        style
+      };
+    }
+    parseDeploymentRelation(astNode) {
+      const isValid = this.isValid;
+      const astPath = this.getAstNodePath(astNode);
+      const source = FqnRef.toDeploymentRef(this.parseFqnRef(astNode.source));
+      const target = FqnRef.toDeploymentRef(this.parseFqnRef(astNode.target));
+      const tags = this.convertTags(astNode) ?? this.convertTags(astNode.body);
+      const links = this.convertLinks(astNode.body);
+      const kind = astNode.kind?.ref?.name;
+      const metadata = this.getMetadata(astNode.body?.props.find(ast.isMetadataProperty));
+      const bodyProps = mapToObj(
+        astNode.body?.props.filter(ast.isRelationStringProperty) ?? [],
+        (p) => [p.key, p.value]
+      );
+      const navigateTo = pipe(
+        astNode.body?.props ?? [],
+        filter(ast.isRelationNavigateToProperty),
+        map((p) => p.value.view.ref?.name),
+        filter(isTruthy),
+        first()
+      );
+      const title = removeIndent(astNode.title ?? bodyProps.title);
+      const description = removeIndent(bodyProps.description);
+      const technology = toSingleLine(astNode.technology) ?? removeIndent(bodyProps.technology);
+      const styleProp = astNode.body?.props.find(ast.isRelationStyleProperty);
+      const id = stringHash(
+        "deployment",
+        astPath,
+        source.id,
+        target.id
+      );
+      return {
+        id,
+        source,
+        target,
+        ...title && { title },
+        ...metadata && { metadata },
+        ...isTruthy(technology) && { technology },
+        ...isTruthy(description) && { description },
+        ...kind && { kind },
+        ...tags && { tags },
+        ...isNonEmptyArray(links) && { links },
+        ...toRelationshipStyleExcludeDefaults(styleProp?.props, isValid),
+        ...navigateTo && { navigateTo },
+        astPath
+      };
+    }
+  };
+}

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

@@ -0,0 +1,38 @@
+import type * as c4 from '@likec4/core';
+import { ast, type ParsedAstDeploymentView } from '../../ast';
+import type { WithDeploymentModel } from './DeploymentModelParser';
+import type { WithExpressionV2 } from './FqnRefParser';
+export type WithDeploymentView = ReturnType<typeof DeploymentViewParser>;
+export declare function DeploymentViewParser<TBase extends WithExpressionV2 & WithDeploymentModel>(B: TBase): {
+    new (...args: any[]): {
+        parseDeploymentView(astNode: ast.DeploymentView): ParsedAstDeploymentView;
+        parseDeploymentViewRule(astRule: ast.DeploymentViewRule): c4.DeploymentViewRule;
+        parseDeploymentViewRulePredicate(astRule: ast.DeploymentViewRulePredicate): c4.DeploymentViewRulePredicate;
+        parseDeploymentViewRuleStyle(astRule: ast.DeploymentViewRuleStyle): c4.DeploymentViewRuleStyle;
+        parseFqnRef(astNode: ast.FqnRef): c4.FqnRef;
+        parseFqnExpr(astNode: ast.FqnExpr): c4.FqnExpr;
+        parseFqnRefExpr(astNode: ast.FqnRefExpr): c4.FqnExpr.NonWildcard;
+        parseFqnExpressions(astNode: ast.FqnExpressions): c4.FqnExpr[];
+        parseRelationExpr(astNode: ast.RelationExpr): c4.RelationExpr;
+        isValid: import("../../validation").IsValidFn;
+        readonly services: import("../..").LikeC4Services;
+        readonly doc: import("../../ast").ParsedLikeC4LangiumDocument;
+        resolveFqn(node: ast.FqnReferenceable): c4.Fqn;
+        getAstNodePath(node: c4): any;
+        getMetadata(metadataAstNode: ast.MetadataProperty | undefined): {
+            [key: string]: string;
+        } | undefined;
+        convertTags<E extends {
+            tags?: ast.Tags;
+        }>(withTags?: E | undefined): any;
+        parseTags<E extends {
+            tags?: ast.Tags;
+        }>(withTags?: E): c4.NonEmptyArray<c4.Tag> | null;
+        convertLinks(source?: ast.LinkProperty["$container"]): import("../../ast").ParsedLink[] | undefined;
+        parseLinks(source?: ast.LinkProperty["$container"]): import("../../ast").ParsedLink[] | undefined;
+        parseDeployment(): void;
+        parseDeploymentNode(astNode: ast.DeploymentNode): import("../../ast").ParsedAstDeployment.Node;
+        parseDeployedInstance(astNode: ast.DeployedInstance): import("../../ast").ParsedAstDeployment.Instance;
+        parseDeploymentRelation(astNode: ast.DeploymentRelation): import("../../ast").ParsedAstDeploymentRelation;
+    };
+} & TBase;

package/dist/model/parser/DeploymentViewParser.js

@@ -0,0 +1,98 @@
+import { invariant, isNonEmptyArray, nonexhaustive } from "@likec4/core";
+import { isNonNullish } from "remeda";
+import { ast, toAutoLayout, toElementStyle, ViewOps } from "../../ast.js";
+import { logWarnError } from "../../logger.js";
+import { stringHash } from "../../utils/index.js";
+import { parseViewManualLayout } from "../../view-utils/manual-layout.js";
+import { removeIndent, toSingleLine } from "./Base.js";
+export function DeploymentViewParser(B) {
+  return class DeploymentViewParser extends B {
+    parseDeploymentView(astNode) {
+      const body = astNode.body;
+      invariant(body, "DynamicElementView body is not defined");
+      const props = body.props.filter(this.isValid);
+      const astPath = this.getAstNodePath(astNode);
+      let id = astNode.name;
+      if (!id) {
+        id = "deployment_" + stringHash(
+          this.doc.uri.toString(),
+          astPath
+        );
+      }
+      const title = toSingleLine(props.find((p) => p.key === "title")?.value) ?? null;
+      const description = removeIndent(props.find((p) => p.key === "description")?.value) ?? null;
+      const tags = this.convertTags(body);
+      const links = this.convertLinks(body);
+      ViewOps.writeId(astNode, id);
+      const manualLayout = parseViewManualLayout(astNode);
+      return {
+        __: "deployment",
+        id,
+        astPath,
+        title,
+        description,
+        tags,
+        links: isNonEmptyArray(links) ? links : null,
+        rules: body.rules.flatMap((n) => {
+          try {
+            return this.isValid(n) ? this.parseDeploymentViewRule(n) : [];
+          } catch (e) {
+            logWarnError(e);
+            return [];
+          }
+        }),
+        ...manualLayout && { manualLayout }
+      };
+    }
+    parseDeploymentViewRule(astRule) {
+      if (ast.isDeploymentViewRulePredicate(astRule)) {
+        return this.parseDeploymentViewRulePredicate(astRule);
+      }
+      if (ast.isViewRuleAutoLayout(astRule)) {
+        return toAutoLayout(astRule);
+      }
+      if (ast.isDeploymentViewRuleStyle(astRule)) {
+        return this.parseDeploymentViewRuleStyle(astRule);
+      }
+      nonexhaustive(astRule);
+    }
+    parseDeploymentViewRulePredicate(astRule) {
+      const exprs = [];
+      let iterator = astRule.expr;
+      while (iterator) {
+        try {
+          const expr = iterator.value;
+          if (isNonNullish(expr) && this.isValid(expr)) {
+            switch (true) {
+              case ast.isFqnExpr(expr):
+                exprs.unshift(this.parseFqnExpr(expr));
+                break;
+              case ast.isRelationExpr(expr):
+                exprs.unshift(this.parseRelationExpr(expr));
+                break;
+              default:
+                nonexhaustive(expr);
+            }
+          }
+        } catch (e) {
+          logWarnError(e);
+        }
+        iterator = iterator.prev;
+      }
+      return astRule.isInclude ? { include: exprs } : { exclude: exprs };
+    }
+    parseDeploymentViewRuleStyle(astRule) {
+      const styleProps = astRule.props.filter(ast.isStyleProperty);
+      const notationProperty = astRule.props.find(ast.isNotationProperty);
+      const notation = removeIndent(notationProperty?.value);
+      const targets = this.parseFqnExpressions(astRule.targets);
+      return {
+        targets,
+        ...notation && { notation },
+        style: {
+          ...toElementStyle(styleProps, this.isValid)
+        }
+      };
+    }
+  };
+}

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

@@ -0,0 +1,29 @@
+import type * as c4 from '@likec4/core';
+import { ast } from '../../ast';
+import type { Base } from './Base';
+export type WithExpressionV2 = ReturnType<typeof ExpressionV2Parser>;
+export declare function ExpressionV2Parser<TBase extends Base>(B: TBase): {
+    new (...args: any[]): {
+        parseFqnRef(astNode: ast.FqnRef): c4.FqnRef;
+        parseFqnExpr(astNode: ast.FqnExpr): c4.FqnExpr;
+        parseFqnRefExpr(astNode: ast.FqnRefExpr): c4.FqnExpr.NonWildcard;
+        parseFqnExpressions(astNode: ast.FqnExpressions): c4.FqnExpr[];
+        parseRelationExpr(astNode: ast.RelationExpr): c4.RelationExpr;
+        isValid: import("../../validation").IsValidFn;
+        readonly services: import("../..").LikeC4Services;
+        readonly doc: import("../../ast").ParsedLikeC4LangiumDocument;
+        resolveFqn(node: ast.FqnReferenceable): c4.Fqn;
+        getAstNodePath(node: c4): any;
+        getMetadata(metadataAstNode: ast.MetadataProperty | undefined): {
+            [key: string]: string;
+        } | undefined;
+        convertTags<E extends {
+            tags?: ast.Tags;
+        }>(withTags?: E | undefined): any;
+        parseTags<E extends {
+            tags?: ast.Tags;
+        }>(withTags?: E): c4.NonEmptyArray<c4.Tag> | null;
+        convertLinks(source?: ast.LinkProperty["$container"]): import("../../ast").ParsedLink[] | undefined;
+        parseLinks(source?: ast.LinkProperty["$container"]): import("../../ast").ParsedLink[] | undefined;
+    };
+} & TBase;

package/dist/model/parser/FqnRefParser.js

@@ -0,0 +1,108 @@
+import { nonexhaustive, nonNullable } from "@likec4/core";
+import { isNonNullish } from "remeda";
+import { ast } from "../../ast.js";
+import { logWarnError } from "../../logger.js";
+import { instanceRef } from "../../utils/fqnRef.js";
+export function ExpressionV2Parser(B) {
+  return class ExpressionV2Parser extends B {
+    parseFqnRef(astNode) {
+      const refValue = nonNullable(
+        astNode.value.ref,
+        `FqnRef is empty ${astNode.$cstNode?.range.start.line}:${astNode.$cstNode?.range.start.character}`
+      );
+      if (ast.isElement(refValue)) {
+        const deployedInstanceAst = instanceRef(astNode);
+        if (!deployedInstanceAst) {
+          return {
+            model: this.resolveFqn(refValue)
+          };
+        }
+        const deployment = this.resolveFqn(deployedInstanceAst);
+        const element = this.resolveFqn(refValue);
+        return {
+          deployment,
+          element
+        };
+      }
+      if (ast.isDeploymentElement(refValue)) {
+        return {
+          deployment: this.resolveFqn(refValue)
+        };
+      }
+      nonexhaustive(refValue);
+    }
+    parseFqnExpr(astNode) {
+      if (ast.isWildcardExpression(astNode)) {
+        return {
+          wildcard: true
+        };
+      }
+      if (ast.isFqnRefExpr(astNode)) {
+        return this.parseFqnRefExpr(astNode);
+      }
+      nonexhaustive(astNode);
+    }
+    parseFqnRefExpr(astNode) {
+      const ref = this.parseFqnRef(astNode.ref);
+      switch (true) {
+        case astNode.selector === "._":
+          return {
+            ref,
+            selector: "expanded"
+          };
+        case astNode.selector === ".**":
+          return {
+            ref,
+            selector: "descendants"
+          };
+        case astNode.selector === ".*":
+          return {
+            ref,
+            selector: "children"
+          };
+        default:
+          return { ref };
+      }
+    }
+    parseFqnExpressions(astNode) {
+      const exprs = [];
+      let iter = astNode;
+      while (iter) {
+        try {
+          if (isNonNullish(iter.value) && this.isValid(iter.value)) {
+            exprs.push(this.parseFqnExpr(iter.value));
+          }
+        } catch (e) {
+          logWarnError(e);
+        }
+        iter = iter.prev;
+      }
+      return exprs.reverse();
+    }
+    parseRelationExpr(astNode) {
+      if (ast.isDirectedRelationExpr(astNode)) {
+        return {
+          source: this.parseFqnExpr(astNode.source.from),
+          target: this.parseFqnExpr(astNode.target),
+          isBidirectional: astNode.source.isBidirectional
+        };
+      }
+      if (ast.isInOutRelationExpr(astNode)) {
+        return {
+          inout: this.parseFqnExpr(astNode.inout.to)
+        };
+      }
+      if (ast.isOutgoingRelationExpr(astNode)) {
+        return {
+          outgoing: this.parseFqnExpr(astNode.from)
+        };
+      }
+      if (ast.isIncomingRelationExpr(astNode)) {
+        return {
+          incoming: this.parseFqnExpr(astNode.to)
+        };
+      }
+      nonexhaustive(astNode);
+    }
+  };
+}

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

@@ -0,0 +1,66 @@
+import type * as c4 from '@likec4/core';
+import { ast, type ParsedAstGlobals } from '../../ast';
+import type { WithViewsParser } from './ViewsParser';
+export declare function GlobalsParser<TBase extends WithViewsParser>(B: TBase): {
+    new (...args: any[]): {
+        parseGlobals(): void;
+        parseAndStoreGlobalPredicateGroupOrDynamic(astRule: ast.GlobalPredicateGroup | ast.GlobalDynamicPredicateGroup, id: c4.GlobalPredicateId, c4Globals: ParsedAstGlobals): void;
+        parseGlobalPredicateGroup(astRule: ast.GlobalPredicateGroup): c4.ViewRulePredicate[];
+        parseGlobalDynamicPredicateGroup(astRule: ast.GlobalDynamicPredicateGroup): c4.DynamicViewIncludeRule[];
+        parseGlobalStyleOrGroup(astRule: ast.GlobalStyle | ast.GlobalStyleGroup): c4.ViewRuleStyle[];
+        parseViews(): void;
+        parseElementView(astNode: ast.ElementView, additionalStyles: c4.ViewRuleStyleOrGlobalRef[]): import("../../ast").ParsedAstElementView;
+        parseViewRule(astRule: ast.ViewRule): c4.ViewRule;
+        parseViewRulePredicate(astNode: ast.ViewRulePredicate): c4.ViewRulePredicate;
+        parseViewRuleGlobalPredicateRef(astRule: ast.ViewRuleGlobalPredicateRef | ast.DynamicViewGlobalPredicateRef): c4.ViewRuleGlobalPredicateRef;
+        parseViewRuleStyleOrGlobalRef(astRule: ast.ViewRuleStyleOrGlobalRef): c4.ViewRuleStyleOrGlobalRef;
+        parseViewRuleGroup(astNode: ast.ViewRuleGroup): c4.ViewRuleGroup;
+        parseViewRuleStyle(astRule: ast.ViewRuleStyle | ast.GlobalStyle): c4.ViewRuleStyle;
+        parseRuleStyle(styleProperties: ast.StyleProperty[], elementExpressionsIterator: ast.ElementExpressionsIterator, notationProperty?: ast.NotationProperty): c4.ViewRuleStyle;
+        parseViewRuleGlobalStyle(astRule: ast.ViewRuleGlobalStyle): c4.ViewRuleGlobalStyle;
+        parseDynamicElementView(astNode: ast.DynamicView, additionalStyles: c4.ViewRuleStyleOrGlobalRef[]): import("../../ast").ParsedAstDynamicView;
+        parseDynamicViewRule(astRule: ast.DynamicViewRule): c4.DynamicViewRule;
+        parseDynamicViewIncludePredicate(astRule: ast.DynamicViewIncludePredicate): c4.DynamicViewIncludeRule;
+        parseDynamicParallelSteps(node: ast.DynamicViewParallelSteps): c4.DynamicViewParallelSteps;
+        parseDynamicStep(node: ast.DynamicViewStep): c4.DynamicViewStep;
+        parsePredicate(astNode: ast.Predicate): c4.Expression;
+        parseElementPredicate(astNode: ast.ElementPredicate): c4.ElementPredicateExpression;
+        parseElementExpressionsIterator(astNode: ast.ElementExpressionsIterator): c4.ElementExpression[];
+        parseElementExpression(astNode: ast.ElementExpression): c4.ElementExpression;
+        parseElementPredicateWhere(astNode: ast.ElementPredicateWhere): c4.ElementWhereExpr;
+        parseElementPredicateWith(astNode: ast.ElementPredicateWith): c4.CustomElementExpr;
+        parseRelationPredicate(astNode: ast.RelationPredicate): c4.RelationPredicateExpression;
+        parseRelationPredicateWhere(astNode: ast.RelationPredicateWhere): c4.RelationWhereExpr;
+        parseRelationPredicateWith(astNode: ast.RelationPredicateWith, relation: c4.RelationExpression | c4.RelationWhereExpr): c4.CustomRelationExpr;
+        parseRelationExpression(astNode: ast.RelationExpression): c4.RelationExpression;
+        isValid: import("../../validation").IsValidFn;
+        readonly services: import("../..").LikeC4Services;
+        readonly doc: import("../../ast").ParsedLikeC4LangiumDocument;
+        resolveFqn(node: ast.FqnReferenceable): c4.Fqn;
+        getAstNodePath(node: c4): any;
+        getMetadata(metadataAstNode: ast.MetadataProperty | undefined): {
+            [key: string]: string;
+        } | undefined;
+        convertTags<E extends {
+            tags?: ast.Tags;
+        }>(withTags?: E | undefined): any;
+        parseTags<E extends {
+            tags?: ast.Tags;
+        }>(withTags?: E): c4.NonEmptyArray<c4.Tag> | null;
+        convertLinks(source?: ast.LinkProperty["$container"]): import("../../ast").ParsedLink[] | undefined;
+        parseLinks(source?: ast.LinkProperty["$container"]): import("../../ast").ParsedLink[] | undefined;
+        parseDeploymentView(astNode: ast.DeploymentView): import("../../ast").ParsedAstDeploymentView;
+        parseDeploymentViewRule(astRule: ast.DeploymentViewRule): c4.DeploymentViewRule;
+        parseDeploymentViewRulePredicate(astRule: ast.DeploymentViewRulePredicate): c4.DeploymentViewRulePredicate;
+        parseDeploymentViewRuleStyle(astRule: ast.DeploymentViewRuleStyle): c4.DeploymentViewRuleStyle;
+        parseFqnRef(astNode: ast.FqnRef): c4.FqnRef;
+        parseFqnExpr(astNode: ast.FqnExpr): c4.FqnExpr;
+        parseFqnRefExpr(astNode: ast.FqnRefExpr): c4.FqnExpr.NonWildcard;
+        parseFqnExpressions(astNode: ast.FqnExpressions): c4.FqnExpr[];
+        parseRelationExpr(astNode: ast.RelationExpr): c4.RelationExpr;
+        parseDeployment(): void;
+        parseDeploymentNode(astNode: ast.DeploymentNode): import("../../ast").ParsedAstDeployment.Node;
+        parseDeployedInstance(astNode: ast.DeployedInstance): import("../../ast").ParsedAstDeployment.Instance;
+        parseDeploymentRelation(astNode: ast.DeploymentRelation): import("../../ast").ParsedAstDeploymentRelation;
+    };
+} & TBase;