likec4 1.35.0 → 1.36.0

package/dist/vite-plugin/index.d.mts

@@ -1,4 +1,4 @@
-import { L as LikeC4LanguageServices } from '../shared/likec4.CcP3mRJH.mjs';
+import { L as LikeC4LanguageServices } from '../shared/likec4.CoVNuZKl.mjs';
 import 'type-fest';
 import '@likec4/core';
 import '@likec4/core/model';

package/dist/vite-plugin/index.mjs

@@ -1,2 +1,2 @@
-export{L as LikeC4VitePlugin}from"../shared/likec4.SsV1pHm2.mjs";import"node:path";import"../shared/likec4.B4j8eNO5.mjs";import"node:fs";import"node:url";import"../shared/likec4.BeWJWU7_.mjs";import"tty";import"node:util";import"util";import"path";import"os";import"crypto";import"net";import"url";import"fs";import"child_process";import"@likec4/core";import"@likec4/core/types";import"events";import"@hpcc-js/wasm-graphviz";import"@likec4/core/model";import"buffer";import"@likec4/core/compute-view";
+export{L as LikeC4VitePlugin}from"../shared/likec4.D8qlxD_Y.mjs";import"@likec4/core";import"node:path";import"../shared/likec4.DWIqzE5d.mjs";import"node:fs";import"node:url";import"../shared/likec4.BeWJWU7_.mjs";import"tty";import"node:util";import"util";import"path";import"os";import"crypto";import"net";import"url";import"fs";import"child_process";import"@likec4/core/types";import"events";import"@hpcc-js/wasm-graphviz";import"@likec4/core/model";import"buffer";import"@likec4/core/compute-view";
 import"@likec4/core/utils";import"node:process";import"boxen";import"node:child_process";import"node:events";import"node:fs/promises";import"node:stream/promises";import"node:readline/promises";import"node:os";import"fs/promises";

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "likec4",
-  "version": "1.35.0",
+  "description": "Toolchain for your architecture diagrams",
+  "version": "1.36.0",
   "license": "MIT",
   "homepage": "https://likec4.dev",
   "author": "Denis Davydkov <denis@davydkov.com>",
@@ -89,14 +90,14 @@
     "access": "public"
   },
   "dependencies": {
-    "@hpcc-js/wasm-graphviz": "1.7.0",
+    "@hpcc-js/wasm-graphviz": "1.10.0",
     "@vitejs/plugin-react": "^4.6.0",
     "boxen": "^8.0.1",
-    "playwright": "^1.53.1",
+    "playwright": "1.54.2",
     "rollup": "^4.44.0",
     "type-fest": "^4.41.0",
     "vite": "^6.3.5",
-    "@likec4/core": "1.35.0"
+    "@likec4/core": "1.36.0"
   },
   "peerDependencies": {
     "react": "^18.x || ^19.x",
@@ -105,8 +106,8 @@
   "devDependencies": {
     "@dagrejs/dagre": "1.1.5",
     "@fontsource/ibm-plex-sans": "^5.2.6",
-    "@mantine/core": "8.2.1",
-    "@mantine/hooks": "8.2.1",
+    "@mantine/core": "8.2.2",
+    "@mantine/hooks": "8.2.2",
     "@nanostores/react": "1.0.0",
     "@pandacss/dev": "^0.54.0",
     "@react-hookz/web": "^25.1.1",
@@ -164,7 +165,7 @@
     "tinyrainbow": "^2.0.0",
     "tsx": "4.20.3",
     "turbo": "2.5.5",
-    "typescript": "5.8.3",
+    "typescript": "5.9.2",
     "ufo": "1.6.1",
     "unbuild": "3.5.0",
     "vite-plugin-dts": "^4.5.4",
@@ -178,15 +179,15 @@
     "which": "^5.0.0",
     "wireit": "0.14.12",
     "yargs": "17.7.2",
-    "@likec4/diagram": "1.35.0",
-    "@likec4/generators": "1.35.0",
-    "@likec4/language-server": "1.35.0",
-    "@likec4/layouts": "1.35.0",
-    "@likec4/icons": "1.35.0",
-    "@likec4/styles": "1.35.0",
-    "@likec4/style-preset": "1.35.0",
-    "@likec4/log": "1.35.0",
-    "@likec4/tsconfig": "1.35.0"
+    "@likec4/diagram": "1.36.0",
+    "@likec4/icons": "1.36.0",
+    "@likec4/language-server": "1.36.0",
+    "@likec4/layouts": "1.36.0",
+    "@likec4/generators": "1.36.0",
+    "@likec4/log": "1.36.0",
+    "@likec4/style-preset": "1.36.0",
+    "@likec4/styles": "1.36.0",
+    "@likec4/tsconfig": "1.36.0"
   },
   "scripts": {
     "typecheck": "tsc --build --verbose",

package/react/index.d.mts

@@ -2,6 +2,7 @@
 
 import { CSSProperties, ComponentType, HTMLAttributes, JSX, MouseEvent as ReactMouseEvent, PropsWithChildren, ReactNode, WheelEvent as WheelEvent$1 } from 'react';
 
+type Primitive = null | undefined | string | number | boolean | symbol | bigint;
 type UnionToIntersection<Union> = (
 // `extends unknown` is always going to be the case and is used to convert the
 // `Union` into a [distributive conditional
@@ -28,6 +29,38 @@ type IsArrayReadonly<T extends UnknownArray> = IfNever<T, false, T extends unkno
 type IfArrayReadonly<T extends UnknownArray, TypeIfArrayReadonly = true, TypeIfNotArrayReadonly = false> = IsArrayReadonly<T> extends infer Result ? Result extends true ? TypeIfArrayReadonly : TypeIfNotArrayReadonly : never;
 type NoInfer$1<T> = T extends infer U ? U : never;
 type IsAny<T> = 0 extends 1 & NoInfer$1<T> ? true : false;
+type Numeric = number | bigint;
+type LiteralCheck<T, LiteralType extends Primitive> = (IsNever<T> extends false // Must be wider than `never`
+ ? [
+	T
+] extends [
+	LiteralType & infer U
+] // Remove any branding
+ ? [
+	U
+] extends [
+	LiteralType
+] // Must be narrower than `LiteralType`
+ ? [
+	LiteralType
+] extends [
+	U
+] // Cannot be wider than `LiteralType`
+ ? false : true : false : false : false);
+type LiteralChecks<T, LiteralUnionType> = (
+// Conditional type to force union distribution.
+// If `T` is none of the literal types in the union `LiteralUnionType`, then `LiteralCheck<T, LiteralType>` will evaluate to `false` for the whole union.
+// If `T` is one of the literal types in the union, it will evaluate to `boolean` (i.e. `true | false`)
+IsNotFalse<LiteralUnionType extends Primitive ? LiteralCheck<T, LiteralUnionType> : never>);
+type IsStringLiteral<T> = IfNever<T, false, 
+// If `T` is an infinite string type (e.g., `on${string}`), `Record<T, never>` produces an index signature,
+// and since `{}` extends index signatures, the result becomes `false`.
+T extends string ? {} extends Record<T, never> ? false : true : false>;
+type IsNumericLiteral<T> = LiteralChecks<T, Numeric>;
+type IsBooleanLiteral<T> = LiteralCheck<T, boolean>;
+type IsSymbolLiteral<T> = LiteralCheck<T, symbol>;
+type IsLiteralUnion<T> = IsStringLiteral<T> | IsNumericLiteral<T> | IsBooleanLiteral<T> | IsSymbolLiteral<T>;
+type IsLiteral<T> = IsPrimitive<T> extends true ? IsNotFalse<IsLiteralUnion<T>> : false;
 type IsEqual<A, B> = (<G>() => G extends A & G | G ? 1 : 2) extends (<G>() => G extends B & G | G ? 1 : 2) ? true : false;
 type Simplify<T> = {
 	[KeyType in keyof T]: T[KeyType];
@@ -43,6 +76,16 @@ type SimpleMerge<Destination, Source> = {
 } & Source;
 type Merge<Destination, Source> = Simplify<SimpleMerge<PickIndexSignature<Destination>, PickIndexSignature<Source>> & SimpleMerge<OmitIndexSignature<Destination>, OmitIndexSignature<Source>>>;
 type IfAny<T, TypeIfAny = true, TypeIfNotAny = false> = (IsAny<T> extends true ? TypeIfAny : TypeIfNotAny);
+type IsNotFalse<T extends boolean> = [
+	T
+] extends [
+	false
+] ? false : true;
+type IsPrimitive<T> = [
+	T
+] extends [
+	Primitive
+] ? true : false;
 type HomomorphicPick<T, Keys extends KeysOfUnion<T>> = {
 	[P in keyof T as Extract<P, Keys>]: T[P];
 };
@@ -120,6 +163,7 @@ interface Link {
 	relative?: string;
 }
 type Coalesce<V extends string, OrIfAny = string> = IsAny<V> extends true ? OrIfAny : V;
+type ProjectId<T = string> = Tagged<T, "ProjectID">;
 type MarkdownOrString = {
 	txt: string;
 	md?: never;
@@ -132,12 +176,16 @@ type Icon = Tagged<string, "Icon"> | BuiltInIcon;
 type IconUrl = Icon;
 type Fqn<Id = string> = Tagged<Id, "Fqn">;
 declare function Fqn(name: string, parent?: Fqn | null): Fqn;
+type ElementKind<Kinds = string> = Tagged<Kinds, "ElementKind">;
 type DeploymentFqn<T = string> = Tagged<T, "DeploymentFqn">;
 declare function DeploymentFqn(name: string, parent?: DeploymentFqn | null): DeploymentFqn;
+type DeploymentKind<Kinds = string> = Tagged<Kinds, "DeploymentKind">;
 type ViewId<Id = string> = Tagged<Id, "ViewId">;
 declare function ViewId(id: string): ViewId;
+type RelationshipKind<Kinds = string> = Tagged<Kinds, "RelationshipKind">;
 type RelationId<Id = string> = Tagged<Id, "RelationId">;
 declare function RelationId(id: string): RelationId;
+type Tag$1<T = string> = Tagged<T, "Tag">;
 type NodeId = Tagged<string, "NodeId" | "Fqn" | "DeploymentFqn">;
 declare function NodeId(id: string): NodeId;
 type EdgeId = Tagged<string, "EdgeId">;
@@ -155,6 +203,7 @@ interface SpecAux<ElementKind extends string, DeploymentKind extends string, Rel
 	Tag: Tag;
 	MetadataKey: MetadataKey;
 }
+type AnySpec = SpecAux<any, any, any, any, any>;
 interface Aux<Stage extends ModelStage, Element extends string, Deployment extends string, View extends string, Project extends string, Spec extends SpecAux<string, string, string, string, string>> {
 	Stage: Stage;
 	ProjectId: Project;
@@ -168,26 +217,129 @@ interface Aux<Stage extends ModelStage, Element extends string, Deployment exten
 	MetadataKey: Spec["MetadataKey"];
 }
 type Any = Aux<any, any, any, any, any, SpecAux<any, any, any, any, any>>;
+type Never = Aux<never, never, never, never, never, SpecAux<never, never, never, never, never>>;
+type Unknown = Aux<"layouted" | "computed", string, string, string, string, SpecAux<string, string, string, string, string>>;
+type UnknownParsed = Aux<"parsed", string, string, string, string, SpecAux<string, string, string, string, string>>;
+type UnknownComputed = Aux<"computed", string, string, string, string, SpecAux<string, string, string, string, string>>;
 type UnknownLayouted = Aux<"layouted", string, string, string, string, SpecAux<string, string, string, string, string>>;
+type Stage<A> = A extends Aux<infer S, any, any, any, any, any> ? IfNever<S, never, Coalesce<S, ModelStage>> : never;
+type PickByStage<A extends Any, OnParsed, OnComputed, OnLayouted = OnComputed> = {
+	parsed: OnParsed;
+	computed: OnComputed;
+	layouted: OnLayouted;
+}[A["Stage"]];
+type setStage<A, S extends ModelStage> = A extends Aux<any, infer E, infer D, infer V, infer P, infer Spec> ? Aux<S, E, D, V, P, Spec> : never;
+type toParsed<A> = A extends Aux<any, infer E, infer D, infer V, infer P, infer Spec> ? Aux<"parsed", E, D, V, P, Spec> : never;
+type toComputed<A> = A extends Aux<any, infer E, infer D, infer V, infer P, infer Spec> ? Aux<"computed", E, D, V, P, Spec> : never;
+type toLayouted<A> = A extends Aux<any, infer E, infer D, infer V, infer P, infer Spec> ? Aux<"layouted", E, D, V, P, Spec> : never;
+type ProjectId$1<A> = A extends infer T extends Any ? Coalesce<T["ProjectId"]> : never;
+type setProject<A, P extends string> = A extends Aux<infer S, infer E, infer D, infer V, any, infer Spec> ? Aux<S, E, D, V, P, Spec> : never;
 type Fqn$1<A> = A extends infer T extends Any ? Fqn<ElementId<T>> : never;
 type ElementId<A> = A extends infer T extends Any ? Coalesce<T["ElementId"]> : never;
 type DeploymentFqn$1<A> = A extends infer T extends Any ? DeploymentFqn<DeploymentId<T>> : never;
 type DeploymentId<A> = A extends infer T extends Any ? Coalesce<T["DeploymentId"]> : never;
 type ViewId$1<A> = A extends infer T extends Any ? Coalesce<T["ViewId"]> : never;
 type RelationId$1 = RelationId;
-type ElementKind<A> = A extends infer T extends Any ? Coalesce<T["ElementKind"]> : never;
-type DeploymentKind<A> = A extends infer T extends Any ? Coalesce<T["DeploymentKind"]> : never;
+type NodeId$1 = NodeId;
+type EdgeId$1 = EdgeId;
+type ElementKind$1<A> = A extends infer T extends Any ? Coalesce<T["ElementKind"]> : never;
+type DeploymentKind$1<A> = A extends infer T extends Any ? Coalesce<T["DeploymentKind"]> : never;
 type RelationKind<A> = A extends infer T extends Any ? Coalesce<T["RelationKind"]> : never;
-type Tag$1<A> = A extends infer T extends Any ? Coalesce<T["Tag"]> : never;
-type Tags<A extends Any> = readonly Tag$1<A>[];
-type AllKinds<A> = ElementKind<A> | DeploymentKind<A> | RelationKind<A>;
+type Tag$2<A> = A extends infer T extends Any ? Coalesce<T["Tag"]> : never;
+type Tags<A extends Any> = readonly Tag$2<A>[];
+type MetadataKey<A> = A extends infer T extends Any ? Coalesce<T["MetadataKey"]> : never;
+type Metadata<A extends Any> = IsNever<A["MetadataKey"]> extends true ? never : IsLiteral<A["MetadataKey"]> extends true ? {
+	[key in A["MetadataKey"]]?: string;
+} : Record<string, string>;
+type AllKinds<A> = ElementKind$1<A> | DeploymentKind$1<A> | RelationKind<A>;
+type Spec<A> = A extends Aux<any, any, any, any, any, infer S> ? S : never;
+type StrictProjectId<A> = A extends infer T extends Any ? ProjectId<ProjectId$1<T>> : never;
 type StrictViewId<A> = A extends infer T extends Any ? ViewId<ViewId$1<T>> : never;
+type StrictTag<A> = A extends infer T extends Any ? Tag$1<Tag$2<T>> : never;
+type StrictElementKind<A> = A extends infer T extends Any ? ElementKind<ElementKind$1<T>> : never;
+type StrictDeploymentKind<A> = A extends infer T extends Any ? DeploymentKind<DeploymentKind$1<T>> : never;
+type StrictRelationKind<A> = A extends infer T extends Any ? RelationshipKind<RelationKind<T>> : never;
+type WithTags<A extends Any> = {
+	readonly tags: Tags<A>;
+};
 type WithOptionalTags<A extends Any> = {
 	readonly tags?: Tags<A> | null;
 };
+type WithLinks = {
+	readonly links: readonly Link[];
+};
 type WithOptionalLinks = {
 	readonly links?: readonly Link[] | null;
 };
+type WithMetadata<A extends Any> = {
+	readonly metadata?: Metadata<A>;
+};
+type OrString = string & Record<never, never>;
+type LooseElementId<A extends Any> = Coalesce<A["ElementId"]> | OrString;
+type LooseDeploymentId<A extends Any> = Coalesce<A["DeploymentId"]> | OrString;
+type LooseViewId<A extends Any> = Coalesce<A["ViewId"]> | OrString;
+type LooseTag<A extends Any> = Coalesce<A["Tag"]> | OrString;
+type LooseTags<A extends Any> = readonly (Coalesce<A["Tag"]> | OrString)[];
+type LooseElementKind<A extends Any> = Coalesce<A["ElementKind"]> | OrString;
+type LooseDeploymentKind<A extends Any> = Coalesce<A["DeploymentKind"]> | OrString;
+type LooseRelationKind<A extends Any> = Coalesce<A["RelationKind"]> | OrString;
+type _aux_AllKinds<A> = AllKinds<A>;
+type _aux_Any = Any;
+type _aux_AnySpec = AnySpec;
+type _aux_Aux<Stage extends ModelStage, Element extends string, Deployment extends string, View extends string, Project extends string, Spec extends SpecAux<string, string, string, string, string>> = Aux<Stage, Element, Deployment, View, Project, Spec>;
+type _aux_DeploymentFqn<A> = DeploymentFqn$1<A>;
+type _aux_DeploymentId<A> = DeploymentId<A>;
+type _aux_DeploymentKind<A> = DeploymentKind$1<A>;
+type _aux_EdgeId = EdgeId$1;
+type _aux_ElementId<A> = ElementId<A>;
+type _aux_ElementKind<A> = ElementKind$1<A>;
+type _aux_Fqn<A> = Fqn$1<A>;
+type _aux_LooseDeploymentId<A extends Any> = LooseDeploymentId<A>;
+type _aux_LooseDeploymentKind<A extends Any> = LooseDeploymentKind<A>;
+type _aux_LooseElementId<A extends Any> = LooseElementId<A>;
+type _aux_LooseElementKind<A extends Any> = LooseElementKind<A>;
+type _aux_LooseRelationKind<A extends Any> = LooseRelationKind<A>;
+type _aux_LooseTag<A extends Any> = LooseTag<A>;
+type _aux_LooseTags<A extends Any> = LooseTags<A>;
+type _aux_LooseViewId<A extends Any> = LooseViewId<A>;
+type _aux_Metadata<A extends Any> = Metadata<A>;
+type _aux_MetadataKey<A> = MetadataKey<A>;
+type _aux_Never = Never;
+type _aux_NodeId = NodeId$1;
+type _aux_OrString = OrString;
+type _aux_PickByStage<A extends Any, OnParsed, OnComputed, OnLayouted = OnComputed> = PickByStage<A, OnParsed, OnComputed, OnLayouted>;
+type _aux_ProjectId<A> = ProjectId$1<A>;
+type _aux_RelationId = RelationId$1;
+type _aux_RelationKind<A> = RelationKind<A>;
+type _aux_Spec<A> = Spec<A>;
+type _aux_SpecAux<ElementKind extends string, DeploymentKind extends string, RelationKind extends string, Tag extends string, MetadataKey extends string> = SpecAux<ElementKind, DeploymentKind, RelationKind, Tag, MetadataKey>;
+type _aux_Stage<A> = Stage<A>;
+type _aux_StrictDeploymentKind<A> = StrictDeploymentKind<A>;
+type _aux_StrictElementKind<A> = StrictElementKind<A>;
+type _aux_StrictProjectId<A> = StrictProjectId<A>;
+type _aux_StrictRelationKind<A> = StrictRelationKind<A>;
+type _aux_StrictTag<A> = StrictTag<A>;
+type _aux_StrictViewId<A> = StrictViewId<A>;
+type _aux_Tag<A> = Tag$2<A>;
+type _aux_Tags<A extends Any> = Tags<A>;
+type _aux_Unknown = Unknown;
+type _aux_UnknownComputed = UnknownComputed;
+type _aux_UnknownLayouted = UnknownLayouted;
+type _aux_UnknownParsed = UnknownParsed;
+type _aux_ViewId<A> = ViewId$1<A>;
+type _aux_WithLinks = WithLinks;
+type _aux_WithMetadata<A extends Any> = WithMetadata<A>;
+type _aux_WithOptionalLinks = WithOptionalLinks;
+type _aux_WithOptionalTags<A extends Any> = WithOptionalTags<A>;
+type _aux_WithTags<A extends Any> = WithTags<A>;
+type _aux_setProject<A, P extends string> = setProject<A, P>;
+type _aux_setStage<A, S extends ModelStage> = setStage<A, S>;
+type _aux_toComputed<A> = toComputed<A>;
+type _aux_toLayouted<A> = toLayouted<A>;
+type _aux_toParsed<A> = toParsed<A>;
+declare namespace _aux {
+	export type { _aux_AllKinds as _aux_AllKinds, _aux_Any as _aux_Any, Any as Any, _aux_AnySpec as _aux_AnySpec, _aux_Aux as _aux_Aux, _aux_DeploymentFqn as _aux_DeploymentFqn, _aux_DeploymentId as _aux_DeploymentId, _aux_DeploymentKind as _aux_DeploymentKind, _aux_EdgeId as _aux_EdgeId, _aux_ElementId as _aux_ElementId, _aux_ElementKind as _aux_ElementKind, _aux_Fqn as _aux_Fqn, _aux_LooseDeploymentId as _aux_LooseDeploymentId, _aux_LooseDeploymentKind as _aux_LooseDeploymentKind, _aux_LooseElementId as _aux_LooseElementId, _aux_LooseElementKind as _aux_LooseElementKind, _aux_LooseRelationKind as _aux_LooseRelationKind, _aux_LooseTag as _aux_LooseTag, _aux_LooseTags as _aux_LooseTags, _aux_LooseViewId as _aux_LooseViewId, _aux_Metadata as _aux_Metadata, _aux_MetadataKey as _aux_MetadataKey, _aux_Never as _aux_Never, _aux_NodeId as _aux_NodeId, _aux_OrString as _aux_OrString, _aux_PickByStage as _aux_PickByStage, _aux_ProjectId as _aux_ProjectId, _aux_RelationId as _aux_RelationId, _aux_RelationKind as _aux_RelationKind, _aux_Spec as _aux_Spec, _aux_SpecAux as _aux_SpecAux, _aux_Stage as _aux_Stage, DeploymentFqn$1 as DeploymentFqn$1, _aux_StrictDeploymentKind as _aux_StrictDeploymentKind, _aux_StrictElementKind as _aux_StrictElementKind, Fqn$1 as Fqn$1, _aux_StrictProjectId as _aux_StrictProjectId, _aux_StrictRelationKind as _aux_StrictRelationKind, _aux_StrictTag as _aux_StrictTag, _aux_StrictViewId as _aux_StrictViewId, _aux_Tag as _aux_Tag, _aux_Tags as _aux_Tags, _aux_Unknown as _aux_Unknown, _aux_UnknownComputed as _aux_UnknownComputed, _aux_UnknownLayouted as _aux_UnknownLayouted, _aux_UnknownParsed as _aux_UnknownParsed, _aux_ViewId as _aux_ViewId, _aux_WithLinks as _aux_WithLinks, _aux_WithMetadata as _aux_WithMetadata, _aux_WithOptionalLinks as _aux_WithOptionalLinks, _aux_WithOptionalTags as _aux_WithOptionalTags, _aux_WithTags as _aux_WithTags, _aux_setProject as _aux_setProject, _aux_setStage as _aux_setStage, _aux_toComputed as _aux_toComputed, _aux_toLayouted as _aux_toLayouted, _aux_toParsed as _aux_toParsed };
+}
 type SpacingSize = "xs" | "sm" | "md" | "lg" | "xl";
 type TextSize = "xs" | "sm" | "md" | "lg" | "xl";
 type ShapeSize = "xs" | "sm" | "md" | "lg" | "xl";
@@ -244,7 +396,7 @@ type AllNever = {
 	operator?: never;
 };
 type TagEqual<A extends Any> = Omit<AllNever, "tag"> & {
-	tag: EqualOperator<Tag$1<A>> | Tag$1<A>;
+	tag: EqualOperator<Tag$2<A>> | Tag$2<A>;
 };
 type KindEqual<A extends Any> = Omit<AllNever, "kind"> & {
 	kind: EqualOperator<AllKinds<A>> | AllKinds<A>;
@@ -384,7 +536,7 @@ interface ElementStyle {
 }
 interface ComputedNode<A extends Any = Any> extends WithOptionalLinks {
 	id: NodeId;
-	kind: ElementKind<A> | DeploymentKind<A> | "@group";
+	kind: ElementKind$1<A> | DeploymentKind$1<A> | "@group";
 	parent: NodeId | null;
 	/**
 	 * Reference to model element
@@ -425,7 +577,7 @@ interface ComputedEdge<A extends Any = Any> extends WithOptionalTags<A> {
 	relations: RelationId[];
 	kind?: RelationKind<A> | typeof StepEdgeKind;
 	notation?: string;
-	notes?: string;
+	notes?: MarkdownOrString;
 	color?: Color;
 	line?: RelationshipLineType;
 	head?: RelationshipArrowType;
@@ -2123,7 +2275,7 @@ type ElementIconRendererProps = {
 	className?: string;
 };
 export type ElementIconRenderer = (props: ElementIconRendererProps) => ReactNode;
-type OnNavigateTo<A extends Any> = (to: ViewId$1<A>, event?: ReactMouseEvent, element?: DiagramNodeWithNavigate<A>) => void;
+type OnNavigateTo<A extends Any> = (to: _aux.ViewId<A>, event?: ReactMouseEvent, element?: DiagramNodeWithNavigate<A>) => void;
 type OnNodeClick<A extends Any> = (node: DiagramNode<A>, event: ReactMouseEvent) => void;
 type OnEdgeClick<A extends Any> = (edge: DiagramEdge<A>, event: ReactMouseEvent) => void;
 type OnCanvasClick = (event: ReactMouseEvent) => void;
@@ -2142,7 +2294,7 @@ type ViewPadding = PaddingWithUnit$1 | {
 	x?: PaddingWithUnit$1;
 	y?: PaddingWithUnit$1;
 };
-interface LikeC4DiagramProperties<A extends Any> {
+interface LikeC4DiagramProperties<A extends _aux.Any> {
 	view: LayoutedView<A>;
 	className?: string | undefined;
 	/**
@@ -2314,18 +2466,18 @@ interface LikeC4DiagramProperties<A extends Any> {
 	 */
 	reactFlowProps?: OverrideReactFlowProps | undefined;
 }
-type OpenSourceParams<A extends Any = Any> = {
-	element: Fqn$1<A>;
+type OpenSourceParams<A extends _aux.Any = _aux.Any> = {
+	element: _aux.Fqn<A>;
 	property?: string;
 } | {
-	relation: RelationId$1;
+	relation: _aux.RelationId;
 } | {
-	deployment: DeploymentFqn$1<A>;
+	deployment: _aux.DeploymentFqn<A>;
 	property?: string;
 } | {
-	view: StrictViewId<A>;
+	view: _aux.StrictViewId<A>;
 };
-interface LikeC4DiagramEventHandlers<A extends Any> {
+interface LikeC4DiagramEventHandlers<A extends _aux.Any = _aux.Any> {
 	onChange?: OnChange | null | undefined;
 	onNavigateTo?: OnNavigateTo<A> | null | undefined;
 	onNodeClick?: OnNodeClick<A> | null | undefined;
@@ -2338,11 +2490,11 @@ interface LikeC4DiagramEventHandlers<A extends Any> {
 	onBurgerMenuClick?: null | undefined | (() => void);
 	onOpenSource?: null | undefined | ((params: OpenSourceParams<A>) => void);
 }
-export interface LikeC4ViewProps<A extends Any> {
+export interface LikeC4ViewProps<A extends _aux.Any> {
 	/**
 	 * View to display.
 	 */
-	viewId: ViewId$1<A>;
+	viewId: _aux.ViewId<A>;
 	/**
 	 * Enable/disable panning
 	 * @default false
@@ -2560,10 +2712,10 @@ interface LikeC4BrowserProps {
 	 */
 	reactFlowProps?: OverrideReactFlowProps | undefined;
 }
-export declare function LikeC4View<A extends Any = UnknownLayouted>({ viewId, ...props }: LikeC4ViewProps<A>): import("react/jsx-runtime").JSX.Element;
+export declare function LikeC4View<A extends _aux.Any = _aux.UnknownLayouted>({ viewId, ...props }: LikeC4ViewProps<A>): import("react/jsx-runtime").JSX.Element;
 type LikeC4DiagramProps<A extends Any = Any> = PropsWithChildren<LikeC4DiagramProperties<A> & LikeC4DiagramEventHandlers<A>>;
-export type ReactLikeC4Props<A extends Any> = Omit<LikeC4DiagramProps<A>, "view"> & {
-	viewId: ViewId$1<A>;
+export type ReactLikeC4Props<A extends _aux.Any> = Omit<LikeC4DiagramProps<A>, "view"> & {
+	viewId: _aux.ViewId<A>;
 	/**
 	 * Keep aspect ratio of the diagram
 	 * Disable if you need to manage the viewport (use className)
@@ -2588,7 +2740,7 @@ export type ReactLikeC4Props<A extends Any> = Omit<LikeC4DiagramProps<A>, "view"
 	/** Function to generate nonce attribute added to all generated `<style />` tags */
 	styleNonce?: string | (() => string) | undefined;
 };
-export declare function ReactLikeC4<A extends Any = UnknownLayouted>({ viewId, ...props }: ReactLikeC4Props<A>): import("react/jsx-runtime").JSX.Element;
+export declare function ReactLikeC4<A extends _aux.Any = _aux.UnknownLayouted>({ viewId, ...props }: ReactLikeC4Props<A>): import("react/jsx-runtime").JSX.Element;
 export declare namespace ReactLikeC4 {
 	var displayName: string;
 }