@likec4/language-server 0.44.1 → 0.46.0

package/contrib/likec4.monarch.ts

@@ -4,9 +4,9 @@ export default {
         'BottomTop','LeftRight','RightLeft','TopBottom','amber','autoLayout','blue','browser','color','crow','cylinder','dashed','description','diamond','dotted','element','exclude','extend','extends','gray','green','head','icon','include','indigo','it','kind','line','link','mobile','model','muted','none','normal','odiamond','of','onormal','open','person','primary','queue','rectangle','red','relationship','secondary','shape','sky','slate','solid','specification','storage','style','tag','tail','technology','this','title','vee','view','views'
     ],
     operators: [
-        '*','.*'
+        '*'
     ],
-    symbols: /\*|-\[|\.\*|\]->/,
+    symbols: /\*|-\[|\]->/,
 
     tokenizer: {
         initial: [
@@ -15,13 +15,14 @@ export default {
             { regex: /-/, action: {"token":"DASH"} },
             { regex: /[^\W\d_]/, action: { cases: { '@keywords': {"token":"keyword"}, '@default': {"token":"LETTER"} }} },
             { regex: /[0-9]/, action: {"token":"DIGIT"} },
-            { regex: /[\t\r\n\v\f]/, action: {"token":"NEWLINE"} },
+            { regex: /[\r?\n]/, action: {"token":"NEWLINE"} },
             { regex: /\w+:\/\/\S+/, action: {"token":"URI_WITH_SCHEMA"} },
             { regex: /\.{0,2}\/[^\/]\S+/, action: {"token":"URI_RELATIVE"} },
-            { regex: /->/, action: {"token":"RARROW"} },
-            { regex: /\b\.\b/, action: {"token":"Dot"} },
+            { regex: /->/, action: {"token":"RArrow"} },
+            { regex: /\b\.\*/, action: {"token":"DotWildcard"} },
+            { regex: /\b\./, action: {"token":"Dot"} },
             { regex: /!=/, action: {"token":"NotEqual"} },
-            { regex: /=/, action: {"token":"Eq"} },
+            { regex: /\={1,2}/, action: {"token":"Eq"} },
             { regex: /\{/, action: {"token":"OpenBlock"} },
             { regex: /\}/, action: {"token":"CloseBlock"} },
             { regex: /:/, action: {"token":"Colon"} },
@@ -34,10 +35,10 @@ export default {
             { regex: /@symbols/, action: { cases: { '@operators': {"token":"operator"}, '@default': {"token":""} }} },
         ],
         whitespace: [
+            { regex: /[^\S\r\n]/, action: {"token":"white"} },
             { regex: /\/\*/, action: {"token":"comment","next":"@comment"} },
             { regex: /\/\/[^\n\r]*/, action: {"token":"comment"} },
-            { regex: /(([\t\r\n\v\f])|([^\S\r\n]))+/, action: {"token":"white"} },
-            { regex: /[^\S\r\n]/, action: {"token":"white"} },
+            { regex: /(([\r?\n])|([^\S\r\n]))+/, action: {"token":"white"} },
         ],
         comment: [
             { regex: /[^/\*]+/, action: {"token":"comment"} },

package/dist/Rpc.js

@@ -1,7 +1,7 @@
 import { logError, logger } from "./logger.js";
 import pThrottle from "p-throttle";
 import { nonexhaustive } from "@likec4/core";
-import { URI } from "langium";
+import { URI, UriUtils } from "langium";
 import { isLikeC4LangiumDocument } from "./ast.js";
 import {
   buildDocuments,
@@ -9,17 +9,18 @@ import {
   fetchModel,
   fetchRawModel,
   locate,
-  onDidChangeModel,
-  rebuild
+  onDidChangeModel
 } from "./protocol.js";
 export class Rpc {
   constructor(services) {
     this.services = services;
   }
   init() {
-    const { ModelBuilder: modelBuilder, ModelLocator: modelLocator } = this.services.likec4;
+    const modelBuilder = this.services.likec4.ModelBuilder;
+    const modelLocator = this.services.likec4.ModelLocator;
     const connection = this.services.shared.lsp.Connection;
     if (!connection) {
+      logger.info(`[ServerRpc] no connection, not initializing`);
       return;
     }
     logger.info(`[ServerRpc] init`);
@@ -52,67 +53,20 @@ export class Rpc {
       }
       return Promise.resolve({ rawmodel });
     });
-    connection.onRequest(computeView, ({ viewId }) => {
-      return {
+    connection.onRequest(computeView, async ({ viewId }, _cancelToken) => {
+      return Promise.resolve({
         view: modelBuilder.computeView(viewId)
-      };
-    });
-    connection.onRequest(rebuild, async (cancelToken) => {
-      const changed = LangiumDocuments.all.map((d) => {
-        if (isLikeC4LangiumDocument(d)) {
-          delete d.c4Specification;
-          delete d.c4Elements;
-          delete d.c4Relations;
-          delete d.c4Views;
-          delete d.c4fqns;
-        }
-        return d.uri;
-      }).toArray();
-      logger.debug(`[ServerRpc] rebuild all documents: [
-        ${changed.map((d) => d.toString()).join("\n      ")}
-      ]`);
-      await DocumentBuilder.update(changed, [], cancelToken);
-      return {
-        docs: changed.map((d) => d.toString())
-      };
+      });
     });
     connection.onRequest(buildDocuments, async ({ docs }, cancelToken) => {
-      if (docs.length === 0) {
-        logger.debug(`[ServerRpc] received empty request to rebuild`);
-        return;
-      }
+      const changed = docs.map((d) => URI.parse(d));
+      const notChanged = (uri) => changed.every((c) => !UriUtils.equals(c, uri));
+      const deleted = LangiumDocuments.all.filter((d) => isLikeC4LangiumDocument(d) && notChanged(d.uri)).map((d) => d.uri).toArray();
       logger.debug(
-        `[ServerRpc] received request to buildDocuments:
-${docs.map((d) => "   - " + d).join("\n")}`
+        `[ServerRpc] received request to build:
+  changed (total ${changed.length}):${docs.map((d) => "\n    - " + d).join("")}
+  deleted (total ${deleted.length}):${deleted.map((d) => "\n    - " + d.toString()).join("\n")}`
       );
-      const deleted = LangiumDocuments.all.filter((d) => !docs.includes(d.uri.toString())).map((d) => d.uri).toArray();
-      const changed = [];
-      for (const d of docs) {
-        try {
-          const uri = URI.parse(d);
-          if (LangiumDocuments.hasDocument(uri)) {
-            changed.push(uri);
-          } else {
-            logger.warn(`[ServerRpc] LangiumDocuments does not have document: ${d}`);
-            LangiumDocuments.getOrCreateDocument(uri);
-          }
-        } catch (e) {
-          logError(e);
-        }
-      }
-      if (changed.length !== docs.length) {
-        const all = LangiumDocuments.all.map((d) => d.uri.toString()).toArray();
-        logger.warn(
-          `
-[ServerRpc] We have in LangiumDocuments: [
-  ${all.join("\n  ")}
-]
-We rebuild: [
-  ${changed.join("\n  ")}
-]
-  `.trim()
-        );
-      }
       await DocumentBuilder.update(changed, deleted, cancelToken);
     });
     connection.onRequest(locate, (params) => {

package/dist/ast.d.ts

@@ -1,12 +1,16 @@
 /// <reference types="react" />
 import { type c4 } from '@likec4/core';
 import type { LangiumDocument, MultiMap } from 'langium';
-import type { LikeC4Document } from './generated/ast';
+import type { LikeC4Grammar } from './generated/ast';
 import * as ast from './generated/ast';
 export { ast };
+declare const idattr: unique symbol;
 declare module './generated/ast' {
     interface Element {
-        fqn?: c4.Fqn;
+        [idattr]?: c4.Fqn;
+    }
+    interface ElementView {
+        [idattr]?: c4.ViewID;
     }
 }
 export interface ParsedAstSpecification {
@@ -75,19 +79,14 @@ export interface LikeC4DocumentProps {
     c4Views?: ParsedAstElementView[];
     c4fqns?: MultiMap<c4.Fqn, DocFqnIndexEntry>;
 }
-export interface LikeC4LangiumDocument extends LangiumDocument<LikeC4Document>, LikeC4DocumentProps {
+export interface LikeC4LangiumDocument extends LangiumDocument<LikeC4Grammar>, LikeC4DocumentProps {
 }
 export type ParsedLikeC4LangiumDocument = Omit<LikeC4LangiumDocument, keyof LikeC4DocumentProps> & Required<LikeC4DocumentProps>;
-export declare function cleanParsedModel(doc: LikeC4LangiumDocument): {
-    elements: ParsedAstElement[];
-    relations: ParsedAstRelation[];
-    views: ParsedAstElementView[];
-    specification: ParsedAstSpecification;
-};
+export declare function cleanParsedModel(doc: LikeC4LangiumDocument): ParsedLikeC4LangiumDocument;
 export declare function isLikeC4LangiumDocument(doc: LangiumDocument): doc is LikeC4LangiumDocument;
 export declare function isParsedLikeC4LangiumDocument(doc: LangiumDocument): doc is ParsedLikeC4LangiumDocument;
 export declare const isValidLikeC4LangiumDocument: (doc: LangiumDocument) => doc is ParsedLikeC4LangiumDocument;
-export declare function streamModel(doc: LikeC4LangiumDocument): Generator<ast.Element | ast.Relation, void, unknown>;
+export declare function streamModel(doc: LikeC4LangiumDocument): Generator<ast.Relation | ast.Element, void, unknown>;
 export declare function resolveRelationPoints(node: ast.Relation): {
     source: ast.Element;
     target: ast.Element;

package/dist/ast.js

@@ -11,11 +11,11 @@ import { DocumentState } from "langium";
 import { elementRef } from "./elementRef.js";
 import * as ast from "./generated/ast.js";
 import { LikeC4LanguageMetaData } from "./generated/module.js";
+import { isNil } from "remeda";
 export { ast };
 const idattr = Symbol.for("idattr");
 export const ElementViewOps = {
   writeId(node, id) {
-    ;
     node[idattr] = id;
     return node;
   },
@@ -25,13 +25,10 @@ export const ElementViewOps = {
 };
 export const ElementOps = {
   writeId(node, id) {
-    if (id === null) {
+    if (isNil(id)) {
       delete node[idattr];
-      delete node.fqn;
     } else {
-      ;
       node[idattr] = id;
-      node.fqn = id;
     }
     return node;
   },
@@ -40,19 +37,17 @@ export const ElementOps = {
   }
 };
 export function cleanParsedModel(doc) {
-  const specification = doc.c4Specification = {
-    kinds: {},
-    relationships: {}
-  };
-  const elements = doc.c4Elements = [];
-  const relations = doc.c4Relations = [];
-  const views = doc.c4Views = [];
-  return {
-    elements,
-    relations,
-    views,
-    specification
+  const props = {
+    c4Specification: {
+      kinds: {},
+      relationships: {}
+    },
+    c4Elements: [],
+    c4Relations: [],
+    c4Views: []
   };
+  Object.assign(doc, props);
+  return doc;
 }
 export function isLikeC4LangiumDocument(doc) {
   return doc.textDocument.languageId === LikeC4LanguageMetaData.languageId;
@@ -67,7 +62,7 @@ export const isValidLikeC4LangiumDocument = (doc) => {
   return state === DocumentState.Validated && parseResult.lexerErrors.length === 0 && (!diagnostics || diagnostics.every((d) => d.severity !== 1));
 };
 export function* streamModel(doc) {
-  const elements = doc.parseResult.value.model?.elements ?? [];
+  const elements = doc.parseResult.value.models.flatMap((m) => m.elements);
   const traverseStack = [...elements];
   const relations = [];
   let el;
@@ -102,7 +97,7 @@ export function resolveRelationPoints(node) {
   if (!target) {
     throw new RelationRefError("Invalid reference to target");
   }
-  if ("source" in node) {
+  if (ast.isExplicitRelation(node)) {
     const source = elementRef(node.source);
     if (!source) {
       throw new RelationRefError("Invalid reference to source");
@@ -112,9 +107,6 @@ export function resolveRelationPoints(node) {
       target
     };
   }
-  if (!ast.isElementBody(node.$container)) {
-    throw new RelationRefError("Invalid relation parent, expected Element");
-  }
   return {
     source: node.$container.$container,
     target

package/dist/elementRef.d.ts

@@ -1,19 +1,13 @@
 import { type c4 } from '@likec4/core';
-import { ast } from './ast';
-export declare function isElementRefHead(node: ast.ElementRef | ast.StrictElementRef): boolean;
+import type { ast } from './ast';
 /**
  * Returns referenced AST Element
  *
  */
-export declare function elementRef(node: ast.ElementRef | ast.StrictElementRef): ast.Element | undefined;
+export declare function elementRef(node: ast.ElementRef | ast.FqnElementRef): ast.Element | undefined;
 /**
- * Returns FQN of strictElementRef
- * a.b.c.d - for c node returns a.b
+ * Returns FQN of FqnElementRef
+ * a.b.c.d - for c node returns a.b.c
  */
-export declare function fqnElementRef(node: ast.StrictElementRef): c4.Fqn;
-/**
- * Returns parent FQN
- * a.b.c.d - for c node returns a.b
- */
-export declare function parentFqnElementRef(node: ast.StrictElementRef): c4.Fqn;
+export declare function getFqnElementRef(node: ast.FqnElementRef): c4.Fqn;
 //# sourceMappingURL=elementRef.d.ts.map

package/dist/elementRef.js

@@ -1,39 +1,12 @@
-import { invariant, nonexhaustive } from "@likec4/core";
-import { ast } from "./ast.js";
-export function isElementRefHead(node) {
-  if (ast.isElementRef(node)) {
-    return !ast.isElementRef(node.$container);
-  }
-  if (ast.isStrictElementRef(node)) {
-    return !ast.isStrictElementRef(node.$container);
-  }
-  nonexhaustive(node);
-}
 export function elementRef(node) {
-  invariant(isElementRefHead(node), "Expected head ElementRef");
-  while (node.next) {
-    node = node.next;
-  }
   return node.el.ref;
 }
-export function fqnElementRef(node) {
-  invariant(isElementRefHead(node), "Expected head StrictElementRef");
+export function getFqnElementRef(node) {
   const name = [node.el.$refText];
-  let child = node.next;
-  while (child) {
-    name.push(child.el.$refText);
-    child = child.next;
+  let parent = node.parent;
+  while (parent) {
+    name.unshift(parent.el.$refText);
+    parent = parent.parent;
   }
   return name.join(".");
 }
-export function parentFqnElementRef(node) {
-  invariant(!isElementRefHead(node), "Expected next StrictElementRef");
-  const path = [];
-  let parent = node.$container;
-  while (ast.isStrictElementRef(parent)) {
-    path.unshift(parent.el.$refText);
-    parent = parent.$container;
-  }
-  invariant(path.length > 0, "Expected non-empty parent path");
-  return path.join(".");
-}

package/dist/generated/ast.d.ts

@@ -1,5 +1,5 @@
 /******************************************************************************
- * This file was generated by langium-cli 2.0.1.
+ * This file was generated by langium-cli 2.1.0.
  * DO NOT EDIT MANUALLY!
  ******************************************************************************/
 import type { AstNode, Reference, ReferenceInfo, TypeMetaData } from 'langium';
@@ -10,7 +10,8 @@ export declare const LikeC4Terminals: {
     WS: RegExp;
     URI_WITH_SCHEMA: RegExp;
     URI_RELATIVE: RegExp;
-    RARROW: RegExp;
+    RArrow: RegExp;
+    DotWildcard: RegExp;
     Dot: RegExp;
     NotEqual: RegExp;
     Eq: RegExp;
@@ -19,7 +20,7 @@ export declare const LikeC4Terminals: {
     Colon: RegExp;
     SemiColon: RegExp;
     Comma: RegExp;
-    STRING: RegExp;
+    String: RegExp;
     TagID: RegExp;
     ID: RegExp;
 };
@@ -28,7 +29,7 @@ export declare function isArrowType(item: unknown): item is ArrowType;
 export type ElementExpression = ElementKindExpression | ElementRefExpression | ElementTagExpression | WildcardExpression;
 export declare const ElementExpression = "ElementExpression";
 export declare function isElementExpression(item: unknown): item is ElementExpression;
-export type ElementProperty = ElementStringProperty | StyleProperties;
+export type ElementProperty = ElementStringProperty | LinkProperty | StyleProperties;
 export declare const ElementProperty = "ElementProperty";
 export declare function isElementProperty(item: unknown): item is ElementProperty;
 export type ElementShape = 'browser' | 'cylinder' | 'mobile' | 'person' | 'queue' | 'rectangle' | 'storage';
@@ -40,8 +41,9 @@ export type LineOptions = 'dashed' | 'dotted' | 'solid';
 export declare function isLineOptions(item: unknown): item is LineOptions;
 export type Name = 'element' | 'model' | ArrowType | ElementShape | LineOptions | ThemeColor | string;
 export declare function isName(item: unknown): item is Name;
-export type RArrow = string;
-export declare function isRArrow(item: unknown): item is RArrow;
+export type Relation = ExplicitRelation | ImplicitRelation;
+export declare const Relation = "Relation";
+export declare function isRelation(item: unknown): item is Relation;
 export type ThemeColor = 'amber' | 'blue' | 'gray' | 'green' | 'indigo' | 'muted' | 'primary' | 'red' | 'secondary' | 'sky' | 'slate';
 export declare function isThemeColor(item: unknown): item is ThemeColor;
 export type Uri = string;
@@ -84,7 +86,7 @@ export interface ElementBody extends AstNode {
     readonly $container: Element;
     readonly $type: 'ElementBody';
     elements: Array<Element | Relation>;
-    props: Array<ElementProperty | LinkProperty>;
+    props: Array<ElementProperty>;
     tags?: Tags;
 }
 export declare const ElementBody = "ElementBody";
@@ -105,10 +107,10 @@ export interface ElementKindExpression extends AstNode {
 export declare const ElementKindExpression = "ElementKindExpression";
 export declare function isElementKindExpression(item: unknown): item is ElementKindExpression;
 export interface ElementRef extends AstNode {
-    readonly $container: ElementRef | ElementRefExpression | ElementView | Relation;
+    readonly $container: ElementRef | ElementRefExpression | ElementView | ExplicitRelation | ImplicitRelation;
     readonly $type: 'ElementRef';
     el: Reference<Element>;
-    next?: ElementRef;
+    parent?: ElementRef;
 }
 export declare const ElementRef = "ElementRef";
 export declare function isElementRef(item: unknown): item is ElementRef;
@@ -162,21 +164,41 @@ export interface ElementViewRef extends AstNode {
 }
 export declare const ElementViewRef = "ElementViewRef";
 export declare function isElementViewRef(item: unknown): item is ElementViewRef;
+export interface ExplicitRelation extends AstNode {
+    readonly $container: ElementBody | ExtendElementBody | Model;
+    readonly $type: 'ExplicitRelation';
+    kind?: Reference<RelationshipKind>;
+    props: Array<RelationStringProperty>;
+    source: ElementRef;
+    tags?: Tags;
+    target: ElementRef;
+    title?: string;
+}
+export declare const ExplicitRelation = "ExplicitRelation";
+export declare function isExplicitRelation(item: unknown): item is ExplicitRelation;
 export interface ExtendElement extends AstNode {
     readonly $container: Model;
     readonly $type: 'ExtendElement';
     body: ExtendElementBody;
-    element: StrictElementRef;
+    element: FqnElementRef;
 }
 export declare const ExtendElement = "ExtendElement";
 export declare function isExtendElement(item: unknown): item is ExtendElement;
 export interface ExtendElementBody extends AstNode {
     readonly $container: ExtendElement;
     readonly $type: 'ExtendElementBody';
-    elements: Array<Element | Relation>;
+    elements: Array<Element | ExplicitRelation>;
 }
 export declare const ExtendElementBody = "ExtendElementBody";
 export declare function isExtendElementBody(item: unknown): item is ExtendElementBody;
+export interface FqnElementRef extends AstNode {
+    readonly $container: ExtendElement | FqnElementRef;
+    readonly $type: 'FqnElementRef';
+    el: Reference<Element>;
+    parent?: FqnElementRef;
+}
+export declare const FqnElementRef = "FqnElementRef";
+export declare function isFqnElementRef(item: unknown): item is FqnElementRef;
 export interface IconProperty extends AstNode {
     readonly $container: StyleProperties | ViewRuleStyle;
     readonly $type: 'IconProperty';
@@ -185,10 +207,20 @@ export interface IconProperty extends AstNode {
 }
 export declare const IconProperty = "IconProperty";
 export declare function isIconProperty(item: unknown): item is IconProperty;
+export interface ImplicitRelation extends AstNode {
+    readonly $container: ElementBody;
+    readonly $type: 'ImplicitRelation';
+    kind?: Reference<RelationshipKind>;
+    props: Array<RelationStringProperty>;
+    tags?: Tags;
+    target: ElementRef;
+    title?: string;
+}
+export declare const ImplicitRelation = "ImplicitRelation";
+export declare function isImplicitRelation(item: unknown): item is ImplicitRelation;
 export interface IncomingExpression extends AstNode {
     readonly $container: InOutExpression | ViewRuleExpression;
     readonly $type: 'IncomingExpression';
-    arr: RArrow;
     target: ElementExpression;
 }
 export declare const IncomingExpression = "IncomingExpression";
@@ -196,19 +228,18 @@ export declare function isIncomingExpression(item: unknown): item is IncomingExp
 export interface InOutExpression extends AstNode {
     readonly $container: ViewRuleExpression;
     readonly $type: 'InOutExpression';
-    arr: RArrow;
     inout: IncomingExpression;
 }
 export declare const InOutExpression = "InOutExpression";
 export declare function isInOutExpression(item: unknown): item is InOutExpression;
-export interface LikeC4Document extends AstNode {
-    readonly $type: 'LikeC4Document';
-    model?: Model;
-    specification?: SpecificationRule;
-    views?: ModelViews;
-}
-export declare const LikeC4Document = "LikeC4Document";
-export declare function isLikeC4Document(item: unknown): item is LikeC4Document;
+export interface LikeC4Grammar extends AstNode {
+    readonly $type: 'LikeC4Grammar';
+    models: Array<Model>;
+    specifications: Array<SpecificationRule>;
+    views: Array<ModelViews>;
+}
+export declare const LikeC4Grammar = "LikeC4Grammar";
+export declare function isLikeC4Grammar(item: unknown): item is LikeC4Grammar;
 export interface LineProperty extends AstNode {
     readonly $container: SpecificationRelationshipKind;
     readonly $type: 'LineProperty';
@@ -226,15 +257,15 @@ export interface LinkProperty extends AstNode {
 export declare const LinkProperty = "LinkProperty";
 export declare function isLinkProperty(item: unknown): item is LinkProperty;
 export interface Model extends AstNode {
-    readonly $container: LikeC4Document;
+    readonly $container: LikeC4Grammar;
     readonly $type: 'Model';
-    elements: Array<Element | ExtendElement | Relation>;
+    elements: Array<Element | ExplicitRelation | ExtendElement>;
     name: 'model';
 }
 export declare const Model = "Model";
 export declare function isModel(item: unknown): item is Model;
 export interface ModelViews extends AstNode {
-    readonly $container: LikeC4Document;
+    readonly $container: LikeC4Grammar;
     readonly $type: 'ModelViews';
     name: 'views';
     views: Array<View>;
@@ -244,35 +275,13 @@ export declare function isModelViews(item: unknown): item is ModelViews;
 export interface OutgoingExpression extends AstNode {
     readonly $container: ViewRuleExpression;
     readonly $type: 'OutgoingExpression';
-    arr: RArrow;
     source: ElementExpression;
 }
 export declare const OutgoingExpression = "OutgoingExpression";
 export declare function isOutgoingExpression(item: unknown): item is OutgoingExpression;
-export interface Relation extends AstNode {
-    readonly $container: ElementBody | ExtendElementBody | Model;
-    readonly $type: 'Relation';
-    arr?: RArrow;
-    body?: RelationBody;
-    kind?: Reference<RelationshipKind>;
-    source?: ElementRef;
-    target: ElementRef;
-    title?: string;
-}
-export declare const Relation = "Relation";
-export declare function isRelation(item: unknown): item is Relation;
-export interface RelationBody extends AstNode {
-    readonly $container: Relation;
-    readonly $type: 'RelationBody';
-    props: Array<RelationStringProperty>;
-    tags?: Tags;
-}
-export declare const RelationBody = "RelationBody";
-export declare function isRelationBody(item: unknown): item is RelationBody;
 export interface RelationExpression extends AstNode {
     readonly $container: ViewRuleExpression;
     readonly $type: 'RelationExpression';
-    arr: RArrow;
     source: ElementExpression;
     target: ElementExpression;
 }
@@ -286,7 +295,7 @@ export interface RelationshipKind extends AstNode {
 export declare const RelationshipKind = "RelationshipKind";
 export declare function isRelationshipKind(item: unknown): item is RelationshipKind;
 export interface RelationStringProperty extends AstNode {
-    readonly $container: RelationBody;
+    readonly $container: ExplicitRelation | ImplicitRelation;
     readonly $type: 'RelationStringProperty';
     key: 'title';
     value: string;
@@ -318,7 +327,7 @@ export interface SpecificationRelationshipKind extends AstNode {
 export declare const SpecificationRelationshipKind = "SpecificationRelationshipKind";
 export declare function isSpecificationRelationshipKind(item: unknown): item is SpecificationRelationshipKind;
 export interface SpecificationRule extends AstNode {
-    readonly $container: LikeC4Document;
+    readonly $container: LikeC4Grammar;
     readonly $type: 'SpecificationRule';
     elements: Array<SpecificationElementKind>;
     name: 'specification';
@@ -335,14 +344,6 @@ export interface SpecificationTag extends AstNode {
 }
 export declare const SpecificationTag = "SpecificationTag";
 export declare function isSpecificationTag(item: unknown): item is SpecificationTag;
-export interface StrictElementRef extends AstNode {
-    readonly $container: ExtendElement | StrictElementRef;
-    readonly $type: 'StrictElementRef';
-    el: Reference<Element>;
-    next?: StrictElementRef;
-}
-export declare const StrictElementRef = "StrictElementRef";
-export declare function isStrictElementRef(item: unknown): item is StrictElementRef;
 export interface StyleProperties extends AstNode {
     readonly $container: ElementBody | SpecificationElementKind | SpecificationTag;
     readonly $type: 'StyleProperties';
@@ -359,7 +360,7 @@ export interface Tag extends AstNode {
 export declare const Tag = "Tag";
 export declare function isTag(item: unknown): item is Tag;
 export interface Tags extends AstNode {
-    readonly $container: ElementBody | ElementViewBody | RelationBody;
+    readonly $container: ElementBody | ElementViewBody | ExplicitRelation | ImplicitRelation;
     readonly $type: 'Tags';
     value: Array<Reference<Tag>>;
 }
@@ -419,20 +420,22 @@ export type LikeC4AstType = {
     ElementView: ElementView;
     ElementViewBody: ElementViewBody;
     ElementViewRef: ElementViewRef;
+    ExplicitRelation: ExplicitRelation;
     Expression: Expression;
     ExtendElement: ExtendElement;
     ExtendElementBody: ExtendElementBody;
+    FqnElementRef: FqnElementRef;
     IconProperty: IconProperty;
+    ImplicitRelation: ImplicitRelation;
     InOutExpression: InOutExpression;
     IncomingExpression: IncomingExpression;
-    LikeC4Document: LikeC4Document;
+    LikeC4Grammar: LikeC4Grammar;
     LineProperty: LineProperty;
     LinkProperty: LinkProperty;
     Model: Model;
     ModelViews: ModelViews;
     OutgoingExpression: OutgoingExpression;
     Relation: Relation;
-    RelationBody: RelationBody;
     RelationExpression: RelationExpression;
     RelationStringProperty: RelationStringProperty;
     RelationshipKind: RelationshipKind;
@@ -441,7 +444,6 @@ export type LikeC4AstType = {
     SpecificationRelationshipKind: SpecificationRelationshipKind;
     SpecificationRule: SpecificationRule;
     SpecificationTag: SpecificationTag;
-    StrictElementRef: StrictElementRef;
     StyleProperties: StyleProperties;
     Tag: Tag;
     Tags: Tags;