@likec4/language-server 1.1.1 → 1.2.1

package/src/generated/ast.ts

@@ -0,0 +1,1632 @@
+/******************************************************************************
+ * This file was generated by langium-cli 3.0.3.
+ * DO NOT EDIT MANUALLY!
+ ******************************************************************************/
+
+/* eslint-disable */
+import type { AstNode, Reference, ReferenceInfo, TypeMetaData } from 'langium';
+import { AbstractAstReflection } from 'langium';
+
+export const LikeC4Terminals = {
+    BLOCK_COMMENT: /\/\*[\s\S]*?\*\//,
+    LINE_COMMENT: /\/\/[^\n\r]*/,
+    WS: /\s+/,
+    URI_WITH_SCHEMA: /\w+:\/\/\S+/,
+    URI_RELATIVE: /\.{0,2}\/[^\/]\S+/,
+    DotUnderscore: /\b\._/,
+    DotWildcard: /\b\.\*/,
+    TagHash: /\#\b/,
+    Dot: /\b\./,
+    NotEqual: /\!\={1,2}/,
+    Eq: /\={1,2}/,
+    Colon: /:/,
+    SemiColon: /;/,
+    Comma: /,/,
+    Percent: /\b\d+%/,
+    String: /"[^"]*"|'[^']*'/,
+    IdTerminal: /\b[_]*[a-zA-Z][_-\w]*/,
+};
+
+export type ArrowType = 'crow' | 'diamond' | 'none' | 'normal' | 'odiamond' | 'onormal' | 'open' | 'vee';
+
+export function isArrowType(item: unknown): item is ArrowType {
+    return item === 'none' || item === 'normal' || item === 'onormal' || item === 'diamond' || item === 'odiamond' || item === 'crow' || item === 'open' || item === 'vee';
+}
+
+export type BorderStyleValue = 'none' | LineOptions;
+
+export function isBorderStyleValue(item: unknown): item is BorderStyleValue {
+    return isLineOptions(item) || item === 'none';
+}
+
+export type DynamicViewRule = DynamicViewRulePredicate | ViewRuleAutoLayout | ViewRuleStyle;
+
+export const DynamicViewRule = 'DynamicViewRule';
+
+export function isDynamicViewRule(item: unknown): item is DynamicViewRule {
+    return reflection.isInstance(item, DynamicViewRule);
+}
+
+export type ElementExpr = DescedantsExpr | ElementKindExpr | ElementRef | ElementTagExpr | ExpandElementExpr | WildcardExpr;
+
+export const ElementExpr = 'ElementExpr';
+
+export function isElementExpr(item: unknown): item is ElementExpr {
+    return reflection.isInstance(item, ElementExpr);
+}
+
+export type ElementProperty = ElementStringProperty | LinkProperty | StyleProperties;
+
+export const ElementProperty = 'ElementProperty';
+
+export function isElementProperty(item: unknown): item is ElementProperty {
+    return reflection.isInstance(item, ElementProperty);
+}
+
+export type ElementShape = 'browser' | 'cylinder' | 'mobile' | 'person' | 'queue' | 'rectangle' | 'storage';
+
+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 Id = 'element' | 'model' | ArrowType | ElementShape | LineOptions | ThemeColor | string;
+
+export function isId(item: unknown): item is Id {
+    return isElementShape(item) || isThemeColor(item) || isArrowType(item) || isLineOptions(item) || item === 'element' || item === 'model' || (typeof item === 'string' && (/\b[_]*[a-zA-Z][_-\w]*/.test(item)));
+}
+
+export type LikeC4View = DynamicView | ElementView;
+
+export const LikeC4View = 'LikeC4View';
+
+export function isLikeC4View(item: unknown): item is LikeC4View {
+    return reflection.isInstance(item, LikeC4View);
+}
+
+export type LineOptions = 'dashed' | 'dotted' | 'solid';
+
+export function isLineOptions(item: unknown): item is LineOptions {
+    return item === 'solid' || item === 'dashed' || item === 'dotted';
+}
+
+export type Relation = ExplicitRelation | ImplicitRelation;
+
+export const Relation = 'Relation';
+
+export function isRelation(item: unknown): item is Relation {
+    return reflection.isInstance(item, Relation);
+}
+
+export type RelationProperty = LinkProperty | RelationStringProperty | RelationStyleProperty;
+
+export const RelationProperty = 'RelationProperty';
+
+export function isRelationProperty(item: unknown): item is RelationProperty {
+    return reflection.isInstance(item, RelationProperty);
+}
+
+export type RelationshipStyleProperty = ArrowProperty | ColorProperty | LineProperty;
+
+export const RelationshipStyleProperty = 'RelationshipStyleProperty';
+
+export function isRelationshipStyleProperty(item: unknown): item is RelationshipStyleProperty {
+    return reflection.isInstance(item, RelationshipStyleProperty);
+}
+
+export type StyleProperty = BorderProperty | ColorProperty | IconProperty | OpacityProperty | ShapeProperty;
+
+export const StyleProperty = 'StyleProperty';
+
+export function isStyleProperty(item: unknown): item is StyleProperty {
+    return reflection.isInstance(item, StyleProperty);
+}
+
+export type TagId = string;
+
+export function isTagId(item: unknown): item is TagId {
+    return typeof item === 'string';
+}
+
+export type ThemeColor = 'amber' | 'blue' | 'gray' | 'green' | 'indigo' | 'muted' | 'primary' | 'red' | 'secondary' | 'sky' | 'slate';
+
+export function isThemeColor(item: unknown): item is ThemeColor {
+    return item === 'primary' || item === 'secondary' || item === 'muted' || item === 'slate' || item === 'blue' || item === 'indigo' || item === 'sky' || item === 'red' || item === 'gray' || item === 'green' || item === 'amber';
+}
+
+export type Uri = string;
+
+export function isUri(item: unknown): item is Uri {
+    return (typeof item === 'string' && (/\w+:\/\/\S+/.test(item) || /\.{0,2}\/[^\/]\S+/.test(item)));
+}
+
+export type ViewLayoutDirection = 'BottomTop' | 'LeftRight' | 'RightLeft' | 'TopBottom';
+
+export function isViewLayoutDirection(item: unknown): item is ViewLayoutDirection {
+    return item === 'TopBottom' || item === 'LeftRight' || item === 'BottomTop' || item === 'RightLeft';
+}
+
+export type ViewProperty = LinkProperty | ViewStringProperty;
+
+export const ViewProperty = 'ViewProperty';
+
+export function isViewProperty(item: unknown): item is ViewProperty {
+    return reflection.isInstance(item, ViewProperty);
+}
+
+export type ViewRule = ViewRuleAutoLayout | ViewRulePredicate | ViewRuleStyle;
+
+export const ViewRule = 'ViewRule';
+
+export function isViewRule(item: unknown): item is ViewRule {
+    return reflection.isInstance(item, ViewRule);
+}
+
+export type ViewRulePredicate = ExcludePredicate | IncludePredicate;
+
+export const ViewRulePredicate = 'ViewRulePredicate';
+
+export function isViewRulePredicate(item: unknown): item is ViewRulePredicate {
+    return reflection.isInstance(item, ViewRulePredicate);
+}
+
+export type ViewRulePredicateExpr = CustomElementExpr | ElementExpr | InOutExpr | IncomingExpr | OutgoingExpr | RelationExpr;
+
+export const ViewRulePredicateExpr = 'ViewRulePredicateExpr';
+
+export function isViewRulePredicateExpr(item: unknown): item is ViewRulePredicateExpr {
+    return reflection.isInstance(item, ViewRulePredicateExpr);
+}
+
+export interface ArrowProperty extends AstNode {
+    readonly $container: RelationStyleProperty | SpecificationRelationshipKind;
+    readonly $type: 'ArrowProperty';
+    key: 'head' | 'tail';
+    value: ArrowType;
+}
+
+export const ArrowProperty = 'ArrowProperty';
+
+export function isArrowProperty(item: unknown): item is ArrowProperty {
+    return reflection.isInstance(item, ArrowProperty);
+}
+
+export interface BorderProperty extends AstNode {
+    readonly $container: CustomElementExprBody | StyleProperties | ViewRuleStyle;
+    readonly $type: 'BorderProperty';
+    key: 'border';
+    value: BorderStyleValue;
+}
+
+export const BorderProperty = 'BorderProperty';
+
+export function isBorderProperty(item: unknown): item is BorderProperty {
+    return reflection.isInstance(item, BorderProperty);
+}
+
+export interface ColorProperty extends AstNode {
+    readonly $container: CustomElementExprBody | RelationStyleProperty | SpecificationRelationshipKind | StyleProperties | ViewRuleStyle;
+    readonly $type: 'ColorProperty';
+    key: 'color';
+    value: ThemeColor;
+}
+
+export const ColorProperty = 'ColorProperty';
+
+export function isColorProperty(item: unknown): item is ColorProperty {
+    return reflection.isInstance(item, ColorProperty);
+}
+
+export interface CustomElementExpr extends AstNode {
+    readonly $container: DynamicViewRulePredicate | ExcludePredicate | IncludePredicate;
+    readonly $type: 'CustomElementExpr';
+    body: CustomElementExprBody;
+    target: ElementExpr;
+}
+
+export const CustomElementExpr = 'CustomElementExpr';
+
+export function isCustomElementExpr(item: unknown): item is CustomElementExpr {
+    return reflection.isInstance(item, CustomElementExpr);
+}
+
+export interface CustomElementExprBody extends AstNode {
+    readonly $container: CustomElementExpr;
+    readonly $type: 'CustomElementExprBody';
+    props: Array<ElementStringProperty | NavigateToProperty | StyleProperty>;
+}
+
+export const CustomElementExprBody = 'CustomElementExprBody';
+
+export function isCustomElementExprBody(item: unknown): item is CustomElementExprBody {
+    return reflection.isInstance(item, CustomElementExprBody);
+}
+
+export interface DescedantsExpr extends AstNode {
+    readonly $container: CustomElementExpr | DynamicViewRulePredicate | ExcludePredicate | IncludePredicate | IncomingExpr | OutgoingExpr | RelationExpr | ViewRuleStyle;
+    readonly $type: 'DescedantsExpr';
+    parent: ElementRef;
+}
+
+export const DescedantsExpr = 'DescedantsExpr';
+
+export function isDescedantsExpr(item: unknown): item is DescedantsExpr {
+    return reflection.isInstance(item, DescedantsExpr);
+}
+
+export interface DynamicView extends AstNode {
+    readonly $container: ModelViews;
+    readonly $type: 'DynamicView';
+    body: DynamicViewBody;
+    name: Id;
+}
+
+export const DynamicView = 'DynamicView';
+
+export function isDynamicView(item: unknown): item is DynamicView {
+    return reflection.isInstance(item, DynamicView);
+}
+
+export interface DynamicViewBody extends AstNode {
+    readonly $container: DynamicView;
+    readonly $type: 'DynamicViewBody';
+    props: Array<ViewProperty>;
+    rules: Array<DynamicViewRule>;
+    steps: Array<DynamicViewStep>;
+    tags?: Tags;
+}
+
+export const DynamicViewBody = 'DynamicViewBody';
+
+export function isDynamicViewBody(item: unknown): item is DynamicViewBody {
+    return reflection.isInstance(item, DynamicViewBody);
+}
+
+export interface DynamicViewRulePredicate extends AstNode {
+    readonly $container: DynamicViewBody;
+    readonly $type: 'DynamicViewRulePredicate';
+    expressions: Array<ViewRulePredicateExpr>;
+}
+
+export const DynamicViewRulePredicate = 'DynamicViewRulePredicate';
+
+export function isDynamicViewRulePredicate(item: unknown): item is DynamicViewRulePredicate {
+    return reflection.isInstance(item, DynamicViewRulePredicate);
+}
+
+export interface DynamicViewStep extends AstNode {
+    readonly $container: DynamicViewBody;
+    readonly $type: 'DynamicViewStep';
+    isBackward: boolean;
+    kind?: Reference<RelationshipKind>;
+    source: ElementRef;
+    target: ElementRef;
+    title?: string;
+}
+
+export const DynamicViewStep = 'DynamicViewStep';
+
+export function isDynamicViewStep(item: unknown): item is DynamicViewStep {
+    return reflection.isInstance(item, DynamicViewStep);
+}
+
+export interface Element extends AstNode {
+    readonly $container: ElementBody | ExtendElementBody | Model;
+    readonly $type: 'Element';
+    body?: ElementBody;
+    kind: Reference<ElementKind>;
+    name: Id;
+    props: Array<string>;
+}
+
+export const Element = 'Element';
+
+export function isElement(item: unknown): item is Element {
+    return reflection.isInstance(item, Element);
+}
+
+export interface ElementBody extends AstNode {
+    readonly $container: Element;
+    readonly $type: 'ElementBody';
+    elements: Array<Element | Relation>;
+    props: Array<ElementProperty>;
+    tags?: Tags;
+}
+
+export const ElementBody = 'ElementBody';
+
+export function isElementBody(item: unknown): item is ElementBody {
+    return reflection.isInstance(item, ElementBody);
+}
+
+export interface ElementKind extends AstNode {
+    readonly $container: SpecificationElementKind;
+    readonly $type: 'ElementKind';
+    name: Id;
+}
+
+export const ElementKind = 'ElementKind';
+
+export function isElementKind(item: unknown): item is ElementKind {
+    return reflection.isInstance(item, ElementKind);
+}
+
+export interface ElementKindExpr extends AstNode {
+    readonly $container: CustomElementExpr | DynamicViewRulePredicate | ExcludePredicate | IncludePredicate | IncomingExpr | OutgoingExpr | RelationExpr | ViewRuleStyle;
+    readonly $type: 'ElementKindExpr';
+    isEqual: boolean;
+    kind: Reference<ElementKind>;
+}
+
+export const ElementKindExpr = 'ElementKindExpr';
+
+export function isElementKindExpr(item: unknown): item is ElementKindExpr {
+    return reflection.isInstance(item, ElementKindExpr);
+}
+
+export interface ElementRef extends AstNode {
+    readonly $container: CustomElementExpr | DescedantsExpr | DynamicViewRulePredicate | DynamicViewStep | ElementRef | ElementView | ExcludePredicate | ExpandElementExpr | ExplicitRelation | ImplicitRelation | IncludePredicate | IncomingExpr | OutgoingExpr | RelationExpr | ViewRuleStyle;
+    readonly $type: 'ElementRef';
+    el: Reference<Element>;
+    parent?: ElementRef;
+}
+
+export const ElementRef = 'ElementRef';
+
+export function isElementRef(item: unknown): item is ElementRef {
+    return reflection.isInstance(item, ElementRef);
+}
+
+export interface ElementStringProperty extends AstNode {
+    readonly $container: CustomElementExprBody | ElementBody;
+    readonly $type: 'ElementStringProperty';
+    key: 'description' | 'technology' | 'title';
+    value: string;
+}
+
+export const ElementStringProperty = 'ElementStringProperty';
+
+export function isElementStringProperty(item: unknown): item is ElementStringProperty {
+    return reflection.isInstance(item, ElementStringProperty);
+}
+
+export interface ElementTagExpr extends AstNode {
+    readonly $container: CustomElementExpr | DynamicViewRulePredicate | ExcludePredicate | IncludePredicate | IncomingExpr | OutgoingExpr | RelationExpr | ViewRuleStyle;
+    readonly $type: 'ElementTagExpr';
+    isEqual: boolean;
+    tag: Reference<Tag>;
+}
+
+export const ElementTagExpr = 'ElementTagExpr';
+
+export function isElementTagExpr(item: unknown): item is ElementTagExpr {
+    return reflection.isInstance(item, ElementTagExpr);
+}
+
+export interface ElementView extends AstNode {
+    readonly $container: ModelViews;
+    readonly $type: 'ElementView';
+    body: ElementViewBody;
+    extends?: ElementViewRef;
+    name?: Id;
+    viewOf?: ElementRef;
+}
+
+export const ElementView = 'ElementView';
+
+export function isElementView(item: unknown): item is ElementView {
+    return reflection.isInstance(item, ElementView);
+}
+
+export interface ElementViewBody extends AstNode {
+    readonly $container: ElementView;
+    readonly $type: 'ElementViewBody';
+    props: Array<ViewProperty>;
+    rules: Array<ViewRule>;
+    tags?: Tags;
+}
+
+export const ElementViewBody = 'ElementViewBody';
+
+export function isElementViewBody(item: unknown): item is ElementViewBody {
+    return reflection.isInstance(item, ElementViewBody);
+}
+
+export interface ElementViewRef extends AstNode {
+    readonly $container: ElementView;
+    readonly $type: 'ElementViewRef';
+    view: Reference<ElementView>;
+}
+
+export const ElementViewRef = 'ElementViewRef';
+
+export function isElementViewRef(item: unknown): item is ElementViewRef {
+    return reflection.isInstance(item, ElementViewRef);
+}
+
+export interface ExcludePredicate extends AstNode {
+    readonly $container: ElementViewBody;
+    readonly $type: 'ExcludePredicate';
+    expressions: Array<ViewRulePredicateExpr>;
+}
+
+export const ExcludePredicate = 'ExcludePredicate';
+
+export function isExcludePredicate(item: unknown): item is ExcludePredicate {
+    return reflection.isInstance(item, ExcludePredicate);
+}
+
+export interface ExpandElementExpr extends AstNode {
+    readonly $container: CustomElementExpr | DynamicViewRulePredicate | ExcludePredicate | IncludePredicate | IncomingExpr | OutgoingExpr | RelationExpr | ViewRuleStyle;
+    readonly $type: 'ExpandElementExpr';
+    parent: ElementRef;
+}
+
+export const ExpandElementExpr = 'ExpandElementExpr';
+
+export function isExpandElementExpr(item: unknown): item is ExpandElementExpr {
+    return reflection.isInstance(item, ExpandElementExpr);
+}
+
+export interface ExplicitRelation extends AstNode {
+    readonly $container: ElementBody | ExtendElementBody | Model;
+    readonly $type: 'ExplicitRelation';
+    body?: RelationBody;
+    kind?: Reference<RelationshipKind>;
+    source: ElementRef;
+    tags?: Tags;
+    target: ElementRef;
+    title?: string;
+}
+
+export const ExplicitRelation = 'ExplicitRelation';
+
+export function isExplicitRelation(item: unknown): item is ExplicitRelation {
+    return reflection.isInstance(item, ExplicitRelation);
+}
+
+export interface ExtendElement extends AstNode {
+    readonly $container: Model;
+    readonly $type: 'ExtendElement';
+    body: ExtendElementBody;
+    element: FqnElementRef;
+}
+
+export const ExtendElement = 'ExtendElement';
+
+export function isExtendElement(item: unknown): item is ExtendElement {
+    return reflection.isInstance(item, ExtendElement);
+}
+
+export interface ExtendElementBody extends AstNode {
+    readonly $container: ExtendElement;
+    readonly $type: 'ExtendElementBody';
+    elements: Array<Element | ExplicitRelation>;
+}
+
+export const ExtendElementBody = 'ExtendElementBody';
+
+export function isExtendElementBody(item: unknown): item is ExtendElementBody {
+    return reflection.isInstance(item, ExtendElementBody);
+}
+
+export interface FqnElementRef extends AstNode {
+    readonly $container: ExtendElement | FqnElementRef;
+    readonly $type: 'FqnElementRef';
+    el: Reference<Element>;
+    parent?: FqnElementRef;
+}
+
+export const FqnElementRef = 'FqnElementRef';
+
+export function isFqnElementRef(item: unknown): item is FqnElementRef {
+    return reflection.isInstance(item, FqnElementRef);
+}
+
+export interface IconProperty extends AstNode {
+    readonly $container: CustomElementExprBody | StyleProperties | ViewRuleStyle;
+    readonly $type: 'IconProperty';
+    key: 'icon';
+    value: Uri;
+}
+
+export const IconProperty = 'IconProperty';
+
+export function isIconProperty(item: unknown): item is IconProperty {
+    return reflection.isInstance(item, IconProperty);
+}
+
+export interface ImplicitRelation extends AstNode {
+    readonly $container: ElementBody;
+    readonly $type: 'ImplicitRelation';
+    body?: RelationBody;
+    kind?: Reference<RelationshipKind>;
+    tags?: Tags;
+    target: ElementRef;
+    title?: string;
+}
+
+export const ImplicitRelation = 'ImplicitRelation';
+
+export function isImplicitRelation(item: unknown): item is ImplicitRelation {
+    return reflection.isInstance(item, ImplicitRelation);
+}
+
+export interface IncludePredicate extends AstNode {
+    readonly $container: ElementViewBody;
+    readonly $type: 'IncludePredicate';
+    expressions: Array<ViewRulePredicateExpr>;
+}
+
+export const IncludePredicate = 'IncludePredicate';
+
+export function isIncludePredicate(item: unknown): item is IncludePredicate {
+    return reflection.isInstance(item, IncludePredicate);
+}
+
+export interface IncomingExpr extends AstNode {
+    readonly $container: DynamicViewRulePredicate | ExcludePredicate | InOutExpr | IncludePredicate;
+    readonly $type: 'IncomingExpr';
+    to: ElementExpr;
+}
+
+export const IncomingExpr = 'IncomingExpr';
+
+export function isIncomingExpr(item: unknown): item is IncomingExpr {
+    return reflection.isInstance(item, IncomingExpr);
+}
+
+export interface InOutExpr extends AstNode {
+    readonly $container: DynamicViewRulePredicate | ExcludePredicate | IncludePredicate;
+    readonly $type: 'InOutExpr';
+    inout: IncomingExpr;
+}
+
+export const InOutExpr = 'InOutExpr';
+
+export function isInOutExpr(item: unknown): item is InOutExpr {
+    return reflection.isInstance(item, InOutExpr);
+}
+
+export interface LikeC4Grammar extends AstNode {
+    readonly $type: 'LikeC4Grammar';
+    models: Array<Model>;
+    specifications: Array<SpecificationRule>;
+    views: Array<ModelViews>;
+}
+
+export const LikeC4Grammar = 'LikeC4Grammar';
+
+export function isLikeC4Grammar(item: unknown): item is LikeC4Grammar {
+    return reflection.isInstance(item, LikeC4Grammar);
+}
+
+export interface LineProperty extends AstNode {
+    readonly $container: RelationStyleProperty | SpecificationRelationshipKind;
+    readonly $type: 'LineProperty';
+    key: 'line';
+    value: LineOptions;
+}
+
+export const LineProperty = 'LineProperty';
+
+export function isLineProperty(item: unknown): item is LineProperty {
+    return reflection.isInstance(item, LineProperty);
+}
+
+export interface LinkProperty extends AstNode {
+    readonly $container: DynamicViewBody | ElementBody | ElementViewBody | RelationBody;
+    readonly $type: 'LinkProperty';
+    key: 'link';
+    value: Uri;
+}
+
+export const LinkProperty = 'LinkProperty';
+
+export function isLinkProperty(item: unknown): item is LinkProperty {
+    return reflection.isInstance(item, LinkProperty);
+}
+
+export interface Model extends AstNode {
+    readonly $container: LikeC4Grammar;
+    readonly $type: 'Model';
+    elements: Array<Element | ExplicitRelation | ExtendElement>;
+    name: 'model';
+}
+
+export const Model = 'Model';
+
+export function isModel(item: unknown): item is Model {
+    return reflection.isInstance(item, Model);
+}
+
+export interface ModelViews extends AstNode {
+    readonly $container: LikeC4Grammar;
+    readonly $type: 'ModelViews';
+    name: 'views';
+    views: Array<DynamicView | ElementView>;
+}
+
+export const ModelViews = 'ModelViews';
+
+export function isModelViews(item: unknown): item is ModelViews {
+    return reflection.isInstance(item, ModelViews);
+}
+
+export interface NavigateToProperty extends AstNode {
+    readonly $container: CustomElementExprBody;
+    readonly $type: 'NavigateToProperty';
+    value: ViewRef;
+}
+
+export const NavigateToProperty = 'NavigateToProperty';
+
+export function isNavigateToProperty(item: unknown): item is NavigateToProperty {
+    return reflection.isInstance(item, NavigateToProperty);
+}
+
+export interface OpacityProperty extends AstNode {
+    readonly $container: CustomElementExprBody | StyleProperties | ViewRuleStyle;
+    readonly $type: 'OpacityProperty';
+    key: 'opacity';
+    value: string;
+}
+
+export const OpacityProperty = 'OpacityProperty';
+
+export function isOpacityProperty(item: unknown): item is OpacityProperty {
+    return reflection.isInstance(item, OpacityProperty);
+}
+
+export interface OutgoingExpr extends AstNode {
+    readonly $container: DynamicViewRulePredicate | ExcludePredicate | IncludePredicate;
+    readonly $type: 'OutgoingExpr';
+    from: ElementExpr;
+}
+
+export const OutgoingExpr = 'OutgoingExpr';
+
+export function isOutgoingExpr(item: unknown): item is OutgoingExpr {
+    return reflection.isInstance(item, OutgoingExpr);
+}
+
+export interface RelationBody extends AstNode {
+    readonly $container: ExplicitRelation | ImplicitRelation;
+    readonly $type: 'RelationBody';
+    props: Array<RelationProperty>;
+    tags?: Tags;
+}
+
+export const RelationBody = 'RelationBody';
+
+export function isRelationBody(item: unknown): item is RelationBody {
+    return reflection.isInstance(item, RelationBody);
+}
+
+export interface RelationExpr extends AstNode {
+    readonly $container: DynamicViewRulePredicate | ExcludePredicate | IncludePredicate;
+    readonly $type: 'RelationExpr';
+    isBidirectional: boolean;
+    source: ElementExpr;
+    target: ElementExpr;
+}
+
+export const RelationExpr = 'RelationExpr';
+
+export function isRelationExpr(item: unknown): item is RelationExpr {
+    return reflection.isInstance(item, RelationExpr);
+}
+
+export interface RelationshipKind extends AstNode {
+    readonly $container: SpecificationRelationshipKind;
+    readonly $type: 'RelationshipKind';
+    name: Id;
+}
+
+export const RelationshipKind = 'RelationshipKind';
+
+export function isRelationshipKind(item: unknown): item is RelationshipKind {
+    return reflection.isInstance(item, RelationshipKind);
+}
+
+export interface RelationStringProperty extends AstNode {
+    readonly $container: RelationBody;
+    readonly $type: 'RelationStringProperty';
+    key: 'title';
+    value: string;
+}
+
+export const RelationStringProperty = 'RelationStringProperty';
+
+export function isRelationStringProperty(item: unknown): item is RelationStringProperty {
+    return reflection.isInstance(item, RelationStringProperty);
+}
+
+export interface RelationStyleProperty extends AstNode {
+    readonly $container: RelationBody;
+    readonly $type: 'RelationStyleProperty';
+    key: 'style';
+    props: Array<RelationshipStyleProperty>;
+}
+
+export const RelationStyleProperty = 'RelationStyleProperty';
+
+export function isRelationStyleProperty(item: unknown): item is RelationStyleProperty {
+    return reflection.isInstance(item, RelationStyleProperty);
+}
+
+export interface ShapeProperty extends AstNode {
+    readonly $container: CustomElementExprBody | StyleProperties | ViewRuleStyle;
+    readonly $type: 'ShapeProperty';
+    key: 'shape';
+    value: ElementShape;
+}
+
+export const ShapeProperty = 'ShapeProperty';
+
+export function isShapeProperty(item: unknown): item is ShapeProperty {
+    return reflection.isInstance(item, ShapeProperty);
+}
+
+export interface SpecificationElementKind extends AstNode {
+    readonly $container: SpecificationRule;
+    readonly $type: 'SpecificationElementKind';
+    kind: ElementKind;
+    style?: StyleProperties;
+}
+
+export const SpecificationElementKind = 'SpecificationElementKind';
+
+export function isSpecificationElementKind(item: unknown): item is SpecificationElementKind {
+    return reflection.isInstance(item, SpecificationElementKind);
+}
+
+export interface SpecificationRelationshipKind extends AstNode {
+    readonly $container: SpecificationRule;
+    readonly $type: 'SpecificationRelationshipKind';
+    kind: RelationshipKind;
+    props: Array<RelationshipStyleProperty>;
+}
+
+export const SpecificationRelationshipKind = 'SpecificationRelationshipKind';
+
+export function isSpecificationRelationshipKind(item: unknown): item is SpecificationRelationshipKind {
+    return reflection.isInstance(item, SpecificationRelationshipKind);
+}
+
+export interface SpecificationRule extends AstNode {
+    readonly $container: LikeC4Grammar;
+    readonly $type: 'SpecificationRule';
+    elements: Array<SpecificationElementKind>;
+    name: 'specification';
+    relationships: Array<SpecificationRelationshipKind>;
+    tags: Array<SpecificationTag>;
+}
+
+export const SpecificationRule = 'SpecificationRule';
+
+export function isSpecificationRule(item: unknown): item is SpecificationRule {
+    return reflection.isInstance(item, SpecificationRule);
+}
+
+export interface SpecificationTag extends AstNode {
+    readonly $container: SpecificationRule;
+    readonly $type: 'SpecificationTag';
+    tag: Tag;
+}
+
+export const SpecificationTag = 'SpecificationTag';
+
+export function isSpecificationTag(item: unknown): item is SpecificationTag {
+    return reflection.isInstance(item, SpecificationTag);
+}
+
+export interface StyleProperties extends AstNode {
+    readonly $container: ElementBody | SpecificationElementKind;
+    readonly $type: 'StyleProperties';
+    key: 'style';
+    props: Array<StyleProperty>;
+}
+
+export const StyleProperties = 'StyleProperties';
+
+export function isStyleProperties(item: unknown): item is StyleProperties {
+    return reflection.isInstance(item, StyleProperties);
+}
+
+export interface Tag extends AstNode {
+    readonly $container: SpecificationTag;
+    readonly $type: 'Tag';
+    name: Id;
+}
+
+export const Tag = 'Tag';
+
+export function isTag(item: unknown): item is Tag {
+    return reflection.isInstance(item, Tag);
+}
+
+export interface Tags extends AstNode {
+    readonly $container: DynamicViewBody | ElementBody | ElementViewBody | ExplicitRelation | ImplicitRelation | RelationBody;
+    readonly $type: 'Tags';
+    value: Array<Reference<Tag>>;
+}
+
+export const Tags = 'Tags';
+
+export function isTags(item: unknown): item is Tags {
+    return reflection.isInstance(item, Tags);
+}
+
+export interface ViewRef extends AstNode {
+    readonly $container: NavigateToProperty;
+    readonly $type: 'ViewRef';
+    view: Reference<LikeC4View>;
+}
+
+export const ViewRef = 'ViewRef';
+
+export function isViewRef(item: unknown): item is ViewRef {
+    return reflection.isInstance(item, ViewRef);
+}
+
+export interface ViewRuleAutoLayout extends AstNode {
+    readonly $container: DynamicViewBody | ElementViewBody;
+    readonly $type: 'ViewRuleAutoLayout';
+    direction: ViewLayoutDirection;
+}
+
+export const ViewRuleAutoLayout = 'ViewRuleAutoLayout';
+
+export function isViewRuleAutoLayout(item: unknown): item is ViewRuleAutoLayout {
+    return reflection.isInstance(item, ViewRuleAutoLayout);
+}
+
+export interface ViewRuleStyle extends AstNode {
+    readonly $container: DynamicViewBody | ElementViewBody;
+    readonly $type: 'ViewRuleStyle';
+    styleprops: Array<StyleProperty>;
+    targets: Array<ElementExpr>;
+}
+
+export const ViewRuleStyle = 'ViewRuleStyle';
+
+export function isViewRuleStyle(item: unknown): item is ViewRuleStyle {
+    return reflection.isInstance(item, ViewRuleStyle);
+}
+
+export interface ViewStringProperty extends AstNode {
+    readonly $container: DynamicViewBody | ElementViewBody;
+    readonly $type: 'ViewStringProperty';
+    key: 'description' | 'title';
+    value: string;
+}
+
+export const ViewStringProperty = 'ViewStringProperty';
+
+export function isViewStringProperty(item: unknown): item is ViewStringProperty {
+    return reflection.isInstance(item, ViewStringProperty);
+}
+
+export interface WildcardExpr extends AstNode {
+    readonly $container: CustomElementExpr | DynamicViewRulePredicate | ExcludePredicate | IncludePredicate | IncomingExpr | OutgoingExpr | RelationExpr | ViewRuleStyle;
+    readonly $type: 'WildcardExpr';
+    isWildcard: boolean;
+}
+
+export const WildcardExpr = 'WildcardExpr';
+
+export function isWildcardExpr(item: unknown): item is WildcardExpr {
+    return reflection.isInstance(item, WildcardExpr);
+}
+
+export type LikeC4AstType = {
+    ArrowProperty: ArrowProperty
+    BorderProperty: BorderProperty
+    ColorProperty: ColorProperty
+    CustomElementExpr: CustomElementExpr
+    CustomElementExprBody: CustomElementExprBody
+    DescedantsExpr: DescedantsExpr
+    DynamicView: DynamicView
+    DynamicViewBody: DynamicViewBody
+    DynamicViewRule: DynamicViewRule
+    DynamicViewRulePredicate: DynamicViewRulePredicate
+    DynamicViewStep: DynamicViewStep
+    Element: Element
+    ElementBody: ElementBody
+    ElementExpr: ElementExpr
+    ElementKind: ElementKind
+    ElementKindExpr: ElementKindExpr
+    ElementProperty: ElementProperty
+    ElementRef: ElementRef
+    ElementStringProperty: ElementStringProperty
+    ElementTagExpr: ElementTagExpr
+    ElementView: ElementView
+    ElementViewBody: ElementViewBody
+    ElementViewRef: ElementViewRef
+    ExcludePredicate: ExcludePredicate
+    ExpandElementExpr: ExpandElementExpr
+    ExplicitRelation: ExplicitRelation
+    ExtendElement: ExtendElement
+    ExtendElementBody: ExtendElementBody
+    FqnElementRef: FqnElementRef
+    IconProperty: IconProperty
+    ImplicitRelation: ImplicitRelation
+    InOutExpr: InOutExpr
+    IncludePredicate: IncludePredicate
+    IncomingExpr: IncomingExpr
+    LikeC4Grammar: LikeC4Grammar
+    LikeC4View: LikeC4View
+    LineProperty: LineProperty
+    LinkProperty: LinkProperty
+    Model: Model
+    ModelViews: ModelViews
+    NavigateToProperty: NavigateToProperty
+    OpacityProperty: OpacityProperty
+    OutgoingExpr: OutgoingExpr
+    Relation: Relation
+    RelationBody: RelationBody
+    RelationExpr: RelationExpr
+    RelationProperty: RelationProperty
+    RelationStringProperty: RelationStringProperty
+    RelationStyleProperty: RelationStyleProperty
+    RelationshipKind: RelationshipKind
+    RelationshipStyleProperty: RelationshipStyleProperty
+    ShapeProperty: ShapeProperty
+    SpecificationElementKind: SpecificationElementKind
+    SpecificationRelationshipKind: SpecificationRelationshipKind
+    SpecificationRule: SpecificationRule
+    SpecificationTag: SpecificationTag
+    StyleProperties: StyleProperties
+    StyleProperty: StyleProperty
+    Tag: Tag
+    Tags: Tags
+    ViewProperty: ViewProperty
+    ViewRef: ViewRef
+    ViewRule: ViewRule
+    ViewRuleAutoLayout: ViewRuleAutoLayout
+    ViewRulePredicate: ViewRulePredicate
+    ViewRulePredicateExpr: ViewRulePredicateExpr
+    ViewRuleStyle: ViewRuleStyle
+    ViewStringProperty: ViewStringProperty
+    WildcardExpr: WildcardExpr
+}
+
+export class LikeC4AstReflection extends AbstractAstReflection {
+
+    getAllTypes(): string[] {
+        return ['ArrowProperty', 'BorderProperty', 'ColorProperty', 'CustomElementExpr', 'CustomElementExprBody', 'DescedantsExpr', 'DynamicView', 'DynamicViewBody', 'DynamicViewRule', 'DynamicViewRulePredicate', 'DynamicViewStep', 'Element', 'ElementBody', 'ElementExpr', 'ElementKind', 'ElementKindExpr', 'ElementProperty', 'ElementRef', 'ElementStringProperty', 'ElementTagExpr', 'ElementView', 'ElementViewBody', 'ElementViewRef', 'ExcludePredicate', 'ExpandElementExpr', 'ExplicitRelation', 'ExtendElement', 'ExtendElementBody', 'FqnElementRef', 'IconProperty', 'ImplicitRelation', 'InOutExpr', 'IncludePredicate', 'IncomingExpr', 'LikeC4Grammar', 'LikeC4View', 'LineProperty', 'LinkProperty', 'Model', 'ModelViews', 'NavigateToProperty', 'OpacityProperty', 'OutgoingExpr', 'Relation', 'RelationBody', 'RelationExpr', 'RelationProperty', 'RelationStringProperty', 'RelationStyleProperty', 'RelationshipKind', 'RelationshipStyleProperty', 'ShapeProperty', 'SpecificationElementKind', 'SpecificationRelationshipKind', 'SpecificationRule', 'SpecificationTag', 'StyleProperties', 'StyleProperty', 'Tag', 'Tags', 'ViewProperty', 'ViewRef', 'ViewRule', 'ViewRuleAutoLayout', 'ViewRulePredicate', 'ViewRulePredicateExpr', 'ViewRuleStyle', 'ViewStringProperty', 'WildcardExpr'];
+    }
+
+    protected override computeIsSubtype(subtype: string, supertype: string): boolean {
+        switch (subtype) {
+            case ArrowProperty:
+            case LineProperty: {
+                return this.isSubtype(RelationshipStyleProperty, supertype);
+            }
+            case BorderProperty:
+            case IconProperty:
+            case OpacityProperty:
+            case ShapeProperty: {
+                return this.isSubtype(StyleProperty, supertype);
+            }
+            case ColorProperty: {
+                return this.isSubtype(RelationshipStyleProperty, supertype) || this.isSubtype(StyleProperty, supertype);
+            }
+            case CustomElementExpr:
+            case ElementExpr:
+            case IncomingExpr:
+            case InOutExpr:
+            case OutgoingExpr:
+            case RelationExpr: {
+                return this.isSubtype(ViewRulePredicateExpr, supertype);
+            }
+            case DescedantsExpr:
+            case ElementKindExpr:
+            case ElementRef:
+            case ElementTagExpr:
+            case ExpandElementExpr:
+            case WildcardExpr: {
+                return this.isSubtype(ElementExpr, supertype);
+            }
+            case DynamicView:
+            case ElementView: {
+                return this.isSubtype(LikeC4View, supertype);
+            }
+            case DynamicViewRulePredicate: {
+                return this.isSubtype(DynamicViewRule, supertype);
+            }
+            case ElementStringProperty:
+            case StyleProperties: {
+                return this.isSubtype(ElementProperty, supertype);
+            }
+            case ExcludePredicate:
+            case IncludePredicate: {
+                return this.isSubtype(ViewRulePredicate, supertype);
+            }
+            case ExplicitRelation:
+            case ImplicitRelation: {
+                return this.isSubtype(Relation, supertype);
+            }
+            case LinkProperty: {
+                return this.isSubtype(ElementProperty, supertype) || this.isSubtype(RelationProperty, supertype) || this.isSubtype(ViewProperty, supertype);
+            }
+            case RelationStringProperty:
+            case RelationStyleProperty: {
+                return this.isSubtype(RelationProperty, supertype);
+            }
+            case ViewRuleAutoLayout:
+            case ViewRuleStyle: {
+                return this.isSubtype(DynamicViewRule, supertype) || this.isSubtype(ViewRule, supertype);
+            }
+            case ViewRulePredicate: {
+                return this.isSubtype(ViewRule, supertype);
+            }
+            case ViewStringProperty: {
+                return this.isSubtype(ViewProperty, supertype);
+            }
+            default: {
+                return false;
+            }
+        }
+    }
+
+    getReferenceType(refInfo: ReferenceInfo): string {
+        const referenceId = `${refInfo.container.$type}:${refInfo.property}`;
+        switch (referenceId) {
+            case 'DynamicViewStep:kind':
+            case 'ExplicitRelation:kind':
+            case 'ImplicitRelation:kind': {
+                return RelationshipKind;
+            }
+            case 'Element:kind':
+            case 'ElementKindExpr:kind': {
+                return ElementKind;
+            }
+            case 'ElementRef:el':
+            case 'FqnElementRef:el': {
+                return Element;
+            }
+            case 'ElementTagExpr:tag':
+            case 'Tags:value': {
+                return Tag;
+            }
+            case 'ElementViewRef:view': {
+                return ElementView;
+            }
+            case 'ViewRef:view': {
+                return LikeC4View;
+            }
+            default: {
+                throw new Error(`${referenceId} is not a valid reference id.`);
+            }
+        }
+    }
+
+    getTypeMetaData(type: string): TypeMetaData {
+        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: 'key' },
+                        { name: 'value' }
+                    ]
+                };
+            }
+            case 'CustomElementExpr': {
+                return {
+                    name: 'CustomElementExpr',
+                    properties: [
+                        { name: 'body' },
+                        { name: 'target' }
+                    ]
+                };
+            }
+            case 'CustomElementExprBody': {
+                return {
+                    name: 'CustomElementExprBody',
+                    properties: [
+                        { name: 'props', defaultValue: [] }
+                    ]
+                };
+            }
+            case 'DescedantsExpr': {
+                return {
+                    name: 'DescedantsExpr',
+                    properties: [
+                        { name: 'parent' }
+                    ]
+                };
+            }
+            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 'DynamicViewRulePredicate': {
+                return {
+                    name: 'DynamicViewRulePredicate',
+                    properties: [
+                        { name: 'expressions', defaultValue: [] }
+                    ]
+                };
+            }
+            case 'DynamicViewStep': {
+                return {
+                    name: 'DynamicViewStep',
+                    properties: [
+                        { 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' }
+                    ]
+                };
+            }
+            case 'ElementBody': {
+                return {
+                    name: 'ElementBody',
+                    properties: [
+                        { name: 'elements', defaultValue: [] },
+                        { name: 'props', defaultValue: [] },
+                        { name: 'tags' }
+                    ]
+                };
+            }
+            case 'ElementKind': {
+                return {
+                    name: 'ElementKind',
+                    properties: [
+                        { name: 'name' }
+                    ]
+                };
+            }
+            case 'ElementKindExpr': {
+                return {
+                    name: 'ElementKindExpr',
+                    properties: [
+                        { name: 'isEqual', defaultValue: false },
+                        { name: 'kind' }
+                    ]
+                };
+            }
+            case 'ElementRef': {
+                return {
+                    name: 'ElementRef',
+                    properties: [
+                        { name: 'el' },
+                        { name: 'parent' }
+                    ]
+                };
+            }
+            case 'ElementStringProperty': {
+                return {
+                    name: 'ElementStringProperty',
+                    properties: [
+                        { name: 'key' },
+                        { name: 'value' }
+                    ]
+                };
+            }
+            case 'ElementTagExpr': {
+                return {
+                    name: 'ElementTagExpr',
+                    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: 'expressions', defaultValue: [] }
+                    ]
+                };
+            }
+            case 'ExpandElementExpr': {
+                return {
+                    name: 'ExpandElementExpr',
+                    properties: [
+                        { name: 'parent' }
+                    ]
+                };
+            }
+            case 'ExplicitRelation': {
+                return {
+                    name: 'ExplicitRelation',
+                    properties: [
+                        { name: 'body' },
+                        { name: 'kind' },
+                        { name: 'source' },
+                        { name: 'tags' },
+                        { name: 'target' },
+                        { name: 'title' }
+                    ]
+                };
+            }
+            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 'IconProperty': {
+                return {
+                    name: 'IconProperty',
+                    properties: [
+                        { name: 'key' },
+                        { name: 'value' }
+                    ]
+                };
+            }
+            case 'ImplicitRelation': {
+                return {
+                    name: 'ImplicitRelation',
+                    properties: [
+                        { name: 'body' },
+                        { name: 'kind' },
+                        { name: 'tags' },
+                        { name: 'target' },
+                        { name: 'title' }
+                    ]
+                };
+            }
+            case 'IncludePredicate': {
+                return {
+                    name: 'IncludePredicate',
+                    properties: [
+                        { name: 'expressions', defaultValue: [] }
+                    ]
+                };
+            }
+            case 'IncomingExpr': {
+                return {
+                    name: 'IncomingExpr',
+                    properties: [
+                        { name: 'to' }
+                    ]
+                };
+            }
+            case 'InOutExpr': {
+                return {
+                    name: 'InOutExpr',
+                    properties: [
+                        { name: 'inout' }
+                    ]
+                };
+            }
+            case 'LikeC4Grammar': {
+                return {
+                    name: 'LikeC4Grammar',
+                    properties: [
+                        { name: 'models', defaultValue: [] },
+                        { name: 'specifications', defaultValue: [] },
+                        { name: 'views', defaultValue: [] }
+                    ]
+                };
+            }
+            case 'LineProperty': {
+                return {
+                    name: 'LineProperty',
+                    properties: [
+                        { name: 'key' },
+                        { name: 'value' }
+                    ]
+                };
+            }
+            case 'LinkProperty': {
+                return {
+                    name: 'LinkProperty',
+                    properties: [
+                        { name: 'key' },
+                        { name: 'value' }
+                    ]
+                };
+            }
+            case 'Model': {
+                return {
+                    name: 'Model',
+                    properties: [
+                        { name: 'elements', defaultValue: [] },
+                        { name: 'name' }
+                    ]
+                };
+            }
+            case 'ModelViews': {
+                return {
+                    name: 'ModelViews',
+                    properties: [
+                        { name: 'name' },
+                        { name: 'views', defaultValue: [] }
+                    ]
+                };
+            }
+            case 'NavigateToProperty': {
+                return {
+                    name: 'NavigateToProperty',
+                    properties: [
+                        { name: 'value' }
+                    ]
+                };
+            }
+            case 'OpacityProperty': {
+                return {
+                    name: 'OpacityProperty',
+                    properties: [
+                        { name: 'key' },
+                        { name: 'value' }
+                    ]
+                };
+            }
+            case 'OutgoingExpr': {
+                return {
+                    name: 'OutgoingExpr',
+                    properties: [
+                        { name: 'from' }
+                    ]
+                };
+            }
+            case 'RelationBody': {
+                return {
+                    name: 'RelationBody',
+                    properties: [
+                        { name: 'props', defaultValue: [] },
+                        { name: 'tags' }
+                    ]
+                };
+            }
+            case 'RelationExpr': {
+                return {
+                    name: 'RelationExpr',
+                    properties: [
+                        { name: 'isBidirectional', defaultValue: false },
+                        { name: 'source' },
+                        { name: 'target' }
+                    ]
+                };
+            }
+            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 'SpecificationElementKind': {
+                return {
+                    name: 'SpecificationElementKind',
+                    properties: [
+                        { name: 'kind' },
+                        { name: 'style' }
+                    ]
+                };
+            }
+            case 'SpecificationRelationshipKind': {
+                return {
+                    name: 'SpecificationRelationshipKind',
+                    properties: [
+                        { name: 'kind' },
+                        { name: 'props', defaultValue: [] }
+                    ]
+                };
+            }
+            case 'SpecificationRule': {
+                return {
+                    name: 'SpecificationRule',
+                    properties: [
+                        { name: 'elements', defaultValue: [] },
+                        { name: 'name' },
+                        { name: 'relationships', defaultValue: [] },
+                        { name: 'tags', defaultValue: [] }
+                    ]
+                };
+            }
+            case 'SpecificationTag': {
+                return {
+                    name: 'SpecificationTag',
+                    properties: [
+                        { name: 'tag' }
+                    ]
+                };
+            }
+            case 'StyleProperties': {
+                return {
+                    name: 'StyleProperties',
+                    properties: [
+                        { name: 'key' },
+                        { name: 'props', defaultValue: [] }
+                    ]
+                };
+            }
+            case 'Tag': {
+                return {
+                    name: 'Tag',
+                    properties: [
+                        { name: 'name' }
+                    ]
+                };
+            }
+            case 'Tags': {
+                return {
+                    name: 'Tags',
+                    properties: [
+                        { name: 'value', defaultValue: [] }
+                    ]
+                };
+            }
+            case 'ViewRef': {
+                return {
+                    name: 'ViewRef',
+                    properties: [
+                        { name: 'view' }
+                    ]
+                };
+            }
+            case 'ViewRuleAutoLayout': {
+                return {
+                    name: 'ViewRuleAutoLayout',
+                    properties: [
+                        { name: 'direction' }
+                    ]
+                };
+            }
+            case 'ViewRuleStyle': {
+                return {
+                    name: 'ViewRuleStyle',
+                    properties: [
+                        { name: 'styleprops', defaultValue: [] },
+                        { name: 'targets', defaultValue: [] }
+                    ]
+                };
+            }
+            case 'ViewStringProperty': {
+                return {
+                    name: 'ViewStringProperty',
+                    properties: [
+                        { name: 'key' },
+                        { name: 'value' }
+                    ]
+                };
+            }
+            case 'WildcardExpr': {
+                return {
+                    name: 'WildcardExpr',
+                    properties: [
+                        { name: 'isWildcard', defaultValue: false }
+                    ]
+                };
+            }
+            default: {
+                return {
+                    name: type,
+                    properties: []
+                };
+            }
+        }
+    }
+}
+
+export const reflection = new LikeC4AstReflection();