@likec4/language-server 1.4.0 → 1.6.0

package/src/generated/ast.ts

@@ -11,6 +11,7 @@ export const LikeC4Terminals = {
     BLOCK_COMMENT: /\/\*[\s\S]*?\*\//,
     LINE_COMMENT: /\/\/[^\n\r]*/,
     WS: /\s+/,
+    LIB_ICON: /\b(aws|gcp|tech):[-\w]*/,
     URI_WITH_SCHEMA: /\w+:\/\/\S+/,
     URI_RELATIVE: /\.{0,2}\/[^\/]\S+/,
     DotUnderscore: /\b\._/,
@@ -20,18 +21,15 @@ export const LikeC4Terminals = {
     Dot: /\./,
     NotEqual: /\!\={1,2}/,
     Eq: /\={1,2}/,
-    Colon: /:/,
-    SemiColon: /;/,
-    Comma: /,/,
     Percent: /\b\d+%/,
     String: /"[^"]*"|'[^']*'/,
-    IdTerminal: /\b[_]*[a-zA-Z][_-\w]*/,
+    IdTerminal: /[_]*[a-zA-Z][-\w]*/,
 };
 
-export type ArrowType = 'crow' | 'diamond' | 'none' | 'normal' | 'odiamond' | 'onormal' | 'open' | 'vee';
+export type ArrowType = 'crow' | 'diamond' | 'dot' | 'none' | 'normal' | 'odiamond' | 'odot' | 'onormal' | 'open' | 'vee';
 
 export function isArrowType(item: unknown): item is ArrowType {
-    return item === 'none' || item === 'normal' || item === 'onormal' || item === 'diamond' || item === 'odiamond' || item === 'crow' || item === 'open' || item === 'vee';
+    return item === 'none' || item === 'normal' || item === 'onormal' || item === 'dot' || item === 'odot' || item === 'diamond' || item === 'odiamond' || item === 'crow' || item === 'open' || item === 'vee';
 }
 
 export type BorderStyleValue = 'none' | LineOptions;
@@ -46,6 +44,14 @@ export function isDotId(item: unknown): item is DotId {
     return typeof item === 'string';
 }
 
+export type DynamicViewElementExpression = CustomElementExpression | ElementExpression;
+
+export const DynamicViewElementExpression = 'DynamicViewElementExpression';
+
+export function isDynamicViewElementExpression(item: unknown): item is DynamicViewElementExpression {
+    return reflection.isInstance(item, DynamicViewElementExpression);
+}
+
 export type DynamicViewRule = DynamicViewRulePredicate | ViewRuleAutoLayout | ViewRuleStyle;
 
 export const DynamicViewRule = 'DynamicViewRule';
@@ -54,15 +60,15 @@ export function isDynamicViewRule(item: unknown): item is DynamicViewRule {
     return reflection.isInstance(item, DynamicViewRule);
 }
 
-export type ElementExpr = DescedantsExpr | ElementKindExpr | ElementRef | ElementTagExpr | ExpandElementExpr | WildcardExpr;
+export type ElementExpression = ElementDescedantsExpression | ElementKindExpression | ElementRef | ElementTagExpression | ExpandElementExpression | WildcardExpression;
 
-export const ElementExpr = 'ElementExpr';
+export const ElementExpression = 'ElementExpression';
 
-export function isElementExpr(item: unknown): item is ElementExpr {
-    return reflection.isInstance(item, ElementExpr);
+export function isElementExpression(item: unknown): item is ElementExpression {
+    return reflection.isInstance(item, ElementExpression);
 }
 
-export type ElementProperty = ElementStringProperty | LinkProperty | StyleProperties;
+export type ElementProperty = ElementStringProperty | IconProperty | LinkProperty | StyleProperties;
 
 export const ElementProperty = 'ElementProperty';
 
@@ -76,10 +82,24 @@ export function isElementShape(item: unknown): item is ElementShape {
     return item === 'rectangle' || item === 'person' || item === 'browser' || item === 'mobile' || item === 'cylinder' || item === 'storage' || item === 'queue';
 }
 
+export type Expression = CustomElementExpression | CustomRelationExpression | ElementExpression | RelationExpression;
+
+export const Expression = 'Expression';
+
+export function isExpression(item: unknown): item is Expression {
+    return reflection.isInstance(item, Expression);
+}
+
+export type IconId = string;
+
+export function isIconId(item: unknown): item is IconId {
+    return (typeof item === 'string' && (/\b(aws|gcp|tech):[-\w]*/.test(item)));
+}
+
 export type Id = 'element' | 'model' | ArrowType | ElementShape | LineOptions | ThemeColor | string;
 
 export function isId(item: unknown): item is Id {
-    return isElementShape(item) || isThemeColor(item) || isArrowType(item) || isLineOptions(item) || item === 'element' || item === 'model' || (typeof item === 'string' && (/\b[_]*[a-zA-Z][_-\w]*/.test(item)));
+    return isElementShape(item) || isThemeColor(item) || isArrowType(item) || isLineOptions(item) || item === 'element' || item === 'model' || (typeof item === 'string' && (/[_]*[a-zA-Z][-\w]*/.test(item)));
 }
 
 export type LikeC4View = DynamicView | ElementView;
@@ -104,6 +124,14 @@ export function isRelation(item: unknown): item is Relation {
     return reflection.isInstance(item, Relation);
 }
 
+export type RelationExpression = DirectedRelationExpression | InOutRelationExpression | IncomingRelationExpression | OutgoingRelationExpression;
+
+export const RelationExpression = 'RelationExpression';
+
+export function isRelationExpression(item: unknown): item is RelationExpression {
+    return reflection.isInstance(item, RelationExpression);
+}
+
 export type RelationProperty = LinkProperty | RelationStringProperty | RelationStyleProperty;
 
 export const RelationProperty = 'RelationProperty';
@@ -120,7 +148,7 @@ export function isRelationshipStyleProperty(item: unknown): item is Relationship
     return reflection.isInstance(item, RelationshipStyleProperty);
 }
 
-export type StringProperty = ElementStringProperty | ViewStringProperty;
+export type StringProperty = ElementStringProperty | RelationStringProperty | ViewStringProperty;
 
 export const StringProperty = 'StringProperty';
 
@@ -184,16 +212,8 @@ export function isViewRulePredicate(item: unknown): item is ViewRulePredicate {
     return reflection.isInstance(item, ViewRulePredicate);
 }
 
-export type ViewRulePredicateExpr = CustomElementExpr | ElementExpr | InOutExpr | IncomingExpr | OutgoingExpr | RelationExpr;
-
-export const ViewRulePredicateExpr = 'ViewRulePredicateExpr';
-
-export function isViewRulePredicateExpr(item: unknown): item is ViewRulePredicateExpr {
-    return reflection.isInstance(item, ViewRulePredicateExpr);
-}
-
 export interface ArrowProperty extends AstNode {
-    readonly $container: RelationStyleProperty | SpecificationRelationshipKind;
+    readonly $container: CustomRelationProperties | RelationStyleProperty | SpecificationRelationshipKind;
     readonly $type: 'ArrowProperty';
     key: 'head' | 'tail';
     value: ArrowType;
@@ -206,7 +226,7 @@ export function isArrowProperty(item: unknown): item is ArrowProperty {
 }
 
 export interface BorderProperty extends AstNode {
-    readonly $container: CustomElementExprBody | StyleProperties | ViewRuleStyle;
+    readonly $container: CustomElementProperties | StyleProperties | ViewRuleStyle;
     readonly $type: 'BorderProperty';
     key: 'border';
     value: BorderStyleValue;
@@ -219,7 +239,7 @@ export function isBorderProperty(item: unknown): item is BorderProperty {
 }
 
 export interface ColorProperty extends AstNode {
-    readonly $container: CustomElementExprBody | RelationStyleProperty | SpecificationRelationshipKind | StyleProperties | ViewRuleStyle;
+    readonly $container: CustomElementProperties | CustomRelationProperties | RelationStyleProperty | SpecificationRelationshipKind | StyleProperties | ViewRuleStyle;
     readonly $type: 'ColorProperty';
     key: 'color';
     value: ThemeColor;
@@ -231,41 +251,67 @@ export function isColorProperty(item: unknown): item is ColorProperty {
     return reflection.isInstance(item, ColorProperty);
 }
 
-export interface CustomElementExpr extends AstNode {
-    readonly $container: DynamicViewRulePredicate | ExcludePredicate | IncludePredicate;
-    readonly $type: 'CustomElementExpr';
-    body: CustomElementExprBody;
-    target: ElementExpr;
+export interface CustomElementExpression extends AstNode {
+    readonly $container: DynamicViewRulePredicateIterator | Expressions;
+    readonly $type: 'CustomElementExpression';
+    custom: CustomElementProperties;
+    target: ElementExpression;
 }
 
-export const CustomElementExpr = 'CustomElementExpr';
+export const CustomElementExpression = 'CustomElementExpression';
 
-export function isCustomElementExpr(item: unknown): item is CustomElementExpr {
-    return reflection.isInstance(item, CustomElementExpr);
+export function isCustomElementExpression(item: unknown): item is CustomElementExpression {
+    return reflection.isInstance(item, CustomElementExpression);
 }
 
-export interface CustomElementExprBody extends AstNode {
-    readonly $container: CustomElementExpr;
-    readonly $type: 'CustomElementExprBody';
+export interface CustomElementProperties extends AstNode {
+    readonly $container: CustomElementExpression;
+    readonly $type: 'CustomElementProperties';
     props: Array<ElementStringProperty | NavigateToProperty | StyleProperty>;
 }
 
-export const CustomElementExprBody = 'CustomElementExprBody';
+export const CustomElementProperties = 'CustomElementProperties';
 
-export function isCustomElementExprBody(item: unknown): item is CustomElementExprBody {
-    return reflection.isInstance(item, CustomElementExprBody);
+export function isCustomElementProperties(item: unknown): item is CustomElementProperties {
+    return reflection.isInstance(item, CustomElementProperties);
 }
 
-export interface DescedantsExpr extends AstNode {
-    readonly $container: CustomElementExpr | DynamicViewRulePredicate | ExcludePredicate | IncludePredicate | IncomingExpr | OutgoingExpr | RelationExpr | ViewRuleStyle;
-    readonly $type: 'DescedantsExpr';
-    parent: ElementRef;
+export interface CustomRelationExpression extends AstNode {
+    readonly $container: Expressions;
+    readonly $type: 'CustomRelationExpression';
+    custom: CustomRelationProperties;
+    relation: RelationExpression;
+}
+
+export const CustomRelationExpression = 'CustomRelationExpression';
+
+export function isCustomRelationExpression(item: unknown): item is CustomRelationExpression {
+    return reflection.isInstance(item, CustomRelationExpression);
+}
+
+export interface CustomRelationProperties extends AstNode {
+    readonly $container: CustomRelationExpression;
+    readonly $type: 'CustomRelationProperties';
+    props: Array<RelationStringProperty | RelationshipStyleProperty>;
+}
+
+export const CustomRelationProperties = 'CustomRelationProperties';
+
+export function isCustomRelationProperties(item: unknown): item is CustomRelationProperties {
+    return reflection.isInstance(item, CustomRelationProperties);
 }
 
-export const DescedantsExpr = 'DescedantsExpr';
+export interface DirectedRelationExpression extends AstNode {
+    readonly $container: CustomRelationExpression | Expressions;
+    readonly $type: 'DirectedRelationExpression';
+    source: OutgoingRelationExpression;
+    target: ElementExpression;
+}
+
+export const DirectedRelationExpression = 'DirectedRelationExpression';
 
-export function isDescedantsExpr(item: unknown): item is DescedantsExpr {
-    return reflection.isInstance(item, DescedantsExpr);
+export function isDirectedRelationExpression(item: unknown): item is DirectedRelationExpression {
+    return reflection.isInstance(item, DirectedRelationExpression);
 }
 
 export interface DynamicView extends AstNode {
@@ -299,8 +345,7 @@ export function isDynamicViewBody(item: unknown): item is DynamicViewBody {
 export interface DynamicViewRulePredicate extends AstNode {
     readonly $container: DynamicViewBody;
     readonly $type: 'DynamicViewRulePredicate';
-    commas: Array<string>;
-    expressions: Array<ViewRulePredicateExpr>;
+    exprs: DynamicViewRulePredicateIterator;
 }
 
 export const DynamicViewRulePredicate = 'DynamicViewRulePredicate';
@@ -309,6 +354,19 @@ export function isDynamicViewRulePredicate(item: unknown): item is DynamicViewRu
     return reflection.isInstance(item, DynamicViewRulePredicate);
 }
 
+export interface DynamicViewRulePredicateIterator extends AstNode {
+    readonly $container: DynamicViewRulePredicate | DynamicViewRulePredicateIterator;
+    readonly $type: 'DynamicViewRulePredicateIterator';
+    prev?: DynamicViewRulePredicateIterator;
+    value: DynamicViewElementExpression;
+}
+
+export const DynamicViewRulePredicateIterator = 'DynamicViewRulePredicateIterator';
+
+export function isDynamicViewRulePredicateIterator(item: unknown): item is DynamicViewRulePredicateIterator {
+    return reflection.isInstance(item, DynamicViewRulePredicateIterator);
+}
+
 export interface DynamicViewStep extends AstNode {
     readonly $container: DynamicViewBody;
     readonly $type: 'DynamicViewStep';
@@ -354,6 +412,31 @@ export function isElementBody(item: unknown): item is ElementBody {
     return reflection.isInstance(item, ElementBody);
 }
 
+export interface ElementDescedantsExpression extends AstNode {
+    readonly $container: CustomElementExpression | DirectedRelationExpression | DynamicViewRulePredicateIterator | ElementExpressionsIterator | Expressions | IncomingRelationExpression | OutgoingRelationExpression;
+    readonly $type: 'ElementDescedantsExpression';
+    parent: ElementRef;
+}
+
+export const ElementDescedantsExpression = 'ElementDescedantsExpression';
+
+export function isElementDescedantsExpression(item: unknown): item is ElementDescedantsExpression {
+    return reflection.isInstance(item, ElementDescedantsExpression);
+}
+
+export interface ElementExpressionsIterator extends AstNode {
+    readonly $container: ElementExpressionsIterator | ViewRuleStyle;
+    readonly $type: 'ElementExpressionsIterator';
+    prev?: ElementExpressionsIterator;
+    value: ElementExpression;
+}
+
+export const ElementExpressionsIterator = 'ElementExpressionsIterator';
+
+export function isElementExpressionsIterator(item: unknown): item is ElementExpressionsIterator {
+    return reflection.isInstance(item, ElementExpressionsIterator);
+}
+
 export interface ElementKind extends AstNode {
     readonly $container: SpecificationElementKind;
     readonly $type: 'ElementKind';
@@ -366,21 +449,21 @@ export function isElementKind(item: unknown): item is ElementKind {
     return reflection.isInstance(item, ElementKind);
 }
 
-export interface ElementKindExpr extends AstNode {
-    readonly $container: CustomElementExpr | DynamicViewRulePredicate | ExcludePredicate | IncludePredicate | IncomingExpr | OutgoingExpr | RelationExpr | ViewRuleStyle;
-    readonly $type: 'ElementKindExpr';
+export interface ElementKindExpression extends AstNode {
+    readonly $container: CustomElementExpression | DirectedRelationExpression | DynamicViewRulePredicateIterator | ElementExpressionsIterator | Expressions | IncomingRelationExpression | OutgoingRelationExpression;
+    readonly $type: 'ElementKindExpression';
     isEqual: boolean;
-    kind: Reference<ElementKind>;
+    kind?: Reference<ElementKind>;
 }
 
-export const ElementKindExpr = 'ElementKindExpr';
+export const ElementKindExpression = 'ElementKindExpression';
 
-export function isElementKindExpr(item: unknown): item is ElementKindExpr {
-    return reflection.isInstance(item, ElementKindExpr);
+export function isElementKindExpression(item: unknown): item is ElementKindExpression {
+    return reflection.isInstance(item, ElementKindExpression);
 }
 
 export interface ElementRef extends AstNode {
-    readonly $container: CustomElementExpr | DescedantsExpr | DynamicViewRulePredicate | DynamicViewStep | ElementRef | ElementView | ExcludePredicate | ExpandElementExpr | ExplicitRelation | ImplicitRelation | IncludePredicate | IncomingExpr | OutgoingExpr | RelationExpr | ViewRuleStyle;
+    readonly $container: CustomElementExpression | DirectedRelationExpression | DynamicViewRulePredicateIterator | DynamicViewStep | ElementDescedantsExpression | ElementExpressionsIterator | ElementRef | ElementView | ExpandElementExpression | ExplicitRelation | Expressions | ImplicitRelation | IncomingRelationExpression | OutgoingRelationExpression;
     readonly $type: 'ElementRef';
     dot?: string;
     el: Reference<Element>;
@@ -394,7 +477,7 @@ export function isElementRef(item: unknown): item is ElementRef {
 }
 
 export interface ElementStringProperty extends AstNode {
-    readonly $container: CustomElementExprBody | ElementBody;
+    readonly $container: CustomElementProperties | ElementBody;
     readonly $type: 'ElementStringProperty';
     key: 'description' | 'technology' | 'title';
     value: string;
@@ -406,17 +489,17 @@ export function isElementStringProperty(item: unknown): item is ElementStringPro
     return reflection.isInstance(item, ElementStringProperty);
 }
 
-export interface ElementTagExpr extends AstNode {
-    readonly $container: CustomElementExpr | DynamicViewRulePredicate | ExcludePredicate | IncludePredicate | IncomingExpr | OutgoingExpr | RelationExpr | ViewRuleStyle;
-    readonly $type: 'ElementTagExpr';
+export interface ElementTagExpression extends AstNode {
+    readonly $container: CustomElementExpression | DirectedRelationExpression | DynamicViewRulePredicateIterator | ElementExpressionsIterator | Expressions | IncomingRelationExpression | OutgoingRelationExpression;
+    readonly $type: 'ElementTagExpression';
     isEqual: boolean;
-    tag: Reference<Tag>;
+    tag?: Reference<Tag>;
 }
 
-export const ElementTagExpr = 'ElementTagExpr';
+export const ElementTagExpression = 'ElementTagExpression';
 
-export function isElementTagExpr(item: unknown): item is ElementTagExpr {
-    return reflection.isInstance(item, ElementTagExpr);
+export function isElementTagExpression(item: unknown): item is ElementTagExpression {
+    return reflection.isInstance(item, ElementTagExpression);
 }
 
 export interface ElementView extends AstNode {
@@ -463,8 +546,7 @@ export function isElementViewRef(item: unknown): item is ElementViewRef {
 export interface ExcludePredicate extends AstNode {
     readonly $container: ElementViewBody;
     readonly $type: 'ExcludePredicate';
-    commas: Array<string>;
-    expressions: Array<ViewRulePredicateExpr>;
+    exprs: Expressions;
 }
 
 export const ExcludePredicate = 'ExcludePredicate';
@@ -473,16 +555,16 @@ export function isExcludePredicate(item: unknown): item is ExcludePredicate {
     return reflection.isInstance(item, ExcludePredicate);
 }
 
-export interface ExpandElementExpr extends AstNode {
-    readonly $container: CustomElementExpr | DynamicViewRulePredicate | ExcludePredicate | IncludePredicate | IncomingExpr | OutgoingExpr | RelationExpr | ViewRuleStyle;
-    readonly $type: 'ExpandElementExpr';
-    parent: ElementRef;
+export interface ExpandElementExpression extends AstNode {
+    readonly $container: CustomElementExpression | DirectedRelationExpression | DynamicViewRulePredicateIterator | ElementExpressionsIterator | Expressions | IncomingRelationExpression | OutgoingRelationExpression;
+    readonly $type: 'ExpandElementExpression';
+    expand: ElementRef;
 }
 
-export const ExpandElementExpr = 'ExpandElementExpr';
+export const ExpandElementExpression = 'ExpandElementExpression';
 
-export function isExpandElementExpr(item: unknown): item is ExpandElementExpr {
-    return reflection.isInstance(item, ExpandElementExpr);
+export function isExpandElementExpression(item: unknown): item is ExpandElementExpression {
+    return reflection.isInstance(item, ExpandElementExpression);
 }
 
 export interface ExplicitRelation extends AstNode {
@@ -502,6 +584,19 @@ export function isExplicitRelation(item: unknown): item is ExplicitRelation {
     return reflection.isInstance(item, ExplicitRelation);
 }
 
+export interface Expressions extends AstNode {
+    readonly $container: ExcludePredicate | Expressions | IncludePredicate;
+    readonly $type: 'Expressions';
+    prev?: Expressions;
+    value: Expression;
+}
+
+export const Expressions = 'Expressions';
+
+export function isExpressions(item: unknown): item is Expressions {
+    return reflection.isInstance(item, Expressions);
+}
+
 export interface ExtendElement extends AstNode {
     readonly $container: Model;
     readonly $type: 'ExtendElement';
@@ -542,10 +637,11 @@ export function isFqnElementRef(item: unknown): item is FqnElementRef {
 }
 
 export interface IconProperty extends AstNode {
-    readonly $container: CustomElementExprBody | StyleProperties | ViewRuleStyle;
+    readonly $container: CustomElementProperties | ElementBody | StyleProperties | ViewRuleStyle;
     readonly $type: 'IconProperty';
     key: 'icon';
-    value: Uri;
+    libicon?: Reference<LibIcon>;
+    value?: Uri;
 }
 
 export const IconProperty = 'IconProperty';
@@ -573,8 +669,7 @@ export function isImplicitRelation(item: unknown): item is ImplicitRelation {
 export interface IncludePredicate extends AstNode {
     readonly $container: ElementViewBody;
     readonly $type: 'IncludePredicate';
-    commas: Array<string>;
-    expressions: Array<ViewRulePredicateExpr>;
+    exprs: Expressions;
 }
 
 export const IncludePredicate = 'IncludePredicate';
@@ -583,32 +678,45 @@ export function isIncludePredicate(item: unknown): item is IncludePredicate {
     return reflection.isInstance(item, IncludePredicate);
 }
 
-export interface IncomingExpr extends AstNode {
-    readonly $container: DynamicViewRulePredicate | ExcludePredicate | InOutExpr | IncludePredicate;
-    readonly $type: 'IncomingExpr';
-    to: ElementExpr;
+export interface IncomingRelationExpression extends AstNode {
+    readonly $container: CustomRelationExpression | Expressions | InOutRelationExpression;
+    readonly $type: 'IncomingRelationExpression';
+    to: ElementExpression;
 }
 
-export const IncomingExpr = 'IncomingExpr';
+export const IncomingRelationExpression = 'IncomingRelationExpression';
 
-export function isIncomingExpr(item: unknown): item is IncomingExpr {
-    return reflection.isInstance(item, IncomingExpr);
+export function isIncomingRelationExpression(item: unknown): item is IncomingRelationExpression {
+    return reflection.isInstance(item, IncomingRelationExpression);
 }
 
-export interface InOutExpr extends AstNode {
-    readonly $container: DynamicViewRulePredicate | ExcludePredicate | IncludePredicate;
-    readonly $type: 'InOutExpr';
-    inout: IncomingExpr;
+export interface InOutRelationExpression extends AstNode {
+    readonly $container: CustomRelationExpression | Expressions;
+    readonly $type: 'InOutRelationExpression';
+    inout: IncomingRelationExpression;
 }
 
-export const InOutExpr = 'InOutExpr';
+export const InOutRelationExpression = 'InOutRelationExpression';
+
+export function isInOutRelationExpression(item: unknown): item is InOutRelationExpression {
+    return reflection.isInstance(item, InOutRelationExpression);
+}
 
-export function isInOutExpr(item: unknown): item is InOutExpr {
-    return reflection.isInstance(item, InOutExpr);
+export interface LibIcon extends AstNode {
+    readonly $container: LikeC4Lib;
+    readonly $type: 'LibIcon';
+    name: IconId;
+}
+
+export const LibIcon = 'LibIcon';
+
+export function isLibIcon(item: unknown): item is LibIcon {
+    return reflection.isInstance(item, LibIcon);
 }
 
 export interface LikeC4Grammar extends AstNode {
     readonly $type: 'LikeC4Grammar';
+    likec4lib: Array<LikeC4Lib>;
     models: Array<Model>;
     specifications: Array<SpecificationRule>;
     views: Array<ModelViews>;
@@ -620,8 +728,20 @@ export function isLikeC4Grammar(item: unknown): item is LikeC4Grammar {
     return reflection.isInstance(item, LikeC4Grammar);
 }
 
+export interface LikeC4Lib extends AstNode {
+    readonly $container: LikeC4Grammar;
+    readonly $type: 'LikeC4Lib';
+    icons: Array<LibIcon>;
+}
+
+export const LikeC4Lib = 'LikeC4Lib';
+
+export function isLikeC4Lib(item: unknown): item is LikeC4Lib {
+    return reflection.isInstance(item, LikeC4Lib);
+}
+
 export interface LineProperty extends AstNode {
-    readonly $container: RelationStyleProperty | SpecificationRelationshipKind;
+    readonly $container: CustomRelationProperties | RelationStyleProperty | SpecificationRelationshipKind;
     readonly $type: 'LineProperty';
     key: 'line';
     value: LineOptions;
@@ -673,7 +793,7 @@ export function isModelViews(item: unknown): item is ModelViews {
 }
 
 export interface NavigateToProperty extends AstNode {
-    readonly $container: CustomElementExprBody;
+    readonly $container: CustomElementProperties;
     readonly $type: 'NavigateToProperty';
     key: 'navigateTo';
     value: ViewRef;
@@ -686,7 +806,7 @@ export function isNavigateToProperty(item: unknown): item is NavigateToProperty
 }
 
 export interface OpacityProperty extends AstNode {
-    readonly $container: CustomElementExprBody | StyleProperties | ViewRuleStyle;
+    readonly $container: CustomElementProperties | StyleProperties | ViewRuleStyle;
     readonly $type: 'OpacityProperty';
     key: 'opacity';
     value: string;
@@ -698,16 +818,18 @@ export function isOpacityProperty(item: unknown): item is OpacityProperty {
     return reflection.isInstance(item, OpacityProperty);
 }
 
-export interface OutgoingExpr extends AstNode {
-    readonly $container: DynamicViewRulePredicate | ExcludePredicate | IncludePredicate;
-    readonly $type: 'OutgoingExpr';
-    from: ElementExpr;
+export interface OutgoingRelationExpression extends AstNode {
+    readonly $container: CustomRelationExpression | DirectedRelationExpression | Expressions;
+    readonly $type: 'OutgoingRelationExpression';
+    from: ElementExpression;
+    isBidirectional: boolean;
+    kind?: Reference<RelationshipKind>;
 }
 
-export const OutgoingExpr = 'OutgoingExpr';
+export const OutgoingRelationExpression = 'OutgoingRelationExpression';
 
-export function isOutgoingExpr(item: unknown): item is OutgoingExpr {
-    return reflection.isInstance(item, OutgoingExpr);
+export function isOutgoingRelationExpression(item: unknown): item is OutgoingRelationExpression {
+    return reflection.isInstance(item, OutgoingRelationExpression);
 }
 
 export interface RelationBody extends AstNode {
@@ -723,20 +845,6 @@ export function isRelationBody(item: unknown): item is RelationBody {
     return reflection.isInstance(item, RelationBody);
 }
 
-export interface RelationExpr extends AstNode {
-    readonly $container: DynamicViewRulePredicate | ExcludePredicate | IncludePredicate;
-    readonly $type: 'RelationExpr';
-    isBidirectional: boolean;
-    source: ElementExpr;
-    target: ElementExpr;
-}
-
-export const RelationExpr = 'RelationExpr';
-
-export function isRelationExpr(item: unknown): item is RelationExpr {
-    return reflection.isInstance(item, RelationExpr);
-}
-
 export interface RelationshipKind extends AstNode {
     readonly $container: SpecificationRelationshipKind;
     readonly $type: 'RelationshipKind';
@@ -750,7 +858,7 @@ export function isRelationshipKind(item: unknown): item is RelationshipKind {
 }
 
 export interface RelationStringProperty extends AstNode {
-    readonly $container: RelationBody;
+    readonly $container: CustomRelationProperties | RelationBody;
     readonly $type: 'RelationStringProperty';
     key: 'title';
     value: string;
@@ -776,7 +884,7 @@ export function isRelationStyleProperty(item: unknown): item is RelationStylePro
 }
 
 export interface ShapeProperty extends AstNode {
-    readonly $container: CustomElementExprBody | StyleProperties | ViewRuleStyle;
+    readonly $container: CustomElementProperties | StyleProperties | ViewRuleStyle;
     readonly $type: 'ShapeProperty';
     key: 'shape';
     value: ElementShape;
@@ -869,7 +977,6 @@ export function isTag(item: unknown): item is Tag {
 export interface Tags extends AstNode {
     readonly $container: DynamicViewBody | ElementBody | ElementViewBody | ExplicitRelation | ImplicitRelation | RelationBody;
     readonly $type: 'Tags';
-    comma: Array<string>;
     value: Array<Reference<Tag>>;
 }
 
@@ -906,9 +1013,8 @@ export function isViewRuleAutoLayout(item: unknown): item is ViewRuleAutoLayout
 export interface ViewRuleStyle extends AstNode {
     readonly $container: DynamicViewBody | ElementViewBody;
     readonly $type: 'ViewRuleStyle';
-    commas: Array<string>;
-    styleprops: Array<StyleProperty>;
-    targets: Array<ElementExpr>;
+    props: Array<StyleProperty>;
+    target: ElementExpressionsIterator;
 }
 
 export const ViewRuleStyle = 'ViewRuleStyle';
@@ -930,54 +1036,64 @@ export function isViewStringProperty(item: unknown): item is ViewStringProperty
     return reflection.isInstance(item, ViewStringProperty);
 }
 
-export interface WildcardExpr extends AstNode {
-    readonly $container: CustomElementExpr | DynamicViewRulePredicate | ExcludePredicate | IncludePredicate | IncomingExpr | OutgoingExpr | RelationExpr | ViewRuleStyle;
-    readonly $type: 'WildcardExpr';
+export interface WildcardExpression extends AstNode {
+    readonly $container: CustomElementExpression | DirectedRelationExpression | DynamicViewRulePredicateIterator | ElementExpressionsIterator | Expressions | IncomingRelationExpression | OutgoingRelationExpression;
+    readonly $type: 'WildcardExpression';
     isWildcard: boolean;
 }
 
-export const WildcardExpr = 'WildcardExpr';
+export const WildcardExpression = 'WildcardExpression';
 
-export function isWildcardExpr(item: unknown): item is WildcardExpr {
-    return reflection.isInstance(item, WildcardExpr);
+export function isWildcardExpression(item: unknown): item is WildcardExpression {
+    return reflection.isInstance(item, WildcardExpression);
 }
 
 export type LikeC4AstType = {
     ArrowProperty: ArrowProperty
     BorderProperty: BorderProperty
     ColorProperty: ColorProperty
-    CustomElementExpr: CustomElementExpr
-    CustomElementExprBody: CustomElementExprBody
-    DescedantsExpr: DescedantsExpr
+    CustomElementExpression: CustomElementExpression
+    CustomElementProperties: CustomElementProperties
+    CustomRelationExpression: CustomRelationExpression
+    CustomRelationProperties: CustomRelationProperties
+    DirectedRelationExpression: DirectedRelationExpression
     DynamicView: DynamicView
     DynamicViewBody: DynamicViewBody
+    DynamicViewElementExpression: DynamicViewElementExpression
     DynamicViewRule: DynamicViewRule
     DynamicViewRulePredicate: DynamicViewRulePredicate
+    DynamicViewRulePredicateIterator: DynamicViewRulePredicateIterator
     DynamicViewStep: DynamicViewStep
     Element: Element
     ElementBody: ElementBody
-    ElementExpr: ElementExpr
+    ElementDescedantsExpression: ElementDescedantsExpression
+    ElementExpression: ElementExpression
+    ElementExpressionsIterator: ElementExpressionsIterator
     ElementKind: ElementKind
-    ElementKindExpr: ElementKindExpr
+    ElementKindExpression: ElementKindExpression
     ElementProperty: ElementProperty
     ElementRef: ElementRef
     ElementStringProperty: ElementStringProperty
-    ElementTagExpr: ElementTagExpr
+    ElementTagExpression: ElementTagExpression
     ElementView: ElementView
     ElementViewBody: ElementViewBody
     ElementViewRef: ElementViewRef
     ExcludePredicate: ExcludePredicate
-    ExpandElementExpr: ExpandElementExpr
+    ExpandElementExpression: ExpandElementExpression
     ExplicitRelation: ExplicitRelation
+    Expression: Expression
+    Expressions: Expressions
     ExtendElement: ExtendElement
     ExtendElementBody: ExtendElementBody
     FqnElementRef: FqnElementRef
     IconProperty: IconProperty
     ImplicitRelation: ImplicitRelation
-    InOutExpr: InOutExpr
+    InOutRelationExpression: InOutRelationExpression
     IncludePredicate: IncludePredicate
-    IncomingExpr: IncomingExpr
+    IncomingRelationExpression: IncomingRelationExpression
+    LibIcon: LibIcon
     LikeC4Grammar: LikeC4Grammar
+    LikeC4Lib: LikeC4Lib
     LikeC4View: LikeC4View
     LineProperty: LineProperty
     LinkProperty: LinkProperty
@@ -985,10 +1101,10 @@ export type LikeC4AstType = {
     ModelViews: ModelViews
     NavigateToProperty: NavigateToProperty
     OpacityProperty: OpacityProperty
-    OutgoingExpr: OutgoingExpr
+    OutgoingRelationExpression: OutgoingRelationExpression
     Relation: Relation
     RelationBody: RelationBody
-    RelationExpr: RelationExpr
+    RelationExpression: RelationExpression
     RelationProperty: RelationProperty
     RelationStringProperty: RelationStringProperty
     RelationStyleProperty: RelationStyleProperty
@@ -1009,16 +1125,15 @@ export type LikeC4AstType = {
     ViewRule: ViewRule
     ViewRuleAutoLayout: ViewRuleAutoLayout
     ViewRulePredicate: ViewRulePredicate
-    ViewRulePredicateExpr: ViewRulePredicateExpr
     ViewRuleStyle: ViewRuleStyle
     ViewStringProperty: ViewStringProperty
-    WildcardExpr: WildcardExpr
+    WildcardExpression: WildcardExpression
 }
 
 export class LikeC4AstReflection extends AbstractAstReflection {
 
     getAllTypes(): string[] {
-        return [ArrowProperty, BorderProperty, ColorProperty, CustomElementExpr, CustomElementExprBody, DescedantsExpr, DynamicView, DynamicViewBody, DynamicViewRule, DynamicViewRulePredicate, DynamicViewStep, Element, ElementBody, ElementExpr, ElementKind, ElementKindExpr, ElementProperty, ElementRef, ElementStringProperty, ElementTagExpr, ElementView, ElementViewBody, ElementViewRef, ExcludePredicate, ExpandElementExpr, ExplicitRelation, ExtendElement, ExtendElementBody, FqnElementRef, IconProperty, ImplicitRelation, InOutExpr, IncludePredicate, IncomingExpr, LikeC4Grammar, LikeC4View, LineProperty, LinkProperty, Model, ModelViews, NavigateToProperty, OpacityProperty, OutgoingExpr, Relation, RelationBody, RelationExpr, RelationProperty, RelationStringProperty, RelationStyleProperty, RelationshipKind, RelationshipStyleProperty, ShapeProperty, SpecificationElementKind, SpecificationRelationshipKind, SpecificationRule, SpecificationTag, StringProperty, StyleProperties, StyleProperty, Tag, Tags, ViewProperty, ViewRef, ViewRule, ViewRuleAutoLayout, ViewRulePredicate, ViewRulePredicateExpr, ViewRuleStyle, ViewStringProperty, WildcardExpr];
+        return [ArrowProperty, BorderProperty, ColorProperty, CustomElementExpression, CustomElementProperties, CustomRelationExpression, CustomRelationProperties, DirectedRelationExpression, DynamicView, DynamicViewBody, DynamicViewElementExpression, DynamicViewRule, DynamicViewRulePredicate, DynamicViewRulePredicateIterator, DynamicViewStep, Element, ElementBody, ElementDescedantsExpression, ElementExpression, ElementExpressionsIterator, ElementKind, ElementKindExpression, ElementProperty, ElementRef, ElementStringProperty, ElementTagExpression, ElementView, ElementViewBody, ElementViewRef, ExcludePredicate, ExpandElementExpression, ExplicitRelation, Expression, Expressions, ExtendElement, ExtendElementBody, FqnElementRef, IconProperty, ImplicitRelation, InOutRelationExpression, IncludePredicate, IncomingRelationExpression, LibIcon, LikeC4Grammar, LikeC4Lib, LikeC4View, LineProperty, LinkProperty, Model, ModelViews, NavigateToProperty, OpacityProperty, OutgoingRelationExpression, Relation, RelationBody, RelationExpression, RelationProperty, RelationStringProperty, RelationStyleProperty, RelationshipKind, RelationshipStyleProperty, ShapeProperty, SpecificationElementKind, SpecificationRelationshipKind, SpecificationRule, SpecificationTag, StringProperty, StyleProperties, StyleProperty, Tag, Tags, ViewProperty, ViewRef, ViewRule, ViewRuleAutoLayout, ViewRulePredicate, ViewRuleStyle, ViewStringProperty, WildcardExpression];
     }
 
     protected override computeIsSubtype(subtype: string, supertype: string): boolean {
@@ -1028,7 +1143,6 @@ export class LikeC4AstReflection extends AbstractAstReflection {
                 return this.isSubtype(RelationshipStyleProperty, supertype);
             }
             case BorderProperty:
-            case IconProperty:
             case OpacityProperty:
             case ShapeProperty: {
                 return this.isSubtype(StyleProperty, supertype);
@@ -1036,21 +1150,19 @@ export class LikeC4AstReflection extends AbstractAstReflection {
             case ColorProperty: {
                 return this.isSubtype(RelationshipStyleProperty, supertype) || this.isSubtype(StyleProperty, supertype);
             }
-            case CustomElementExpr:
-            case ElementExpr:
-            case IncomingExpr:
-            case InOutExpr:
-            case OutgoingExpr:
-            case RelationExpr: {
-                return this.isSubtype(ViewRulePredicateExpr, supertype);
+            case CustomElementExpression:
+            case ElementExpression: {
+                return this.isSubtype(DynamicViewElementExpression, supertype) || this.isSubtype(Expression, supertype);
             }
-            case DescedantsExpr:
-            case ElementKindExpr:
-            case ElementRef:
-            case ElementTagExpr:
-            case ExpandElementExpr:
-            case WildcardExpr: {
-                return this.isSubtype(ElementExpr, supertype);
+            case CustomRelationExpression:
+            case RelationExpression: {
+                return this.isSubtype(Expression, supertype);
+            }
+            case DirectedRelationExpression:
+            case IncomingRelationExpression:
+            case InOutRelationExpression:
+            case OutgoingRelationExpression: {
+                return this.isSubtype(RelationExpression, supertype);
             }
             case DynamicView:
             case ElementView: {
@@ -1059,6 +1171,14 @@ export class LikeC4AstReflection extends AbstractAstReflection {
             case DynamicViewRulePredicate: {
                 return this.isSubtype(DynamicViewRule, supertype);
             }
+            case ElementDescedantsExpression:
+            case ElementKindExpression:
+            case ElementRef:
+            case ElementTagExpression:
+            case ExpandElementExpression:
+            case WildcardExpression: {
+                return this.isSubtype(ElementExpression, supertype);
+            }
             case ElementStringProperty: {
                 return this.isSubtype(ElementProperty, supertype) || this.isSubtype(StringProperty, supertype);
             }
@@ -1070,10 +1190,15 @@ export class LikeC4AstReflection extends AbstractAstReflection {
             case ImplicitRelation: {
                 return this.isSubtype(Relation, supertype);
             }
+            case IconProperty: {
+                return this.isSubtype(ElementProperty, supertype) || this.isSubtype(StyleProperty, supertype);
+            }
             case LinkProperty: {
                 return this.isSubtype(ElementProperty, supertype) || this.isSubtype(RelationProperty, supertype) || this.isSubtype(ViewProperty, supertype);
             }
-            case RelationStringProperty:
+            case RelationStringProperty: {
+                return this.isSubtype(RelationProperty, supertype) || this.isSubtype(StringProperty, supertype);
+            }
             case RelationStyleProperty: {
                 return this.isSubtype(RelationProperty, supertype);
             }
@@ -1101,24 +1226,28 @@ export class LikeC4AstReflection extends AbstractAstReflection {
         switch (referenceId) {
             case 'DynamicViewStep:kind':
             case 'ExplicitRelation:kind':
-            case 'ImplicitRelation:kind': {
+            case 'ImplicitRelation:kind':
+            case 'OutgoingRelationExpression:kind': {
                 return RelationshipKind;
             }
             case 'Element:kind':
-            case 'ElementKindExpr:kind': {
+            case 'ElementKindExpression:kind': {
                 return ElementKind;
             }
             case 'ElementRef:el':
             case 'FqnElementRef:el': {
                 return Element;
             }
-            case 'ElementTagExpr:tag':
+            case 'ElementTagExpression:tag':
             case 'Tags:value': {
                 return Tag;
             }
             case 'ElementViewRef:view': {
                 return ElementView;
             }
+            case 'IconProperty:libicon': {
+                return LibIcon;
+            }
             case 'ViewRef:view': {
                 return LikeC4View;
             }
@@ -1157,28 +1286,46 @@ export class LikeC4AstReflection extends AbstractAstReflection {
                     ]
                 };
             }
-            case CustomElementExpr: {
+            case CustomElementExpression: {
                 return {
-                    name: CustomElementExpr,
+                    name: CustomElementExpression,
                     properties: [
-                        { name: 'body' },
+                        { name: 'custom' },
                         { name: 'target' }
                     ]
                 };
             }
-            case CustomElementExprBody: {
+            case CustomElementProperties: {
                 return {
-                    name: CustomElementExprBody,
+                    name: CustomElementProperties,
                     properties: [
                         { name: 'props', defaultValue: [] }
                     ]
                 };
             }
-            case DescedantsExpr: {
+            case CustomRelationExpression: {
                 return {
-                    name: DescedantsExpr,
+                    name: CustomRelationExpression,
                     properties: [
-                        { name: 'parent' }
+                        { name: 'custom' },
+                        { name: 'relation' }
+                    ]
+                };
+            }
+            case CustomRelationProperties: {
+                return {
+                    name: CustomRelationProperties,
+                    properties: [
+                        { name: 'props', defaultValue: [] }
+                    ]
+                };
+            }
+            case DirectedRelationExpression: {
+                return {
+                    name: DirectedRelationExpression,
+                    properties: [
+                        { name: 'source' },
+                        { name: 'target' }
                     ]
                 };
             }
@@ -1206,8 +1353,16 @@ export class LikeC4AstReflection extends AbstractAstReflection {
                 return {
                     name: DynamicViewRulePredicate,
                     properties: [
-                        { name: 'commas', defaultValue: [] },
-                        { name: 'expressions', defaultValue: [] }
+                        { name: 'exprs' }
+                    ]
+                };
+            }
+            case DynamicViewRulePredicateIterator: {
+                return {
+                    name: DynamicViewRulePredicateIterator,
+                    properties: [
+                        { name: 'prev' },
+                        { name: 'value' }
                     ]
                 };
             }
@@ -1244,6 +1399,23 @@ export class LikeC4AstReflection extends AbstractAstReflection {
                     ]
                 };
             }
+            case ElementDescedantsExpression: {
+                return {
+                    name: ElementDescedantsExpression,
+                    properties: [
+                        { name: 'parent' }
+                    ]
+                };
+            }
+            case ElementExpressionsIterator: {
+                return {
+                    name: ElementExpressionsIterator,
+                    properties: [
+                        { name: 'prev' },
+                        { name: 'value' }
+                    ]
+                };
+            }
             case ElementKind: {
                 return {
                     name: ElementKind,
@@ -1252,9 +1424,9 @@ export class LikeC4AstReflection extends AbstractAstReflection {
                     ]
                 };
             }
-            case ElementKindExpr: {
+            case ElementKindExpression: {
                 return {
-                    name: ElementKindExpr,
+                    name: ElementKindExpression,
                     properties: [
                         { name: 'isEqual', defaultValue: false },
                         { name: 'kind' }
@@ -1280,9 +1452,9 @@ export class LikeC4AstReflection extends AbstractAstReflection {
                     ]
                 };
             }
-            case ElementTagExpr: {
+            case ElementTagExpression: {
                 return {
-                    name: ElementTagExpr,
+                    name: ElementTagExpression,
                     properties: [
                         { name: 'isEqual', defaultValue: false },
                         { name: 'tag' }
@@ -1322,16 +1494,15 @@ export class LikeC4AstReflection extends AbstractAstReflection {
                 return {
                     name: ExcludePredicate,
                     properties: [
-                        { name: 'commas', defaultValue: [] },
-                        { name: 'expressions', defaultValue: [] }
+                        { name: 'exprs' }
                     ]
                 };
             }
-            case ExpandElementExpr: {
+            case ExpandElementExpression: {
                 return {
-                    name: ExpandElementExpr,
+                    name: ExpandElementExpression,
                     properties: [
-                        { name: 'parent' }
+                        { name: 'expand' }
                     ]
                 };
             }
@@ -1348,6 +1519,15 @@ export class LikeC4AstReflection extends AbstractAstReflection {
                     ]
                 };
             }
+            case Expressions: {
+                return {
+                    name: Expressions,
+                    properties: [
+                        { name: 'prev' },
+                        { name: 'value' }
+                    ]
+                };
+            }
             case ExtendElement: {
                 return {
                     name: ExtendElement,
@@ -1380,6 +1560,7 @@ export class LikeC4AstReflection extends AbstractAstReflection {
                     name: IconProperty,
                     properties: [
                         { name: 'key' },
+                        { name: 'libicon' },
                         { name: 'value' }
                     ]
                 };
@@ -1400,37 +1581,53 @@ export class LikeC4AstReflection extends AbstractAstReflection {
                 return {
                     name: IncludePredicate,
                     properties: [
-                        { name: 'commas', defaultValue: [] },
-                        { name: 'expressions', defaultValue: [] }
+                        { name: 'exprs' }
                     ]
                 };
             }
-            case IncomingExpr: {
+            case IncomingRelationExpression: {
                 return {
-                    name: IncomingExpr,
+                    name: IncomingRelationExpression,
                     properties: [
                         { name: 'to' }
                     ]
                 };
             }
-            case InOutExpr: {
+            case InOutRelationExpression: {
                 return {
-                    name: InOutExpr,
+                    name: InOutRelationExpression,
                     properties: [
                         { name: 'inout' }
                     ]
                 };
             }
+            case LibIcon: {
+                return {
+                    name: LibIcon,
+                    properties: [
+                        { name: 'name' }
+                    ]
+                };
+            }
             case LikeC4Grammar: {
                 return {
                     name: LikeC4Grammar,
                     properties: [
+                        { name: 'likec4lib', defaultValue: [] },
                         { name: 'models', defaultValue: [] },
                         { name: 'specifications', defaultValue: [] },
                         { name: 'views', defaultValue: [] }
                     ]
                 };
             }
+            case LikeC4Lib: {
+                return {
+                    name: LikeC4Lib,
+                    properties: [
+                        { name: 'icons', defaultValue: [] }
+                    ]
+                };
+            }
             case LineProperty: {
                 return {
                     name: LineProperty,
@@ -1485,11 +1682,13 @@ export class LikeC4AstReflection extends AbstractAstReflection {
                     ]
                 };
             }
-            case OutgoingExpr: {
+            case OutgoingRelationExpression: {
                 return {
-                    name: OutgoingExpr,
+                    name: OutgoingRelationExpression,
                     properties: [
-                        { name: 'from' }
+                        { name: 'from' },
+                        { name: 'isBidirectional', defaultValue: false },
+                        { name: 'kind' }
                     ]
                 };
             }
@@ -1502,16 +1701,6 @@ export class LikeC4AstReflection extends AbstractAstReflection {
                     ]
                 };
             }
-            case RelationExpr: {
-                return {
-                    name: RelationExpr,
-                    properties: [
-                        { name: 'isBidirectional', defaultValue: false },
-                        { name: 'source' },
-                        { name: 'target' }
-                    ]
-                };
-            }
             case RelationshipKind: {
                 return {
                     name: RelationshipKind,
@@ -1605,7 +1794,6 @@ export class LikeC4AstReflection extends AbstractAstReflection {
                 return {
                     name: Tags,
                     properties: [
-                        { name: 'comma', defaultValue: [] },
                         { name: 'value', defaultValue: [] }
                     ]
                 };
@@ -1630,9 +1818,8 @@ export class LikeC4AstReflection extends AbstractAstReflection {
                 return {
                     name: ViewRuleStyle,
                     properties: [
-                        { name: 'commas', defaultValue: [] },
-                        { name: 'styleprops', defaultValue: [] },
-                        { name: 'targets', defaultValue: [] }
+                        { name: 'props', defaultValue: [] },
+                        { name: 'target' }
                     ]
                 };
             }
@@ -1645,9 +1832,9 @@ export class LikeC4AstReflection extends AbstractAstReflection {
                     ]
                 };
             }
-            case WildcardExpr: {
+            case WildcardExpression: {
                 return {
-                    name: WildcardExpr,
+                    name: WildcardExpression,
                     properties: [
                         { name: 'isWildcard', defaultValue: false }
                     ]