@likec4/core 1.49.0 → 1.50.0

package/dist/_chunks/index.d.mts

@@ -1,288 +1,2033 @@
-import { $i as IterableContainer, bi as Fqn, ea as IteratorLike, ii as Unknown, jr as Any, sa as ReorderedArray, zr as EdgeId } from "./guards.mjs";
-import { C as ElementModel, S as NodeModel, T as RelationshipModel, a as DeploymentNodeModel, c as NestedElementOfDeployedInstanceModel, i as DeploymentElementModel, l as RelationshipsAccum, r as DeployedInstanceModel, s as DeploymentRelationModel, w as AnyRelationshipModel, x as EdgeModel, y as LikeC4ViewModel } from "./LikeC4Model.mjs";
+import { c as XYPoint, i as BBox, s as Point } from "./index2.mjs";
+import { IfNever, IsAny, IsLiteral, IsNever, KeysOfUnion, PartialDeep, SetNonNullable, SetRequired, Simplify, Tagged, TupleToUnion, UnionToIntersection, WritableDeep } from "type-fest";
 
-//#region src/model/connection/Connection.d.ts
-interface Connection<Elem = ElementModel<Any> | DeploymentElementModel<Any>, Id = string> {
-  readonly id: Id;
-  readonly source: Elem;
-  readonly target: Elem;
-  /**
-   * Common ancestor of the source and target elements.
-   * Represents the boundary of the connection.
-   */
-  readonly boundary: Elem | null;
-  /**
-   * Human readable expression of the connection
-   * Mostly used for testing and debugging
-   */
-  readonly expression: string;
-  mergeWith(this: Connection<Elem, Id>, other: typeof this): typeof this;
-  nonEmpty(): boolean;
-  difference(this: Connection<Elem, Id>, other: typeof this): typeof this;
-  intersect(this: Connection<Elem, Id>, other: typeof this): typeof this;
-  equals(other: Connection): boolean;
-}
-declare namespace Connection {
-  type ConnectionPredicate = <C extends Connection<{
-    id: string;
-  }, any>>(connection: C) => boolean;
-  type ElementId = Fqn | string;
-  export const isInside: (fqn: ElementId) => ConnectionPredicate;
-  export const isDirectedBetween: (source: ElementId, target: ElementId) => ConnectionPredicate;
-  export const isAnyBetween: (source: ElementId, target: ElementId) => ConnectionPredicate;
-  export const isIncoming: (target: ElementId) => ConnectionPredicate;
-  export const isOutgoing: (source: ElementId) => ConnectionPredicate;
-  export const isAnyInOut: (source: ElementId) => ConnectionPredicate;
-  export {};
+//#region src/types/_common.d.ts
+type NonEmptyArray<T> = [T, ...T[]];
+type NonEmptyReadonlyArray<T> = readonly [T, ...T[]];
+type IterableContainer<T = unknown> = ReadonlyArray<T> | readonly [];
+type ReorderedArray<T extends IterableContainer> = { -readonly [P in keyof T]: T[number] };
+type KeysOf<T> = keyof T extends infer K extends string ? K : never;
+type AllNever$1<Expressions> = UnionToIntersection<{ [Name in keyof Expressions]: { -readonly [Key in keyof Expressions[Name]]?: never } }[keyof Expressions]>;
+/**
+ * @example
+ * ```ts
+ *   type Variant1 = {
+ *     a: string
+ *   }
+ *   type Variant2 = {
+ *     b: number
+ *   }
+ *
+ *   type Variants = ExclusiveUnion<{
+ *     Variant1: Variant1,
+ *     Variant2: Variant2
+ *   }>
+ *
+ *   // Fail here
+ *   const variant1: Variants = {
+ *      a: 'one',
+ *      b: 1
+ *   }
+ * ```
+ */
+type ExclusiveUnion<Expressions, All = AllNever$1<Expressions>> = Expressions extends object ? { [Name in keyof Expressions]: Simplify<Omit<All, keyof Expressions[Name]> & Expressions[Name]> }[keyof Expressions] : never;
+/**
+ * Copy from https://github.com/remeda/remeda/blob/main/packages/remeda/src/internal/types/NTuple.ts
+ * An array with *exactly* N elements in it.
+ *
+ * Only literal N values are supported. For very large N the type might result
+ * in a recurse depth error. For negative N the type would result in an infinite
+ * recursion. None of these have protections because this is an internal type!
+ */
+type NTuple<T, N extends number, Result extends Array<unknown> = []> = Result['length'] extends N ? Result : NTuple<T, N, [...Result, T]>;
+type IteratorLike<T> = IteratorObject<T, BuiltinIteratorReturn, unknown>;
+type Predicate<T> = (x: T) => boolean;
+interface Link {
+  title?: string;
+  url: string;
+  relative?: string;
 }
+/**
+ * Coalesce `V` to a string if it is `any`
+ */
+type Coalesce<V extends string, OrIfAny = string> = IsAny<V> extends true ? OrIfAny : V;
+type ExactObject<T, InputType = unknown> = { [KeyType in keyof T]: undefined extends T[KeyType] ? T[KeyType] | undefined : T[KeyType] } & Record<Exclude<keyof InputType, KeysOfUnion<T>>, never>;
+/**
+ * Allows only exact properties of `U` to be present in `T` and omits undefined values
+ *
+ * See {@link Exact} for more details (this version is non-deep)
+ */
+declare function exact<Expected, T extends ExactObject<Expected, T>>(a: T): Expected;
 //#endregion
-//#region src/utils/const.d.ts
-declare const customInspectSymbol: unique symbol;
+//#region src/types/const.d.ts
+/**
+ * Determines the stage of the model:
+ * 1. `parsed` - parsed from DSL or returned from Builder
+ * 2. `computed` - views are computed
+ * 3. `layouted` - views are layouted
+ *
+ * @internal
+ */
+type ModelStage = 'parsed' | 'computed' | 'layouted';
+type ExtractOnStage<T, S extends ModelStage> = Extract<T, {
+  [_stage]: S;
+}>;
+declare function isOnStage<T extends {
+  [_stage]: ModelStage;
+}, S extends ModelStage>(value: T, stage: S): value is ExtractOnStage<T, S>;
+/**
+ * Property name to store the stage of the model
+ *
+ * @internal
+ */
+declare const _stage = "_stage";
+type _stage = typeof _stage;
+/**
+ * Property name to store type information, used to identify the type of the view
+ *
+ * @internal
+ */
+declare const _type = "_type";
+type _type = typeof _type;
+/**
+ * Property name to store layout type information, used to identify the type of the layout*
+ * @internal
+ */
+declare const _layout = "_layout";
+type _layout = typeof _layout;
+declare namespace scalar_d_exports {
+  export { AnyFqn, BuiltInIcon, DeploymentFqn$1 as DeploymentFqn, DeploymentKind$1 as DeploymentKind, EdgeId$1 as EdgeId, ElementKind$1 as ElementKind, Fqn$1 as Fqn, GlobalFqn, GroupElementKind, Icon, IconUrl, MarkdownOrString, NodeId$1 as NodeId, NoneIcon, ProjectId$1 as ProjectId, RelationId$1 as RelationId, RelationKind$1 as RelationKind, RelationshipKind, StepEdgeId, StepEdgeIdLiteral, StepEdgeKind, Tag$1 as Tag, ViewId$1 as ViewId, extractStep, flattenMarkdownOrString, isGlobalFqn, isGroupElementKind, isStepEdgeId, splitGlobalFqn, stepEdgeId };
+}
+type ProjectId$1<T = string> = Tagged<T, 'ProjectID'>;
+declare function ProjectId$1(name: string): ProjectId$1;
+type MarkdownOrString = {
+  txt: string;
+  md?: never;
+} | {
+  md: string;
+  txt?: never;
+};
+declare function MarkdownOrString(value: {
+  txt: string;
+  md?: never;
+} | {
+  md: string;
+  txt?: never;
+} | string): MarkdownOrString;
+/**
+ * Converts a MarkdownOrString object or a plain string into a simple string representation.
+ * This utility function handles different types of text content and normalizes them to a string format.
+ *
+ * @param value - The content to be flattened.
+ *   Can be one of:
+ *   - A plain string
+ *   - A MarkdownOrString object with either txt or md property
+ *   - undefined or null
+ *
+ * @returns The string content contained within the input value.
+ *   - Returns the input directly if it's already a string
+ *   - Returns the txt property if available in a MarkdownOrString object
+ *   - Falls back to the md property if txt is not available
+ *   - Returns null if:
+ *     - The input is null or undefined
+ *     - The resulting string value is empty, whitespace, or null
+ *
+ * @example
+ * // String input
+ * flattenMarkdownOrString("Hello world") // Returns: "Hello world"
+ * flattenMarkdownOrString("   ") // Returns: null
+ *
+ * // MarkdownOrString with txt property
+ * flattenMarkdownOrString({ txt: "Plain text" }) // Returns: "Plain text"
+ * flattenMarkdownOrString({ txt: "   " }) // Returns: null
+ *
+ * // MarkdownOrString with md property
+ * flattenMarkdownOrString({ md: "**Bold markdown**" }) // Returns: "**Bold markdown**"
+ *
+ * // Null input
+ * flattenMarkdownOrString(null) // Returns: null
+ */
+declare function flattenMarkdownOrString(value: MarkdownOrString | string): string;
+declare function flattenMarkdownOrString(value: MarkdownOrString | string | undefined | null): string | null;
+type BuiltInIcon = 'none' | `${'aws' | 'azure' | 'gcp' | 'tech' | 'bootstrap'}:${string}`;
+type Icon = Tagged<string, 'Icon'> | BuiltInIcon;
+declare const NoneIcon: Icon;
+type IconUrl = Icon;
+/**
+ * Full-qualified-name for model elements
+ */
+type Fqn$1<Id = string> = Tagged<Id, 'Fqn'>;
+declare function Fqn$1(name: string, parent?: Fqn$1 | null): Fqn$1;
+type ElementKind$1<Kinds = string> = Tagged<Kinds, 'ElementKind'>;
+declare const GroupElementKind: ElementKind$1<"@group">;
+type GroupElementKind = typeof GroupElementKind;
+declare function isGroupElementKind<V extends {
+  kind?: any;
+}>(v: V): v is V & {
+  kind: GroupElementKind;
+};
+/**
+ * Full-qualified-name for deployment elements
+ */
+type DeploymentFqn$1<T = string> = Tagged<T, 'DeploymentFqn'>;
+declare function DeploymentFqn$1(name: string, parent?: DeploymentFqn$1 | null): DeploymentFqn$1;
+type DeploymentKind$1<Kinds = string> = Tagged<Kinds, 'DeploymentKind'>;
+type ViewId$1<Id = string> = Tagged<Id, 'ViewId'>;
+declare function ViewId$1(id: string): ViewId$1;
+type AnyFqn<T = string> = DeploymentFqn$1<T> | Fqn$1<T>;
+/**
+ * @deprecated Use {@link RelationshipKind} instead
+ */
+type RelationKind$1<Kinds = string> = RelationshipKind<Kinds>;
+type RelationshipKind<Kinds = string> = Tagged<Kinds, 'RelationshipKind'>;
+type RelationId$1<Id = string> = Tagged<Id, 'RelationId'>;
+declare function RelationId$1(id: string): RelationId$1;
+type Tag$1<T = string> = Tagged<T, 'Tag'>;
+type GlobalFqn<Id = string> = Tagged<Fqn$1<Id>, 'GlobalFqn'>;
+declare function GlobalFqn<A>(projectId: A | ProjectId$1<A>, name: string): GlobalFqn<A>;
+declare function isGlobalFqn<A extends string>(fqn: A): fqn is GlobalFqn<A>;
+declare function splitGlobalFqn<I extends string>(fqn: Fqn$1<I> | GlobalFqn<I>): [ProjectId$1 | null, Fqn$1<I>];
+type NodeId$1 = Tagged<string, 'NodeId' | 'Fqn' | 'DeploymentFqn'>;
+declare function NodeId$1(id: string): NodeId$1;
+type EdgeId$1 = Tagged<string, 'EdgeId'>;
+declare function EdgeId$1(id: string): EdgeId$1;
+type StepEdgeIdLiteral = `step-${number}` | `step-${number}.${number}`;
+type StepEdgeId = Tagged<StepEdgeIdLiteral, 'EdgeId'>;
+declare function stepEdgeId(step: number, parallelStep?: number): StepEdgeId;
+declare const StepEdgeKind = "@step";
+declare function isStepEdgeId(id: string): id is StepEdgeId;
+declare function extractStep(id: EdgeId$1): number;
+declare namespace _aux_d_exports {
+  export { AllKinds, Any, Any as AnyAux, AnyComputed, AnyLayouted, AnyOnStage, AnyParsed, AnySpec, Aux, DeploymentFqn, DeploymentId, DeploymentKind, EdgeId, ElementId, ElementKind, Fqn, LooseDeploymentId, LooseDeploymentKind, LooseElementId, LooseElementKind, LooseLiteral, LooseRelationKind, LooseTag, LooseTags, LooseViewId, Metadata, MetadataKey, Never, NodeId, OrString, PickByStage, ProjectId, RelationId, RelationKind, Spec, SpecAux, Stage, DeploymentFqn as StrictDeploymentFqn, StrictDeploymentKind, StrictElementKind, Fqn as StrictFqn, StrictProjectId, StrictRelationKind, StrictTag, StrictViewId, Tag, Tags, Unknown, UnknownComputed, UnknownLayouted, UnknownParsed, ViewId, WithDescriptionAndTech, WithLinks, WithMetadata, WithNotation, WithOptionalLinks, WithOptionalTags, WithTags, preferDescription, preferSummary, setProject, setStage, toComputed, toLayouted, toParsed };
+}
+/**
+ * Specification types (kinds, tags, metadata keys)
+ *
+ * @param ElementKind - Literal union of element kinds
+ * @param DeploymentKind - Literal union of deployment kinds
+ * @param RelationKind - Literal union of relationship kinds
+ * @param Tag - Literal union of tags
+ * @param MetadataKey - Literal union of metadata keys
+ */
+interface SpecAux<ElementKind extends string, DeploymentKind extends string, RelationKind extends string, Tag extends string, MetadataKey extends string> {
+  ElementKind: ElementKind;
+  DeploymentKind: DeploymentKind;
+  RelationKind: RelationKind;
+  Tag: Tag;
+  MetadataKey: MetadataKey;
+}
+type AnySpec = SpecAux<any, any, any, any, any>;
+/**
+ * Auxilary interface to keep inferred types
+ *
+ * @typeParam Stage - View stage
+ * @typeParam Element - Literal union of FQNs of model elements
+ * @typeParam Deployment - Literal union of FQNs of deployment elements
+ * @typeParam View - Literal union of view identifiers
+ * @typeParam Project - Project identifier type
+ * @typeParam Spec - Specification types (kinds, tags, metadata keys)
+ */
+interface Aux<Stage extends ModelStage, Element extends string, Deployment extends string, View extends string, Project extends string, Spec extends AnySpec> {
+  Stage: Stage;
+  ProjectId: Project;
+  ElementId: Element;
+  DeploymentId: Deployment;
+  ViewId: View;
+  ElementKind: Spec['ElementKind'];
+  DeploymentKind: Spec['DeploymentKind'];
+  RelationKind: Spec['RelationKind'];
+  Tag: Spec['Tag'];
+  MetadataKey: Spec['MetadataKey'];
+}
+type AnyOnStage<Stage extends ModelStage> = Aux<Stage, any, any, any, any, any>;
+type AnyParsed = AnyOnStage<'parsed'>;
+type AnyComputed = AnyOnStage<'computed'>;
+type AnyLayouted = AnyOnStage<'layouted'>;
+type Any = Aux<any, any, any, any, any, any>;
+type Never = Aux<never, never, never, never, never, SpecAux<never, never, never, never, never>>;
+/**
+ * Fallback when {@link Aux} can't be inferred.
+ * By default assumes non parsed model
+ */
+type Unknown = UnknownComputed | UnknownLayouted;
+type UnknownParsed = Aux<'parsed', string, string, string, string, SpecAux<string, string, string, string, string>>;
+type UnknownComputed = Aux<'computed', string, string, string, string, SpecAux<string, string, string, string, string>>;
+type UnknownLayouted = Aux<'layouted', string, string, string, string, SpecAux<string, string, string, string, string>>;
+/**
+ * Reads stage from Aux
+ */
+type Stage<A> = A extends Aux<infer S, any, any, any, any, any> ? IfNever<S, never, Coalesce<S, ModelStage>> : never;
+/**
+ * Picks type based on stage from Aux
+ */
+type PickByStage<A extends Any, OnParsed, OnComputed, OnLayouted = OnComputed> = {
+  parsed: OnParsed;
+  computed: OnComputed;
+  layouted: OnLayouted;
+}[A['Stage']];
+type setStage<A, S extends ModelStage> = A extends Aux<any, infer E, infer D, infer V, infer P, infer Spec> ? Aux<S, E, D, V, P, Spec> : never;
+type toParsed<A> = A extends Aux<any, infer E, infer D, infer V, infer P, infer Spec> ? Aux<'parsed', E, D, V, P, Spec> : never;
+type toComputed<A> = A extends Aux<any, infer E, infer D, infer V, infer P, infer Spec> ? Aux<'computed', E, D, V, P, Spec> : never;
+type toLayouted<A> = A extends Aux<any, infer E, infer D, infer V, infer P, infer Spec> ? Aux<'layouted', E, D, V, P, Spec> : never;
+/**
+ * Project identifier from Aux
+ */
+type ProjectId<A> = A extends Aux<any, any, any, any, infer P, any> ? Coalesce<P> : never;
+type setProject<A, P extends string> = A extends Aux<infer S, infer E, infer D, infer V, any, infer Spec> ? Aux<S, E, D, V, P, Spec> : never;
+/**
+ * Element FQN from Aux as branded type
+ */
+type Fqn<A> = A extends Any ? Fqn$1<ElementId<A>> : never;
+/**
+ * Element FQN from Aux as a literal union
+ */
+type ElementId<A> = A extends Any ? Coalesce<A['ElementId']> : never;
+/**
+ * Deployment FQN from Aux as branded type
+ */
+type DeploymentFqn<A> = A extends Any ? DeploymentFqn$1<DeploymentId<A>> : never;
+/**
+ * Deployment FQN from Aux as a literal union
+ * @alias {@link DeploymentFqn}
+ */
+type DeploymentId<A> = A extends Any ? Coalesce<A['DeploymentId']> : never;
+/**
+ * View identifier from Aux as a literal union
+ */
+type ViewId<A> = A extends Any ? Coalesce<A['ViewId']> : never;
+type RelationId = RelationId$1;
+type NodeId = NodeId$1;
+type EdgeId = EdgeId$1;
+/**
+ * ElementKind from Aux as a literal union
+ */
+type ElementKind<A> = A extends Any ? Coalesce<A['ElementKind']> : never;
+/**
+ * DeploymentKind from Aux as a literal union
+ */
+type DeploymentKind<A> = A extends Any ? Coalesce<A['DeploymentKind']> : never;
+/**
+ * RelationKind from Aux as a literal union
+ */
+type RelationKind<A> = A extends Any ? Coalesce<A['RelationKind']> : never;
+/**
+ * Tags from Aux as a literal union
+ */
+type Tag<A> = A extends Any ? Coalesce<A['Tag']> : never;
+/**
+ * Array of tags from Aux
+ */
+type Tags<A extends Any> = readonly Tag<A>[];
+/**
+ * Metadata key from Aux
+ */
+type MetadataKey<A> = A extends Any ? Coalesce<A['MetadataKey']> : never;
+/**
+ * Metadata object from Aux
+ */
+type Metadata<A extends Any> = IsNever<A['MetadataKey']> extends true ? never : IsLiteral<A['MetadataKey']> extends true ? { [key in A['MetadataKey']]?: string | string[] } : Record<string, string | string[]>;
+/**
+ * All known kinds from Aux as a literal union.
+ */
+type AllKinds<A> = ElementKind<A> | DeploymentKind<A> | RelationKind<A>;
+/**
+ * Specification from Aux
+ */
+type Spec<A> = A extends Aux<any, any, any, any, any, SpecAux<infer E, infer D, infer R, infer T, infer M>> ? SpecAux<E, D, R, T, M> : never;
+type StrictProjectId<A> = A extends infer T extends Any ? ProjectId$1<ProjectId<T>> : never;
+type StrictViewId<A> = A extends infer T extends Any ? ViewId$1<ViewId<T>> : never;
+type StrictTag<A> = A extends infer T extends Any ? Tag$1<Tag<T>> : never;
+type StrictElementKind<A> = A extends infer T extends Any ? ElementKind$1<ElementKind<T>> : never;
+type StrictDeploymentKind<A> = A extends infer T extends Any ? DeploymentKind$1<DeploymentKind<T>> : never;
+type StrictRelationKind<A> = A extends infer T extends Any ? RelationshipKind<RelationKind<T>> : never;
+type WithDescriptionAndTech = {
+  readonly summary?: MarkdownOrString | null;
+  readonly description?: MarkdownOrString | null;
+  readonly technology?: string | null;
+};
+/**
+ * Returns summary if it is not null, otherwise returns description
+ */
+declare function preferSummary(a: WithDescriptionAndTech): MarkdownOrString | null | undefined;
+/**
+ * Returns description if it is not null, otherwise returns summary
+ */
+declare function preferDescription(a: WithDescriptionAndTech): MarkdownOrString | null | undefined;
+type WithTags<A extends Any> = {
+  readonly tags: Tags<A>;
+};
+type WithOptionalTags<A extends Any> = {
+  readonly tags?: Tags<A> | null;
+};
+type WithLinks = {
+  readonly links: readonly Link[];
+};
+type WithOptionalLinks = {
+  readonly links?: readonly Link[] | null;
+};
+type WithMetadata<A extends Any> = {
+  readonly metadata?: Metadata<A>;
+};
+type WithNotation = {
+  readonly notation?: string | null;
+};
+/**
+ * @see {@link LiteralUnion} from type-fest (https://github.com/sindresorhus/type-fest/blob/main/source/literal-union.d.ts)
+ */
+type OrString = string & Record<never, never>;
+/**
+ * Allows any string value, but still auto-completes to the possible values in IDE
+ */
+type LooseLiteral<V extends string> = Coalesce<V> | OrString;
+type LooseElementId<A> = A extends Any ? LooseLiteral<A['ElementId']> : string;
+type LooseDeploymentId<A> = A extends Any ? LooseLiteral<A['DeploymentId']> : string;
+type LooseViewId<A> = A extends Any ? LooseLiteral<A['ViewId']> : string;
+type LooseTag<A> = A extends Any ? LooseLiteral<A['Tag']> : string;
+type LooseTags<A> = A extends Any ? readonly (LooseLiteral<A['Tag']>)[] : string[];
+type LooseElementKind<A> = A extends Any ? LooseLiteral<A['ElementKind']> : string;
+type LooseDeploymentKind<A> = A extends Any ? LooseLiteral<A['DeploymentKind']> : string;
+type LooseRelationKind<A> = A extends Any ? LooseLiteral<A['RelationKind']> : string;
 //#endregion
-//#region src/model/connection/deployment/DeploymentConnectionModel.d.ts
+//#region ../../styled-system/preset/dist/defaults/index.d.mts
+//#region src/defaults/types.d.ts
+declare const Sizes: readonly ["xs", "sm", "md", "lg", "xl"];
+declare const IconPositions: readonly ["left", "right", "top", "bottom"];
+declare const BorderStyles: readonly ["solid", "dashed", "dotted", "none"];
+declare const ElementShapes: readonly ["rectangle", "person", "browser", "mobile", "cylinder", "storage", "queue", "bucket", "document", "component"];
+declare const ThemeColors: readonly ["amber", "blue", "gray", "slate", "green", "indigo", "muted", "primary", "red", "secondary", "sky"];
+declare const DefaultTagColors: readonly ["tomato", "grass", "blue", "ruby", "orange", "indigo", "pink", "teal", "purple", "amber", "crimson", "red", "lime", "yellow", "violet"];
+//#endregion
+//#region src/styles/types.d.ts
 /**
- * Connection is ephemeral entity, result of a resolving relationships between source and target.
- * Includes direct relationships and/or between their nested elements.
+ * For padding, margin, etc.
  */
-declare class DeploymentConnectionModel<A extends Any = Any> implements Connection<DeploymentElementModel<A>, EdgeId> {
-  readonly source: DeploymentElementModel<A>;
-  readonly target: DeploymentElementModel<A>;
-  readonly relations: RelationshipsAccum<A>;
-  readonly id: EdgeId;
-  constructor(source: DeploymentElementModel<A>, target: DeploymentElementModel<A>, relations: RelationshipsAccum<A>);
-  /**
-   * Human readable expression of the connection
-   * Mostly used for testing and debugging
-   */
-  get expression(): string;
-  private _boundary;
+type Size = typeof Sizes[number];
+type TextSize = Size;
+type ShapeSize = Size;
+type SpacingSize = Size;
+type IconSize = Size;
+type IconPosition = typeof IconPositions[number];
+type BorderStyle = typeof BorderStyles[number];
+type ElementShape = typeof ElementShapes[number];
+type HexColor = `#${string}`;
+type ColorLiteral = HexColor | `rgb(${number},${number},${number})` | `rgba(${number},${number},${number},${number})`;
+type RelationshipLineType = 'dashed' | 'solid' | 'dotted';
+declare const RelationshipArrowTypes: readonly ["none", "normal", "onormal", "dot", "odot", "diamond", "odiamond", "crow", "open", "vee"];
+type RelationshipArrowType = TupleToUnion<typeof RelationshipArrowTypes>;
+type ThemeColor = typeof ThemeColors[number];
+declare function isThemeColor(color: string): color is ThemeColor;
+type CustomColorDefinitions = {
+  [key: string]: ThemeColorValues;
+};
+type CustomColor = Tagged<string, 'CustomColor'>;
+declare function isCustomColor(color: string): color is CustomColor;
+type Color = ThemeColor | CustomColor;
+interface ElementColorValues {
+  readonly fill: ColorLiteral;
+  readonly stroke: ColorLiteral;
+  readonly hiContrast: ColorLiteral;
+  readonly loContrast: ColorLiteral;
+}
+interface RelationshipColorValues {
+  readonly line: ColorLiteral;
+  readonly labelBg: ColorLiteral;
+  readonly label: ColorLiteral;
+}
+interface ThemeColorValues {
+  readonly elements: ElementColorValues;
+  readonly relationships: RelationshipColorValues;
+}
+/**
+ * Default style values for elements, groups and relationships
+ */
+interface LikeC4StyleDefaults {
+  readonly color: ThemeColor;
+  readonly size: ShapeSize;
+  readonly shape: ElementShape;
+  readonly opacity?: number;
+  readonly border?: BorderStyle;
+  readonly padding?: SpacingSize;
+  readonly text?: TextSize;
+  readonly iconPosition?: IconPosition;
   /**
-   * Common ancestor of the source and target elements.
-   * Represents the boundary of the connection.
+   * Default style values for groups
+   * If not specified, the default values for elements are used
    */
-  get boundary(): DeploymentNodeModel<A> | null;
-  nonEmpty(): boolean;
-  [customInspectSymbol](_depth: any, _inspectOptions: any, _inspect: any): string;
-  toString(): string;
+  readonly group: {
+    readonly color?: ThemeColor;
+    readonly opacity: number;
+    readonly border: BorderStyle;
+  };
+  readonly relationship: {
+    readonly color: ThemeColor;
+    readonly line: RelationshipLineType;
+    readonly arrow: RelationshipArrowType;
+  };
+}
+interface LikeC4Theme {
+  readonly colors: Readonly<Record<ThemeColor, ThemeColorValues>>;
+  readonly sizes: Readonly<Record<ShapeSize, {
+    readonly width: number;
+    readonly height: number;
+  }>>;
+  readonly spacing: Readonly<Record<SpacingSize, number>>;
+  readonly textSizes: Readonly<Record<TextSize, number>>;
+  readonly iconSizes: Readonly<Record<IconSize, number>>;
+}
+interface LikeC4StylesConfig {
+  readonly theme: LikeC4Theme;
+  readonly defaults: LikeC4StyleDefaults;
+}
+//#endregion
+//#region src/types/fqnRef.d.ts
+type AnyAux$2 = Any;
+declare namespace FqnRef {
   /**
-   * Check if connection contains deployment relation,
-   * that is directly connected to source or target.
+   * Reference to logical model element
    */
-  hasDirectDeploymentRelation(): boolean;
-  values(): IteratorLike<RelationshipModel<A> | DeploymentRelationModel<A>>;
+  interface ElementRef<A extends AnyAux$2 = AnyAux$2> {
+    project?: never;
+    model: ElementId<A>;
+  }
+  function isElementRef<A extends AnyAux$2>(ref: FqnRef<A>): ref is ElementRef<A>;
   /**
-   * Merge with another connections, if it has the same source and target.
-   * Returns new connection with union of relationships.
+   * Reference to imported logical model element
    */
-  mergeWith(others: DeploymentConnectionModel<A>[]): DeploymentConnectionModel<A>;
+  interface ImportRef<A extends AnyAux$2 = AnyAux$2> {
+    project: ProjectId<A>;
+    model: ElementId<A>;
+  }
+  function isImportRef<A extends AnyAux$2>(ref: FqnRef<A>): ref is ImportRef<A>;
+  function flatten<A extends AnyAux$2>(ref: FqnRef<A>): Fqn<A>;
+  type ModelRef<A extends AnyAux$2 = AnyAux$2> = ImportRef<A> | ElementRef<A>;
+  function isModelRef<A extends AnyAux$2>(ref: FqnRef<A>): ref is ModelRef<A>;
   /**
-   * Merge with another connection, if it has the same source and target.
-   * Returns new connection with union of relationships.
+   * 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.
    */
-  mergeWith(other: DeploymentConnectionModel<A>): DeploymentConnectionModel<A>;
-  difference(other: DeploymentConnectionModel<A>): DeploymentConnectionModel<A>;
-  intersect(other: DeploymentConnectionModel<A>): DeploymentConnectionModel<A>;
-  equals(other: Connection): boolean;
+  interface InsideInstanceRef<A extends AnyAux$2 = AnyAux$2> {
+    deployment: DeploymentId<A>;
+    element: ElementId<A>;
+  }
+  function isInsideInstanceRef<A extends AnyAux$2>(ref: FqnRef<A>): ref is InsideInstanceRef<A>;
   /**
-   * Creates a clone of the current `DeploymentConnectionModel` instance with optional overrides.
-   * if `null` is provided in overrides, the corresponding relation set will be empty.
+   * 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.
    */
-  update(overrides?: {
-    model?: ReadonlySet<RelationshipModel<A>> | null;
-    deployment?: ReadonlySet<DeploymentRelationModel<A>> | null;
-  }): DeploymentConnectionModel<A>;
+  interface DeploymentElementRef<A extends AnyAux$2> {
+    deployment: DeploymentId<A>;
+    element?: never;
+  }
+  function isDeploymentElementRef<A extends AnyAux$2>(ref: FqnRef<A>): ref is DeploymentElementRef<A>;
+  type DeploymentRef<A extends AnyAux$2> = DeploymentElementRef<A> | InsideInstanceRef<A>;
+  function isDeploymentRef<A extends AnyAux$2>(ref: FqnRef<A>): ref is DeploymentRef<A>;
 }
+type FqnRef<A extends AnyAux$2 = AnyAux$2> = ExclusiveUnion<{
+  DeploymentRef: FqnRef.DeploymentRef<A>;
+  ModelRef: FqnRef.ModelRef<A>;
+}>;
+//#endregion
+//#region src/types/operators.d.ts
+type EqualOperator<V> = {
+  eq: V;
+  neq?: never;
+} | {
+  eq?: never;
+  neq: V;
+};
+type AllNever = {
+  not?: never;
+  and?: never;
+  or?: never;
+  tag?: never;
+  kind?: never;
+  participant?: never;
+  operator?: never;
+};
+type TagEqual<A extends Any> = Omit<AllNever, 'tag'> & {
+  tag: EqualOperator<Tag<A>> | Tag<A>;
+};
+declare function isTagEqual<A extends Any>(operator: WhereOperator<A>): operator is TagEqual<A>;
+type KindEqual<A extends Any> = Omit<AllNever, 'kind'> & {
+  kind: EqualOperator<AllKinds<A>> | AllKinds<A>;
+};
+declare function isKindEqual<A extends Any>(operator: WhereOperator<A>): operator is KindEqual<A>;
+type Participant = 'source' | 'target';
+type ParticipantOperator<A extends Any> = Omit<AllNever, 'participant' | 'operator'> & {
+  participant: Participant;
+  operator: KindEqual<A> | TagEqual<A>;
+};
+declare function isParticipantOperator<A extends Any>(operator: WhereOperator<A>): operator is ParticipantOperator<A>;
+type NotOperator<A extends Any> = Omit<AllNever, 'not'> & {
+  not: WhereOperator<A>;
+};
+declare function isNotOperator<A extends Any>(operator: WhereOperator<A>): operator is NotOperator<A>;
+type AndOperator<A extends Any> = Omit<AllNever, 'and'> & {
+  and: NonEmptyArray<WhereOperator<A>>;
+};
+declare function isAndOperator<A extends Any>(operator: WhereOperator<A>): operator is AndOperator<A>;
+type OrOperator<A extends Any> = Omit<AllNever, 'or'> & {
+  or: NonEmptyArray<WhereOperator<A>>;
+};
+declare function isOrOperator<A extends Any>(operator: WhereOperator<A>): operator is OrOperator<A>;
+type WhereOperator<A extends Any = Any> = TagEqual<A> | KindEqual<A> | ParticipantOperator<A> | NotOperator<A> | AndOperator<A> | OrOperator<A>;
+type Filterable<A extends Any> = {
+  tags?: Tags<A> | null | undefined;
+  kind?: AllKinds<A> | null | undefined;
+  source?: Filterable<A>;
+  target?: Filterable<A>;
+};
+type OperatorPredicate<A extends Any> = (value: Filterable<A>) => boolean;
+declare function whereOperatorAsPredicate<A extends Any>(operator: WhereOperator<A>): OperatorPredicate<A>;
 //#endregion
-//#region src/model/connection/model/ConnectionModel.d.ts
+//#region src/types/expression.d.ts
+type AnyAux$1 = Any;
+type PredicateSelector = 'children' | 'expanded' | 'descendants';
+declare namespace FqnExpr {
+  type Wildcard = {
+    wildcard: true;
+  };
+  function isWildcard<A extends AnyAux$1>(expr: Expression<A>): expr is FqnExpr.Wildcard;
+  interface ModelRef<M extends AnyAux$1 = AnyAux$1> {
+    ref: FqnRef.ModelRef<M>;
+    selector?: PredicateSelector;
+  }
+  function isModelRef<A extends AnyAux$1>(ref: Expression<A>): ref is FqnExpr.ModelRef<A>;
+  interface DeploymentRef<A extends AnyAux$1 = AnyAux$1> {
+    ref: FqnRef.DeploymentRef<A>;
+    selector?: PredicateSelector;
+  }
+  function isDeploymentRef<A extends AnyAux$1>(expr: Expression<A>): expr is FqnExpr.DeploymentRef<A>;
+  interface ElementKindExpr<A extends AnyAux$1 = AnyAux$1> {
+    elementKind: ElementKind<A>;
+    isEqual: boolean;
+  }
+  function isElementKindExpr<A extends AnyAux$1>(expr: Expression<A>): expr is ElementKindExpr<A>;
+  interface ElementTagExpr<A extends AnyAux$1 = AnyAux$1> {
+    elementTag: Tag<A>;
+    isEqual: boolean;
+  }
+  function isElementTagExpr<A extends AnyAux$1>(expr: Expression<A>): expr is ElementTagExpr<A>;
+  type NonWildcard<A extends AnyAux$1 = AnyAux$1> = ExclusiveUnion<{
+    ModelRef: ModelRef<A>;
+    DeploymentRef: DeploymentRef<A>;
+    ElementKind: ElementKindExpr<A>;
+    ElementTag: ElementTagExpr<A>;
+  }>;
+  interface Where<A extends AnyAux$1 = AnyAux$1> {
+    where: {
+      expr: ExclusiveUnion<{
+        Wildcard: Wildcard;
+        ModelRef: ModelRef<A>;
+        DeploymentRef: DeploymentRef<A>;
+        ElementKind: ElementKindExpr<A>;
+        ElementTag: ElementTagExpr<A>;
+      }>;
+      condition: WhereOperator<A>;
+    };
+  }
+  function isWhere<A extends AnyAux$1>(expr: Expression<A>): expr is FqnExpr.Where<A>;
+  interface Custom<A extends AnyAux$1 = AnyAux$1> {
+    custom: {
+      expr: OrWhere<A>;
+      title?: string;
+      description?: MarkdownOrString;
+      technology?: string;
+      notation?: string;
+      notes?: MarkdownOrString;
+      shape?: ElementShape;
+      color?: Color;
+      icon?: Icon;
+      iconColor?: Color;
+      iconSize?: ShapeSize;
+      iconPosition?: IconPosition;
+      border?: BorderStyle;
+      opacity?: number;
+      navigateTo?: StrictViewId<A>;
+      multiple?: boolean;
+      size?: ShapeSize;
+      padding?: ShapeSize;
+      textSize?: ShapeSize;
+    };
+  }
+  function isCustom<A extends AnyAux$1>(expr: Expression<A>): expr is Custom<A>;
+  function is<A extends AnyAux$1>(expr: Expression<A>): expr is FqnExpr<A>;
+  type OrWhere<A extends AnyAux$1 = AnyAux$1> = 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 AnyAux$1 = AnyAux$1> = 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 AnyAux$1>(expr: FqnExpr.Any<A>): Wildcard | ModelRef<A> | DeploymentRef<A> | ElementKindExpr<A> | ElementTagExpr<A>;
+}
+type FqnExpr<A extends AnyAux$1 = AnyAux$1> = 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 AnyAux$1 = AnyAux$1> = FqnExpr.Where<A>['where']['expr'];
+  interface Direct<A extends AnyAux$1 = AnyAux$1> {
+    source: Endpoint<A>;
+    target: Endpoint<A>;
+    isBidirectional?: boolean;
+  }
+  function isDirect<A extends AnyAux$1>(expr: Expression<A>): expr is RelationExpr.Direct<A>;
+  interface Incoming<A extends AnyAux$1 = AnyAux$1> {
+    incoming: Endpoint<A>;
+  }
+  function isIncoming<A extends AnyAux$1>(expr: Expression<A>): expr is RelationExpr.Incoming<A>;
+  interface Outgoing<A extends AnyAux$1 = AnyAux$1> {
+    outgoing: Endpoint<A>;
+  }
+  function isOutgoing<A extends AnyAux$1>(expr: Expression<A>): expr is RelationExpr.Outgoing<A>;
+  interface InOut<A extends AnyAux$1 = AnyAux$1> {
+    inout: Endpoint<A>;
+  }
+  function isInOut<A extends AnyAux$1>(expr: Expression<A>): expr is RelationExpr.InOut<A>;
+  interface Where<A extends AnyAux$1 = AnyAux$1> {
+    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 AnyAux$1>(expr: Expression<A>): expr is RelationExpr.Where<A>;
+  interface Custom<A extends AnyAux$1 = AnyAux$1> {
+    customRelation: {
+      expr: OrWhere<A>;
+      title?: string;
+      description?: MarkdownOrString;
+      technology?: string;
+      notation?: string;
+      navigateTo?: StrictViewId<A>;
+      notes?: MarkdownOrString;
+      color?: Color;
+      line?: RelationshipLineType;
+      head?: RelationshipArrowType;
+      tail?: RelationshipArrowType;
+    };
+  }
+  function isCustom<A extends AnyAux$1>(expr: Expression<A>): expr is Custom<A>;
+  function is<A extends AnyAux$1>(expr: Expression<A>): expr is RelationExpr<A>;
+  type OrWhere<A extends AnyAux$1 = AnyAux$1> = ExclusiveUnion<{
+    Direct: Direct<A>;
+    Incoming: Incoming<A>;
+    Outgoing: Outgoing<A>;
+    InOut: InOut<A>;
+    Where: Where<A>;
+  }>;
+  type Any<A extends AnyAux$1 = AnyAux$1> = ExclusiveUnion<{
+    Direct: Direct<A>;
+    Incoming: Incoming<A>;
+    Outgoing: Outgoing<A>;
+    InOut: InOut<A>;
+    Where: Where<A>;
+    Custom: Custom<A>;
+  }>;
+  function unwrap<A extends AnyAux$1>(expr: RelationExpr.Any<A>): Direct<A> | Incoming<A> | Outgoing<A> | InOut<A>;
+}
+type RelationExpr<A extends AnyAux$1 = AnyAux$1> = ExclusiveUnion<{
+  Direct: RelationExpr.Direct<A>;
+  Incoming: RelationExpr.Incoming<A>;
+  Outgoing: RelationExpr.Outgoing<A>;
+  InOut: RelationExpr.InOut<A>;
+}>;
 /**
- * Connection refers to any relationships between two elements,
- * both direct and implicit ones (between their nested elements).
+ * Represents a version 2 expression which can be one of several types.
  *
- * Merges relationships together to an single edge on the diagram.
+ * @template D - The type for the deployment FQN, defaults to `Fqn`.
+ * @template M - The type for the model FQN, defaults to `Fqn`.
  */
-declare class ConnectionModel<A extends Any = Unknown> implements Connection<ElementModel<A>, EdgeId> {
-  readonly source: ElementModel<A>;
-  readonly target: ElementModel<A>;
-  readonly relations: ReadonlySet<RelationshipModel<A>>;
-  readonly id: EdgeId;
-  constructor(source: ElementModel<A>, target: ElementModel<A>, relations?: ReadonlySet<RelationshipModel<A>>);
-  private _boundary;
+type Expression<A extends AnyAux$1 = AnyAux$1> = 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 AnyAux$1 = AnyAux$1> = FqnExpr.Where<A> | RelationExpr.Where<A>;
+  function isWhere<A extends AnyAux$1>(expr: Expression<A>): expr is Expression.Where<A>;
+  function isRelationWhere<A extends AnyAux$1>(expr: Expression<A>): expr is RelationExpr.Where<A>;
+  function isFqnExprWhere<A extends AnyAux$1>(expr: Expression<A>): expr is FqnExpr.Where<A>;
+  function isFqnExpr<A extends AnyAux$1>(expr: Expression<A>): expr is FqnExpr.Any<A>;
+  function isRelation<A extends AnyAux$1>(expr: Expression<A>): expr is RelationExpr.Any<A>;
+}
+//#endregion
+//#region src/types/expression-model.d.ts
+type AnyAux = Any;
+declare namespace ModelFqnExpr {
+  type Wildcard = {
+    wildcard: true;
+  };
+  function isWildcard<A extends AnyAux>(expr: ModelExpression<A>): expr is ModelFqnExpr.Wildcard;
+  interface Ref<M extends AnyAux = AnyAux> {
+    ref: FqnRef.ModelRef<M>;
+    selector?: PredicateSelector;
+  }
+  function isModelRef<A extends AnyAux>(ref: ModelExpression<A>): ref is ModelFqnExpr.Ref<A>;
+  interface ElementKindExpr<A extends AnyAux = AnyAux> {
+    elementKind: ElementKind<A>;
+    isEqual: boolean;
+  }
+  function isElementKindExpr<A extends AnyAux>(expr: ModelExpression<A>): expr is ElementKindExpr<A>;
+  interface ElementTagExpr<A extends AnyAux> {
+    elementTag: Tag<A>;
+    isEqual: boolean;
+  }
+  function isElementTagExpr<A extends AnyAux>(expr: ModelExpression<A>): expr is ElementTagExpr<A>;
+  type NonWildcard<A extends AnyAux = AnyAux> = ExclusiveUnion<{
+    Ref: Ref<A>;
+    ElementKind: ElementKindExpr<A>;
+    ElementTag: ElementTagExpr<A>;
+  }>;
+  interface Where<A extends AnyAux = AnyAux> {
+    where: {
+      expr: ExclusiveUnion<{
+        Wildcard: Wildcard;
+        Ref: Ref<A>;
+        ElementKind: ElementKindExpr<A>;
+        ElementTag: ElementTagExpr<A>;
+      }>;
+      condition: WhereOperator<A>;
+    };
+  }
+  function isWhere<A extends AnyAux>(expr: ModelExpression<A>): expr is ModelFqnExpr.Where<A>;
+  interface Custom<A extends AnyAux = AnyAux> {
+    custom: {
+      expr: OrWhere<A>;
+      title?: string;
+      description?: MarkdownOrString;
+      technology?: string;
+      notation?: string;
+      notes?: MarkdownOrString;
+      shape?: ElementShape;
+      color?: Color;
+      icon?: Icon;
+      iconColor?: Color;
+      iconSize?: ShapeSize;
+      iconPosition?: IconPosition;
+      border?: BorderStyle;
+      opacity?: number;
+      navigateTo?: StrictViewId<A>;
+      multiple?: boolean;
+      size?: ShapeSize;
+      padding?: ShapeSize;
+      textSize?: ShapeSize;
+    };
+  }
+  function isCustom<A extends AnyAux>(expr: ModelExpression<A>): expr is Custom<A>;
+  function is<A extends AnyAux>(expr: ModelExpression<A>): expr is ModelFqnExpr<A>;
+  type OrWhere<A extends AnyAux = AnyAux> = ExclusiveUnion<{
+    Wildcard: ModelFqnExpr.Wildcard;
+    Ref: ModelFqnExpr.Ref<A>;
+    ElementKind: ElementKindExpr<A>;
+    ElementTag: ElementTagExpr<A>;
+    Where: ModelFqnExpr.Where<A>;
+  }>;
+  type Any<A extends AnyAux = AnyAux> = ExclusiveUnion<{
+    Wildcard: Wildcard;
+    Ref: Ref<A>;
+    ElementKind: ElementKindExpr<A>;
+    ElementTag: ElementTagExpr<A>;
+    Where: Where<A>;
+    Custom: Custom<A>;
+  }>;
+  function unwrap<A extends AnyAux>(expr: ModelFqnExpr.Any<A>): Wildcard | Ref<A> | ElementKindExpr<A> | ElementTagExpr<A>;
+}
+type ModelFqnExpr<A extends AnyAux = AnyAux> = ExclusiveUnion<{
+  Wildcard: ModelFqnExpr.Wildcard;
+  Ref: ModelFqnExpr.Ref<A>;
+  ElementKind: ModelFqnExpr.ElementKindExpr<A>;
+  ElementTag: ModelFqnExpr.ElementTagExpr<A>;
+}>;
+declare namespace ModelRelationExpr {
+  type Endpoint<A extends AnyAux = AnyAux> = ModelFqnExpr.Where<A>['where']['expr'];
+  interface Direct<A extends AnyAux = AnyAux> {
+    source: Endpoint<A>;
+    target: Endpoint<A>;
+    isBidirectional?: boolean;
+  }
+  function isDirect<A extends AnyAux>(expr: ModelExpression<A>): expr is ModelRelationExpr.Direct<A>;
+  interface Incoming<A extends AnyAux = AnyAux> {
+    incoming: Endpoint<A>;
+  }
+  function isIncoming<A extends AnyAux>(expr: ModelExpression<A>): expr is ModelRelationExpr.Incoming<A>;
+  interface Outgoing<A extends AnyAux = AnyAux> {
+    outgoing: Endpoint<A>;
+  }
+  function isOutgoing<A extends AnyAux>(expr: ModelExpression<A>): expr is ModelRelationExpr.Outgoing<A>;
+  interface InOut<A extends AnyAux = AnyAux> {
+    inout: Endpoint<A>;
+  }
+  function isInOut<A extends AnyAux>(expr: ModelExpression<A>): expr is ModelRelationExpr.InOut<A>;
+  interface Where<A extends AnyAux = AnyAux> {
+    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 AnyAux>(expr: ModelExpression<A>): expr is ModelRelationExpr.Where<A>;
+  interface Custom<A extends AnyAux = AnyAux> {
+    customRelation: {
+      expr: OrWhere<A>;
+      title?: string;
+      description?: MarkdownOrString;
+      technology?: string;
+      notation?: string;
+      navigateTo?: StrictViewId<A>;
+      notes?: MarkdownOrString;
+      color?: Color;
+      line?: RelationshipLineType;
+      head?: RelationshipArrowType;
+      tail?: RelationshipArrowType;
+    };
+  }
+  function isCustom<A extends AnyAux>(expr: ModelExpression<A>): expr is Custom<A>;
+  function is<A extends AnyAux>(expr: ModelExpression<A>): expr is ModelRelationExpr<A>;
+  type OrWhere<A extends AnyAux = AnyAux> = ExclusiveUnion<{
+    Direct: Direct<A>;
+    Incoming: Incoming<A>;
+    Outgoing: Outgoing<A>;
+    InOut: InOut<A>;
+    Where: Where<A>;
+  }>;
+  type Any<A extends AnyAux = AnyAux> = ExclusiveUnion<{
+    Direct: Direct<A>;
+    Incoming: Incoming<A>;
+    Outgoing: Outgoing<A>;
+    InOut: InOut<A>;
+    Where: Where<A>;
+    Custom: Custom<A>;
+  }>;
+  function unwrap<A extends AnyAux>(expr: ModelRelationExpr.Any<A>): Direct<A> | Incoming<A> | Outgoing<A> | InOut<A>;
+}
+type ModelRelationExpr<A extends AnyAux = AnyAux> = ExclusiveUnion<{
+  Direct: ModelRelationExpr.Direct<A>;
+  Incoming: ModelRelationExpr.Incoming<A>;
+  Outgoing: ModelRelationExpr.Outgoing<A>;
+  InOut: ModelRelationExpr.InOut<A>;
+}>;
+/**
+ * Represents a version 2 expression which can be one of several types.
+ *
+ * @template D - The type for the deployment FQN, defaults to `Fqn`.
+ * @template M - The type for the model FQN, defaults to `Fqn`.
+ */
+type ModelExpression<A extends AnyAux = AnyAux> = 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 AnyAux = AnyAux> = ModelFqnExpr.Where<A> | ModelRelationExpr.Where<A>;
+  function isWhere<A extends AnyAux>(expr: ModelExpression<A>): expr is ModelExpression.Where<A>;
+  function isRelationWhere<A extends AnyAux>(expr: ModelExpression<A>): expr is ModelRelationExpr.Where<A>;
+  function isFqnExprWhere<A extends AnyAux>(expr: ModelExpression<A>): expr is ModelFqnExpr.Where<A>;
+  function isFqnExpr<A extends AnyAux>(expr: ModelExpression<A>): expr is ModelFqnExpr.Any<A>;
+  function isRelationExpr<A extends AnyAux>(expr: ModelExpression<A>): expr is ModelRelationExpr.Any<A>;
+}
+//#endregion
+//#region src/types/view-common.d.ts
+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;
+    iconColor?: Color;
+    iconSize?: IconSize;
+    iconPosition?: IconPosition;
+  };
+}
+interface ViewRuleGlobalStyle {
+  styleId: GlobalStyleID;
+}
+declare function isViewRuleGlobalStyle(rule: object): rule is ViewRuleGlobalStyle;
+interface ViewRuleGlobalPredicateRef {
+  predicateId: GlobalPredicateId;
+}
+declare function isViewRuleGlobalPredicateRef(rule: object): rule is ViewRuleGlobalPredicateRef;
+type RankValue = 'max' | 'min' | 'same' | 'sink' | 'source';
+interface ViewRuleRank<Expr> {
+  targets: Expr[];
+  rank: RankValue;
+}
+type AutoLayoutDirection = 'TB' | 'BT' | 'LR' | 'RL';
+declare function isAutoLayoutDirection(autoLayout: unknown): autoLayout is AutoLayoutDirection;
+interface ViewRuleAutoLayout {
+  direction: AutoLayoutDirection;
+  nodeSep?: number;
+  rankSep?: number;
+}
+declare function isViewRuleAutoLayout(rule: object): rule is ViewRuleAutoLayout;
+interface ViewAutoLayout {
+  direction: ViewRuleAutoLayout['direction'];
+  rankSep?: number;
+  nodeSep?: number;
+}
+/**
+ * v1 Manual layout of a view, stored in the block comment to the view definition.
+ * Keeping this type for backward compatibility and migration purposes.
+ *
+ * @deprecated Use {@link ViewManualLayoutSnapshot} instead
+ */
+type ViewManualLayout = {
+  readonly hash: string;
+  readonly x: number;
+  readonly y: number;
+  readonly width: number;
+  readonly height: number;
+  readonly autoLayout: ViewAutoLayout;
+  readonly nodes: Record<string, {
+    isCompound: boolean;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+  }>;
+  readonly edges: Record<string, {
+    points: NonEmptyArray<Point>;
+    controlPoints?: NonEmptyArray<XYPoint>;
+    labelBBox?: BBox;
+  }>;
+};
+type ViewType = 'element' | 'dynamic' | 'deployment';
+interface BaseViewProperties<A extends Any> extends WithOptionalTags<A>, WithOptionalLinks {
+  readonly id: StrictViewId<A>;
+  readonly title: string | null;
+  readonly description: MarkdownOrString | null;
   /**
-   * Common ancestor of the source and target elements.
-   * Represents the boundary of the connection.
+   * Source file containing this view, relative to the project root.
+   * Undefined if the view is auto-generated.
    */
-  get boundary(): ElementModel<A> | null;
+  readonly sourcePath?: string | undefined;
+}
+interface BaseParsedViewProperties<A extends Any> extends BaseViewProperties<A> {
   /**
-   * Human readable expression of the connection
-   * Mostly used for testing and debugging
+   * Internal field to identify the stage of the view.
+   * This is used to create the correct type of the view.
    */
-  get expression(): string;
+  readonly [_stage]: 'parsed';
   /**
-   * Returns true if only includes relations between the source and target elements.
+   * URI to the source file of this view.
+   * Undefined if the view is auto-generated.
    */
-  get isDirect(): boolean;
+  readonly docUri?: string | undefined;
+}
+type NodeNotation = {
+  kinds: string[];
+  shape: ElementShape;
+  color: Color;
+  title: string;
+};
+interface ViewWithNotation {
+  notation?: {
+    nodes: NodeNotation[];
+  };
+}
+interface ViewWithHash {
   /**
-   * Returns true if includes relations between nested elements of the source and target elements.
+   * Hash of the view object.
+   * This is used to detect changes in layout
    */
-  get isImplicit(): boolean;
-  get directRelations(): ReadonlySet<RelationshipModel<A>>;
-  nonEmpty(): boolean;
-  mergeWith(other: ConnectionModel<A>): ConnectionModel<A>;
-  difference(other: ConnectionModel<A>): ConnectionModel<A>;
-  intersect(other: ConnectionModel<A>): ConnectionModel<A>;
-  equals(other: Connection): boolean;
+  hash: string;
+}
+//#endregion
+//#region src/types/view-parsed.element.d.ts
+/**
+ * Predicates scoped to logical model
+ */
+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;
+}
+declare function isViewRuleGroup<A extends Any>(rule: ElementViewRule<A>): rule is ElementViewRuleGroup<A>;
+interface ElementViewRuleStyle<A extends Any = Any> extends AnyViewRuleStyle<ModelFqnExpr<A>> {}
+interface ElementViewRuleRank<A extends Any = Any> extends ViewRuleRank<ModelFqnExpr<A>> {}
+declare function isViewRuleRank<A extends Any>(rule: ElementViewRule<A>): rule is ElementViewRuleRank<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;
+  Rank: ElementViewRuleRank<A>;
+}>;
+interface ParsedElementView<A extends Any = Any> extends BaseParsedViewProperties<A> {
+  [_type]: 'element';
+  readonly rules: ElementViewRule<A>[];
+  readonly viewOf?: Fqn<A>;
+  readonly extends?: StrictViewId<A>;
+}
+//#endregion
+//#region src/types/view-parsed.dynamic.d.ts
+interface DynamicStep<A extends Any = Any> {
+  readonly source: Fqn<A>;
+  readonly target: Fqn<A>;
+  readonly title?: string | null;
+  readonly kind?: RelationKind<A>;
+  readonly description?: MarkdownOrString;
+  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>;
   /**
-   * Returns a new instance with the updated relations.
-   *
-   * @param relations - A readonly set of `RelationshipModel` instances representing the new relations.
-   * @returns A new `ConnectionModel` instance with the updated relations.
+   * Path to the AST node relative to the view body ast
+   * Used to locate the step in the source code
    */
-  update(relations: ReadonlySet<RelationshipModel<A>>): ConnectionModel<A>;
-  [customInspectSymbol](_depth: any, _inspectOptions: any, _inspect: any): string;
-  toString(): string;
+  readonly astPath: string;
+}
+interface DynamicStepsSeries<A extends Any = Any> {
+  readonly seriesId: string;
+  readonly __series: NonEmptyReadonlyArray<DynamicStep<A>>;
+}
+interface DynamicStepsParallel<A extends Any = Any> {
+  readonly parallelId: string;
+  readonly __parallel: NonEmptyReadonlyArray<DynamicStep<A> | DynamicStepsSeries<A>>;
+}
+declare function getParallelStepsPrefix(id: string): string | null;
+type DynamicViewStep<A extends Any = Any> = ExclusiveUnion<{
+  Step: DynamicStep<A>;
+  Series: DynamicStepsSeries<A>;
+  Parallel: DynamicStepsParallel<A>;
+}>;
+declare function isDynamicStep<A extends Any>(step: DynamicViewStep<A> | undefined): step is DynamicStep<A>;
+declare function isDynamicStepsParallel<A extends Any>(step: DynamicViewStep<A> | undefined): step is DynamicStepsParallel<A>;
+declare function isDynamicStepsSeries<A extends Any>(step: DynamicViewStep<A> | undefined): step is DynamicStepsSeries<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;
+}>;
+type DynamicViewDisplayVariant = 'diagram' | 'sequence';
+interface ParsedDynamicView<A extends Any = Any> extends BaseParsedViewProperties<A> {
+  [_type]: 'dynamic';
   /**
-   * Creates a new connection with reversed direction (target becomes source and vice versa)
+   * How to display the dynamic view
+   * - `diagram`: display as a regular likec4 view
+   * - `sequence`: display as a sequence diagram
+   *
+   * @default 'diagram'
    */
-  reversed(): ConnectionModel<A>;
+  readonly variant?: DynamicViewDisplayVariant;
+  readonly steps: DynamicViewStep<A>[];
+  readonly rules: DynamicViewRule<A>[];
+}
+//#endregion
+//#region src/types/global.d.ts
+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> = NonEmptyArray<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>>;
 }
 //#endregion
-//#region src/model/connection/ops.d.ts
+//#region src/types/model-logical.d.ts
+interface ElementStyle {
+  readonly icon?: Icon;
+  readonly iconColor?: Color;
+  readonly iconSize?: IconSize;
+  readonly iconPosition?: IconPosition;
+  readonly shape?: ElementShape;
+  readonly color?: Color;
+  readonly border?: BorderStyle;
+  /**
+   * In percentage 0-100, 0 is fully transparent
+   *
+   * @default 100
+   */
+  readonly opacity?: number;
+  /**
+   * If true, the element is rendered as multiple shapes
+   * @default false
+   */
+  readonly multiple?: boolean;
+  /**
+   * Shape size
+   *
+   * @default 'md'
+   */
+  readonly size?: ShapeSize;
+  readonly padding?: SpacingSize;
+  readonly textSize?: TextSize;
+}
+type WithSizes = Pick<ElementStyle, 'size' | 'padding' | 'textSize' | 'iconSize'>;
 /**
- * Check if connection is nested inside another connection
- * (i.e. between descendants)
+ * Ensures that the sizes are set to default values if they are not set
  */
-declare function isNestedConnection<T extends {
-  id: string;
-}>(parent: WithSourceTarget<NoInfer<T>>): (nested: WithSourceTarget<T>) => boolean;
-declare function isNestedConnection<T extends {
-  id: string;
-}>(nested: WithSourceTarget<T>, parent: WithSourceTarget<T>): boolean;
-type ConnectionElemId = Connection<{
-  readonly id: string;
-}, any>;
-declare function findDeepestNestedConnection<C extends ConnectionElemId>(connections: ReadonlyArray<C>, connection: C): C | null;
-declare function sortDeepestFirst<C extends ConnectionElemId>(connections: ReadonlyArray<C>): C[];
-type WithBoundary = {
-  id: string;
-  boundary: null | {
-    id: string;
-  };
+declare function ensureSizes<S extends WithSizes>({
+  size,
+  padding,
+  textSize,
+  iconSize,
+  ...rest
+}: S, defaultSize?: "xs" | "sm" | "md" | "lg" | "xl"): Omit<S, keyof WithSizes> & Required<WithSizes>;
+interface Element<A extends Any = Any> extends WithDescriptionAndTech, WithOptionalTags<A>, WithOptionalLinks, WithMetadata<A>, WithNotation {
+  readonly id: Fqn<A>;
+  readonly kind: ElementKind<A>;
+  readonly title: string;
+  readonly style: ElementStyle;
+}
+interface AbstractRelationship<A extends Any> extends WithDescriptionAndTech, WithOptionalTags<A>, WithOptionalLinks, WithMetadata<A> {
+  readonly id: RelationId$1;
+  readonly title?: string | null;
+  readonly kind?: RelationKind<A>;
+  readonly color?: Color;
+  readonly line?: RelationshipLineType;
+  readonly head?: RelationshipArrowType;
+  readonly tail?: RelationshipArrowType;
+  readonly navigateTo?: StrictViewId<A>;
+}
+/**
+ * Relationship between two model elements
+ */
+interface Relationship<A extends Any = Any> extends AbstractRelationship<A> {
+  readonly source: FqnRef.ModelRef<A>;
+  readonly target: FqnRef.ModelRef<A>;
+}
+/**
+ * Backward compatibility alias
+ * @deprecated Use {@link Relationship} instead
+ */
+type ModelRelation<A extends Any = Any> = Relationship<A>;
+//#endregion
+//#region src/types/model-deployment.d.ts
+interface DeploymentNode<A extends Any = Unknown> extends WithDescriptionAndTech, WithOptionalTags<A>, WithOptionalLinks, WithMetadata<A>, WithNotation {
+  element?: never;
+  readonly id: DeploymentFqn<A>;
+  readonly kind: DeploymentKind<A>;
+  readonly title: string;
+  readonly style: ElementStyle;
+}
+interface DeployedInstance<A extends Any = Unknown> extends WithDescriptionAndTech, WithOptionalTags<A>, WithOptionalLinks, WithMetadata<A>, WithNotation {
+  kind?: never;
+  /**
+   * Format: `<DeploymentNode Fqn>.<Instance Id>`
+   * i.e parent fqn is deployment target
+   */
+  readonly id: DeploymentFqn<A>;
+  readonly element: Fqn<A>;
+  readonly title?: string;
+  readonly style: ElementStyle;
+}
+type DeploymentElement<A extends Any = Unknown> = DeploymentNode<A> | DeployedInstance<A>;
+type DeploymentElementRef$1<A extends Any = Unknown> = {
+  readonly id: DeploymentFqn<A>;
+  readonly element?: Fqn<A>;
 };
-declare function sortConnectionsByBoundaryHierarchy(sort?: 'asc' | 'desc'): <T extends WithBoundary, A extends IterableContainer<T>>(array: A) => ReorderedArray<A>;
-declare function sortConnectionsByBoundaryHierarchy<T extends WithBoundary, A extends IterableContainer<T>>(array: A, sort?: 'asc' | 'desc'): ReorderedArray<A>;
+declare function isDeploymentNode<A extends Any>(el: DeploymentElement<A>): el is DeploymentNode<A>;
+declare function isDeployedInstance<A extends Any>(el: DeploymentElement<A>): el is DeployedInstance<A>;
 /**
- * Find connections that includes given connection (i.e between it's ancestors)
+ * Relationship in deployment model
  */
-declare function findAscendingConnections<C extends ConnectionElemId>(connections: ReadonlyArray<C>, connection: C): Array<C>;
+interface DeploymentRelationship<A extends Any = Unknown> extends AbstractRelationship<A> {
+  readonly source: FqnRef.DeploymentRef<A>;
+  readonly target: FqnRef.DeploymentRef<A>;
+}
 /**
- * Find connections that given connection includes (i.e between it's descendants)
+ * Backward compatibility alias
+ * @deprecated Use {@link DeploymentRelationship} instead
  */
-declare function findDescendantConnections<C extends ConnectionElemId>(connections: ReadonlyArray<C>, connection: C): Array<C>;
-declare function mergeConnections<C extends IterableContainer<Connection<any, any>>>(connections: C): Array<C[number]>;
+type DeploymentRelation<A extends Any = Unknown> = DeploymentRelationship<A>;
+//#endregion
+//#region src/types/model-spec.d.ts
 /**
- * Excludes the values existing in `other` array.
- * The output maintains the same order as the input.
+ * Element and deployment kind specification
  */
-declare function differenceConnections<C extends Connection<any, any>>(source: Iterable<C>, exclude: Iterable<C>): C[];
-type WithSourceTarget<T = unknown> = {
-  source: T;
-  target: T;
-};
-declare function hasSameSourceTarget<T>(a: WithSourceTarget<NoInfer<T>>): (b: WithSourceTarget<T>) => boolean;
-declare function hasSameSourceTarget<T>(a: WithSourceTarget<T>, b: WithSourceTarget<T>): boolean;
-declare function hasSameSource<T>(a: WithSourceTarget<NoInfer<T>>): (b: WithSourceTarget<T>) => boolean;
-declare function hasSameSource<T>(a: WithSourceTarget<T>, b: WithSourceTarget<T>): boolean;
-declare function hasSameTarget<T>(a: WithSourceTarget<NoInfer<T>>): (b: WithSourceTarget<T>) => boolean;
-declare function hasSameTarget<T>(a: WithSourceTarget<T>, b: WithSourceTarget<T>): boolean;
-type WithId<T> = {
-  id: T;
+interface ElementSpecification {
+  tags?: Tag$1[];
+  title?: string;
+  summary?: MarkdownOrString;
+  description?: MarkdownOrString;
+  technology?: string;
+  notation?: string;
+  links?: NonEmptyArray<Link>;
+  style: {
+    shape?: ElementShape;
+    icon?: Icon;
+    iconColor?: Color;
+    iconSize?: ShapeSize;
+    iconPosition?: IconPosition;
+    color?: Color;
+    border?: BorderStyle;
+    opacity?: number;
+    size?: ShapeSize;
+    padding?: SpacingSize;
+    textSize?: TextSize;
+    multiple?: boolean;
+  };
+}
+interface TagSpecification {
+  color: ThemeColor | ColorLiteral;
+}
+/**
+ * Checks if tag color is defined in the specification
+ * Expects HEX, `rgb(...)` or `rgba(...)` color
+ */
+declare function isTagColorSpecified(spec: string | TagSpecification): spec is {
+  color: ColorLiteral;
 };
-declare function isOutgoing<T extends string>(source: WithId<NoInfer<T>>): (a: WithSourceTarget<WithId<T>>) => boolean;
-declare function isOutgoing<T extends string>(a: WithSourceTarget<WithId<T>>, source: WithId<T>): boolean;
-declare function isIncoming<T extends string>(target: WithId<NoInfer<T>>): (a: WithSourceTarget<WithId<T>>) => boolean;
-declare function isIncoming<T extends string>(a: WithSourceTarget<WithId<T>>, target: WithId<T>): boolean;
-declare function isAnyInOut<T extends string>(source: WithId<NoInfer<T>>): (a: WithSourceTarget<WithId<T>>) => boolean;
-declare function isAnyInOut<T extends string>(a: WithSourceTarget<WithId<T>>, source: WithId<T>): boolean;
-declare namespace find_d_exports$1 {
-  export { findConnection$1 as findConnection, findConnectionsBetween$1 as findConnectionsBetween, findConnectionsWithin$1 as findConnectionsWithin };
-}
-/**
- * Resolve connection from source to target
- * If direction is `both`, also look for reverse connection
- *
- * @default direction directed
+interface RelationshipSpecification {
+  technology?: string;
+  notation?: string;
+  color?: Color;
+  line?: RelationshipLineType;
+  head?: RelationshipArrowType;
+  tail?: RelationshipArrowType;
+}
+type Specification<A> = A extends Any ? {
+  tags: { [key in Tag<A>]: TagSpecification };
+  elements: { [key in ElementKind<A>]: Partial<ElementSpecification> };
+  deployments: { [key in DeploymentKind<A>]: Partial<ElementSpecification> };
+  relationships: { [key in RelationKind<A>]: Partial<RelationshipSpecification> };
+  metadataKeys?: IsNever<MetadataKey<A>> extends true ? never : MetadataKey<A>[];
+  customColors?: CustomColorDefinitions;
+} : never;
+//#endregion
+//#region src/types/project.d.ts
+type LikeC4ProjectTheme = PartialDeep<WritableDeep<LikeC4Theme>, {
+  recurseIntoArrays: false;
+  allowUndefinedInNonTupleArrays: false;
+}>;
+type LikeC4ProjectStyleDefaults = PartialDeep<WritableDeep<LikeC4StyleDefaults>, {
+  recurseIntoArrays: false;
+  allowUndefinedInNonTupleArrays: false;
+}>;
+interface LikeC4ProjectStylesCustomStylesheets {
+  /**
+   * List of paths to CSS files, relative to the project root
+   * (available in LSP, but not in dumped JSON)
+   */
+  paths?: string[];
+  /**
+   * Merged CSS
+   */
+  content: string;
+}
+interface LikeC4ProjectStylesConfig {
+  theme?: LikeC4ProjectTheme;
+  defaults?: LikeC4ProjectStyleDefaults;
+  customCss?: LikeC4ProjectStylesCustomStylesheets;
+}
+interface LikeC4ProjectManualLayoutsConfig {
+  outDir: string;
+}
+/**
+ * Configuration of the project, as read from the config file.
+ * LikeC4 projects encapsulate models, and can import from each other
  */
-declare function findConnection$1<M extends Any>(source: DeploymentElementModel<M>, target: DeploymentElementModel<NoInfer<M>>, direction: 'directed'): readonly [DeploymentConnectionModel<M>] | readonly [];
-declare function findConnection$1<M extends Any>(source: DeploymentElementModel<M>, target: DeploymentElementModel<NoInfer<M>>, direction: 'both'): readonly [DeploymentConnectionModel<M>, DeploymentConnectionModel<M>] | readonly [DeploymentConnectionModel<M>] | readonly [];
-declare function findConnection$1<M extends Any>(source: DeploymentElementModel<M>, target: DeploymentElementModel<NoInfer<M>>, direction?: 'directed' | 'both'): readonly [DeploymentConnectionModel<M>, DeploymentConnectionModel<M>] | readonly [DeploymentConnectionModel<M>] | readonly [];
+interface LikeC4Project {
+  /**
+   * ID of the project, casted to {@link ProjectId}
+   */
+  readonly id: ProjectId$1;
+  /**
+   * Title of the project
+   */
+  title?: string;
+  /**
+   * Custom styles
+   */
+  styles?: LikeC4ProjectStylesConfig | undefined;
+  /**
+   * Configuration for manual layouts snapshots
+   */
+  manualLayouts?: LikeC4ProjectManualLayoutsConfig | undefined;
+  /**
+   * Automatically derive element technology from icon name
+   * when technology is not explicitly set.
+   * Applies to aws:, azure:, gcp:, and tech: icons.
+   * Defaults to true.
+   */
+  inferTechnologyFromIcon?: boolean | undefined;
+}
+//#endregion
+//#region src/types/view-computed.d.ts
+type ComputedNodeStyle = Simplify<ElementStyle & {
+  icon?: never;
+  shape?: never;
+  color?: never;
+}>;
+interface ComputedNode<A extends Any = Any> extends WithTags<A>, WithOptionalLinks {
+  id: NodeId$1;
+  kind: ElementKind<A> | DeploymentKind<A> | '@group';
+  parent: NodeId$1 | null;
+  /**
+   * Reference to model element
+   */
+  modelRef?: Fqn<A>;
+  /**
+   * Reference to deployment element
+   */
+  deploymentRef?: DeploymentFqn<A>;
+  title: string;
+  /**
+   * Description of the node
+   * either summary or description
+   */
+  description?: MarkdownOrString | null;
+  technology?: string | null;
+  children: NodeId$1[];
+  inEdges: EdgeId$1[];
+  outEdges: EdgeId$1[];
+  shape: ElementShape;
+  color: Color;
+  icon?: Icon | null;
+  style: ComputedNodeStyle;
+  navigateTo?: StrictViewId<A> | null;
+  level: number;
+  depth?: number | null;
+  /**
+   * If this node was customized in the view
+   */
+  isCustomized?: boolean;
+  notation?: string | null;
+  notes?: MarkdownOrString | undefined;
+}
+interface ComputedEdge<A extends Any = Any> extends WithOptionalTags<A> {
+  id: EdgeId$1;
+  parent: NodeId$1 | null;
+  source: NodeId$1;
+  target: NodeId$1;
+  label: string | null;
+  description?: MarkdownOrString | null;
+  technology?: string | null;
+  relations: RelationId$1[];
+  kind?: RelationKind<A> | typeof StepEdgeKind;
+  notation?: string;
+  notes?: MarkdownOrString;
+  color: Color;
+  line: RelationshipLineType;
+  head?: RelationshipArrowType;
+  tail?: RelationshipArrowType;
+  navigateTo?: StrictViewId<A> | null;
+  /**
+   * If this edge is derived from custom relationship predicate
+   */
+  isCustomized?: boolean;
+  /**
+   * Path to the AST node relative to the view body ast
+   * Available only in dynamic views
+   * @internal
+   */
+  astPath?: string;
+  /**
+   * For layouting purposes
+   * @default 'forward'
+   */
+  dir?: 'forward' | 'back' | 'both';
+}
+interface ComputedRankConstraint {
+  type: RankValue;
+  nodes: NodeId$1[];
+}
+interface BaseComputedViewProperties<A extends Any> extends BaseViewProperties<A>, ViewWithHash, ViewWithNotation {
+  readonly [_stage]: 'computed';
+  readonly autoLayout: ViewAutoLayout;
+  readonly nodes: ReadonlyArray<ComputedNode<A>>;
+  readonly edges: ReadonlyArray<ComputedEdge<A>>;
+  /**
+   * If the view has manual layout (v2)
+   */
+  readonly hasManualLayout?: boolean;
+  /**
+   * Manual layout data (v1), for compatibility during migration
+   * @deprecated
+   */
+  readonly manualLayout?: ViewManualLayout | undefined;
+}
+interface ComputedElementView<A extends Any = Any> extends BaseComputedViewProperties<A> {
+  readonly [_type]: 'element';
+  readonly viewOf?: Fqn<A>;
+  readonly extends?: StrictViewId<A>;
+  readonly ranks?: ComputedRankConstraint[];
+}
+interface ComputedDeploymentView<A extends Any = Any> extends BaseComputedViewProperties<A> {
+  readonly [_type]: 'deployment';
+}
+interface ComputedDynamicView<A extends Any = Any> extends BaseComputedViewProperties<A> {
+  readonly [_type]: 'dynamic';
+  /**
+   * How to display the dynamic view
+   * - `diagram`: display as a regular likec4 view
+   * - `sequence`: display as a sequence diagram
+   */
+  readonly variant: DynamicViewDisplayVariant;
+}
+//#endregion
+//#region src/types/view-manual-layout.d.ts
+type LayoutedViewDriftReason = 'not-exists' | 'type-changed' | 'nodes-added' | 'nodes-removed' | 'nodes-drift' | 'edges-added' | 'edges-removed' | 'edges-drift';
+type DiagramNodeDriftReason = 'removed' | 'added' | 'label-changed' | 'modelRef-changed' | 'parent-changed' | 'children-changed' | 'became-compound' | 'became-leaf' | 'shape-changed';
+type DiagramEdgeDriftReason = 'removed' | 'added' | 'label-added' | 'label-removed' | 'label-changed' | 'notes-changed' | 'direction-changed' | 'source-changed' | 'target-changed';
+type ViewManualLayoutSnapshotPerType = {
+  readonly [_type]: 'element';
+  readonly viewOf?: Fqn$1;
+  readonly extends?: ViewId$1;
+} | {
+  readonly [_type]: 'deployment';
+} | {
+  readonly [_type]: 'dynamic';
+  readonly sequenceLayout: LayoutedDynamicView.Sequence.Layout;
+};
+type ViewManualLayoutSnapshot<Type extends ViewType = ViewType> = Simplify<ViewManualLayoutSnapshotPerType & {
+  readonly id: ViewId$1;
+  readonly title: string | null;
+  readonly description: MarkdownOrString | null;
+  readonly [_type]: Type;
+  readonly [_stage]: 'layouted';
+  readonly hash: string;
+  readonly nodes: ReadonlyArray<DiagramNode>;
+  readonly edges: ReadonlyArray<DiagramEdge>;
+  readonly bounds: BBox;
+  readonly autoLayout: ViewAutoLayout;
+} & ViewWithNotation>;
+//#endregion
+//#region src/types/view-layouted.d.ts
+interface DiagramNode<A extends Any = Any> extends ComputedNode<A>, BBox {
+  /**
+   * Absolute X coordinate
+   */
+  x: number;
+  /**
+   * Absolute Y coordinate
+   */
+  y: number;
+  width: number;
+  height: number;
+  /**
+   * Bounding box of label
+   * (Absolute coordinates)
+   */
+  labelBBox: BBox;
+  /**
+   * List of reasons causing node drift
+   */
+  drifts?: NonEmptyReadonlyArray<DiagramNodeDriftReason> | null;
+}
+interface DiagramEdge<A extends Any = Any> extends ComputedEdge<A> {
+  /**
+   * Bezier points
+   * (Absolute coordinates)
+   */
+  points: NonEmptyArray<Point>;
+  /**
+   * Control points to adjust the edge
+   * (Absolute coordinates)
+   */
+  controlPoints?: NonEmptyArray<XYPoint> | null;
+  /**
+   * Bounding box of label
+   * (Absolute coordinates)
+   */
+  labelBBox?: BBox | null;
+  /**
+   * List of reasons causing edge drift
+   */
+  drifts?: NonEmptyReadonlyArray<DiagramEdgeDriftReason> | null;
+}
 /**
- * Resolve all connections between element and others
- * By default, look for both directions.
- *
- * @default direction both
+ * Type of the layout
+ * - `auto`: auto-layouted from the current sources
+ * - `manual`: read from the manually layouted snapshot
  */
-declare function findConnectionsBetween$1<M extends Any>(element: DeploymentElementModel<M>, others: Iterable<DeploymentElementModel<NoInfer<M>>>, direction?: 'directed' | 'both'): readonly DeploymentConnectionModel<M>[];
+type LayoutType = 'auto' | 'manual';
+interface BaseLayoutedViewProperties<A extends Any> extends BaseViewProperties<A>, ViewWithHash, ViewWithNotation {
+  readonly [_stage]: 'layouted';
+  /**
+   * If undefined, view does not have any manual layouts, and is auto-layouted
+   */
+  readonly [_layout]?: LayoutType;
+  readonly autoLayout: ViewAutoLayout;
+  readonly nodes: ReadonlyArray<DiagramNode<A>>;
+  readonly edges: ReadonlyArray<DiagramEdge<A>>;
+  readonly bounds: BBox;
+  /**
+   * If diagram has manual layout
+   * But was changed and layout should be recalculated
+   * @deprecated manual layout v2 uses {@link drifts}
+   */
+  readonly hasLayoutDrift?: boolean;
+  /**
+   * List of reasons causing layout drift
+   * If undefined or null, there is no layout drift or view is auto-layouted
+   */
+  readonly drifts?: NonEmptyReadonlyArray<LayoutedViewDriftReason> | null;
+}
+interface LayoutedElementView<A extends Any = Any> extends BaseLayoutedViewProperties<A> {
+  readonly [_type]: 'element';
+  readonly viewOf?: Fqn<A>;
+  readonly extends?: StrictViewId<A>;
+}
+interface LayoutedDeploymentView<A extends Any = Any> extends BaseLayoutedViewProperties<A> {
+  readonly [_type]: 'deployment';
+}
+interface LayoutedDynamicView<A extends Any = Any> extends BaseLayoutedViewProperties<A> {
+  readonly [_type]: 'dynamic';
+  /**
+   * Default variant of this dynamic view
+   * - `diagram`: display as a regular likec4 view (default if not specified)
+   * - `sequence`: display as a sequence diagram
+   */
+  readonly variant: DynamicViewDisplayVariant;
+  /**
+   * Sequence layout of this dynamic view
+   */
+  readonly sequenceLayout: LayoutedDynamicView.Sequence.Layout;
+}
+declare namespace LayoutedDynamicView {
+  namespace Sequence {
+    interface ActorPort {
+      readonly id: string;
+      readonly cx: number;
+      readonly cy: number;
+      readonly height: number;
+      readonly type: 'target' | 'source';
+      readonly position: 'left' | 'right' | 'top' | 'bottom';
+    }
+    interface Actor {
+      readonly id: NodeId;
+      readonly x: number;
+      readonly y: number;
+      readonly width: number;
+      readonly height: number;
+      readonly ports: ReadonlyArray<ActorPort>;
+    }
+    interface Compound {
+      readonly id: NodeId;
+      /**
+       * Original node id, since multiple compound nodes can be built from one node
+       */
+      readonly origin: NodeId;
+      readonly x: number;
+      readonly y: number;
+      readonly width: number;
+      readonly height: number;
+      readonly depth: number;
+    }
+    interface ParallelArea {
+      readonly parallelPrefix: string;
+      readonly x: number;
+      readonly y: number;
+      readonly width: number;
+      readonly height: number;
+    }
+    interface Step {
+      readonly id: EdgeId;
+      readonly labelBBox?: {
+        width: number;
+        height: number;
+      } | undefined;
+      readonly sourceHandle: string;
+      readonly targetHandle: string;
+    }
+    interface Layout {
+      readonly actors: ReadonlyArray<Actor>;
+      /**
+       * Steps in the sequence diagram (filtered edges with compound nodes)
+       */
+      readonly steps: ReadonlyArray<Step>;
+      readonly compounds: ReadonlyArray<Compound>;
+      readonly parallelAreas: ReadonlyArray<ParallelArea>;
+      readonly bounds: BBox;
+    }
+  }
+}
+//#endregion
+//#region src/types/view-parsed.deployment.d.ts
 /**
- * Resolve all connections within a given set of elements
+ * Predicates scoped to deployment model
  */
-declare function findConnectionsWithin$1<M extends Any>(elements: Iterable<DeploymentElementModel<M>>): readonly DeploymentConnectionModel<M>[];
-declare namespace find_d_exports {
-  export { findConnection, findConnectionsBetween, findConnectionsWithin };
+interface DeploymentViewIncludePredicate<A extends Any = Unknown> extends AnyIncludePredicate<Expression<A>> {}
+interface DeploymentViewExcludePredicate<A extends Any = Unknown> extends AnyExcludePredicate<Expression<A>> {}
+type DeploymentViewPredicate<A extends Any = Unknown> = DeploymentViewIncludePredicate<A> | DeploymentViewExcludePredicate<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>[];
 }
+//#endregion
+//#region src/types/view.d.ts
+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 ProcessedView<A extends Any = Any> = ComputedView<A> | LayoutedView<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 ViewOnStage<V extends AnyView<Any>, T extends ModelStage> = Extract<V, {
+  [_stage]: T;
+}>;
+type ViewWithType<V extends AnyView<Any>, T extends ViewType> = Extract<V, {
+  [_type]: T;
+}>;
+type ViewRule<A extends Any = Any> = ParsedView<A>['rules'][number];
+type ViewRulePredicate<A extends Any = Any> = Extract<ViewRule<A>, {
+  include: any[];
+} | {
+  exclude: any[];
+}>;
+declare function isViewRulePredicate<V extends ViewRule<any>>(rule: V): rule is Extract<V, {
+  include: any[];
+} | {
+  exclude: any[];
+}>;
+declare function isViewRuleStyle<V extends ViewRule<any>>(rule: V): rule is Extract<V, {
+  targets: any[];
+  style: {};
+}>;
+declare function isComputedView<V extends AnyView<any>>(view: V): view is ExtractOnStage<V, 'computed'>;
+declare function isDiagramView<V extends AnyView<any>>(view: V): view is ExtractOnStage<V, 'layouted'>;
+declare function isElementView<V extends AnyView<any>>(view: V): view is ViewWithType<V, 'element'>;
+declare function isScopedElementView<V extends AnyView<any>>(view: V): view is ViewWithType<V, 'element'> & {
+  viewOf: Fqn<Any>;
+};
+declare function isExtendsElementView<V extends AnyView<any>>(view: V): view is ViewWithType<V, 'element'> & {
+  extends: StrictViewId<Any>;
+};
+declare function isDeploymentView<V extends AnyView<any>>(view: V): view is ViewWithType<V, 'deployment'>;
+declare function isDynamicView<V extends AnyView<any>>(view: V): view is ViewWithType<V, 'dynamic'>;
+//#endregion
+//#region src/types/model-data.d.ts
 /**
- * Resolve connection from source to target
+ * Represents a LikeC4 model data, in different stages of processing
+ * - {@link ParsedLikeC4ModelData} - parsed from DSL or result from Builder
+ * - {@link ComputedLikeC4ModelData} - computed from parsed model
+ * - {@link LayoutedLikeC4ModelData} - layouted from computed model
  *
- * @param direction - if 'both', also returns connection from target to source
- * @default `directed`
+ * !IMPORTANT: This is a low-level type, use `LikeC4Model` instead.
  */
-declare function findConnection<A extends Any>(source: ElementModel<A>, target: ElementModel<A>, direction?: 'directed' | 'both'): [ConnectionModel<A>, ConnectionModel<A>] | [ConnectionModel<A>] | [];
+interface BaseLikeC4ModelData<A extends Any> {
+  [_stage]: A['Stage'];
+  projectId: ProjectId<A>;
+  project: LikeC4Project;
+  specification: Specification<A>;
+  elements: Record<ElementId<A>, Element<A>>;
+  deployments: {
+    elements: Record<DeploymentId<A>, DeploymentElement<A>>;
+    relations: Record<RelationId$1, DeploymentRelationship<A>>;
+  };
+  relations: Record<RelationId$1, Relationship<A>>;
+  globals: ModelGlobals;
+  imports: Record<string, NonEmptyArray<Element<A>>>;
+}
+type AuxFromLikeC4ModelData<D> = D extends BaseLikeC4ModelData<infer A extends Any> ? IsAny<A> extends true ? never : A : never;
+interface ParsedLikeC4ModelData<A extends AnyParsed = UnknownParsed> extends BaseLikeC4ModelData<A> {
+  [_stage]: 'parsed';
+  views: Record<ViewId<A>, ParsedView<A>>;
+}
+interface ComputedLikeC4ModelData<A extends AnyComputed = UnknownComputed> extends BaseLikeC4ModelData<A> {
+  [_stage]: 'computed';
+  views: Record<ViewId<A>, ComputedView<A>>;
+  /**
+   * If project contains saved manual layouts
+   */
+  manualLayouts?: Record<ViewId$1, ViewManualLayoutSnapshot>;
+}
+interface LayoutedLikeC4ModelData<A extends AnyLayouted = UnknownLayouted> extends BaseLikeC4ModelData<A> {
+  [_stage]: 'layouted';
+  views: Record<ViewId<A>, LayoutedView<A>>;
+  /**
+   * If this model contains saved manual layouts
+   */
+  manualLayouts?: Record<ViewId$1, ViewManualLayoutSnapshot>;
+}
+type LikeC4ModelData<A extends Any> = ParsedLikeC4ModelData<A> | ComputedLikeC4ModelData<A> | LayoutedLikeC4ModelData<A>;
+//#endregion
+//#region src/types/model-dump.d.ts
 /**
- * Resolve all connections between element and others
- * @param direction - if 'directed', only look for outgoing connections from the element to others
- * @default `both`
+ * JSON representation of {@link Specification}
  */
-declare function findConnectionsBetween<M extends Any>(element: ElementModel<M>, others: Iterable<ElementModel<M>>, direction?: 'directed' | 'both'): readonly ConnectionModel<M>[];
+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>;
 /**
- * Resolve all connections within a given set of elements
+ * Dump differs from {@link ParsedLikeC4ModelData} by the fact that it is computed or layouted
  */
-declare function findConnectionsWithin<M extends Any>(elements: Iterable<ElementModel<M>>): readonly ConnectionModel<M>[];
+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 '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;
 //#endregion
-//#region src/model/guards.d.ts
-type AnyModel<A extends Any> = DeploymentNodeModel<A> | DeployedInstanceModel<A> | DeploymentRelationModel<A> | AnyRelationshipModel<A> | NestedElementOfDeployedInstanceModel<A> | ElementModel<A> | RelationshipModel<A> | LikeC4ViewModel<A> | NodeModel<A> | EdgeModel<A>;
-declare function isDeploymentNodeModel<M extends Any>(model: AnyModel<M>): model is DeploymentNodeModel<M>;
-declare function isDeployedInstanceModel<M extends Any>(model: AnyModel<M>): model is DeployedInstanceModel<M>;
-declare function isDeploymentElementModel<M extends Any>(model: AnyModel<M>): model is DeploymentElementModel<M>;
-declare function isNestedElementOfDeployedInstanceModel<M extends Any>(model: AnyModel<M>): model is NestedElementOfDeployedInstanceModel<M>;
-declare function isDeploymentRelationModel<M extends Any>(x: AnyModel<M>): x is DeploymentRelationModel<M>;
-declare function isRelationModel<M extends Any>(x: AnyModel<M>): x is RelationshipModel<M>;
-declare function isElementModel<M extends Any>(element: AnyModel<M>): element is ElementModel<M>;
-declare function isLikeC4ViewModel<M extends Any>(view: AnyModel<M>): view is LikeC4ViewModel<M>;
-declare function isNodeModel<M extends Any>(node: AnyModel<M>): node is NodeModel<M>;
-declare function isEdgeModel<M extends Any>(edge: AnyModel<M>): edge is EdgeModel<M>;
+//#region src/types/view-changes.d.ts
+declare namespace ViewChange {
+  interface ChangeElementStyle {
+    op: 'change-element-style';
+    style: {
+      border?: BorderStyle;
+      opacity?: number;
+      shape?: ElementShape;
+      color?: ThemeColor;
+    };
+    targets: NonEmptyArray<Fqn$1 | DeploymentFqn$1>;
+  }
+  interface SaveViewSnapshot {
+    op: 'save-view-snapshot';
+    layout: LayoutedView;
+  }
+  interface ResetManualLayout {
+    op: 'reset-manual-layout';
+  }
+  interface ChangeAutoLayout {
+    op: 'change-autolayout';
+    layout: {
+      direction: AutoLayoutDirection;
+      nodeSep?: number | null;
+      rankSep?: number | null;
+    };
+  }
+}
+type ViewChange = ViewChange.ChangeElementStyle | ViewChange.SaveViewSnapshot | ViewChange.ResetManualLayout | ViewChange.ChangeAutoLayout;
 //#endregion
-//#region src/model/utils/view-title-path.d.ts
-declare const VIEW_FOLDERS_SEPARATOR = "/";
+//#region src/types/RichText.d.ts
+interface RichTextEmpty {
+  readonly isEmpty: true;
+  readonly isMarkdown: false;
+  readonly nonEmpty: false;
+  readonly $source: null;
+  readonly text: null;
+  readonly md: null;
+  readonly html: null;
+  equals(other: unknown): boolean;
+}
+interface RichTextNonEmpty {
+  readonly isEmpty: false;
+  readonly nonEmpty: true;
+  readonly isMarkdown: boolean;
+  readonly $source: MarkdownOrString;
+  readonly text: string;
+  readonly md: string;
+  readonly html: string;
+  equals(other: unknown): boolean;
+}
+type RichTextOrEmpty = RichTextNonEmpty | RichTextEmpty;
 /**
- * Normalizes view path by removing spaces from segments, removing empty segments,
- * and removing leading/trailing slashes
- * @example
- * normalizeViewPath('One / Tw o / Thre e') === 'One/Tw o/Thre e'
+ * RichText is a class that represents a potentially markdown string.
+ * It can be either a plain text or a markdown.
+ * It is used to represent the content of a node or a link.
  */
-declare const normalizeViewPath: (title: string) => string;
+declare class RichText {
+  private static mdcache;
+  private static txtcache;
+  private static getOrCreateFromText;
+  private static getOrCreateFromMarkdown;
+  /**
+   * Creates and memoizes a RichText instance.
+   * @see ElementModel.description
+   * @example
+   *
+   *  get description(): RichTextOrEmpty {
+   *    return RichText.memoize(this, 'description', this.$element.description)
+   *  }
+   */
+  static memoize(obj: object, tag: symbol | string, source: MarkdownOrString | null | undefined): RichTextOrEmpty;
+  /**
+   * Creates a RichText instance from a source.
+   */
+  static from(source: RichTextOrEmpty | MarkdownOrString | string | null | undefined): RichTextOrEmpty;
+  /**
+   * This is a workaround for the fact that we need instance of RichText for `instanceof` checks
+   * It is invalid inheritance (returning `null` from getters), and we cast to @see RichTextEmpty
+   */
+  static EMPTY: RichTextEmpty;
+  readonly $source: Readonly<MarkdownOrString> | null;
+  readonly isEmpty: boolean;
+  readonly nonEmpty: boolean;
+  readonly isMarkdown: boolean;
+  /**
+   * Private constructor to prevent direct instantiation.
+   * Use {@link RichText.from} or {@link RichText.memoize} instead.
+   */
+  private constructor();
+  /**
+   * Returns the text content of the rich text.
+   * If the source is a string, it returns the string.
+   * If the source is a markdown, it returns the markdown.
+   */
+  get text(): string;
+  /**
+   * Returns the markdown content of the rich text.
+   * If the source is a string, it returns the string.
+   * If the source is a markdown, it returns the markdown.
+   */
+  get md(): string;
+  /**
+   * Returns the html content of the rich text.
+   * If the source is a string, it returns the string.
+   * If the source is a markdown, it returns the HTML.
+   */
+  get html(): string;
+  equals(other: unknown): boolean;
+}
+//#endregion
+//#region src/types/guards.d.ts
+declare function isString(value: unknown): value is string;
+declare function isNonEmptyArray<A>(arr: ArrayLike<A> | undefined): arr is NonEmptyArray<A>;
+declare function hasProp<T extends object, P extends keyof T & string>(value: T, path: P): value is SetRequired<SetNonNullable<T, P>, P>;
+type Guard<N = unknown> = (n: unknown) => n is N;
 /**
- * Returns view group path if it is used as a path
- * Returns empty string if it is not a path
+ * Extracts the guarded type from a Guard type.
+ *
+ * @template G - A Guard type or union of Guard types
+ * @returns The type that the guard narrows to
+ *
  * @example
- * getViewFolderPath('One / Tw o / Thre e') === 'One/Tw o'
- * getViewFolderPath('One') === ''
+ * ```typescript
+ * const isString = (n): n is string => typeof n === 'string';
+ * GuardedBy<typeof isString>; // string
+ * ```
  */
-declare const getViewFolderPath: (title: string) => string | null;
+type GuardedBy<G> = G extends Guard<infer N> ? N : never;
 /**
- * Returns view title if it is used as a path
+ * Creates a type guard that checks if a value matches any of the provided predicates.
+ *
+ * @template Predicates - A non-empty array of guard functions
+ * @param predicates - The guard functions to test against
+ * @returns A type guard function that returns true if the value matches any of the predicates
+ *
  * @example
- * getViewTitleFromPath('One / Tw o / Thre e') === 'Thre e'
- * getViewTitleFromPath('One') === 'One'
+ * ```typescript
+ * const isStringOrNumber = isAnyOf(isString, isNumber);
+ *
+ * if (isStringOrNumber(value)) {
+ *   // value is now typed as string | number
+ *   console.log(value);
+ * }
+ * ```
  */
-declare const extractViewTitleFromPath: (title: string) => string;
+declare function isAnyOf<const Predicates extends NonEmptyArray<Guard>>(...predicates: Predicates): <T>(value: T) => value is T & GuardedBy<Predicates[number]>;
 //#endregion
-export { sortDeepestFirst as A, hasSameTarget as C, isOutgoing as D, isNestedConnection as E, DeploymentConnectionModel as M, Connection as N, mergeConnections as O, hasSameSourceTarget as S, isIncoming as T, differenceConnections as _, isDeployedInstanceModel as a, findDescendantConnections as b, isDeploymentRelationModel as c, isLikeC4ViewModel as d, isNestedElementOfDeployedInstanceModel as f, find_d_exports$1 as g, find_d_exports as h, normalizeViewPath as i, ConnectionModel as j, sortConnectionsByBoundaryHierarchy as k, isEdgeModel as l, isRelationModel as m, extractViewTitleFromPath as n, isDeploymentElementModel as o, isNodeModel as p, getViewFolderPath as r, isDeploymentNodeModel as s, VIEW_FOLDERS_SEPARATOR as t, isElementModel as u, findAscendingConnections as v, isAnyInOut as w, hasSameSource as x, findDeepestNestedConnection as y };
+export { LayoutedViewDriftReason as $, IterableContainer as $i, FqnRef as $n, SpecAux as $r, ElementViewPredicate as $t, isComputedView as A, RelationKind$1 as Ai, ModelRelationExpr as An, ThemeColors as Ar, ModelRelation as At, DeploymentViewIncludePredicate as B, isGroupElementKind as Bi, OperatorPredicate as Bn, ElementId as Br, DynamicStepsParallel as Bt, LayoutedView as C, Icon as Ci, ViewWithNotation as Cn, isCustomColor as Cr, DeploymentRelation as Ct, ViewRule as D, NoneIcon as Di, isViewRuleGlobalStyle as Dn, ElementShapes as Dr, AbstractRelationship as Dt, ViewOnStage as E, NodeId$1 as Ei, isViewRuleGlobalPredicateRef as En, DefaultTagColors as Er, isDeploymentNode as Et, isExtendsElementView as F, Tag$1 as Fi, AndOperator as Fn, Aux as Fr, GlobalPredicates as Ft, DiagramEdge as G, ExtractOnStage as Gi, WhereOperator as Gn, LooseLiteral as Gr, DynamicViewStep as Gt, DeploymentViewRule as H, scalar_d_exports as Hi, Participant as Hn, Fqn as Hr, DynamicViewDisplayVariant as Ht, isScopedElementView as I, ViewId$1 as Ii, EqualOperator as In, DeploymentFqn as Ir, GlobalStyleID as It, LayoutedDeploymentView as J, _stage as Ji, isNotOperator as Jn, Metadata as Jr, isDynamicStep as Jt, DiagramNode as K, ModelStage as Ki, isAndOperator as Kn, LooseTag as Kr, ParsedDynamicView as Kt, isViewRulePredicate as L, extractStep as Li, Filterable as Ln, DeploymentId as Lr, GlobalStyles as Lt, isDiagramView as M, StepEdgeId as Mi, FqnExpr as Mn, AnyComputed as Mr, ensureSizes as Mt, isDynamicView as N, StepEdgeIdLiteral as Ni, PredicateSelector as Nn, AnyLayouted as Nr, GlobalDynamicPredicates as Nt, ViewRulePredicate as O, ProjectId$1 as Oi, ModelExpression as On, IconPositions as Or, Element as Ot, isElementView as P, StepEdgeKind as Pi, RelationExpr as Pn, AnyParsed as Pr, GlobalPredicateId as Pt, DiagramNodeDriftReason as Q, ExclusiveUnion as Qi, whereOperatorAsPredicate as Qn, RelationKind as Qr, ElementViewIncludePredicate as Qt, isViewRuleStyle as R, flattenMarkdownOrString as Ri, KindEqual as Rn, DeploymentKind as Rr, ModelGlobals as Rt, ComputedView as S, GroupElementKind as Si, ViewWithHash as Sn, ThemeColorValues as Sr, DeploymentNode as St, ProcessedView as T, MarkdownOrString as Ti, isViewRuleAutoLayout as Tn, BorderStyles as Tr, isDeployedInstance as Tt, DeploymentViewRuleStyle as U, splitGlobalFqn as Ui, ParticipantOperator as Un, LooseDeploymentId as Ur, DynamicViewIncludeRule as Ut, DeploymentViewPredicate as V, isStepEdgeId as Vi, OrOperator as Vn, ElementKind as Vr, DynamicStepsSeries as Vt, ParsedDeploymentView as W, stepEdgeId as Wi, TagEqual as Wn, LooseElementId as Wr, DynamicViewRule as Wt, LayoutedElementView as X, isOnStage as Xi, isParticipantOperator as Xn, ProjectId as Xr, isDynamicStepsSeries as Xt, LayoutedDynamicView as Y, _type as Yi, isOrOperator as Yn, MetadataKey as Yr, isDynamicStepsParallel as Yt, DiagramEdgeDriftReason as Z, Coalesce as Zi, isTagEqual as Zn, RelationId as Zr, ElementViewExcludePredicate as Zt, ComputedLikeC4ModelData as _, DeploymentKind$1 as _i, ViewRuleAutoLayout as _n, ShapeSize as _r, TagSpecification as _t, isNonEmptyArray as a, NonEmptyReadonlyArray as aa, UnknownComputed as ai, isViewRuleGroup as an, ElementColorValues as ar, ComputedNode as at, ParsedLikeC4ModelData as b, Fqn$1 as bi, ViewRuleRank as bn, TextSize as br, DeploymentElement as bt, RichTextEmpty as c, exact as ca, ViewId as ci, AnyIncludePredicate as cn, IconPosition as cr, LikeC4Project as ct, AuxFromDump as d, preferSummary as di, BaseParsedViewProperties as dn, LikeC4StylesConfig as dr, LikeC4ProjectStylesConfig as dt, IteratorLike as ea, Stage as ei, ElementViewRule as en, BorderStyle as er, ViewManualLayoutSnapshot as et, LikeC4ModelDump as f, setProject as fi, BaseViewProperties as fn, LikeC4Theme as fr, LikeC4ProjectStylesCustomStylesheets as ft, AuxFromLikeC4ModelData as g, DeploymentFqn$1 as gi, ViewManualLayout as gn, RelationshipLineType as gr, Specification as gt, SpecificationDump as h, BuiltInIcon as hi, ViewAutoLayout as hn, RelationshipColorValues as hr, RelationshipSpecification as ht, isAnyOf as i, NonEmptyArray as ia, Unknown as ii, ParsedElementView as in, CustomColorDefinitions as ir, ComputedElementView as it, isDeploymentView as j, RelationshipKind as ji, Expression as jn, Any as jr, Relationship as jt, ViewWithType as k, RelationId$1 as ki, ModelFqnExpr as kn, Sizes as kr, ElementStyle as kt, RichTextOrEmpty as l, _aux_d_exports as li, AnyViewRuleStyle as ln, IconSize as lr, LikeC4ProjectManualLayoutsConfig as lt, SpecTypesFromDump as m, AnyFqn as mi, RankValue as mn, RelationshipArrowTypes as mr, ElementSpecification as mt, GuardedBy as n, Link as na, Tag as ni, ElementViewRuleRank as nn, ColorLiteral as nr, ComputedDynamicView as nt, isString as o, Predicate as oa, UnknownLayouted as oi, isViewRuleRank as on, ElementShape as or, ComputedNodeStyle as ot, ProjectDump as p, toComputed as pi, NodeNotation as pn, RelationshipArrowType as pr, LikeC4ProjectTheme as pt, LayoutType as q, _layout as qi, isKindEqual as qn, LooseViewId as qr, getParallelStepsPrefix as qt, hasProp as r, NTuple as ra, Tags as ri, ElementViewRuleStyle as rn, CustomColor as rr, ComputedEdge as rt, RichText as s, ReorderedArray as sa, UnknownParsed as si, AnyExcludePredicate as sn, HexColor as sr, ComputedRankConstraint as st, Guard as t, KeysOf as ta, StrictViewId as ti, ElementViewRuleGroup as tn, Color as tr, ComputedDeploymentView as tt, ViewChange as u, preferDescription as ui, AutoLayoutDirection as un, LikeC4StyleDefaults as ur, LikeC4ProjectStyleDefaults as ut, LayoutedLikeC4ModelData as v, EdgeId$1 as vi, ViewRuleGlobalPredicateRef as vn, Size as vr, isTagColorSpecified as vt, ParsedView as w, IconUrl as wi, isAutoLayoutDirection as wn, isThemeColor as wr, DeploymentRelationship as wt, AnyView as x, GlobalFqn as xi, ViewType as xn, ThemeColor as xr, DeploymentElementRef$1 as xt, LikeC4ModelData as y, ElementKind$1 as yi, ViewRuleGlobalStyle as yn, SpacingSize as yr, DeployedInstance as yt, DeploymentViewExcludePredicate as z, isGlobalFqn as zi, NotOperator as zn, EdgeId as zr, DynamicStep as zt };