likec4 1.17.0 → 1.18.0

package/react/index.d.ts

@@ -1,7 +1,7 @@
 // Generated by dts-bundle-generator v9.5.1
 
 import { CSSProperties, DependencyList, HTMLAttributes, MouseEvent as ReactMouseEvent, PropsWithChildren, ReactNode } from 'react';
-import { Class, LiteralUnion, NonEmptyTuple, OverrideProperties, PartialDeep, Tagged, TupleToUnion } from 'type-fest';
+import { IsLiteral, LiteralUnion, MergeExclusive, NonEmptyTuple, OverrideProperties, PartialDeep, SetRequired, Simplify, Tagged, TupleToUnion, UnionToIntersection } from 'type-fest';
 
 type NonEmptyArray<T> = [
 	T,
@@ -16,6 +16,7 @@ interface XYPoint {
 	x: number;
 	y: number;
 }
+type KeysOf<T> = keyof T extends infer K extends string ? K : never;
 declare const ThemeColors: readonly [
 	"amber",
 	"blue",
@@ -71,8 +72,13 @@ declare const ElementShapes: readonly [
 ];
 type ElementShape = TupleToUnion<typeof ElementShapes>;
 interface ElementStyle {
-	border?: BorderStyle;
-	opacity?: number;
+	readonly border?: BorderStyle;
+	/**
+	 * In percentage 0-100, 0 is fully transparent
+	 *
+	 * @default 100
+	 */
+	readonly opacity?: number;
 }
 type Tag<Tags extends string = string> = Tagged<Tags, "Tag">;
 interface Link {
@@ -139,6 +145,104 @@ type OrOperator<Tag, Kind> = Omit<AllNever, "or"> & {
 	or: NonEmptyArray<WhereOperator<Tag, Kind>>;
 };
 type WhereOperator<Tag, Kind> = TagEqual<Tag> | KindEqual<Kind> | NotOperator<Tag, Kind> | AndOperator<Tag, Kind> | OrOperator<Tag, Kind>;
+interface BaseExpr {
+	where?: never;
+	element?: never;
+	custom?: never;
+	expanded?: never;
+	elementKind?: never;
+	elementTag?: never;
+	isEqual?: never;
+	isChildren?: never;
+	isDescendants?: never;
+	wildcard?: never;
+	source?: never;
+	target?: never;
+	inout?: never;
+	incoming?: never;
+	outgoing?: never;
+	customRelation?: never;
+}
+interface ElementRefExpr extends Omit<BaseExpr, "element" | "isChildren" | "isDescendants"> {
+	element: Fqn;
+	isChildren?: boolean;
+	isDescendants?: boolean;
+}
+interface ExpandedElementExpr extends Omit<BaseExpr, "expanded"> {
+	expanded: Fqn;
+}
+interface CustomElementExpr extends Omit<BaseExpr, "custom"> {
+	custom: {
+		expr: ElementExpression | ElementWhereExpr;
+		title?: string;
+		description?: string;
+		technology?: string;
+		notation?: string;
+		shape?: ElementShape;
+		color?: Color;
+		icon?: IconUrl;
+		border?: BorderStyle;
+		opacity?: number;
+		navigateTo?: ViewId;
+	};
+}
+interface WildcardExpr extends Omit<BaseExpr, "wildcard"> {
+	wildcard: true;
+}
+interface ElementKindExpr extends Omit<BaseExpr, "elementKind" | "isEqual"> {
+	elementKind: ElementKind;
+	isEqual: boolean;
+}
+interface ElementTagExpr extends Omit<BaseExpr, "elementTag" | "isEqual"> {
+	elementTag: Tag;
+	isEqual: boolean;
+}
+type ElementExpression = ElementRefExpr | WildcardExpr | ElementKindExpr | ElementTagExpr | ExpandedElementExpr;
+interface ElementWhereExpr extends Omit<BaseExpr, "where"> {
+	where: {
+		expr: ElementExpression;
+		condition: WhereOperator<string, string>;
+	};
+}
+type ElementPredicateExpression = ElementExpression | ElementWhereExpr | CustomElementExpr;
+interface RelationExpr extends Omit<BaseExpr, "source" | "target"> {
+	source: ElementExpression;
+	target: ElementExpression;
+	isBidirectional?: boolean;
+}
+interface InOutExpr extends Omit<BaseExpr, "inout"> {
+	inout: ElementExpression;
+}
+interface IncomingExpr extends Omit<BaseExpr, "incoming"> {
+	incoming: ElementExpression;
+}
+interface OutgoingExpr extends Omit<BaseExpr, "outgoing"> {
+	outgoing: ElementExpression;
+}
+type RelationExpression = RelationExpr | InOutExpr | IncomingExpr | OutgoingExpr;
+interface RelationWhereExpr extends Omit<BaseExpr, "where"> {
+	where: {
+		expr: RelationExpression;
+		condition: WhereOperator<string, string>;
+	};
+}
+interface CustomRelationExpr extends Omit<BaseExpr, "customRelation"> {
+	customRelation: {
+		relation: RelationExpression | RelationWhereExpr;
+		title?: string;
+		description?: string;
+		technology?: string;
+		notation?: string;
+		navigateTo?: ViewId;
+		notes?: string;
+		color?: Color;
+		line?: RelationshipLineType;
+		head?: RelationshipArrowType;
+		tail?: RelationshipArrowType;
+	};
+}
+type RelationPredicateExpression = RelationExpression | RelationWhereExpr | CustomRelationExpr;
+type Expression = ElementPredicateExpression | RelationPredicateExpression;
 type GlobalPredicateId = Tagged<string, "GlobalPredicateId">;
 type GlobalPredicates = NonEmptyArray<ViewRulePredicate>;
 type GlobalDynamicPredicates = NonEmptyArray<DynamicViewIncludeRule>;
@@ -150,12 +254,12 @@ interface ModelGlobals {
 	styles: Record<GlobalStyleID, GlobalStyles>;
 }
 type ElementNotation = {
-	kinds: ElementKind[];
+	kinds: string[];
 	shape: ElementShape;
 	color: Color;
 	title: string;
 };
-type ViewID<Id extends string = string> = Tagged<Id, "ViewID">;
+type ViewId<Id extends string = string> = Tagged<Id, "ViewID">;
 type ViewRulePredicate = {
 	include: Expression[];
 	exclude?: never;
@@ -192,9 +296,9 @@ interface ViewRuleGroup {
 	opacity?: number;
 }
 type ViewRule = ViewRulePredicate | ViewRuleGlobalPredicateRef | ViewRuleGroup | ViewRuleStyle | ViewRuleGlobalStyle | ViewRuleAutoLayout;
-interface BasicView<ViewType extends "element" | "dynamic", ViewIDs extends string, Tags extends string> {
+interface BasicView<ViewType extends "element" | "dynamic" | "deployment", ViewIDs extends string, Tags extends string> {
 	readonly __?: ViewType;
-	readonly id: ViewID<ViewIDs>;
+	readonly id: ViewId<ViewIDs>;
 	readonly title: string | null;
 	readonly description: string | null;
 	readonly tags: NonEmptyArray<Tag<Tags>> | null;
@@ -227,7 +331,7 @@ interface ScopedElementView<ViewIDs extends string, Tags extends string> extends
 	readonly viewOf: Fqn;
 }
 interface ExtendsElementView<ViewIDs extends string, Tags extends string> extends BasicElementView<ViewIDs, Tags> {
-	readonly extends: ViewID<ViewIDs>;
+	readonly extends: ViewId<ViewIDs>;
 }
 type ElementView<ViewIDs extends string = string, Tags extends string = string> = ScopedElementView<ViewIDs, Tags> | ExtendsElementView<ViewIDs, Tags> | BasicElementView<ViewIDs, Tags>;
 interface DynamicViewStep {
@@ -243,7 +347,7 @@ interface DynamicViewStep {
 	readonly head?: RelationshipArrowType;
 	readonly tail?: RelationshipArrowType;
 	readonly isBackward?: boolean;
-	readonly navigateTo?: ViewID;
+	readonly navigateTo?: ViewId;
 	__parallel?: never;
 }
 interface DynamicViewParallelSteps {
@@ -262,13 +366,46 @@ interface DynamicView<ViewIDs extends string = string, Tags extends string = str
 type CustomColorDefinitions = {
 	[key: string]: ThemeColorValues;
 };
-type LikeC4View<ViewIDs extends string = string, Tags extends string = string> = ElementView<ViewIDs, Tags> | DynamicView<ViewIDs, Tags>;
+type DeploymentViewRulePredicate = {
+	include: DeploymentExpression[];
+	exclude?: never;
+} | {
+	include?: never;
+	exclude: DeploymentExpression[];
+};
+type DeploymentViewRuleStyle = {
+	targets: DeploymentExpression[];
+	notation?: string;
+	style: ElementStyle & {
+		color?: Color;
+		shape?: ElementShape;
+		icon?: IconUrl;
+	};
+};
+type DeploymentViewRule = DeploymentViewRulePredicate | ViewRuleAutoLayout | DeploymentViewRuleStyle;
+interface DeploymentView<ViewIDs extends string = string, Tags extends string = string> extends BasicView<"deployment", ViewIDs, Tags> {
+	readonly __: "deployment";
+	readonly rules: DeploymentViewRule[];
+}
+type LikeC4View<ViewIDs extends string = string, Tags extends string = string> = ElementView<ViewIDs, Tags> | DynamicView<ViewIDs, Tags> | DeploymentView<ViewIDs, Tags>;
 type NodeId<IDs extends string = string> = Tagged<IDs, "Fqn">;
 type EdgeId = Tagged<string, "EdgeId">;
+type StepEdgeIdLiteral = `step-${number}` | `step-${number}.${number}`;
+type StepEdgeId = Tagged<StepEdgeIdLiteral, "EdgeId">;
 interface ComputedNode {
 	id: NodeId;
-	kind: ElementKind;
+	kind: string;
 	parent: NodeId | null;
+	/**
+	 * Reference to model element
+	 * If 1 - node id is a reference
+	 */
+	modelRef?: 1 | Fqn;
+	/**
+	 * Reference to deployment element
+	 * If 1 - node id is a reference
+	 */
+	deploymentRef?: 1 | Fqn;
 	title: string;
 	description: string | null;
 	technology: string | null;
@@ -279,16 +416,13 @@ interface ComputedNode {
 	inEdges: EdgeId[];
 	outEdges: EdgeId[];
 	shape: ElementShape;
-	/**
-	 * @deprecated Use `style` instead
-	 */
 	color: Color;
 	/**
 	 * @deprecated Use `style` instead
 	 */
 	icon?: IconUrl;
 	style: ElementStyle;
-	navigateTo?: ViewID;
+	navigateTo?: ViewId;
 	level: number;
 	depth?: number;
 	/**
@@ -297,6 +431,8 @@ interface ComputedNode {
 	isCustomized?: boolean;
 }
 declare namespace ComputedNode {
+	function modelRef(node: ComputedNode): Fqn | null;
+	function deploymentRef(node: ComputedNode): Fqn | null;
 	/**
 	 * Nodes group is a special kind of node, exisiting only in view
 	 */
@@ -310,7 +446,7 @@ interface ComputedEdge {
 	label: string | null;
 	description?: string;
 	technology?: string;
-	relations: RelationID[];
+	relations: RelationId[];
 	kind?: RelationshipKind;
 	notation?: string;
 	notes?: string;
@@ -319,7 +455,7 @@ interface ComputedEdge {
 	head?: RelationshipArrowType;
 	tail?: RelationshipArrowType;
 	tags?: NonEmptyArray<Tag>;
-	navigateTo?: ViewID;
+	navigateTo?: ViewId;
 	/**
 	 * If this edge is derived from custom relationship predicate
 	 */
@@ -328,7 +464,7 @@ interface ComputedEdge {
 	 * For layouting purposes
 	 * @default 'forward'
 	 */
-	dir?: "forward" | "back";
+	dir?: "forward" | "back" | "both";
 }
 interface ViewWithHash {
 	/**
@@ -348,7 +484,7 @@ interface ViewAutoLayout {
 	nodeSep?: number;
 }
 interface ComputedElementView<ViewIDs extends string = string, Tags extends string = string> extends Omit<ElementView<ViewIDs, Tags>, "rules" | "docUri">, ViewWithHash, ViewWithNotation {
-	readonly extends?: ViewID<ViewIDs>;
+	readonly extends?: ViewId<ViewIDs>;
 	readonly autoLayout: ViewAutoLayout;
 	readonly nodes: ComputedNode[];
 	readonly edges: ComputedEdge[];
@@ -363,7 +499,19 @@ interface ComputedDynamicView<ViewIDs extends string = string, Tags extends stri
 	rules?: never;
 	docUri?: never;
 }
-type ComputedView<ViewIDs extends string = string, Tags extends string = string> = ComputedElementView<ViewIDs, Tags> | ComputedDynamicView<ViewIDs, Tags>;
+interface ComputedDeploymentView<ViewIDs extends string = string, Tags extends string = string> extends Omit<DeploymentView<ViewIDs, Tags>, "rules" | "docUri">, ViewWithHash, ViewWithNotation {
+	readonly autoLayout: ViewAutoLayout;
+	readonly nodes: ComputedNode[];
+	readonly edges: ComputedEdge[];
+	rules?: never;
+	docUri?: never;
+}
+type ComputedView<ViewIDs extends string = string, Tags extends string = string> = ComputedElementView<ViewIDs, Tags> | ComputedDynamicView<ViewIDs, Tags> | ComputedDeploymentView<ViewIDs, Tags>;
+declare namespace ComputedView {
+	function isDeployment(view: ComputedView): view is ComputedDeploymentView;
+	function isDynamic(view: ComputedView): view is ComputedDynamicView;
+	function isElement(view: ComputedView): view is ComputedElementView;
+}
 type BBox = {
 	x: number;
 	y: number;
@@ -377,6 +525,8 @@ interface DiagramNode extends ComputedNode {
 	labelBBox: BBox;
 }
 declare namespace DiagramNode {
+	function modelRef(node: DiagramNode): Fqn | null;
+	function deploymentRef(node: DiagramNode): Fqn | null;
 	/**
 	 * Nodes group is a special kind of node, exisiting only in view
 	 */
@@ -388,7 +538,7 @@ interface DiagramEdge extends ComputedEdge {
 	labelBBox?: BBox | null;
 	dotpos?: string;
 }
-interface DiagramView<ViewIDs extends string = string, Tags extends string = string> extends Omit<ComputedView<ViewIDs, Tags>, "nodes" | "edges" | "manualLayout"> {
+export interface DiagramView<ViewIDs extends string = string, Tags extends string = string> extends Omit<ComputedView<ViewIDs, Tags>, "nodes" | "edges" | "manualLayout"> {
 	readonly nodes: DiagramNode[];
 	readonly edges: DiagramEdge[];
 	readonly bounds: BBox;
@@ -420,12 +570,12 @@ type ViewManualLayout = {
 		labelBBox?: BBox;
 	}>;
 };
-type RelationID = Tagged<string, "RelationID">;
+type RelationId = Tagged<string, "RelationID">;
 type RelationshipKind<Kinds extends string = string> = Tagged<Kinds, "RelationshipKind">;
 type RelationshipLineType = "dashed" | "solid" | "dotted";
 type RelationshipArrowType = "none" | "normal" | "onormal" | "dot" | "odot" | "diamond" | "odiamond" | "crow" | "open" | "vee";
 interface Relation {
-	readonly id: RelationID;
+	readonly id: RelationId;
 	readonly source: Fqn;
 	readonly target: Fqn;
 	readonly title: string;
@@ -438,7 +588,7 @@ interface Relation {
 	readonly head?: RelationshipArrowType;
 	readonly tail?: RelationshipArrowType;
 	readonly links?: NonEmptyArray<Link>;
-	readonly navigateTo?: ViewID;
+	readonly navigateTo?: ViewId;
 	readonly metadata?: {
 		[key: string]: string;
 	};
@@ -451,120 +601,171 @@ interface RelationshipKindSpecification {
 	readonly head?: RelationshipArrowType;
 	readonly tail?: RelationshipArrowType;
 }
-interface BaseExpr {
-	where?: never;
-	element?: never;
-	custom?: never;
-	expanded?: never;
-	elementKind?: never;
-	elementTag?: never;
-	isEqual?: never;
-	isDescedants?: never;
-	wildcard?: never;
-	source?: never;
-	target?: never;
-	inout?: never;
-	incoming?: never;
-	outgoing?: never;
-	customRelation?: never;
-}
-interface ElementRefExpr extends Omit<BaseExpr, "element" | "isDescedants"> {
-	element: Fqn;
-	isDescedants?: boolean;
-}
-interface ExpandedElementExpr extends Omit<BaseExpr, "expanded"> {
-	expanded: Fqn;
+type DeploymentNodeKind<Kinds extends string = string> = Tagged<Kinds, "DeploymentNodeKind">;
+type PhysicalElementStyle = ElementStyle & {
+	readonly icon?: IconUrl;
+	readonly shape?: ElementShape;
+	readonly color?: Color;
+};
+interface DeploymentNodeKindSpecification {
+	readonly technology?: string;
+	readonly notation?: string;
+	readonly style: PhysicalElementStyle;
 }
-interface CustomElementExpr extends Omit<BaseExpr, "custom"> {
-	custom: {
-		expr: ElementExpression | ElementWhereExpr;
-		title?: string;
-		description?: string;
-		technology?: string;
-		notation?: string;
-		shape?: ElementShape;
-		color?: Color;
-		icon?: IconUrl;
-		border?: BorderStyle;
-		opacity?: number;
-		navigateTo?: ViewID;
-	};
+interface DeploymentNode {
+	readonly id: Fqn;
+	readonly kind: DeploymentNodeKind;
+	readonly title: string;
+	readonly description?: string | null;
+	readonly technology?: string | null;
+	readonly tags?: NonEmptyArray<Tag> | null;
+	readonly links?: NonEmptyArray<Link> | null;
+	readonly style?: PhysicalElementStyle;
+	readonly notation?: string;
+	readonly metadata?: Record<string, string>;
 }
-interface WildcardExpr extends Omit<BaseExpr, "wildcard"> {
-	wildcard: true;
+interface DeployedInstance {
+	/**
+	 * Format: `<DeploymentNode Fqn>.<Instance Id>`
+	 * i.e parent fqn is deployment target
+	 */
+	readonly id: Fqn;
+	readonly element: Fqn;
+	readonly title?: string;
+	readonly description?: string | null;
+	readonly technology?: string | null;
+	readonly tags?: NonEmptyArray<Tag> | null;
+	readonly links?: NonEmptyArray<Link> | null;
+	readonly style?: PhysicalElementStyle;
+	readonly notation?: string;
+	readonly metadata?: Record<string, string>;
 }
-interface ElementKindExpr extends Omit<BaseExpr, "elementKind" | "isEqual"> {
-	elementKind: ElementKind;
-	isEqual: boolean;
+type DeploymentElement = Simplify<MergeExclusive<DeploymentNode, DeployedInstance>>;
+declare namespace DeploymentElement {
+	const isDeploymentNode: (el: DeploymentElement) => el is DeploymentNode;
+	const isInstance: (el: DeploymentElement) => el is DeployedInstance;
 }
-interface ElementTagExpr extends Omit<BaseExpr, "elementTag" | "isEqual"> {
-	elementTag: Tag;
-	isEqual: boolean;
+interface DeploymentRef {
+	readonly id: Fqn;
+	readonly element?: Fqn;
 }
-type ElementExpression = ElementRefExpr | WildcardExpr | ElementKindExpr | ElementTagExpr | ExpandedElementExpr;
-interface ElementWhereExpr extends Omit<BaseExpr, "where"> {
-	where: {
-		expr: ElementExpression;
-		condition: WhereOperator<string, string>;
+interface DeploymentRelation {
+	readonly id: RelationId;
+	readonly source: DeploymentRef;
+	readonly target: DeploymentRef;
+	readonly title?: string;
+	readonly tags?: NonEmptyArray<Tag> | null;
+	readonly description?: string;
+	readonly technology?: string;
+	readonly kind?: RelationshipKind;
+	readonly color?: Color;
+	readonly line?: RelationshipLineType;
+	readonly head?: RelationshipArrowType;
+	readonly tail?: RelationshipArrowType;
+	readonly links?: NonEmptyArray<Link> | null;
+	readonly navigateTo?: ViewId;
+	readonly metadata?: {
+		[key: string]: string;
 	};
 }
-type ElementPredicateExpression = ElementExpression | ElementWhereExpr | CustomElementExpr;
-interface RelationExpr extends Omit<BaseExpr, "source" | "target"> {
-	source: ElementExpression;
-	target: ElementExpression;
-	isBidirectional?: boolean;
-}
-interface InOutExpr extends Omit<BaseExpr, "inout"> {
-	inout: ElementExpression;
-}
-interface IncomingExpr extends Omit<BaseExpr, "incoming"> {
-	incoming: ElementExpression;
-}
-interface OutgoingExpr extends Omit<BaseExpr, "outgoing"> {
-	outgoing: ElementExpression;
-}
-type RelationExpression = RelationExpr | InOutExpr | IncomingExpr | OutgoingExpr;
-interface RelationWhereExpr extends Omit<BaseExpr, "where"> {
-	where: {
-		expr: RelationExpression;
-		condition: WhereOperator<string, string>;
+type AllNever$1<Expressions> = UnionToIntersection<{
+	[Name in keyof Expressions]: {
+		-readonly [Key in keyof Expressions[Name]]?: never;
+	};
+}[keyof Expressions]>;
+type ExclusiveUnion<Expressions> = Expressions extends object ? {
+	[Name in keyof Expressions]: Simplify<Omit<AllNever$1<Expressions>, keyof Expressions[Name]> & Expressions[Name]>;
+}[keyof Expressions] : Expressions;
+declare namespace DeploymentRelationExpression {
+	type Direct = {
+		source: DeploymentElementExpression;
+		target: DeploymentElementExpression;
+		isBidirectional?: boolean;
+	};
+	const isDirect: (expr: DeploymentExpression) => expr is Direct;
+	type Incoming = {
+		incoming: DeploymentElementExpression;
 	};
+	const isIncoming: (expr: DeploymentExpression) => expr is Incoming;
+	type Outgoing = {
+		outgoing: DeploymentElementExpression;
+	};
+	const isOutgoing: (expr: DeploymentExpression) => expr is Outgoing;
+	type InOut = {
+		inout: DeploymentElementExpression;
+	};
+	const isInOut: (expr: DeploymentExpression) => expr is InOut;
 }
-interface CustomRelationExpr extends Omit<BaseExpr, "customRelation"> {
-	customRelation: {
-		relation: RelationExpression | RelationWhereExpr;
-		title?: string;
-		description?: string;
-		technology?: string;
-		notation?: string;
-		navigateTo?: ViewID;
-		notes?: string;
-		color?: Color;
-		line?: RelationshipLineType;
-		head?: RelationshipArrowType;
-		tail?: RelationshipArrowType;
+type DeploymentRelationExpression = ExclusiveUnion<{
+	Direct: DeploymentRelationExpression.Direct;
+	Incoming: DeploymentRelationExpression.Incoming;
+	Outgoing: DeploymentRelationExpression.Outgoing;
+	InOut: DeploymentRelationExpression.InOut;
+}>;
+declare namespace DeploymentElementExpression {
+	type Ref = {
+		ref: DeploymentRef;
+		selector?: "children" | "expanded" | "descendants";
+	};
+	const isRef: (expr: DeploymentExpression) => expr is Ref;
+	type Wildcard = {
+		wildcard: true;
 	};
+	const isWildcard: (expr: DeploymentExpression) => expr is Wildcard;
 }
-type RelationPredicateExpression = RelationExpression | RelationWhereExpr | CustomRelationExpr;
-type Expression = ElementPredicateExpression | RelationPredicateExpression;
-interface ParsedLikeC4Model<ElementKinds extends string = string, RelationKinds extends string = string, Tags extends string = string, Fqns extends string = string, Views extends string = string> {
+type DeploymentElementExpression = ExclusiveUnion<{
+	DeploymentRef: DeploymentElementExpression.Ref;
+	Wildcard: DeploymentElementExpression.Wildcard;
+}>;
+type DeploymentExpression = ExclusiveUnion<{
+	Element: DeploymentElementExpression;
+	Relation: DeploymentRelationExpression;
+}>;
+declare namespace DeploymentExpression {
+	type Element = DeploymentElementExpression;
+	type Relation = DeploymentRelationExpression;
+	const isElement: (expr: DeploymentExpression) => expr is DeploymentElementExpression;
+	const isRelation: (expr: DeploymentExpression) => expr is DeploymentRelationExpression;
+}
+interface ParsedLikeC4Model<ElementKinds extends string = string, RelationKinds extends string = string, Tags extends string = string, Fqns extends string = string, Views extends string = string, DeploymentFqns extends string = string> {
 	specification: {
 		tags: Tag<Tags>[];
 		elements: Record<ElementKinds, ElementKindSpecification>;
+		deployments: Record<DeploymentNodeKind, DeploymentNodeKindSpecification>;
 		relationships: Record<RelationKinds, RelationshipKindSpecification>;
 	};
 	elements: Record<Fqns, TypedElement<Fqns, ElementKinds, Tags>>;
-	relations: Record<RelationID, Relation>;
+	relations: Record<RelationId, Relation>;
 	globals: ModelGlobals;
 	views: Record<Views, LikeC4View<Views, Tags>>;
+	/**
+	 * Deployment Model.
+	 */
+	deployments: {
+		elements: Record<DeploymentFqns, DeploymentElement>;
+		relations: Record<RelationId, DeploymentRelation>;
+	};
 }
-interface ComputedLikeC4Model extends Omit<ParsedLikeC4Model, "views"> {
-	__?: never;
-	views: Record<ViewID, ComputedView>;
+type ParsedLikeC4ModelDump = {
+	elements: {
+		[kind: string]: object;
+	};
+	deployments: {
+		elements: {
+			[kind: string]: object;
+		};
+	};
+	views: {
+		[kind: string]: object;
+	};
+};
+interface AnyLikeC4Model<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;
+	views: Record<Views, ComputedView | DiagramView>;
 }
-interface LayoutedLikeC4Model extends Omit<ParsedLikeC4Model, "views"> {
+interface LayoutedLikeC4Model<Fqns extends string = string, DeploymentFqns extends string = string, Views extends string = string, Tags extends string = string> extends Omit<AnyLikeC4Model<Fqns, DeploymentFqns, Views, Tags, "layouted">, "views"> {
 	__: "layouted";
-	views: Record<ViewID, DiagramView>;
+	views: Record<Views, DiagramView<Views, Tags>>;
 }
 declare namespace ViewChange {
 	interface ChangeElementStyle {
@@ -591,374 +792,631 @@ declare namespace ViewChange {
 	}
 }
 type ViewChange = ViewChange.ChangeElementStyle | ViewChange.SaveManualLayout | ViewChange.ChangeAutoLayout;
-type Fqn$1 = LiteralUnion<Fqn, string>;
-type RelationID$1 = LiteralUnion<RelationID, string>;
-type ViewID$1 = LiteralUnion<ViewID, string>;
-type EdgeId$1 = LiteralUnion<EdgeId, string>;
 type IncomingFilter = "all" | "direct" | "to-descendants";
 type OutgoingFilter = "all" | "direct" | "from-descendants";
-type ElementOrFqn = Fqn$1 | {
-	id: Fqn$1;
+type IteratorLike<T> = IteratorObject<T, BuiltinIteratorReturn>;
+type WithId<Id> = {
+	id: Id;
+};
+type WithViews<Id extends string, ViewType> = {
+	views: Record<Id, ViewType>;
 };
-declare class LikeC4ViewModel {
-	readonly view: ComputedView;
-	readonly model: LikeC4Model<LikeC4ViewModel>;
-	private readonly _rootElements;
-	private readonly _elements;
-	private readonly _connections;
-	constructor(view: ComputedView, model: LikeC4Model<LikeC4ViewModel>);
-	get id(): ViewID<string>;
+interface Aux<Element extends string, Deployment extends string, Views extends string, ViewType> {
+	Fqn: IsLiteral<Element> extends true ? Fqn<Element> : Fqn;
+	Element: Element;
+	ElementOrFqn: Element | WithId<this["Fqn"]>;
+	DeploymentFqn: IsLiteral<Deployment> extends true ? Fqn<Deployment> : Fqn;
+	Deployment: Deployment;
+	DeploymentOrFqn: Deployment | WithId<this["DeploymentFqn"]>;
+	ViewId: IsLiteral<Views> extends true ? ViewId<Views> : ViewId;
+	ViewIdLiteral: Views;
+	ViewType: ViewType;
+	RelationId: RelationId;
+	NodeId: NodeId;
+	NodeIdLiteral: string;
+	EdgeId: EdgeId;
+	EdgeIdLiteral: string;
+	NodeOrId: LiteralUnion<this["NodeIdLiteral"], string> | WithId<this["NodeId"]>;
+	EdgeOrId: LiteralUnion<this["EdgeIdLiteral"], string> | WithId<this["EdgeId"]>;
+	Model: Simplify<Omit<AnyLikeC4Model, "views"> & WithViews<this["ViewId"], ViewType>>;
+}
+type AnyAux = Aux<string, string, string, any>;
+declare namespace Aux {
+	type FromModel<M> = M extends AnyLikeC4Model ? Aux<KeysOf<M["elements"]>, KeysOf<M["deployments"]["elements"]>, KeysOf<M["views"]>, M extends LayoutedLikeC4Model ? DiagramView<ViewId<KeysOf<M["views"]>>, string> : ComputedView<ViewId<KeysOf<M["views"]>>, string>> : never;
+	type FromDump<M> = M extends ParsedLikeC4ModelDump ? Aux<KeysOf<M["elements"]>, KeysOf<M["deployments"]["elements"]>, KeysOf<M["views"]>, DiagramView<ViewId<KeysOf<M["views"]>>, string>> : never;
+}
+type RelationshipsIterator<M extends AnyAux> = IteratorLike<RelationshipModel<M>>;
+declare class RelationshipModel<M extends AnyAux> {
+	readonly model: LikeC4Model<M>;
+	readonly $relationship: Relation;
+	readonly source: ElementModel<M>;
+	readonly target: ElementModel<M>;
+	/**
+	 * Common ancestor of the source and target elements.
+	 * Represents the boundary of the Relation.
+	 */
+	readonly boundary: ElementModel<M> | null;
+	constructor(model: LikeC4Model<M>, $relationship: Relation);
+	get id(): M["RelationId"];
+	get expression(): string;
+	get title(): string | null;
+	get technology(): string | null;
+	get description(): string | null;
+	get navigateTo(): LikeC4ViewModel<M> | null;
+	get tags(): ReadonlyArray<Tag>;
+	get links(): ReadonlyArray<Link>;
+	/**
+	 * Iterate over all views that include this relationship.
+	 */
+	views(): ViewsIterator<M>;
+}
+type ElementsIterator<M extends AnyAux> = IteratorLike<ElementModel<M>>;
+declare class ElementModel<M extends AnyAux> {
+	readonly model: LikeC4Model<M>;
+	readonly $element: Element$1;
+	constructor(model: LikeC4Model<M>, $element: Element$1);
+	get id(): M["Fqn"];
+	get kind(): ElementKind;
+	get shape(): ElementShape;
+	get color(): ThemeColor;
+	get tags(): ReadonlyArray<Tag>;
 	get title(): string;
-	get viewOf(): LikeC4Model.ElementModel<LikeC4ViewModel>;
-	get tags(): Tag[];
-	roots(): ReadonlyArray<LikeC4ViewModel.Element>;
-	elements(): ReadonlyArray<LikeC4ViewModel.Element>;
-	element(id: Fqn$1): LikeC4ViewModel.Element;
-	hasElement(id: Fqn$1): boolean;
-	connections(): ReadonlyArray<LikeC4ViewModel.Connection>;
-	connection(id: EdgeId$1): LikeC4ViewModel.Connection;
-	findConnections(source: ElementOrFqn, target: ElementOrFqn, direction?: "both" | "direct"): ReadonlyArray<LikeC4ViewModel.Connection>;
-	parent(element: ElementOrFqn): LikeC4ViewModel.Element | null;
-	children(element: ElementOrFqn): ReadonlyArray<LikeC4ViewModel.Element>;
-	siblings(element: ElementOrFqn): ReadonlyArray<LikeC4ViewModel.Element>;
+	get description(): string | null;
+	get technology(): string | null;
+	get links(): ReadonlyArray<Link>;
+	get parent(): ElementModel<M> | null;
+	get defaultView(): LikeC4ViewModel<M> | null;
 	/**
 	 * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
 	 * (from closest to root)
 	 */
-	ancestors(element: ElementOrFqn): ReadonlyArray<LikeC4ViewModel.Element>;
-	descendants(element: ElementOrFqn): ReadonlyArray<LikeC4ViewModel.Element>;
-	incoming(element: ElementOrFqn, filter?: IncomingFilter): ReadonlyArray<LikeC4ViewModel.Connection>;
-	incomers(element: ElementOrFqn, filter?: IncomingFilter): ReadonlyArray<LikeC4ViewModel.Element>;
+	ancestors(): ElementsIterator<M>;
 	/**
-	 * Outgoing relationships from the element and its descendants
+	 * Returns the common ancestor of this element and another element.
+	 */
+	commonAncestor(another: ElementModel<M>): ElementModel<M> | null;
+	children(): ReadonlySet<ElementModel<M>>;
+	/**
+	 * Get all descendant elements (i.e. children, children’s children, etc.)
+	 */
+	descendants(): ElementsIterator<M>;
+	/**
+	 * Get all sibling (i.e. same parent)
 	 */
-	outgoing(element: ElementOrFqn, filter?: OutgoingFilter): ReadonlyArray<LikeC4ViewModel.Connection>;
-	outgoers(element: ElementOrFqn, filter?: OutgoingFilter): ReadonlyArray<LikeC4ViewModel.Element>;
-}
-declare namespace LikeC4ViewModel {
-	/**
-	 * Represents an element in the view. (Diagram node)
-	 * All methods are view-scoped, i.e. `children` returns only children of the element in the view.
-	 */
-	class Element {
-		readonly node: ComputedNode;
-		private readonly viewmodel;
-		constructor(node: ComputedNode, viewmodel: LikeC4ViewModel);
-		get id(): NodeId<string>;
-		get title(): string;
-		get kind(): ElementKind;
-		get isRoot(): boolean;
-		get hasNested(): boolean;
-		get shape(): ElementShape;
-		get color(): Color;
-		get tags(): Tag[];
-		model(): LikeC4Model.ElementModel<LikeC4ViewModel>;
-		parent(): LikeC4ViewModel.Element | null;
-		metadata(key: string): string | undefined;
-		metadata(key: string, defaultValue: string): string;
-		hasMetadata(key: string): boolean;
-		ancestors(): ReadonlyArray<LikeC4ViewModel.Element>;
-		siblings(): ReadonlyArray<LikeC4ViewModel.Element>;
-		descendants(): ReadonlyArray<LikeC4ViewModel.Element>;
-		children(): ReadonlyArray<LikeC4ViewModel.Element>;
-		incoming(filter?: "all" | "direct" | "to-descendants"): ReadonlyArray<LikeC4ViewModel.Connection>;
-		incomers(filter?: "all" | "direct" | "to-descendants"): ReadonlyArray<LikeC4ViewModel.Element>;
-		outgoing(filter?: OutgoingFilter): ReadonlyArray<LikeC4ViewModel.Connection>;
-		outgoers(filter?: OutgoingFilter): ReadonlyArray<LikeC4ViewModel.Element>;
-		connectionsTo(target: Fqn$1 | LikeC4ViewModel.Element): ReadonlyArray<LikeC4ViewModel.Connection>;
+	siblings(): ElementsIterator<M>;
+	/**
+	 * Resolve siblings of the element and its ancestors
+	 *  (from closest to root)
+	 */
+	ascendingSiblings(): ElementsIterator<M>;
+	incoming(filter?: IncomingFilter): RelationshipsIterator<M>;
+	incomers(filter?: IncomingFilter): ElementsIterator<M>;
+	outgoing(filter?: OutgoingFilter): RelationshipsIterator<M>;
+	outgoers(filter?: OutgoingFilter): ElementsIterator<M>;
+	protected cachedOutgoing: Set<RelationshipModel<M>> | null;
+	protected cachedIncoming: Set<RelationshipModel<M>> | null;
+	get allOutgoing(): ReadonlySet<RelationshipModel<M>>;
+	get allIncoming(): ReadonlySet<RelationshipModel<M>>;
+	/**
+	 * Iterate over all views that include this element.
+	 */
+	views(): ViewsIterator<M>;
+	/**
+	 * Iterate over all views that scope this element.
+	 * It is possible that element is not included in the view.
+	 */
+	scopedViews(): ViewsIterator<M>;
+	/**
+	 * @returns true if the element is deployed
+	 */
+	isDeployed(): boolean;
+	deployments(): DeployedInstancesIterator<M>;
+}
+type NodesIterator<M extends AnyAux, V extends ComputedView | DiagramView> = IteratorLike<NodeModel<M, V>>;
+declare namespace NodeModel {
+	interface WithParent<M extends AnyAux, V extends ComputedView | DiagramView> extends NodeModel<M, V> {
+		parent: NodeModel<M, V>;
+	}
+	interface WithElement<M extends AnyAux, V extends ComputedView | DiagramView> extends NodeModel<M, V> {
+		kind: ElementKind;
+		element: ElementModel<M>;
+	}
+	interface WithDeploymentElement<M extends AnyAux, V extends ComputedView | DiagramView> extends NodeModel<M, V> {
+		kind: DeploymentNodeKind;
+		deployment: DeploymentElementModel<M>;
+	}
+	interface WithDeployedInstance<M extends AnyAux, V extends ComputedView | DiagramView> extends NodeModel<M, V> {
+		kind: "instance";
+		element: ElementModel<M>;
+		deployment: DeployedInstanceModel<M>;
 	}
+	interface IsGroup<M extends AnyAux, V extends ComputedView | DiagramView> extends NodeModel<M, V> {
+		kind: typeof ElementKind.Group;
+		element: null;
+		deployment: null;
+	}
+}
+declare class NodeModel<M extends AnyAux, V extends ComputedView | DiagramView = M["ViewType"]> {
+	readonly $view: LikeC4ViewModel<M, V>;
+	readonly $node: V["nodes"][number];
+	constructor($view: LikeC4ViewModel<M, V>, $node: V["nodes"][number]);
+	get id(): NodeId;
+	get title(): string;
+	get kind(): ElementKind | DeploymentNodeKind | typeof ElementKind.Group | "instance";
+	get description(): string | null;
+	get technology(): string | null;
+	get parent(): NodeModel<M, V> | null;
+	get element(): ElementModel<M> | null;
+	get deployment(): DeploymentElementModel<M> | null;
+	get shape(): ElementShape;
+	get color(): Color;
+	get tags(): ReadonlyArray<Tag>;
+	get links(): ReadonlyArray<Link>;
+	get navigateTo(): LikeC4ViewModel<M> | null;
 	/**
-	 * Represents a connection between two elements.
-	 * May be source from multiple model relationships.
-	 */
-	class Connection {
-		readonly edge: ComputedEdge;
-		private readonly viewmodel;
-		constructor(edge: ComputedEdge, viewmodel: LikeC4ViewModel);
-		get id(): EdgeId;
-		get source(): LikeC4ViewModel.Element;
-		get target(): LikeC4ViewModel.Element;
-		get tags(): Tag[];
-		/**
-		 * Model relationships
-		 */
-		relationships(): ReadonlyArray<LikeC4Model.Relationship<LikeC4ViewModel>>;
+	 * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
+	 * (from closest to root)
+	 */
+	ancestors(): NodesIterator<M, V>;
+	children(): NodesIterator<M, V>;
+	sublings(): NodesIterator<M, V>;
+	incoming(filter?: IncomingFilter): EdgesIterator<M, V>;
+	incomers(filter?: IncomingFilter): NodesIterator<M, V>;
+	outgoing(filter?: OutgoingFilter): EdgesIterator<M, V>;
+	outgoers(filter?: OutgoingFilter): NodesIterator<M, V>;
+	isDiagramNode(): this is NodeModel<M, DiagramView>;
+	hasChildren(): boolean;
+	hasParent(): this is NodeModel.WithParent<M, V>;
+	/**
+	 * Check if this node references to logical model element.
+	 */
+	hasElement(): this is NodeModel.WithElement<M, V>;
+	/**
+	 * Check if this node references to deployment element (Node or Instance).
+	 */
+	hasDeployment(): this is NodeModel.WithDeploymentElement<M, V>;
+	/**
+	 * Check if this node references to deployed instance
+	 * Deployed instance always references to element and deployment element.
+	 */
+	hasDeployedInstance(): this is NodeModel.WithDeployedInstance<M, V>;
+	isGroup(): this is NodeModel.IsGroup<M, V>;
+}
+type EdgesIterator<M extends AnyAux, V extends ComputedView | DiagramView> = IteratorLike<EdgeModel<M, V>>;
+declare class EdgeModel<M extends AnyAux, V extends ComputedView | DiagramView = M["ViewType"]> {
+	readonly view: LikeC4ViewModel<M, V>;
+	readonly $edge: V["edges"][number];
+	readonly source: NodeModel<M, V>;
+	readonly target: NodeModel<M, V>;
+	constructor(view: LikeC4ViewModel<M, V>, $edge: V["edges"][number], source: NodeModel<M, V>, target: NodeModel<M, V>);
+	get id(): M["EdgeId"];
+	get parent(): NodeModel<M, V> | null;
+	get label(): string | null;
+	get description(): string | null;
+	get technology(): string | null;
+	hasParent(): this is EdgeModel$1.WithParent<M, V>;
+	get tags(): ReadonlyArray<Tag>;
+	get stepNumber(): number | null;
+	get navigateTo(): LikeC4ViewModel<M> | null;
+	isStep(): this is EdgeModel$1.StepEdge<M, ComputedDynamicView>;
+	relationships(type: "model"): IteratorLike<RelationshipModel<M>>;
+	relationships(type: "deployment"): IteratorLike<DeploymentRelationModel<M>>;
+	relationships(type?: "model" | "deployment"): IteratorLike<LikeC4Model.AnyRelation<M>>;
+	includesRelation(rel: M["RelationId"]): boolean;
+}
+declare namespace EdgeModel$1 {
+	interface StepEdge<M extends AnyAux, V extends ComputedView | DiagramView> extends EdgeModel<M, V> {
+		id: StepEdgeId;
+		stepNumber: number;
+	}
+	interface WithParent<M extends AnyAux, V extends ComputedView | DiagramView> extends EdgeModel<M, V> {
+		parent: NodeModel<M, V>;
 	}
 }
-type PickBySource<Source> = Source extends LikeC4Model.Layouted.SourceModel ? LikeC4Model.Layouted : Source extends LikeC4Model.Computed.SourceModel ? LikeC4Model.Computed : never;
-export declare class LikeC4Model<M extends LikeC4Model.ViewModel = LikeC4Model.ViewModel> {
-	readonly type: LikeC4Model.ModelType<M>;
-	readonly sourcemodel: LikeC4Model.SourceModel<M>;
-	private _elements;
-	private _parents;
-	private _children;
-	private _rootElements;
-	private _relations;
-	private _incoming;
-	private _outgoing;
-	private _internal;
-	private _cacheAscendingSiblings;
-	private _views;
-	constructor(type: LikeC4Model.ModelType<M>, sourcemodel: LikeC4Model.SourceModel<M>, elements: Element$1[], relations: Relation[], views: LikeC4Model.SourceModel<M>["views"], ViewModelClass: Class<M>);
+type ViewsIterator<M extends AnyAux> = IteratorLike<LikeC4ViewModel<M>>;
+declare class LikeC4ViewModel<M extends AnyAux, V extends ComputedView | DiagramView = M["ViewType"]> {
+	#private;
+	readonly $model: LikeC4Model<M>;
+	readonly $view: V;
+	constructor($model: LikeC4Model<M>, $view: V);
+	get __(): NonNullable<M["ViewType"]["__"]>;
+	get id(): M["ViewId"];
+	get title(): string | null;
+	get tags(): ReadonlyArray<Tag>;
+	get links(): ReadonlyArray<Link>;
+	get viewOf(): ElementModel<M> | null;
+	/**
+	 * All tags from nodes and edges.
+	 */
+	get includedTags(): ReadonlyArray<Tag>;
+	roots(): NodesIterator<M, V>;
+	/**
+	 * Iterate over all nodes that have children.
+	 */
+	compounds(): NodesIterator<M, V>;
+	/**
+	 * Get node by id.
+	 * @throws Error if node is not found.
+	 */
+	node(node: M["NodeOrId"]): NodeModel<M, V>;
+	/**
+	 * Find node by id.
+	 */
+	findNode(node: M["NodeOrId"]): NodeModel<M, V> | null;
+	/**
+	 * Iterate over all nodes.
+	 */
+	nodes(): NodesIterator<M, V>;
+	/**
+	 * Find edge by id.
+	 * @param edge Edge or id
+	 * @returns EdgeModel
+	 */
+	edge(edge: M["EdgeOrId"]): EdgeModel<M, V>;
+	findEdge(edge: M["EdgeOrId"]): EdgeModel<M, V> | null;
+	/**
+	 * Iterate over all edges.
+	 */
+	edges(): EdgesIterator<M, V>;
+	/**
+	 * Iterate over all edges.
+	 */
+	edgesWithRelation(relation: M["RelationId"]): EdgesIterator<M, V>;
+	/**
+	 * Nodes that have references to elements from logical model.
+	 */
+	elements(): IteratorLike<NodeModel.WithElement<M, V>>;
+	includesElement(elementId: M["Element"]): boolean;
+	includesDeployment(deploymentId: M["Deployment"]): boolean;
+	includesRelation(relationId: M["RelationId"]): boolean;
+	/**
+	 * Below are type guards.
+	 */
+	isComputed(): this is LikeC4ViewModel<M, ComputedView>;
+	isDiagram(): this is LikeC4ViewModel<M, DiagramView>;
+	isElementView(): this is LikeC4ViewModel<M, ComputedElementView>;
+	isDeploymentView(): this is LikeC4ViewModel<M, ComputedDeploymentView>;
+	isDynamicView(): this is LikeC4ViewModel<M, ComputedDynamicView>;
+}
+declare class LikeC4DeploymentModel<M extends AnyAux = AnyAux> {
+	#private;
+	readonly $model: LikeC4Model<M>;
+	readonly $deployments: AnyLikeC4Model["deployments"];
+	constructor($model: LikeC4Model<M>, $deployments: AnyLikeC4Model["deployments"]);
+	element(el: M["DeploymentOrFqn"]): DeploymentElementModel<M>;
+	findElement(el: M["Deployment"]): DeploymentElementModel<M> | null;
+	node(el: M["DeploymentOrFqn"]): DeploymentNodeModel<M>;
+	findNode(el: M["Deployment"]): DeploymentNodeModel<M> | null;
+	instance(el: M["DeploymentOrFqn"]): DeployedInstanceModel<M>;
+	findInstance(el: M["Deployment"]): DeployedInstanceModel<M> | null;
 	/**
 	 * Returns the root elements of the model.
 	 */
-	roots(): ReadonlyArray<LikeC4Model.ElementModel<M>>;
+	roots(): DeploymentNodesIterator<M>;
 	/**
 	 * Returns all elements in the model.
 	 */
-	elements(): ReadonlyArray<LikeC4Model.ElementModel<M>>;
+	elements(): DeploymentElementsIterator<M>;
 	/**
-	 * Returns a specific element by its FQN.
+	 * Returns all elements in the model.
 	 */
-	element(id: Fqn$1): LikeC4Model.ElementModel<M>;
+	nodes(): DeploymentNodesIterator<M>;
+	instances(): DeployedInstancesIterator<M>;
 	/**
-	 * Returns all relationships in the model.
+	 * Iterate over all instances of the given logical element.
 	 */
-	relationships(): ReadonlyArray<LikeC4Model.Relationship<M>>;
+	instancesOf(element: M["ElementOrFqn"]): DeployedInstancesIterator<M>;
+	deploymentRef(ref: DeploymentRef): DeploymentElementModel<M> | NestedElementOfDeployedInstanceModel<M>;
 	/**
-	 * Returns a specific relationship by its ID.
+	 * Returns all relationships in the model.
 	 */
-	relationship(id: RelationID$1): LikeC4Model.Relationship<M>;
+	relationships(): IteratorLike<DeploymentRelationModel<M>>;
 	/**
-	 * Returns all views in the model.
+	 * Returns a specific relationship by its ID.
 	 */
-	views(): ReadonlyArray<M>;
+	relationship(id: M["RelationId"]): DeploymentRelationModel<M>;
+	findRelationship(id: LiteralUnion<M["RelationId"], string>): DeploymentRelationModel<M> | null;
 	/**
-	 * Returns a specific view by its ID.
+	 * Returns all deployment views in the model.
 	 */
-	view(viewId: ViewID$1): M;
+	views(): IteratorLike<LikeC4ViewModel<M, ComputedDeploymentView>>;
 	/**
 	 * Returns the parent element of given element.
 	 * @see ancestors
 	 */
-	parent(element: ElementOrFqn): LikeC4Model.ElementModel<M> | null;
+	parent(element: M["DeploymentOrFqn"]): DeploymentNodeModel<M> | null;
 	/**
 	 * Get all children of the element (only direct children),
 	 * @see descendants
 	 */
-	children(element: ElementOrFqn): ReadonlyArray<LikeC4Model.ElementModel<M>>;
+	children(element: M["DeploymentOrFqn"]): ReadonlySet<DeploymentElementModel<M>>;
 	/**
 	 * Get all sibling (i.e. same parent)
 	 */
-	siblings(element: ElementOrFqn): ReadonlyArray<LikeC4Model.ElementModel<M>>;
+	siblings(element: M["DeploymentOrFqn"]): DeploymentElementsIterator<M>;
 	/**
 	 * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
 	 * (from closest to root)
 	 */
-	ancestors(element: ElementOrFqn): ReadonlyArray<LikeC4Model.ElementModel<M>>;
+	ancestors(element: M["DeploymentOrFqn"]): DeploymentNodesIterator<M>;
 	/**
 	 * Get all descendant elements (i.e. children, children’s children, etc.)
 	 */
-	descendants(element: ElementOrFqn): ReadonlyArray<LikeC4Model.ElementModel<M>>;
+	descendants(element: M["DeploymentOrFqn"]): DeploymentElementsIterator<M>;
 	/**
 	 * Incoming relationships to the element and its descendants
 	 * @see incomers
 	 */
-	incoming(element: ElementOrFqn, filter?: IncomingFilter): ReadonlyArray<LikeC4Model.Relationship<M>>;
-	/**
-	 * Source elements of incoming relationships
-	 */
-	incomers(element: ElementOrFqn, filter?: IncomingFilter): ReadonlyArray<LikeC4Model.ElementModel<M>>;
+	incoming(element: M["DeploymentOrFqn"], filter?: IncomingFilter): IteratorLike<DeploymentRelationModel<M>>;
 	/**
 	 * Outgoing relationships from the element and its descendants
 	 * @see outgoers
 	 */
-	outgoing(element: ElementOrFqn, filter?: OutgoingFilter): ReadonlyArray<LikeC4Model.Relationship<M>>;
+	outgoing(element: M["DeploymentOrFqn"], filter?: OutgoingFilter): IteratorLike<DeploymentRelationModel<M>>;
+	private addElement;
+	private addRelation;
+}
+type DeploymentElementsIterator<M extends AnyAux> = IteratorLike<DeploymentElementModel<M>>;
+type DeployedInstancesIterator<M extends AnyAux> = IteratorLike<DeployedInstanceModel<M>>;
+type DeploymentNodesIterator<M extends AnyAux> = IteratorLike<DeploymentNodeModel<M>>;
+declare abstract class DeploymentElementModel<M extends AnyAux = AnyAux> {
+	abstract readonly $model: LikeC4DeploymentModel<M>;
+	abstract readonly $node: DeploymentNode | DeployedInstance;
+	get id(): M["DeploymentFqn"];
+	get style(): SetRequired<PhysicalElementStyle, "shape" | "color">;
+	get shape(): ElementShape;
+	get color(): ThemeColor;
+	get tags(): ReadonlyArray<Tag>;
+	get title(): string;
+	get description(): string | null;
+	get technology(): string | null;
+	get parent(): DeploymentNodeModel<M> | null;
+	get links(): ReadonlyArray<Link>;
 	/**
-	 * Target elements of outgoing relationships
+	 * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
+	 * (from closest to root)
 	 */
-	outgoers(element: ElementOrFqn, filter?: OutgoingFilter): ReadonlyArray<LikeC4Model.ElementModel<M>>;
+	ancestors(): DeploymentNodesIterator<M>;
 	/**
-	 * Relationships inside the element, among descendants
+	 * Returns the common ancestor of this element and another element.
 	 */
-	internal(element: ElementOrFqn): ReadonlyArray<LikeC4Model.Relationship<M>>;
+	commonAncestor(another: DeploymentElementModel<M>): DeploymentNodeModel<M> | null;
 	/**
-	 * Resolve siblings of the element and siblings of ancestors
+	 * Get all sibling (i.e. same parent)
+	 */
+	siblings(): DeploymentElementsIterator<M>;
+	/**
+	 * Check if the element is a sibling of another element
+	 */
+	isSibling(other: DeploymentElementModel<M>): boolean;
+	/**
+	 * Resolve siblings of the element and its ancestors
 	 *  (from closest to root)
 	 */
-	ascendingSiblings(element: ElementOrFqn): ReadonlyArray<LikeC4Model.ElementModel<M>>;
+	ascendingSiblings(): DeploymentElementsIterator<M>;
+	incoming(filter?: IncomingFilter): IteratorLike<DeploymentRelationModel<M>>;
+	outgoing(filter?: OutgoingFilter): IteratorLike<DeploymentRelationModel<M>>;
+	incomers(filter?: IncomingFilter): IteratorLike<DeploymentRelationEndpoint<M>>;
+	outgoers(filter?: OutgoingFilter): IteratorLike<DeploymentRelationEndpoint<M>>;
 	/**
-	 * Resolve all views that contain the element
+	 * Iterate over all views that include this deployment element.
 	 */
-	viewsWithElement(element: ElementOrFqn): ReadonlyArray<M>;
-	private addElement;
-	private addRelation;
-	private _childrenOf;
-	private _incomingTo;
-	private _outgoingFrom;
-	private _internalOf;
+	views(): IteratorLike<LikeC4ViewModel<M, ComputedDeploymentView>>;
+	isDeploymentNode(): this is DeploymentNodeModel<M>;
+	isInstance(): this is DeployedInstanceModel<M>;
+	abstract outgoingFromModel(): RelationshipsIterator<M>;
+	abstract incomingFromModel(): RelationshipsIterator<M>;
+	protected cachedOutgoing: RelationshipsAccum<M> | null;
+	protected cachedIncoming: RelationshipsAccum<M> | null;
+	get allOutgoing(): RelationshipsAccum<M>;
+	get allIncoming(): RelationshipsAccum<M>;
 }
-export declare namespace LikeC4Model {
-	function create(source: LikeC4Model.SourceModel): PickBySource<typeof source>;
-	function computed(source: ComputedLikeC4Model): LikeC4Model<LikeC4ViewModel>;
-	function layouted(source: LayoutedLikeC4Model): LikeC4Model<LikeC4DiagramModel>;
-	function isModel(model: any): model is LikeC4Model;
-	type SourceModel<M extends ViewModel = ViewModel> = M extends LikeC4DiagramModel ? LayoutedLikeC4Model : ComputedLikeC4Model;
-	type ViewModel = LikeC4ViewModel | LikeC4DiagramModel;
-	namespace ViewModel {
-		type ElementModel = LikeC4ViewModel.Element | LikeC4DiagramModel.Element;
-		type Relationship = LikeC4Model.Relationship<ViewModel>;
-		function isLayouted(model: ViewModel): model is LikeC4DiagramModel;
-	}
-	type Computed = LikeC4Model<LikeC4ViewModel>;
-	namespace Computed {
-		type ViewModel = LikeC4ViewModel;
-		type SourceModel = LikeC4Model.SourceModel<ViewModel>;
-	}
-	type Layouted = LikeC4Model<LikeC4DiagramModel>;
-	namespace Layouted {
-		type ViewModel = LikeC4DiagramModel;
-		type SourceModel = LikeC4Model.SourceModel<ViewModel>;
-	}
-	type ModelType<M extends ViewModel = ViewModel> = M extends LikeC4DiagramModel ? "layouted" : M extends LikeC4ViewModel ? "computed" : never;
-	function isLayouted(model: LikeC4Model): model is Layouted;
-	class Relationship<M extends ViewModel = ViewModel> {
-		readonly relationship: Relation;
-		private readonly model;
-		constructor(relationship: Relation, model: LikeC4Model<M>);
-		get id(): RelationID;
-		get title(): string;
-		get kind(): RelationshipKind<string>;
-		get tags(): Tag[];
-		get source(): ElementModel<M>;
-		get target(): ElementModel<M>;
-		metadata(key: string): string | undefined;
-		metadata(key: string, defaultValue: string): string;
-		hasMetadata(key: string): boolean;
-	}
-	class ElementModel<M extends ViewModel = ViewModel> {
-		readonly element: Element$1;
-		private readonly model;
-		constructor(element: Element$1, model: LikeC4Model<M>);
-		get id(): Fqn<string>;
-		get title(): string;
-		get kind(): ElementKind;
-		get isRoot(): boolean;
-		get hasNested(): boolean;
-		get shape(): ElementShape;
-		get color(): Color;
-		get tags(): Tag[];
-		parent(): ElementModel<M> | null;
-		metadata(key: string): string | undefined;
-		metadata(key: string, defaultValue: string): string;
-		hasMetadata(key: string): boolean;
-		ancestors(): readonly ElementModel<M>[];
-		siblings(): readonly ElementModel<M>[];
-		descendants(): readonly ElementModel<M>[];
-		children(): readonly ElementModel<M>[];
-		/**
-		 * First 'view of' current element
-		 */
-		viewOf(): M;
-		/**
-		 * All views 'view of' current element
-		 */
-		viewsOf(): M[];
-		/**
-		 * Views that contain this element
-		 */
-		views(): readonly M[];
-		incoming(filter?: IncomingFilter): readonly Relationship<M>[];
-		incomers(filter?: IncomingFilter): readonly ElementModel<M>[];
-		outgoing(filter?: OutgoingFilter): readonly Relationship<M>[];
-		outgoers(filter?: OutgoingFilter): readonly ElementModel<M>[];
-		internal(): readonly Relationship<M>[];
-		/**
-		 * Resolve siblings of the element and siblings of ancestors
-		 *  (from closest to root)
-		 */
-		ascendingSiblings(): readonly ElementModel<M>[];
-	}
+declare class DeploymentNodeModel<M extends AnyAux = AnyAux> extends DeploymentElementModel<M> {
+	readonly $model: LikeC4DeploymentModel<M>;
+	readonly $node: DeploymentNode;
+	constructor($model: LikeC4DeploymentModel<M>, $node: DeploymentNode);
+	get kind(): DeploymentNodeKind;
+	children(): ReadonlySet<DeploymentElementModel<M>>;
+	descendants(): DeploymentElementsIterator<M>;
+	isDeploymentNode(): this is DeploymentNodeModel<M>;
+	/**
+	 * Iterate over all instances nested in this deployment node.
+	 */
+	instances(): DeployedInstancesIterator<M>;
+	/**
+	 * Returns deployed instance inside this deployment node
+	 * if only there are no more instances
+	 */
+	onlyOneInstance(): DeployedInstanceModel<M> | null;
+	/**
+	 * Cached result of relationships from instances
+	 */
+	private _relationshipsFromInstances;
+	private relationshipsFromInstances;
+	/**
+	 * We return only relationships that are not already present in nested instances
+	 */
+	outgoingFromModel(): RelationshipsIterator<M>;
+	/**
+	 * We return only relationships that are not already present in nested instances
+	 */
+	incomingFromModel(): RelationshipsIterator<M>;
 }
-declare class LikeC4DiagramModel {
-	readonly view: DiagramView;
-	readonly model: LikeC4Model.Layouted;
-	private readonly _rootElements;
-	private readonly _elements;
-	private readonly _connections;
-	constructor(view: DiagramView, model: LikeC4Model.Layouted);
-	get isDynamic(): boolean;
-	get id(): ViewID<string>;
+declare class DeployedInstanceModel<M extends AnyAux = AnyAux> extends DeploymentElementModel<M> {
+	readonly $model: LikeC4DeploymentModel<M>;
+	readonly $instance: DeployedInstance;
+	readonly $element: ElementModel<M>;
+	constructor($model: LikeC4DeploymentModel<M>, $instance: DeployedInstance, $element: ElementModel<M>);
+	get parent(): DeploymentNodeModel<M>;
+	get $node(): DeployedInstance;
+	get style(): SetRequired<PhysicalElementStyle, "shape" | "color">;
+	get shape(): ElementShape;
+	get color(): ThemeColor;
+	get tags(): ReadonlyArray<Tag>;
+	get title(): string;
+	get description(): string | null;
+	get technology(): string | null;
+	get links(): ReadonlyArray<Link>;
+	isInstance(): this is DeployedInstanceModel<M>;
+	outgoingFromModel(): RelationshipsIterator<M>;
+	incomingFromModel(): RelationshipsIterator<M>;
+}
+declare class NestedElementOfDeployedInstanceModel<M extends AnyAux> {
+	readonly instance: DeployedInstanceModel<M>;
+	readonly element: ElementModel<M>;
+	constructor(instance: DeployedInstanceModel<M>, element: ElementModel<M>);
+	get id(): M["DeploymentFqn"];
+	get style(): SetRequired<PhysicalElementStyle, "shape" | "color">;
+	get shape(): ElementShape;
+	get color(): ThemeColor;
 	get title(): string;
-	get viewOf(): LikeC4Model.ElementModel<LikeC4DiagramModel>;
-	get tags(): Tag[];
-	roots(): ReadonlyArray<LikeC4DiagramModel.Element>;
-	elements(): ReadonlyArray<LikeC4DiagramModel.Element>;
-	element(id: Fqn$1): LikeC4DiagramModel.Element;
-	hasElement(id: Fqn$1): boolean;
-	connections(): ReadonlyArray<LikeC4DiagramModel.Connection>;
-	connection(id: EdgeId$1): LikeC4DiagramModel.Connection;
-	findConnections(source: ElementOrFqn, target: ElementOrFqn, direction?: "both" | "direct"): ReadonlyArray<LikeC4DiagramModel.Connection>;
-	parent(element: ElementOrFqn): LikeC4DiagramModel.Element | null;
-	children(element: ElementOrFqn): ReadonlyArray<LikeC4DiagramModel.Element>;
-	siblings(element: ElementOrFqn): ReadonlyArray<LikeC4DiagramModel.Element>;
+	get description(): string | null;
+	get technology(): string | null;
+	isDeploymentNode(): this is DeploymentNodeModel<M>;
+	isInstance(): this is DeployedInstanceModel<M>;
+}
+type DeploymentRelationEndpoint<M extends AnyAux> = DeploymentElementModel<M> | NestedElementOfDeployedInstanceModel<M>;
+declare class DeploymentRelationModel<M extends AnyAux> {
+	readonly $model: LikeC4DeploymentModel<M>;
+	readonly $relationship: DeploymentRelation;
+	boundary: DeploymentNodeModel<M> | null;
+	source: DeploymentRelationEndpoint<M>;
+	target: DeploymentRelationEndpoint<M>;
+	constructor($model: LikeC4DeploymentModel<M>, $relationship: DeploymentRelation);
+	get id(): M["RelationId"];
+	get expression(): string;
+	get title(): string | null;
+	get technology(): string | null;
+	get description(): string | null;
+	get tags(): ReadonlyArray<Tag>;
+	get navigateTo(): LikeC4ViewModel<M> | null;
+	get links(): ReadonlyArray<Link>;
+	views(): IteratorLike<LikeC4ViewModel<M, ComputedDeploymentView>>;
+}
+declare class RelationshipsAccum<M extends AnyAux> {
+	readonly model: ReadonlySet<RelationshipModel<M>>;
+	readonly deployment: ReadonlySet<DeploymentRelationModel<M>>;
+	/**
+	 * @param model relationships from logical model
+	 * @param deployment relationships from deployment model
+	 */
+	constructor(model: ReadonlySet<RelationshipModel<M>>, deployment: ReadonlySet<DeploymentRelationModel<M>>);
+	get isEmpty(): boolean;
+	get nonEmpty(): boolean;
+	get size(): number;
+	/**
+	 * Returns new Accum containing all the elements which are both in this and otherAccum
+	 */
+	intersect(otherAccum: RelationshipsAccum<M>): RelationshipsAccum<M>;
+	/**
+	 * Returns new Accum containing all the elements which are both in this and otherAccum
+	 */
+	difference(otherAccum: RelationshipsAccum<M>): RelationshipsAccum<M>;
+	/**
+	 * Returns new Accum containing all the elements from both
+	 */
+	union(otherAccum: RelationshipsAccum<M>): RelationshipsAccum<M>;
+}
+export declare class LikeC4Model<M extends AnyAux = LikeC4Model.Any> {
+	#private;
+	readonly $model: M["Model"];
+	/**
+	 * Only available in compile time
+	 */
+	readonly Aux: M;
+	readonly deployment: LikeC4DeploymentModel<M>;
+	static create<const M extends AnyLikeC4Model>(model: M): LikeC4Model<Aux.FromModel<M>>;
+	/**
+	 * This method is supposed to be used only in dumps
+	 */
+	static fromDump<const M extends ParsedLikeC4ModelDump>(dump: M): LikeC4Model<Aux.FromDump<M>>;
+	private constructor();
+	get type(): "computed" | "layouted";
+	element(el: M["ElementOrFqn"]): ElementModel<M>;
+	findElement(el: LiteralUnion<M["Element"], string>): ElementModel<M> | null;
+	/**
+	 * Returns the root elements of the model.
+	 */
+	roots(): ElementsIterator<M>;
+	/**
+	 * Returns all elements in the model.
+	 */
+	elements(): ElementsIterator<M>;
+	/**
+	 * Returns all relationships in the model.
+	 */
+	relationships(): RelationshipsIterator<M>;
+	/**
+	 * 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.
+	 */
+	relationship(id: M["RelationId"], type: "model"): RelationshipModel<M>;
+	relationship(id: M["RelationId"], type: "deployment"): DeploymentRelationModel<M>;
+	relationship(id: M["RelationId"], type?: "model" | "deployment"): RelationshipModel<M> | DeploymentRelationModel<M>;
+	findRelationship(id: LiteralUnion<M["RelationId"], string>, type: "model"): RelationshipModel<M> | null;
+	findRelationship(id: LiteralUnion<M["RelationId"], string>, type: "deployment"): DeploymentRelationModel<M> | null;
+	findRelationship(id: LiteralUnion<M["RelationId"], string>, type?: "model" | "deployment"): RelationshipModel<M> | DeploymentRelationModel<M> | null;
+	/**
+	 * Returns all views in the model.
+	 */
+	views(): MapIterator<LikeC4ViewModel<M, M["ViewType"]>>;
+	/**
+	 * Returns a specific view by its ID.
+	 */
+	view(viewId: M["ViewIdLiteral"]): LikeC4ViewModel<M>;
+	findView(viewId: LiteralUnion<M["ViewId"], string>): LikeC4ViewModel<M>;
+	/**
+	 * Returns the parent element of given element.
+	 * @see ancestors
+	 */
+	parent(element: M["ElementOrFqn"]): ElementModel<M> | null;
+	/**
+	 * Get all children of the element (only direct children),
+	 * @see descendants
+	 */
+	children(element: M["ElementOrFqn"]): ReadonlySet<ElementModel<M>>;
+	/**
+	 * Get all sibling (i.e. same parent)
+	 */
+	siblings(element: M["ElementOrFqn"]): ElementsIterator<M>;
 	/**
 	 * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
 	 * (from closest to root)
 	 */
-	ancestors(element: ElementOrFqn): ReadonlyArray<LikeC4DiagramModel.Element>;
-	descendants(element: ElementOrFqn): ReadonlyArray<LikeC4DiagramModel.Element>;
-	incoming(element: ElementOrFqn, filter?: IncomingFilter): ReadonlyArray<LikeC4DiagramModel.Connection>;
-	incomers(element: ElementOrFqn, filter?: IncomingFilter): ReadonlyArray<LikeC4DiagramModel.Element>;
+	ancestors(element: M["ElementOrFqn"]): ElementsIterator<M>;
 	/**
-	 * Outgoing relationships from the element and its descendants
+	 * Get all descendant elements (i.e. children, children’s children, etc.)
 	 */
-	outgoing(element: ElementOrFqn, filter?: OutgoingFilter): ReadonlyArray<LikeC4DiagramModel.Connection>;
-	outgoers(element: ElementOrFqn, filter?: OutgoingFilter): ReadonlyArray<LikeC4DiagramModel.Element>;
-}
-declare namespace LikeC4DiagramModel {
-	/**
-	 * Represents an element in the view. (Diagram node)
-	 * All methods are view-scoped, i.e. `children` returns only children of the element in the view.
-	 */
-	class Element {
-		readonly node: DiagramNode;
-		private readonly view;
-		constructor(node: DiagramNode, view: LikeC4DiagramModel);
-		get id(): NodeId<string>;
-		get title(): string;
-		get kind(): ElementKind;
-		get isRoot(): boolean;
-		get hasNested(): boolean;
-		get shape(): ElementShape;
-		get color(): Color;
-		get tags(): Tag[];
-		get level(): number;
-		get depth(): number;
-		model(): LikeC4Model.ElementModel<LikeC4DiagramModel>;
-		parent(): LikeC4DiagramModel.Element | null;
-		metadata(key: string): string | undefined;
-		metadata(key: string, defaultValue: string): string;
-		hasMetadata(key: string): boolean;
-		ancestors(): ReadonlyArray<LikeC4DiagramModel.Element>;
-		siblings(): ReadonlyArray<LikeC4DiagramModel.Element>;
-		descendants(): ReadonlyArray<LikeC4DiagramModel.Element>;
-		children(): ReadonlyArray<LikeC4DiagramModel.Element>;
-		incoming(filter?: IncomingFilter): ReadonlyArray<LikeC4DiagramModel.Connection>;
-		incomers(filter?: IncomingFilter): ReadonlyArray<LikeC4DiagramModel.Element>;
-		outgoing(filter?: OutgoingFilter): ReadonlyArray<LikeC4DiagramModel.Connection>;
-		outgoers(filter?: OutgoingFilter): ReadonlyArray<LikeC4DiagramModel.Element>;
-		connectionsTo(target: Fqn$1 | LikeC4DiagramModel.Element): ReadonlyArray<LikeC4DiagramModel.Connection>;
-	}
+	descendants(element: M["ElementOrFqn"]): ElementsIterator<M>;
 	/**
-	 * Represents a connection between two elements.
-	 * May be source from multiple model relationships.
-	 */
-	class Connection {
-		readonly edge: DiagramEdge;
-		private readonly view;
-		constructor(edge: DiagramEdge, view: LikeC4DiagramModel);
-		get id(): EdgeId;
-		get source(): LikeC4DiagramModel.Element;
-		get target(): LikeC4DiagramModel.Element;
-		get tags(): Tag[];
-		get color(): Color;
-		/**
-		 * Model relationships
-		 */
-		relationships(): ReadonlyArray<LikeC4Model.Relationship<LikeC4DiagramModel>>;
-	}
+	 * Incoming relationships to the element and its descendants
+	 * @see incomers
+	 */
+	incoming(element: M["ElementOrFqn"], filter?: IncomingFilter): RelationshipsIterator<M>;
+	/**
+	 * Outgoing relationships from the element and its descendants
+	 * @see outgoers
+	 */
+	outgoing(element: M["ElementOrFqn"], filter?: OutgoingFilter): RelationshipsIterator<M>;
+	private addElement;
+	private addRelation;
+}
+export declare namespace LikeC4Model {
+	type Any = Aux<string, string, string, ComputedView | DiagramView>;
+	type Element<M extends AnyAux = Any> = ElementModel<M>;
+	type Relation<M extends AnyAux = Any> = RelationshipModel<M>;
+	type AnyRelation<M extends AnyAux = Any> = RelationshipModel<M> | DeploymentRelationModel<M>;
+	type View<M extends AnyAux = Any, V extends ComputedView | DiagramView = M["ViewType"]> = LikeC4ViewModel<M, V>;
+	type Node<M extends AnyAux = Any, V extends ComputedView | DiagramView = M["ViewType"]> = NodeModel<M, V>;
+	type Edge<M extends AnyAux = Any, V extends ComputedView | DiagramView = M["ViewType"]> = EdgeModel<M, V>;
+	type DeploymentModel<M extends AnyAux = AnyAux> = LikeC4DeploymentModel<M>;
+	type Deployment<M extends AnyAux = AnyAux> = DeploymentElementModel<M>;
+	type DeploymentNode<M extends AnyAux = AnyAux> = DeploymentNodeModel<M>;
+	type DeployedInstance<M extends AnyAux = AnyAux> = DeployedInstanceModel<M>;
+	type Typed<Elements extends string = string, Deployments extends string = string, Views extends string = string, ViewType = DiagramView<Views> | ComputedView<Views>> = Aux<Elements, Deployments, Views, ViewType>;
+	type Computed<Elements extends string = string, Deployments extends string = string, Views extends string = string> = LikeC4Model<Typed<Elements, Deployments, Views, ComputedView<Views>>>;
+	type Layouted<Elements extends string = string, Deployments extends string = string, Views extends string = string> = LikeC4Model<Typed<Elements, Deployments, Views, DiagramView<Views>>>;
 }
 interface VariantColorsResolverInput {
 	color: MantineColor | undefined;
@@ -1132,9 +1590,7 @@ type MantineThemeColors = MantineThemeColorsOverride extends {
 	colors: Record<infer CustomColors, MantineColorsTuple>;
 } ? Record<CustomColors, MantineColorsTuple> : Record<DefaultMantineColor, MantineColorsTuple>;
 type MantineColor = keyof MantineThemeColors;
-export type ViewData<ViewId extends string> = Omit<DiagramView, "id"> & {
-	id: ViewId;
-};
+export type ViewData<Views extends string> = DiagramView<Views, string>;
 type ElementIconRendererProps = {
 	node: {
 		id: string;
@@ -1379,7 +1835,7 @@ type XYBackgroundVariant = "dots" | "lines" | "cross";
 type XYBackground = XYBackgroundVariant | OverrideProperties<BackgroundProps, {
 	variant: XYBackgroundVariant;
 }>;
-type DiagramNodeWithNavigate<ID extends string = ViewID> = Omit<DiagramNode, "navigateTo"> & {
+type DiagramNodeWithNavigate<ID extends string = ViewId> = Omit<DiagramNode, "navigateTo"> & {
 	navigateTo: ID;
 };
 type ElementIconNodeProps = {
@@ -1390,7 +1846,7 @@ type ElementIconNodeProps = {
 type ElementIconRenderer$1 = (props: {
 	node: ElementIconNodeProps;
 }) => ReactNode;
-type OnNavigateTo<ID extends string = ViewID> = (to: ID, event?: ReactMouseEvent, element?: DiagramNodeWithNavigate<ID>) => void;
+type OnNavigateTo<ID extends string = ViewId> = (to: ID, event?: ReactMouseEvent, element?: DiagramNodeWithNavigate<ID>) => void;
 type OnNodeClick = (node: DiagramNode, event: ReactMouseEvent) => void;
 type OnEdgeClick = (edge: DiagramEdge, event: ReactMouseEvent) => void;
 type OnCanvasClick = (event: ReactMouseEvent) => void;
@@ -1477,6 +1933,11 @@ interface LikeC4DiagramProperties {
 	 * @default false
 	 */
 	enableFocusMode?: boolean | undefined;
+	/**
+	 * Enable search popup for elements and views
+	 * @default true
+	 */
+	enableSearch?: boolean | undefined;
 	/**
 	 * Enable modal with element details
 	 * @default false
@@ -1508,6 +1969,17 @@ interface LikeC4DiagramProperties {
 	 */
 	where?: WhereOperator<string, string> | undefined;
 }
+type OpenSourceParams = {
+	element: Fqn;
+	property?: string;
+} | {
+	relation: RelationId;
+} | {
+	deployment: Fqn;
+	property?: string;
+} | {
+	view: ViewId;
+};
 interface LikeC4DiagramEventHandlers {
 	onChange?: OnChange | null | undefined;
 	onNavigateTo?: OnNavigateTo | null | undefined;
@@ -1519,9 +1991,7 @@ interface LikeC4DiagramEventHandlers {
 	onCanvasClick?: OnCanvasClick | null | undefined;
 	onCanvasDblClick?: OnCanvasClick | null | undefined;
 	onBurgerMenuClick?: null | undefined | (() => void);
-	onOpenSourceView?: null | undefined | (() => void);
-	onOpenSourceElement?: null | undefined | ((fqn: Fqn) => void);
-	onOpenSourceRelation?: null | undefined | ((id: RelationID) => void);
+	onOpenSource?: null | undefined | ((params: OpenSourceParams) => void);
 }
 type LikeC4DiagramProps = LikeC4DiagramProperties & LikeC4DiagramEventHandlers;
 export declare function useLikeC4Model(): LikeC4Model | null;
@@ -1529,17 +1999,17 @@ export declare function useLikeC4Model(strict: true): LikeC4Model;
 export declare function useLikeC4Model(strict: boolean): LikeC4Model | null;
 export declare function useLikeC4Model(strict: true, type: "layouted"): LikeC4Model.Layouted;
 export declare function useLikeC4Model(strict: true, type: "computed"): LikeC4Model.Computed;
-export declare function useLikeC4Model(strict: true, type: LikeC4Model["type"] | undefined): LikeC4Model;
+export declare function useLikeC4Model(strict: true, type: "layouted" | "computed" | undefined): LikeC4Model;
 export declare function useLikeC4Model(strict: boolean, type: "layouted"): LikeC4Model.Layouted | null;
 export declare function useLikeC4Model(strict: boolean, type: "computed"): LikeC4Model.Computed | null;
-export declare function useLikeC4Model(strict: boolean, type: LikeC4Model["type"] | undefined): LikeC4Model | null;
-export declare function useLikeC4Views(): LikeC4Model.SourceModel["views"];
-export declare function useLikeC4ViewModel(viewId: LiteralUnion<ViewID, string>): LikeC4Model.ViewModel;
+export declare function useLikeC4Model(strict: boolean, type: "layouted" | "computed" | undefined): LikeC4Model | null;
+export declare function useLikeC4Views(): Record<ViewId, ComputedView | DiagramView>;
+export declare function useLikeC4ViewModel(viewId: LiteralUnion<ViewId, string>): LikeC4Model.View;
 /**
  * Parsed view, computed or layouted
  */
-export declare function useLikeC4View(viewId: LiteralUnion<ViewID, string>): ComputedView | DiagramView | null;
-export declare function useLikeC4DiagramView(viewId: LiteralUnion<ViewID, string>): DiagramView | null;
+export declare function useLikeC4View(viewId: LiteralUnion<ViewId, string>): ComputedView | DiagramView | null;
+export declare function useLikeC4DiagramView(viewId: LiteralUnion<ViewId, string>): DiagramView | null;
 type LikeC4ModelProviderProps = PropsWithChildren<{
 	likec4model: LikeC4Model;
 }>;
@@ -1815,6 +2285,9 @@ export declare const BundledStyles: () => any;
 export declare function useBundledStyleSheet(injectFontCss: boolean, styleNonce?: string | (() => string) | undefined): CSSStyleSheet[];
 type ColorScheme = "light" | "dark";
 export declare function useColorScheme(explicit?: ColorScheme): ColorScheme;
+export declare const ViewNotFound: ({ viewId }: {
+	viewId: string;
+}) => import("react/jsx-runtime").JSX.Element;
 /**
  * We need this function to bundle LikeC4Model with `likec4/react'
  * Used by vite plugin to generate `virtual:likec4/model`