@likec4/language-server 1.17.1 → 1.19.0

package/src/generated/ast.ts

@@ -15,8 +15,8 @@ export const LikeC4Terminals = {
     LIB_ICON: /(aws|azure|gcp|tech):[-\w]*/,
     URI_WITH_SCHEMA: /\w+:\/\/\S+/,
     URI_RELATIVE: /\.{0,2}\/[^\/]\S+/,
-    DotUnderscore: /\b\._/,
-    DotWildcard: /\b\.\*/,
+    DotUnderscore: /\b\._(?![_a-zA-Z])/,
+    DotWildcard: /\b\.\*{1,2}/,
     Hash: /#/,
     StickyDot: /\b\./,
     Dot: /\./,
@@ -57,6 +57,8 @@ export type LikeC4KeywordNames =
     | "crow"
     | "cylinder"
     | "dashed"
+    | "deployment"
+    | "deploymentNode"
     | "description"
     | "diamond"
     | "dot"
@@ -78,6 +80,8 @@ export type LikeC4KeywordNames =
     | "icons"
     | "include"
     | "indigo"
+    | "instance"
+    | "instanceOf"
     | "is"
     | "kind"
     | "likec4lib"
@@ -88,6 +92,7 @@ export type LikeC4KeywordNames =
     | "model"
     | "muted"
     | "navigateTo"
+    | "node"
     | "none"
     | "normal"
     | "not"
@@ -157,6 +162,22 @@ export function isCustomColorValue(item: unknown): item is CustomColorValue {
     return typeof item === 'string';
 }
 
+export type DeploymentElement = DeployedInstance | DeploymentNode;
+
+export const DeploymentElement = 'DeploymentElement';
+
+export function isDeploymentElement(item: unknown): item is DeploymentElement {
+    return reflection.isInstance(item, DeploymentElement);
+}
+
+export type DeploymentViewRule = DeploymentViewRulePredicate | DeploymentViewRuleStyle | ViewRuleAutoLayout;
+
+export const DeploymentViewRule = 'DeploymentViewRule';
+
+export function isDeploymentViewRule(item: unknown): item is DeploymentViewRule {
+    return reflection.isInstance(item, DeploymentViewRule);
+}
+
 export type DotId = string;
 
 export function isDotId(item: unknown): item is DotId {
@@ -209,19 +230,43 @@ 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 ExpressionV2 = FqnExpr | RelationExpr;
+
+export const ExpressionV2 = 'ExpressionV2';
+
+export function isExpressionV2(item: unknown): item is ExpressionV2 {
+    return reflection.isInstance(item, ExpressionV2);
+}
+
+export type FqnExpr = FqnRefExpr | WildcardExpression;
+
+export const FqnExpr = 'FqnExpr';
+
+export function isFqnExpr(item: unknown): item is FqnExpr {
+    return reflection.isInstance(item, FqnExpr);
+}
+
+export type FqnReferenceable = Element | ExtendElement | Referenceable;
+
+export const FqnReferenceable = 'FqnReferenceable';
+
+export function isFqnReferenceable(item: unknown): item is FqnReferenceable {
+    return reflection.isInstance(item, FqnReferenceable);
+}
+
 export type IconId = string;
 
 export function isIconId(item: unknown): item is IconId {
     return (typeof item === 'string' && (/(aws|azure|gcp|tech):[-\w]*/.test(item)));
 }
 
-export type Id = 'element' | 'group' | 'model' | ArrowType | ElementShape | LineOptions | ThemeColor | string;
+export type Id = 'deployment' | 'element' | 'group' | 'instance' | 'model' | 'node' | 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' || item === 'group' || (typeof item === 'string' && (/[_]*[a-zA-Z][-\w]*/.test(item)));
+    return isElementShape(item) || isThemeColor(item) || isArrowType(item) || isLineOptions(item) || item === 'element' || item === 'model' || item === 'group' || item === 'node' || item === 'deployment' || item === 'instance' || (typeof item === 'string' && (/[_]*[a-zA-Z][-\w]*/.test(item)));
 }
 
-export type LikeC4View = DynamicView | ElementView;
+export type LikeC4View = DeploymentView | DynamicView | ElementView;
 
 export const LikeC4View = 'LikeC4View';
 
@@ -251,6 +296,22 @@ export function isPredicate(item: unknown): item is Predicate {
     return reflection.isInstance(item, Predicate);
 }
 
+export type Referenceable = DeployedInstance | DeploymentNode | Element;
+
+export const Referenceable = 'Referenceable';
+
+export function isReferenceable(item: unknown): item is Referenceable {
+    return reflection.isInstance(item, Referenceable);
+}
+
+export type RelationExpr = DirectedRelationExpr | InOutRelationExpr | IncomingRelationExpr | OutgoingRelationExpr;
+
+export const RelationExpr = 'RelationExpr';
+
+export function isRelationExpr(item: unknown): item is RelationExpr {
+    return reflection.isInstance(item, RelationExpr);
+}
+
 export type RelationExpression = DirectedRelationExpression | InOutRelationExpression | IncomingRelationExpression | OutgoingRelationExpression;
 
 export const RelationExpression = 'RelationExpression';
@@ -433,7 +494,7 @@ export function isArrowProperty(item: unknown): item is ArrowProperty {
 }
 
 export interface BorderProperty extends AstNode {
-    readonly $container: CustomElementProperties | ElementStyleProperty | GlobalStyle | ViewRuleGroup | ViewRuleStyle;
+    readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleGroup | ViewRuleStyle;
     readonly $type: 'BorderProperty';
     key: 'border';
     value: BorderStyleValue;
@@ -446,7 +507,7 @@ export function isBorderProperty(item: unknown): item is BorderProperty {
 }
 
 export interface ColorProperty extends AstNode {
-    readonly $container: CustomElementProperties | CustomRelationProperties | ElementStyleProperty | GlobalStyle | RelationStyleProperty | SpecificationRelationshipKind | ViewRuleGroup | ViewRuleStyle;
+    readonly $container: CustomElementProperties | CustomRelationProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | RelationStyleProperty | SpecificationRelationshipKind | ViewRuleGroup | ViewRuleStyle;
     readonly $type: 'ColorProperty';
     customColor?: Reference<CustomColor>;
     key: 'color';
@@ -495,6 +556,185 @@ export function isCustomRelationProperties(item: unknown): item is CustomRelatio
     return reflection.isInstance(item, CustomRelationProperties);
 }
 
+export interface DeployedInstance extends AstNode {
+    readonly $container: DeploymentNodeBody;
+    readonly $type: 'DeployedInstance';
+    body?: DeployedInstanceBody;
+    element: ElementRef;
+    name?: Id;
+    title?: string;
+}
+
+export const DeployedInstance = 'DeployedInstance';
+
+export function isDeployedInstance(item: unknown): item is DeployedInstance {
+    return reflection.isInstance(item, DeployedInstance);
+}
+
+export interface DeployedInstanceBody extends AstNode {
+    readonly $container: DeployedInstance;
+    readonly $type: 'DeployedInstanceBody';
+    props: Array<ElementProperty>;
+    tags?: Tags;
+}
+
+export const DeployedInstanceBody = 'DeployedInstanceBody';
+
+export function isDeployedInstanceBody(item: unknown): item is DeployedInstanceBody {
+    return reflection.isInstance(item, DeployedInstanceBody);
+}
+
+export interface DeploymentNode extends AstNode {
+    readonly $container: DeploymentNodeBody | ModelDeployments;
+    readonly $type: 'DeploymentNode';
+    body?: DeploymentNodeBody;
+    kind: Reference<DeploymentNodeKind>;
+    name: Id;
+    title?: string;
+}
+
+export const DeploymentNode = 'DeploymentNode';
+
+export function isDeploymentNode(item: unknown): item is DeploymentNode {
+    return reflection.isInstance(item, DeploymentNode);
+}
+
+export interface DeploymentNodeBody extends AstNode {
+    readonly $container: DeploymentNode;
+    readonly $type: 'DeploymentNodeBody';
+    elements: Array<DeployedInstance | DeploymentNode | DeploymentRelation>;
+    props: Array<ElementProperty>;
+    tags?: Tags;
+}
+
+export const DeploymentNodeBody = 'DeploymentNodeBody';
+
+export function isDeploymentNodeBody(item: unknown): item is DeploymentNodeBody {
+    return reflection.isInstance(item, DeploymentNodeBody);
+}
+
+export interface DeploymentNodeKind extends AstNode {
+    readonly $container: SpecificationDeploymentNodeKind;
+    readonly $type: 'DeploymentNodeKind';
+    name: Id;
+}
+
+export const DeploymentNodeKind = 'DeploymentNodeKind';
+
+export function isDeploymentNodeKind(item: unknown): item is DeploymentNodeKind {
+    return reflection.isInstance(item, DeploymentNodeKind);
+}
+
+export interface DeploymentRelation extends AstNode {
+    readonly $container: DeploymentNodeBody | ModelDeployments;
+    readonly $type: 'DeploymentRelation';
+    body?: DeploymentRelationBody;
+    kind?: Reference<RelationshipKind>;
+    source: FqnRef;
+    tags?: Tags;
+    target: FqnRef;
+    technology?: string;
+    title?: string;
+}
+
+export const DeploymentRelation = 'DeploymentRelation';
+
+export function isDeploymentRelation(item: unknown): item is DeploymentRelation {
+    return reflection.isInstance(item, DeploymentRelation);
+}
+
+export interface DeploymentRelationBody extends AstNode {
+    readonly $container: DeploymentRelation;
+    readonly $type: 'DeploymentRelationBody';
+    props: Array<RelationProperty>;
+    tags?: Tags;
+}
+
+export const DeploymentRelationBody = 'DeploymentRelationBody';
+
+export function isDeploymentRelationBody(item: unknown): item is DeploymentRelationBody {
+    return reflection.isInstance(item, DeploymentRelationBody);
+}
+
+export interface DeploymentView extends AstNode {
+    readonly $container: ModelViews;
+    readonly $type: 'DeploymentView';
+    body?: DeploymentViewBody;
+    name: Id;
+}
+
+export const DeploymentView = 'DeploymentView';
+
+export function isDeploymentView(item: unknown): item is DeploymentView {
+    return reflection.isInstance(item, DeploymentView);
+}
+
+export interface DeploymentViewBody extends AstNode {
+    readonly $container: DeploymentView;
+    readonly $type: 'DeploymentViewBody';
+    props: Array<ViewProperty>;
+    rules: Array<DeploymentViewRule>;
+    tags?: Tags;
+}
+
+export const DeploymentViewBody = 'DeploymentViewBody';
+
+export function isDeploymentViewBody(item: unknown): item is DeploymentViewBody {
+    return reflection.isInstance(item, DeploymentViewBody);
+}
+
+export interface DeploymentViewRulePredicate extends AstNode {
+    readonly $container: DeploymentViewBody;
+    readonly $type: 'DeploymentViewRulePredicate';
+    expr: DeploymentViewRulePredicateExpression;
+    isInclude: boolean;
+}
+
+export const DeploymentViewRulePredicate = 'DeploymentViewRulePredicate';
+
+export function isDeploymentViewRulePredicate(item: unknown): item is DeploymentViewRulePredicate {
+    return reflection.isInstance(item, DeploymentViewRulePredicate);
+}
+
+export interface DeploymentViewRulePredicateExpression extends AstNode {
+    readonly $container: DeploymentViewRulePredicate | DeploymentViewRulePredicateExpression;
+    readonly $type: 'DeploymentViewRulePredicateExpression';
+    prev?: DeploymentViewRulePredicateExpression;
+    value: ExpressionV2;
+}
+
+export const DeploymentViewRulePredicateExpression = 'DeploymentViewRulePredicateExpression';
+
+export function isDeploymentViewRulePredicateExpression(item: unknown): item is DeploymentViewRulePredicateExpression {
+    return reflection.isInstance(item, DeploymentViewRulePredicateExpression);
+}
+
+export interface DeploymentViewRuleStyle extends AstNode {
+    readonly $container: DeploymentViewBody;
+    readonly $type: 'DeploymentViewRuleStyle';
+    props: Array<NotationProperty | StyleProperty>;
+    targets: FqnExpressions;
+}
+
+export const DeploymentViewRuleStyle = 'DeploymentViewRuleStyle';
+
+export function isDeploymentViewRuleStyle(item: unknown): item is DeploymentViewRuleStyle {
+    return reflection.isInstance(item, DeploymentViewRuleStyle);
+}
+
+export interface DirectedRelationExpr extends AstNode {
+    readonly $container: DeploymentViewRulePredicateExpression;
+    readonly $type: 'DirectedRelationExpr';
+    source: OutgoingRelationExpr;
+    target: FqnExpr;
+}
+
+export const DirectedRelationExpr = 'DirectedRelationExpr';
+
+export function isDirectedRelationExpr(item: unknown): item is DirectedRelationExpr {
+    return reflection.isInstance(item, DirectedRelationExpr);
+}
+
 export interface DirectedRelationExpression extends AstNode {
     readonly $container: Predicates | RelationPredicateWhere | RelationPredicateWith;
     readonly $type: 'DirectedRelationExpression';
@@ -647,6 +887,7 @@ export interface ElementDescedantsExpression extends AstNode {
     readonly $container: DirectedRelationExpression | DynamicViewPredicateIterator | ElementExpressionsIterator | ElementPredicateWhere | ElementPredicateWith | IncomingRelationExpression | OutgoingRelationExpression | Predicates;
     readonly $type: 'ElementDescedantsExpression';
     parent: ElementRef;
+    suffix: string;
 }
 
 export const ElementDescedantsExpression = 'ElementDescedantsExpression';
@@ -720,7 +961,7 @@ export function isElementPredicateWith(item: unknown): item is ElementPredicateW
 }
 
 export interface ElementRef extends AstNode {
-    readonly $container: DirectedRelationExpression | DynamicViewPredicateIterator | DynamicViewStep | ElementDescedantsExpression | ElementExpressionsIterator | ElementPredicateWhere | ElementPredicateWith | ElementRef | ElementView | ExpandElementExpression | IncomingRelationExpression | OutgoingRelationExpression | Predicates | Relation;
+    readonly $container: DeployedInstance | DirectedRelationExpression | DynamicViewPredicateIterator | DynamicViewStep | ElementDescedantsExpression | ElementExpressionsIterator | ElementPredicateWhere | ElementPredicateWith | ElementRef | ElementView | ExpandElementExpression | IncomingRelationExpression | OutgoingRelationExpression | Predicates | Relation;
     readonly $type: 'ElementRef';
     el: Reference<Element>;
     parent?: ElementRef;
@@ -733,7 +974,7 @@ export function isElementRef(item: unknown): item is ElementRef {
 }
 
 export interface ElementStringProperty extends AstNode {
-    readonly $container: CustomElementProperties | ElementBody;
+    readonly $container: CustomElementProperties | DeployedInstanceBody | DeploymentNodeBody | ElementBody;
     readonly $type: 'ElementStringProperty';
     key: 'description' | 'technology' | 'title';
     value: string;
@@ -746,7 +987,7 @@ export function isElementStringProperty(item: unknown): item is ElementStringPro
 }
 
 export interface ElementStyleProperty extends AstNode {
-    readonly $container: ElementBody | SpecificationElementKind;
+    readonly $container: DeployedInstanceBody | DeploymentNodeBody | ElementBody | SpecificationDeploymentNodeKind | SpecificationElementKind;
     readonly $type: 'ElementStyleProperty';
     key: 'style';
     props: Array<StyleProperty>;
@@ -874,6 +1115,45 @@ export function isFqnElementRef(item: unknown): item is FqnElementRef {
     return reflection.isInstance(item, FqnElementRef);
 }
 
+export interface FqnExpressions extends AstNode {
+    readonly $container: DeploymentViewRuleStyle | FqnExpressions;
+    readonly $type: 'FqnExpressions';
+    prev?: FqnExpressions;
+    value: FqnExpr;
+}
+
+export const FqnExpressions = 'FqnExpressions';
+
+export function isFqnExpressions(item: unknown): item is FqnExpressions {
+    return reflection.isInstance(item, FqnExpressions);
+}
+
+export interface FqnRef extends AstNode {
+    readonly $container: DeploymentRelation | FqnRef | FqnRefExpr;
+    readonly $type: 'FqnRef';
+    parent?: FqnRef;
+    value: Reference<Referenceable>;
+}
+
+export const FqnRef = 'FqnRef';
+
+export function isFqnRef(item: unknown): item is FqnRef {
+    return reflection.isInstance(item, FqnRef);
+}
+
+export interface FqnRefExpr extends AstNode {
+    readonly $container: DeploymentViewRulePredicateExpression | DirectedRelationExpr | FqnExpressions | IncomingRelationExpr | OutgoingRelationExpr;
+    readonly $type: 'FqnRefExpr';
+    ref: FqnRef;
+    selector?: string;
+}
+
+export const FqnRefExpr = 'FqnRefExpr';
+
+export function isFqnRefExpr(item: unknown): item is FqnRefExpr {
+    return reflection.isInstance(item, FqnRefExpr);
+}
+
 export interface GlobalDynamicPredicateGroup extends AstNode {
     readonly $container: Globals;
     readonly $type: 'GlobalDynamicPredicateGroup';
@@ -954,7 +1234,7 @@ export function isGlobalStyleId(item: unknown): item is GlobalStyleId {
 }
 
 export interface IconProperty extends AstNode {
-    readonly $container: CustomElementProperties | ElementBody | ElementStyleProperty | GlobalStyle | ViewRuleStyle;
+    readonly $container: CustomElementProperties | DeployedInstanceBody | DeploymentNodeBody | DeploymentViewRuleStyle | ElementBody | ElementStyleProperty | GlobalStyle | ViewRuleStyle;
     readonly $type: 'IconProperty';
     key: 'icon';
     libicon?: Reference<LibIcon>;
@@ -979,6 +1259,18 @@ export function isIncludePredicate(item: unknown): item is IncludePredicate {
     return reflection.isInstance(item, IncludePredicate);
 }
 
+export interface IncomingRelationExpr extends AstNode {
+    readonly $container: DeploymentViewRulePredicateExpression | InOutRelationExpr;
+    readonly $type: 'IncomingRelationExpr';
+    to: FqnExpr;
+}
+
+export const IncomingRelationExpr = 'IncomingRelationExpr';
+
+export function isIncomingRelationExpr(item: unknown): item is IncomingRelationExpr {
+    return reflection.isInstance(item, IncomingRelationExpr);
+}
+
 export interface IncomingRelationExpression extends AstNode {
     readonly $container: InOutRelationExpression | Predicates | RelationPredicateWhere | RelationPredicateWith;
     readonly $type: 'IncomingRelationExpression';
@@ -991,6 +1283,18 @@ export function isIncomingRelationExpression(item: unknown): item is IncomingRel
     return reflection.isInstance(item, IncomingRelationExpression);
 }
 
+export interface InOutRelationExpr extends AstNode {
+    readonly $container: DeploymentViewRulePredicateExpression;
+    readonly $type: 'InOutRelationExpr';
+    inout: IncomingRelationExpr;
+}
+
+export const InOutRelationExpr = 'InOutRelationExpr';
+
+export function isInOutRelationExpr(item: unknown): item is InOutRelationExpr {
+    return reflection.isInstance(item, InOutRelationExpr);
+}
+
 export interface InOutRelationExpression extends AstNode {
     readonly $container: Predicates | RelationPredicateWhere | RelationPredicateWith;
     readonly $type: 'InOutRelationExpression';
@@ -1017,6 +1321,7 @@ export function isLibIcon(item: unknown): item is LibIcon {
 
 export interface LikeC4Grammar extends AstNode {
     readonly $type: 'LikeC4Grammar';
+    deployments: Array<ModelDeployments>;
     globals: Array<Globals>;
     likec4lib: Array<LikeC4Lib>;
     models: Array<Model>;
@@ -1056,7 +1361,7 @@ export function isLineProperty(item: unknown): item is LineProperty {
 }
 
 export interface LinkProperty extends AstNode {
-    readonly $container: DynamicViewBody | ElementBody | ElementViewBody | RelationBody;
+    readonly $container: DeployedInstanceBody | DeploymentNodeBody | DeploymentRelationBody | DeploymentViewBody | DynamicViewBody | ElementBody | ElementViewBody | RelationBody;
     readonly $type: 'LinkProperty';
     key: 'link';
     title?: string;
@@ -1083,7 +1388,7 @@ export function isMetadataAttribute(item: unknown): item is MetadataAttribute {
 }
 
 export interface MetadataBody extends AstNode {
-    readonly $container: ElementBody | RelationBody;
+    readonly $container: DeployedInstanceBody | DeploymentNodeBody | DeploymentRelationBody | ElementBody | RelationBody;
     readonly $type: 'MetadataBody';
     props: Array<MetadataAttribute>;
 }
@@ -1107,6 +1412,19 @@ export function isModel(item: unknown): item is Model {
     return reflection.isInstance(item, Model);
 }
 
+export interface ModelDeployments extends AstNode {
+    readonly $container: LikeC4Grammar;
+    readonly $type: 'ModelDeployments';
+    elements: Array<DeploymentNode | DeploymentRelation>;
+    name: 'deployment';
+}
+
+export const ModelDeployments = 'ModelDeployments';
+
+export function isModelDeployments(item: unknown): item is ModelDeployments {
+    return reflection.isInstance(item, ModelDeployments);
+}
+
 export interface ModelViews extends AstNode {
     readonly $container: LikeC4Grammar;
     readonly $type: 'ModelViews';
@@ -1135,7 +1453,7 @@ export function isNavigateToProperty(item: unknown): item is NavigateToProperty
 }
 
 export interface NotationProperty extends AstNode {
-    readonly $container: CustomElementProperties | CustomRelationProperties | GlobalStyle | ViewRuleStyle;
+    readonly $container: CustomElementProperties | CustomRelationProperties | DeploymentViewRuleStyle | GlobalStyle | ViewRuleStyle;
     readonly $type: 'NotationProperty';
     key: 'notation';
     value: string;
@@ -1161,7 +1479,7 @@ export function isNotesProperty(item: unknown): item is NotesProperty {
 }
 
 export interface OpacityProperty extends AstNode {
-    readonly $container: CustomElementProperties | ElementStyleProperty | GlobalStyle | ViewRuleGroup | ViewRuleStyle;
+    readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleGroup | ViewRuleStyle;
     readonly $type: 'OpacityProperty';
     key: 'opacity';
     value: string;
@@ -1173,6 +1491,20 @@ export function isOpacityProperty(item: unknown): item is OpacityProperty {
     return reflection.isInstance(item, OpacityProperty);
 }
 
+export interface OutgoingRelationExpr extends AstNode {
+    readonly $container: DeploymentViewRulePredicateExpression | DirectedRelationExpr;
+    readonly $type: 'OutgoingRelationExpr';
+    from: FqnExpr;
+    isBidirectional: boolean;
+    kind?: Reference<RelationshipKind>;
+}
+
+export const OutgoingRelationExpr = 'OutgoingRelationExpr';
+
+export function isOutgoingRelationExpr(item: unknown): item is OutgoingRelationExpr {
+    return reflection.isInstance(item, OutgoingRelationExpr);
+}
+
 export interface OutgoingRelationExpression extends AstNode {
     readonly $container: DirectedRelationExpression | Predicates | RelationPredicateWhere | RelationPredicateWith;
     readonly $type: 'OutgoingRelationExpression';
@@ -1232,7 +1564,7 @@ export function isRelationBody(item: unknown): item is RelationBody {
 }
 
 export interface RelationNavigateToProperty extends AstNode {
-    readonly $container: CustomRelationProperties | RelationBody;
+    readonly $container: CustomRelationProperties | DeploymentRelationBody | RelationBody;
     readonly $type: 'RelationNavigateToProperty';
     key: 'navigateTo';
     value: DynamicViewRef;
@@ -1283,7 +1615,7 @@ export function isRelationshipKind(item: unknown): item is RelationshipKind {
 }
 
 export interface RelationStringProperty extends AstNode {
-    readonly $container: CustomRelationProperties | RelationBody;
+    readonly $container: CustomRelationProperties | DeploymentRelationBody | RelationBody;
     readonly $type: 'RelationStringProperty';
     key: 'description' | 'technology' | 'title';
     value: string;
@@ -1296,7 +1628,7 @@ export function isRelationStringProperty(item: unknown): item is RelationStringP
 }
 
 export interface RelationStyleProperty extends AstNode {
-    readonly $container: RelationBody;
+    readonly $container: DeploymentRelationBody | RelationBody;
     readonly $type: 'RelationStyleProperty';
     key: 'style';
     props: Array<RelationshipStyleProperty>;
@@ -1309,7 +1641,7 @@ export function isRelationStyleProperty(item: unknown): item is RelationStylePro
 }
 
 export interface ShapeProperty extends AstNode {
-    readonly $container: CustomElementProperties | ElementStyleProperty | GlobalStyle | ViewRuleStyle;
+    readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleStyle;
     readonly $type: 'ShapeProperty';
     key: 'shape';
     value: ElementShape;
@@ -1334,6 +1666,19 @@ export function isSpecificationColor(item: unknown): item is SpecificationColor
     return reflection.isInstance(item, SpecificationColor);
 }
 
+export interface SpecificationDeploymentNodeKind extends AstNode {
+    readonly $container: SpecificationRule;
+    readonly $type: 'SpecificationDeploymentNodeKind';
+    kind: DeploymentNodeKind;
+    props: Array<ElementStyleProperty | SpecificationElementStringProperty>;
+}
+
+export const SpecificationDeploymentNodeKind = 'SpecificationDeploymentNodeKind';
+
+export function isSpecificationDeploymentNodeKind(item: unknown): item is SpecificationDeploymentNodeKind {
+    return reflection.isInstance(item, SpecificationDeploymentNodeKind);
+}
+
 export interface SpecificationElementKind extends AstNode {
     readonly $container: SpecificationRule;
     readonly $type: 'SpecificationElementKind';
@@ -1348,7 +1693,7 @@ export function isSpecificationElementKind(item: unknown): item is Specification
 }
 
 export interface SpecificationElementStringProperty extends AstNode {
-    readonly $container: SpecificationElementKind;
+    readonly $container: SpecificationDeploymentNodeKind | SpecificationElementKind;
     readonly $type: 'SpecificationElementStringProperty';
     key: 'notation' | 'technology';
     value: string;
@@ -1390,6 +1735,7 @@ export interface SpecificationRule extends AstNode {
     readonly $container: LikeC4Grammar;
     readonly $type: 'SpecificationRule';
     colors: Array<SpecificationColor>;
+    deploymentNodes: Array<SpecificationDeploymentNodeKind>;
     elements: Array<SpecificationElementKind>;
     name: 'specification';
     relationships: Array<SpecificationRelationshipKind>;
@@ -1427,7 +1773,7 @@ export function isTag(item: unknown): item is Tag {
 }
 
 export interface Tags extends AstNode {
-    readonly $container: DynamicViewBody | ElementBody | ElementViewBody | Relation | RelationBody | Tags;
+    readonly $container: DeployedInstanceBody | DeploymentNodeBody | DeploymentRelation | DeploymentRelationBody | DeploymentViewBody | DynamicViewBody | ElementBody | ElementViewBody | Relation | RelationBody | Tags;
     readonly $type: 'Tags';
     prev?: Tags;
     values: Array<Reference<Tag>>;
@@ -1452,7 +1798,7 @@ export function isViewRef(item: unknown): item is ViewRef {
 }
 
 export interface ViewRuleAutoLayout extends AstNode {
-    readonly $container: DynamicViewBody | ElementViewBody;
+    readonly $container: DeploymentViewBody | DynamicViewBody | ElementViewBody;
     readonly $type: 'ViewRuleAutoLayout';
     direction: ViewLayoutDirection;
     nodeSep?: number;
@@ -1517,7 +1863,7 @@ export function isViewRuleStyle(item: unknown): item is ViewRuleStyle {
 }
 
 export interface ViewStringProperty extends AstNode {
-    readonly $container: DynamicViewBody | ElementViewBody;
+    readonly $container: DeploymentViewBody | DynamicViewBody | ElementViewBody;
     readonly $type: 'ViewStringProperty';
     key: 'description' | 'title';
     value: string;
@@ -1624,7 +1970,7 @@ export function isWhereRelationTag(item: unknown): item is WhereRelationTag {
 }
 
 export interface WildcardExpression extends AstNode {
-    readonly $container: DirectedRelationExpression | DynamicViewPredicateIterator | ElementExpressionsIterator | ElementPredicateWhere | ElementPredicateWith | IncomingRelationExpression | OutgoingRelationExpression | Predicates;
+    readonly $container: DeploymentViewRulePredicateExpression | DirectedRelationExpr | DirectedRelationExpression | DynamicViewPredicateIterator | ElementExpressionsIterator | ElementPredicateWhere | ElementPredicateWith | FqnExpressions | IncomingRelationExpr | IncomingRelationExpression | OutgoingRelationExpr | OutgoingRelationExpression | Predicates;
     readonly $type: 'WildcardExpression';
     isWildcard: boolean;
 }
@@ -1642,6 +1988,21 @@ export type LikeC4AstType = {
     CustomColor: CustomColor
     CustomElementProperties: CustomElementProperties
     CustomRelationProperties: CustomRelationProperties
+    DeployedInstance: DeployedInstance
+    DeployedInstanceBody: DeployedInstanceBody
+    DeploymentElement: DeploymentElement
+    DeploymentNode: DeploymentNode
+    DeploymentNodeBody: DeploymentNodeBody
+    DeploymentNodeKind: DeploymentNodeKind
+    DeploymentRelation: DeploymentRelation
+    DeploymentRelationBody: DeploymentRelationBody
+    DeploymentView: DeploymentView
+    DeploymentViewBody: DeploymentViewBody
+    DeploymentViewRule: DeploymentViewRule
+    DeploymentViewRulePredicate: DeploymentViewRulePredicate
+    DeploymentViewRulePredicateExpression: DeploymentViewRulePredicateExpression
+    DeploymentViewRuleStyle: DeploymentViewRuleStyle
+    DirectedRelationExpr: DirectedRelationExpr
     DirectedRelationExpression: DirectedRelationExpression
     DynamicView: DynamicView
     DynamicViewBody: DynamicViewBody
@@ -1673,9 +2034,15 @@ export type LikeC4AstType = {
     ElementViewRef: ElementViewRef
     ExcludePredicate: ExcludePredicate
     ExpandElementExpression: ExpandElementExpression
+    ExpressionV2: ExpressionV2
     ExtendElement: ExtendElement
     ExtendElementBody: ExtendElementBody
     FqnElementRef: FqnElementRef
+    FqnExpr: FqnExpr
+    FqnExpressions: FqnExpressions
+    FqnRef: FqnRef
+    FqnRefExpr: FqnRefExpr
+    FqnReferenceable: FqnReferenceable
     GlobalDynamicPredicateGroup: GlobalDynamicPredicateGroup
     GlobalPredicateGroup: GlobalPredicateGroup
     GlobalStyle: GlobalStyle
@@ -1683,8 +2050,10 @@ export type LikeC4AstType = {
     GlobalStyleId: GlobalStyleId
     Globals: Globals
     IconProperty: IconProperty
+    InOutRelationExpr: InOutRelationExpr
     InOutRelationExpression: InOutRelationExpression
     IncludePredicate: IncludePredicate
+    IncomingRelationExpr: IncomingRelationExpr
     IncomingRelationExpression: IncomingRelationExpression
     LibIcon: LibIcon
     LikeC4Grammar: LikeC4Grammar
@@ -1696,16 +2065,20 @@ export type LikeC4AstType = {
     MetadataBody: MetadataBody
     MetadataProperty: MetadataProperty
     Model: Model
+    ModelDeployments: ModelDeployments
     ModelViews: ModelViews
     NavigateToProperty: NavigateToProperty
     NotationProperty: NotationProperty
     NotesProperty: NotesProperty
     OpacityProperty: OpacityProperty
+    OutgoingRelationExpr: OutgoingRelationExpr
     OutgoingRelationExpression: OutgoingRelationExpression
     Predicate: Predicate
     Predicates: Predicates
+    Referenceable: Referenceable
     Relation: Relation
     RelationBody: RelationBody
+    RelationExpr: RelationExpr
     RelationExpression: RelationExpression
     RelationNavigateToProperty: RelationNavigateToProperty
     RelationPredicate: RelationPredicate
@@ -1719,6 +2092,7 @@ export type LikeC4AstType = {
     RelationshipStyleProperty: RelationshipStyleProperty
     ShapeProperty: ShapeProperty
     SpecificationColor: SpecificationColor
+    SpecificationDeploymentNodeKind: SpecificationDeploymentNodeKind
     SpecificationElementKind: SpecificationElementKind
     SpecificationElementStringProperty: SpecificationElementStringProperty
     SpecificationRelationshipKind: SpecificationRelationshipKind
@@ -1760,7 +2134,7 @@ export type LikeC4AstType = {
 export class LikeC4AstReflection extends AbstractAstReflection {
 
     getAllTypes(): string[] {
-        return [ArrowProperty, BorderProperty, ColorProperty, CustomColor, CustomElementProperties, CustomRelationProperties, DirectedRelationExpression, DynamicView, DynamicViewBody, DynamicViewGlobalPredicateRef, DynamicViewIncludePredicate, DynamicViewParallelSteps, DynamicViewPredicateIterator, DynamicViewRef, DynamicViewRule, DynamicViewStep, Element, ElementBody, ElementDescedantsExpression, ElementExpression, ElementExpressionsIterator, ElementKind, ElementKindExpression, ElementPredicate, ElementPredicateOrWhere, ElementPredicateWhere, ElementPredicateWith, ElementProperty, ElementRef, ElementStringProperty, ElementStyleProperty, ElementTagExpression, ElementView, ElementViewBody, ElementViewRef, ExcludePredicate, ExpandElementExpression, ExtendElement, ExtendElementBody, FqnElementRef, GlobalDynamicPredicateGroup, GlobalPredicateGroup, GlobalStyle, GlobalStyleGroup, GlobalStyleId, Globals, IconProperty, InOutRelationExpression, IncludePredicate, IncomingRelationExpression, LibIcon, LikeC4Grammar, LikeC4Lib, LikeC4View, LineProperty, LinkProperty, MetadataAttribute, MetadataBody, MetadataProperty, Model, ModelViews, NavigateToProperty, NotationProperty, NotesProperty, OpacityProperty, OutgoingRelationExpression, Predicate, Predicates, Relation, RelationBody, RelationExpression, RelationNavigateToProperty, RelationPredicate, RelationPredicateOrWhere, RelationPredicateWhere, RelationPredicateWith, RelationProperty, RelationStringProperty, RelationStyleProperty, RelationshipKind, RelationshipStyleProperty, ShapeProperty, SpecificationColor, SpecificationElementKind, SpecificationElementStringProperty, SpecificationRelationshipKind, SpecificationRelationshipStringProperty, SpecificationRule, SpecificationTag, StringProperty, StyleProperty, Tag, Tags, ViewProperty, ViewRef, ViewRule, ViewRuleAutoLayout, ViewRuleGlobalPredicateRef, ViewRuleGlobalStyle, ViewRuleGroup, ViewRulePredicate, ViewRuleStyle, ViewRuleStyleOrGlobalRef, ViewStringProperty, WhereBinaryExpression, WhereElement, WhereElementExpression, WhereElementKind, WhereElementNegation, WhereElementTag, WhereExpression, WhereKindEqual, WhereRelation, WhereRelationExpression, WhereRelationKind, WhereRelationNegation, WhereRelationTag, WhereTagEqual, WildcardExpression];
+        return [ArrowProperty, BorderProperty, ColorProperty, CustomColor, CustomElementProperties, CustomRelationProperties, DeployedInstance, DeployedInstanceBody, DeploymentElement, DeploymentNode, DeploymentNodeBody, DeploymentNodeKind, DeploymentRelation, DeploymentRelationBody, DeploymentView, DeploymentViewBody, DeploymentViewRule, DeploymentViewRulePredicate, DeploymentViewRulePredicateExpression, DeploymentViewRuleStyle, DirectedRelationExpr, DirectedRelationExpression, DynamicView, DynamicViewBody, DynamicViewGlobalPredicateRef, DynamicViewIncludePredicate, DynamicViewParallelSteps, DynamicViewPredicateIterator, DynamicViewRef, DynamicViewRule, DynamicViewStep, Element, ElementBody, ElementDescedantsExpression, ElementExpression, ElementExpressionsIterator, ElementKind, ElementKindExpression, ElementPredicate, ElementPredicateOrWhere, ElementPredicateWhere, ElementPredicateWith, ElementProperty, ElementRef, ElementStringProperty, ElementStyleProperty, ElementTagExpression, ElementView, ElementViewBody, ElementViewRef, ExcludePredicate, ExpandElementExpression, ExpressionV2, ExtendElement, ExtendElementBody, FqnElementRef, FqnExpr, FqnExpressions, FqnRef, FqnRefExpr, FqnReferenceable, GlobalDynamicPredicateGroup, GlobalPredicateGroup, GlobalStyle, GlobalStyleGroup, GlobalStyleId, Globals, IconProperty, InOutRelationExpr, InOutRelationExpression, IncludePredicate, IncomingRelationExpr, IncomingRelationExpression, LibIcon, LikeC4Grammar, LikeC4Lib, LikeC4View, LineProperty, LinkProperty, MetadataAttribute, MetadataBody, MetadataProperty, Model, ModelDeployments, ModelViews, NavigateToProperty, NotationProperty, NotesProperty, OpacityProperty, OutgoingRelationExpr, OutgoingRelationExpression, Predicate, Predicates, Referenceable, Relation, RelationBody, RelationExpr, RelationExpression, RelationNavigateToProperty, RelationPredicate, RelationPredicateOrWhere, RelationPredicateWhere, RelationPredicateWith, RelationProperty, RelationStringProperty, RelationStyleProperty, RelationshipKind, RelationshipStyleProperty, ShapeProperty, SpecificationColor, SpecificationDeploymentNodeKind, SpecificationElementKind, SpecificationElementStringProperty, SpecificationRelationshipKind, SpecificationRelationshipStringProperty, SpecificationRule, SpecificationTag, StringProperty, StyleProperty, Tag, Tags, ViewProperty, ViewRef, ViewRule, ViewRuleAutoLayout, ViewRuleGlobalPredicateRef, ViewRuleGlobalStyle, ViewRuleGroup, ViewRulePredicate, ViewRuleStyle, ViewRuleStyleOrGlobalRef, ViewStringProperty, WhereBinaryExpression, WhereElement, WhereElementExpression, WhereElementKind, WhereElementNegation, WhereElementTag, WhereExpression, WhereKindEqual, WhereRelation, WhereRelationExpression, WhereRelationKind, WhereRelationNegation, WhereRelationTag, WhereTagEqual, WildcardExpression];
     }
 
     protected override computeIsSubtype(subtype: string, supertype: string): boolean {
@@ -1777,26 +2151,43 @@ export class LikeC4AstReflection extends AbstractAstReflection {
             case ColorProperty: {
                 return this.isSubtype(RelationshipStyleProperty, supertype) || this.isSubtype(StyleProperty, supertype);
             }
+            case DeployedInstance:
+            case DeploymentNode: {
+                return this.isSubtype(DeploymentElement, supertype) || this.isSubtype(Referenceable, supertype);
+            }
+            case DeploymentView:
+            case DynamicView:
+            case ElementView: {
+                return this.isSubtype(LikeC4View, supertype);
+            }
+            case DeploymentViewRulePredicate:
+            case DeploymentViewRuleStyle: {
+                return this.isSubtype(DeploymentViewRule, supertype);
+            }
+            case DirectedRelationExpr:
+            case IncomingRelationExpr:
+            case InOutRelationExpr:
+            case OutgoingRelationExpr: {
+                return this.isSubtype(RelationExpr, supertype);
+            }
             case DirectedRelationExpression:
             case IncomingRelationExpression:
             case InOutRelationExpression:
             case OutgoingRelationExpression: {
                 return this.isSubtype(RelationExpression, supertype);
             }
-            case DynamicView:
-            case ElementView: {
-                return this.isSubtype(LikeC4View, supertype);
-            }
             case DynamicViewGlobalPredicateRef:
             case DynamicViewIncludePredicate: {
                 return this.isSubtype(DynamicViewRule, supertype);
             }
+            case Element: {
+                return this.isSubtype(FqnReferenceable, supertype) || this.isSubtype(Referenceable, supertype);
+            }
             case ElementDescedantsExpression:
             case ElementKindExpression:
             case ElementRef:
             case ElementTagExpression:
-            case ExpandElementExpression:
-            case WildcardExpression: {
+            case ExpandElementExpression: {
                 return this.isSubtype(ElementExpression, supertype);
             }
             case ElementExpression:
@@ -1821,6 +2212,17 @@ export class LikeC4AstReflection extends AbstractAstReflection {
             case IncludePredicate: {
                 return this.isSubtype(ViewRulePredicate, supertype);
             }
+            case ExtendElement:
+            case Referenceable: {
+                return this.isSubtype(FqnReferenceable, supertype);
+            }
+            case FqnExpr:
+            case RelationExpr: {
+                return this.isSubtype(ExpressionV2, supertype);
+            }
+            case FqnRefExpr: {
+                return this.isSubtype(FqnExpr, supertype);
+            }
             case IconProperty: {
                 return this.isSubtype(ElementProperty, supertype) || this.isSubtype(StyleProperty, supertype);
             }
@@ -1855,9 +2257,8 @@ export class LikeC4AstReflection extends AbstractAstReflection {
             case RelationStringProperty: {
                 return this.isSubtype(RelationProperty, supertype) || this.isSubtype(StringProperty, supertype);
             }
-            case ViewRuleAutoLayout:
-            case ViewRuleStyleOrGlobalRef: {
-                return this.isSubtype(DynamicViewRule, supertype) || this.isSubtype(ViewRule, supertype);
+            case ViewRuleAutoLayout: {
+                return this.isSubtype(DeploymentViewRule, supertype) || this.isSubtype(DynamicViewRule, supertype) || this.isSubtype(ViewRule, supertype);
             }
             case ViewRuleGlobalPredicateRef:
             case ViewRuleGroup:
@@ -1868,6 +2269,9 @@ export class LikeC4AstReflection extends AbstractAstReflection {
             case ViewRuleStyle: {
                 return this.isSubtype(ViewRuleStyleOrGlobalRef, supertype);
             }
+            case ViewRuleStyleOrGlobalRef: {
+                return this.isSubtype(DynamicViewRule, supertype) || this.isSubtype(ViewRule, supertype);
+            }
             case ViewStringProperty: {
                 return this.isSubtype(StringProperty, supertype) || this.isSubtype(ViewProperty, supertype);
             }
@@ -1898,6 +2302,9 @@ export class LikeC4AstReflection extends AbstractAstReflection {
             case WhereRelationTag: {
                 return this.isSubtype(WhereRelation, supertype) || this.isSubtype(WhereTagEqual, supertype);
             }
+            case WildcardExpression: {
+                return this.isSubtype(ElementExpression, supertype) || this.isSubtype(FqnExpr, supertype);
+            }
             default: {
                 return false;
             }
@@ -1910,18 +2317,23 @@ export class LikeC4AstReflection extends AbstractAstReflection {
             case 'ColorProperty:customColor': {
                 return CustomColor;
             }
-            case 'DynamicViewGlobalPredicateRef:predicate': {
-                return GlobalDynamicPredicateGroup;
-            }
-            case 'DynamicViewRef:view': {
-                return DynamicView;
+            case 'DeploymentNode:kind': {
+                return DeploymentNodeKind;
             }
+            case 'DeploymentRelation:kind':
             case 'DynamicViewStep:kind':
+            case 'OutgoingRelationExpr:kind':
             case 'OutgoingRelationExpression:kind':
             case 'Relation:kind':
             case 'WhereRelationKind:value': {
                 return RelationshipKind;
             }
+            case 'DynamicViewGlobalPredicateRef:predicate': {
+                return GlobalDynamicPredicateGroup;
+            }
+            case 'DynamicViewRef:view': {
+                return DynamicView;
+            }
             case 'Element:kind':
             case 'ElementKindExpression:kind':
             case 'WhereElementKind:value': {
@@ -1940,6 +2352,9 @@ export class LikeC4AstReflection extends AbstractAstReflection {
             case 'ElementViewRef:view': {
                 return ElementView;
             }
+            case 'FqnRef:value': {
+                return Referenceable;
+            }
             case 'IconProperty:libicon': {
                 return LibIcon;
             }
@@ -2012,6 +2427,133 @@ export class LikeC4AstReflection extends AbstractAstReflection {
                     ]
                 };
             }
+            case DeployedInstance: {
+                return {
+                    name: DeployedInstance,
+                    properties: [
+                        { name: 'body' },
+                        { name: 'element' },
+                        { name: 'name' },
+                        { name: 'title' }
+                    ]
+                };
+            }
+            case DeployedInstanceBody: {
+                return {
+                    name: DeployedInstanceBody,
+                    properties: [
+                        { name: 'props', defaultValue: [] },
+                        { name: 'tags' }
+                    ]
+                };
+            }
+            case DeploymentNode: {
+                return {
+                    name: DeploymentNode,
+                    properties: [
+                        { name: 'body' },
+                        { name: 'kind' },
+                        { name: 'name' },
+                        { name: 'title' }
+                    ]
+                };
+            }
+            case DeploymentNodeBody: {
+                return {
+                    name: DeploymentNodeBody,
+                    properties: [
+                        { name: 'elements', defaultValue: [] },
+                        { name: 'props', defaultValue: [] },
+                        { name: 'tags' }
+                    ]
+                };
+            }
+            case DeploymentNodeKind: {
+                return {
+                    name: DeploymentNodeKind,
+                    properties: [
+                        { name: 'name' }
+                    ]
+                };
+            }
+            case DeploymentRelation: {
+                return {
+                    name: DeploymentRelation,
+                    properties: [
+                        { name: 'body' },
+                        { name: 'kind' },
+                        { name: 'source' },
+                        { name: 'tags' },
+                        { name: 'target' },
+                        { name: 'technology' },
+                        { name: 'title' }
+                    ]
+                };
+            }
+            case DeploymentRelationBody: {
+                return {
+                    name: DeploymentRelationBody,
+                    properties: [
+                        { name: 'props', defaultValue: [] },
+                        { name: 'tags' }
+                    ]
+                };
+            }
+            case DeploymentView: {
+                return {
+                    name: DeploymentView,
+                    properties: [
+                        { name: 'body' },
+                        { name: 'name' }
+                    ]
+                };
+            }
+            case DeploymentViewBody: {
+                return {
+                    name: DeploymentViewBody,
+                    properties: [
+                        { name: 'props', defaultValue: [] },
+                        { name: 'rules', defaultValue: [] },
+                        { name: 'tags' }
+                    ]
+                };
+            }
+            case DeploymentViewRulePredicate: {
+                return {
+                    name: DeploymentViewRulePredicate,
+                    properties: [
+                        { name: 'expr' },
+                        { name: 'isInclude', defaultValue: false }
+                    ]
+                };
+            }
+            case DeploymentViewRulePredicateExpression: {
+                return {
+                    name: DeploymentViewRulePredicateExpression,
+                    properties: [
+                        { name: 'prev' },
+                        { name: 'value' }
+                    ]
+                };
+            }
+            case DeploymentViewRuleStyle: {
+                return {
+                    name: DeploymentViewRuleStyle,
+                    properties: [
+                        { name: 'props', defaultValue: [] },
+                        { name: 'targets' }
+                    ]
+                };
+            }
+            case DirectedRelationExpr: {
+                return {
+                    name: DirectedRelationExpr,
+                    properties: [
+                        { name: 'source' },
+                        { name: 'target' }
+                    ]
+                };
+            }
             case DirectedRelationExpression: {
                 return {
                     name: DirectedRelationExpression,
@@ -2120,7 +2662,8 @@ export class LikeC4AstReflection extends AbstractAstReflection {
                 return {
                     name: ElementDescedantsExpression,
                     properties: [
-                        { name: 'parent' }
+                        { name: 'parent' },
+                        { name: 'suffix' }
                     ]
                 };
             }
@@ -2275,6 +2818,33 @@ export class LikeC4AstReflection extends AbstractAstReflection {
                     ]
                 };
             }
+            case FqnExpressions: {
+                return {
+                    name: FqnExpressions,
+                    properties: [
+                        { name: 'prev' },
+                        { name: 'value' }
+                    ]
+                };
+            }
+            case FqnRef: {
+                return {
+                    name: FqnRef,
+                    properties: [
+                        { name: 'parent' },
+                        { name: 'value' }
+                    ]
+                };
+            }
+            case FqnRefExpr: {
+                return {
+                    name: FqnRefExpr,
+                    properties: [
+                        { name: 'ref' },
+                        { name: 'selector' }
+                    ]
+                };
+            }
             case GlobalDynamicPredicateGroup: {
                 return {
                     name: GlobalDynamicPredicateGroup,
@@ -2348,6 +2918,14 @@ export class LikeC4AstReflection extends AbstractAstReflection {
                     ]
                 };
             }
+            case IncomingRelationExpr: {
+                return {
+                    name: IncomingRelationExpr,
+                    properties: [
+                        { name: 'to' }
+                    ]
+                };
+            }
             case IncomingRelationExpression: {
                 return {
                     name: IncomingRelationExpression,
@@ -2356,6 +2934,14 @@ export class LikeC4AstReflection extends AbstractAstReflection {
                     ]
                 };
             }
+            case InOutRelationExpr: {
+                return {
+                    name: InOutRelationExpr,
+                    properties: [
+                        { name: 'inout' }
+                    ]
+                };
+            }
             case InOutRelationExpression: {
                 return {
                     name: InOutRelationExpression,
@@ -2376,6 +2962,7 @@ export class LikeC4AstReflection extends AbstractAstReflection {
                 return {
                     name: LikeC4Grammar,
                     properties: [
+                        { name: 'deployments', defaultValue: [] },
                         { name: 'globals', defaultValue: [] },
                         { name: 'likec4lib', defaultValue: [] },
                         { name: 'models', defaultValue: [] },
@@ -2437,6 +3024,15 @@ export class LikeC4AstReflection extends AbstractAstReflection {
                     ]
                 };
             }
+            case ModelDeployments: {
+                return {
+                    name: ModelDeployments,
+                    properties: [
+                        { name: 'elements', defaultValue: [] },
+                        { name: 'name' }
+                    ]
+                };
+            }
             case ModelViews: {
                 return {
                     name: ModelViews,
@@ -2483,6 +3079,16 @@ export class LikeC4AstReflection extends AbstractAstReflection {
                     ]
                 };
             }
+            case OutgoingRelationExpr: {
+                return {
+                    name: OutgoingRelationExpr,
+                    properties: [
+                        { name: 'from' },
+                        { name: 'isBidirectional', defaultValue: false },
+                        { name: 'kind' }
+                    ]
+                };
+            }
             case OutgoingRelationExpression: {
                 return {
                     name: OutgoingRelationExpression,
@@ -2596,6 +3202,15 @@ export class LikeC4AstReflection extends AbstractAstReflection {
                     ]
                 };
             }
+            case SpecificationDeploymentNodeKind: {
+                return {
+                    name: SpecificationDeploymentNodeKind,
+                    properties: [
+                        { name: 'kind' },
+                        { name: 'props', defaultValue: [] }
+                    ]
+                };
+            }
             case SpecificationElementKind: {
                 return {
                     name: SpecificationElementKind,
@@ -2637,6 +3252,7 @@ export class LikeC4AstReflection extends AbstractAstReflection {
                     name: SpecificationRule,
                     properties: [
                         { name: 'colors', defaultValue: [] },
+                        { name: 'deploymentNodes', defaultValue: [] },
                         { name: 'elements', defaultValue: [] },
                         { name: 'name' },
                         { name: 'relationships', defaultValue: [] },