@likec4/core 1.25.1 → 1.26.1

package/dist/utils/index.mjs

@@ -1,9 +1,217 @@
-import { T as getDefaultExportFromCjs, V as requireIterator, U as requireForeach, d as t, Y as n, h as commonAncestor, k as compareFqnHierarchically } from '../shared/core.DQMSDiu8.mjs';
-export { D as DefaultMap, S as Stack, g as ancestorsFqn, e as commonHead, j as compareByFqnHierarchically, f as compareNatural, I as difference, J as equalsSet, x as getOrCreate, a as hasAtLeast, o as hierarchyDistance, q as hierarchyLevel, A as ifilter, i as ifind, B as iflat, C as imap, K as intersection, r as isAncestor, s as isDescendantOf, E as isIterable, y as isNonEmptyArray, c as isSameHierarchy, z as isString, F as isome, G as iunique, n as nameFromFqn, O as objectHash, p as parentFqn, u as sortByFqnHierarchically, v as sortNaturalByFqn, w as sortParentsFirst, N as stringHash, L as symmetricDifference, H as toArray, t as toSet, M as union } from '../shared/core.DQMSDiu8.mjs';
-import { i as invariant } from '../shared/core.Btj1m6H6.mjs';
+import { U as requireForeach, T as getDefaultExportFromCjs, V as requireIterator, d as t, Y as n, h as commonAncestor, k as compareFqnHierarchically } from '../shared/core.BqezHsjR.mjs';
+export { D as DefaultMap, S as Stack, g as ancestorsFqn, e as commonHead, j as compareByFqnHierarchically, f as compareNatural, I as difference, J as equalsSet, x as getOrCreate, a as hasAtLeast, o as hierarchyDistance, q as hierarchyLevel, A as ifilter, i as ifind, B as iflat, C as imap, K as intersection, r as isAncestor, s as isDescendantOf, E as isIterable, y as isNonEmptyArray, c as isSameHierarchy, z as isString, F as isome, G as iunique, n as nameFromFqn, O as objectHash, p as parentFqn, u as sortByFqnHierarchically, v as sortNaturalByFqn, w as sortParentsFirst, N as stringHash, L as symmetricDifference, H as toArray, t as toSet, M as union } from '../shared/core.BqezHsjR.mjs';
+import { i as invariant } from '../shared/core.DRxv3HIl.mjs';
 
 function o(r,n){let e=Math.ceil(r),t=Math.floor(n);if(t<e)throw new RangeError(`randomInteger: The range [${r.toString()},${n.toString()}] contains no integer`);return Math.floor(Math.random()*(t-e+1)+e)}
 
+/**
+ * Mnemonist BiMap
+ * ================
+ *
+ * JavaScript implementation of a BiMap.
+ */
+
+var biMap$1;
+var hasRequiredBiMap;
+
+function requireBiMap () {
+	if (hasRequiredBiMap) return biMap$1;
+	hasRequiredBiMap = 1;
+	var forEach = requireForeach();
+
+	/**
+	 * Inverse Map.
+	 *
+	 * @constructor
+	 */
+	function InverseMap(original) {
+
+	  this.size = 0;
+	  this.items = new Map();
+	  this.inverse = original;
+	}
+
+	/**
+	 * BiMap.
+	 *
+	 * @constructor
+	 */
+	function BiMap() {
+
+	  this.size = 0;
+	  this.items = new Map();
+	  this.inverse = new InverseMap(this);
+	}
+
+	/**
+	 * Method used to clear the map.
+	 *
+	 * @return {undefined}
+	 */
+	function clear() {
+	  this.size = 0;
+	  this.items.clear();
+	  this.inverse.items.clear();
+	}
+
+	BiMap.prototype.clear = clear;
+	InverseMap.prototype.clear = clear;
+
+	/**
+	 * Method used to set a relation.
+	 *
+	 * @param  {any} key - Key.
+	 * @param  {any} value - Value.
+	 * @return {BiMap|InverseMap}
+	 */
+	function set(key, value) {
+
+	  // First we need to attempt to see if the relation is not flawed
+	  if (this.items.has(key)) {
+	    var currentValue = this.items.get(key);
+
+	    // The relation already exists, we do nothing
+	    if (currentValue === value)
+	      return this;
+	    else
+	      this.inverse.items.delete(currentValue);
+	  }
+
+	  if (this.inverse.items.has(value)) {
+	    var currentKey = this.inverse.items.get(value);
+
+	    if (currentKey === key)
+	      return this;
+	    else
+	      this.items.delete(currentKey);
+	  }
+
+	  // Here we actually add the relation
+	  this.items.set(key, value);
+	  this.inverse.items.set(value, key);
+
+	  // Size
+	  this.size = this.items.size;
+	  this.inverse.size = this.inverse.items.size;
+
+	  return this;
+	}
+
+	BiMap.prototype.set = set;
+	InverseMap.prototype.set = set;
+
+	/**
+	 * Method used to delete a relation.
+	 *
+	 * @param  {any} key - Key.
+	 * @return {boolean}
+	 */
+	function del(key) {
+	  if (this.items.has(key)) {
+	    var currentValue = this.items.get(key);
+
+	    this.items.delete(key);
+	    this.inverse.items.delete(currentValue);
+
+	    // Size
+	    this.size = this.items.size;
+	    this.inverse.size = this.inverse.items.size;
+
+	    return true;
+	  }
+
+	  return false;
+	}
+
+	BiMap.prototype.delete = del;
+	InverseMap.prototype.delete = del;
+
+	/**
+	 * Mapping some Map prototype function unto our two classes.
+	 */
+	var METHODS = ['has', 'get', 'forEach', 'keys', 'values', 'entries'];
+
+	METHODS.forEach(function(name) {
+	  BiMap.prototype[name] = InverseMap.prototype[name] = function() {
+	    return Map.prototype[name].apply(this.items, arguments);
+	  };
+	});
+
+	/**
+	 * Attaching the #.values method to Symbol.iterator if possible.
+	 */
+	if (typeof Symbol !== 'undefined') {
+	  BiMap.prototype[Symbol.iterator] = BiMap.prototype.entries;
+	  InverseMap.prototype[Symbol.iterator] = InverseMap.prototype.entries;
+	}
+
+	/**
+	 * Convenience known methods.
+	 */
+	BiMap.prototype.inspect = function() {
+	  var dummy = {
+	    left: this.items,
+	    right: this.inverse.items
+	  };
+
+	  // Trick so that node displays the name of the constructor
+	  Object.defineProperty(dummy, 'constructor', {
+	    value: BiMap,
+	    enumerable: false
+	  });
+
+	  return dummy;
+	};
+
+	if (typeof Symbol !== 'undefined')
+	  BiMap.prototype[Symbol.for('nodejs.util.inspect.custom')] = BiMap.prototype.inspect;
+
+	InverseMap.prototype.inspect = function() {
+	  var dummy = {
+	    left: this.inverse.items,
+	    right: this.items
+	  };
+
+	  // Trick so that node displays the name of the constructor
+	  Object.defineProperty(dummy, 'constructor', {
+	    value: InverseMap,
+	    enumerable: false
+	  });
+
+	  return dummy;
+	};
+
+	if (typeof Symbol !== 'undefined')
+	  InverseMap.prototype[Symbol.for('nodejs.util.inspect.custom')] = InverseMap.prototype.inspect;
+
+
+	/**
+	 * Static @.from function taking an arbitrary iterable & converting it into
+	 * a bimap.
+	 *
+	 * @param  {Iterable} iterable - Target iterable.
+	 * @return {BiMap}
+	 */
+	BiMap.from = function(iterable) {
+	  var bimap = new BiMap();
+
+	  forEach(iterable, function(value, key) {
+	    bimap.set(key, value);
+	  });
+
+	  return bimap;
+	};
+
+	/**
+	 * Exporting.
+	 */
+	biMap$1 = BiMap;
+	return biMap$1;
+}
+
+var biMapExports = /*@__PURE__*/ requireBiMap();
+const biMap = /*@__PURE__*/getDefaultExportFromCjs(biMapExports);
+
 /**
  * Mnemonist DefaultWeakMap
  * =========================
@@ -1096,4 +1304,4 @@ const compareRelations = (a, b) => {
   return compareFqnHierarchically(a.target, b.target);
 };
 
-export { defaultWeakMap as DefaultWeakMap, linkedList as LinkedList, multiMap as MultiMap, queue as Queue, commonAncestor, compareFqnHierarchically, compareRelations, delay, ireduce };
+export { biMap as BiMap, defaultWeakMap as DefaultWeakMap, linkedList as LinkedList, multiMap as MultiMap, queue as Queue, commonAncestor, compareFqnHierarchically, compareRelations, delay, ireduce };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@likec4/core",
-  "version": "1.25.1",
+  "version": "1.26.1",
   "license": "MIT",
   "homepage": "https://likec4.dev",
   "author": "Denis Davydkov <denis@davydkov.com>",
@@ -87,7 +87,7 @@
     "graphology": "^0.25.4",
     "graphology-dag": "^0.4.1",
     "graphology-types": "^0.24.8",
-    "mnemonist": "0.40.2",
+    "mnemonist": "0.40.3",
     "natural-compare-lite": "^1.4.0",
     "object-hash": "^3.0.0",
     "obliterator": "^2.0.5",
@@ -95,8 +95,8 @@
     "turbo": "^2.4.4",
     "typescript": "5.8.2",
     "unbuild": "^3.3.1",
-    "vitest": "^3.0.7",
-    "@likec4/tsconfig": "1.25.1"
+    "vitest": "^3.0.8",
+    "@likec4/tsconfig": "1.26.1"
   },
   "scripts": {
     "typecheck": "tsc --noEmit",

package/src/builder/_types.ts

@@ -8,7 +8,7 @@ import type {
   ElementShape,
   KeysOf,
   NonEmptyArray,
-  ParsedLikeC4Model,
+  ParsedLikeC4ModelData,
   RelationshipArrowType,
   RelationshipKindSpecification,
   RelationshipLineType,
@@ -275,7 +275,7 @@ export namespace Types {
       >
     : never
 
-  export type ToParsedLikeC4Model<T> = T extends AnyTypes ? ParsedLikeC4Model<
+  export type ToParsedLikeC4Model<T> = T extends AnyTypes ? ParsedLikeC4ModelData<
       T['ElementKind'],
       T['RelationshipKind'],
       T['Tag'],

package/src/compute-view/compute-view.ts

@@ -2,13 +2,13 @@ import { mapValues } from 'remeda'
 import { nonexhaustive } from '../errors'
 import { LikeC4Model } from '../model'
 import {
-  type ComputedLikeC4Model,
+  type ComputedLikeC4ModelData,
   type ComputedView,
+  type LikeC4View,
+  type ParsedLikeC4ModelData,
   isDeploymentView,
   isDynamicView,
   isElementView,
-  type LikeC4View,
-  type ParsedLikeC4Model
 } from '../types'
 import { computeDeploymentView } from './deployment-view/compute'
 import { computeDynamicView } from './dynamic-view/compute'
@@ -28,7 +28,7 @@ export type ComputeViewResult<V extends ComputedView = ComputedView> =
 
 export function unsafeComputeView(
   viewsource: LikeC4View,
-  likec4model: LikeC4Model
+  likec4model: LikeC4Model,
 ): ComputedView {
   switch (true) {
     case isDeploymentView(viewsource): {
@@ -45,27 +45,27 @@ export function unsafeComputeView(
 
 export function computeView<V extends LikeC4View>(
   viewsource: V,
-  likec4model: LikeC4Model
+  likec4model: LikeC4Model,
 ): ComputeViewResult {
   try {
     return {
       isSuccess: true,
-      view: unsafeComputeView(viewsource, likec4model)
+      view: unsafeComputeView(viewsource, likec4model),
     }
   } catch (e) {
     return {
       isSuccess: false,
       error: e instanceof Error ? e : new Error(`Unknown error: ${e}`),
-      view: undefined
+      view: undefined,
     }
   }
 }
 
-export function computeViews<P extends ParsedLikeC4Model>(parsed: P): ComputedLikeC4Model {
+export function computeViews<P extends ParsedLikeC4ModelData>(parsed: P): ComputedLikeC4ModelData {
   const { views, ...rest } = parsed as Omit<P, '__'>
   const likec4model = LikeC4Model.create({
     ...rest,
-    views: {}
+    views: {},
   })
   const compute = (source: LikeC4View): ComputedView => {
     const result = computeView(source, likec4model)
@@ -78,6 +78,6 @@ export function computeViews<P extends ParsedLikeC4Model>(parsed: P): ComputedLi
   return {
     ...rest,
     __: 'computed',
-    views: mapValues(parsed.views, compute)
+    views: mapValues(parsed.views, compute),
   }
 }

package/src/compute-view/utils/with-readable-edges.ts

@@ -1,5 +1,5 @@
 import { map, mapToObj, mapValues, omit } from 'remeda'
-import type { ComputedLikeC4Model } from '../../types'
+import type { ComputedLikeC4ModelData } from '../../types'
 import type { ComputedView, EdgeId } from '../../types/view'
 
 /**
@@ -28,7 +28,7 @@ export function withReadableEdges<T extends ComputedView>({ edges, nodes, ...vie
   } as any
 }
 
-export function viewsWithReadableEdges<M extends ComputedLikeC4Model>({ views, ...model }: M): M {
+export function viewsWithReadableEdges<M extends ComputedLikeC4ModelData>({ views, ...model }: M): M {
   return {
     ...model,
     views: mapValues(views, v => omit(withReadableEdges(v), ['nodeIds', 'edgeIds'])),

package/src/errors/index.ts

@@ -1,9 +1,10 @@
 // Ensure that the value is NonNullable
 // Mostly as safer `value!`
 // eslint-disable-next-line @typescript-eslint/ban-types
-export function nonNullable<T>(value: T, message?: string): NonNullable<T> {
+export function nonNullable<T>(value: T, message?: string | (() => string)): NonNullable<T> {
   if (typeof value === 'undefined' || value == null) {
-    throw new Error(message ?? `Expected defined value, but received ${value}`)
+    const msg = typeof message === 'function' ? message() : message
+    throw new Error(msg ?? `Expected defined value, but received ${value}`)
   }
   return value
 }
@@ -15,7 +16,7 @@ export function invariant(
   condition: any,
   // Can provide a string, or a function that returns a string for cases where
   // the message takes a fair amount of effort to compute
-  message?: string
+  message?: string,
 ): asserts condition {
   if (condition) {
     return

package/src/index.ts

@@ -14,11 +14,21 @@ export {
 export {
   type AnyAux,
   type Aux,
+  Connection,
+  ConnectionModel,
+  DeployedInstanceModel,
+  DeploymentConnectionModel,
+  type DeploymentElementModel,
+  DeploymentNodeModel,
+  DeploymentRelationModel,
+  EdgeModel,
+  ElementModel,
   LikeC4DeploymentModel,
   LikeC4Model,
   LikeC4ViewModel,
+  NodeModel,
+  RelationshipModel,
 } from './model'
-
 export * from './types'
 
 export * from './utils'

package/src/model/DeploymentModel.ts

@@ -5,7 +5,7 @@ import {
   type ComputedDeploymentView,
   type DeploymentRef,
   type DeploymentRelation,
-  type GenericLikeC4Model,
+  type GenericLikeC4ModelData,
   type IteratorLike,
   type Tag as C4Tag,
   DeploymentElement,
@@ -64,7 +64,7 @@ export class LikeC4DeploymentModel<M extends AnyAux = AnyAux> {
 
   constructor(
     public readonly $model: LikeC4Model<M>,
-    public readonly $deployments: GenericLikeC4Model['deployments'],
+    public readonly $deployments: GenericLikeC4ModelData['deployments'],
   ) {
     for (const element of sortParentsFirst(values($deployments.elements))) {
       const el = this.addElement(element)

package/src/model/LikeC4Model.ts

@@ -6,7 +6,7 @@ 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 { AnyParsedLikeC4ModelData, GenericLikeC4ModelData, LikeC4ModelDump } from '../types/model-data'
 import type { ModelRelation } from '../types/relation'
 import { compareNatural } from '../utils'
 import { ancestorsFqn, commonAncestor, parentFqn } from '../utils/fqn'
@@ -68,7 +68,7 @@ export class LikeC4Model<M extends AnyAux = LikeC4Model.Any> {
    * @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>> {
+  static compute<const M extends AnyParsedLikeC4ModelData>(parsed: M): LikeC4Model<Aux.FromParsed<M>> {
     let { views, ...rest } = parsed as Omit<M, '__'>
     const model = new LikeC4Model({ ...rest, views: {} })
     return new LikeC4Model({
@@ -84,7 +84,7 @@ export class LikeC4Model<M extends AnyAux = LikeC4Model.Any> {
    * const compute = LikeC4Model.makeCompute(parsedModel);
    * const result = compute(viewSource);
    */
-  static makeCompute<M extends AnyParsedLikeC4Model>(parsed: M): (viewsource: LikeC4View) => ComputeViewResult {
+  static makeCompute<M extends AnyParsedLikeC4ModelData>(parsed: M): (viewsource: LikeC4View) => ComputeViewResult {
     let { views, ...rest } = parsed as Omit<M, '__'>
     const model = new LikeC4Model({ ...rest, views: {} })
     return (viewsource) => computeView(viewsource, model)
@@ -97,7 +97,7 @@ export class LikeC4Model<M extends AnyAux = LikeC4Model.Any> {
    * @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>> {
+  static create<const M extends GenericLikeC4ModelData>(model: M): LikeC4Model<Aux.FromModel<M>> {
     return new LikeC4Model(model as any)
   }
 

package/src/model/types.ts

@@ -4,13 +4,12 @@ import type {
   DiagramView,
   EdgeId,
   Fqn,
-  GenericLikeC4Model,
-  IteratorLike,
+  GenericLikeC4ModelData,
   KeysOf,
-  LayoutedLikeC4Model,
+  LayoutedLikeC4ModelData,
   LikeC4ModelDump,
   NodeId,
-  ParsedLikeC4Model,
+  ParsedLikeC4ModelData,
   RelationId,
   ViewId,
 } from '../types'
@@ -66,7 +65,7 @@ export interface Aux<
   NodeOrId: LiteralUnion<this['NodeIdLiteral'], string> | WithId<this['NodeId']>
   EdgeOrId: LiteralUnion<this['EdgeIdLiteral'], string> | WithId<this['EdgeId']>
 
-  Model: Simplify<Omit<GenericLikeC4Model, 'views'> & WithViews<this['ViewId'], ViewType>>
+  Model: Simplify<Omit<GenericLikeC4ModelData, 'views'> & WithViews<this['ViewId'], ViewType>>
 }
 
 export type AnyAux = Aux<
@@ -83,7 +82,7 @@ export namespace Strict {
 }
 
 export namespace Aux {
-  export type FromParsed<M> = M extends ParsedLikeC4Model ? Aux<
+  export type FromParsed<M> = M extends ParsedLikeC4ModelData ? Aux<
       KeysOf<M['elements']>,
       KeysOf<M['deployments']['elements']>,
       KeysOf<M['views']>,
@@ -91,11 +90,11 @@ export namespace Aux {
     >
     : never
 
-  export type FromModel<M> = M extends GenericLikeC4Model ? Aux<
+  export type FromModel<M> = M extends GenericLikeC4ModelData ? Aux<
       KeysOf<M['elements']>,
       KeysOf<M['deployments']['elements']>,
       KeysOf<M['views']>,
-      M extends LayoutedLikeC4Model ? DiagramView<ViewId<KeysOf<M['views']>>, string>
+      M extends LayoutedLikeC4ModelData ? DiagramView<ViewId<KeysOf<M['views']>>, string>
         : ComputedView<ViewId<KeysOf<M['views']>>, string>
     >
     : never

package/src/types/_common.ts

@@ -1,5 +1,7 @@
 import type { Simplify, Tagged, UnionToIntersection } from 'type-fest'
 
+export type ProjectId = Tagged<string, 'ProjectID'>
+
 export type NonEmptyArray<T> = [T, ...T[]]
 
 export type NonEmptyReadonlyArray<T> = readonly [T, ...T[]]

package/src/types/index.ts

@@ -9,6 +9,7 @@ export type {
   NTuple,
   Point,
   Predicate,
+  ProjectId,
   XYPoint,
 } from './_common'
 
@@ -102,13 +103,13 @@ export type {
 } from './global'
 
 export type {
-  AnyParsedLikeC4Model,
-  ComputedLikeC4Model,
-  GenericLikeC4Model,
-  LayoutedLikeC4Model,
+  AnyParsedLikeC4ModelData,
+  ComputedLikeC4ModelData,
+  GenericLikeC4ModelData,
+  LayoutedLikeC4ModelData,
   LikeC4ModelDump,
-  ParsedLikeC4Model,
-} from './model'
+  ParsedLikeC4ModelData,
+} from './model-data'
 
 export {
   isAndOperator,

package/src/types/{model.ts → model-data.ts}

@@ -2,7 +2,7 @@ import type {
   DeploymentElement,
   DeploymentNodeKind,
   DeploymentNodeKindSpecification,
-  DeploymentRelation
+  DeploymentRelation,
 } from './deployments'
 import type { ElementKindSpecification, Tag, TypedElement } from './element'
 import type { ModelGlobals } from './global'
@@ -23,13 +23,13 @@ import type { ComputedView, DiagramView, LikeC4View } from './view'
  * @typeParam Views - Types of views in the model (defaults to string)
  * @typeParam DeploymentFqns - Fully Qualified Names for deployment nodes (defaults to string)
  */
-export interface ParsedLikeC4Model<
+export interface ParsedLikeC4ModelData<
   ElementKinds extends string = string,
   RelationKinds extends string = string,
   Tags extends string = string,
   Fqns extends string = string,
   Views extends string = string,
-  DeploymentFqns extends string = string
+  DeploymentFqns extends string = string,
 > {
   // To prevent accidental use of this type
   __?: never
@@ -52,7 +52,7 @@ export interface ParsedLikeC4Model<
   }
 }
 
-export type AnyParsedLikeC4Model = ParsedLikeC4Model<any, any, any, any, any, any>
+export type AnyParsedLikeC4ModelData = ParsedLikeC4ModelData<any, any, any, any, any, any>
 /**
  * Hook to get types from dump
  */
@@ -71,34 +71,34 @@ export type LikeC4ModelDump = {
 }
 
 /**
- * Same as {@link ParsedLikeC4Model}, but with computed views or layouted views.
+ * Same as {@link ParsedLikeC4ModelData}, but with computed views or layouted views.
  */
-export interface GenericLikeC4Model<
+export interface GenericLikeC4ModelData<
   Fqns extends string = string,
   DeploymentFqns extends string = string,
   Views extends string = string,
   Tags extends string = string,
-  T = 'computed' | 'layouted'
-> extends Omit<ParsedLikeC4Model<string, string, Tags, Fqns, Views, DeploymentFqns>, 'views' | '__'> {
+  T = 'computed' | 'layouted',
+> extends Omit<ParsedLikeC4ModelData<string, string, Tags, Fqns, Views, DeploymentFqns>, 'views' | '__'> {
   __?: T
   views: Record<Views, ComputedView<Views> | DiagramView<Views>>
 }
 
-export interface ComputedLikeC4Model<
+export interface ComputedLikeC4ModelData<
   Fqns extends string = string,
   DeploymentFqns extends string = string,
   Views extends string = string,
-  Tags extends string = string
-> extends Omit<GenericLikeC4Model<Fqns, DeploymentFqns, Views, Tags, 'computed'>, 'views'> {
+  Tags extends string = string,
+> extends Omit<GenericLikeC4ModelData<Fqns, DeploymentFqns, Views, Tags, 'computed'>, 'views'> {
   views: Record<Views, ComputedView<Views>>
 }
 
-export interface LayoutedLikeC4Model<
+export interface LayoutedLikeC4ModelData<
   Fqns extends string = string,
   DeploymentFqns extends string = string,
   Views extends string = string,
-  Tags extends string = string
-> extends Omit<GenericLikeC4Model<Fqns, DeploymentFqns, Views, Tags, 'layouted'>, 'views'> {
+  Tags extends string = string,
+> extends Omit<GenericLikeC4ModelData<Fqns, DeploymentFqns, Views, Tags, 'layouted'>, 'views'> {
   __: 'layouted'
   views: Record<Views, DiagramView<Views, Tags>>
 }

package/src/utils/index.ts

@@ -1,4 +1,5 @@
 export {
+  BiMap,
   DefaultMap,
   DefaultWeakMap,
   LinkedList,

package/src/utils/mnemonist.ts

@@ -1,4 +1,5 @@
 export {
+  BiMap,
   DefaultMap,
   DefaultWeakMap,
   LinkedList,