@likec4/language-server 1.40.0 → 1.42.0

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

@@ -20,6 +20,7 @@ export declare function DeploymentViewParser<TBase extends WithExpressionV2 & Wi
         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;
@@ -48,16 +49,19 @@ export declare function DeploymentViewParser<TBase extends WithExpressionV2 & Wi
         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;
-        parseTitleDescriptionTechnology(inlineProps: {
-            title?: string | undefined;
-            description?: string | undefined;
-            technology?: string | undefined;
-        }, bodyProps: {
+        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/DeploymentViewParser.mjs

@@ -23,8 +23,7 @@ export function DeploymentViewParser(B) {
       const {
         title = null,
         description = null
-      } = this.parseTitleDescriptionTechnology(
-        {},
+      } = this.parseBaseProps(
         pipe(
           props,
           filter(ast.isViewStringProperty),

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

@@ -1,4 +1,6 @@
 import type * as c4 from '@likec4/core';
+import { type AstNode } from 'langium';
+import type { Except } from 'type-fest';
 import { ast } from '../../ast';
 import { type Base } from './Base';
 export type WithExpressionV2 = ReturnType<typeof ExpressionV2Parser>;
@@ -15,6 +17,7 @@ export declare function ExpressionV2Parser<TBase extends Base>(B: TBase): {
         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): 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;
@@ -25,7 +28,7 @@ export declare function ExpressionV2Parser<TBase extends Base>(B: TBase): {
         readonly doc: import("../../ast").ParsedLikeC4LangiumDocument;
         get project(): import("../../workspace").Project;
         resolveFqn(node: ast.FqnReferenceable): c4.Fqn;
-        getAstNodePath(node: c4): any;
+        getAstNodePath(node: AstNode): any;
         getMetadata(metadataAstNode: ast.MetadataProperty | undefined): {
             [key: string]: string;
         } | undefined;
@@ -43,16 +46,19 @@ export declare function ExpressionV2Parser<TBase extends Base>(B: TBase): {
         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;
-        parseTitleDescriptionTechnology(inlineProps: {
-            title?: string | undefined;
-            description?: string | undefined;
-            technology?: string | undefined;
-        }, bodyProps: {
+        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/FqnRefParser.mjs

@@ -1,17 +1,25 @@
 import { invariant, nonexhaustive, nonNullable } from "@likec4/core";
+import { loggable } from "@likec4/log";
+import { AstUtils } from "langium";
 import { isBoolean, isDefined, isNonNullish, isTruthy } from "remeda";
 import { ast, parseAstOpacityProperty, parseAstSizeValue, parseMarkdownAsString, toColor } from "../../ast.mjs";
-import { logWarnError } from "../../logger.mjs";
+import { serverLogger } from "../../logger.mjs";
 import { projectIdFrom } from "../../utils/index.mjs";
 import { importsRef, instanceRef } from "../../utils/fqnRef.mjs";
 import { createBinaryOperator, parseWhereClause } from "../model-parser-where.mjs";
 import { removeIndent } from "./Base.mjs";
+const logger = serverLogger.getChild("ExpressionV2Parser");
+const location = (astNode) => {
+  const cst = astNode.$cstNode;
+  const position = cst ? `:${cst.range.start.line + 1}:${cst.range.start.character + 1}` : "";
+  return `${AstUtils.getDocument(astNode).uri.fsPath}${position}`;
+};
 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}`
+        () => `FqnRef "${astNode.$cstNode?.text}" is empty at ${location(astNode)}`
       );
       if (ast.isImported(refValue)) {
         const fqnRef = {
@@ -87,7 +95,7 @@ export function ExpressionV2Parser(B) {
             return acc;
           }
           if (ast.isElementStringProperty(prop)) {
-            if (isDefined(prop.value)) {
+            if (isDefined(prop.value) && prop.key !== "summary") {
               if (prop.key === "description") {
                 const parsed = this.parseMarkdownOrString(prop.value);
                 if (parsed) {
@@ -248,7 +256,7 @@ export function ExpressionV2Parser(B) {
             exprs.push(this.parseFqnExpr(iter.value));
           }
         } catch (e) {
-          logWarnError(e);
+          logger.warn(loggable(e));
         }
         iter = iter.prev;
       }
@@ -265,49 +273,54 @@ export function ExpressionV2Parser(B) {
     }
     parseRelationExprWith(astNode) {
       const expr = this.parseRelationExprOrWhere(astNode.subject);
-      const props = astNode.custom?.props ?? [];
+      const customProps = this.parseCustomRelationProperties(astNode.custom);
+      return {
+        customRelation: {
+          ...customProps,
+          expr
+        }
+      };
+    }
+    parseCustomRelationProperties(custom) {
+      const props = custom?.props ?? [];
       return props.reduce(
         (acc, prop) => {
           if (ast.isRelationStringProperty(prop) || ast.isNotationProperty(prop) || ast.isNotesProperty(prop)) {
             const value = isTruthy(prop.value) ? removeIndent(parseMarkdownAsString(prop.value)) : void 0;
             if (value) {
-              acc.customRelation[prop.key] = value;
+              acc[prop.key] = value;
             }
             return acc;
           }
           if (ast.isArrowProperty(prop)) {
             if (isTruthy(prop.value)) {
-              acc.customRelation[prop.key] = prop.value;
+              acc[prop.key] = prop.value;
             }
             return acc;
           }
           if (ast.isColorProperty(prop)) {
             const value = toColor(prop);
             if (isTruthy(value)) {
-              acc.customRelation[prop.key] = value;
+              acc[prop.key] = value;
             }
             return acc;
           }
           if (ast.isLineProperty(prop)) {
             if (isTruthy(prop.value)) {
-              acc.customRelation[prop.key] = prop.value;
+              acc[prop.key] = prop.value;
             }
             return acc;
           }
           if (ast.isRelationNavigateToProperty(prop)) {
             const viewId = prop.value.view.ref?.name;
             if (isTruthy(viewId)) {
-              acc.customRelation.navigateTo = viewId;
+              acc[prop.key] = viewId;
             }
             return acc;
           }
           nonexhaustive(prop);
         },
-        {
-          customRelation: {
-            expr
-          }
-        }
+        {}
       );
     }
     parseRelationExprOrWhere(astNode) {

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

@@ -20,8 +20,13 @@ export declare function GlobalsParser<TBase extends WithViewsParser>(B: TBase):
         parseDynamicElementView(astNode: ast.DynamicView, additionalStyles: any[]): 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;
+        parseDynamicParallelSteps(node: ast.DynamicViewParallelSteps): c4.DynamicStepsParallel;
+        parseDynamicStep(node: ast.DynamicViewStep): c4.DynamicStep | c4.DynamicStepsSeries;
+        recursiveParseDynamicStepChain(node: ast.DynamicStepChain, callstack?: Array<[source: c4.Fqn, target: c4.Fqn]>): c4.DynamicStep[];
+        parseDynamicStepSingle(node: ast.DynamicStepSingle): c4.DynamicStep;
+        parseAbstractDynamicStep(astnode: ast.AbstractDynamicStep): import("type-fest").Writable<import("type-fest").Except<c4.DynamicStep, "source", {
+            requireExactProps: true;
+        }>>;
         parsePredicate(astNode: ast.ExpressionV2): c4.ModelExpression;
         parseElementPredicate(astNode: ast.FqnExprOrWith): c4.ModelFqnExpr.Any;
         parseElementPredicateOrWhere(astNode: ast.FqnExprOrWhere): c4.ModelFqnExpr.OrWhere;
@@ -44,6 +49,7 @@ export declare function GlobalsParser<TBase extends WithViewsParser>(B: TBase):
         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;
@@ -72,16 +78,19 @@ export declare function GlobalsParser<TBase extends WithViewsParser>(B: TBase):
         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;
-        parseTitleDescriptionTechnology(inlineProps: {
-            title?: string | undefined;
-            description?: string | undefined;
-            technology?: string | undefined;
-        }, bodyProps: {
+        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/GlobalsParser.mjs

@@ -1,7 +1,9 @@
 import { nonexhaustive } from "@likec4/core";
+import { loggable } from "@likec4/log";
 import { hasAtLeast, isTruthy } from "remeda";
 import { ast } from "../../ast.mjs";
-import { logger, logWarnError } from "../../logger.mjs";
+import { serverLogger } from "../../logger.mjs";
+const logger = serverLogger.getChild("GlobalsParser");
 export function GlobalsParser(B) {
   return class GlobalsParser extends B {
     parseGlobals() {
@@ -21,7 +23,7 @@ export function GlobalsParser(B) {
           }
           this.parseAndStoreGlobalPredicateGroupOrDynamic(predicate, globalPredicateId, c4Globals);
         } catch (e) {
-          logWarnError(e);
+          logger.warn(loggable(e));
         }
       }
       const styles = globals.flatMap((r) => r.styles.filter(isValid));
@@ -40,7 +42,7 @@ export function GlobalsParser(B) {
             c4Globals.styles[globalStyleId] = styles2;
           }
         } catch (e) {
-          logWarnError(e);
+          logger.warn(loggable(e));
         }
       }
     }

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

@@ -27,16 +27,19 @@ export declare function ImportsParser<TBase extends Base>(B: TBase): {
         parseColorLiteral(astNode: ast.ColorLiteral): ProjectId | undefined;
         parseElementStyle(elementProps: Array<ast.ElementProperty> | ast.ElementStyleProperty | undefined): import("../../ast").ParsedElementStyle;
         parseStyleProps(styleProps: Array<ast.StyleProperty> | undefined): import("../../ast").ParsedElementStyle;
-        parseTitleDescriptionTechnology(inlineProps: {
-            title?: string | undefined;
-            description?: string | undefined;
-            technology?: string | undefined;
-        }, bodyProps: {
+        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?: ProjectId;
             description?: ProjectId;
             technology?: string;
         };

package/dist/model/parser/ImportsParser.mjs

@@ -1,5 +1,7 @@
 import { nonNullable } from "@likec4/core";
-import { logWarnError } from "../../logger.mjs";
+import { loggable } from "@likec4/log";
+import { serverLogger } from "../../logger.mjs";
+const logger = serverLogger.getChild("ImportsParser");
 export function ImportsParser(B) {
   return class ImportsParser extends B {
     parseImports() {
@@ -16,7 +18,7 @@ export function ImportsParser(B) {
               )
             );
           } catch (e) {
-            logWarnError(e);
+            logger.warn(loggable(e));
           }
           imported = imported.prev;
         }

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

@@ -21,6 +21,7 @@ export declare function ModelParser<TBase extends WithExpressionV2>(B: TBase): {
         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;
@@ -49,16 +50,19 @@ export declare function ModelParser<TBase extends WithExpressionV2>(B: TBase): {
         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;
-        parseTitleDescriptionTechnology(inlineProps: {
-            title?: string | undefined;
-            description?: string | undefined;
-            technology?: string | undefined;
-        }, bodyProps: {
+        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/ModelParser.mjs

@@ -1,10 +1,10 @@
 import { invariant, isNonEmptyArray, LinkedList, nonexhaustive, nonNullable } from "@likec4/core";
-import { FqnRef } from "@likec4/core/types";
+import { exact, FqnRef } from "@likec4/core/types";
 import { loggable } from "@likec4/log";
 import { filter, first, isDefined, isEmpty, isTruthy, map, mapToObj, pipe } from "remeda";
 import {
   ast,
-  toRelationshipStyleExcludeDefaults
+  toRelationshipStyle
 } from "../../ast.mjs";
 import { logger as mainLogger } from "../../logger.mjs";
 import { stringHash } from "../../utils/stringHash.mjs";
@@ -75,33 +75,30 @@ ${error}`, {
       const style = this.parseElementStyle(astNode.body?.props);
       const metadata = this.getMetadata(astNode.body?.props.find(ast.isMetadataProperty));
       const astPath = this.getAstNodePath(astNode);
-      let [_title, _description, _technology] = astNode.props ?? [];
+      let [_title, _summary, _technology] = astNode.props ?? [];
       const bodyProps = pipe(
         astNode.body?.props ?? [],
         filter(isValid),
         filter(ast.isElementStringProperty),
         mapToObj((p) => [p.key, p.value])
       );
-      const { title, ...descAndTech } = this.parseTitleDescriptionTechnology(
-        {
-          title: _title,
-          description: _description,
-          technology: _technology
-        },
-        bodyProps
-      );
+      const { title, ...descAndTech } = this.parseBaseProps(bodyProps, {
+        title: _title,
+        summary: _summary,
+        technology: _technology
+      });
       const links = this.parseLinks(astNode.body);
-      return {
+      return exact({
         id,
         kind,
         astPath,
         title: title ?? astNode.name,
-        ...metadata && { metadata },
-        ...tags && { tags },
+        metadata,
+        tags: tags ?? void 0,
         ...links && isNonEmptyArray(links) && { links },
         ...descAndTech,
         style
-      };
+      });
     }
     parseExtendElement(astNode) {
       const id = this.resolveFqn(astNode);
@@ -112,13 +109,13 @@ ${error}`, {
       if (!tags && isEmpty(metadata ?? {}) && isEmpty(links)) {
         return null;
       }
-      return {
+      return exact({
         id,
         astPath,
-        ...metadata && { metadata },
-        ...tags && { tags },
-        ...links && isNonEmptyArray(links) && { links }
-      };
+        metadata,
+        tags,
+        links: isNonEmptyArray(links) ? links : null
+      });
     }
     _resolveRelationSource(node) {
       if (isDefined(node.source)) {
@@ -126,12 +123,17 @@ ${error}`, {
         invariant(FqnRef.isModelRef(source) || FqnRef.isImportRef(source), "Relation source must be a model reference");
         return source;
       }
-      if (!ast.isElementBody(node.$container)) {
-        throw new Error("RelationRefError: Invalid container for sourceless relation");
+      if (ast.isElementBody(node.$container)) {
+        return {
+          model: this.resolveFqn(node.$container.$container)
+        };
+      }
+      if (ast.isExtendElementBody(node.$container)) {
+        return {
+          model: this.resolveFqn(node.$container.$container)
+        };
       }
-      return {
-        model: this.resolveFqn(node.$container.$container)
-      };
+      throw new Error("RelationRefError: Invalid container for sourceless relation");
     }
     parseRelation(astNode) {
       const isValid = this.isValid;
@@ -156,35 +158,33 @@ ${error}`, {
         filter(isTruthy),
         first()
       );
-      const { title = "", ...descAndTech } = this.parseTitleDescriptionTechnology(
+      const { title = "", description, technology } = this.parseBaseProps(bodyProps, {
         // inline props
-        {
-          title: astNode.title,
-          description: astNode.description,
-          technology: astNode.technology
-        },
-        bodyProps
-      );
+        title: astNode.title,
+        description: astNode.description,
+        technology: astNode.technology
+      });
       const styleProp = astNode.body?.props.find(ast.isRelationStyleProperty);
       const id = stringHash(
         astPath,
         source.model,
         target.model
       );
-      return {
+      return exact({
         id,
         astPath,
         source,
         target,
         title,
-        ...metadata && { metadata },
-        ...descAndTech,
-        ...kind && { kind },
-        ...tags && { tags },
-        ...isNonEmptyArray(links) && { links },
-        ...toRelationshipStyleExcludeDefaults(styleProp?.props, isValid),
-        ...navigateTo && { navigateTo }
-      };
+        metadata,
+        kind,
+        tags: tags ?? void 0,
+        links: isNonEmptyArray(links) ? links : void 0,
+        navigateTo: navigateTo ? navigateTo : void 0,
+        description,
+        technology,
+        ...toRelationshipStyle(styleProp?.props, isValid)
+      });
     }
   };
 }

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

@@ -26,6 +26,7 @@ export declare function PredicatesParser<TBase extends WithExpressionV2>(B: TBas
         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;
@@ -54,16 +55,19 @@ export declare function PredicatesParser<TBase extends WithExpressionV2>(B: TBas
         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;
-        parseTitleDescriptionTechnology(inlineProps: {
-            title?: string | undefined;
-            description?: string | undefined;
-            technology?: string | undefined;
-        }, bodyProps: {
+        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/SpecificationParser.d.ts

@@ -33,16 +33,19 @@ export declare function SpecificationParser<TBase extends Base>(B: TBase): {
         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;
-        parseTitleDescriptionTechnology(inlineProps: {
-            title?: string | undefined;
-            description?: string | undefined;
-            technology?: string | undefined;
-        }, bodyProps: {
+        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;
         };