@likec4/language-server 0.46.1 → 0.48.0

package/contrib/likec4.monarch.ts

@@ -1,16 +1,15 @@
 // Monarch syntax highlighting for the likec4 language.
 export default {
     keywords: [
-        'BottomTop','LeftRight','RightLeft','TopBottom','amber','autoLayout','blue','browser','color','crow','cylinder','dashed','description','diamond','dotted','element','exclude','extend','extends','gray','green','head','icon','include','indigo','it','kind','line','link','mobile','model','muted','none','normal','odiamond','of','onormal','open','person','primary','queue','rectangle','red','relationship','secondary','shape','sky','slate','solid','specification','storage','style','tag','tail','technology','this','title','vee','view','views'
+        'BottomTop','LeftRight','RightLeft','TopBottom','amber','autoLayout','blue','browser','color','crow','cylinder','dashed','description','diamond','dotted','element','exclude','extend','extends','gray','green','head','icon','include','indigo','it','kind','line','link','mobile','model','muted','navigateTo','none','normal','odiamond','of','onormal','open','person','primary','queue','rectangle','red','relationship','secondary','shape','sky','slate','solid','specification','storage','style','tag','tail','technology','this','title','vee','view','views','with'
     ],
     operators: [
         '*'
     ],
-    symbols: /\*|-\[|\]->/,
+    symbols: /\*|-\[|\]->|\{|\}/,
 
     tokenizer: {
         initial: [
-            { regex: /#/, action: {"token":"HASH"} },
             { regex: /_/, action: {"token":"UNDERSCORE"} },
             { regex: /-/, action: {"token":"DASH"} },
             { regex: /[^\W\d_]/, action: { cases: { '@keywords': {"token":"keyword"}, '@default': {"token":"LETTER"} }} },
@@ -20,17 +19,15 @@ export default {
             { regex: /\.{0,2}\/[^\/]\S+/, action: {"token":"URI_RELATIVE"} },
             { regex: /->/, action: {"token":"RArrow"} },
             { regex: /\b\.\*/, action: {"token":"DotWildcard"} },
+            { regex: /\#\b/, action: {"token":"TagHash"} },
             { regex: /\b\./, action: {"token":"Dot"} },
-            { regex: /!=/, action: {"token":"NotEqual"} },
+            { regex: /\!\={1,2}/, action: {"token":"NotEqual"} },
             { regex: /\={1,2}/, action: {"token":"Eq"} },
-            { regex: /\{/, action: {"token":"OpenBlock"} },
-            { regex: /\}/, action: {"token":"CloseBlock"} },
             { regex: /:/, action: {"token":"Colon"} },
             { regex: /;/, action: {"token":"SemiColon"} },
             { regex: /,/, action: {"token":"Comma"} },
             { regex: /"[^"]*"|'[^']*'/, action: {"token":"string"} },
-            { regex: /((#)([^\W\d_])(((([^\W\d_])|([0-9]))|(_))|(-))*)/, action: {"token":"TagID"} },
-            { regex: /((([^\W\d_])|(_))(((([^\W\d_])|([0-9]))|(_))|(-))*)/, action: { cases: { '@keywords': {"token":"keyword"}, '@default': {"token":"ID"} }} },
+            { regex: /((([^\W\d_])|((_)+(([^\W\d_])|([0-9]))))(((([^\W\d_])|([0-9]))|(_))|(-))*)/, action: { cases: { '@keywords': {"token":"keyword"}, '@default': {"token":"ID"} }} },
             { include: '@whitespace' },
             { regex: /@symbols/, action: { cases: { '@operators': {"token":"operator"}, '@default': {"token":""} }} },
         ],

package/contrib/likec4.tmLanguage.json

@@ -12,7 +12,7 @@
     },
     {
       "name": "keyword.control.likec4",
-      "match": "\\b(BottomTop|LeftRight|RightLeft|TopBottom|amber|autoLayout|blue|browser|color|crow|cylinder|dashed|description|diamond|dotted|element|exclude|extend|extends|gray|green|head|icon|include|indigo|it|kind|line|link|mobile|model|muted|none|normal|odiamond|of|onormal|open|person|primary|queue|rectangle|red|relationship|secondary|shape|sky|slate|solid|specification|storage|style|tag|tail|technology|this|title|vee|view|views)\\b"
+      "match": "\\b(BottomTop|LeftRight|RightLeft|TopBottom|amber|autoLayout|blue|browser|color|crow|cylinder|dashed|description|diamond|dotted|element|exclude|extend|extends|gray|green|head|icon|include|indigo|it|kind|line|link|mobile|model|muted|navigateTo|none|normal|odiamond|of|onormal|open|person|primary|queue|rectangle|red|relationship|secondary|shape|sky|slate|solid|specification|storage|style|tag|tail|technology|this|title|vee|view|views|with)\\b"
     },
     {
       "name": "string.quoted.double.likec4",

package/dist/ast.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="react" />
 import { type c4 } from '@likec4/core';
 import type { LangiumDocument, MultiMap } from 'langium';
+import type { SetRequired } from 'type-fest';
 import type { LikeC4Grammar } from './generated/ast';
 import * as ast from './generated/ast';
 export { ast };
@@ -81,8 +82,12 @@ export interface LikeC4DocumentProps {
 }
 export interface LikeC4LangiumDocument extends LangiumDocument<LikeC4Grammar>, LikeC4DocumentProps {
 }
-export type ParsedLikeC4LangiumDocument = Omit<LikeC4LangiumDocument, keyof LikeC4DocumentProps> & Required<LikeC4DocumentProps>;
+export interface FqnIndexedDocument extends LangiumDocument<LikeC4Grammar>, SetRequired<LikeC4DocumentProps, 'c4fqns'> {
+}
+export interface ParsedLikeC4LangiumDocument extends LangiumDocument<LikeC4Grammar>, Required<LikeC4DocumentProps> {
+}
 export declare function cleanParsedModel(doc: LikeC4LangiumDocument): ParsedLikeC4LangiumDocument;
+export declare function isFqnIndexedDocument(doc: LangiumDocument): doc is FqnIndexedDocument;
 export declare function isLikeC4LangiumDocument(doc: LangiumDocument): doc is LikeC4LangiumDocument;
 export declare function isParsedLikeC4LangiumDocument(doc: LangiumDocument): doc is ParsedLikeC4LangiumDocument;
 export declare const isValidLikeC4LangiumDocument: (doc: LangiumDocument) => doc is ParsedLikeC4LangiumDocument;
@@ -91,7 +96,7 @@ export declare function resolveRelationPoints(node: ast.Relation): {
     source: ast.Element;
     target: ast.Element;
 };
-export declare function toElementStyle(props?: ast.StyleProperties['props']): {
+export declare function toElementStyle(props?: Array<ast.StyleProperty>): {
     color?: c4.ThemeColor;
     shape?: c4.ElementShape;
     icon?: c4.IconUrl;
@@ -113,5 +118,5 @@ export declare function toRelationshipStyleExcludeDefaults(props?: ast.Specifica
     line?: "dotted" | "solid";
     color?: "amber" | "blue" | "green" | "indigo" | "muted" | "primary" | "red" | "secondary" | "sky" | "slate";
 };
-export declare function toAutoLayout(direction: ast.ViewRuleLayoutDirection): c4.ViewRuleAutoLayout['autoLayout'];
+export declare function toAutoLayout(direction: ast.ViewLayoutDirection): c4.ViewRuleAutoLayout['autoLayout'];
 //# sourceMappingURL=ast.d.ts.map

package/dist/ast.js

@@ -1,17 +1,18 @@
 import {
+  DefaultArrowType,
   DefaultElementShape,
+  DefaultLineStyle,
+  DefaultRelationshipColor,
   DefaultThemeColor,
   RelationRefError,
-  nonexhaustive,
-  DefaultLineStyle,
-  DefaultArrowType,
-  DefaultRelationshipColor
+  nonexhaustive
 } from "@likec4/core";
 import { DocumentState } from "langium";
+import { isNil } from "remeda";
 import { elementRef } from "./elementRef.js";
 import * as ast from "./generated/ast.js";
 import { LikeC4LanguageMetaData } from "./generated/module.js";
-import { isNil } from "remeda";
+import { DiagnosticSeverity } from "vscode-languageserver-protocol";
 export { ast };
 const idattr = Symbol.for("idattr");
 export const ElementViewOps = {
@@ -49,17 +50,20 @@ export function cleanParsedModel(doc) {
   Object.assign(doc, props);
   return doc;
 }
+export function isFqnIndexedDocument(doc) {
+  return isLikeC4LangiumDocument(doc) && doc.state >= DocumentState.IndexedContent && !isNil(doc.c4fqns);
+}
 export function isLikeC4LangiumDocument(doc) {
   return doc.textDocument.languageId === LikeC4LanguageMetaData.languageId;
 }
 export function isParsedLikeC4LangiumDocument(doc) {
-  return isLikeC4LangiumDocument(doc) && doc.state >= DocumentState.Validated && !!doc.c4Specification && !!doc.c4Elements && !!doc.c4Relations && !!doc.c4Views && !!doc.c4fqns;
+  return isLikeC4LangiumDocument(doc) && doc.state == DocumentState.Validated && !!doc.c4Specification && !!doc.c4Elements && !!doc.c4Relations && !!doc.c4Views && !!doc.c4fqns;
 }
 export const isValidLikeC4LangiumDocument = (doc) => {
   if (!isParsedLikeC4LangiumDocument(doc))
     return false;
-  const { state, parseResult, diagnostics } = doc;
-  return state === DocumentState.Validated && parseResult.lexerErrors.length === 0 && (!diagnostics || diagnostics.every((d) => d.severity !== 1));
+  const { parseResult, diagnostics } = doc;
+  return parseResult.lexerErrors.length === 0 && (!diagnostics || diagnostics.every((d) => d.severity !== DiagnosticSeverity.Error));
 };
 export function* streamModel(doc) {
   const elements = doc.parseResult.value.models.flatMap((m) => m.elements);

package/dist/generated/ast.d.ts

@@ -12,31 +12,26 @@ export declare const LikeC4Terminals: {
     URI_RELATIVE: RegExp;
     RArrow: RegExp;
     DotWildcard: RegExp;
+    TagHash: RegExp;
     Dot: RegExp;
     NotEqual: RegExp;
     Eq: RegExp;
-    OpenBlock: RegExp;
-    CloseBlock: RegExp;
     Colon: RegExp;
     SemiColon: RegExp;
     Comma: RegExp;
     String: RegExp;
-    TagID: RegExp;
     ID: RegExp;
 };
 export type ArrowType = 'crow' | 'diamond' | 'none' | 'normal' | 'odiamond' | 'onormal' | 'open' | 'vee';
 export declare function isArrowType(item: unknown): item is ArrowType;
-export type ElementExpression = ElementKindExpression | ElementRefExpression | ElementTagExpression | WildcardExpression;
-export declare const ElementExpression = "ElementExpression";
-export declare function isElementExpression(item: unknown): item is ElementExpression;
+export type ElementExpr = DescedantsExpr | ElementKindExpr | ElementRef | ElementTagExpr | WildcardExpr;
+export declare const ElementExpr = "ElementExpr";
+export declare function isElementExpr(item: unknown): item is ElementExpr;
 export type ElementProperty = ElementStringProperty | LinkProperty | StyleProperties;
 export declare const ElementProperty = "ElementProperty";
 export declare function isElementProperty(item: unknown): item is ElementProperty;
 export type ElementShape = 'browser' | 'cylinder' | 'mobile' | 'person' | 'queue' | 'rectangle' | 'storage';
 export declare function isElementShape(item: unknown): item is ElementShape;
-export type Expression = ElementExpression | InOutExpression | IncomingExpression | OutgoingExpression | RelationExpression;
-export declare const Expression = "Expression";
-export declare function isExpression(item: unknown): item is Expression;
 export type LineOptions = 'dashed' | 'dotted' | 'solid';
 export declare function isLineOptions(item: unknown): item is LineOptions;
 export type Name = 'element' | 'model' | ArrowType | ElementShape | LineOptions | ThemeColor | string;
@@ -44,18 +39,32 @@ export declare function isName(item: unknown): item is Name;
 export type Relation = ExplicitRelation | ImplicitRelation;
 export declare const Relation = "Relation";
 export declare function isRelation(item: unknown): item is Relation;
+export type RelationshipStyleProperty = ArrowProperty | ColorProperty | LineProperty;
+export declare const RelationshipStyleProperty = "RelationshipStyleProperty";
+export declare function isRelationshipStyleProperty(item: unknown): item is RelationshipStyleProperty;
+export type StyleProperty = ColorProperty | IconProperty | ShapeProperty;
+export declare const StyleProperty = "StyleProperty";
+export declare function isStyleProperty(item: unknown): item is StyleProperty;
+export type TagID = string;
+export declare function isTagID(item: unknown): item is TagID;
 export type ThemeColor = 'amber' | 'blue' | 'gray' | 'green' | 'indigo' | 'muted' | 'primary' | 'red' | 'secondary' | 'sky' | 'slate';
 export declare function isThemeColor(item: unknown): item is ThemeColor;
 export type Uri = string;
 export declare function isUri(item: unknown): item is Uri;
-export type View = ElementView;
-export declare const View = "View";
-export declare function isView(item: unknown): item is View;
-export type ViewRule = ViewRuleAutoLayout | ViewRuleExpression | ViewRuleStyle;
+export type ViewLayoutDirection = 'BottomTop' | 'LeftRight' | 'RightLeft' | 'TopBottom';
+export declare function isViewLayoutDirection(item: unknown): item is ViewLayoutDirection;
+export type ViewProperty = LinkProperty | ViewStringProperty;
+export declare const ViewProperty = "ViewProperty";
+export declare function isViewProperty(item: unknown): item is ViewProperty;
+export type ViewRule = ViewRuleAutoLayout | ViewRulePredicate | ViewRuleStyle;
 export declare const ViewRule = "ViewRule";
 export declare function isViewRule(item: unknown): item is ViewRule;
-export type ViewRuleLayoutDirection = 'BottomTop' | 'LeftRight' | 'RightLeft' | 'TopBottom';
-export declare function isViewRuleLayoutDirection(item: unknown): item is ViewRuleLayoutDirection;
+export type ViewRulePredicate = ExcludePredicate | IncludePredicate;
+export declare const ViewRulePredicate = "ViewRulePredicate";
+export declare function isViewRulePredicate(item: unknown): item is ViewRulePredicate;
+export type ViewRulePredicateExpr = CustomElementExpr | ElementExpr | InOutExpr | IncomingExpr | OutgoingExpr | RelationExpr;
+export declare const ViewRulePredicateExpr = "ViewRulePredicateExpr";
+export declare function isViewRulePredicateExpr(item: unknown): item is ViewRulePredicateExpr;
 export interface ArrowProperty extends AstNode {
     readonly $container: SpecificationRelationshipKind;
     readonly $type: 'ArrowProperty';
@@ -65,13 +74,35 @@ export interface ArrowProperty extends AstNode {
 export declare const ArrowProperty = "ArrowProperty";
 export declare function isArrowProperty(item: unknown): item is ArrowProperty;
 export interface ColorProperty extends AstNode {
-    readonly $container: SpecificationRelationshipKind | StyleProperties | ViewRuleStyle;
+    readonly $container: CustomElementExprBody | SpecificationRelationshipKind | StyleProperties | ViewRuleStyle;
     readonly $type: 'ColorProperty';
     key: 'color';
     value: ThemeColor;
 }
 export declare const ColorProperty = "ColorProperty";
 export declare function isColorProperty(item: unknown): item is ColorProperty;
+export interface CustomElementExpr extends AstNode {
+    readonly $container: ExcludePredicate | IncludePredicate;
+    readonly $type: 'CustomElementExpr';
+    body: CustomElementExprBody;
+    target: ElementExpr;
+}
+export declare const CustomElementExpr = "CustomElementExpr";
+export declare function isCustomElementExpr(item: unknown): item is CustomElementExpr;
+export interface CustomElementExprBody extends AstNode {
+    readonly $container: CustomElementExpr;
+    readonly $type: 'CustomElementExprBody';
+    props: Array<ColorProperty | ElementStringProperty | NavigateToProperty | ShapeProperty>;
+}
+export declare const CustomElementExprBody = "CustomElementExprBody";
+export declare function isCustomElementExprBody(item: unknown): item is CustomElementExprBody;
+export interface DescedantsExpr extends AstNode {
+    readonly $container: CustomElementExpr | ExcludePredicate | IncludePredicate | IncomingExpr | OutgoingExpr | RelationExpr | ViewRuleStyle;
+    readonly $type: 'DescedantsExpr';
+    parent: ElementRef;
+}
+export declare const DescedantsExpr = "DescedantsExpr";
+export declare function isDescedantsExpr(item: unknown): item is DescedantsExpr;
 export interface Element extends AstNode {
     readonly $container: ElementBody | ExtendElementBody | Model;
     readonly $type: 'Element';
@@ -98,46 +129,38 @@ export interface ElementKind extends AstNode {
 }
 export declare const ElementKind = "ElementKind";
 export declare function isElementKind(item: unknown): item is ElementKind;
-export interface ElementKindExpression extends AstNode {
-    readonly $container: IncomingExpression | OutgoingExpression | RelationExpression | ViewRuleExpression | ViewRuleStyle;
-    readonly $type: 'ElementKindExpression';
+export interface ElementKindExpr extends AstNode {
+    readonly $container: CustomElementExpr | ExcludePredicate | IncludePredicate | IncomingExpr | OutgoingExpr | RelationExpr | ViewRuleStyle;
+    readonly $type: 'ElementKindExpr';
     isEqual: boolean;
     kind: Reference<ElementKind>;
 }
-export declare const ElementKindExpression = "ElementKindExpression";
-export declare function isElementKindExpression(item: unknown): item is ElementKindExpression;
+export declare const ElementKindExpr = "ElementKindExpr";
+export declare function isElementKindExpr(item: unknown): item is ElementKindExpr;
 export interface ElementRef extends AstNode {
-    readonly $container: ElementRef | ElementRefExpression | ElementView | ExplicitRelation | ImplicitRelation;
+    readonly $container: CustomElementExpr | DescedantsExpr | ElementRef | ElementView | ExcludePredicate | ExplicitRelation | ImplicitRelation | IncludePredicate | IncomingExpr | OutgoingExpr | RelationExpr | ViewRuleStyle;
     readonly $type: 'ElementRef';
     el: Reference<Element>;
     parent?: ElementRef;
 }
 export declare const ElementRef = "ElementRef";
 export declare function isElementRef(item: unknown): item is ElementRef;
-export interface ElementRefExpression extends AstNode {
-    readonly $container: IncomingExpression | OutgoingExpression | RelationExpression | ViewRuleExpression | ViewRuleStyle;
-    readonly $type: 'ElementRefExpression';
-    id: ElementRef;
-    isDescedants: boolean;
-}
-export declare const ElementRefExpression = "ElementRefExpression";
-export declare function isElementRefExpression(item: unknown): item is ElementRefExpression;
 export interface ElementStringProperty extends AstNode {
-    readonly $container: ElementBody;
+    readonly $container: CustomElementExprBody | ElementBody;
     readonly $type: 'ElementStringProperty';
     key: 'description' | 'technology' | 'title';
     value: string;
 }
 export declare const ElementStringProperty = "ElementStringProperty";
 export declare function isElementStringProperty(item: unknown): item is ElementStringProperty;
-export interface ElementTagExpression extends AstNode {
-    readonly $container: IncomingExpression | OutgoingExpression | RelationExpression | ViewRuleExpression | ViewRuleStyle;
-    readonly $type: 'ElementTagExpression';
+export interface ElementTagExpr extends AstNode {
+    readonly $container: CustomElementExpr | ExcludePredicate | IncludePredicate | IncomingExpr | OutgoingExpr | RelationExpr | ViewRuleStyle;
+    readonly $type: 'ElementTagExpr';
     isEqual: boolean;
     tag: Reference<Tag>;
 }
-export declare const ElementTagExpression = "ElementTagExpression";
-export declare function isElementTagExpression(item: unknown): item is ElementTagExpression;
+export declare const ElementTagExpr = "ElementTagExpr";
+export declare function isElementTagExpr(item: unknown): item is ElementTagExpr;
 export interface ElementView extends AstNode {
     readonly $container: ModelViews;
     readonly $type: 'ElementView';
@@ -151,19 +174,26 @@ export declare function isElementView(item: unknown): item is ElementView;
 export interface ElementViewBody extends AstNode {
     readonly $container: ElementView;
     readonly $type: 'ElementViewBody';
-    props: Array<LinkProperty | ViewProperty>;
-    rules: Array<ViewRuleAutoLayout | ViewRuleExpression | ViewRuleStyle>;
+    props: Array<ViewProperty>;
+    rules: Array<ViewRule>;
     tags?: Tags;
 }
 export declare const ElementViewBody = "ElementViewBody";
 export declare function isElementViewBody(item: unknown): item is ElementViewBody;
 export interface ElementViewRef extends AstNode {
-    readonly $container: ElementView;
+    readonly $container: ElementView | NavigateToProperty;
     readonly $type: 'ElementViewRef';
     view: Reference<ElementView>;
 }
 export declare const ElementViewRef = "ElementViewRef";
 export declare function isElementViewRef(item: unknown): item is ElementViewRef;
+export interface ExcludePredicate extends AstNode {
+    readonly $container: ElementViewBody;
+    readonly $type: 'ExcludePredicate';
+    expressions: Array<ViewRulePredicateExpr>;
+}
+export declare const ExcludePredicate = "ExcludePredicate";
+export declare function isExcludePredicate(item: unknown): item is ExcludePredicate;
 export interface ExplicitRelation extends AstNode {
     readonly $container: ElementBody | ExtendElementBody | Model;
     readonly $type: 'ExplicitRelation';
@@ -218,20 +248,27 @@ export interface ImplicitRelation extends AstNode {
 }
 export declare const ImplicitRelation = "ImplicitRelation";
 export declare function isImplicitRelation(item: unknown): item is ImplicitRelation;
-export interface IncomingExpression extends AstNode {
-    readonly $container: InOutExpression | ViewRuleExpression;
-    readonly $type: 'IncomingExpression';
-    target: ElementExpression;
-}
-export declare const IncomingExpression = "IncomingExpression";
-export declare function isIncomingExpression(item: unknown): item is IncomingExpression;
-export interface InOutExpression extends AstNode {
-    readonly $container: ViewRuleExpression;
-    readonly $type: 'InOutExpression';
-    inout: IncomingExpression;
-}
-export declare const InOutExpression = "InOutExpression";
-export declare function isInOutExpression(item: unknown): item is InOutExpression;
+export interface IncludePredicate extends AstNode {
+    readonly $container: ElementViewBody;
+    readonly $type: 'IncludePredicate';
+    expressions: Array<ViewRulePredicateExpr>;
+}
+export declare const IncludePredicate = "IncludePredicate";
+export declare function isIncludePredicate(item: unknown): item is IncludePredicate;
+export interface IncomingExpr extends AstNode {
+    readonly $container: ExcludePredicate | InOutExpr | IncludePredicate;
+    readonly $type: 'IncomingExpr';
+    to: ElementExpr;
+}
+export declare const IncomingExpr = "IncomingExpr";
+export declare function isIncomingExpr(item: unknown): item is IncomingExpr;
+export interface InOutExpr extends AstNode {
+    readonly $container: ExcludePredicate | IncludePredicate;
+    readonly $type: 'InOutExpr';
+    inout: IncomingExpr;
+}
+export declare const InOutExpr = "InOutExpr";
+export declare function isInOutExpr(item: unknown): item is InOutExpr;
 export interface LikeC4Grammar extends AstNode {
     readonly $type: 'LikeC4Grammar';
     models: Array<Model>;
@@ -268,25 +305,32 @@ export interface ModelViews extends AstNode {
     readonly $container: LikeC4Grammar;
     readonly $type: 'ModelViews';
     name: 'views';
-    views: Array<View>;
+    views: Array<ElementView>;
 }
 export declare const ModelViews = "ModelViews";
 export declare function isModelViews(item: unknown): item is ModelViews;
-export interface OutgoingExpression extends AstNode {
-    readonly $container: ViewRuleExpression;
-    readonly $type: 'OutgoingExpression';
-    source: ElementExpression;
-}
-export declare const OutgoingExpression = "OutgoingExpression";
-export declare function isOutgoingExpression(item: unknown): item is OutgoingExpression;
-export interface RelationExpression extends AstNode {
-    readonly $container: ViewRuleExpression;
-    readonly $type: 'RelationExpression';
-    source: ElementExpression;
-    target: ElementExpression;
-}
-export declare const RelationExpression = "RelationExpression";
-export declare function isRelationExpression(item: unknown): item is RelationExpression;
+export interface NavigateToProperty extends AstNode {
+    readonly $container: CustomElementExprBody;
+    readonly $type: 'NavigateToProperty';
+    value: ElementViewRef;
+}
+export declare const NavigateToProperty = "NavigateToProperty";
+export declare function isNavigateToProperty(item: unknown): item is NavigateToProperty;
+export interface OutgoingExpr extends AstNode {
+    readonly $container: ExcludePredicate | IncludePredicate;
+    readonly $type: 'OutgoingExpr';
+    from: ElementExpr;
+}
+export declare const OutgoingExpr = "OutgoingExpr";
+export declare function isOutgoingExpr(item: unknown): item is OutgoingExpr;
+export interface RelationExpr extends AstNode {
+    readonly $container: ExcludePredicate | IncludePredicate;
+    readonly $type: 'RelationExpr';
+    source: ElementExpr;
+    target: ElementExpr;
+}
+export declare const RelationExpr = "RelationExpr";
+export declare function isRelationExpr(item: unknown): item is RelationExpr;
 export interface RelationshipKind extends AstNode {
     readonly $container: SpecificationRelationshipKind;
     readonly $type: 'RelationshipKind';
@@ -303,7 +347,7 @@ export interface RelationStringProperty extends AstNode {
 export declare const RelationStringProperty = "RelationStringProperty";
 export declare function isRelationStringProperty(item: unknown): item is RelationStringProperty;
 export interface ShapeProperty extends AstNode {
-    readonly $container: StyleProperties | ViewRuleStyle;
+    readonly $container: CustomElementExprBody | StyleProperties | ViewRuleStyle;
     readonly $type: 'ShapeProperty';
     key: 'shape';
     value: ElementShape;
@@ -322,7 +366,7 @@ export interface SpecificationRelationshipKind extends AstNode {
     readonly $container: SpecificationRule;
     readonly $type: 'SpecificationRelationshipKind';
     kind: RelationshipKind;
-    props: Array<ArrowProperty | ColorProperty | LineProperty>;
+    props: Array<RelationshipStyleProperty>;
 }
 export declare const SpecificationRelationshipKind = "SpecificationRelationshipKind";
 export declare function isSpecificationRelationshipKind(item: unknown): item is SpecificationRelationshipKind;
@@ -339,16 +383,15 @@ export declare function isSpecificationRule(item: unknown): item is Specificatio
 export interface SpecificationTag extends AstNode {
     readonly $container: SpecificationRule;
     readonly $type: 'SpecificationTag';
-    style?: StyleProperties;
     tag: Tag;
 }
 export declare const SpecificationTag = "SpecificationTag";
 export declare function isSpecificationTag(item: unknown): item is SpecificationTag;
 export interface StyleProperties extends AstNode {
-    readonly $container: ElementBody | SpecificationElementKind | SpecificationTag;
+    readonly $container: ElementBody | SpecificationElementKind;
     readonly $type: 'StyleProperties';
     key: 'style';
-    props: Array<ColorProperty | IconProperty | ShapeProperty>;
+    props: Array<StyleProperty>;
 }
 export declare const StyleProperties = "StyleProperties";
 export declare function isStyleProperties(item: unknown): item is StyleProperties;
@@ -366,94 +409,93 @@ export interface Tags extends AstNode {
 }
 export declare const Tags = "Tags";
 export declare function isTags(item: unknown): item is Tags;
-export interface ViewProperty extends AstNode {
-    readonly $container: ElementViewBody;
-    readonly $type: 'ViewProperty';
-    key: 'description' | 'title';
-    value: string;
-}
-export declare const ViewProperty = "ViewProperty";
-export declare function isViewProperty(item: unknown): item is ViewProperty;
 export interface ViewRuleAutoLayout extends AstNode {
     readonly $container: ElementViewBody;
     readonly $type: 'ViewRuleAutoLayout';
-    direction: ViewRuleLayoutDirection;
+    direction: ViewLayoutDirection;
 }
 export declare const ViewRuleAutoLayout = "ViewRuleAutoLayout";
 export declare function isViewRuleAutoLayout(item: unknown): item is ViewRuleAutoLayout;
-export interface ViewRuleExpression extends AstNode {
-    readonly $container: ElementViewBody;
-    readonly $type: 'ViewRuleExpression';
-    expressions: Array<Expression>;
-    isInclude: boolean;
-}
-export declare const ViewRuleExpression = "ViewRuleExpression";
-export declare function isViewRuleExpression(item: unknown): item is ViewRuleExpression;
 export interface ViewRuleStyle extends AstNode {
     readonly $container: ElementViewBody;
     readonly $type: 'ViewRuleStyle';
-    props: Array<ColorProperty | IconProperty | ShapeProperty>;
-    targets: Array<ElementExpression>;
+    styleprops: Array<StyleProperty>;
+    targets: Array<ElementExpr>;
 }
 export declare const ViewRuleStyle = "ViewRuleStyle";
 export declare function isViewRuleStyle(item: unknown): item is ViewRuleStyle;
-export interface WildcardExpression extends AstNode {
-    readonly $container: IncomingExpression | OutgoingExpression | RelationExpression | ViewRuleExpression | ViewRuleStyle;
-    readonly $type: 'WildcardExpression';
+export interface ViewStringProperty extends AstNode {
+    readonly $container: ElementViewBody;
+    readonly $type: 'ViewStringProperty';
+    key: 'description' | 'title';
+    value: string;
+}
+export declare const ViewStringProperty = "ViewStringProperty";
+export declare function isViewStringProperty(item: unknown): item is ViewStringProperty;
+export interface WildcardExpr extends AstNode {
+    readonly $container: CustomElementExpr | ExcludePredicate | IncludePredicate | IncomingExpr | OutgoingExpr | RelationExpr | ViewRuleStyle;
+    readonly $type: 'WildcardExpr';
     isWildcard: boolean;
 }
-export declare const WildcardExpression = "WildcardExpression";
-export declare function isWildcardExpression(item: unknown): item is WildcardExpression;
+export declare const WildcardExpr = "WildcardExpr";
+export declare function isWildcardExpr(item: unknown): item is WildcardExpr;
 export type LikeC4AstType = {
     ArrowProperty: ArrowProperty;
     ColorProperty: ColorProperty;
+    CustomElementExpr: CustomElementExpr;
+    CustomElementExprBody: CustomElementExprBody;
+    DescedantsExpr: DescedantsExpr;
     Element: Element;
     ElementBody: ElementBody;
-    ElementExpression: ElementExpression;
+    ElementExpr: ElementExpr;
     ElementKind: ElementKind;
-    ElementKindExpression: ElementKindExpression;
+    ElementKindExpr: ElementKindExpr;
     ElementProperty: ElementProperty;
     ElementRef: ElementRef;
-    ElementRefExpression: ElementRefExpression;
     ElementStringProperty: ElementStringProperty;
-    ElementTagExpression: ElementTagExpression;
+    ElementTagExpr: ElementTagExpr;
     ElementView: ElementView;
     ElementViewBody: ElementViewBody;
     ElementViewRef: ElementViewRef;
+    ExcludePredicate: ExcludePredicate;
     ExplicitRelation: ExplicitRelation;
-    Expression: Expression;
     ExtendElement: ExtendElement;
     ExtendElementBody: ExtendElementBody;
     FqnElementRef: FqnElementRef;
     IconProperty: IconProperty;
     ImplicitRelation: ImplicitRelation;
-    InOutExpression: InOutExpression;
-    IncomingExpression: IncomingExpression;
+    InOutExpr: InOutExpr;
+    IncludePredicate: IncludePredicate;
+    IncomingExpr: IncomingExpr;
     LikeC4Grammar: LikeC4Grammar;
     LineProperty: LineProperty;
     LinkProperty: LinkProperty;
     Model: Model;
     ModelViews: ModelViews;
-    OutgoingExpression: OutgoingExpression;
+    NavigateToProperty: NavigateToProperty;
+    OutgoingExpr: OutgoingExpr;
     Relation: Relation;
-    RelationExpression: RelationExpression;
+    RelationExpr: RelationExpr;
     RelationStringProperty: RelationStringProperty;
     RelationshipKind: RelationshipKind;
+    RelationshipStyleProperty: RelationshipStyleProperty;
     ShapeProperty: ShapeProperty;
     SpecificationElementKind: SpecificationElementKind;
     SpecificationRelationshipKind: SpecificationRelationshipKind;
     SpecificationRule: SpecificationRule;
     SpecificationTag: SpecificationTag;
     StyleProperties: StyleProperties;
+    StyleProperty: StyleProperty;
     Tag: Tag;
     Tags: Tags;
-    View: View;
     ViewProperty: ViewProperty;
     ViewRule: ViewRule;
     ViewRuleAutoLayout: ViewRuleAutoLayout;
-    ViewRuleExpression: ViewRuleExpression;
+    ViewRulePredicate: ViewRulePredicate;
+    ViewRulePredicateExpr: ViewRulePredicateExpr;
     ViewRuleStyle: ViewRuleStyle;
-    WildcardExpression: WildcardExpression;
+    ViewStringProperty: ViewStringProperty;
+    WildcardExpr: WildcardExpr;
 };
 export declare class LikeC4AstReflection extends AbstractAstReflection {
     getAllTypes(): string[];