likec4 1.36.0 → 1.37.0

package/react/index.d.mts

@@ -1,6 +1,6 @@
 // Generated by dts-bundle-generator v9.5.1
 
-import { CSSProperties, ComponentType, HTMLAttributes, JSX, MouseEvent as ReactMouseEvent, PropsWithChildren, ReactNode, WheelEvent as WheelEvent$1 } from 'react';
+import { AriaRole, CSSProperties, ComponentType, DOMAttributes, FunctionComponent, HTMLAttributes, JSX, MouseEvent as ReactMouseEvent, PropsWithChildren, ReactNode, SVGAttributes, WheelEvent as WheelEvent$1 } from 'react';
 
 type Primitive = null | undefined | string | number | boolean | symbol | bigint;
 type UnionToIntersection<Union> = (
@@ -111,6 +111,14 @@ type Except<ObjectType, KeysType extends keyof ObjectType, Options extends Excep
 type _Except<ObjectType, KeysType extends keyof ObjectType, Options extends Required<ExceptOptions>> = {
 	[KeyType in keyof ObjectType as Filter<KeyType, KeysType>]: ObjectType[KeyType];
 } & (Options["requireExactProps"] extends true ? Partial<Record<KeysType, never>> : {});
+type NonEmptyTuple<T = unknown> = readonly [
+	T,
+	...T[]
+];
+type Without<FirstType, SecondType> = {
+	[KeyType in Exclude<keyof FirstType, keyof SecondType>]?: never;
+};
+type MergeExclusive<FirstType, SecondType> = (FirstType | SecondType) extends object ? (Without<FirstType, SecondType> & SecondType) | (Without<SecondType, FirstType> & FirstType) : FirstType | SecondType;
 declare const tag: unique symbol;
 type TagContainer<Token> = {
 	readonly [tag]: Token;
@@ -157,6 +165,16 @@ type NonEmptyArray<T> = [
 	T,
 	...T[]
 ];
+type KeysOf<T> = keyof T extends infer K extends string ? K : never;
+type AllNever<Expressions> = UnionToIntersection<{
+	[Name in keyof Expressions]: {
+		-readonly [Key in keyof Expressions[Name]]?: never;
+	};
+}[keyof Expressions]>;
+type ExclusiveUnion<Expressions, All = AllNever<Expressions>> = Expressions extends object ? {
+	[Name in keyof Expressions]: Simplify<Omit<All, keyof Expressions[Name]> & Expressions[Name]>;
+}[keyof Expressions] : never;
+type IteratorLike<T> = IteratorObject<T, BuiltinIteratorReturn>;
 interface Link {
 	title?: string;
 	url: string;
@@ -164,6 +182,7 @@ interface Link {
 }
 type Coalesce<V extends string, OrIfAny = string> = IsAny<V> extends true ? OrIfAny : V;
 type ProjectId<T = string> = Tagged<T, "ProjectID">;
+declare function ProjectId(name: string): ProjectId;
 type MarkdownOrString = {
 	txt: string;
 	md?: never;
@@ -177,6 +196,8 @@ 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">;
+declare const GroupElementKind: ElementKind<"@group">;
+type GroupElementKind = typeof GroupElementKind;
 type DeploymentFqn<T = string> = Tagged<T, "DeploymentFqn">;
 declare function DeploymentFqn(name: string, parent?: DeploymentFqn | null): DeploymentFqn;
 type DeploymentKind<Kinds = string> = Tagged<Kinds, "DeploymentKind">;
@@ -190,8 +211,13 @@ type NodeId = Tagged<string, "NodeId" | "Fqn" | "DeploymentFqn">;
 declare function NodeId(id: string): NodeId;
 type EdgeId = Tagged<string, "EdgeId">;
 declare function EdgeId(id: string): EdgeId;
+type StepEdgeIdLiteral = `step-${number}` | `step-${number}.${number}`;
+type StepEdgeId = Tagged<StepEdgeIdLiteral, "EdgeId">;
 declare const StepEdgeKind = "@step";
 type ModelStage = "parsed" | "computed" | "layouted";
+type ExtractOnStage<T, S extends ModelStage> = Extract<T, {
+	[_stage]: S;
+}>;
 declare const _stage = "_stage";
 type _stage = typeof _stage;
 declare const _type = "_type";
@@ -362,6 +388,9 @@ declare const ElementShapes: readonly [
 type ElementShape = TupleToUnion<typeof ElementShapes>;
 type HexColor = `#${string}`;
 type ColorLiteral = HexColor | `rgb(${number},${number},${number})` | `rgba(${number},${number},${number},${number})`;
+type CustomColorDefinitions = {
+	[key: string]: ThemeColorValues;
+};
 type RelationshipLineType = "dashed" | "solid" | "dotted";
 type RelationshipArrowType = "none" | "normal" | "onormal" | "dot" | "odot" | "diamond" | "odiamond" | "crow" | "open" | "vee";
 declare const ThemeColors: readonly [
@@ -379,6 +408,73 @@ declare const ThemeColors: readonly [
 ];
 type ThemeColor = typeof ThemeColors[number];
 type Color = ThemeColor | ColorLiteral;
+interface ElementThemeColorValues {
+	fill: ColorLiteral;
+	stroke: ColorLiteral;
+	hiContrast: ColorLiteral;
+	loContrast: ColorLiteral;
+}
+interface RelationshipThemeColorValues {
+	lineColor: ColorLiteral;
+	labelBgColor: ColorLiteral;
+	labelColor: ColorLiteral;
+}
+interface ThemeColorValues {
+	elements: ElementThemeColorValues;
+	relationships: RelationshipThemeColorValues;
+}
+declare namespace FqnRef {
+	/**
+	 * Reference to logical model element
+	 */
+	interface ElementRef<A extends Any = Unknown> {
+		project?: never;
+		model: ElementId<A>;
+	}
+	function isElementRef<A extends Any>(ref: FqnRef<A>): ref is ElementRef<A>;
+	/**
+	 * Reference to imported logical model element
+	 */
+	interface ImportRef<A extends Any = Unknown> {
+		project: ProjectId$1<A>;
+		model: ElementId<A>;
+	}
+	function isImportRef<A extends Any>(ref: FqnRef<A>): ref is ImportRef<A>;
+	function flatten<A extends Any>(ref: FqnRef<A>): Fqn$1<A>;
+	type ModelRef<A extends Any = Unknown> = ImportRef<A> | ElementRef<A>;
+	function isModelRef<A extends Any>(ref: FqnRef<A>): ref is ModelRef<A>;
+	/**
+	 * Represents a reference to an instance within a deployment.
+	 *
+	 * @template D - The type representing the deployment fqn. Defaults to `Fqn`.
+	 * @template M - The type representing the model fqn. Defaults to `Fqn`.
+	 *
+	 * @property {D} deployment - TThe fully qualified name (FQN) of the deployed instance.
+	 * @property {M} element - The element reference within the deployment.
+	 */
+	interface InsideInstanceRef<A extends Any = Unknown> {
+		deployment: DeploymentId<A>;
+		element: ElementId<A>;
+	}
+	function isInsideInstanceRef<A extends Any>(ref: FqnRef<A>): ref is InsideInstanceRef<A>;
+	/**
+	 * Represents a reference to a deployment element.
+	 *
+	 * @template F - The type of the fully qualified name (FQN) of the deployment element. Defaults to `Fqn`.
+	 * @property {F} deployment - The fully qualified name (FQN) of the deployment element.
+	 */
+	interface DeploymentElementRef<A extends Any> {
+		deployment: DeploymentId<A>;
+		element?: never;
+	}
+	function isDeploymentElementRef<A extends Any>(ref: FqnRef<A>): ref is DeploymentElementRef<A>;
+	type DeploymentRef<A extends Any> = DeploymentElementRef<A> | InsideInstanceRef<A>;
+	function isDeploymentRef<A extends Any>(ref: FqnRef<A>): ref is DeploymentRef<A>;
+}
+type FqnRef<A extends Any = Unknown> = ExclusiveUnion<{
+	DeploymentRef: FqnRef.DeploymentRef<A>;
+	ModelRef: FqnRef.ModelRef<A>;
+}>;
 type EqualOperator<V> = {
 	eq: V;
 	neq?: never;
@@ -386,7 +482,7 @@ type EqualOperator<V> = {
 	eq?: never;
 	neq: V;
 };
-type AllNever = {
+type AllNever$1 = {
 	not?: never;
 	and?: never;
 	or?: never;
@@ -395,27 +491,387 @@ type AllNever = {
 	participant?: never;
 	operator?: never;
 };
-type TagEqual<A extends Any> = Omit<AllNever, "tag"> & {
+type TagEqual<A extends Any> = Omit<AllNever$1, "tag"> & {
 	tag: EqualOperator<Tag$2<A>> | Tag$2<A>;
 };
-type KindEqual<A extends Any> = Omit<AllNever, "kind"> & {
+type KindEqual<A extends Any> = Omit<AllNever$1, "kind"> & {
 	kind: EqualOperator<AllKinds<A>> | AllKinds<A>;
 };
 type Participant = "source" | "target";
-type ParticipantOperator<A extends Any> = Omit<AllNever, "participant" | "operator"> & {
+type ParticipantOperator<A extends Any> = Omit<AllNever$1, "participant" | "operator"> & {
 	participant: Participant;
 	operator: KindEqual<A> | TagEqual<A>;
 };
-type NotOperator<A extends Any> = Omit<AllNever, "not"> & {
+type NotOperator<A extends Any> = Omit<AllNever$1, "not"> & {
 	not: WhereOperator<A>;
 };
-type AndOperator<A extends Any> = Omit<AllNever, "and"> & {
+type AndOperator<A extends Any> = Omit<AllNever$1, "and"> & {
 	and: NonEmptyArray<WhereOperator<A>>;
 };
-type OrOperator<A extends Any> = Omit<AllNever, "or"> & {
+type OrOperator<A extends Any> = Omit<AllNever$1, "or"> & {
 	or: NonEmptyArray<WhereOperator<A>>;
 };
-type WhereOperator<A extends Any = Any> = TagEqual<A> | KindEqual<A> | ParticipantOperator<A> | NotOperator<A> | AndOperator<A> | OrOperator<A>;
+export type WhereOperator<A extends Any = Any> = TagEqual<A> | KindEqual<A> | ParticipantOperator<A> | NotOperator<A> | AndOperator<A> | OrOperator<A>;
+type PredicateSelector = "children" | "expanded" | "descendants";
+declare namespace FqnExpr {
+	type Wildcard = {
+		wildcard: true;
+	};
+	function isWildcard<A extends Any>(expr: Expression<A>): expr is FqnExpr.Wildcard;
+	interface ModelRef<M extends Any = Any> {
+		ref: FqnRef.ModelRef<M>;
+		selector?: PredicateSelector;
+	}
+	function isModelRef<A extends Any>(ref: Expression<A>): ref is FqnExpr.ModelRef<A>;
+	interface DeploymentRef<A extends Any = Any> {
+		ref: FqnRef.DeploymentRef<A>;
+		selector?: PredicateSelector;
+	}
+	function isDeploymentRef<A extends Any>(expr: Expression<A>): expr is FqnExpr.DeploymentRef<A>;
+	interface ElementKindExpr<A extends Any = Any> {
+		elementKind: ElementKind$1<A>;
+		isEqual: boolean;
+	}
+	function isElementKindExpr<A extends Any>(expr: Expression<A>): expr is ElementKindExpr<A>;
+	interface ElementTagExpr<A extends Any = Any> {
+		elementTag: Tag$2<A>;
+		isEqual: boolean;
+	}
+	function isElementTagExpr<A extends Any>(expr: Expression<A>): expr is ElementTagExpr<A>;
+	type NonWildcard<A extends Any = Any> = ExclusiveUnion<{
+		ModelRef: ModelRef<A>;
+		DeploymentRef: DeploymentRef<A>;
+		ElementKind: ElementKindExpr<A>;
+		ElementTag: ElementTagExpr<A>;
+	}>;
+	interface Where<A extends Any = Any> {
+		where: {
+			expr: ExclusiveUnion<{
+				Wildcard: Wildcard;
+				ModelRef: ModelRef<A>;
+				DeploymentRef: DeploymentRef<A>;
+				ElementKind: ElementKindExpr<A>;
+				ElementTag: ElementTagExpr<A>;
+			}>;
+			condition: WhereOperator<A>;
+		};
+	}
+	function isWhere<A extends Any>(expr: Expression<A>): expr is FqnExpr.Where<A>;
+	interface Custom<A extends Any = Any> {
+		custom: {
+			expr: OrWhere<A>;
+			title?: string;
+			description?: MarkdownOrString;
+			technology?: string;
+			notation?: string;
+			shape?: ElementShape;
+			color?: Color;
+			icon?: Icon;
+			border?: BorderStyle;
+			opacity?: number;
+			navigateTo?: StrictViewId<A>;
+			multiple?: boolean;
+			size?: ShapeSize;
+			padding?: ShapeSize;
+			textSize?: ShapeSize;
+		};
+	}
+	function isCustom<A extends Any>(expr: Expression<A>): expr is Custom<A>;
+	function is<A extends Any>(expr: Expression<A>): expr is FqnExpr<A>;
+	type OrWhere<A extends Any = Any> = ExclusiveUnion<{
+		Wildcard: FqnExpr.Wildcard;
+		ModelRef: FqnExpr.ModelRef<A>;
+		DeploymentRef: FqnExpr.DeploymentRef<A>;
+		ElementKind: ElementKindExpr<A>;
+		ElementTag: ElementTagExpr<A>;
+		Where: FqnExpr.Where<A>;
+	}>;
+	type Any<A extends Any = Any> = ExclusiveUnion<{
+		Wildcard: Wildcard;
+		ModelRef: ModelRef<A>;
+		DeploymentRef: DeploymentRef<A>;
+		ElementKind: ElementKindExpr<A>;
+		ElementTag: ElementTagExpr<A>;
+		Where: Where<A>;
+		Custom: Custom<A>;
+	}>;
+	function unwrap<A extends Any>(expr: FqnExpr.Any<A>): Wildcard | ModelRef<A> | DeploymentRef<A> | ElementKindExpr<A> | ElementTagExpr<A>;
+}
+type FqnExpr<A extends Any = Any> = ExclusiveUnion<{
+	Wildcard: FqnExpr.Wildcard;
+	ModelRef: FqnExpr.ModelRef<A>;
+	DeploymentRef: FqnExpr.DeploymentRef<A>;
+	ElementKind: FqnExpr.ElementKindExpr<A>;
+	ElementTag: FqnExpr.ElementTagExpr<A>;
+}>;
+declare namespace RelationExpr {
+	type Endpoint<A extends Any = Any> = FqnExpr.Where<A>["where"]["expr"];
+	interface Direct<A extends Any = Any> {
+		source: Endpoint<A>;
+		target: Endpoint<A>;
+		isBidirectional?: boolean;
+	}
+	function isDirect<A extends Any>(expr: Expression<A>): expr is RelationExpr.Direct<A>;
+	interface Incoming<A extends Any = Any> {
+		incoming: Endpoint<A>;
+	}
+	function isIncoming<A extends Any>(expr: Expression<A>): expr is RelationExpr.Incoming<A>;
+	interface Outgoing<A extends Any = Any> {
+		outgoing: Endpoint<A>;
+	}
+	function isOutgoing<A extends Any>(expr: Expression<A>): expr is RelationExpr.Outgoing<A>;
+	interface InOut<A extends Any = Any> {
+		inout: Endpoint<A>;
+	}
+	function isInOut<A extends Any>(expr: Expression<A>): expr is RelationExpr.InOut<A>;
+	interface Where<A extends Any = Any> {
+		where: {
+			expr: ExclusiveUnion<{
+				Direct: RelationExpr.Direct<A>;
+				Incoming: RelationExpr.Incoming<A>;
+				Outgoing: RelationExpr.Outgoing<A>;
+				InOut: RelationExpr.InOut<A>;
+			}>;
+			condition: WhereOperator<A>;
+		};
+	}
+	function isWhere<A extends Any>(expr: Expression<A>): expr is RelationExpr.Where<A>;
+	interface Custom<A extends Any = Any> {
+		customRelation: {
+			expr: OrWhere<A>;
+			title?: string;
+			description?: string;
+			technology?: string;
+			notation?: string;
+			navigateTo?: StrictViewId<A>;
+			notes?: string;
+			color?: Color;
+			line?: RelationshipLineType;
+			head?: RelationshipArrowType;
+			tail?: RelationshipArrowType;
+		};
+	}
+	function isCustom<A extends Any>(expr: Expression<A>): expr is Custom<A>;
+	function is<A extends Any>(expr: Expression<A>): expr is RelationExpr<A>;
+	type OrWhere<A extends Any = Any> = ExclusiveUnion<{
+		Direct: Direct<A>;
+		Incoming: Incoming<A>;
+		Outgoing: Outgoing<A>;
+		InOut: InOut<A>;
+		Where: Where<A>;
+	}>;
+	type Any<A extends Any = Any> = ExclusiveUnion<{
+		Direct: Direct<A>;
+		Incoming: Incoming<A>;
+		Outgoing: Outgoing<A>;
+		InOut: InOut<A>;
+		Where: Where<A>;
+		Custom: Custom<A>;
+	}>;
+	function unwrap<A extends Any>(expr: RelationExpr.Any<A>): Direct<A> | Incoming<A> | Outgoing<A> | InOut<A>;
+}
+type RelationExpr<A extends Any = Any> = ExclusiveUnion<{
+	Direct: RelationExpr.Direct<A>;
+	Incoming: RelationExpr.Incoming<A>;
+	Outgoing: RelationExpr.Outgoing<A>;
+	InOut: RelationExpr.InOut<A>;
+}>;
+type Expression<A extends Any = Any> = ExclusiveUnion<{
+	Wildcard: FqnExpr.Wildcard;
+	ModelRef: FqnExpr.ModelRef<A>;
+	DeploymentRef: FqnExpr.DeploymentRef<A>;
+	ElementKind: FqnExpr.ElementKindExpr<A>;
+	ElementTag: FqnExpr.ElementTagExpr<A>;
+	Custom: FqnExpr.Custom<A>;
+	Direct: RelationExpr.Direct<A>;
+	Incoming: RelationExpr.Incoming<A>;
+	Outgoing: RelationExpr.Outgoing<A>;
+	InOut: RelationExpr.InOut<A>;
+	Where: Expression.Where<A>;
+	CustomRelation: RelationExpr.Custom<A>;
+}>;
+declare namespace Expression {
+	type Where<A extends Any = Any> = FqnExpr.Where<A> | RelationExpr.Where<A>;
+	function isWhere<A extends Any>(expr: Expression<A>): expr is Expression.Where<A>;
+	function isRelationWhere<A extends Any>(expr: Expression<A>): expr is RelationExpr.Where<A>;
+	function isFqnExprWhere<A extends Any>(expr: Expression<A>): expr is FqnExpr.Where<A>;
+	function isFqnExpr<A extends Any>(expr: Expression<A>): expr is FqnExpr.Any<A>;
+	function isRelation<A extends Any>(expr: Expression<A>): expr is RelationExpr.Any<A>;
+}
+declare namespace ModelFqnExpr {
+	type Wildcard = {
+		wildcard: true;
+	};
+	function isWildcard<A extends Any>(expr: ModelExpression<A>): expr is ModelFqnExpr.Wildcard;
+	interface Ref<M extends Any> {
+		ref: FqnRef.ModelRef<M>;
+		selector?: PredicateSelector;
+	}
+	function isModelRef<A extends Any>(ref: ModelExpression<A>): ref is ModelFqnExpr.Ref<A>;
+	interface ElementKindExpr<A extends Any = Any> {
+		elementKind: ElementKind$1<A>;
+		isEqual: boolean;
+	}
+	function isElementKindExpr<A extends Any>(expr: ModelExpression<A>): expr is ElementKindExpr<A>;
+	interface ElementTagExpr<A extends Any> {
+		elementTag: Tag$2<A>;
+		isEqual: boolean;
+	}
+	function isElementTagExpr<A extends Any>(expr: ModelExpression<A>): expr is ElementTagExpr<A>;
+	type NonWildcard<A extends Any = Any> = ExclusiveUnion<{
+		Ref: Ref<A>;
+		ElementKind: ElementKindExpr<A>;
+		ElementTag: ElementTagExpr<A>;
+	}>;
+	interface Where<A extends Any = Any> {
+		where: {
+			expr: ExclusiveUnion<{
+				Wildcard: Wildcard;
+				Ref: Ref<A>;
+				ElementKind: ElementKindExpr<A>;
+				ElementTag: ElementTagExpr<A>;
+			}>;
+			condition: WhereOperator<A>;
+		};
+	}
+	function isWhere<A extends Any>(expr: ModelExpression<A>): expr is ModelFqnExpr.Where<A>;
+	interface Custom<A extends Any = Any> {
+		custom: {
+			expr: OrWhere<A>;
+			title?: string;
+			description?: MarkdownOrString;
+			technology?: string;
+			notation?: string;
+			shape?: ElementShape;
+			color?: Color;
+			icon?: Icon;
+			border?: BorderStyle;
+			opacity?: number;
+			navigateTo?: StrictViewId<A>;
+			multiple?: boolean;
+			size?: ShapeSize;
+			padding?: ShapeSize;
+			textSize?: ShapeSize;
+		};
+	}
+	function isCustom<A extends Any>(expr: ModelExpression<A>): expr is Custom<A>;
+	function is<A extends Any>(expr: ModelExpression<A>): expr is ModelFqnExpr<A>;
+	type OrWhere<A extends Any = Any> = ExclusiveUnion<{
+		Wildcard: ModelFqnExpr.Wildcard;
+		Ref: ModelFqnExpr.Ref<A>;
+		ElementKind: ElementKindExpr<A>;
+		ElementTag: ElementTagExpr<A>;
+		Where: ModelFqnExpr.Where<A>;
+	}>;
+	type Any<A extends Any = Any> = ExclusiveUnion<{
+		Wildcard: Wildcard;
+		Ref: Ref<A>;
+		ElementKind: ElementKindExpr<A>;
+		ElementTag: ElementTagExpr<A>;
+		Where: Where<A>;
+		Custom: Custom<A>;
+	}>;
+	function unwrap<A extends Any>(expr: ModelFqnExpr.Any<A>): Wildcard | Ref<A> | ElementKindExpr<A> | ElementTagExpr<A>;
+}
+type ModelFqnExpr<A extends Any = Any> = ExclusiveUnion<{
+	Wildcard: ModelFqnExpr.Wildcard;
+	Ref: ModelFqnExpr.Ref<A>;
+	ElementKind: ModelFqnExpr.ElementKindExpr<A>;
+	ElementTag: ModelFqnExpr.ElementTagExpr<A>;
+}>;
+declare namespace ModelRelationExpr {
+	type Endpoint<A extends Any = Any> = ModelFqnExpr.Where<A>["where"]["expr"];
+	interface Direct<A extends Any = Any> {
+		source: Endpoint<A>;
+		target: Endpoint<A>;
+		isBidirectional?: boolean;
+	}
+	function isDirect<A extends Any>(expr: ModelExpression<A>): expr is ModelRelationExpr.Direct<A>;
+	interface Incoming<A extends Any = Any> {
+		incoming: Endpoint<A>;
+	}
+	function isIncoming<A extends Any>(expr: ModelExpression<A>): expr is ModelRelationExpr.Incoming<A>;
+	interface Outgoing<A extends Any = Any> {
+		outgoing: Endpoint<A>;
+	}
+	function isOutgoing<A extends Any>(expr: ModelExpression<A>): expr is ModelRelationExpr.Outgoing<A>;
+	interface InOut<A extends Any = Any> {
+		inout: Endpoint<A>;
+	}
+	function isInOut<A extends Any>(expr: ModelExpression<A>): expr is ModelRelationExpr.InOut<A>;
+	interface Where<A extends Any = Any> {
+		where: {
+			expr: ExclusiveUnion<{
+				Direct: ModelRelationExpr.Direct<A>;
+				Incoming: ModelRelationExpr.Incoming<A>;
+				Outgoing: ModelRelationExpr.Outgoing<A>;
+				InOut: ModelRelationExpr.InOut<A>;
+			}>;
+			condition: WhereOperator<A>;
+		};
+	}
+	function isWhere<A extends Any>(expr: ModelExpression<A>): expr is ModelRelationExpr.Where<A>;
+	interface Custom<A extends Any = Any> {
+		customRelation: {
+			expr: OrWhere<A>;
+			title?: string;
+			description?: string;
+			technology?: string;
+			notation?: string;
+			navigateTo?: StrictViewId<A>;
+			notes?: string;
+			color?: Color;
+			line?: RelationshipLineType;
+			head?: RelationshipArrowType;
+			tail?: RelationshipArrowType;
+		};
+	}
+	function isCustom<A extends Any>(expr: ModelExpression<A>): expr is Custom<A>;
+	function is<A extends Any>(expr: ModelExpression<A>): expr is ModelRelationExpr<A>;
+	type OrWhere<A extends Any = Any> = ExclusiveUnion<{
+		Direct: Direct<A>;
+		Incoming: Incoming<A>;
+		Outgoing: Outgoing<A>;
+		InOut: InOut<A>;
+		Where: Where<A>;
+	}>;
+	type Any<A extends Any = Any> = ExclusiveUnion<{
+		Direct: Direct<A>;
+		Incoming: Incoming<A>;
+		Outgoing: Outgoing<A>;
+		InOut: InOut<A>;
+		Where: Where<A>;
+		Custom: Custom<A>;
+	}>;
+	function unwrap<A extends Any>(expr: ModelRelationExpr.Any<A>): Direct<A> | Incoming<A> | Outgoing<A> | InOut<A>;
+}
+type ModelRelationExpr<A extends Any = Any> = ExclusiveUnion<{
+	Direct: ModelRelationExpr.Direct<A>;
+	Incoming: ModelRelationExpr.Incoming<A>;
+	Outgoing: ModelRelationExpr.Outgoing<A>;
+	InOut: ModelRelationExpr.InOut<A>;
+}>;
+type ModelExpression<A extends Any = Any> = ExclusiveUnion<{
+	Wildcard: ModelFqnExpr.Wildcard;
+	Ref: ModelFqnExpr.Ref<A>;
+	ElementKind: ModelFqnExpr.ElementKindExpr<A>;
+	ElementTag: ModelFqnExpr.ElementTagExpr<A>;
+	Custom: ModelFqnExpr.Custom<A>;
+	Direct: ModelRelationExpr.Direct<A>;
+	Incoming: ModelRelationExpr.Incoming<A>;
+	Outgoing: ModelRelationExpr.Outgoing<A>;
+	InOut: ModelRelationExpr.InOut<A>;
+	Where: ModelExpression.Where<A>;
+	CustomRelation: ModelRelationExpr.Custom<A>;
+}>;
+declare namespace ModelExpression {
+	type Where<A extends Any = Any> = ModelFqnExpr.Where<A> | ModelRelationExpr.Where<A>;
+	function isWhere<A extends Any>(expr: ModelExpression<A>): expr is ModelExpression.Where<A>;
+	function isRelationWhere<A extends Any>(expr: ModelExpression<A>): expr is ModelRelationExpr.Where<A>;
+	function isFqnExprWhere<A extends Any>(expr: ModelExpression<A>): expr is ModelFqnExpr.Where<A>;
+	function isFqnExpr<A extends Any>(expr: ModelExpression<A>): expr is ModelFqnExpr.Any<A>;
+	function isRelationExpr<A extends Any>(expr: ModelExpression<A>): expr is ModelRelationExpr.Any<A>;
+}
 type Point = readonly [
 	x: number,
 	y: number
@@ -448,6 +904,35 @@ declare namespace RectBox {
 	function merge(...boxes: RectBox[]): RectBox;
 	function toBBox(box: RectBox): BBox;
 }
+interface AnyIncludePredicate<Expr> {
+	include: Expr[];
+	exclude?: never;
+}
+interface AnyExcludePredicate<Expr> {
+	include?: never;
+	exclude: Expr[];
+}
+interface AnyViewRuleStyle<Expr> {
+	targets: Expr[];
+	notation?: string;
+	style: {
+		border?: BorderStyle;
+		opacity?: number;
+		multiple?: boolean;
+		size?: ShapeSize;
+		padding?: SpacingSize;
+		textSize?: TextSize;
+		color?: Color;
+		shape?: ElementShape;
+		icon?: Icon;
+	};
+}
+interface ViewRuleGlobalStyle {
+	styleId: GlobalStyleID;
+}
+interface ViewRuleGlobalPredicateRef {
+	predicateId: GlobalPredicateId;
+}
 type AutoLayoutDirection = "TB" | "BT" | "LR" | "RL";
 interface ViewRuleAutoLayout {
 	direction: AutoLayoutDirection;
@@ -480,6 +965,7 @@ type ViewManualLayout = {
 		labelBBox?: BBox;
 	}>;
 };
+type ViewType = "element" | "dynamic" | "deployment";
 interface BaseViewProperties<A extends Any> extends WithOptionalTags<A>, WithOptionalLinks {
 	readonly id: StrictViewId<A>;
 	readonly title: string | null;
@@ -494,6 +980,22 @@ interface BaseViewProperties<A extends Any> extends WithOptionalTags<A>, WithOpt
 	 */
 	readonly relativePath?: string | undefined;
 }
+interface BaseParsedViewProperties<A extends Any> extends BaseViewProperties<A> {
+	/**
+	 * Internal field to identify the stage of the view.
+	 * This is used to create the correct type of the view.
+	 */
+	readonly [_stage]: "parsed";
+	/**
+	 * URI to the source file of this view.
+	 * Undefined if the view is auto-generated.
+	 */
+	readonly docUri?: string | undefined;
+	/**
+	 * If the view is changed manually this field contains the layout data.
+	 */
+	readonly manualLayout?: ViewManualLayout | undefined;
+}
 type NodeNotation = {
 	kinds: string[];
 	shape: ElementShape;
@@ -512,6 +1014,83 @@ interface ViewWithHash {
 	 */
 	hash: string;
 }
+interface ElementViewIncludePredicate<A extends Any = Any> extends AnyIncludePredicate<ModelExpression<A>> {
+}
+interface ElementViewExcludePredicate<A extends Any = Any> extends AnyExcludePredicate<ModelExpression<A>> {
+}
+type ElementViewPredicate<A extends Any = Any> = ElementViewIncludePredicate<A> | ElementViewExcludePredicate<A>;
+interface ElementViewRuleGroup<A extends Any = Any> {
+	groupRules: Array<ElementViewPredicate<A> | ElementViewRuleGroup<A>>;
+	title: string | null;
+	color?: Color;
+	border?: BorderStyle;
+	opacity?: number;
+	multiple?: boolean;
+	size?: ShapeSize;
+	padding?: SpacingSize;
+	textSize?: TextSize;
+}
+interface ElementViewRuleStyle<A extends Any = Any> extends AnyViewRuleStyle<ModelFqnExpr<A>> {
+}
+type ElementViewRule<A extends Any = Any> = ExclusiveUnion<{
+	IncludePredicate: ElementViewIncludePredicate<A>;
+	ExcludePredicate: ElementViewExcludePredicate<A>;
+	Group: ElementViewRuleGroup<A>;
+	Style: ElementViewRuleStyle<A>;
+	GlobalStyle: ViewRuleGlobalStyle;
+	GlobalPredicateRef: ViewRuleGlobalPredicateRef;
+	AutoLayout: ViewRuleAutoLayout;
+}>;
+interface ParsedElementView<A extends Any = Any> extends BaseParsedViewProperties<A> {
+	[_type]: "element";
+	readonly rules: ElementViewRule<A>[];
+	readonly viewOf?: Fqn$1<A>;
+	readonly extends?: StrictViewId<A>;
+}
+interface DynamicViewStep<A extends Any = Any> {
+	readonly source: Fqn$1<A>;
+	readonly target: Fqn$1<A>;
+	readonly title: string | null;
+	readonly description?: string;
+	readonly technology?: string;
+	readonly notation?: string;
+	readonly notes?: MarkdownOrString;
+	readonly color?: Color;
+	readonly line?: RelationshipLineType;
+	readonly head?: RelationshipArrowType;
+	readonly tail?: RelationshipArrowType;
+	readonly isBackward?: boolean;
+	readonly navigateTo?: StrictViewId<A>;
+}
+interface DynamicViewParallelSteps<A extends Any = Any> {
+	readonly __parallel: DynamicViewStep<A>[];
+}
+type DynamicViewStepOrParallel<A extends Any = Any> = Simplify<MergeExclusive<DynamicViewStep<A>, DynamicViewParallelSteps<A>>>;
+interface DynamicViewIncludeRule<A extends Any = Any> {
+	include: ModelFqnExpr.Any<A>[];
+}
+type DynamicViewRule<A extends Any = Any> = ExclusiveUnion<{
+	Include: DynamicViewIncludeRule<A>;
+	GlobalPredicateRef: ViewRuleGlobalPredicateRef;
+	ElementViewRuleStyle: ElementViewRuleStyle<A>;
+	GlobalStyle: ViewRuleGlobalStyle;
+	AutoLayout: ViewRuleAutoLayout;
+}>;
+interface ParsedDynamicView<A extends Any = Any> extends BaseParsedViewProperties<A> {
+	[_type]: "dynamic";
+	readonly steps: DynamicViewStepOrParallel<A>[];
+	readonly rules: DynamicViewRule<A>[];
+}
+type GlobalPredicateId = Tagged<string, "GlobalPredicateId">;
+type GlobalPredicates<A extends Any = Any> = NonEmptyArray<ElementViewPredicate<A>>;
+type GlobalDynamicPredicates<A extends Any = Any> = NonEmptyArray<DynamicViewIncludeRule<A>>;
+type GlobalStyleID = Tagged<string, "GlobalStyleID">;
+type GlobalStyles<A extends Any = Any> = NonEmptyTuple<ElementViewRuleStyle<A>>;
+interface ModelGlobals<A extends Any = Any> {
+	readonly predicates: Record<GlobalPredicateId, GlobalPredicates<A>>;
+	readonly dynamicPredicates: Record<GlobalPredicateId, GlobalDynamicPredicates<A>>;
+	readonly styles: Record<GlobalStyleID, GlobalStyles<A>>;
+}
 interface ElementStyle {
 	readonly border?: BorderStyle;
 	/**
@@ -534,6 +1113,133 @@ interface ElementStyle {
 	readonly padding?: SpacingSize;
 	readonly textSize?: TextSize;
 }
+interface Element$1<A extends Any = Any> extends WithOptionalTags<A>, WithOptionalLinks, WithMetadata<A> {
+	readonly id: Fqn$1<A>;
+	readonly kind: ElementKind$1<A>;
+	readonly title: string;
+	readonly description?: MarkdownOrString | null;
+	readonly technology?: string | null;
+	readonly tags?: Tags<A> | null;
+	readonly links?: readonly Link[] | null;
+	readonly icon?: Icon;
+	readonly shape?: ElementShape;
+	readonly color?: Color;
+	readonly style?: ElementStyle;
+	readonly notation?: string | null;
+	readonly metadata?: Metadata<A>;
+}
+interface AbstractRelationship<A extends Any> extends WithOptionalTags<A>, WithOptionalLinks, WithMetadata<A> {
+	readonly id: RelationId;
+	readonly title?: string | null;
+	readonly description?: MarkdownOrString | null;
+	readonly technology?: string | null;
+	readonly kind?: RelationKind<A>;
+	readonly color?: Color;
+	readonly line?: RelationshipLineType;
+	readonly head?: RelationshipArrowType;
+	readonly tail?: RelationshipArrowType;
+	readonly tags?: Tags<A> | null;
+	readonly links?: readonly Link[] | null;
+	readonly navigateTo?: ViewId$1<A>;
+	readonly metadata?: Metadata<A>;
+}
+interface Relationship<A extends Any = Any> extends AbstractRelationship<A> {
+	readonly source: FqnRef.ModelRef<A>;
+	readonly target: FqnRef.ModelRef<A>;
+}
+interface DeploymentElementStyle extends ElementStyle {
+	readonly icon?: Icon;
+	readonly shape?: ElementShape;
+	readonly color?: Color;
+}
+interface DeploymentNode<A extends Any = Unknown> extends WithOptionalTags<A>, WithOptionalLinks, WithMetadata<A> {
+	element?: never;
+	readonly id: DeploymentFqn$1<A>;
+	readonly kind: DeploymentKind$1<A>;
+	readonly title: string;
+	readonly description?: MarkdownOrString | null;
+	readonly technology?: string | null;
+	readonly tags?: Tags<A> | null;
+	readonly links?: readonly Link[] | null;
+	readonly style: DeploymentElementStyle;
+	readonly notation?: string | null;
+	readonly metadata?: Metadata<A>;
+}
+interface DeployedInstance<A extends Any = Unknown> extends WithOptionalTags<A>, WithOptionalLinks, WithMetadata<A> {
+	kind?: never;
+	/**
+	 * Format: `<DeploymentNode Fqn>.<Instance Id>`
+	 * i.e parent fqn is deployment target
+	 */
+	readonly id: DeploymentFqn$1<A>;
+	readonly element: Fqn$1<A>;
+	readonly title?: string;
+	readonly description?: MarkdownOrString | null;
+	readonly technology?: string | null;
+	readonly tags?: Tags<A> | null;
+	readonly links?: readonly Link[] | null;
+	readonly style?: DeploymentElementStyle;
+	readonly notation?: string;
+	readonly metadata?: Metadata<A>;
+}
+type DeploymentElement<A extends Any = Unknown> = DeploymentNode<A> | DeployedInstance<A>;
+interface DeploymentRelationship<A extends Any = Unknown> extends AbstractRelationship<A> {
+	readonly source: FqnRef.DeploymentRef<A>;
+	readonly target: FqnRef.DeploymentRef<A>;
+}
+interface ElementSpecification {
+	tags?: Tag$1[];
+	title?: string;
+	description?: MarkdownOrString;
+	technology?: string;
+	notation?: string;
+	links?: NonEmptyArray<Link>;
+	style: {
+		shape?: ElementShape;
+		icon?: Icon;
+		color?: Color;
+		border?: BorderStyle;
+		opacity?: number;
+		size?: ShapeSize;
+		padding?: SpacingSize;
+		textSize?: TextSize;
+		multiple?: boolean;
+	};
+}
+interface TagSpecification {
+	color: ThemeColor | ColorLiteral;
+}
+interface RelationshipSpecification {
+	technology?: string;
+	notation?: string;
+	color?: Color;
+	line?: RelationshipLineType;
+	head?: RelationshipArrowType;
+	tail?: RelationshipArrowType;
+}
+type Specification<A> = A extends Any ? {
+	tags: {
+		[key in Tag$2<A>]: TagSpecification;
+	};
+	elements: {
+		[key in ElementKind$1<A>]: Partial<ElementSpecification>;
+	};
+	deployments: {
+		[key in DeploymentKind$1<A>]: Partial<ElementSpecification>;
+	};
+	relationships: {
+		[key in RelationKind<A>]: Partial<RelationshipSpecification>;
+	};
+	metadataKeys?: IsNever<MetadataKey<A>> extends true ? never : MetadataKey<A>[];
+	customColors?: CustomColorDefinitions;
+} : never;
+interface LikeC4Project {
+	/**
+	 * ID of the project, casted to {@link scalar.ProjectId}
+	 */
+	readonly id: ProjectId;
+	title?: string;
+}
 interface ComputedNode<A extends Any = Any> extends WithOptionalLinks {
 	id: NodeId;
 	kind: ElementKind$1<A> | DeploymentKind$1<A> | "@group";
@@ -593,6 +1299,27 @@ interface ComputedEdge<A extends Any = Any> extends WithOptionalTags<A> {
 	 */
 	dir?: "forward" | "back" | "both";
 }
+interface BaseComputedViewProperties<A extends Any> extends BaseViewProperties<A>, ViewWithHash, ViewWithNotation {
+	readonly [_stage]: "computed";
+	readonly autoLayout: ViewAutoLayout;
+	readonly nodes: ComputedNode<A>[];
+	readonly edges: ComputedEdge<A>[];
+	/**
+	 * If the view is changed manually this field contains the layout data.
+	 */
+	readonly manualLayout?: ViewManualLayout | undefined;
+}
+interface ComputedElementView<A extends Any = Any> extends BaseComputedViewProperties<A> {
+	readonly [_type]: "element";
+	readonly viewOf?: Fqn$1<A>;
+	readonly extends?: StrictViewId<A>;
+}
+interface ComputedDeploymentView<A extends Any = Any> extends BaseComputedViewProperties<A> {
+	readonly [_type]: "deployment";
+}
+interface ComputedDynamicView<A extends Any = Any> extends BaseComputedViewProperties<A> {
+	readonly [_type]: "dynamic";
+}
 interface DiagramNode<A extends Any = Any> extends ComputedNode<A>, BBox {
 	x: number;
 	y: number;
@@ -656,7 +1383,107 @@ interface LayoutedDeploymentView<A extends Any = Any> extends BaseLayoutedViewPr
 interface LayoutedDynamicView<A extends Any = Any> extends BaseLayoutedViewProperties<A> {
 	readonly [_type]: "dynamic";
 }
+interface DeploymentViewIncludePredicate<A extends Any = Unknown> extends AnyIncludePredicate<Expression<A>> {
+}
+interface DeploymentViewExcludePredicate<A extends Any = Unknown> extends AnyExcludePredicate<Expression<A>> {
+}
+interface DeploymentViewRuleStyle<A extends Any = Unknown> extends AnyViewRuleStyle<FqnExpr<A>> {
+}
+type DeploymentViewRule<A extends Any = Unknown> = ExclusiveUnion<{
+	Include: DeploymentViewIncludePredicate<A>;
+	Exclude: DeploymentViewExcludePredicate<A>;
+	Style: DeploymentViewRuleStyle<A>;
+	AutoLayout: ViewRuleAutoLayout;
+}>;
+interface ParsedDeploymentView<A extends Any = Unknown> extends BaseParsedViewProperties<A> {
+	[_type]: "deployment";
+	readonly rules: DeploymentViewRule<A>[];
+}
+type ParsedView<A extends Any = Any> = ParsedElementView<A> | ParsedDeploymentView<A> | ParsedDynamicView<A>;
+type ComputedView<A extends Any = Any> = ComputedElementView<A> | ComputedDeploymentView<A> | ComputedDynamicView<A>;
 type LayoutedView<A extends Any = Any> = LayoutedElementView<A> | LayoutedDeploymentView<A> | LayoutedDynamicView<A>;
+type AnyView<A extends Any = Any> = ParsedElementView<A> | ParsedDeploymentView<A> | ParsedDynamicView<A> | ComputedElementView<A> | ComputedDeploymentView<A> | ComputedDynamicView<A> | LayoutedElementView<A> | LayoutedDeploymentView<A> | LayoutedDynamicView<A>;
+type ViewWithType<V extends AnyView<Any>, T extends ViewType> = Extract<V, {
+	[_type]: T;
+}>;
+interface BaseLikeC4ModelData<A extends Any> {
+	projectId: ProjectId$1<A>;
+	project: LikeC4Project;
+	specification: Specification<A>;
+	elements: Record<ElementId<A>, Element$1<A>>;
+	deployments: {
+		elements: Record<DeploymentId<A>, DeploymentElement<A>>;
+		relations: Record<RelationId, DeploymentRelationship<A>>;
+	};
+	relations: Record<RelationId, Relationship<A>>;
+	globals: ModelGlobals;
+	imports: Record<string, NonEmptyArray<Element$1<A>>>;
+}
+interface ParsedLikeC4ModelData<A extends Any = UnknownParsed> extends BaseLikeC4ModelData<A> {
+	[_stage]: "parsed";
+	views: Record<ViewId$1<A>, ParsedView<A>>;
+}
+interface ComputedLikeC4ModelData<A extends Any = UnknownComputed> extends BaseLikeC4ModelData<A> {
+	[_stage]: "computed";
+	views: Record<ViewId$1<A>, ComputedView<A>>;
+}
+interface LayoutedLikeC4ModelData<A extends Any = UnknownLayouted> extends BaseLikeC4ModelData<A> {
+	[_stage]: "layouted";
+	views: Record<ViewId$1<A>, LayoutedView<A>>;
+}
+interface SpecificationDump {
+	elements: {
+		[kind: string]: object;
+	};
+	tags?: {
+		[tag: string]: object;
+	};
+	deployments?: {
+		[kind: string]: object;
+	};
+	relationships?: {
+		[kind: string]: object;
+	};
+	metadataKeys?: string[];
+	customColors?: {
+		[kind: string]: object;
+	};
+}
+type SpecTypesFromDump<J> = J extends SpecificationDump ? SpecAux<KeysOf<J["elements"]>, KeysOf<J["deployments"]>, KeysOf<J["relationships"]>, KeysOf<J["tags"]>, J["metadataKeys"] extends readonly [
+	string,
+	...string[]
+] ? J["metadataKeys"][number] : never> : SpecAux<never, never, never, never, never>;
+type LikeC4ModelDump = {
+	[_stage]?: "computed" | "layouted";
+	projectId?: string;
+	project?: ProjectDump;
+	specification: SpecificationDump;
+	elements?: {
+		[kind: string]: object;
+	};
+	deployments: {
+		elements?: {
+			[kind: string]: object;
+		};
+		relations?: {};
+	};
+	views?: {
+		[kind: string]: object;
+	};
+	relations?: {};
+	globals?: {
+		predicates?: {};
+		dynamicPredicates?: {};
+		styles?: {};
+	};
+	imports?: {};
+};
+type ProjectDump = {
+	id: string;
+	name?: string;
+	title?: string | undefined;
+};
+type AuxFromDump<D> = D extends LikeC4ModelDump ? Aux<D[_stage] extends infer S extends string & "computed" | "layouted" ? S : "computed" | "layouted" | "parsed", KeysOf<D["elements"]>, KeysOf<D["deployments"]["elements"]>, KeysOf<D["views"]>, D["projectId"] extends infer PID extends string ? PID : never, SpecTypesFromDump<D["specification"]>> : Never;
 interface RichTextEmpty {
 	readonly isEmpty: true;
 	readonly isMarkdown: false;
@@ -776,7 +1603,7 @@ type CoordinateExtent = [
 	]
 ];
 type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;
-type NodeBase<NodeData extends Record<string, unknown> = Record<string, unknown>, NodeType extends string = string> = {
+type NodeBase<NodeData extends Record<string, unknown> = Record<string, unknown>, NodeType extends string | undefined = string | undefined> = {
 	/** Unique id of a node. */
 	id: string;
 	/**
@@ -786,8 +1613,6 @@ type NodeBase<NodeData extends Record<string, unknown> = Record<string, unknown>
 	position: XYPosition;
 	/** Arbitrary data passed to a node. */
 	data: NodeData;
-	/** Type of node defined in `nodeTypes`. */
-	type?: NodeType;
 	/**
 	 * Only relevant for default, source, target nodeType. Controls source position.
 	 * @example 'right', 'left', 'top', 'bottom'
@@ -844,7 +1669,13 @@ type NodeBase<NodeData extends Record<string, unknown> = Record<string, unknown>
 		width?: number;
 		height?: number;
 	};
-};
+} & (undefined extends NodeType ? {
+	/** Type of node defined in nodeTypes */
+	type?: string | undefined;
+} : {
+	/** Type of node defined in nodeTypes */
+	type: NodeType;
+});
 type InternalNodeBase<NodeType extends NodeBase = NodeBase> = Omit<NodeType, "measured"> & {
 	measured: {
 		width?: number;
@@ -949,6 +1780,8 @@ type FitViewOptionsBase<NodeType extends NodeBase = NodeBase> = {
 	minZoom?: number;
 	maxZoom?: number;
 	duration?: number;
+	ease?: (t: number) => number;
+	interpolate?: "smooth" | "linear";
 	nodes?: (NodeType | {
 		id: string;
 	})[];
@@ -970,6 +1803,8 @@ declare enum PanOnScrollMode {
 }
 type ViewportHelperFunctionOptions = {
 	duration?: number;
+	ease?: (t: number) => number;
+	interpolate?: "smooth" | "linear";
 };
 type SetCenterOptions = ViewportHelperFunctionOptions & {
 	zoom?: number;
@@ -1082,8 +1917,8 @@ declare enum ConnectionLineType {
 	SimpleBezier = "simplebezier"
 }
 type EdgeMarker = {
-	type: MarkerType;
-	color?: string;
+	type: MarkerType | `${MarkerType}`;
+	color?: string | null;
 	width?: number;
 	height?: number;
 	markerUnits?: string;
@@ -1103,6 +1938,24 @@ type EdgePosition = {
 	sourcePosition: Position;
 	targetPosition: Position;
 };
+declare const defaultAriaLabelConfig: {
+	"node.a11yDescription.default": string;
+	"node.a11yDescription.keyboardDisabled": string;
+	"node.a11yDescription.ariaLiveMessage": ({ direction, x, y }: {
+		direction: string;
+		x: number;
+		y: number;
+	}) => string;
+	"edge.a11yDescription.default": string;
+	"controls.ariaLabel": string;
+	"controls.zoomIn.ariaLabel": string;
+	"controls.zoomOut.ariaLabel": string;
+	"controls.fitView.ariaLabel": string;
+	"controls.interactive.ariaLabel": string;
+	"minimap.ariaLabel": string;
+	"handle.ariaLabel": string;
+};
+type AriaLabelConfig = typeof defaultAriaLabelConfig;
 type OnNodesChange<NodeType extends Node$1 = Node$1> = (changes: NodeChange<NodeType>[]) => void;
 type OnEdgesChange<EdgeType extends Edge = Edge> = (changes: EdgeChange<EdgeType>[]) => void;
 type OnNodesDelete<NodeType extends Node$1 = Node$1> = (nodes: NodeType[]) => void;
@@ -1159,6 +2012,7 @@ type ViewportHelperFunctions = {
 	 *
 	 * @param viewport - the viewport to set
 	 * @param options.duration - optional duration. If set, a transition will be applied
+	 * @param options.ease - optional ease function.
 	 */
 	setViewport: SetViewport;
 	/**
@@ -1174,6 +2028,8 @@ type ViewportHelperFunctions = {
 	 * @param x - x position
 	 * @param y - y position
 	 * @param options.zoom - optional zoom
+	 * @param options.duration - optional duration. If set, a transition will be applied
+	 * @param options.ease - optional ease function.
 	 */
 	setCenter: SetCenter;
 	/**
@@ -1183,6 +2039,8 @@ type ViewportHelperFunctions = {
 	 *
 	 * @param bounds - the bounds ({ x: number, y: number, width: number, height: number }) to fit the view to
 	 * @param options.padding - optional padding
+	 * @param options.duration - optional duration. If set, a transition will be applied
+	 * @param options.ease - optional ease function.
 	 */
 	fitBounds: FitBounds;
 	/**
@@ -1212,11 +2070,20 @@ type ViewportHelperFunctions = {
 };
 type OnBeforeDelete<NodeType extends Node$1 = Node$1, EdgeType extends Edge = Edge> = OnBeforeDeleteBase<NodeType, EdgeType>;
 type IsValidConnection<EdgeType extends Edge = Edge> = (edge: EdgeType | Connection) => boolean;
-type Node$1<NodeData extends Record<string, unknown> = Record<string, unknown>, NodeType extends string = string> = NodeBase<NodeData, NodeType> & {
+type Node$1<NodeData extends Record<string, unknown> = Record<string, unknown>, NodeType extends string | undefined = string | undefined> = NodeBase<NodeData, NodeType> & {
 	style?: CSSProperties;
 	className?: string;
 	resizing?: boolean;
 	focusable?: boolean;
+	/**
+	 * The ARIA role attribute for the node element, used for accessibility.
+	 * @default "group"
+	 */
+	ariaRole?: AriaRole;
+	/**
+	 * General escape hatch for adding custom attributes to the node's DOM element.
+	 */
+	domAttributes?: Omit<HTMLAttributes<HTMLDivElement>, "id" | "style" | "className" | "draggable" | "role" | "aria-label" | "defaultValue" | keyof DOMAttributes<HTMLDivElement>>;
 };
 type InternalNode<NodeType extends Node$1 = Node$1> = InternalNodeBase<NodeType>;
 type NodeMouseHandler<NodeType extends Node$1 = Node$1> = (event: ReactMouseEvent, node: NodeType) => void;
@@ -1251,6 +2118,15 @@ type Edge<EdgeData extends Record<string, unknown> = Record<string, unknown>, Ed
 	 */
 	reconnectable?: boolean | HandleType;
 	focusable?: boolean;
+	/**
+	 * The ARIA role attribute for the edge, used for accessibility.
+	 * @default "group"
+	 */
+	ariaRole?: AriaRole;
+	/**
+	 * General escape hatch for adding custom attributes to the edge's DOM element.
+	 */
+	domAttributes?: Omit<SVGAttributes<SVGGElement>, "id" | "style" | "className" | "role" | "aria-label">;
 };
 type EdgeMouseHandler<EdgeType extends Edge = Edge> = (event: ReactMouseEvent, edge: EdgeType) => void;
 type DefaultEdgeOptions = DefaultEdgeOptionsBase<Edge>;
@@ -1370,7 +2246,7 @@ interface ReactFlowProps<NodeType extends Node$1 = Node$1, EdgeType extends Edge
 	 * This event fires when the user releases the source or target of an editable edge. It is called
 	 * even if an edge update does not occur.
 	 */
-	onReconnectEnd?: (event: MouseEvent | TouchEvent, edge: EdgeType, handleType: HandleType) => void;
+	onReconnectEnd?: (event: MouseEvent | TouchEvent, edge: EdgeType, handleType: HandleType, connectionState: FinalConnectionState) => void;
 	/**
 	 * Use this event handler to add interactivity to a controlled flow.
 	 * It is called on node drag, select, and move.
@@ -1615,6 +2491,11 @@ interface ReactFlowProps<NodeType extends Node$1 = Node$1, EdgeType extends Edge
 	 * @default true
 	 */
 	nodesDraggable?: boolean;
+	/**
+	 * When `true`, the viewport will pan when a node is focused.
+	 * @default true
+	 */
+	autoPanOnNodeFocus?: boolean;
 	/**
 	 * Controls whether all nodes should be connectable or not. Individual nodes can override this
 	 * setting by setting their `connectable` prop.
@@ -1720,9 +2601,10 @@ interface ReactFlowProps<NodeType extends Node$1 = Node$1, EdgeType extends Edge
 	nodeExtent?: CoordinateExtent;
 	/**
 	 * Color of edge markers.
+	 * You can pass `null` to use the CSS variable `--xy-edge-stroke` for the marker color.
 	 * @default '#b1b1b7'
 	 */
-	defaultMarkerColor?: string;
+	defaultMarkerColor?: string | null;
 	/**
 	 * Controls if the viewport should zoom by scrolling inside the container.
 	 * @default true
@@ -1771,7 +2653,7 @@ interface ReactFlowProps<NodeType extends Node$1 = Node$1, EdgeType extends Edge
 	noDragClassName?: string;
 	/**
 	 * Typically, scrolling the mouse wheel when the mouse is over the canvas will zoom the viewport.
-	 * Adding the `"nowheel"` class to an element n the canvas will prevent this behavior and this prop
+	 * Adding the `"nowheel"` class to an element in the canvas will prevent this behavior and this prop
 	 * allows you to change the name of that class.
 	 * @default "nowheel"
 	 */
@@ -1884,6 +2766,12 @@ interface ReactFlowProps<NodeType extends Node$1 = Node$1, EdgeType extends Edge
 	 * @default 1
 	 */
 	nodeDragThreshold?: number;
+	/**
+	 * The threshold in pixels that the mouse must move before a connection line starts to drag.
+	 * This is useful to prevent accidental connections when clicking on a handle.
+	 * @default 1
+	 */
+	connectionDragThreshold?: number;
 	/** Sets a fixed width for the flow. */
 	width?: number;
 	/** Sets a fixed height for the flow. */
@@ -1899,6 +2787,11 @@ interface ReactFlowProps<NodeType extends Node$1 = Node$1, EdgeType extends Edge
 	 * @default false
 	 */
 	debug?: boolean;
+	/**
+	 * Configuration for customizable labels, descriptions, and UI text. Provided keys will override the corresponding defaults.
+	 * Allows localization, customization of ARIA descriptions, control labels, minimap labels, and other UI strings.
+	 */
+	ariaLabelConfig?: Partial<AriaLabelConfig>;
 }
 type ReactFlowJsonObject<NodeType extends Node$1 = Node$1, EdgeType extends Edge = Edge> = {
 	nodes: NodeType[];
@@ -2002,7 +2895,7 @@ type GeneralHelpers<NodeType extends Node$1 = Node$1, EdgeType extends Edge = Ed
 	 * parameter can be set to `true` to include nodes that are only partially intersecting.
 	 *
 	 * @param node - the node or rect to check for intersections
-	 * @param partially - if true, the node is considered to be intersecting if it partially overlaps with the passed node or rect
+	 * @param partially - true by default, if set to false, only nodes that are fully intersecting will be returned
 	 * @param nodes - optional nodes array to check for intersections
 	 *
 	 * @returns an array of intersecting nodes
@@ -2125,46 +3018,1167 @@ type ControlsCustomLayoutProps = {
 	actionsGroup: ReactNode;
 };
 type ControlsCustomLayout = (props: ControlsCustomLayoutProps) => ReactNode;
-type Dimmed = "immediate" | boolean;
-type NodeData = {
+declare class DefaultMap<K, V> implements Iterable<[
+	K,
+	V
+]> {
+	// Members
+	size: number;
+	// Constructor
+	constructor(factory: (key: K, index: number) => V);
+	// Methods
+	clear(): void;
+	set(key: K, value: V): this;
+	delete(key: K): boolean;
+	has(key: K): boolean;
+	get(key: K): V;
+	peek(key: K): V | undefined;
+	forEach(callback: (value: V, key: K, map: this) => void, scope?: any): void;
+	keys(): IterableIterator<K>;
+	values(): IterableIterator<V>;
+	entries(): IterableIterator<[
+		K,
+		V
+	]>;
+	[Symbol.iterator](): IterableIterator<[
+		K,
+		V
+	]>;
+	inspect(): any;
+	// Statics
+	static autoIncrement(): number;
+}
+type RelationshipsIterator<A extends Any> = IteratorLike<RelationshipModel<A>>;
+interface AnyRelationshipModel<A extends Any> extends WithTags$1<A>, WithMetadata$1<A> {
+	readonly id: RelationId;
+	readonly expression: string;
+	readonly title: string | null;
+	readonly technology: string | null;
+	readonly description: RichTextOrEmpty;
+	readonly navigateTo: LikeC4ViewModel<A> | null;
+	readonly kind: RelationKind<A> | null;
+	readonly links: ReadonlyArray<Link>;
+	readonly color: Color;
+	readonly line: RelationshipLineType;
+	isDeploymentRelation(): this is DeploymentRelationModel<A>;
+	isModelRelation(): this is RelationshipModel<A>;
+	views(): ViewsIterator<A>;
+}
+declare class RelationshipModel<A extends Any = Any> implements AnyRelationshipModel<A> {
+	readonly model: LikeC4Model<A>;
+	readonly $relationship: Relationship<A>;
+	readonly source: ElementModel<A>;
+	readonly target: ElementModel<A>;
+	/**
+	 * Common ancestor of the source and target elements.
+	 * Represents the boundary of the Relation.
+	 */
+	readonly boundary: ElementModel<A> | null;
+	constructor(model: LikeC4Model<A>, $relationship: Relationship<A>);
+	get id(): RelationId;
+	get expression(): string;
+	get title(): string | null;
+	get technology(): string | null;
+	get description(): RichTextOrEmpty;
+	get navigateTo(): LikeC4ViewModel<A> | null;
+	get tags(): Tags<A>;
+	get kind(): RelationKind<A> | null;
+	get links(): ReadonlyArray<Link>;
+	get color(): Color;
+	get line(): RelationshipLineType;
+	/**
+	 * Iterate over all views that include this relationship.
+	 */
+	views(): ViewsIterator<A>;
+	isDeploymentRelation(): this is DeploymentRelationModel<A>;
+	isModelRelation(): this is RelationshipModel<A>;
+	hasMetadata(): boolean;
+	getMetadata(): Metadata<A>;
+	getMetadata(field: MetadataKey<A>): string | undefined;
+	/**
+	 * Checks if the relationship has the given tag.
+	 */
+	isTagged(tag: LooseTag<A>): boolean;
+}
+type ElementsIterator<M extends Any> = IteratorLike<ElementModel<M>>;
+declare class ElementModel<A extends Any = Any> implements WithTags$1<A>, WithMetadata$1<A> {
+	readonly $model: LikeC4Model<A>;
+	readonly $element: Element$1<A>;
+	readonly id: Fqn$1<A>;
+	readonly _literalId: ElementId<A>;
+	readonly hierarchyLevel: number;
+	readonly imported: null | {
+		from: ProjectId;
+		fqn: Fqn$1<A>;
+	};
+	constructor($model: LikeC4Model<A>, $element: Element$1<A>);
+	get name(): string;
+	get parent(): ElementModel<A> | null;
+	get kind(): ElementKind$1<A>;
+	get shape(): ElementShape;
+	get color(): Color;
+	get icon(): IconUrl | null;
 	/**
-	 * Whether the cursor is hovering over the node
+	 * Returns all tags of the element.
+	 * It includes tags from the element and its kind.
 	 */
-	hovered?: boolean;
+	get tags(): Tags<A>;
+	get title(): string;
+	get description(): RichTextOrEmpty;
+	get technology(): string | null;
+	get links(): ReadonlyArray<Link>;
+	get defaultView(): LikeC4ViewModel.ScopedElementView<A> | null;
+	get isRoot(): boolean;
+	get style(): SetRequired<ElementStyle, "size">;
+	isAncestorOf(another: ElementModel<A>): boolean;
+	isDescendantOf(another: ElementModel<A>): boolean;
 	/**
-	 * Whether the node is dimmed
-	 * 'immediate' means that the node is dimmed without delay
+	 * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
+	 * (from closest to root)
 	 */
-	dimmed?: Dimmed;
-};
-type Node$1 = Node$1<NodeData>;
-type NodeProps$2 = NodeProps$1<Node$1<NodeData, any>>;
-type EdgeData = {
+	ancestors(): ElementsIterator<A>;
 	/**
-	 * Whether the cursor is hovering over the edge
+	 * Returns the common ancestor of this element and another element.
 	 */
-	hovered?: boolean;
+	commonAncestor(another: ElementModel<A>): ElementModel<A> | null;
+	children(): ReadonlySet<ElementModel<A>>;
 	/**
-	 * Whether the edge is active (animated and highlighted)
+	 * Get all descendant elements (i.e. children, children’s children, etc.)
 	 */
-	active?: boolean;
+	descendants(sort?: "asc" | "desc"): ElementsIterator<A>;
 	/**
-	 * Whether the edge is dimmed
-	 * 'immediate' means that the edge is dimmed without delay
+	 * Get all sibling (i.e. same parent)
 	 */
-	dimmed?: Dimmed;
-};
-type Edge$1 = Simplify<Omit<Edge, "data"> & {
-	data: EdgeData;
-}>;
-type WithDimmed = {
-	data: {
-		dimmed?: Dimmed;
-	};
-};
-type WithHovered = {
-	data: {
-		hovered?: boolean;
+	siblings(): ElementsIterator<A>;
+	/**
+	 * Resolve siblings of the element and its ancestors
+	 * (from closest parent to root)
+	 */
+	ascendingSiblings(): ElementsIterator<A>;
+	/**
+	 * Resolve siblings of the element and its ancestors
+	 *  (from root to closest)
+	 */
+	descendingSiblings(): ElementsIterator<A>;
+	incoming(filter?: IncomingFilter): RelationshipsIterator<A>;
+	incomers(filter?: IncomingFilter): ElementsIterator<A>;
+	outgoing(filter?: OutgoingFilter): RelationshipsIterator<A>;
+	outgoers(filter?: OutgoingFilter): ElementsIterator<A>;
+	get allOutgoing(): ReadonlySet<RelationshipModel<A>>;
+	get allIncoming(): ReadonlySet<RelationshipModel<A>>;
+	/**
+	 * Iterate over all views that include this element.
+	 */
+	views(): ReadonlySet<LikeC4ViewModel<A>>;
+	/**
+	 * Iterate over all views that scope this element.
+	 * It is possible that element is not included in the view.
+	 */
+	scopedViews(): ReadonlySet<LikeC4ViewModel.ScopedElementView<A>>;
+	/**
+	 * @returns true if the element is deployed
+	 */
+	isDeployed(): boolean;
+	deployments(): DeployedInstancesIterator<A>;
+	hasMetadata(): boolean;
+	getMetadata(): Metadata<A>;
+	getMetadata(field: MetadataKey<A>): string | undefined;
+	/**
+	 * Checks if the element has the given tag.
+	 */
+	isTagged(tag: LooseTag<A>): boolean;
+}
+type NodesIterator<M extends Any, V extends $View<M>> = IteratorLike<NodeModel<M, V>>;
+declare class NodeModel<A extends Any = Any, V extends $View<A> = $View<A>> implements WithTags$1<A> {
+	#private;
+	readonly $view: LikeC4ViewModel<A, V>;
+	readonly $node: V["nodes"][number];
+	constructor($view: LikeC4ViewModel<A, V>, $node: V["nodes"][number]);
+	get id(): NodeId;
+	get title(): string;
+	get kind(): ElementKind$1<A> | DeploymentKind$1<A> | typeof GroupElementKind | "instance";
+	get description(): RichTextOrEmpty;
+	get technology(): string | null;
+	get parent(): NodeModel<A, V> | null;
+	get element(): ElementModel<A> | null;
+	get deployment(): DeploymentElementModel<A> | null;
+	get shape(): ElementShape;
+	get color(): Color;
+	get icon(): IconUrl | null;
+	get tags(): Tags<A>;
+	get links(): ReadonlyArray<Link>;
+	get navigateTo(): LikeC4ViewModel<A> | null;
+	get style(): ElementStyle;
+	children(): ReadonlySet<NodeModel<A, V>>;
+	/**
+	 * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
+	 * (from closest to root)
+	 */
+	ancestors(): NodesIterator<A, V>;
+	siblings(): NodesIterator<A, V>;
+	incoming(filter?: IncomingFilter): EdgesIterator<A, V>;
+	incomers(filter?: IncomingFilter): NodesIterator<A, V>;
+	outgoing(filter?: OutgoingFilter): EdgesIterator<A, V>;
+	outgoers(filter?: OutgoingFilter): NodesIterator<A, V>;
+	isDiagramNode(this: NodeModel<any, any>): this is NodeModel<A, ExtractOnStage<V, "layouted">>;
+	hasChildren(): boolean;
+	hasParent(): this is NodeModel.WithParent<A, V>;
+	/**
+	 * Check if this node references to logical model element.
+	 */
+	hasElement(): this is NodeModel.WithElement<A, V>;
+	/**
+	 * Check if this node references to deployment element (Node or Instance).
+	 */
+	hasDeployment(): this is NodeModel.WithDeploymentElement<A, V>;
+	/**
+	 * Check if this node references to deployed instance
+	 * Deployed instance always references to element and deployment element.
+	 */
+	hasDeployedInstance(): this is NodeModel.WithDeployedInstance<A, V>;
+	isGroup(): this is NodeModel.IsGroup<A, V>;
+	/**
+	 * Checks if the node has the given tag.
+	 */
+	isTagged(tag: LooseTag<A>): boolean;
+}
+declare namespace NodeModel {
+	interface WithParent<A extends Any = Any, V extends $View<A> = $View<A>> extends NodeModel<A, V> {
+		parent: NodeModel<A, V>;
+	}
+	interface WithElement<A extends Any = Any, V extends $View<A> = $View<A>> extends NodeModel<A, V> {
+		kind: ElementKind$1<A>;
+		element: ElementModel<A>;
+	}
+	interface WithDeploymentElement<A extends Any = Any, V extends $View<A> = $View<A>> extends NodeModel<A, V> {
+		kind: DeploymentKind$1<A>;
+		deployment: DeploymentElementModel<A>;
+	}
+	interface WithDeployedInstance<A extends Any = Any, V extends $View<A> = $View<A>> extends NodeModel<A, V> {
+		kind: "instance";
+		element: ElementModel<A>;
+		deployment: DeployedInstanceModel<A>;
+	}
+	interface IsGroup<A extends Any = Any, V extends $View<A> = $View<A>> extends NodeModel<A, V> {
+		kind: typeof GroupElementKind;
+		element: null;
+		deployment: null;
+	}
+}
+type EdgesIterator<A extends Any, V extends $View<A>> = IteratorLike<EdgeModel<A, V>>;
+declare class EdgeModel<A extends Any = Any, View extends $View<A> = $View<A>> implements WithTags$1<A> {
+	#private;
+	readonly view: LikeC4ViewModel<A, View>;
+	readonly $edge: View["edges"][number];
+	readonly source: NodeModel<A, View>;
+	readonly target: NodeModel<A, View>;
+	constructor(view: LikeC4ViewModel<A, View>, $edge: View["edges"][number], source: NodeModel<A, View>, target: NodeModel<A, View>);
+	get id(): EdgeId;
+	get parent(): NodeModel<A, View> | null;
+	get label(): string | null;
+	get description(): RichTextOrEmpty;
+	get technology(): string | null;
+	hasParent(): this is EdgeModel.WithParent<A, View>;
+	get tags(): Tags<A>;
+	get stepNumber(): number | null;
+	get navigateTo(): LikeC4ViewModel<A> | null;
+	get color(): Color;
+	get line(): RelationshipLineType;
+	isStep(): this is EdgeModel.StepEdge<A, View>;
+	relationships(type: "model"): IteratorLike<RelationshipModel<A>>;
+	relationships(type: "deployment"): IteratorLike<DeploymentRelationModel<A>>;
+	relationships(type?: "model" | "deployment"): IteratorLike<RelationshipModel<A> | DeploymentRelationModel<A>>;
+	includesRelation(rel: RelationId$1 | {
+		id: RelationId$1;
+	}): boolean;
+	isTagged(tag: LooseTag<A>): boolean;
+}
+declare namespace EdgeModel {
+	interface StepEdge<A extends Any, V extends $View<A>> extends EdgeModel<A, V> {
+		id: StepEdgeId;
+		stepNumber: number;
+	}
+	interface WithParent<A extends Any, V extends $View<A>> extends EdgeModel<A, V> {
+		parent: NodeModel<A, V>;
+	}
+}
+declare class LikeC4ViewsFolder<A extends Any = Any> {
+	readonly $model: LikeC4Model<A>;
+	/**
+	 * Path to this view folder, processed by {@link normalizeViewPath}
+	 *
+	 * @example
+	 * "Folder 1/Folder 2/Folder 3"
+	 */
+	readonly path: string;
+	/**
+	 * Title of this view folder.
+	 *
+	 * @example
+	 * // title is the last segment of the path
+	 * path = "Folder 1/Folder 2/Folder 3"
+	 * title = "Folder 3"
+	 */
+	readonly title: string;
+	/**
+	 * Whether this is the root view folder.
+	 *
+	 * !NOTE
+	 * Root folder is special folder with an empty path and used only for internal purposes. \
+	 * It is not visible to the user and should not be used in the code.
+	 */
+	readonly isRoot: boolean;
+	protected readonly parentPath: string | undefined;
+	protected readonly defaultViewId: StrictViewId<A> | undefined;
+	constructor($model: LikeC4Model<A>, path: NonEmptyArray<string>, defaultViewId: StrictViewId<A> | undefined);
+	/**
+	 * Default view of this view folder.\
+	 * It is for the case when there is a view at the same path as this folder.\
+	 * (if there are multiple views at the same path, the first one is chosen)
+	 *
+	 * @example
+	 * ```
+	 * // Assume the following views exist:
+	 * const views = [
+	 *   "Folder 1/ Folder 2 / View",
+	 *   "Folder 1/ Folder 2 / View / Subview",
+	 * ]
+	 * ```
+	 * Group with path `Folder 1/ Folder 2 / View`\
+	 * will have default view `Folder 1/ Folder 2 / View`
+	 */
+	get defaultView(): LikeC4ViewModel<A> | null;
+	/**
+	 * Returns path to this view folder as an array of ancestors (excluding root) and this view folder as the last element
+	 *
+	 * @throws Error if this is the root folder.
+	 */
+	get breadcrumbs(): [
+		...LikeC4ViewsFolder<A>[],
+		this
+	];
+	/**
+	 * Returns parent folder
+	 *
+	 * @throws Error if this is the root folder.
+	 */
+	get parent(): LikeC4ViewsFolder<A> | null;
+	/**
+	 * Returns sorted set of children
+	 * - First folders
+	 * - Then views
+	 */
+	get children(): ReadonlySet<LikeC4ViewsFolder<A> | LikeC4ViewModel<A>>;
+	/**
+	 * Returns sorted array of children folders
+	 */
+	get folders(): ReadonlyArray<LikeC4ViewsFolder<A>>;
+	/**
+	 * Returns all views in this view folder.
+	 */
+	get views(): ReadonlyArray<LikeC4ViewModel<A>>;
+}
+type ViewsIterator<A extends Any, V extends $View<A> = $View<A>> = IteratorLike<LikeC4ViewModel<A, V>>;
+declare class LikeC4ViewModel<A extends Any = Any, V extends $View<A> = $View<A>> implements WithTags$1<A> {
+	#private;
+	/**
+	 * Don't use in runtime, only for type inference
+	 */
+	readonly Aux: A;
+	readonly $view: V;
+	readonly $model: LikeC4Model<A>;
+	readonly title: string | null;
+	/**
+	 * View folder this view belongs to.
+	 * If view is top-level, this is the root folder.
+	 */
+	readonly folder: LikeC4ViewsFolder<A>;
+	/**
+	 * Path to this view, processed by {@link normalizeViewPath}
+	 *
+	 * @example
+	 * "Group 1/Group 2/View"
+	 */
+	readonly viewPath: string;
+	constructor(model: LikeC4Model<A>, view: V, folder: LikeC4ViewsFolder<A>);
+	get _type(): V[_type];
+	get id(): StrictViewId<A>;
+	/**
+	 * Returns title if defined, otherwise returns its {@link id}
+	 */
+	get titleOrId(): string;
+	/**
+	 * Returns title if defined, otherwise returns `Untitled`.
+	 */
+	get titleOrUntitled(): string;
+	/**
+	 * Returns path to this view as an array of groups and this view as the last element
+	 * If view is top-level, returns only this view.
+	 *
+	 * @example
+	 * viewPath = "Group 1/Group 2/View"
+	 *
+	 * breadcrumbs = [
+	 *   "Group 1",             // folder
+	 *   "Group 1/Group 2",     // folder
+	 *   "Group 1/Group 2/View" // view
+	 * ]
+	 */
+	get breadcrumbs(): [
+		...LikeC4ViewsFolder<A>[],
+		this
+	];
+	get description(): RichTextOrEmpty;
+	get tags(): Tags<A>;
+	get links(): ReadonlyArray<Link>;
+	get viewOf(): ElementModel<A> | null;
+	/**
+	 * All tags from nodes and edges.
+	 */
+	get includedTags(): Tags<A>;
+	roots(): NodesIterator<A, V>;
+	/**
+	 * Iterate over all nodes that have children.
+	 */
+	compounds(): NodesIterator<A, V>;
+	/**
+	 * Get node by id.
+	 * @throws Error if node is not found.
+	 */
+	node(node: NodeOrId): NodeModel<A, V>;
+	/**
+	 * Find node by id.
+	 */
+	findNode(node: NodeOrId): NodeModel<A, V> | null;
+	findNodeWithElement(element: LooseElementId<A> | {
+		id: Fqn$1<A>;
+	}): NodeModel.WithElement<A, V> | null;
+	/**
+	 * Iterate over all nodes.
+	 */
+	nodes(): NodesIterator<A, V>;
+	/**
+	 * Find edge by id.
+	 * @param edge Edge or id
+	 * @returns EdgeModel
+	 */
+	edge(edge: EdgeOrId): EdgeModel<A, V>;
+	findEdge(edge: EdgeOrId): EdgeModel<A, V> | null;
+	/**
+	 * Iterate over all edges.
+	 */
+	edges(): EdgesIterator<A, V>;
+	/**
+	 * Iterate over all edges.
+	 */
+	edgesWithRelation(relation: RelationId$1): EdgesIterator<A, V>;
+	/**
+	 * Nodes that have references to elements from logical model.
+	 */
+	elements(): IteratorLike<NodeModel.WithElement<A, V>>;
+	/**
+	 * Checks if the view has the given tag.
+	 */
+	isTagged(tag: LooseTag<A>): boolean;
+	includesElement(element: LooseElementId<A> | {
+		id: Fqn$1<A>;
+	}): boolean;
+	includesDeployment(deployment: LooseDeploymentId<A> | {
+		id: DeploymentFqn$1<A>;
+	}): boolean;
+	includesRelation(relation: RelationId | {
+		id: RelationId;
+	}): boolean;
+	/**
+	 * Below are type guards.
+	 */
+	isComputed(this: LikeC4ViewModel<any, any>): this is LikeC4ViewModel<toComputed<A>>;
+	isDiagram(this: LikeC4ViewModel<any, any>): this is LikeC4ViewModel<toLayouted<A>>;
+	isElementView(this: LikeC4ViewModel<any, any>): this is LikeC4ViewModel.ElementView<A, V>;
+	isScopedElementView(this: LikeC4ViewModel<any, any>): this is LikeC4ViewModel.ScopedElementView<A>;
+	isDeploymentView(this: LikeC4ViewModel<any, any>): this is LikeC4ViewModel.DeploymentView<A, V>;
+	isDynamicView(this: LikeC4ViewModel<any, any>): this is LikeC4ViewModel.DynamicView<A, V>;
+}
+declare namespace LikeC4ViewModel {
+	interface ElementView<A extends Any, V extends $View<A> = $View<A>> extends LikeC4ViewModel<A, ViewWithType<V, "element">> {
+	}
+	interface ScopedElementView<A extends Any> extends LikeC4ViewModel<A, ViewWithType<$View<A>, "element"> & {
+		viewOf: Fqn$1<A>;
+	}> {
+		viewOf: ElementModel<A>;
+	}
+	interface DeploymentView<A extends Any, V extends $View<A> = $View<A>> extends LikeC4ViewModel<A, ViewWithType<V, "deployment">> {
+	}
+	interface DynamicView<A extends Any, V extends $View<A> = $View<A>> extends LikeC4ViewModel<A, ViewWithType<V, "dynamic">> {
+	}
+}
+type IncomingFilter = "all" | "direct" | "to-descendants";
+type OutgoingFilter = "all" | "direct" | "from-descendants";
+type ElementOrFqn<A extends Any> = ElementId<A> | {
+	id: Fqn$1<A>;
+};
+type DeploymentOrFqn<A extends Any> = DeploymentId<A> | {
+	id: DeploymentFqn$1<A>;
+};
+type NodeOrId = string | {
+	id: NodeId;
+};
+type EdgeOrId = string | {
+	id: EdgeId;
+};
+type RelationOrId = string | {
+	id: RelationId;
+};
+type $View<A extends Any> = {
+	parsed: never;
+	computed: ComputedView<A>;
+	layouted: LayoutedView<A>;
+}[Stage<A>];
+type $ViewModel<A extends Any> = {
+	parsed: never;
+	computed: LikeC4ViewModel<A>;
+	layouted: LikeC4ViewModel<A>;
+}[Stage<A>];
+type $ModelData<A extends Any> = {
+	parsed: ParsedLikeC4ModelData<A>;
+	computed: ComputedLikeC4ModelData<A>;
+	layouted: LayoutedLikeC4ModelData<A>;
+}[Stage<A>];
+interface WithTags$1<A extends Any> {
+	get tags(): Tags<A>;
+	isTagged(tag: LooseTag<A>): boolean;
+}
+interface WithMetadata$1<A extends Any> {
+	hasMetadata(): boolean;
+	getMetadata(): Metadata<A>;
+	getMetadata(field: MetadataKey<A>): string | undefined;
+}
+declare class LikeC4DeploymentModel<A extends Any = Any> {
+	#private;
+	readonly $model: LikeC4Model<A>;
+	readonly $deployments: $ModelData<A>["deployments"];
+	constructor($model: LikeC4Model<A>);
+	element(el: DeploymentOrFqn<A>): DeploymentElementModel<A>;
+	findElement(el: LooseDeploymentId<A>): DeploymentElementModel<A> | null;
+	node(el: DeploymentOrFqn<A>): DeploymentNodeModel<A>;
+	findNode(el: LooseDeploymentId<A>): DeploymentNodeModel<A> | null;
+	instance(el: DeploymentOrFqn<A>): DeployedInstanceModel<A>;
+	findInstance(el: LooseDeploymentId<A>): DeployedInstanceModel<A> | null;
+	/**
+	 * Returns the root elements of the model.
+	 */
+	roots(): DeploymentNodesIterator<A>;
+	/**
+	 * Returns all elements in the model.
+	 */
+	elements(): DeploymentElementsIterator<A>;
+	/**
+	 * Returns all elements in the model.
+	 */
+	nodes(): DeploymentNodesIterator<A>;
+	nodesOfKind(kind: DeploymentKind$1<A>): DeploymentNodesIterator<A>;
+	instances(): DeployedInstancesIterator<A>;
+	/**
+	 * Iterate over all instances of the given logical element.
+	 */
+	instancesOf(element: ElementOrFqn<A>): DeployedInstancesIterator<A>;
+	deploymentRef(ref: FqnRef.DeploymentRef<A>): DeploymentElementModel<A> | NestedElementOfDeployedInstanceModel<A>;
+	/**
+	 * Returns all relationships in the model.
+	 */
+	relationships(): IteratorLike<DeploymentRelationModel<A>>;
+	/**
+	 * Returns a specific relationship by its ID.
+	 */
+	relationship(id: RelationOrId): DeploymentRelationModel<A>;
+	findRelationship(id: string): DeploymentRelationModel<A> | null;
+	/**
+	 * Returns all deployment views in the model.
+	 */
+	views(): IteratorLike<LikeC4ViewModel.DeploymentView<A>>;
+	/**
+	 * Returns the parent element of given element.
+	 * @see ancestors
+	 */
+	parent(element: DeploymentOrFqn<A>): DeploymentNodeModel<A> | null;
+	/**
+	 * Get all children of the element (only direct children),
+	 * @see descendants
+	 */
+	children(element: DeploymentOrFqn<A>): ReadonlySet<DeploymentElementModel<A>>;
+	/**
+	 * Get all sibling (i.e. same parent)
+	 */
+	siblings(element: DeploymentOrFqn<A>): DeploymentElementsIterator<A>;
+	/**
+	 * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
+	 * (from closest to root)
+	 */
+	ancestors(element: DeploymentOrFqn<A>): DeploymentNodesIterator<A>;
+	/**
+	 * Get all descendant elements (i.e. children, children’s children, etc.)
+	 */
+	descendants(element: DeploymentOrFqn<A>, sort?: "asc" | "desc"): DeploymentElementsIterator<A>;
+	/**
+	 * Incoming relationships to the element and its descendants
+	 * @see incomers
+	 */
+	incoming(element: DeploymentOrFqn<A>, filter?: IncomingFilter): IteratorLike<DeploymentRelationModel<A>>;
+	/**
+	 * Outgoing relationships from the element and its descendants
+	 * @see outgoers
+	 */
+	outgoing(element: DeploymentOrFqn<A>, filter?: OutgoingFilter): IteratorLike<DeploymentRelationModel<A>>;
+	private addElement;
+	private addRelation;
+}
+type DeploymentElementsIterator<A extends Any> = IteratorLike<DeploymentElementModel<A>>;
+type DeployedInstancesIterator<A extends Any> = IteratorLike<DeployedInstanceModel<A>>;
+type DeploymentNodesIterator<A extends Any> = IteratorLike<DeploymentNodeModel<A>>;
+type DeploymentElementModel<A extends Any = Any> = DeploymentNodeModel<A> | DeployedInstanceModel<A>;
+declare abstract class AbstractDeploymentElementModel<A extends Any> implements WithTags$1<A>, WithMetadata$1<A> {
+	abstract readonly id: DeploymentFqn$1<A>;
+	abstract readonly _literalId: DeploymentId<A>;
+	abstract readonly parent: DeploymentNodeModel<A> | null;
+	abstract readonly title: string;
+	abstract readonly hierarchyLevel: number;
+	abstract readonly $model: LikeC4DeploymentModel<A>;
+	abstract readonly $node: DeploymentElement<A>;
+	abstract readonly tags: Tags<A>;
+	get style(): SetRequired<DeploymentElementStyle, "shape" | "color" | "size">;
+	get shape(): ElementShape;
+	get color(): Color;
+	get description(): RichTextOrEmpty;
+	get technology(): string | null;
+	get links(): ReadonlyArray<Link>;
+	/**
+	 * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
+	 * (from closest to root)
+	 */
+	ancestors(): DeploymentNodesIterator<A>;
+	/**
+	 * Returns the common ancestor of this element and another element.
+	 */
+	commonAncestor(another: DeploymentElementModel<A>): DeploymentNodeModel<A> | null;
+	/**
+	 * Get all sibling (i.e. same parent)
+	 */
+	siblings(): DeploymentElementsIterator<A>;
+	/**
+	 * Check if the element is a sibling of another element
+	 */
+	isSibling(other: DeploymentElementModel<A>): boolean;
+	/**
+	 * Resolve siblings of the element and its ancestors
+	 *  (from closest to root)
+	 */
+	ascendingSiblings(): DeploymentElementsIterator<A>;
+	/**
+	 * Resolve siblings of the element and its ancestors
+	 *  (from root to closest)
+	 */
+	descendingSiblings(): DeploymentElementsIterator<A>;
+	incoming(filter?: IncomingFilter): IteratorLike<DeploymentRelationModel<A>>;
+	outgoing(filter?: OutgoingFilter): IteratorLike<DeploymentRelationModel<A>>;
+	incomers(filter?: IncomingFilter): IteratorLike<DeploymentRelationEndpoint<A>>;
+	outgoers(filter?: OutgoingFilter): IteratorLike<DeploymentRelationEndpoint<A>>;
+	/**
+	 * Iterate over all views that include this deployment element.
+	 */
+	views(): IteratorLike<LikeC4ViewModel.DeploymentView<A>>;
+	isDeploymentNode(): this is DeploymentNodeModel<A>;
+	isInstance(): this is DeployedInstanceModel<A>;
+	abstract outgoingModelRelationships(): RelationshipsIterator<A>;
+	abstract incomingModelRelationships(): RelationshipsIterator<A>;
+	get allOutgoing(): RelationshipsAccum<A>;
+	get allIncoming(): RelationshipsAccum<A>;
+	hasMetadata(): boolean;
+	getMetadata(): Metadata<A>;
+	getMetadata(field: MetadataKey<A>): string | undefined;
+	/**
+	 * Checks if the deployment element has the given tag.
+	 */
+	isTagged(tag: LooseTag<A>): boolean;
+}
+declare class DeploymentNodeModel<A extends Any = Any> extends AbstractDeploymentElementModel<A> {
+	readonly $model: LikeC4DeploymentModel<A>;
+	readonly $node: DeploymentNode<A>;
+	id: DeploymentFqn$1<A>;
+	_literalId: DeploymentId<A>;
+	title: string;
+	hierarchyLevel: number;
+	constructor($model: LikeC4DeploymentModel<A>, $node: DeploymentNode<A>);
+	get parent(): DeploymentNodeModel<A> | null;
+	get kind(): DeploymentKind$1<A>;
+	get tags(): Tags<A>;
+	children(): ReadonlySet<DeploymentElementModel<A>>;
+	descendants(sort?: "asc" | "desc"): DeploymentElementsIterator<A>;
+	isDeploymentNode(): this is DeploymentNodeModel<A>;
+	/**
+	 * Iterate over all instances nested in this deployment node.
+	 */
+	instances(): DeployedInstancesIterator<A>;
+	/**
+	 * Returns deployed instance inside this deployment node
+	 * if only there are no more instances
+	 */
+	onlyOneInstance(): DeployedInstanceModel<A> | null;
+	/**
+	 * Cached result of relationships from instances
+	 */
+	private _relationshipsFromInstances;
+	private relationshipsFromInstances;
+	/**
+	 * We return only relationships that are not already present in nested instances
+	 */
+	outgoingModelRelationships(): RelationshipsIterator<A>;
+	/**
+	 * We return only relationships that are not already present in nested instances
+	 */
+	incomingModelRelationships(): RelationshipsIterator<A>;
+	/**
+	 * Returns an iterator of relationships between nested instances
+	 */
+	internalModelRelationships(): ReadonlySet<RelationshipModel<A>>;
+}
+declare class DeployedInstanceModel<A extends Any = Any> extends AbstractDeploymentElementModel<A> {
+	readonly $model: LikeC4DeploymentModel<A>;
+	readonly $instance: DeployedInstance<A>;
+	readonly element: ElementModel<A>;
+	readonly id: DeploymentFqn$1<A>;
+	readonly _literalId: DeploymentId<A>;
+	readonly title: string;
+	readonly hierarchyLevel: number;
+	constructor($model: LikeC4DeploymentModel<A>, $instance: DeployedInstance<A>, element: ElementModel<A>);
+	get $node(): DeployedInstance<A>;
+	get parent(): DeploymentNodeModel<A>;
+	get style(): SetRequired<DeploymentElementStyle, "shape" | "color" | "size">;
+	get shape(): ElementShape;
+	get color(): Color;
+	get tags(): Tags<A>;
+	get kind(): ElementKind$1<A>;
+	get description(): RichTextOrEmpty;
+	get technology(): string | null;
+	get links(): ReadonlyArray<Link>;
+	isInstance(): this is DeployedInstanceModel<A>;
+	outgoingModelRelationships(): RelationshipsIterator<A>;
+	incomingModelRelationships(): RelationshipsIterator<A>;
+	/**
+	 * Iterate over all views that include this instance.
+	 * (Some views may include the parent deployment node instead of the instance.)
+	 */
+	views(): IteratorLike<LikeC4ViewModel.DeploymentView<A>>;
+}
+declare class NestedElementOfDeployedInstanceModel<A extends Any = Any> {
+	readonly instance: DeployedInstanceModel<A>;
+	readonly element: ElementModel<A>;
+	constructor(instance: DeployedInstanceModel<A>, element: ElementModel<A>);
+	get id(): DeploymentFqn$1<A>;
+	get _literalId(): DeploymentId<A>;
+	get style(): SetRequired<DeploymentElementStyle, "shape" | "color">;
+	get shape(): ElementShape;
+	get color(): Color;
+	get title(): string;
+	get description(): RichTextOrEmpty;
+	get technology(): string | null;
+	isDeploymentNode(): this is DeploymentNodeModel<A>;
+	isInstance(): this is DeployedInstanceModel<A>;
+}
+type DeploymentRelationEndpoint<A extends Any = Any> = DeploymentElementModel<A> | NestedElementOfDeployedInstanceModel<A>;
+declare class DeploymentRelationModel<A extends Any = Any> implements AnyRelationshipModel<A> {
+	readonly $model: LikeC4DeploymentModel<A>;
+	readonly $relationship: DeploymentRelationship<A>;
+	boundary: DeploymentNodeModel<A> | null;
+	source: DeploymentRelationEndpoint<A>;
+	target: DeploymentRelationEndpoint<A>;
+	constructor($model: LikeC4DeploymentModel<A>, $relationship: DeploymentRelationship<A>);
+	get id(): RelationId;
+	get expression(): string;
+	get title(): string | null;
+	get technology(): string | null;
+	get description(): RichTextOrEmpty;
+	get tags(): Tags<A>;
+	get kind(): RelationKind<A> | null;
+	get navigateTo(): LikeC4ViewModel<A> | null;
+	get links(): ReadonlyArray<Link>;
+	get color(): Color;
+	get line(): RelationshipLineType;
+	views(): IteratorLike<LikeC4ViewModel.DeploymentView<A>>;
+	isDeploymentRelation(): this is DeploymentRelationModel<A>;
+	isModelRelation(): this is RelationshipModel<A>;
+	hasMetadata(): boolean;
+	getMetadata(): Metadata<A>;
+	getMetadata(field: MetadataKey<A>): string | undefined;
+	/**
+	 * Checks if the relationship has the given tag.
+	 */
+	isTagged(tag: LooseTag<A>): boolean;
+}
+declare class RelationshipsAccum<A extends Any = Any> {
+	readonly model: ReadonlySet<RelationshipModel<A>>;
+	readonly deployment: ReadonlySet<DeploymentRelationModel<A>>;
+	static empty<A extends Any>(): RelationshipsAccum<A>;
+	static from<A extends Any>(model: Iterable<RelationshipModel<A>> | undefined, deployment?: Iterable<DeploymentRelationModel<A>>): RelationshipsAccum<A>;
+	/**
+	 * @param model relationships from logical model
+	 * @param deployment relationships from deployment model
+	 */
+	constructor(model?: ReadonlySet<RelationshipModel<A>>, deployment?: ReadonlySet<DeploymentRelationModel<A>>);
+	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<A>): RelationshipsAccum<A>;
+	/**
+	 * Returns new Accum containing all the elements which are both in this and otherAccum
+	 */
+	difference(otherAccum: RelationshipsAccum<A>): RelationshipsAccum<A>;
+	/**
+	 * Returns new Accum containing all the elements from both
+	 */
+	union(otherAccum: RelationshipsAccum<A>): RelationshipsAccum<A>;
+}
+declare class LikeC4Model<A extends Any = Unknown> {
+	/**
+	 * Don't use in runtime, only for type inference
+	 */
+	readonly Aux: A;
+	protected readonly _elements: Map<Fqn$1<A>, ElementModel<A>>;
+	protected readonly _parents: Map<Fqn$1<A>, ElementModel<A>>;
+	protected readonly _children: DefaultMap<Fqn$1<A>, Set<ElementModel<A>>>;
+	protected readonly _rootElements: Set<ElementModel<A>>;
+	protected readonly _relations: Map<RelationId<string>, RelationshipModel<A>>;
+	protected readonly _incoming: DefaultMap<Fqn$1<A>, Set<RelationshipModel<A>>>;
+	protected readonly _outgoing: DefaultMap<Fqn$1<A>, Set<RelationshipModel<A>>>;
+	protected readonly _internal: DefaultMap<Fqn$1<A>, Set<RelationshipModel<A>>>;
+	protected readonly _views: Map<ViewId$1<A>, LikeC4ViewModel<A, $View<A>>>;
+	protected readonly _rootViewFolder: LikeC4ViewsFolder<A>;
+	protected readonly _viewFolders: Map<string, LikeC4ViewsFolder<A>>;
+	protected readonly _viewFolderItems: DefaultMap<string, Set<LikeC4ViewModel<A, $View<A>> | LikeC4ViewsFolder<A>>>;
+	protected readonly _allTags: DefaultMap<Tag$2<A>, Set<LikeC4ViewModel<A, $View<A>> | ElementModel<A> | RelationshipModel<A>>>;
+	static fromParsed<T extends Any>(model: ParsedLikeC4ModelData<T>): LikeC4Model.Parsed<T>;
+	/**
+	 * Creates a new LikeC4Model instance from the provided model data.
+	 * Model with parsed data will not have views, as they must be computed
+	 * (this model is used for computing views)
+	 *
+	 * @typeParam M - Type parameter constrained to AnyLikeC4Model
+	 * @param model - The model data to create a LikeC4Model from
+	 * @returns A new LikeC4Model instance with the type derived from the input model
+	 */
+	static create<T extends Any>(model: ParsedLikeC4ModelData<T>): LikeC4Model.Parsed<T>;
+	static create<T extends Any>(model: LayoutedLikeC4ModelData<T>): LikeC4Model.Layouted<T>;
+	static create<T extends Any>(model: ComputedLikeC4ModelData<T>): LikeC4Model.Computed<T>;
+	/**
+	 * Creates a new LikeC4Model instance and infers types from a model dump.\
+	 * Model dump expected to be computed or layouted.
+	 *
+	 * @typeParam D - A constant type parameter extending LikeC4ModelDump
+	 * @param dump - The model dump to create the instance from
+	 * @returns A  new LikeC4Model instance with types inferred from the dump
+	 */
+	static fromDump<const D extends LikeC4ModelDump>(dump: D): LikeC4Model<AuxFromDump<D>>;
+	readonly deployment: LikeC4DeploymentModel<A>;
+	readonly $data: $ModelData<A>;
+	constructor($data: $ModelData<A>);
+	/**
+	 * Type narrows the model to the parsed stage.
+	 * This is useful for tests
+	 */
+	get asParsed(): LikeC4Model.Parsed<A>;
+	/**
+	 * Type narrows the model to the layouted stage.
+	 * This is useful for tests
+	 */
+	get asComputed(): LikeC4Model.Computed<A>;
+	/**
+	 * Type narrows the model to the layouted stage.
+	 * This is useful for tests
+	 */
+	get asLayouted(): LikeC4Model.Layouted<A>;
+	/**
+	 * Type guard the model to the parsed stage.
+	 */
+	isParsed(this: LikeC4Model<any>): this is LikeC4Model<toParsed<A>>;
+	/**
+	 * Type guard the model to the layouted stage.
+	 */
+	isLayouted(this: LikeC4Model<any>): this is LikeC4Model<toLayouted<A>>;
+	/**
+	 * Type guard the model to the computed stage.
+	 */
+	isComputed(this: LikeC4Model<any>): this is LikeC4Model<toComputed<A>>;
+	/**
+	 * Keeping here for backward compatibility
+	 * @deprecated use {@link $data}
+	 */
+	get $model(): $ModelData<A>;
+	get stage(): Stage<A>;
+	/**
+	 * Returns the Project ID associated with the model.
+	 * If the project ID is not defined in the model, it returns "default".
+	 */
+	get projectId(): ProjectId$1<A>;
+	/**
+	 * Returns the project associated with the model.
+	 * If the project is not defined in the model, it returns a default project with the ID "default".
+	 */
+	get project(): LikeC4Project;
+	get specification(): Specification<A>;
+	get globals(): ModelGlobals;
+	/**
+	 * Returns the element with the given FQN.
+	 *
+	 * @throws Error if element is not found\
+	 * Use {@link findElement} if you don't want to throw an error
+	 *
+	 * @note Method is type-safe for typed model
+  
+	 * @example
+	 * model.element('cloud.frontend')
+	 * // or object with id property of scalar.Fqn
+	 * model.element({
+	 *   id: 'dashboard',
+	 * })
+	 */
+	element(el: ElementOrFqn<A>): ElementModel<A>;
+	/**
+	 * Returns the element with the given FQN.
+	 *
+	 * @returns Element if found, null otherwise
+	 * @note Method is not type-safe as {@link element}
+	 *
+	 * @example
+	 * model.findElement('cloud.frontend')
+	 */
+	findElement(el: LooseElementId<A>): ElementModel<A> | null;
+	/**
+	 * Returns the root elements of the model.
+	 */
+	roots(): ElementsIterator<A>;
+	/**
+	 * Returns all elements in the model.
+	 */
+	elements(): ElementsIterator<A>;
+	/**
+	 * Returns all relationships in the model.
+	 */
+	relationships(): RelationshipsIterator<A>;
+	/**
+	 * 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(rel: RelationOrId, type: "model"): RelationshipModel<A>;
+	relationship(rel: RelationOrId, type: "deployment"): DeploymentRelationModel<A>;
+	relationship(rel: RelationId, type?: "model" | "deployment"): RelationshipModel<A> | DeploymentRelationModel<A>;
+	findRelationship(id: string, type: "model"): RelationshipModel<A> | null;
+	findRelationship(id: string, type: "deployment"): DeploymentRelationModel<A> | null;
+	findRelationship(id: string, type?: "model" | "deployment"): RelationshipModel<A> | DeploymentRelationModel<A> | null;
+	/**
+	 * Returns all views in the model.
+	 */
+	views(): IteratorLike<LikeC4ViewModel<A, $View<A>>>;
+	/**
+	 * Returns a specific view by its ID.
+	 * @note Method is type-safe for typed model
+	 * @throws Error if view is not found\
+	 * Use {@link findView} if you don't want to throw an error
+	 *
+	 * @example
+	 * model.view('index')
+	 * // or object with id property of scalar.ViewId
+	 * model.view({
+	 *   id: 'index',
+	 * })
+	 */
+	view(viewId: ViewId$1<A> | {
+		id: ViewId<ViewId$1<A>>;
+	}): LikeC4ViewModel<A, $View<A>>;
+	/**
+	 * Returns a specific view by its ID.
+	 * @note Method is not type-safe as {@link view}
+	 *
+	 * @example
+	 * model.findView('index')
+	 */
+	findView(viewId: LooseViewId<A>): LikeC4ViewModel<A, $View<A>> | null;
+	/**
+	 * Returns a view folder by its path.
+	 * Path is extracted from the view title, e.g. "Group 1/Group 2/View" -> "Group 1/Group 2"
+	 * @throws Error if view folder is not found.
+	 */
+	viewFolder(path: string): LikeC4ViewsFolder<A>;
+	/**
+	 * Root folder is a special one with an empty path and used only for internal purposes.
+	 * It is not visible to the user and should be used only to get top-level folders and views.
+	 */
+	get rootViewFolder(): LikeC4ViewsFolder<A>;
+	/**
+	 * Whether the model has any view folders.
+	 */
+	get hasViewFolders(): boolean;
+	/**
+	 * Returns all children of a view folder.
+	 * Path is extracted from the view title, e.g. "Group 1/Group 2/View" -> "Group 1/Group 2"
+	 *
+	 * @throws Error if view folder is not found.
+	 */
+	viewFolderItems(path: string): ReadonlySet<LikeC4ViewsFolder<A> | LikeC4ViewModel<A>>;
+	/**
+	 * Returns the parent element of given element.
+	 * @see ancestors
+	 */
+	parent(element: ElementOrFqn<A>): ElementModel<A> | null;
+	/**
+	 * Get all children of the element (only direct children),
+	 * @see descendants
+	 */
+	children(element: ElementOrFqn<A>): ReadonlySet<ElementModel<A>>;
+	/**
+	 * Get all sibling (i.e. same parent)
+	 */
+	siblings(element: ElementOrFqn<A>): ElementsIterator<A>;
+	/**
+	 * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
+	 * (from closest to root)
+	 */
+	ancestors(element: ElementOrFqn<A>): ElementsIterator<A>;
+	/**
+	 * Get all descendant elements (i.e. children, children’s children, etc.)
+	 */
+	descendants(element: ElementOrFqn<A>): ElementsIterator<A>;
+	/**
+	 * Incoming relationships to the element and its descendants
+	 * @see incomers
+	 */
+	incoming(element: ElementOrFqn<A>, filter?: IncomingFilter): RelationshipsIterator<A>;
+	/**
+	 * Outgoing relationships from the element and its descendants
+	 * @see outgoers
+	 */
+	outgoing(element: ElementOrFqn<A>, filter?: OutgoingFilter): RelationshipsIterator<A>;
+	/**
+	 * Returns array of all tags used in the model, sorted naturally.\
+	 * Use {@link specification.tags} to get all defined tags
+	 */
+	get tags(): Tags<A>;
+	/**
+	 * Returns all tags used in the model, sorted by usage count (descending).
+	 */
+	get tagsSortedByUsage(): ReadonlyArray<{
+		tag: Tag$2<A>;
+		count: number;
+		tagged: ReadonlySet<ElementModel<A> | RelationshipModel<A> | LikeC4ViewModel<A>>;
+	}>;
+	/**
+	 * Returns all elements, relationships and views marked with the given tag.
+	 */
+	findByTag(tag: Tag$2<A>): IteratorLike<ElementModel<A> | RelationshipModel<A> | LikeC4ViewModel<A>>;
+	findByTag(tag: Tag$2<A>, type: "elements"): IteratorLike<ElementModel<A>>;
+	findByTag(tag: Tag$2<A>, type: "views"): IteratorLike<LikeC4ViewModel<A>>;
+	findByTag(tag: Tag$2<A>, type: "relationships"): IteratorLike<RelationshipModel<A>>;
+	/**
+	 * Returns all elements of the given kind.
+	 */
+	elementsOfKind(kind: ElementKind$1<A>): IteratorLike<ElementModel<A>>;
+	/**
+	 * Returns all elements that match the given where operator.
+	 *
+	 * @example
+	 * ```ts
+	 * model.where({
+	 *   and: [
+	 *     { kind: 'component' },
+	 *     {
+	 *       or: [
+	 *         { tag: 'old' },
+	 *         { tag: { neq: 'new' } },
+	 *       ],
+	 *     },
+	 *   ],
+	 * })
+	 * ```
+	 */
+	elementsWhere(where: WhereOperator<A>): IteratorLike<ElementModel<A>>;
+	/**
+	 * Returns all **model** relationships that match the given where operator.
+	 *
+	 * @example
+	 * ```ts
+	 * model.relationshipsWhere({
+	 *   and: [
+	 *     { kind: 'uses' },
+	 *     {
+	 *       or: [
+	 *         { tag: 'old' },
+	 *         { tag: { neq: 'new' } },
+	 *       ],
+	 *     },
+	 *   ],
+	 * })
+	 * ```
+	 */
+	relationshipsWhere(where: WhereOperator<A>): IteratorLike<RelationshipModel<A>>;
+	private addElement;
+	private addImportedElement;
+	private addRelation;
+}
+declare namespace LikeC4Model {
+	const EMPTY: LikeC4Model<Aux<"computed", string, string, string, string, SpecAux<string, string, string, string, string>>>;
+	type Parsed<A = Unknown> = Unknown extends A ? LikeC4Model<UnknownParsed> : A extends Aux<any, infer E, infer D, infer V, infer PID, infer Spec> ? LikeC4Model<Aux<"parsed", E, D, V, PID, Spec>> : never;
+	type Computed<A = Unknown> = Unknown extends A ? LikeC4Model<UnknownComputed> : A extends Aux<any, infer E, infer D, infer V, infer PID, infer Spec> ? LikeC4Model<Aux<"computed", E, D, V, PID, Spec>> : never;
+	type Layouted<A = Unknown> = Unknown extends A ? LikeC4Model<UnknownLayouted> : A extends Aux<any, infer E, infer D, infer V, infer PID, infer Spec> ? LikeC4Model<Aux<"layouted", E, D, V, PID, Spec>> : never;
+	type Node<A = Unknown> = A extends Any ? NodeModel<A> : never;
+	type Element<A = Unknown> = A extends Any ? ElementModel<A> : never;
+	type Relationship<A = Unknown> = A extends Any ? RelationshipModel<A> : never;
+	type View<A = Unknown> = A extends Any ? $ViewModel<A> : never;
+	type DeploymentNode<A = Unknown> = A extends Any ? DeploymentNodeModel<A> : never;
+	type DeployedInstance<A = Unknown> = A extends Any ? DeployedInstanceModel<A> : never;
+	type AnyRelation<M = Unknown> = M extends Any ? RelationshipModel<M> | DeploymentRelationModel<M> : never;
+}
+type Dimmed = "immediate" | boolean;
+type NodeData = {
+	/**
+	 * Whether the cursor is hovering over the node
+	 */
+	hovered?: boolean;
+	/**
+	 * Whether the node is dimmed
+	 * 'immediate' means that the node is dimmed without delay
+	 */
+	dimmed?: Dimmed;
+};
+type Node$1 = Node$1<NodeData>;
+type NodeProps$2 = NodeProps$1<Node$1<NodeData, any>>;
+type EdgeData = {
+	/**
+	 * Whether the cursor is hovering over the edge
+	 */
+	hovered?: boolean;
+	/**
+	 * Whether the edge is active (animated and highlighted)
+	 */
+	active?: boolean;
+	/**
+	 * Whether the edge is dimmed
+	 * 'immediate' means that the edge is dimmed without delay
+	 */
+	dimmed?: Dimmed;
+};
+type Edge$1 = Simplify<Omit<Edge, "data"> & {
+	data: EdgeData;
+}>;
+type WithDimmed = {
+	data: {
+		dimmed?: Dimmed;
+	};
+};
+type WithHovered = {
+	data: {
+		hovered?: boolean;
 	};
 };
 declare function setDimmed<T extends WithDimmed>(value: T, dimmed: "immediate" | boolean): T;
@@ -2176,7 +4190,7 @@ type WithData<D> = {
 };
 declare function setData<E extends WithData<any>>(value: E, state: Partial<E["data"]>): E;
 declare function setData<E extends WithData<any>>(state: Partial<E["data"]>): (value: E) => E;
-type NodeProps$3<T extends Record<string, unknown> = {}, NodeType extends string = string> = NodeProps$1<Node$1<Base.NodeData & T, NodeType>>;
+type NodeProps$3<T extends Record<string, unknown> = {}, NodeType extends string = string> = Simplify<NodeProps$1<Node$1<Base.NodeData & T, NodeType>>>;
 type ReactFlowNode<Data extends Record<string, unknown>, NodeType extends string> = SetRequired<Node$1<Data, NodeType>, "type" | "initialWidth" | "initialHeight">;
 type ReactFlowEdge<Data extends Record<string, unknown>, EdgeType extends string> = SetRequired<Edge<Data, EdgeType>, "type" | "data">;
 type NonOptional<T extends object> = Simplify<{
@@ -2258,12 +4272,12 @@ declare namespace Types {
 	type Edge = RelationshipEdge;
 	type EdgeData = RelationshipEdgeData;
 }
-interface CustomNodes {
-	element?: undefined | ((props: NodeProps$3<Types.ElementNodeData, "element">) => ReactNode);
-	deployment?: undefined | ((props: NodeProps$3<Types.DeploymentElementNodeData, "deployment">) => ReactNode);
-	compoundElement?: undefined | ((props: NodeProps$3<Types.CompoundElementNodeData, "compound-element">) => ReactNode);
-	compoundDeployment?: undefined | ((props: NodeProps$3<Types.CompoundDeploymentNodeData, "compound-deployment">) => ReactNode);
-	viewGroup?: undefined | ((props: NodeProps$3<Types.ViewGroupNodeData, "view-group">) => ReactNode);
+export interface CustomNodes {
+	element?: FunctionComponent<NodeProps$3<Types.ElementNodeData, "element">>;
+	deployment?: FunctionComponent<NodeProps$3<Types.DeploymentElementNodeData, "deployment">>;
+	compoundElement?: FunctionComponent<NodeProps$3<Types.CompoundElementNodeData, "compound-element">>;
+	compoundDeployment?: FunctionComponent<NodeProps$3<Types.CompoundDeploymentNodeData, "compound-deployment">>;
+	viewGroup?: FunctionComponent<NodeProps$3<Types.ViewGroupNodeData, "view-group">>;
 }
 type DiagramNodeWithNavigate<A extends Any> = SetRequired<DiagramNode<A>, "navigateTo">;
 type ElementIconRendererProps = {
@@ -2275,14 +4289,18 @@ type ElementIconRendererProps = {
 	className?: string;
 };
 export type ElementIconRenderer = (props: ElementIconRendererProps) => ReactNode;
-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;
-type ChangeEvent = {
+export type OnNavigateTo<A extends Any = Any> = (to: _aux.ViewId<A>, event?: ReactMouseEvent, element?: DiagramNodeWithNavigate<A>) => void;
+export type OnNodeClick<A extends Any = Any> = (node: DiagramNode<A>, event: ReactMouseEvent) => void;
+export type OnEdgeClick<A extends Any = Any> = (edge: DiagramEdge<A>, event: ReactMouseEvent) => void;
+/**
+ * On pane/canvas click (not on any node or edge)
+ */
+export type OnCanvasClick = (event: ReactMouseEvent) => void;
+export type ChangeEvent = {
 	change: ViewChange;
 };
-type OnChange = (event: ChangeEvent) => void;
+export type OnChange = (event: ChangeEvent) => void;
+export type LikeC4ColorScheme = "light" | "dark";
 type OverrideReactFlowProps = Pick<ReactFlowProps, "paneClickDistance" | "nodeClickDistance" | "selectionKeyCode" | "panActivationKeyCode" | "multiSelectionKeyCode" | "zoomActivationKeyCode" | "snapToGrid" | "snapGrid" | "onlyRenderVisibleElements" | "nodesDraggable" | "nodesFocusable" | "elementsSelectable" | "selectNodesOnDrag" | "panOnDrag" | "preventScrolling" | "zoomOnScroll" | "zoomOnPinch" | "panOnScroll" | "panOnScrollSpeed" | "panOnScrollMode" | "zoomOnDoubleClick" | "nodeDragThreshold">;
 type PaddingUnit$1 = "px" | "%";
 type PaddingWithUnit$1 = `${number}${PaddingUnit$1}` | number;
@@ -2294,7 +4312,7 @@ type ViewPadding = PaddingWithUnit$1 | {
 	x?: PaddingWithUnit$1;
 	y?: PaddingWithUnit$1;
 };
-interface LikeC4DiagramProperties<A extends _aux.Any> {
+interface LikeC4DiagramProperties<A extends Any = Any> {
 	view: LayoutedView<A>;
 	className?: string | undefined;
 	/**
@@ -2466,7 +4484,7 @@ interface LikeC4DiagramProperties<A extends _aux.Any> {
 	 */
 	reactFlowProps?: OverrideReactFlowProps | undefined;
 }
-type OpenSourceParams<A extends _aux.Any = _aux.Any> = {
+export type OpenSourceParams<A extends _aux.Any = _aux.Any> = {
 	element: _aux.Fqn<A>;
 	property?: string;
 } | {
@@ -2477,7 +4495,7 @@ type OpenSourceParams<A extends _aux.Any = _aux.Any> = {
 } | {
 	view: _aux.StrictViewId<A>;
 };
-interface LikeC4DiagramEventHandlers<A extends _aux.Any = _aux.Any> {
+export interface LikeC4DiagramEventHandlers<A extends _aux.Any = _aux.Any> {
 	onChange?: OnChange | null | undefined;
 	onNavigateTo?: OnNavigateTo<A> | null | undefined;
 	onNodeClick?: OnNodeClick<A> | null | undefined;
@@ -2490,7 +4508,7 @@ interface LikeC4DiagramEventHandlers<A extends _aux.Any = _aux.Any> {
 	onBurgerMenuClick?: null | undefined | (() => void);
 	onOpenSource?: null | undefined | ((params: OpenSourceParams<A>) => void);
 }
-export interface LikeC4ViewProps<A extends _aux.Any> {
+export interface LikeC4ViewProps<A extends Any> {
 	/**
 	 * View to display.
 	 */
@@ -2628,7 +4646,7 @@ export interface LikeC4ViewProps<A extends _aux.Any> {
 	 */
 	renderIcon?: ElementIconRenderer | undefined;
 }
-interface LikeC4BrowserProps {
+export interface LikeC4BrowserProps {
 	/**
 	 * Background pattern for the browser view.
 	 * @default 'dots'
@@ -2712,9 +4730,9 @@ interface LikeC4BrowserProps {
 	 */
 	reactFlowProps?: OverrideReactFlowProps | undefined;
 }
-export declare function LikeC4View<A extends _aux.Any = _aux.UnknownLayouted>({ viewId, ...props }: LikeC4ViewProps<A>): import("react/jsx-runtime").JSX.Element;
+export declare function LikeC4View<A extends Any = 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 _aux.Any> = Omit<LikeC4DiagramProps<A>, "view"> & {
+export type ReactLikeC4Props<A extends Any> = Omit<LikeC4DiagramProps<A>, "view"> & {
 	viewId: _aux.ViewId<A>;
 	/**
 	 * Keep aspect ratio of the diagram
@@ -2740,11 +4758,26 @@ export type ReactLikeC4Props<A extends _aux.Any> = Omit<LikeC4DiagramProps<A>, "
 	/** Function to generate nonce attribute added to all generated `<style />` tags */
 	styleNonce?: string | (() => string) | undefined;
 };
-export declare function ReactLikeC4<A extends _aux.Any = _aux.UnknownLayouted>({ viewId, ...props }: ReactLikeC4Props<A>): import("react/jsx-runtime").JSX.Element;
+export declare function ReactLikeC4<A extends Any = UnknownLayouted>({ viewId, ...props }: ReactLikeC4Props<A>): import("react/jsx-runtime").JSX.Element;
 export declare namespace ReactLikeC4 {
 	var displayName: string;
 }
-type LikeC4ModelProviderProps = PropsWithChildren<{
+export interface LikeC4ProjectsProviderProps {
+	/**
+	 * Projects to be used in the navigation panel.
+	 * Current project is taken from the LikeC4Model
+	 */
+	projects: ReadonlyArray<LikeC4Project>;
+	/**
+	 * Optional callback when another project is selected.
+	 */
+	onProjectChange?: (id: ProjectId) => void;
+}
+/**
+ * Ensures LikeC4Projects context
+ */
+export declare function LikeC4ProjectsProvider({ children, projects, onProjectChange: _onProjectChange, }: PropsWithChildren<LikeC4ProjectsProviderProps>): import("react/jsx-runtime").JSX.Element;
+export type LikeC4ModelProviderProps = PropsWithChildren<{
 	/**
 	 * The LikeC4 model to be provided to the context.
 	 * TODO: refer to 'likec4/model'
@@ -2755,9 +4788,49 @@ export declare const LikeC4ModelProvider: (props: LikeC4ModelProviderProps) => J
 export declare const ViewNotFound: ({ viewId }: {
 	viewId: string;
 }) => import("react/jsx-runtime").JSX.Element;
+declare const FeatureNames: readonly [
+	"Controls",
+	"ReadOnly",
+	"FocusMode",
+	"NavigateTo",
+	"ElementDetails",
+	"RelationshipDetails",
+	"RelationshipBrowser",
+	"Search",
+	"NavigationButtons",
+	"Notations",
+	"DynamicViewWalkthrough",
+	"EdgeEditing",
+	"ViewTitle",
+	"FitView",
+	"Vscode",
+	"ElementTags"
+];
+type FeatureName = typeof FeatureNames[number];
+type CustomFeatures = {
+	enableControls: "next" | boolean;
+};
+export type EnabledFeatures = {
+	[P in `enable${FeatureName}`]: P extends keyof CustomFeatures ? CustomFeatures[P] : boolean;
+};
+export declare function useEnabledFeatures(): EnabledFeatures;
+/**
+ * Returns current view id
+ * Should be used only inside LikeC4Diagram
+ */
+export declare function useCurrentViewId(): ViewId;
+type CurrentViewModel = LikeC4ViewModel<_aux.UnknownLayouted, LayoutedView<_aux.UnknownLayouted>>;
+export declare function useCurrentViewModel(): CurrentViewModel;
+export declare function useLikeC4Model<A extends _aux.Any = _aux.UnknownLayouted>(): LikeC4Model<A>;
+export declare function useLikeC4ViewModel<A extends _aux.Any = _aux.UnknownLayouted>(viewId: _aux.ViewId<A>): LikeC4ViewModel<A>;
 
 declare namespace Base {
 	export { Dimmed, Edge$1 as Edge, EdgeData, Node$1 as Node, NodeData, NodeProps$2 as NodeProps, setData, setDimmed, setHovered };
 }
 
+export {
+	PaddingUnit$1 as PaddingUnit,
+	PaddingWithUnit$1 as PaddingWithUnit,
+};
+
 export {};