@likec4/core 1.17.1 → 1.19.0

package/src/model/LikeC4Model.ts

@@ -1,305 +1,397 @@
-import { isString, isTruthy, map, pipe, sort, values } from 'remeda'
-import type { Class } from 'type-fest'
-import { nonNullable } from '../errors'
+import DefaultMap from 'mnemonist/default-map'
+import { mapValues, pipe, sort, values } from 'remeda'
+import type { LiteralUnion } from 'type-fest'
+import { computeView, unsafeComputeView } from '../compute-view'
+import type { ComputeViewResult } from '../compute-view/compute-view'
+import { invariant, nonNullable } from '../errors'
+import type { ComputedView, DiagramView, IteratorLike, LikeC4View, ModelGlobals } from '../types'
+import type { Element } from '../types/element'
+import { type Tag as C4Tag } from '../types/element'
+import type { AnyParsedLikeC4Model, GenericLikeC4Model, LikeC4ModelDump } from '../types/model'
+import type { ModelRelation } from '../types/relation'
+import { compareNatural } from '../utils'
+import { ancestorsFqn, commonAncestor, parentFqn } from '../utils/fqn'
 import type {
-  Element as C4Element,
-  ElementKind as C4ElementKind,
-  ElementShape as C4ElementShape,
-  Tag as C4Tag
-} from '../types/element'
-import { DefaultElementShape, DefaultThemeColor } from '../types/element'
-import type {
-  ComputedLikeC4Model as C4ComputedLikeC4Model,
-  LayoutedLikeC4Model as C4LayoutedLikeC4Model
-} from '../types/model'
-import type { Relation as C4Relation } from '../types/relation'
-import type { Color as C4Color } from '../types/theme'
-import { compareNatural } from '../utils/compare-natural'
-import { ancestorsFqn, commonAncestor, parentFqn, sortNaturalByFqn } from '../utils/fqn'
-import { LikeC4DiagramModel } from './LikeC4DiagramModel'
-import { LikeC4ViewModel } from './LikeC4ViewModel'
-import type { ElementOrFqn, Fqn, IncomingFilter, OutgoingFilter, RelationID, ViewID } from './types'
-import { getId } from './types'
-
-type PickBySource<Source> = Source extends LikeC4Model.Layouted.SourceModel ? LikeC4Model.Layouted
-  : Source extends LikeC4Model.Computed.SourceModel ? LikeC4Model.Computed
-  : never
-
-export class LikeC4Model<M extends LikeC4Model.ViewModel = LikeC4Model.ViewModel> {
-  private _elements = new Map<Fqn, LikeC4Model.ElementModel<M>>()
+  DeployedInstanceModel,
+  DeploymentElementModel,
+  DeploymentNodeModel,
+  DeploymentRelationModel,
+} from './DeploymentElementModel'
+import { LikeC4DeploymentModel } from './DeploymentModel'
+import { type ElementsIterator, ElementModel } from './ElementModel'
+import { type RelationshipsIterator, RelationshipModel } from './RelationModel'
+import { type AnyAux, type Aux, type IncomingFilter, type OutgoingFilter, getId } from './types'
+import { EdgeModel } from './view/EdgeModel'
+import { LikeC4ViewModel } from './view/LikeC4ViewModel'
+import { NodeModel } from './view/NodeModel'
+
+export class LikeC4Model<M extends AnyAux = LikeC4Model.Any> {
+  /**
+   * Only available in compile tim
+   */
+  readonly Aux!: M
 
+  readonly #elements = new Map<M['Element'], ElementModel<M>>()
   // Parent element for given FQN
-  private _parents = new Map<Fqn, LikeC4Model.ElementModel<M>>()
-
+  readonly #parents = new Map<M['Element'], ElementModel<M>>()
   // Children elements for given FQN
-  private _children = new Map<Fqn, LikeC4Model.ElementModel<M>[]>()
+  readonly #children = new DefaultMap<M['Element'], Set<ElementModel<M>>>(() => new Set())
 
-  private _rootElements = new Set<LikeC4Model.ElementModel<M>>()
+  readonly #rootElements = new Set<ElementModel<M>>()
 
-  private _relations = new Map<RelationID, LikeC4Model.Relationship<M>>()
+  readonly #relations = new Map<M['RelationId'], RelationshipModel<M>>()
 
   // Incoming to an element or its descendants
-  private _incoming = new Map<Fqn, Set<LikeC4Model.Relationship<M>>>()
+  readonly #incoming = new DefaultMap<M['Element'], Set<RelationshipModel<M>>>(() => new Set())
 
   // Outgoing from an element or its descendants
-  private _outgoing = new Map<Fqn, Set<LikeC4Model.Relationship<M>>>()
+  readonly #outgoing = new DefaultMap<M['Element'], Set<RelationshipModel<M>>>(() => new Set())
 
   // Relationships inside the element, among descendants
-  private _internal = new Map<Fqn, Set<LikeC4Model.Relationship<M>>>()
+  readonly #internal = new DefaultMap<M['Element'], Set<RelationshipModel<M>>>(() => new Set())
+
+  readonly #views = new Map<M['ViewId'], LikeC4ViewModel<M>>()
+
+  readonly #allTags = new DefaultMap<C4Tag, Set<ElementModel<M> | RelationshipModel<M> | LikeC4ViewModel<M>>>(() =>
+    new Set()
+  )
+
+  public readonly deployment: LikeC4DeploymentModel<M>
+
+  /**
+   * Computes views from the parsed model
+   * Creates a new LikeC4Model instance from a parsed model.
+   *
+   * May throw an error if the model is invalid.
+   *
+   * @typeParam M - The type of the parsed LikeC4 model, must extend ParsedLikeC4Model
+   * @param parsed - The parsed LikeC4 model to compute from
+   * @returns A new LikeC4Model instance with computed relationships and structure
+   */
+  static compute<const M extends AnyParsedLikeC4Model>(parsed: M): LikeC4Model<Aux.FromParsed<M>> {
+    let { views, ...rest } = parsed as Omit<M, '__'>
+    const model = new LikeC4Model({ ...rest, views: {} })
+    return new LikeC4Model({
+      ...rest,
+      views: mapValues(views, view => unsafeComputeView(view as LikeC4View, model)),
+    } as any)
+  }
 
-  private _cacheAscendingSiblings = new Map<Fqn, LikeC4Model.ElementModel<M>[]>()
+  /**
+   * Creates a function that computes a view using the data from the model.
+   *
+   * @example
+   * const compute = LikeC4Model.makeCompute(parsedModel);
+   * const result = compute(viewSource);
+   */
+  static makeCompute<M extends AnyParsedLikeC4Model>(parsed: M): (viewsource: LikeC4View) => ComputeViewResult {
+    let { views, ...rest } = parsed as Omit<M, '__'>
+    const model = new LikeC4Model(structuredClone({ ...rest, views: {} }))
+    return (viewsource) => computeView(viewsource, model)
+  }
 
-  private _views: Map<Fqn, M>
+  /**
+   * Creates a new LikeC4Model instance from the provided model data.
+   *
+   * @typeParam M - Type parameter constrained to AnyLikeC4Model
+   * @param model - The model data to create a LikeC4Model from
+   * @returns A new LikeC4Model instance with the type derived from the input model
+   */
+  static create<const M extends GenericLikeC4Model>(model: M): LikeC4Model<Aux.FromModel<M>> {
+    return new LikeC4Model(model as any)
+  }
 
-  constructor(
-    public readonly type: LikeC4Model.ModelType<M>,
-    public readonly sourcemodel: LikeC4Model.SourceModel<M>,
-    elements: C4Element[],
-    relations: C4Relation[],
-    views: LikeC4Model.SourceModel<M>['views'],
-    ViewModelClass: Class<M>
+  /**
+   * Creates a new LikeC4Model instance from a model dump.
+   *
+   * @typeParam M - A constant type parameter extending LikeC4ModelDump
+   * @param dump - The model dump to create the instance from
+   * @returns A new LikeC4Model instance with types inferred from the dump
+   */
+  static fromDump<const M extends LikeC4ModelDump>(dump: M): LikeC4Model<Aux.FromDump<M>> {
+    return new LikeC4Model(dump as any)
+  }
+
+  private constructor(
+    public readonly $model: M['Model'],
   ) {
-    for (const el of elements) {
-      this.addElement(el)
+    for (const element of values($model.elements)) {
+      const el = this.addElement(element)
+      for (const tag of el.tags) {
+        this.#allTags.get(tag).add(el)
+      }
     }
-    for (const rel of relations) {
-      this.addRelation(rel)
+    for (const relation of values($model.relations)) {
+      const el = this.addRelation(relation)
+      for (const tag of el.tags) {
+        this.#allTags.get(tag).add(el)
+      }
     }
-    this._views = new Map(
-      pipe(
-        values(views),
-        sort((a, b) => compareNatural(a.title ?? 'untitled', b.title ?? 'untitled')),
-        map(view => [view.id, new ViewModelClass(view, this)] as [Fqn, M])
-      )
+    this.deployment = new LikeC4DeploymentModel(this, $model.deployments)
+    const views = pipe(
+      values($model.views),
+      sort((a, b) => compareNatural(a.title ?? 'untitled', b.title ?? 'untitled')),
     )
+    for (const view of views) {
+      const vm = new LikeC4ViewModel(this, Object.freeze(view as M['ViewType']))
+      this.#views.set(view.id, vm)
+      for (const tag of vm.tags) {
+        this.#allTags.get(tag).add(vm)
+      }
+    }
   }
 
-  /**
-   * Returns the root elements of the model.
-   */
-  public roots(): ReadonlyArray<LikeC4Model.ElementModel<M>> {
-    return [...this._rootElements]
+  get type(): 'computed' | 'layouted' {
+    return this.$model.__ ?? 'computed'
+  }
+
+  public element(el: M['ElementOrFqn']): ElementModel<M> {
+    if (el instanceof ElementModel) {
+      return el
+    }
+    const id = getId(el)
+    return nonNullable(this.findElement(id), `Element ${getId(el)} not found`)
+  }
+  public findElement(el: LiteralUnion<M['Element'], string>): ElementModel<M> | null {
+    return this.#elements.get(el) ?? null
   }
 
   /**
-   * Returns all elements in the model.
+   * Returns the root elements of the model.
    */
-  public elements(): ReadonlyArray<LikeC4Model.ElementModel<M>> {
-    return [...this._elements.values()]
+  public roots(): ElementsIterator<M> {
+    return this.#rootElements.values()
   }
 
   /**
-   * Returns a specific element by its FQN.
+   * Returns all elements in the model.
    */
-  public element(id: Fqn): LikeC4Model.ElementModel<M> {
-    return nonNullable(this._elements.get(id), `Element ${id} not found`)
+  public elements(): ElementsIterator<M> {
+    return this.#elements.values()
   }
 
   /**
    * Returns all relationships in the model.
    */
-  public relationships(): ReadonlyArray<LikeC4Model.Relationship<M>> {
-    return [...this._relations.values()]
+  public relationships(): RelationshipsIterator<M> {
+    return this.#relations.values()
   }
 
   /**
    * Returns a specific relationship by its ID.
+   * If the relationship is not found in the model, it will be searched in the deployment model.
+   * Search can be limited to the model or deployment model only.
    */
-  public relationship(id: RelationID) {
-    return nonNullable(this._relations.get(id), `Relation ${id} not found`)
+  public relationship(id: M['RelationId'], type: 'model'): RelationshipModel<M>
+  public relationship(id: M['RelationId'], type: 'deployment'): DeploymentRelationModel<M>
+  public relationship(
+    id: M['RelationId'],
+    type?: 'model' | 'deployment',
+  ): RelationshipModel<M> | DeploymentRelationModel<M>
+  public relationship(
+    id: M['RelationId'],
+    type: 'model' | 'deployment' | undefined,
+  ): RelationshipModel<M> | DeploymentRelationModel<M> {
+    if (type === 'deployment') {
+      return this.deployment.relationship(id)
+    }
+    let model = this.#relations.get(id) ?? null
+    if (model || type === 'model') {
+      return nonNullable(model, `Model relation ${id} not found`)
+    }
+    // We did not find the relation in the model, let's search in the deployment
+    return nonNullable(this.deployment.findRelationship(id), `No model/deployment relation ${id} not found`)
+  }
+
+  public findRelationship(id: LiteralUnion<M['RelationId'], string>, type: 'model'): RelationshipModel<M> | null
+  public findRelationship(
+    id: LiteralUnion<M['RelationId'], string>,
+    type: 'deployment',
+  ): DeploymentRelationModel<M> | null
+  public findRelationship(
+    id: LiteralUnion<M['RelationId'], string>,
+    type?: 'model' | 'deployment',
+  ): RelationshipModel<M> | DeploymentRelationModel<M> | null
+  public findRelationship(
+    id: LiteralUnion<M['RelationId'], string>,
+    type: 'model' | 'deployment' | undefined,
+  ): RelationshipModel<M> | DeploymentRelationModel<M> | null {
+    if (type === 'deployment') {
+      return this.deployment.findRelationship(id)
+    }
+    let model = this.#relations.get(id as M['RelationId']) ?? null
+    if (model || type === 'model') {
+      return model
+    }
+    return this.deployment.findRelationship(id)
   }
 
   /**
    * Returns all views in the model.
    */
-  public views(): ReadonlyArray<M> {
-    return [...this._views.values()]
+  public views(): IteratorLike<LikeC4ViewModel<M>> {
+    return this.#views.values()
   }
 
   /**
    * Returns a specific view by its ID.
    */
-  public view(viewId: ViewID): M {
-    return nonNullable(this._views.get(viewId), `View ${viewId} not found`)
+  public view(viewId: M['View']): LikeC4ViewModel<M> {
+    return nonNullable(this.#views.get(viewId as any), `View ${viewId} not found`)
+  }
+  public findView(viewId: M['View']): LikeC4ViewModel<M> {
+    return nonNullable(this.#views.get(viewId as M['ViewId']), `View ${viewId} not found`)
   }
 
   /**
    * Returns the parent element of given element.
    * @see ancestors
    */
-  public parent(element: ElementOrFqn): LikeC4Model.ElementModel<M> | null {
+  public parent(element: M['ElementOrFqn']): ElementModel<M> | null {
     const id = getId(element)
-    return this._parents.get(id) || null
+    return this.#parents.get(id) || null
   }
 
   /**
    * Get all children of the element (only direct children),
    * @see descendants
    */
-  public children(element: ElementOrFqn): ReadonlyArray<LikeC4Model.ElementModel<M>> {
-    const id = getId(element)
-    return this._childrenOf(id)
+  public children(element: M['ElementOrFqn']): ReadonlySet<ElementModel<M>> {
+    const id = getId(element) as M['Fqn']
+    return this.#children.get(id)
   }
 
   /**
    * Get all sibling (i.e. same parent)
    */
-  public siblings(element: ElementOrFqn): ReadonlyArray<LikeC4Model.ElementModel<M>> {
-    const id = getId(element)
-    const parent = this._parents.get(id)
-    const siblings = parent ? this._childrenOf(parent.id) : this.roots()
-    return siblings.filter(e => e.id !== id)
+  public *siblings(element: M['ElementOrFqn']): ElementsIterator<M> {
+    const id = getId(element) as M['Fqn']
+    const parent = this.#parents.get(id)
+    const siblings = parent ? this.#children.get(parent.id).values() : this.roots()
+    for (const sibling of siblings) {
+      if (sibling.id !== id) {
+        yield sibling
+      }
+    }
+    return
   }
 
   /**
    * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
    * (from closest to root)
    */
-  public ancestors(element: ElementOrFqn): ReadonlyArray<LikeC4Model.ElementModel<M>> {
-    let id = isString(element) ? element : element.id
-    const result = [] as LikeC4Model.ElementModel<M>[]
+  public *ancestors(element: M['ElementOrFqn']): ElementsIterator<M> {
+    let id = getId(element) as M['Fqn']
     let parent
-    while (parent = this._parents.get(id)) {
-      result.push(parent)
+    while (parent = this.#parents.get(id)) {
+      yield parent
       id = parent.id
     }
-    return result
+    return
   }
 
   /**
    * Get all descendant elements (i.e. children, children’s children, etc.)
    */
-  public descendants(element: ElementOrFqn): ReadonlyArray<LikeC4Model.ElementModel<M>> {
-    const id = getId(element)
-    const children = this._childrenOf(id)
-    return children.flatMap(c => [c, ...this.descendants(c.id)])
+  public *descendants(element: M['ElementOrFqn']): ElementsIterator<M> {
+    for (const child of this.children(element)) {
+      yield child
+      yield* this.descendants(child.id)
+    }
+    return
   }
 
   /**
    * Incoming relationships to the element and its descendants
    * @see incomers
    */
-  public incoming(
-    element: ElementOrFqn,
-    filter: IncomingFilter = 'all'
-  ): ReadonlyArray<LikeC4Model.Relationship<M>> {
+  public *incoming(
+    element: M['ElementOrFqn'],
+    filter: IncomingFilter = 'all',
+  ): RelationshipsIterator<M> {
     const id = getId(element)
-    const incoming = Array.from(this._incomingTo(id))
-    if (filter === 'all' || incoming.length === 0) {
-      return incoming
-    }
-
-    return incoming.filter(rel => {
-      if (filter === 'direct') {
-        return rel.target.id === id
+    for (const rel of this.#incoming.get(id)) {
+      switch (true) {
+        case filter === 'all':
+        case filter === 'direct' && rel.target.id === id:
+        case filter === 'to-descendants' && rel.target.id !== id:
+          yield rel
+          break
       }
-      return rel.target.id !== id
-    })
-  }
-
-  /**
-   * Source elements of incoming relationships
-   */
-  public incomers(
-    element: ElementOrFqn,
-    filter: IncomingFilter = 'all'
-  ): ReadonlyArray<LikeC4Model.ElementModel<M>> {
-    return [...new Set(this.incoming(element, filter).map(r => r.source))]
+    }
+    return
   }
 
   /**
    * Outgoing relationships from the element and its descendants
    * @see outgoers
    */
-  public outgoing(
-    element: ElementOrFqn,
-    filter: OutgoingFilter = 'all'
-  ): ReadonlyArray<LikeC4Model.Relationship<M>> {
+  public *outgoing(
+    element: M['ElementOrFqn'],
+    filter: OutgoingFilter = 'all',
+  ): RelationshipsIterator<M> {
     const id = getId(element)
-    const outgoing = Array.from(this._outgoingFrom(id))
-    if (filter === 'all' || outgoing.length === 0) {
-      return outgoing
-    }
-    return outgoing.filter(rel => {
-      if (filter === 'direct') {
-        return rel.source.id === id
+    for (const rel of this.#outgoing.get(id)) {
+      switch (true) {
+        case filter === 'all':
+        case filter === 'direct' && rel.source.id === id:
+        case filter === 'from-descendants' && rel.source.id !== id:
+          yield rel
+          break
       }
-      return rel.source.id !== id
-    })
-  }
-
-  /**
-   * Target elements of outgoing relationships
-   */
-  public outgoers(
-    element: ElementOrFqn,
-    filter: OutgoingFilter = 'all'
-  ): ReadonlyArray<LikeC4Model.ElementModel<M>> {
-    return [...new Set(this.outgoing(element, filter).map(r => r.target))]
-  }
-
-  /**
-   * Relationships inside the element, among descendants
-   */
-  public internal(element: ElementOrFqn): ReadonlyArray<LikeC4Model.Relationship<M>> {
-    const id = getId(element)
-    return Array.from(this._internalOf(id))
-  }
-
-  /**
-   * Resolve siblings of the element and siblings of ancestors
-   *  (from closest to root)
-   */
-  public ascendingSiblings(element: ElementOrFqn): ReadonlyArray<LikeC4Model.ElementModel<M>> {
-    const id = getId(element)
-    let siblings = this._cacheAscendingSiblings.get(id)
-    if (!siblings) {
-      siblings = [
-        ...this.siblings(id),
-        ...this.ancestors(id).flatMap(a => this.siblings(a.id))
-      ]
-      this._cacheAscendingSiblings.set(id, siblings)
     }
-    return siblings.slice()
+    return
   }
 
-  /**
-   * Resolve all views that contain the element
-   */
-  public viewsWithElement(element: ElementOrFqn): ReadonlyArray<M> {
-    const id = getId(element)
-    return [...this._views.values()].filter(v => v.hasElement(id))
+  public globals(): ModelGlobals {
+    return {
+      predicates: {
+        ...this.$model.globals?.predicates,
+      },
+      dynamicPredicates: {
+        ...this.$model.globals?.dynamicPredicates,
+      },
+      styles: {
+        ...this.$model.globals?.styles,
+      },
+    }
   }
 
-  private addElement(parsed: C4Element) {
-    if (this._elements.has(parsed.id)) {
-      throw new Error(`Element ${parsed.id} already exists`)
+  private addElement(element: Element) {
+    if (this.#elements.has(element.id)) {
+      throw new Error(`Element ${element.id} already exists`)
     }
-    const el = new LikeC4Model.ElementModel(parsed, this)
-    this._elements.set(el.id, el)
+    const el = new ElementModel(this, Object.freeze(structuredClone(element)))
+    this.#elements.set(el.id, el)
     const parentId = parentFqn(el.id)
     if (parentId) {
-      this._parents.set(el.id, this.element(parentId))
-      this._childrenOf(parentId).push(el)
+      invariant(this.#elements.has(parentId), `Parent ${parentId} of ${el.id} not found`)
+      this.#parents.set(el.id, this.element(parentId))
+      this.#children.get(parentId).add(el)
     } else {
-      this._rootElements.add(el)
+      this.#rootElements.add(el)
     }
+    return el
   }
 
-  private addRelation(relation: C4Relation) {
-    if (this._relations.has(relation.id)) {
+  private addRelation(relation: ModelRelation) {
+    if (this.#relations.has(relation.id)) {
       throw new Error(`Relation ${relation.id} already exists`)
     }
-    const rel = new LikeC4Model.Relationship(relation, this)
-    this._relations.set(rel.id, rel)
-    this._incomingTo(relation.target).add(rel)
-    this._outgoingFrom(relation.source).add(rel)
+    const rel = new RelationshipModel(
+      this,
+      Object.freeze(structuredClone(relation)),
+    )
+    const { source, target } = rel
+    this.#relations.set(rel.id, rel)
+    this.#incoming.get(target.id).add(rel)
+    this.#outgoing.get(source.id).add(rel)
 
-    const relParent = commonAncestor(relation.source, relation.target)
+    const relParent = commonAncestor(source.id, target.id)
     // Process internal relationships
     if (relParent) {
       for (const ancestor of [relParent, ...ancestorsFqn(relParent)]) {
-        this._internalOf(ancestor).add(rel)
+        this.#internal.get(ancestor).add(rel)
       }
     }
     // Process source hierarchy
@@ -307,285 +399,72 @@ export class LikeC4Model<M extends LikeC4Model.ViewModel = LikeC4Model.ViewModel
       if (sourceAncestor === relParent) {
         break
       }
-      this._outgoingFrom(sourceAncestor).add(rel)
+      this.#outgoing.get(sourceAncestor).add(rel)
     }
     // Process target hierarchy
     for (const targetAncestor of ancestorsFqn(relation.target)) {
       if (targetAncestor === relParent) {
         break
       }
-      this._incomingTo(targetAncestor).add(rel)
-    }
-  }
-
-  private _childrenOf(id: Fqn) {
-    let children = this._children.get(id)
-    if (!children) {
-      children = []
-      this._children.set(id, children)
+      this.#incoming.get(targetAncestor).add(rel)
     }
-    return children
-  }
-
-  private _incomingTo(id: Fqn) {
-    let incoming = this._incoming.get(id)
-    if (!incoming) {
-      incoming = new Set()
-      this._incoming.set(id, incoming)
-    }
-    return incoming
-  }
-
-  private _outgoingFrom(id: Fqn) {
-    let outgoing = this._outgoing.get(id)
-    if (!outgoing) {
-      outgoing = new Set()
-      this._outgoing.set(id, outgoing)
-    }
-    return outgoing
-  }
-
-  private _internalOf(id: Fqn) {
-    let internal = this._internal.get(id)
-    if (!internal) {
-      internal = new Set()
-      this._internal.set(id, internal)
-    }
-    return internal
+    return rel
   }
 }
 
 export namespace LikeC4Model {
-  export function create(source: LikeC4Model.SourceModel): PickBySource<typeof source> {
-    // static create<MM extends LikeC4Model>(source: MM['s']): PickBySource<typeof source> {
-    if (source.__ === 'layouted') {
-      return LikeC4Model.layouted(source)
-    }
-    return LikeC4Model.computed(source)
-  }
-
-  export function computed(source: C4ComputedLikeC4Model): LikeC4Model<LikeC4ViewModel> {
-    return new LikeC4Model(
-      'computed',
-      source,
-      values(source.elements),
-      values(source.relations),
-      source.views,
-      LikeC4ViewModel
-    )
-  }
-
-  export function layouted(source: C4LayoutedLikeC4Model): LikeC4Model<LikeC4DiagramModel> {
-    return new LikeC4Model(
-      'layouted',
-      source,
-      values(source.elements),
-      values(source.relations),
-      source.views,
-      LikeC4DiagramModel
-    )
-  }
-
-  export function isModel(model: any): model is LikeC4Model {
-    return model instanceof LikeC4Model
-  }
-
-  export type SourceModel<M extends ViewModel = ViewModel> = M extends LikeC4DiagramModel ? C4LayoutedLikeC4Model
-    : C4ComputedLikeC4Model
-
-  export type ViewModel = LikeC4ViewModel | LikeC4DiagramModel
-  export namespace ViewModel {
-    export type ElementModel = LikeC4ViewModel.Element | LikeC4DiagramModel.Element
-    export type Relationship = LikeC4Model.Relationship<ViewModel>
-
-    export function isLayouted(model: ViewModel): model is LikeC4DiagramModel {
-      return model instanceof LikeC4DiagramModel
-    }
-  }
-
-  export type Computed = LikeC4Model<LikeC4ViewModel>
-  export namespace Computed {
-    export type ViewModel = LikeC4ViewModel
-    export type SourceModel = LikeC4Model.SourceModel<ViewModel>
-  }
-
-  export type Layouted = LikeC4Model<LikeC4DiagramModel>
-  export namespace Layouted {
-    export type ViewModel = LikeC4DiagramModel
-    export type SourceModel = LikeC4Model.SourceModel<ViewModel>
-  }
-
-  export type ModelType<M extends ViewModel = ViewModel> = M extends LikeC4DiagramModel ? 'layouted'
-    : M extends LikeC4ViewModel ? 'computed'
-    : never
-
-  export function isLayouted(model: LikeC4Model): model is Layouted {
-    return model.type === 'layouted'
-  }
-
-  export class Relationship<M extends ViewModel = ViewModel> {
-    constructor(
-      public readonly relationship: C4Relation,
-      private readonly model: LikeC4Model<M>
-    ) {
-    }
-
-    get id() {
-      return this.relationship.id
-    }
-
-    get title() {
-      return this.relationship.title
-    }
-
-    get kind() {
-      return this.relationship.kind ?? null
-    }
-
-    get tags(): C4Tag[] {
-      return this.relationship.tags ?? []
-    }
-
-    get source() {
-      return this.model.element(this.relationship.source)
-    }
-
-    get target() {
-      return this.model.element(this.relationship.target)
-    }
-
-    public metadata(key: string): string | undefined
-    public metadata(key: string, defaultValue: string): string
-    public metadata(key: string, defaultValue?: string): string | undefined {
-      return this.relationship.metadata?.[key] ?? defaultValue
-    }
-
-    public hasMetadata(key: string): boolean {
-      return isTruthy(this.relationship.metadata?.[key])
-    }
-  }
-
-  // Class renamed to ElementModel, otherwise generated DTS will be incorrect
-  export class ElementModel<M extends ViewModel = ViewModel> {
-    constructor(
-      public readonly element: C4Element,
-      private readonly model: LikeC4Model<M>
-    ) {
-    }
-
-    get id() {
-      return this.element.id
-    }
-
-    get title() {
-      return this.element.title
-    }
-
-    get kind(): C4ElementKind {
-      return this.element.kind
-    }
-
-    get isRoot(): boolean {
-      return parentFqn(this.element.id) === null
-    }
-
-    get hasNested(): boolean {
-      return this.model.children(this).length > 0
-    }
-
-    get shape(): C4ElementShape {
-      return this.element.shape ?? DefaultElementShape
-    }
-
-    get color(): C4Color {
-      return this.element.color ?? DefaultThemeColor
-    }
-
-    get tags(): C4Tag[] {
-      return this.element.tags ?? []
-    }
-
-    public parent(): ElementModel<M> | null {
-      return this.model.parent(this)
-    }
-
-    public metadata(key: string): string | undefined
-    public metadata(key: string, defaultValue: string): string
-    public metadata(key: string, defaultValue?: string): string | undefined {
-      return this.element.metadata?.[key] ?? defaultValue
-    }
-
-    public hasMetadata(key: string): boolean {
-      return isTruthy(this.element.metadata?.[key])
-    }
-
-    public ancestors() {
-      return this.model.ancestors(this)
-    }
-
-    public siblings() {
-      return this.model.siblings(this)
-    }
-
-    public descendants() {
-      return this.model.descendants(this)
-    }
-
-    public children() {
-      return this.model.children(this)
-    }
-
-    /**
-     * First 'view of' current element
-     */
-    public viewOf() {
-      return this.model.views().find(v => v.viewOf?.id === this.id) ?? null
-    }
-
-    /**
-     * All views 'view of' current element
-     */
-    public viewsOf() {
-      return this.model.views().filter(v => v.viewOf?.id === this.id)
-    }
-
-    /**
-     * Views that contain this element
-     */
-    public views() {
-      return this.model.viewsWithElement(this)
-    }
-
-    public incoming(filter?: IncomingFilter) {
-      return this.model.incoming(this, filter)
-    }
-
-    public incomers(filter?: IncomingFilter) {
-      return this.model.incomers(this, filter)
-    }
-
-    public outgoing(filter?: OutgoingFilter) {
-      return this.model.outgoing(this, filter)
-    }
-
-    public outgoers(filter?: OutgoingFilter) {
-      return this.model.outgoers(this, filter)
-    }
-
-    public internal() {
-      return this.model.internal(this)
-    }
-
-    /**
-     * Resolve siblings of the element and siblings of ancestors
-     *  (from closest to root)
-     */
-    public ascendingSiblings() {
-      return this.model.ascendingSiblings(this)
-    }
-
-    // public *descendants(): IterableIterator<LikeC4Element> {
-    //   return
-    // }
-  }
+  export type Any = Aux<
+    string,
+    string,
+    string,
+    ComputedView | DiagramView
+  >
+
+  export type Element<M extends AnyAux = Any> = ElementModel<M>
+
+  // Relationship in logical model
+  export type Relation<M extends AnyAux = Any> = RelationshipModel<M>
+
+  // Relationship in logical or deployment model
+  export type AnyRelation<M extends AnyAux = Any> = RelationshipModel<M> | DeploymentRelationModel<M>
+
+  export type View<
+    M extends AnyAux = Any,
+    V extends ComputedView | DiagramView = M['ViewType'],
+  > = LikeC4ViewModel<M, V>
+
+  export type Node<
+    M extends AnyAux = Any,
+    V extends ComputedView | DiagramView = M['ViewType'],
+  > = NodeModel<M, V>
+
+  export type Edge<
+    M extends AnyAux = Any,
+    V extends ComputedView | DiagramView = M['ViewType'],
+  > = EdgeModel<M, V>
+
+  export type DeploymentModel<M extends AnyAux = AnyAux> = LikeC4DeploymentModel<M>
+
+  export type Deployment<M extends AnyAux = AnyAux> = DeploymentElementModel<M>
+  export type DeploymentNode<M extends AnyAux = AnyAux> = DeploymentNodeModel<M>
+  export type DeployedInstance<M extends AnyAux = AnyAux> = DeployedInstanceModel<M>
+
+  export type Typed<
+    Elements extends string = string,
+    Deployments extends string = string,
+    Views extends string = string,
+    ViewType = DiagramView<Views> | ComputedView<Views>,
+  > = Aux<Elements, Deployments, Views, ViewType>
+
+  export type Computed<
+    Elements extends string = string,
+    Deployments extends string = string,
+    Views extends string = string,
+  > = LikeC4Model<Typed<Elements, Deployments, Views, ComputedView<Views>>>
+
+  export type Layouted<
+    Elements extends string = string,
+    Deployments extends string = string,
+    Views extends string = string,
+  > = LikeC4Model<Typed<Elements, Deployments, Views, DiagramView<Views>>>
 }