@likec4/language-server 1.6.1 → 1.7.1

package/src/generated/ast.ts

@@ -1,5 +1,5 @@
 /******************************************************************************
- * This file was generated by langium-cli 3.1.0.
+ * This file was generated by langium-cli 3.1.1.
  * DO NOT EDIT MANUALLY!
  ******************************************************************************/
 
@@ -11,7 +11,7 @@ export const LikeC4Terminals = {
     BLOCK_COMMENT: /\/\*[\s\S]*?\*\//,
     LINE_COMMENT: /\/\/[^\n\r]*/,
     WS: /\s+/,
-    LIB_ICON: /\b(aws|gcp|tech):[-\w]*/,
+    LIB_ICON: /(aws|gcp|tech):[-\w]*/,
     URI_WITH_SCHEMA: /\w+:\/\/\S+/,
     URI_RELATIVE: /\.{0,2}\/[^\/]\S+/,
     DotUnderscore: /\b\._/,
@@ -44,15 +44,7 @@ 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 type DynamicViewRule = DynamicViewIncludePredicate | ViewRuleAutoLayout | ViewRuleStyle;
 
 export const DynamicViewRule = 'DynamicViewRule';
 
@@ -68,6 +60,22 @@ export function isElementExpression(item: unknown): item is ElementExpression {
     return reflection.isInstance(item, ElementExpression);
 }
 
+export type ElementPredicate = ElementPredicateOrWhere | ElementPredicateWith;
+
+export const ElementPredicate = 'ElementPredicate';
+
+export function isElementPredicate(item: unknown): item is ElementPredicate {
+    return reflection.isInstance(item, ElementPredicate);
+}
+
+export type ElementPredicateOrWhere = ElementExpression | ElementPredicateWhere;
+
+export const ElementPredicateOrWhere = 'ElementPredicateOrWhere';
+
+export function isElementPredicateOrWhere(item: unknown): item is ElementPredicateOrWhere {
+    return reflection.isInstance(item, ElementPredicateOrWhere);
+}
+
 export type ElementProperty = ElementStringProperty | IconProperty | LinkProperty | StyleProperties;
 
 export const ElementProperty = 'ElementProperty';
@@ -82,18 +90,10 @@ 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)));
+    return (typeof item === 'string' && (/(aws|gcp|tech):[-\w]*/.test(item)));
 }
 
 export type Id = 'element' | 'model' | ArrowType | ElementShape | LineOptions | ThemeColor | string;
@@ -116,6 +116,14 @@ export function isLineOptions(item: unknown): item is LineOptions {
     return item === 'solid' || item === 'dashed' || item === 'dotted';
 }
 
+export type Predicate = ElementPredicate | RelationPredicate;
+
+export const Predicate = 'Predicate';
+
+export function isPredicate(item: unknown): item is Predicate {
+    return reflection.isInstance(item, Predicate);
+}
+
 export type Relation = ExplicitRelation | ImplicitRelation;
 
 export const Relation = 'Relation';
@@ -132,6 +140,22 @@ export function isRelationExpression(item: unknown): item is RelationExpression
     return reflection.isInstance(item, RelationExpression);
 }
 
+export type RelationPredicate = RelationPredicateOrWhere | RelationPredicateWith;
+
+export const RelationPredicate = 'RelationPredicate';
+
+export function isRelationPredicate(item: unknown): item is RelationPredicate {
+    return reflection.isInstance(item, RelationPredicate);
+}
+
+export type RelationPredicateOrWhere = RelationExpression | RelationPredicateWhere;
+
+export const RelationPredicateOrWhere = 'RelationPredicateOrWhere';
+
+export function isRelationPredicateOrWhere(item: unknown): item is RelationPredicateOrWhere {
+    return reflection.isInstance(item, RelationPredicateOrWhere);
+}
+
 export type RelationProperty = LinkProperty | RelationStringProperty | RelationStyleProperty;
 
 export const RelationProperty = 'RelationProperty';
@@ -212,6 +236,62 @@ export function isViewRulePredicate(item: unknown): item is ViewRulePredicate {
     return reflection.isInstance(item, ViewRulePredicate);
 }
 
+export type WhereElement = WhereElementKind | WhereElementTag;
+
+export const WhereElement = 'WhereElement';
+
+export function isWhereElement(item: unknown): item is WhereElement {
+    return reflection.isInstance(item, WhereElement);
+}
+
+export type WhereElementExpression = WhereBinaryExpression | WhereElement | WhereElementNegation;
+
+export const WhereElementExpression = 'WhereElementExpression';
+
+export function isWhereElementExpression(item: unknown): item is WhereElementExpression {
+    return reflection.isInstance(item, WhereElementExpression);
+}
+
+export type WhereExpression = WhereElementExpression | WhereRelationExpression;
+
+export const WhereExpression = 'WhereExpression';
+
+export function isWhereExpression(item: unknown): item is WhereExpression {
+    return reflection.isInstance(item, WhereExpression);
+}
+
+export type WhereKindEqual = WhereElementKind | WhereRelationKind;
+
+export const WhereKindEqual = 'WhereKindEqual';
+
+export function isWhereKindEqual(item: unknown): item is WhereKindEqual {
+    return reflection.isInstance(item, WhereKindEqual);
+}
+
+export type WhereRelation = WhereRelationKind | WhereRelationTag;
+
+export const WhereRelation = 'WhereRelation';
+
+export function isWhereRelation(item: unknown): item is WhereRelation {
+    return reflection.isInstance(item, WhereRelation);
+}
+
+export type WhereRelationExpression = WhereBinaryExpression | WhereRelation | WhereRelationNegation;
+
+export const WhereRelationExpression = 'WhereRelationExpression';
+
+export function isWhereRelationExpression(item: unknown): item is WhereRelationExpression {
+    return reflection.isInstance(item, WhereRelationExpression);
+}
+
+export type WhereTagEqual = WhereElementTag | WhereRelationTag;
+
+export const WhereTagEqual = 'WhereTagEqual';
+
+export function isWhereTagEqual(item: unknown): item is WhereTagEqual {
+    return reflection.isInstance(item, WhereTagEqual);
+}
+
 export interface ArrowProperty extends AstNode {
     readonly $container: CustomRelationProperties | RelationStyleProperty | SpecificationRelationshipKind;
     readonly $type: 'ArrowProperty';
@@ -251,21 +331,8 @@ export function isColorProperty(item: unknown): item is ColorProperty {
     return reflection.isInstance(item, ColorProperty);
 }
 
-export interface CustomElementExpression extends AstNode {
-    readonly $container: DynamicViewRulePredicateIterator | Expressions;
-    readonly $type: 'CustomElementExpression';
-    custom: CustomElementProperties;
-    target: ElementExpression;
-}
-
-export const CustomElementExpression = 'CustomElementExpression';
-
-export function isCustomElementExpression(item: unknown): item is CustomElementExpression {
-    return reflection.isInstance(item, CustomElementExpression);
-}
-
 export interface CustomElementProperties extends AstNode {
-    readonly $container: CustomElementExpression;
+    readonly $container: ElementPredicateWith;
     readonly $type: 'CustomElementProperties';
     props: Array<ElementStringProperty | NavigateToProperty | StyleProperty>;
 }
@@ -276,21 +343,8 @@ export function isCustomElementProperties(item: unknown): item is CustomElementP
     return reflection.isInstance(item, CustomElementProperties);
 }
 
-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 $container: DynamicViewStep | RelationPredicateWith;
     readonly $type: 'CustomRelationProperties';
     props: Array<RelationStringProperty | RelationshipStyleProperty>;
 }
@@ -302,7 +356,7 @@ export function isCustomRelationProperties(item: unknown): item is CustomRelatio
 }
 
 export interface DirectedRelationExpression extends AstNode {
-    readonly $container: CustomRelationExpression | Expressions;
+    readonly $container: Predicates | RelationPredicateWhere | RelationPredicateWith;
     readonly $type: 'DirectedRelationExpression';
     source: OutgoingRelationExpression;
     target: ElementExpression;
@@ -317,7 +371,7 @@ export function isDirectedRelationExpression(item: unknown): item is DirectedRel
 export interface DynamicView extends AstNode {
     readonly $container: ModelViews;
     readonly $type: 'DynamicView';
-    body: DynamicViewBody;
+    body?: DynamicViewBody;
     name: Id;
 }
 
@@ -342,34 +396,35 @@ export function isDynamicViewBody(item: unknown): item is DynamicViewBody {
     return reflection.isInstance(item, DynamicViewBody);
 }
 
-export interface DynamicViewRulePredicate extends AstNode {
+export interface DynamicViewIncludePredicate extends AstNode {
     readonly $container: DynamicViewBody;
-    readonly $type: 'DynamicViewRulePredicate';
-    exprs: DynamicViewRulePredicateIterator;
+    readonly $type: 'DynamicViewIncludePredicate';
+    predicates: DynamicViewPredicateIterator;
 }
 
-export const DynamicViewRulePredicate = 'DynamicViewRulePredicate';
+export const DynamicViewIncludePredicate = 'DynamicViewIncludePredicate';
 
-export function isDynamicViewRulePredicate(item: unknown): item is DynamicViewRulePredicate {
-    return reflection.isInstance(item, DynamicViewRulePredicate);
+export function isDynamicViewIncludePredicate(item: unknown): item is DynamicViewIncludePredicate {
+    return reflection.isInstance(item, DynamicViewIncludePredicate);
 }
 
-export interface DynamicViewRulePredicateIterator extends AstNode {
-    readonly $container: DynamicViewRulePredicate | DynamicViewRulePredicateIterator;
-    readonly $type: 'DynamicViewRulePredicateIterator';
-    prev?: DynamicViewRulePredicateIterator;
-    value: DynamicViewElementExpression;
+export interface DynamicViewPredicateIterator extends AstNode {
+    readonly $container: DynamicViewIncludePredicate | DynamicViewPredicateIterator;
+    readonly $type: 'DynamicViewPredicateIterator';
+    prev?: DynamicViewPredicateIterator;
+    value: ElementPredicate;
 }
 
-export const DynamicViewRulePredicateIterator = 'DynamicViewRulePredicateIterator';
+export const DynamicViewPredicateIterator = 'DynamicViewPredicateIterator';
 
-export function isDynamicViewRulePredicateIterator(item: unknown): item is DynamicViewRulePredicateIterator {
-    return reflection.isInstance(item, DynamicViewRulePredicateIterator);
+export function isDynamicViewPredicateIterator(item: unknown): item is DynamicViewPredicateIterator {
+    return reflection.isInstance(item, DynamicViewPredicateIterator);
 }
 
 export interface DynamicViewStep extends AstNode {
     readonly $container: DynamicViewBody;
     readonly $type: 'DynamicViewStep';
+    custom?: CustomRelationProperties;
     isBackward: boolean;
     kind?: Reference<RelationshipKind>;
     source: ElementRef;
@@ -413,7 +468,7 @@ export function isElementBody(item: unknown): item is ElementBody {
 }
 
 export interface ElementDescedantsExpression extends AstNode {
-    readonly $container: CustomElementExpression | DirectedRelationExpression | DynamicViewRulePredicateIterator | ElementExpressionsIterator | Expressions | IncomingRelationExpression | OutgoingRelationExpression;
+    readonly $container: DirectedRelationExpression | DynamicViewPredicateIterator | ElementExpressionsIterator | ElementPredicateWhere | ElementPredicateWith | IncomingRelationExpression | OutgoingRelationExpression | Predicates;
     readonly $type: 'ElementDescedantsExpression';
     parent: ElementRef;
 }
@@ -450,7 +505,7 @@ export function isElementKind(item: unknown): item is ElementKind {
 }
 
 export interface ElementKindExpression extends AstNode {
-    readonly $container: CustomElementExpression | DirectedRelationExpression | DynamicViewRulePredicateIterator | ElementExpressionsIterator | Expressions | IncomingRelationExpression | OutgoingRelationExpression;
+    readonly $container: DirectedRelationExpression | DynamicViewPredicateIterator | ElementExpressionsIterator | ElementPredicateWhere | ElementPredicateWith | IncomingRelationExpression | OutgoingRelationExpression | Predicates;
     readonly $type: 'ElementKindExpression';
     isEqual: boolean;
     kind?: Reference<ElementKind>;
@@ -462,10 +517,35 @@ export function isElementKindExpression(item: unknown): item is ElementKindExpre
     return reflection.isInstance(item, ElementKindExpression);
 }
 
+export interface ElementPredicateWhere extends AstNode {
+    readonly $container: DynamicViewPredicateIterator | ElementPredicateWith | Predicates;
+    readonly $type: 'ElementPredicateWhere';
+    subject: ElementExpression;
+    where?: WhereElementExpression;
+}
+
+export const ElementPredicateWhere = 'ElementPredicateWhere';
+
+export function isElementPredicateWhere(item: unknown): item is ElementPredicateWhere {
+    return reflection.isInstance(item, ElementPredicateWhere);
+}
+
+export interface ElementPredicateWith extends AstNode {
+    readonly $container: DynamicViewPredicateIterator | Predicates;
+    readonly $type: 'ElementPredicateWith';
+    custom?: CustomElementProperties;
+    subject: ElementPredicateOrWhere;
+}
+
+export const ElementPredicateWith = 'ElementPredicateWith';
+
+export function isElementPredicateWith(item: unknown): item is ElementPredicateWith {
+    return reflection.isInstance(item, ElementPredicateWith);
+}
+
 export interface ElementRef extends AstNode {
-    readonly $container: CustomElementExpression | DirectedRelationExpression | DynamicViewRulePredicateIterator | DynamicViewStep | ElementDescedantsExpression | ElementExpressionsIterator | ElementRef | ElementView | ExpandElementExpression | ExplicitRelation | Expressions | ImplicitRelation | IncomingRelationExpression | OutgoingRelationExpression;
+    readonly $container: DirectedRelationExpression | DynamicViewPredicateIterator | DynamicViewStep | ElementDescedantsExpression | ElementExpressionsIterator | ElementPredicateWhere | ElementPredicateWith | ElementRef | ElementView | ExpandElementExpression | ExplicitRelation | ImplicitRelation | IncomingRelationExpression | OutgoingRelationExpression | Predicates;
     readonly $type: 'ElementRef';
-    dot?: string;
     el: Reference<Element>;
     parent?: ElementRef;
 }
@@ -490,7 +570,7 @@ export function isElementStringProperty(item: unknown): item is ElementStringPro
 }
 
 export interface ElementTagExpression extends AstNode {
-    readonly $container: CustomElementExpression | DirectedRelationExpression | DynamicViewRulePredicateIterator | ElementExpressionsIterator | Expressions | IncomingRelationExpression | OutgoingRelationExpression;
+    readonly $container: DirectedRelationExpression | DynamicViewPredicateIterator | ElementExpressionsIterator | ElementPredicateWhere | ElementPredicateWith | IncomingRelationExpression | OutgoingRelationExpression | Predicates;
     readonly $type: 'ElementTagExpression';
     isEqual: boolean;
     tag?: Reference<Tag>;
@@ -505,7 +585,7 @@ export function isElementTagExpression(item: unknown): item is ElementTagExpress
 export interface ElementView extends AstNode {
     readonly $container: ModelViews;
     readonly $type: 'ElementView';
-    body: ElementViewBody;
+    body?: ElementViewBody;
     extends?: ElementViewRef;
     name?: Id;
     viewOf?: ElementRef;
@@ -546,7 +626,7 @@ export function isElementViewRef(item: unknown): item is ElementViewRef {
 export interface ExcludePredicate extends AstNode {
     readonly $container: ElementViewBody;
     readonly $type: 'ExcludePredicate';
-    exprs: Expressions;
+    predicates: Predicates;
 }
 
 export const ExcludePredicate = 'ExcludePredicate';
@@ -556,7 +636,7 @@ export function isExcludePredicate(item: unknown): item is ExcludePredicate {
 }
 
 export interface ExpandElementExpression extends AstNode {
-    readonly $container: CustomElementExpression | DirectedRelationExpression | DynamicViewRulePredicateIterator | ElementExpressionsIterator | Expressions | IncomingRelationExpression | OutgoingRelationExpression;
+    readonly $container: DirectedRelationExpression | DynamicViewPredicateIterator | ElementExpressionsIterator | ElementPredicateWhere | ElementPredicateWith | IncomingRelationExpression | OutgoingRelationExpression | Predicates;
     readonly $type: 'ExpandElementExpression';
     expand: ElementRef;
 }
@@ -584,19 +664,6 @@ 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';
@@ -625,7 +692,6 @@ export function isExtendElementBody(item: unknown): item is ExtendElementBody {
 export interface FqnElementRef extends AstNode {
     readonly $container: ExtendElement | FqnElementRef;
     readonly $type: 'FqnElementRef';
-    dot?: string;
     el: Reference<Element>;
     parent?: FqnElementRef;
 }
@@ -669,7 +735,7 @@ export function isImplicitRelation(item: unknown): item is ImplicitRelation {
 export interface IncludePredicate extends AstNode {
     readonly $container: ElementViewBody;
     readonly $type: 'IncludePredicate';
-    exprs: Expressions;
+    predicates: Predicates;
 }
 
 export const IncludePredicate = 'IncludePredicate';
@@ -679,7 +745,7 @@ export function isIncludePredicate(item: unknown): item is IncludePredicate {
 }
 
 export interface IncomingRelationExpression extends AstNode {
-    readonly $container: CustomRelationExpression | Expressions | InOutRelationExpression;
+    readonly $container: InOutRelationExpression | Predicates | RelationPredicateWhere | RelationPredicateWith;
     readonly $type: 'IncomingRelationExpression';
     to: ElementExpression;
 }
@@ -691,7 +757,7 @@ export function isIncomingRelationExpression(item: unknown): item is IncomingRel
 }
 
 export interface InOutRelationExpression extends AstNode {
-    readonly $container: CustomRelationExpression | Expressions;
+    readonly $container: Predicates | RelationPredicateWhere | RelationPredicateWith;
     readonly $type: 'InOutRelationExpression';
     inout: IncomingRelationExpression;
 }
@@ -783,7 +849,7 @@ export interface ModelViews extends AstNode {
     readonly $container: LikeC4Grammar;
     readonly $type: 'ModelViews';
     name: 'views';
-    views: Array<DynamicView | ElementView>;
+    views: Array<LikeC4View>;
 }
 
 export const ModelViews = 'ModelViews';
@@ -819,7 +885,7 @@ export function isOpacityProperty(item: unknown): item is OpacityProperty {
 }
 
 export interface OutgoingRelationExpression extends AstNode {
-    readonly $container: CustomRelationExpression | DirectedRelationExpression | Expressions;
+    readonly $container: DirectedRelationExpression | Predicates | RelationPredicateWhere | RelationPredicateWith;
     readonly $type: 'OutgoingRelationExpression';
     from: ElementExpression;
     isBidirectional: boolean;
@@ -832,6 +898,19 @@ export function isOutgoingRelationExpression(item: unknown): item is OutgoingRel
     return reflection.isInstance(item, OutgoingRelationExpression);
 }
 
+export interface Predicates extends AstNode {
+    readonly $container: ExcludePredicate | IncludePredicate | Predicates;
+    readonly $type: 'Predicates';
+    prev?: Predicates;
+    value: Predicate;
+}
+
+export const Predicates = 'Predicates';
+
+export function isPredicates(item: unknown): item is Predicates {
+    return reflection.isInstance(item, Predicates);
+}
+
 export interface RelationBody extends AstNode {
     readonly $container: ExplicitRelation | ImplicitRelation;
     readonly $type: 'RelationBody';
@@ -845,6 +924,32 @@ export function isRelationBody(item: unknown): item is RelationBody {
     return reflection.isInstance(item, RelationBody);
 }
 
+export interface RelationPredicateWhere extends AstNode {
+    readonly $container: Predicates | RelationPredicateWith;
+    readonly $type: 'RelationPredicateWhere';
+    subject: RelationExpression;
+    where?: WhereRelationExpression;
+}
+
+export const RelationPredicateWhere = 'RelationPredicateWhere';
+
+export function isRelationPredicateWhere(item: unknown): item is RelationPredicateWhere {
+    return reflection.isInstance(item, RelationPredicateWhere);
+}
+
+export interface RelationPredicateWith extends AstNode {
+    readonly $container: Predicates;
+    readonly $type: 'RelationPredicateWith';
+    custom?: CustomRelationProperties;
+    subject: RelationPredicateOrWhere;
+}
+
+export const RelationPredicateWith = 'RelationPredicateWith';
+
+export function isRelationPredicateWith(item: unknown): item is RelationPredicateWith {
+    return reflection.isInstance(item, RelationPredicateWith);
+}
+
 export interface RelationshipKind extends AstNode {
     readonly $container: SpecificationRelationshipKind;
     readonly $type: 'RelationshipKind';
@@ -860,7 +965,7 @@ export function isRelationshipKind(item: unknown): item is RelationshipKind {
 export interface RelationStringProperty extends AstNode {
     readonly $container: CustomRelationProperties | RelationBody;
     readonly $type: 'RelationStringProperty';
-    key: 'title';
+    key: 'description' | 'technology' | 'title';
     value: string;
 }
 
@@ -975,9 +1080,10 @@ export function isTag(item: unknown): item is Tag {
 }
 
 export interface Tags extends AstNode {
-    readonly $container: DynamicViewBody | ElementBody | ElementViewBody | ExplicitRelation | ImplicitRelation | RelationBody;
+    readonly $container: DynamicViewBody | ElementBody | ElementViewBody | ExplicitRelation | ImplicitRelation | RelationBody | Tags;
     readonly $type: 'Tags';
-    value: Array<Reference<Tag>>;
+    prev?: Tags;
+    values: Array<Reference<Tag>>;
 }
 
 export const Tags = 'Tags';
@@ -1036,8 +1142,102 @@ export function isViewStringProperty(item: unknown): item is ViewStringProperty
     return reflection.isInstance(item, ViewStringProperty);
 }
 
+export interface WhereBinaryExpression extends AstNode {
+    readonly $container: ElementPredicateWhere | RelationPredicateWhere | WhereBinaryExpression | WhereElementNegation | WhereRelationNegation;
+    readonly $type: 'WhereBinaryExpression';
+    left: WhereElementExpression | WhereRelationExpression;
+    operator: 'and' | 'or';
+    right: WhereElementExpression | WhereRelationExpression;
+}
+
+export const WhereBinaryExpression = 'WhereBinaryExpression';
+
+export function isWhereBinaryExpression(item: unknown): item is WhereBinaryExpression {
+    return reflection.isInstance(item, WhereBinaryExpression);
+}
+
+export interface WhereElementKind extends AstNode {
+    readonly $container: ElementPredicateWhere | WhereBinaryExpression | WhereElementNegation;
+    readonly $type: 'WhereElementKind';
+    not: boolean;
+    operator: 'is' | string;
+    value?: Reference<ElementKind>;
+}
+
+export const WhereElementKind = 'WhereElementKind';
+
+export function isWhereElementKind(item: unknown): item is WhereElementKind {
+    return reflection.isInstance(item, WhereElementKind);
+}
+
+export interface WhereElementNegation extends AstNode {
+    readonly $container: ElementPredicateWhere | WhereBinaryExpression | WhereElementNegation;
+    readonly $type: 'WhereElementNegation';
+    value: WhereElementExpression;
+}
+
+export const WhereElementNegation = 'WhereElementNegation';
+
+export function isWhereElementNegation(item: unknown): item is WhereElementNegation {
+    return reflection.isInstance(item, WhereElementNegation);
+}
+
+export interface WhereElementTag extends AstNode {
+    readonly $container: ElementPredicateWhere | WhereBinaryExpression | WhereElementNegation;
+    readonly $type: 'WhereElementTag';
+    not: boolean;
+    operator: 'is' | string;
+    value?: Reference<Tag>;
+}
+
+export const WhereElementTag = 'WhereElementTag';
+
+export function isWhereElementTag(item: unknown): item is WhereElementTag {
+    return reflection.isInstance(item, WhereElementTag);
+}
+
+export interface WhereRelationKind extends AstNode {
+    readonly $container: RelationPredicateWhere | WhereBinaryExpression | WhereRelationNegation;
+    readonly $type: 'WhereRelationKind';
+    not: boolean;
+    operator: 'is' | string;
+    value?: Reference<RelationshipKind>;
+}
+
+export const WhereRelationKind = 'WhereRelationKind';
+
+export function isWhereRelationKind(item: unknown): item is WhereRelationKind {
+    return reflection.isInstance(item, WhereRelationKind);
+}
+
+export interface WhereRelationNegation extends AstNode {
+    readonly $container: RelationPredicateWhere | WhereBinaryExpression | WhereRelationNegation;
+    readonly $type: 'WhereRelationNegation';
+    value: WhereRelationExpression;
+}
+
+export const WhereRelationNegation = 'WhereRelationNegation';
+
+export function isWhereRelationNegation(item: unknown): item is WhereRelationNegation {
+    return reflection.isInstance(item, WhereRelationNegation);
+}
+
+export interface WhereRelationTag extends AstNode {
+    readonly $container: RelationPredicateWhere | WhereBinaryExpression | WhereRelationNegation;
+    readonly $type: 'WhereRelationTag';
+    not: boolean;
+    operator: 'is' | string;
+    value?: Reference<Tag>;
+}
+
+export const WhereRelationTag = 'WhereRelationTag';
+
+export function isWhereRelationTag(item: unknown): item is WhereRelationTag {
+    return reflection.isInstance(item, WhereRelationTag);
+}
+
 export interface WildcardExpression extends AstNode {
-    readonly $container: CustomElementExpression | DirectedRelationExpression | DynamicViewRulePredicateIterator | ElementExpressionsIterator | Expressions | IncomingRelationExpression | OutgoingRelationExpression;
+    readonly $container: DirectedRelationExpression | DynamicViewPredicateIterator | ElementExpressionsIterator | ElementPredicateWhere | ElementPredicateWith | IncomingRelationExpression | OutgoingRelationExpression | Predicates;
     readonly $type: 'WildcardExpression';
     isWildcard: boolean;
 }
@@ -1052,17 +1252,14 @@ export type LikeC4AstType = {
     ArrowProperty: ArrowProperty
     BorderProperty: BorderProperty
     ColorProperty: ColorProperty
-    CustomElementExpression: CustomElementExpression
     CustomElementProperties: CustomElementProperties
-    CustomRelationExpression: CustomRelationExpression
     CustomRelationProperties: CustomRelationProperties
     DirectedRelationExpression: DirectedRelationExpression
     DynamicView: DynamicView
     DynamicViewBody: DynamicViewBody
-    DynamicViewElementExpression: DynamicViewElementExpression
+    DynamicViewIncludePredicate: DynamicViewIncludePredicate
+    DynamicViewPredicateIterator: DynamicViewPredicateIterator
     DynamicViewRule: DynamicViewRule
-    DynamicViewRulePredicate: DynamicViewRulePredicate
-    DynamicViewRulePredicateIterator: DynamicViewRulePredicateIterator
     DynamicViewStep: DynamicViewStep
     Element: Element
     ElementBody: ElementBody
@@ -1071,6 +1268,10 @@ export type LikeC4AstType = {
     ElementExpressionsIterator: ElementExpressionsIterator
     ElementKind: ElementKind
     ElementKindExpression: ElementKindExpression
+    ElementPredicate: ElementPredicate
+    ElementPredicateOrWhere: ElementPredicateOrWhere
+    ElementPredicateWhere: ElementPredicateWhere
+    ElementPredicateWith: ElementPredicateWith
     ElementProperty: ElementProperty
     ElementRef: ElementRef
     ElementStringProperty: ElementStringProperty
@@ -1081,8 +1282,6 @@ export type LikeC4AstType = {
     ExcludePredicate: ExcludePredicate
     ExpandElementExpression: ExpandElementExpression
     ExplicitRelation: ExplicitRelation
-    Expression: Expression
-    Expressions: Expressions
     ExtendElement: ExtendElement
     ExtendElementBody: ExtendElementBody
     FqnElementRef: FqnElementRef
@@ -1102,9 +1301,15 @@ export type LikeC4AstType = {
     NavigateToProperty: NavigateToProperty
     OpacityProperty: OpacityProperty
     OutgoingRelationExpression: OutgoingRelationExpression
+    Predicate: Predicate
+    Predicates: Predicates
     Relation: Relation
     RelationBody: RelationBody
     RelationExpression: RelationExpression
+    RelationPredicate: RelationPredicate
+    RelationPredicateOrWhere: RelationPredicateOrWhere
+    RelationPredicateWhere: RelationPredicateWhere
+    RelationPredicateWith: RelationPredicateWith
     RelationProperty: RelationProperty
     RelationStringProperty: RelationStringProperty
     RelationStyleProperty: RelationStyleProperty
@@ -1127,13 +1332,27 @@ export type LikeC4AstType = {
     ViewRulePredicate: ViewRulePredicate
     ViewRuleStyle: ViewRuleStyle
     ViewStringProperty: ViewStringProperty
+    WhereBinaryExpression: WhereBinaryExpression
+    WhereElement: WhereElement
+    WhereElementExpression: WhereElementExpression
+    WhereElementKind: WhereElementKind
+    WhereElementNegation: WhereElementNegation
+    WhereElementTag: WhereElementTag
+    WhereExpression: WhereExpression
+    WhereKindEqual: WhereKindEqual
+    WhereRelation: WhereRelation
+    WhereRelationExpression: WhereRelationExpression
+    WhereRelationKind: WhereRelationKind
+    WhereRelationNegation: WhereRelationNegation
+    WhereRelationTag: WhereRelationTag
+    WhereTagEqual: WhereTagEqual
     WildcardExpression: WildcardExpression
 }
 
 export class LikeC4AstReflection extends AbstractAstReflection {
 
     getAllTypes(): string[] {
-        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];
+        return [ArrowProperty, BorderProperty, ColorProperty, CustomElementProperties, CustomRelationProperties, DirectedRelationExpression, DynamicView, DynamicViewBody, DynamicViewIncludePredicate, DynamicViewPredicateIterator, DynamicViewRule, DynamicViewStep, Element, ElementBody, ElementDescedantsExpression, ElementExpression, ElementExpressionsIterator, ElementKind, ElementKindExpression, ElementPredicate, ElementPredicateOrWhere, ElementPredicateWhere, ElementPredicateWith, ElementProperty, ElementRef, ElementStringProperty, ElementTagExpression, ElementView, ElementViewBody, ElementViewRef, ExcludePredicate, ExpandElementExpression, ExplicitRelation, ExtendElement, ExtendElementBody, FqnElementRef, IconProperty, ImplicitRelation, InOutRelationExpression, IncludePredicate, IncomingRelationExpression, LibIcon, LikeC4Grammar, LikeC4Lib, LikeC4View, LineProperty, LinkProperty, Model, ModelViews, NavigateToProperty, OpacityProperty, OutgoingRelationExpression, Predicate, Predicates, Relation, RelationBody, RelationExpression, RelationPredicate, RelationPredicateOrWhere, RelationPredicateWhere, RelationPredicateWith, RelationProperty, RelationStringProperty, RelationStyleProperty, RelationshipKind, RelationshipStyleProperty, ShapeProperty, SpecificationElementKind, SpecificationRelationshipKind, SpecificationRule, SpecificationTag, StringProperty, StyleProperties, StyleProperty, Tag, Tags, ViewProperty, ViewRef, ViewRule, ViewRuleAutoLayout, ViewRulePredicate, ViewRuleStyle, ViewStringProperty, WhereBinaryExpression, WhereElement, WhereElementExpression, WhereElementKind, WhereElementNegation, WhereElementTag, WhereExpression, WhereKindEqual, WhereRelation, WhereRelationExpression, WhereRelationKind, WhereRelationNegation, WhereRelationTag, WhereTagEqual, WildcardExpression];
     }
 
     protected override computeIsSubtype(subtype: string, supertype: string): boolean {
@@ -1150,14 +1369,6 @@ export class LikeC4AstReflection extends AbstractAstReflection {
             case ColorProperty: {
                 return this.isSubtype(RelationshipStyleProperty, supertype) || this.isSubtype(StyleProperty, supertype);
             }
-            case CustomElementExpression:
-            case ElementExpression: {
-                return this.isSubtype(DynamicViewElementExpression, supertype) || this.isSubtype(Expression, supertype);
-            }
-            case CustomRelationExpression:
-            case RelationExpression: {
-                return this.isSubtype(Expression, supertype);
-            }
             case DirectedRelationExpression:
             case IncomingRelationExpression:
             case InOutRelationExpression:
@@ -1168,7 +1379,7 @@ export class LikeC4AstReflection extends AbstractAstReflection {
             case ElementView: {
                 return this.isSubtype(LikeC4View, supertype);
             }
-            case DynamicViewRulePredicate: {
+            case DynamicViewIncludePredicate: {
                 return this.isSubtype(DynamicViewRule, supertype);
             }
             case ElementDescedantsExpression:
@@ -1179,6 +1390,18 @@ export class LikeC4AstReflection extends AbstractAstReflection {
             case WildcardExpression: {
                 return this.isSubtype(ElementExpression, supertype);
             }
+            case ElementExpression:
+            case ElementPredicateWhere: {
+                return this.isSubtype(ElementPredicateOrWhere, supertype);
+            }
+            case ElementPredicate:
+            case RelationPredicate: {
+                return this.isSubtype(Predicate, supertype);
+            }
+            case ElementPredicateOrWhere:
+            case ElementPredicateWith: {
+                return this.isSubtype(ElementPredicate, supertype);
+            }
             case ElementStringProperty: {
                 return this.isSubtype(ElementProperty, supertype) || this.isSubtype(StringProperty, supertype);
             }
@@ -1196,6 +1419,14 @@ export class LikeC4AstReflection extends AbstractAstReflection {
             case LinkProperty: {
                 return this.isSubtype(ElementProperty, supertype) || this.isSubtype(RelationProperty, supertype) || this.isSubtype(ViewProperty, supertype);
             }
+            case RelationExpression:
+            case RelationPredicateWhere: {
+                return this.isSubtype(RelationPredicateOrWhere, supertype);
+            }
+            case RelationPredicateOrWhere:
+            case RelationPredicateWith: {
+                return this.isSubtype(RelationPredicate, supertype);
+            }
             case RelationStringProperty: {
                 return this.isSubtype(RelationProperty, supertype) || this.isSubtype(StringProperty, supertype);
             }
@@ -1215,6 +1446,33 @@ export class LikeC4AstReflection extends AbstractAstReflection {
             case ViewStringProperty: {
                 return this.isSubtype(StringProperty, supertype) || this.isSubtype(ViewProperty, supertype);
             }
+            case WhereBinaryExpression: {
+                return this.isSubtype(WhereElementExpression, supertype) || this.isSubtype(WhereRelationExpression, supertype);
+            }
+            case WhereElement:
+            case WhereElementNegation: {
+                return this.isSubtype(WhereElementExpression, supertype);
+            }
+            case WhereElementExpression:
+            case WhereRelationExpression: {
+                return this.isSubtype(WhereExpression, supertype);
+            }
+            case WhereElementKind: {
+                return this.isSubtype(WhereElement, supertype) || this.isSubtype(WhereKindEqual, supertype);
+            }
+            case WhereElementTag: {
+                return this.isSubtype(WhereElement, supertype) || this.isSubtype(WhereTagEqual, supertype);
+            }
+            case WhereRelation:
+            case WhereRelationNegation: {
+                return this.isSubtype(WhereRelationExpression, supertype);
+            }
+            case WhereRelationKind: {
+                return this.isSubtype(WhereKindEqual, supertype) || this.isSubtype(WhereRelation, supertype);
+            }
+            case WhereRelationTag: {
+                return this.isSubtype(WhereRelation, supertype) || this.isSubtype(WhereTagEqual, supertype);
+            }
             default: {
                 return false;
             }
@@ -1227,11 +1485,13 @@ export class LikeC4AstReflection extends AbstractAstReflection {
             case 'DynamicViewStep:kind':
             case 'ExplicitRelation:kind':
             case 'ImplicitRelation:kind':
-            case 'OutgoingRelationExpression:kind': {
+            case 'OutgoingRelationExpression:kind':
+            case 'WhereRelationKind:value': {
                 return RelationshipKind;
             }
             case 'Element:kind':
-            case 'ElementKindExpression:kind': {
+            case 'ElementKindExpression:kind':
+            case 'WhereElementKind:value': {
                 return ElementKind;
             }
             case 'ElementRef:el':
@@ -1239,7 +1499,9 @@ export class LikeC4AstReflection extends AbstractAstReflection {
                 return Element;
             }
             case 'ElementTagExpression:tag':
-            case 'Tags:value': {
+            case 'Tags:values':
+            case 'WhereElementTag:value':
+            case 'WhereRelationTag:value': {
                 return Tag;
             }
             case 'ElementViewRef:view': {
@@ -1286,15 +1548,6 @@ export class LikeC4AstReflection extends AbstractAstReflection {
                     ]
                 };
             }
-            case CustomElementExpression: {
-                return {
-                    name: CustomElementExpression,
-                    properties: [
-                        { name: 'custom' },
-                        { name: 'target' }
-                    ]
-                };
-            }
             case CustomElementProperties: {
                 return {
                     name: CustomElementProperties,
@@ -1303,15 +1556,6 @@ export class LikeC4AstReflection extends AbstractAstReflection {
                     ]
                 };
             }
-            case CustomRelationExpression: {
-                return {
-                    name: CustomRelationExpression,
-                    properties: [
-                        { name: 'custom' },
-                        { name: 'relation' }
-                    ]
-                };
-            }
             case CustomRelationProperties: {
                 return {
                     name: CustomRelationProperties,
@@ -1349,17 +1593,17 @@ export class LikeC4AstReflection extends AbstractAstReflection {
                     ]
                 };
             }
-            case DynamicViewRulePredicate: {
+            case DynamicViewIncludePredicate: {
                 return {
-                    name: DynamicViewRulePredicate,
+                    name: DynamicViewIncludePredicate,
                     properties: [
-                        { name: 'exprs' }
+                        { name: 'predicates' }
                     ]
                 };
             }
-            case DynamicViewRulePredicateIterator: {
+            case DynamicViewPredicateIterator: {
                 return {
-                    name: DynamicViewRulePredicateIterator,
+                    name: DynamicViewPredicateIterator,
                     properties: [
                         { name: 'prev' },
                         { name: 'value' }
@@ -1370,6 +1614,7 @@ export class LikeC4AstReflection extends AbstractAstReflection {
                 return {
                     name: DynamicViewStep,
                     properties: [
+                        { name: 'custom' },
                         { name: 'isBackward', defaultValue: false },
                         { name: 'kind' },
                         { name: 'source' },
@@ -1433,11 +1678,28 @@ export class LikeC4AstReflection extends AbstractAstReflection {
                     ]
                 };
             }
+            case ElementPredicateWhere: {
+                return {
+                    name: ElementPredicateWhere,
+                    properties: [
+                        { name: 'subject' },
+                        { name: 'where' }
+                    ]
+                };
+            }
+            case ElementPredicateWith: {
+                return {
+                    name: ElementPredicateWith,
+                    properties: [
+                        { name: 'custom' },
+                        { name: 'subject' }
+                    ]
+                };
+            }
             case ElementRef: {
                 return {
                     name: ElementRef,
                     properties: [
-                        { name: 'dot' },
                         { name: 'el' },
                         { name: 'parent' }
                     ]
@@ -1494,7 +1756,7 @@ export class LikeC4AstReflection extends AbstractAstReflection {
                 return {
                     name: ExcludePredicate,
                     properties: [
-                        { name: 'exprs' }
+                        { name: 'predicates' }
                     ]
                 };
             }
@@ -1519,15 +1781,6 @@ export class LikeC4AstReflection extends AbstractAstReflection {
                     ]
                 };
             }
-            case Expressions: {
-                return {
-                    name: Expressions,
-                    properties: [
-                        { name: 'prev' },
-                        { name: 'value' }
-                    ]
-                };
-            }
             case ExtendElement: {
                 return {
                     name: ExtendElement,
@@ -1549,7 +1802,6 @@ export class LikeC4AstReflection extends AbstractAstReflection {
                 return {
                     name: FqnElementRef,
                     properties: [
-                        { name: 'dot' },
                         { name: 'el' },
                         { name: 'parent' }
                     ]
@@ -1581,7 +1833,7 @@ export class LikeC4AstReflection extends AbstractAstReflection {
                 return {
                     name: IncludePredicate,
                     properties: [
-                        { name: 'exprs' }
+                        { name: 'predicates' }
                     ]
                 };
             }
@@ -1692,6 +1944,15 @@ export class LikeC4AstReflection extends AbstractAstReflection {
                     ]
                 };
             }
+            case Predicates: {
+                return {
+                    name: Predicates,
+                    properties: [
+                        { name: 'prev' },
+                        { name: 'value' }
+                    ]
+                };
+            }
             case RelationBody: {
                 return {
                     name: RelationBody,
@@ -1701,6 +1962,24 @@ export class LikeC4AstReflection extends AbstractAstReflection {
                     ]
                 };
             }
+            case RelationPredicateWhere: {
+                return {
+                    name: RelationPredicateWhere,
+                    properties: [
+                        { name: 'subject' },
+                        { name: 'where' }
+                    ]
+                };
+            }
+            case RelationPredicateWith: {
+                return {
+                    name: RelationPredicateWith,
+                    properties: [
+                        { name: 'custom' },
+                        { name: 'subject' }
+                    ]
+                };
+            }
             case RelationshipKind: {
                 return {
                     name: RelationshipKind,
@@ -1794,7 +2073,8 @@ export class LikeC4AstReflection extends AbstractAstReflection {
                 return {
                     name: Tags,
                     properties: [
-                        { name: 'value', defaultValue: [] }
+                        { name: 'prev' },
+                        { name: 'values', defaultValue: [] }
                     ]
                 };
             }
@@ -1832,6 +2112,72 @@ export class LikeC4AstReflection extends AbstractAstReflection {
                     ]
                 };
             }
+            case WhereBinaryExpression: {
+                return {
+                    name: WhereBinaryExpression,
+                    properties: [
+                        { name: 'left' },
+                        { name: 'operator' },
+                        { name: 'right' }
+                    ]
+                };
+            }
+            case WhereElementKind: {
+                return {
+                    name: WhereElementKind,
+                    properties: [
+                        { name: 'not', defaultValue: false },
+                        { name: 'operator' },
+                        { name: 'value' }
+                    ]
+                };
+            }
+            case WhereElementNegation: {
+                return {
+                    name: WhereElementNegation,
+                    properties: [
+                        { name: 'value' }
+                    ]
+                };
+            }
+            case WhereElementTag: {
+                return {
+                    name: WhereElementTag,
+                    properties: [
+                        { name: 'not', defaultValue: false },
+                        { name: 'operator' },
+                        { name: 'value' }
+                    ]
+                };
+            }
+            case WhereRelationKind: {
+                return {
+                    name: WhereRelationKind,
+                    properties: [
+                        { name: 'not', defaultValue: false },
+                        { name: 'operator' },
+                        { name: 'value' }
+                    ]
+                };
+            }
+            case WhereRelationNegation: {
+                return {
+                    name: WhereRelationNegation,
+                    properties: [
+                        { name: 'value' }
+                    ]
+                };
+            }
+            case WhereRelationTag: {
+                return {
+                    name: WhereRelationTag,
+                    properties: [
+                        { name: 'not', defaultValue: false },
+                        { name: 'operator' },
+                        { name: 'value' }
+                    ]
+                };
+            }
             case WildcardExpression: {
                 return {
                     name: WildcardExpression,