@likec4/language-server 1.17.1 → 1.19.0

package/dist/generated/ast.js

@@ -0,0 +1,1945 @@
+import { AbstractAstReflection } from "langium";
+export const LikeC4Terminals = {
+  BLOCK_COMMENT: /\/\*[\s\S]*?\*\//,
+  LINE_COMMENT: /\/\/[^\n\r]*/,
+  WS: /[\t ]+/,
+  NL: /[\r\n]+/,
+  LIB_ICON: /(aws|azure|gcp|tech):[-\w]*/,
+  URI_WITH_SCHEMA: /\w+:\/\/\S+/,
+  URI_RELATIVE: /\.{0,2}\/[^\/]\S+/,
+  DotUnderscore: /\b\._(?![_a-zA-Z])/,
+  DotWildcard: /\b\.\*{1,2}/,
+  Hash: /#/,
+  StickyDot: /\b\./,
+  Dot: /\./,
+  NotEqual: /\!\={1,2}/,
+  Eq: /\={1,2}/,
+  Percent: /\b\d+%/,
+  String: /"[^"]*"|'[^']*'/,
+  IdTerminal: /[_]*[a-zA-Z][-\w]*/,
+  Number: /\b\d+\b/,
+  Hex: /\b[a-zA-Z0-9]+\b/
+};
+export function isArrowType(item) {
+  return item === "none" || item === "normal" || item === "onormal" || item === "dot" || item === "odot" || item === "diamond" || item === "odiamond" || item === "crow" || item === "open" || item === "vee";
+}
+export function isBorderStyleValue(item) {
+  return isLineOptions(item) || item === "none";
+}
+export function isCustomColorId(item) {
+  return isElementShape(item) || isArrowType(item) || isLineOptions(item) || item === "element" || item === "model" || typeof item === "string" && /[_]*[a-zA-Z][-\w]*/.test(item);
+}
+export function isCustomColorValue(item) {
+  return typeof item === "string";
+}
+export const DeploymentElement = "DeploymentElement";
+export function isDeploymentElement(item) {
+  return reflection.isInstance(item, DeploymentElement);
+}
+export const DeploymentViewRule = "DeploymentViewRule";
+export function isDeploymentViewRule(item) {
+  return reflection.isInstance(item, DeploymentViewRule);
+}
+export function isDotId(item) {
+  return typeof item === "string";
+}
+export const DynamicViewRule = "DynamicViewRule";
+export function isDynamicViewRule(item) {
+  return reflection.isInstance(item, DynamicViewRule);
+}
+export const ElementExpression = "ElementExpression";
+export function isElementExpression(item) {
+  return reflection.isInstance(item, ElementExpression);
+}
+export const ElementPredicate = "ElementPredicate";
+export function isElementPredicate(item) {
+  return reflection.isInstance(item, ElementPredicate);
+}
+export const ElementPredicateOrWhere = "ElementPredicateOrWhere";
+export function isElementPredicateOrWhere(item) {
+  return reflection.isInstance(item, ElementPredicateOrWhere);
+}
+export const ElementProperty = "ElementProperty";
+export function isElementProperty(item) {
+  return reflection.isInstance(item, ElementProperty);
+}
+export function isElementShape(item) {
+  return item === "rectangle" || item === "person" || item === "browser" || item === "mobile" || item === "cylinder" || item === "storage" || item === "queue";
+}
+export const ExpressionV2 = "ExpressionV2";
+export function isExpressionV2(item) {
+  return reflection.isInstance(item, ExpressionV2);
+}
+export const FqnExpr = "FqnExpr";
+export function isFqnExpr(item) {
+  return reflection.isInstance(item, FqnExpr);
+}
+export const FqnReferenceable = "FqnReferenceable";
+export function isFqnReferenceable(item) {
+  return reflection.isInstance(item, FqnReferenceable);
+}
+export function isIconId(item) {
+  return typeof item === "string" && /(aws|azure|gcp|tech):[-\w]*/.test(item);
+}
+export function isId(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 const LikeC4View = "LikeC4View";
+export function isLikeC4View(item) {
+  return reflection.isInstance(item, LikeC4View);
+}
+export function isLineOptions(item) {
+  return item === "solid" || item === "dashed" || item === "dotted";
+}
+export const MetadataProperty = "MetadataProperty";
+export function isMetadataProperty(item) {
+  return reflection.isInstance(item, MetadataProperty);
+}
+export const Predicate = "Predicate";
+export function isPredicate(item) {
+  return reflection.isInstance(item, Predicate);
+}
+export const Referenceable = "Referenceable";
+export function isReferenceable(item) {
+  return reflection.isInstance(item, Referenceable);
+}
+export const RelationExpr = "RelationExpr";
+export function isRelationExpr(item) {
+  return reflection.isInstance(item, RelationExpr);
+}
+export const RelationExpression = "RelationExpression";
+export function isRelationExpression(item) {
+  return reflection.isInstance(item, RelationExpression);
+}
+export const RelationPredicate = "RelationPredicate";
+export function isRelationPredicate(item) {
+  return reflection.isInstance(item, RelationPredicate);
+}
+export const RelationPredicateOrWhere = "RelationPredicateOrWhere";
+export function isRelationPredicateOrWhere(item) {
+  return reflection.isInstance(item, RelationPredicateOrWhere);
+}
+export const RelationProperty = "RelationProperty";
+export function isRelationProperty(item) {
+  return reflection.isInstance(item, RelationProperty);
+}
+export const RelationshipStyleProperty = "RelationshipStyleProperty";
+export function isRelationshipStyleProperty(item) {
+  return reflection.isInstance(item, RelationshipStyleProperty);
+}
+export const StringProperty = "StringProperty";
+export function isStringProperty(item) {
+  return reflection.isInstance(item, StringProperty);
+}
+export const StyleProperty = "StyleProperty";
+export function isStyleProperty(item) {
+  return reflection.isInstance(item, StyleProperty);
+}
+export function isTagId(item) {
+  return typeof item === "string";
+}
+export function isThemeColor(item) {
+  return item === "primary" || item === "secondary" || item === "muted" || item === "slate" || item === "blue" || item === "indigo" || item === "sky" || item === "red" || item === "gray" || item === "green" || item === "amber";
+}
+export function isUri(item) {
+  return typeof item === "string" && (/\w+:\/\/\S+/.test(item) || /\.{0,2}\/[^\/]\S+/.test(item));
+}
+export function isViewLayoutDirection(item) {
+  return item === "TopBottom" || item === "LeftRight" || item === "BottomTop" || item === "RightLeft";
+}
+export const ViewProperty = "ViewProperty";
+export function isViewProperty(item) {
+  return reflection.isInstance(item, ViewProperty);
+}
+export const ViewRule = "ViewRule";
+export function isViewRule(item) {
+  return reflection.isInstance(item, ViewRule);
+}
+export const ViewRulePredicate = "ViewRulePredicate";
+export function isViewRulePredicate(item) {
+  return reflection.isInstance(item, ViewRulePredicate);
+}
+export const ViewRuleStyleOrGlobalRef = "ViewRuleStyleOrGlobalRef";
+export function isViewRuleStyleOrGlobalRef(item) {
+  return reflection.isInstance(item, ViewRuleStyleOrGlobalRef);
+}
+export const WhereElement = "WhereElement";
+export function isWhereElement(item) {
+  return reflection.isInstance(item, WhereElement);
+}
+export const WhereElementExpression = "WhereElementExpression";
+export function isWhereElementExpression(item) {
+  return reflection.isInstance(item, WhereElementExpression);
+}
+export const WhereExpression = "WhereExpression";
+export function isWhereExpression(item) {
+  return reflection.isInstance(item, WhereExpression);
+}
+export const WhereKindEqual = "WhereKindEqual";
+export function isWhereKindEqual(item) {
+  return reflection.isInstance(item, WhereKindEqual);
+}
+export const WhereRelation = "WhereRelation";
+export function isWhereRelation(item) {
+  return reflection.isInstance(item, WhereRelation);
+}
+export const WhereRelationExpression = "WhereRelationExpression";
+export function isWhereRelationExpression(item) {
+  return reflection.isInstance(item, WhereRelationExpression);
+}
+export const WhereTagEqual = "WhereTagEqual";
+export function isWhereTagEqual(item) {
+  return reflection.isInstance(item, WhereTagEqual);
+}
+export const ArrowProperty = "ArrowProperty";
+export function isArrowProperty(item) {
+  return reflection.isInstance(item, ArrowProperty);
+}
+export const BorderProperty = "BorderProperty";
+export function isBorderProperty(item) {
+  return reflection.isInstance(item, BorderProperty);
+}
+export const ColorProperty = "ColorProperty";
+export function isColorProperty(item) {
+  return reflection.isInstance(item, ColorProperty);
+}
+export const CustomColor = "CustomColor";
+export function isCustomColor(item) {
+  return reflection.isInstance(item, CustomColor);
+}
+export const CustomElementProperties = "CustomElementProperties";
+export function isCustomElementProperties(item) {
+  return reflection.isInstance(item, CustomElementProperties);
+}
+export const CustomRelationProperties = "CustomRelationProperties";
+export function isCustomRelationProperties(item) {
+  return reflection.isInstance(item, CustomRelationProperties);
+}
+export const DeployedInstance = "DeployedInstance";
+export function isDeployedInstance(item) {
+  return reflection.isInstance(item, DeployedInstance);
+}
+export const DeployedInstanceBody = "DeployedInstanceBody";
+export function isDeployedInstanceBody(item) {
+  return reflection.isInstance(item, DeployedInstanceBody);
+}
+export const DeploymentNode = "DeploymentNode";
+export function isDeploymentNode(item) {
+  return reflection.isInstance(item, DeploymentNode);
+}
+export const DeploymentNodeBody = "DeploymentNodeBody";
+export function isDeploymentNodeBody(item) {
+  return reflection.isInstance(item, DeploymentNodeBody);
+}
+export const DeploymentNodeKind = "DeploymentNodeKind";
+export function isDeploymentNodeKind(item) {
+  return reflection.isInstance(item, DeploymentNodeKind);
+}
+export const DeploymentRelation = "DeploymentRelation";
+export function isDeploymentRelation(item) {
+  return reflection.isInstance(item, DeploymentRelation);
+}
+export const DeploymentRelationBody = "DeploymentRelationBody";
+export function isDeploymentRelationBody(item) {
+  return reflection.isInstance(item, DeploymentRelationBody);
+}
+export const DeploymentView = "DeploymentView";
+export function isDeploymentView(item) {
+  return reflection.isInstance(item, DeploymentView);
+}
+export const DeploymentViewBody = "DeploymentViewBody";
+export function isDeploymentViewBody(item) {
+  return reflection.isInstance(item, DeploymentViewBody);
+}
+export const DeploymentViewRulePredicate = "DeploymentViewRulePredicate";
+export function isDeploymentViewRulePredicate(item) {
+  return reflection.isInstance(item, DeploymentViewRulePredicate);
+}
+export const DeploymentViewRulePredicateExpression = "DeploymentViewRulePredicateExpression";
+export function isDeploymentViewRulePredicateExpression(item) {
+  return reflection.isInstance(item, DeploymentViewRulePredicateExpression);
+}
+export const DeploymentViewRuleStyle = "DeploymentViewRuleStyle";
+export function isDeploymentViewRuleStyle(item) {
+  return reflection.isInstance(item, DeploymentViewRuleStyle);
+}
+export const DirectedRelationExpr = "DirectedRelationExpr";
+export function isDirectedRelationExpr(item) {
+  return reflection.isInstance(item, DirectedRelationExpr);
+}
+export const DirectedRelationExpression = "DirectedRelationExpression";
+export function isDirectedRelationExpression(item) {
+  return reflection.isInstance(item, DirectedRelationExpression);
+}
+export const DynamicView = "DynamicView";
+export function isDynamicView(item) {
+  return reflection.isInstance(item, DynamicView);
+}
+export const DynamicViewBody = "DynamicViewBody";
+export function isDynamicViewBody(item) {
+  return reflection.isInstance(item, DynamicViewBody);
+}
+export const DynamicViewGlobalPredicateRef = "DynamicViewGlobalPredicateRef";
+export function isDynamicViewGlobalPredicateRef(item) {
+  return reflection.isInstance(item, DynamicViewGlobalPredicateRef);
+}
+export const DynamicViewIncludePredicate = "DynamicViewIncludePredicate";
+export function isDynamicViewIncludePredicate(item) {
+  return reflection.isInstance(item, DynamicViewIncludePredicate);
+}
+export const DynamicViewParallelSteps = "DynamicViewParallelSteps";
+export function isDynamicViewParallelSteps(item) {
+  return reflection.isInstance(item, DynamicViewParallelSteps);
+}
+export const DynamicViewPredicateIterator = "DynamicViewPredicateIterator";
+export function isDynamicViewPredicateIterator(item) {
+  return reflection.isInstance(item, DynamicViewPredicateIterator);
+}
+export const DynamicViewRef = "DynamicViewRef";
+export function isDynamicViewRef(item) {
+  return reflection.isInstance(item, DynamicViewRef);
+}
+export const DynamicViewStep = "DynamicViewStep";
+export function isDynamicViewStep(item) {
+  return reflection.isInstance(item, DynamicViewStep);
+}
+export const Element = "Element";
+export function isElement(item) {
+  return reflection.isInstance(item, Element);
+}
+export const ElementBody = "ElementBody";
+export function isElementBody(item) {
+  return reflection.isInstance(item, ElementBody);
+}
+export const ElementDescedantsExpression = "ElementDescedantsExpression";
+export function isElementDescedantsExpression(item) {
+  return reflection.isInstance(item, ElementDescedantsExpression);
+}
+export const ElementExpressionsIterator = "ElementExpressionsIterator";
+export function isElementExpressionsIterator(item) {
+  return reflection.isInstance(item, ElementExpressionsIterator);
+}
+export const ElementKind = "ElementKind";
+export function isElementKind(item) {
+  return reflection.isInstance(item, ElementKind);
+}
+export const ElementKindExpression = "ElementKindExpression";
+export function isElementKindExpression(item) {
+  return reflection.isInstance(item, ElementKindExpression);
+}
+export const ElementPredicateWhere = "ElementPredicateWhere";
+export function isElementPredicateWhere(item) {
+  return reflection.isInstance(item, ElementPredicateWhere);
+}
+export const ElementPredicateWith = "ElementPredicateWith";
+export function isElementPredicateWith(item) {
+  return reflection.isInstance(item, ElementPredicateWith);
+}
+export const ElementRef = "ElementRef";
+export function isElementRef(item) {
+  return reflection.isInstance(item, ElementRef);
+}
+export const ElementStringProperty = "ElementStringProperty";
+export function isElementStringProperty(item) {
+  return reflection.isInstance(item, ElementStringProperty);
+}
+export const ElementStyleProperty = "ElementStyleProperty";
+export function isElementStyleProperty(item) {
+  return reflection.isInstance(item, ElementStyleProperty);
+}
+export const ElementTagExpression = "ElementTagExpression";
+export function isElementTagExpression(item) {
+  return reflection.isInstance(item, ElementTagExpression);
+}
+export const ElementView = "ElementView";
+export function isElementView(item) {
+  return reflection.isInstance(item, ElementView);
+}
+export const ElementViewBody = "ElementViewBody";
+export function isElementViewBody(item) {
+  return reflection.isInstance(item, ElementViewBody);
+}
+export const ElementViewRef = "ElementViewRef";
+export function isElementViewRef(item) {
+  return reflection.isInstance(item, ElementViewRef);
+}
+export const ExcludePredicate = "ExcludePredicate";
+export function isExcludePredicate(item) {
+  return reflection.isInstance(item, ExcludePredicate);
+}
+export const ExpandElementExpression = "ExpandElementExpression";
+export function isExpandElementExpression(item) {
+  return reflection.isInstance(item, ExpandElementExpression);
+}
+export const ExtendElement = "ExtendElement";
+export function isExtendElement(item) {
+  return reflection.isInstance(item, ExtendElement);
+}
+export const ExtendElementBody = "ExtendElementBody";
+export function isExtendElementBody(item) {
+  return reflection.isInstance(item, ExtendElementBody);
+}
+export const FqnElementRef = "FqnElementRef";
+export function isFqnElementRef(item) {
+  return reflection.isInstance(item, FqnElementRef);
+}
+export const FqnExpressions = "FqnExpressions";
+export function isFqnExpressions(item) {
+  return reflection.isInstance(item, FqnExpressions);
+}
+export const FqnRef = "FqnRef";
+export function isFqnRef(item) {
+  return reflection.isInstance(item, FqnRef);
+}
+export const FqnRefExpr = "FqnRefExpr";
+export function isFqnRefExpr(item) {
+  return reflection.isInstance(item, FqnRefExpr);
+}
+export const GlobalDynamicPredicateGroup = "GlobalDynamicPredicateGroup";
+export function isGlobalDynamicPredicateGroup(item) {
+  return reflection.isInstance(item, GlobalDynamicPredicateGroup);
+}
+export const GlobalPredicateGroup = "GlobalPredicateGroup";
+export function isGlobalPredicateGroup(item) {
+  return reflection.isInstance(item, GlobalPredicateGroup);
+}
+export const Globals = "Globals";
+export function isGlobals(item) {
+  return reflection.isInstance(item, Globals);
+}
+export const GlobalStyle = "GlobalStyle";
+export function isGlobalStyle(item) {
+  return reflection.isInstance(item, GlobalStyle);
+}
+export const GlobalStyleGroup = "GlobalStyleGroup";
+export function isGlobalStyleGroup(item) {
+  return reflection.isInstance(item, GlobalStyleGroup);
+}
+export const GlobalStyleId = "GlobalStyleId";
+export function isGlobalStyleId(item) {
+  return reflection.isInstance(item, GlobalStyleId);
+}
+export const IconProperty = "IconProperty";
+export function isIconProperty(item) {
+  return reflection.isInstance(item, IconProperty);
+}
+export const IncludePredicate = "IncludePredicate";
+export function isIncludePredicate(item) {
+  return reflection.isInstance(item, IncludePredicate);
+}
+export const IncomingRelationExpr = "IncomingRelationExpr";
+export function isIncomingRelationExpr(item) {
+  return reflection.isInstance(item, IncomingRelationExpr);
+}
+export const IncomingRelationExpression = "IncomingRelationExpression";
+export function isIncomingRelationExpression(item) {
+  return reflection.isInstance(item, IncomingRelationExpression);
+}
+export const InOutRelationExpr = "InOutRelationExpr";
+export function isInOutRelationExpr(item) {
+  return reflection.isInstance(item, InOutRelationExpr);
+}
+export const InOutRelationExpression = "InOutRelationExpression";
+export function isInOutRelationExpression(item) {
+  return reflection.isInstance(item, InOutRelationExpression);
+}
+export const LibIcon = "LibIcon";
+export function isLibIcon(item) {
+  return reflection.isInstance(item, LibIcon);
+}
+export const LikeC4Grammar = "LikeC4Grammar";
+export function isLikeC4Grammar(item) {
+  return reflection.isInstance(item, LikeC4Grammar);
+}
+export const LikeC4Lib = "LikeC4Lib";
+export function isLikeC4Lib(item) {
+  return reflection.isInstance(item, LikeC4Lib);
+}
+export const LineProperty = "LineProperty";
+export function isLineProperty(item) {
+  return reflection.isInstance(item, LineProperty);
+}
+export const LinkProperty = "LinkProperty";
+export function isLinkProperty(item) {
+  return reflection.isInstance(item, LinkProperty);
+}
+export const MetadataAttribute = "MetadataAttribute";
+export function isMetadataAttribute(item) {
+  return reflection.isInstance(item, MetadataAttribute);
+}
+export const MetadataBody = "MetadataBody";
+export function isMetadataBody(item) {
+  return reflection.isInstance(item, MetadataBody);
+}
+export const Model = "Model";
+export function isModel(item) {
+  return reflection.isInstance(item, Model);
+}
+export const ModelDeployments = "ModelDeployments";
+export function isModelDeployments(item) {
+  return reflection.isInstance(item, ModelDeployments);
+}
+export const ModelViews = "ModelViews";
+export function isModelViews(item) {
+  return reflection.isInstance(item, ModelViews);
+}
+export const NavigateToProperty = "NavigateToProperty";
+export function isNavigateToProperty(item) {
+  return reflection.isInstance(item, NavigateToProperty);
+}
+export const NotationProperty = "NotationProperty";
+export function isNotationProperty(item) {
+  return reflection.isInstance(item, NotationProperty);
+}
+export const NotesProperty = "NotesProperty";
+export function isNotesProperty(item) {
+  return reflection.isInstance(item, NotesProperty);
+}
+export const OpacityProperty = "OpacityProperty";
+export function isOpacityProperty(item) {
+  return reflection.isInstance(item, OpacityProperty);
+}
+export const OutgoingRelationExpr = "OutgoingRelationExpr";
+export function isOutgoingRelationExpr(item) {
+  return reflection.isInstance(item, OutgoingRelationExpr);
+}
+export const OutgoingRelationExpression = "OutgoingRelationExpression";
+export function isOutgoingRelationExpression(item) {
+  return reflection.isInstance(item, OutgoingRelationExpression);
+}
+export const Predicates = "Predicates";
+export function isPredicates(item) {
+  return reflection.isInstance(item, Predicates);
+}
+export const Relation = "Relation";
+export function isRelation(item) {
+  return reflection.isInstance(item, Relation);
+}
+export const RelationBody = "RelationBody";
+export function isRelationBody(item) {
+  return reflection.isInstance(item, RelationBody);
+}
+export const RelationNavigateToProperty = "RelationNavigateToProperty";
+export function isRelationNavigateToProperty(item) {
+  return reflection.isInstance(item, RelationNavigateToProperty);
+}
+export const RelationPredicateWhere = "RelationPredicateWhere";
+export function isRelationPredicateWhere(item) {
+  return reflection.isInstance(item, RelationPredicateWhere);
+}
+export const RelationPredicateWith = "RelationPredicateWith";
+export function isRelationPredicateWith(item) {
+  return reflection.isInstance(item, RelationPredicateWith);
+}
+export const RelationshipKind = "RelationshipKind";
+export function isRelationshipKind(item) {
+  return reflection.isInstance(item, RelationshipKind);
+}
+export const RelationStringProperty = "RelationStringProperty";
+export function isRelationStringProperty(item) {
+  return reflection.isInstance(item, RelationStringProperty);
+}
+export const RelationStyleProperty = "RelationStyleProperty";
+export function isRelationStyleProperty(item) {
+  return reflection.isInstance(item, RelationStyleProperty);
+}
+export const ShapeProperty = "ShapeProperty";
+export function isShapeProperty(item) {
+  return reflection.isInstance(item, ShapeProperty);
+}
+export const SpecificationColor = "SpecificationColor";
+export function isSpecificationColor(item) {
+  return reflection.isInstance(item, SpecificationColor);
+}
+export const SpecificationDeploymentNodeKind = "SpecificationDeploymentNodeKind";
+export function isSpecificationDeploymentNodeKind(item) {
+  return reflection.isInstance(item, SpecificationDeploymentNodeKind);
+}
+export const SpecificationElementKind = "SpecificationElementKind";
+export function isSpecificationElementKind(item) {
+  return reflection.isInstance(item, SpecificationElementKind);
+}
+export const SpecificationElementStringProperty = "SpecificationElementStringProperty";
+export function isSpecificationElementStringProperty(item) {
+  return reflection.isInstance(item, SpecificationElementStringProperty);
+}
+export const SpecificationRelationshipKind = "SpecificationRelationshipKind";
+export function isSpecificationRelationshipKind(item) {
+  return reflection.isInstance(item, SpecificationRelationshipKind);
+}
+export const SpecificationRelationshipStringProperty = "SpecificationRelationshipStringProperty";
+export function isSpecificationRelationshipStringProperty(item) {
+  return reflection.isInstance(item, SpecificationRelationshipStringProperty);
+}
+export const SpecificationRule = "SpecificationRule";
+export function isSpecificationRule(item) {
+  return reflection.isInstance(item, SpecificationRule);
+}
+export const SpecificationTag = "SpecificationTag";
+export function isSpecificationTag(item) {
+  return reflection.isInstance(item, SpecificationTag);
+}
+export const Tag = "Tag";
+export function isTag(item) {
+  return reflection.isInstance(item, Tag);
+}
+export const Tags = "Tags";
+export function isTags(item) {
+  return reflection.isInstance(item, Tags);
+}
+export const ViewRef = "ViewRef";
+export function isViewRef(item) {
+  return reflection.isInstance(item, ViewRef);
+}
+export const ViewRuleAutoLayout = "ViewRuleAutoLayout";
+export function isViewRuleAutoLayout(item) {
+  return reflection.isInstance(item, ViewRuleAutoLayout);
+}
+export const ViewRuleGlobalPredicateRef = "ViewRuleGlobalPredicateRef";
+export function isViewRuleGlobalPredicateRef(item) {
+  return reflection.isInstance(item, ViewRuleGlobalPredicateRef);
+}
+export const ViewRuleGlobalStyle = "ViewRuleGlobalStyle";
+export function isViewRuleGlobalStyle(item) {
+  return reflection.isInstance(item, ViewRuleGlobalStyle);
+}
+export const ViewRuleGroup = "ViewRuleGroup";
+export function isViewRuleGroup(item) {
+  return reflection.isInstance(item, ViewRuleGroup);
+}
+export const ViewRuleStyle = "ViewRuleStyle";
+export function isViewRuleStyle(item) {
+  return reflection.isInstance(item, ViewRuleStyle);
+}
+export const ViewStringProperty = "ViewStringProperty";
+export function isViewStringProperty(item) {
+  return reflection.isInstance(item, ViewStringProperty);
+}
+export const WhereBinaryExpression = "WhereBinaryExpression";
+export function isWhereBinaryExpression(item) {
+  return reflection.isInstance(item, WhereBinaryExpression);
+}
+export const WhereElementKind = "WhereElementKind";
+export function isWhereElementKind(item) {
+  return reflection.isInstance(item, WhereElementKind);
+}
+export const WhereElementNegation = "WhereElementNegation";
+export function isWhereElementNegation(item) {
+  return reflection.isInstance(item, WhereElementNegation);
+}
+export const WhereElementTag = "WhereElementTag";
+export function isWhereElementTag(item) {
+  return reflection.isInstance(item, WhereElementTag);
+}
+export const WhereRelationKind = "WhereRelationKind";
+export function isWhereRelationKind(item) {
+  return reflection.isInstance(item, WhereRelationKind);
+}
+export const WhereRelationNegation = "WhereRelationNegation";
+export function isWhereRelationNegation(item) {
+  return reflection.isInstance(item, WhereRelationNegation);
+}
+export const WhereRelationTag = "WhereRelationTag";
+export function isWhereRelationTag(item) {
+  return reflection.isInstance(item, WhereRelationTag);
+}
+export const WildcardExpression = "WildcardExpression";
+export function isWildcardExpression(item) {
+  return reflection.isInstance(item, WildcardExpression);
+}
+export class LikeC4AstReflection extends AbstractAstReflection {
+  getAllTypes() {
+    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];
+  }
+  computeIsSubtype(subtype, supertype) {
+    switch (subtype) {
+      case ArrowProperty:
+      case LineProperty: {
+        return this.isSubtype(RelationshipStyleProperty, supertype);
+      }
+      case BorderProperty:
+      case OpacityProperty:
+      case ShapeProperty: {
+        return this.isSubtype(StyleProperty, supertype);
+      }
+      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 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: {
+        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);
+      }
+      case ElementStyleProperty: {
+        return this.isSubtype(ElementProperty, supertype);
+      }
+      case ExcludePredicate:
+      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);
+      }
+      case LinkProperty: {
+        return this.isSubtype(ElementProperty, supertype) || this.isSubtype(RelationProperty, supertype) || this.isSubtype(ViewProperty, supertype);
+      }
+      case MetadataAttribute:
+      case NotationProperty:
+      case NotesProperty:
+      case SpecificationElementStringProperty:
+      case SpecificationRelationshipStringProperty: {
+        return this.isSubtype(StringProperty, supertype);
+      }
+      case MetadataBody: {
+        return this.isSubtype(MetadataProperty, supertype);
+      }
+      case MetadataProperty: {
+        return this.isSubtype(ElementProperty, supertype) || this.isSubtype(RelationProperty, supertype);
+      }
+      case RelationExpression:
+      case RelationPredicateWhere: {
+        return this.isSubtype(RelationPredicateOrWhere, supertype);
+      }
+      case RelationNavigateToProperty:
+      case RelationStyleProperty: {
+        return this.isSubtype(RelationProperty, supertype);
+      }
+      case RelationPredicateOrWhere:
+      case RelationPredicateWith: {
+        return this.isSubtype(RelationPredicate, supertype);
+      }
+      case RelationStringProperty: {
+        return this.isSubtype(RelationProperty, supertype) || this.isSubtype(StringProperty, supertype);
+      }
+      case ViewRuleAutoLayout: {
+        return this.isSubtype(DeploymentViewRule, supertype) || this.isSubtype(DynamicViewRule, supertype) || this.isSubtype(ViewRule, supertype);
+      }
+      case ViewRuleGlobalPredicateRef:
+      case ViewRuleGroup:
+      case ViewRulePredicate: {
+        return this.isSubtype(ViewRule, supertype);
+      }
+      case ViewRuleGlobalStyle:
+      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);
+      }
+      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);
+      }
+      case WildcardExpression: {
+        return this.isSubtype(ElementExpression, supertype) || this.isSubtype(FqnExpr, supertype);
+      }
+      default: {
+        return false;
+      }
+    }
+  }
+  getReferenceType(refInfo) {
+    const referenceId = `${refInfo.container.$type}:${refInfo.property}`;
+    switch (referenceId) {
+      case "ColorProperty:customColor": {
+        return CustomColor;
+      }
+      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": {
+        return ElementKind;
+      }
+      case "ElementRef:el":
+      case "FqnElementRef:el": {
+        return Element;
+      }
+      case "ElementTagExpression:tag":
+      case "Tags:values":
+      case "WhereElementTag:value":
+      case "WhereRelationTag:value": {
+        return Tag;
+      }
+      case "ElementViewRef:view": {
+        return ElementView;
+      }
+      case "FqnRef:value": {
+        return Referenceable;
+      }
+      case "IconProperty:libicon": {
+        return LibIcon;
+      }
+      case "ViewRef:view": {
+        return LikeC4View;
+      }
+      case "ViewRuleGlobalPredicateRef:predicate": {
+        return GlobalPredicateGroup;
+      }
+      case "ViewRuleGlobalStyle:style": {
+        return GlobalStyleId;
+      }
+      default: {
+        throw new Error(`${referenceId} is not a valid reference id.`);
+      }
+    }
+  }
+  getTypeMetaData(type) {
+    switch (type) {
+      case ArrowProperty: {
+        return {
+          name: ArrowProperty,
+          properties: [
+            { name: "key" },
+            { name: "value" }
+          ]
+        };
+      }
+      case BorderProperty: {
+        return {
+          name: BorderProperty,
+          properties: [
+            { name: "key" },
+            { name: "value" }
+          ]
+        };
+      }
+      case ColorProperty: {
+        return {
+          name: ColorProperty,
+          properties: [
+            { name: "customColor" },
+            { name: "key" },
+            { name: "themeColor" }
+          ]
+        };
+      }
+      case CustomColor: {
+        return {
+          name: CustomColor,
+          properties: [
+            { name: "name" }
+          ]
+        };
+      }
+      case CustomElementProperties: {
+        return {
+          name: CustomElementProperties,
+          properties: [
+            { name: "props", defaultValue: [] }
+          ]
+        };
+      }
+      case CustomRelationProperties: {
+        return {
+          name: CustomRelationProperties,
+          properties: [
+            { name: "props", defaultValue: [] }
+          ]
+        };
+      }
+      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,
+          properties: [
+            { name: "source" },
+            { name: "target" }
+          ]
+        };
+      }
+      case DynamicView: {
+        return {
+          name: DynamicView,
+          properties: [
+            { name: "body" },
+            { name: "name" }
+          ]
+        };
+      }
+      case DynamicViewBody: {
+        return {
+          name: DynamicViewBody,
+          properties: [
+            { name: "props", defaultValue: [] },
+            { name: "rules", defaultValue: [] },
+            { name: "steps", defaultValue: [] },
+            { name: "tags" }
+          ]
+        };
+      }
+      case DynamicViewGlobalPredicateRef: {
+        return {
+          name: DynamicViewGlobalPredicateRef,
+          properties: [
+            { name: "predicate" }
+          ]
+        };
+      }
+      case DynamicViewIncludePredicate: {
+        return {
+          name: DynamicViewIncludePredicate,
+          properties: [
+            { name: "predicates" }
+          ]
+        };
+      }
+      case DynamicViewParallelSteps: {
+        return {
+          name: DynamicViewParallelSteps,
+          properties: [
+            { name: "steps", defaultValue: [] }
+          ]
+        };
+      }
+      case DynamicViewPredicateIterator: {
+        return {
+          name: DynamicViewPredicateIterator,
+          properties: [
+            { name: "prev" },
+            { name: "value" }
+          ]
+        };
+      }
+      case DynamicViewRef: {
+        return {
+          name: DynamicViewRef,
+          properties: [
+            { name: "view" }
+          ]
+        };
+      }
+      case DynamicViewStep: {
+        return {
+          name: DynamicViewStep,
+          properties: [
+            { name: "custom" },
+            { name: "isBackward", defaultValue: false },
+            { name: "kind" },
+            { name: "source" },
+            { name: "target" },
+            { name: "title" }
+          ]
+        };
+      }
+      case Element: {
+        return {
+          name: Element,
+          properties: [
+            { name: "body" },
+            { name: "kind" },
+            { name: "name" },
+            { name: "props", defaultValue: [] }
+          ]
+        };
+      }
+      case ElementBody: {
+        return {
+          name: ElementBody,
+          properties: [
+            { name: "elements", defaultValue: [] },
+            { name: "props", defaultValue: [] },
+            { name: "tags" }
+          ]
+        };
+      }
+      case ElementDescedantsExpression: {
+        return {
+          name: ElementDescedantsExpression,
+          properties: [
+            { name: "parent" },
+            { name: "suffix" }
+          ]
+        };
+      }
+      case ElementExpressionsIterator: {
+        return {
+          name: ElementExpressionsIterator,
+          properties: [
+            { name: "prev" },
+            { name: "value" }
+          ]
+        };
+      }
+      case ElementKind: {
+        return {
+          name: ElementKind,
+          properties: [
+            { name: "name" }
+          ]
+        };
+      }
+      case ElementKindExpression: {
+        return {
+          name: ElementKindExpression,
+          properties: [
+            { name: "isEqual", defaultValue: false },
+            { name: "kind" }
+          ]
+        };
+      }
+      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: "el" },
+            { name: "parent" }
+          ]
+        };
+      }
+      case ElementStringProperty: {
+        return {
+          name: ElementStringProperty,
+          properties: [
+            { name: "key" },
+            { name: "value" }
+          ]
+        };
+      }
+      case ElementStyleProperty: {
+        return {
+          name: ElementStyleProperty,
+          properties: [
+            { name: "key" },
+            { name: "props", defaultValue: [] }
+          ]
+        };
+      }
+      case ElementTagExpression: {
+        return {
+          name: ElementTagExpression,
+          properties: [
+            { name: "isEqual", defaultValue: false },
+            { name: "tag" }
+          ]
+        };
+      }
+      case ElementView: {
+        return {
+          name: ElementView,
+          properties: [
+            { name: "body" },
+            { name: "extends" },
+            { name: "name" },
+            { name: "viewOf" }
+          ]
+        };
+      }
+      case ElementViewBody: {
+        return {
+          name: ElementViewBody,
+          properties: [
+            { name: "props", defaultValue: [] },
+            { name: "rules", defaultValue: [] },
+            { name: "tags" }
+          ]
+        };
+      }
+      case ElementViewRef: {
+        return {
+          name: ElementViewRef,
+          properties: [
+            { name: "view" }
+          ]
+        };
+      }
+      case ExcludePredicate: {
+        return {
+          name: ExcludePredicate,
+          properties: [
+            { name: "predicates" }
+          ]
+        };
+      }
+      case ExpandElementExpression: {
+        return {
+          name: ExpandElementExpression,
+          properties: [
+            { name: "expand" }
+          ]
+        };
+      }
+      case ExtendElement: {
+        return {
+          name: ExtendElement,
+          properties: [
+            { name: "body" },
+            { name: "element" }
+          ]
+        };
+      }
+      case ExtendElementBody: {
+        return {
+          name: ExtendElementBody,
+          properties: [
+            { name: "elements", defaultValue: [] }
+          ]
+        };
+      }
+      case FqnElementRef: {
+        return {
+          name: FqnElementRef,
+          properties: [
+            { name: "el" },
+            { name: "parent" }
+          ]
+        };
+      }
+      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,
+          properties: [
+            { name: "name" },
+            { name: "predicates", defaultValue: [] }
+          ]
+        };
+      }
+      case GlobalPredicateGroup: {
+        return {
+          name: GlobalPredicateGroup,
+          properties: [
+            { name: "name" },
+            { name: "predicates", defaultValue: [] }
+          ]
+        };
+      }
+      case Globals: {
+        return {
+          name: Globals,
+          properties: [
+            { name: "name" },
+            { name: "predicates", defaultValue: [] },
+            { name: "styles", defaultValue: [] }
+          ]
+        };
+      }
+      case GlobalStyle: {
+        return {
+          name: GlobalStyle,
+          properties: [
+            { name: "id" },
+            { name: "props", defaultValue: [] },
+            { name: "target" }
+          ]
+        };
+      }
+      case GlobalStyleGroup: {
+        return {
+          name: GlobalStyleGroup,
+          properties: [
+            { name: "id" },
+            { name: "styles", defaultValue: [] }
+          ]
+        };
+      }
+      case GlobalStyleId: {
+        return {
+          name: GlobalStyleId,
+          properties: [
+            { name: "name" }
+          ]
+        };
+      }
+      case IconProperty: {
+        return {
+          name: IconProperty,
+          properties: [
+            { name: "key" },
+            { name: "libicon" },
+            { name: "value" }
+          ]
+        };
+      }
+      case IncludePredicate: {
+        return {
+          name: IncludePredicate,
+          properties: [
+            { name: "predicates" }
+          ]
+        };
+      }
+      case IncomingRelationExpr: {
+        return {
+          name: IncomingRelationExpr,
+          properties: [
+            { name: "to" }
+          ]
+        };
+      }
+      case IncomingRelationExpression: {
+        return {
+          name: IncomingRelationExpression,
+          properties: [
+            { name: "to" }
+          ]
+        };
+      }
+      case InOutRelationExpr: {
+        return {
+          name: InOutRelationExpr,
+          properties: [
+            { name: "inout" }
+          ]
+        };
+      }
+      case InOutRelationExpression: {
+        return {
+          name: InOutRelationExpression,
+          properties: [
+            { name: "inout" }
+          ]
+        };
+      }
+      case LibIcon: {
+        return {
+          name: LibIcon,
+          properties: [
+            { name: "name" }
+          ]
+        };
+      }
+      case LikeC4Grammar: {
+        return {
+          name: LikeC4Grammar,
+          properties: [
+            { name: "deployments", defaultValue: [] },
+            { name: "globals", defaultValue: [] },
+            { name: "likec4lib", defaultValue: [] },
+            { name: "models", defaultValue: [] },
+            { name: "specifications", defaultValue: [] },
+            { name: "views", defaultValue: [] }
+          ]
+        };
+      }
+      case LikeC4Lib: {
+        return {
+          name: LikeC4Lib,
+          properties: [
+            { name: "icons", defaultValue: [] }
+          ]
+        };
+      }
+      case LineProperty: {
+        return {
+          name: LineProperty,
+          properties: [
+            { name: "key" },
+            { name: "value" }
+          ]
+        };
+      }
+      case LinkProperty: {
+        return {
+          name: LinkProperty,
+          properties: [
+            { name: "key" },
+            { name: "title" },
+            { name: "value" }
+          ]
+        };
+      }
+      case MetadataAttribute: {
+        return {
+          name: MetadataAttribute,
+          properties: [
+            { name: "key" },
+            { name: "value" }
+          ]
+        };
+      }
+      case MetadataBody: {
+        return {
+          name: MetadataBody,
+          properties: [
+            { name: "props", defaultValue: [] }
+          ]
+        };
+      }
+      case Model: {
+        return {
+          name: Model,
+          properties: [
+            { name: "elements", defaultValue: [] },
+            { name: "name" }
+          ]
+        };
+      }
+      case ModelDeployments: {
+        return {
+          name: ModelDeployments,
+          properties: [
+            { name: "elements", defaultValue: [] },
+            { name: "name" }
+          ]
+        };
+      }
+      case ModelViews: {
+        return {
+          name: ModelViews,
+          properties: [
+            { name: "name" },
+            { name: "styles", defaultValue: [] },
+            { name: "views", defaultValue: [] }
+          ]
+        };
+      }
+      case NavigateToProperty: {
+        return {
+          name: NavigateToProperty,
+          properties: [
+            { name: "key" },
+            { name: "value" }
+          ]
+        };
+      }
+      case NotationProperty: {
+        return {
+          name: NotationProperty,
+          properties: [
+            { name: "key" },
+            { name: "value" }
+          ]
+        };
+      }
+      case NotesProperty: {
+        return {
+          name: NotesProperty,
+          properties: [
+            { name: "key" },
+            { name: "value" }
+          ]
+        };
+      }
+      case OpacityProperty: {
+        return {
+          name: OpacityProperty,
+          properties: [
+            { name: "key" },
+            { name: "value" }
+          ]
+        };
+      }
+      case OutgoingRelationExpr: {
+        return {
+          name: OutgoingRelationExpr,
+          properties: [
+            { name: "from" },
+            { name: "isBidirectional", defaultValue: false },
+            { name: "kind" }
+          ]
+        };
+      }
+      case OutgoingRelationExpression: {
+        return {
+          name: OutgoingRelationExpression,
+          properties: [
+            { name: "from" },
+            { name: "isBidirectional", defaultValue: false },
+            { name: "kind" }
+          ]
+        };
+      }
+      case Predicates: {
+        return {
+          name: Predicates,
+          properties: [
+            { name: "prev" },
+            { name: "value" }
+          ]
+        };
+      }
+      case Relation: {
+        return {
+          name: Relation,
+          properties: [
+            { name: "body" },
+            { name: "kind" },
+            { name: "source" },
+            { name: "tags" },
+            { name: "target" },
+            { name: "technology" },
+            { name: "title" }
+          ]
+        };
+      }
+      case RelationBody: {
+        return {
+          name: RelationBody,
+          properties: [
+            { name: "props", defaultValue: [] },
+            { name: "tags" }
+          ]
+        };
+      }
+      case RelationNavigateToProperty: {
+        return {
+          name: RelationNavigateToProperty,
+          properties: [
+            { name: "key" },
+            { name: "value" }
+          ]
+        };
+      }
+      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,
+          properties: [
+            { name: "name" }
+          ]
+        };
+      }
+      case RelationStringProperty: {
+        return {
+          name: RelationStringProperty,
+          properties: [
+            { name: "key" },
+            { name: "value" }
+          ]
+        };
+      }
+      case RelationStyleProperty: {
+        return {
+          name: RelationStyleProperty,
+          properties: [
+            { name: "key" },
+            { name: "props", defaultValue: [] }
+          ]
+        };
+      }
+      case ShapeProperty: {
+        return {
+          name: ShapeProperty,
+          properties: [
+            { name: "key" },
+            { name: "value" }
+          ]
+        };
+      }
+      case SpecificationColor: {
+        return {
+          name: SpecificationColor,
+          properties: [
+            { name: "color" },
+            { name: "name" }
+          ]
+        };
+      }
+      case SpecificationDeploymentNodeKind: {
+        return {
+          name: SpecificationDeploymentNodeKind,
+          properties: [
+            { name: "kind" },
+            { name: "props", defaultValue: [] }
+          ]
+        };
+      }
+      case SpecificationElementKind: {
+        return {
+          name: SpecificationElementKind,
+          properties: [
+            { name: "kind" },
+            { name: "props", defaultValue: [] }
+          ]
+        };
+      }
+      case SpecificationElementStringProperty: {
+        return {
+          name: SpecificationElementStringProperty,
+          properties: [
+            { name: "key" },
+            { name: "value" }
+          ]
+        };
+      }
+      case SpecificationRelationshipKind: {
+        return {
+          name: SpecificationRelationshipKind,
+          properties: [
+            { name: "kind" },
+            { name: "props", defaultValue: [] }
+          ]
+        };
+      }
+      case SpecificationRelationshipStringProperty: {
+        return {
+          name: SpecificationRelationshipStringProperty,
+          properties: [
+            { name: "key" },
+            { name: "value" }
+          ]
+        };
+      }
+      case SpecificationRule: {
+        return {
+          name: SpecificationRule,
+          properties: [
+            { name: "colors", defaultValue: [] },
+            { name: "deploymentNodes", defaultValue: [] },
+            { name: "elements", defaultValue: [] },
+            { name: "name" },
+            { name: "relationships", defaultValue: [] },
+            { name: "tags", defaultValue: [] }
+          ]
+        };
+      }
+      case SpecificationTag: {
+        return {
+          name: SpecificationTag,
+          properties: [
+            { name: "tag" }
+          ]
+        };
+      }
+      case Tag: {
+        return {
+          name: Tag,
+          properties: [
+            { name: "name" }
+          ]
+        };
+      }
+      case Tags: {
+        return {
+          name: Tags,
+          properties: [
+            { name: "prev" },
+            { name: "values", defaultValue: [] }
+          ]
+        };
+      }
+      case ViewRef: {
+        return {
+          name: ViewRef,
+          properties: [
+            { name: "view" }
+          ]
+        };
+      }
+      case ViewRuleAutoLayout: {
+        return {
+          name: ViewRuleAutoLayout,
+          properties: [
+            { name: "direction" },
+            { name: "nodeSep" },
+            { name: "rankSep" }
+          ]
+        };
+      }
+      case ViewRuleGlobalPredicateRef: {
+        return {
+          name: ViewRuleGlobalPredicateRef,
+          properties: [
+            { name: "predicate" }
+          ]
+        };
+      }
+      case ViewRuleGlobalStyle: {
+        return {
+          name: ViewRuleGlobalStyle,
+          properties: [
+            { name: "style" }
+          ]
+        };
+      }
+      case ViewRuleGroup: {
+        return {
+          name: ViewRuleGroup,
+          properties: [
+            { name: "groupRules", defaultValue: [] },
+            { name: "props", defaultValue: [] },
+            { name: "title" }
+          ]
+        };
+      }
+      case ViewRuleStyle: {
+        return {
+          name: ViewRuleStyle,
+          properties: [
+            { name: "props", defaultValue: [] },
+            { name: "target" }
+          ]
+        };
+      }
+      case ViewStringProperty: {
+        return {
+          name: ViewStringProperty,
+          properties: [
+            { name: "key" },
+            { name: "value" }
+          ]
+        };
+      }
+      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,
+          properties: [
+            { name: "isWildcard", defaultValue: false }
+          ]
+        };
+      }
+      default: {
+        return {
+          name: type,
+          properties: []
+        };
+      }
+    }
+  }
+}
+export const reflection = new LikeC4AstReflection();