@likec4/core 1.18.0 → 1.19.0

package/dist/shared/{core.DMYY7C8s.d.ts → core.CmYMqgha.d.mts}

@@ -1,110 +1,5 @@
-import { Tagged, LiteralUnion, TupleToUnion, NonEmptyTuple, Simplify, MergeExclusive, UnionToIntersection } from 'type-fest';
-
-type NonEmptyArray<T> = [T, ...T[]];
-type NonEmptyReadonlyArray<T> = readonly [T, ...T[]];
-type IconUrl = Tagged<string, 'IconUrl'> | 'none';
-type CustomColor = string;
-type Point = readonly [x: number, y: number];
-interface XYPoint {
-    x: number;
-    y: number;
-}
-type KeysOf<T> = keyof T extends infer K extends string ? K : never;
-
-declare const ThemeColors: readonly ["amber", "blue", "gray", "slate", "green", "indigo", "muted", "primary", "red", "secondary", "sky"];
-type ThemeColor = typeof ThemeColors[number];
-type HexColorLiteral = `#${string}`;
-type ColorLiteral = HexColorLiteral;
-type Color = LiteralUnion<ThemeColor, string>;
-declare function isThemeColor(color: Color): color is ThemeColor;
-interface ElementThemeColorValues {
-    fill: ColorLiteral;
-    stroke: ColorLiteral;
-    hiContrast: ColorLiteral;
-    loContrast: ColorLiteral;
-}
-type ElementThemeColors = {
-    [key in ThemeColor]: ElementThemeColorValues;
-};
-interface RelationshipThemeColorValues {
-    lineColor: ColorLiteral;
-    labelBgColor: ColorLiteral;
-    labelColor: ColorLiteral;
-}
-interface ThemeColorValues {
-    elements: ElementThemeColorValues;
-    relationships: RelationshipThemeColorValues;
-}
-type RelationshipThemeColors = {
-    [key in ThemeColor]: RelationshipThemeColorValues;
-};
-interface LikeC4Theme {
-    font: 'Arial';
-    shadow: ColorLiteral;
-    relationships: RelationshipThemeColors;
-    elements: ElementThemeColors;
-}
-
-type Fqn<Id extends string = string> = Tagged<Id, 'Fqn'>;
-declare function AsFqn(name: string, parent?: Fqn | null): Fqn;
-declare const BorderStyles: readonly ["solid", "dashed", "dotted", "none"];
-type BorderStyle = TupleToUnion<typeof BorderStyles>;
-type ElementKind<Kinds extends string = string> = Tagged<Kinds, 'ElementKind'>;
-declare namespace ElementKind {
-    const Group: ElementKind;
-}
-declare const ElementShapes: readonly ["rectangle", "person", "browser", "mobile", "cylinder", "storage", "queue"];
-type ElementShape = TupleToUnion<typeof ElementShapes>;
-declare const DefaultThemeColor = "primary";
-declare const DefaultElementShape = "rectangle";
-interface ElementStyle {
-    readonly border?: BorderStyle;
-    /**
-     * In percentage 0-100, 0 is fully transparent
-     *
-     * @default 100
-     */
-    readonly opacity?: number;
-}
-type Tag<Tags extends string = string> = Tagged<Tags, 'Tag'>;
-interface TagSpec {
-    readonly id: Tag;
-    readonly style: ElementStyle;
-}
-interface Link {
-    readonly title?: string;
-    readonly url: string;
-    readonly relative?: string;
-}
-interface TypedElement<Ids extends string, Kinds extends string, Tags extends string, MetadataKeys extends string = never> {
-    readonly id: Fqn<Ids>;
-    readonly kind: ElementKind<Kinds>;
-    readonly title: string;
-    readonly description: string | null;
-    readonly technology: string | null;
-    readonly tags: NonEmptyArray<Tag<Tags>> | null;
-    readonly links: NonEmptyArray<Link> | null;
-    readonly icon?: IconUrl;
-    readonly shape?: ElementShape;
-    readonly color?: Color;
-    readonly style?: ElementStyle;
-    readonly notation?: string;
-    readonly metadata?: Record<MetadataKeys, string>;
-}
-interface Element extends TypedElement<string, string, string, string> {
-}
-interface ElementKindSpecificationStyle {
-    shape?: ElementShape;
-    icon?: IconUrl;
-    color?: Color;
-    border?: BorderStyle;
-    opacity?: number;
-}
-interface ElementKindSpecification {
-    readonly technology?: string;
-    readonly notation?: string;
-    readonly style: ElementKindSpecificationStyle;
-}
+import { Tagged, NonEmptyTuple, Simplify, MergeExclusive } from 'type-fest';
+import { N as NonEmptyArray, F as Fqn, l as ElementShape, s as Color, I as IconUrl, h as BorderStyle, f as ElementKind, o as Tag, E as ExclusiveUnion, m as ElementStyle, n as Link, T as ThemeColorValues, X as XYPoint, P as Point, x as ThemeColor, j as ElementKindSpecification, q as TypedElement } from './core.D74xkKkG.mjs';
 
 type EqualOperator<V> = {
     eq: V;
@@ -113,36 +8,36 @@ type EqualOperator<V> = {
     eq?: never;
     neq: V;
 };
-type AllNever$1 = {
+type AllNever = {
     not?: never;
     and?: never;
     or?: never;
     tag?: never;
     kind?: never;
 };
-type TagEqual<Tag> = Omit<AllNever$1, 'tag'> & {
+type TagEqual<Tag> = Omit<AllNever, 'tag'> & {
     tag: EqualOperator<Tag>;
 };
 declare const isTagEqual: <Tag>(operator: WhereOperator<Tag, any>) => operator is TagEqual<Tag>;
-type KindEqual<Kind> = Omit<AllNever$1, 'kind'> & {
+type KindEqual<Kind> = Omit<AllNever, 'kind'> & {
     kind: EqualOperator<Kind>;
 };
 declare const isKindEqual: <Kind>(operator: WhereOperator<any, Kind>) => operator is KindEqual<Kind>;
-type NotOperator<Tag, Kind> = Omit<AllNever$1, 'not'> & {
+type NotOperator<Tag, Kind> = Omit<AllNever, 'not'> & {
     not: WhereOperator<Tag, Kind>;
 };
 declare const isNotOperator: <Tag, Kind>(operator: WhereOperator<Tag, Kind>) => operator is NotOperator<Tag, Kind>;
-type AndOperator<Tag, Kind> = Omit<AllNever$1, 'and'> & {
+type AndOperator<Tag, Kind> = Omit<AllNever, 'and'> & {
     and: NonEmptyArray<WhereOperator<Tag, Kind>>;
 };
 declare const isAndOperator: <Tag, Kind>(operator: WhereOperator<Tag, Kind>) => operator is AndOperator<Tag, Kind>;
-type OrOperator<Tag, Kind> = Omit<AllNever$1, 'or'> & {
+type OrOperator<Tag, Kind> = Omit<AllNever, 'or'> & {
     or: NonEmptyArray<WhereOperator<Tag, Kind>>;
 };
 declare const isOrOperator: <Tag, Kind>(operator: WhereOperator<Tag, Kind>) => operator is OrOperator<Tag, Kind>;
 type WhereOperator<Tag, Kind> = TagEqual<Tag> | KindEqual<Kind> | NotOperator<Tag, Kind> | AndOperator<Tag, Kind> | OrOperator<Tag, Kind>;
 type Filterable<FTag extends string = string, FKind extends string = string> = {
-    tags?: FTag[] | null;
+    tags?: readonly FTag[] | null;
     kind?: FKind;
 };
 type OperatorPredicate<V extends Filterable> = (value: V) => boolean;
@@ -206,7 +101,8 @@ interface ElementTagExpr extends Omit<BaseExpr, 'elementTag' | 'isEqual'> {
     isEqual: boolean;
 }
 declare function isElementTagExpr(expr: Expression): expr is ElementTagExpr;
-type ElementExpression = ElementRefExpr | WildcardExpr | ElementKindExpr | ElementTagExpr | ExpandedElementExpr;
+type NonWilcard = ElementRefExpr | ElementKindExpr | ElementTagExpr | ExpandedElementExpr;
+type ElementExpression = NonWilcard | WildcardExpr;
 declare function isElement(expr: Expression): expr is ElementExpression;
 interface ElementWhereExpr extends Omit<BaseExpr, 'where'> {
     where: {
@@ -217,12 +113,12 @@ interface ElementWhereExpr extends Omit<BaseExpr, 'where'> {
 declare function isElementWhere(expr: Expression): expr is ElementWhereExpr;
 type ElementPredicateExpression = ElementExpression | ElementWhereExpr | CustomElementExpr;
 declare function isElementPredicateExpr(expr: Expression): expr is ElementPredicateExpression;
-interface RelationExpr extends Omit<BaseExpr, 'source' | 'target'> {
+interface DirectRelationExpr extends Omit<BaseExpr, 'source' | 'target'> {
     source: ElementExpression;
     target: ElementExpression;
     isBidirectional?: boolean;
 }
-declare function isRelation(expr: Expression): expr is RelationExpr;
+declare function isRelation(expr: Expression): expr is DirectRelationExpr;
 interface InOutExpr extends Omit<BaseExpr, 'inout'> {
     inout: ElementExpression;
 }
@@ -235,7 +131,7 @@ interface OutgoingExpr extends Omit<BaseExpr, 'outgoing'> {
     outgoing: ElementExpression;
 }
 declare function isOutgoing(expr: Expression): expr is OutgoingExpr;
-type RelationExpression = RelationExpr | InOutExpr | IncomingExpr | OutgoingExpr;
+type RelationExpression = DirectRelationExpr | InOutExpr | IncomingExpr | OutgoingExpr;
 declare function isRelationExpression(expr: Expression): expr is RelationExpression;
 interface RelationWhereExpr extends Omit<BaseExpr, 'where'> {
     where: {
@@ -266,6 +162,7 @@ type Expression = ElementPredicateExpression | RelationPredicateExpression;
 
 type expression_CustomElementExpr = CustomElementExpr;
 type expression_CustomRelationExpr = CustomRelationExpr;
+type expression_DirectRelationExpr = DirectRelationExpr;
 type expression_ElementExpression = ElementExpression;
 type expression_ElementKindExpr = ElementKindExpr;
 type expression_ElementPredicateExpression = ElementPredicateExpression;
@@ -276,8 +173,8 @@ type expression_ExpandedElementExpr = ExpandedElementExpr;
 type expression_Expression = Expression;
 type expression_InOutExpr = InOutExpr;
 type expression_IncomingExpr = IncomingExpr;
+type expression_NonWilcard = NonWilcard;
 type expression_OutgoingExpr = OutgoingExpr;
-type expression_RelationExpr = RelationExpr;
 type expression_RelationExpression = RelationExpression;
 type expression_RelationPredicateExpression = RelationPredicateExpression;
 type expression_RelationWhereExpr = RelationWhereExpr;
@@ -300,7 +197,119 @@ declare const expression_isRelationPredicateExpr: typeof isRelationPredicateExpr
 declare const expression_isRelationWhere: typeof isRelationWhere;
 declare const expression_isWildcard: typeof isWildcard;
 declare namespace expression {
-  export { type expression_CustomElementExpr as CustomElementExpr, type expression_CustomRelationExpr as CustomRelationExpr, type expression_ElementExpression as ElementExpression, type expression_ElementKindExpr as ElementKindExpr, type expression_ElementPredicateExpression as ElementPredicateExpression, type expression_ElementRefExpr as ElementRefExpr, type expression_ElementTagExpr as ElementTagExpr, type expression_ElementWhereExpr as ElementWhereExpr, type expression_ExpandedElementExpr as ExpandedElementExpr, type expression_Expression as Expression, type expression_InOutExpr as InOutExpr, type expression_IncomingExpr as IncomingExpr, type expression_OutgoingExpr as OutgoingExpr, type expression_RelationExpr as RelationExpr, type expression_RelationExpression as RelationExpression, type expression_RelationPredicateExpression as RelationPredicateExpression, type expression_RelationWhereExpr as RelationWhereExpr, type expression_WildcardExpr as WildcardExpr, expression_isCustomElement as isCustomElement, expression_isCustomRelationExpr as isCustomRelationExpr, expression_isElement as isElement, expression_isElementKindExpr as isElementKindExpr, expression_isElementPredicateExpr as isElementPredicateExpr, expression_isElementRef as isElementRef, expression_isElementTagExpr as isElementTagExpr, expression_isElementWhere as isElementWhere, expression_isExpandedElementExpr as isExpandedElementExpr, expression_isInOut as isInOut, expression_isIncoming as isIncoming, expression_isOutgoing as isOutgoing, expression_isRelation as isRelation, expression_isRelationExpression as isRelationExpression, expression_isRelationPredicateExpr as isRelationPredicateExpr, expression_isRelationWhere as isRelationWhere, expression_isWildcard as isWildcard };
+  export { type expression_CustomElementExpr as CustomElementExpr, type expression_CustomRelationExpr as CustomRelationExpr, type expression_DirectRelationExpr as DirectRelationExpr, type expression_ElementExpression as ElementExpression, type expression_ElementKindExpr as ElementKindExpr, type expression_ElementPredicateExpression as ElementPredicateExpression, type expression_ElementRefExpr as ElementRefExpr, type expression_ElementTagExpr as ElementTagExpr, type expression_ElementWhereExpr as ElementWhereExpr, type expression_ExpandedElementExpr as ExpandedElementExpr, type expression_Expression as Expression, type expression_InOutExpr as InOutExpr, type expression_IncomingExpr as IncomingExpr, type expression_NonWilcard as NonWilcard, type expression_OutgoingExpr as OutgoingExpr, type expression_RelationExpression as RelationExpression, type expression_RelationPredicateExpression as RelationPredicateExpression, type expression_RelationWhereExpr as RelationWhereExpr, type expression_WildcardExpr as WildcardExpr, expression_isCustomElement as isCustomElement, expression_isCustomRelationExpr as isCustomRelationExpr, expression_isElement as isElement, expression_isElementKindExpr as isElementKindExpr, expression_isElementPredicateExpr as isElementPredicateExpr, expression_isElementRef as isElementRef, expression_isElementTagExpr as isElementTagExpr, expression_isElementWhere as isElementWhere, expression_isExpandedElementExpr as isExpandedElementExpr, expression_isInOut as isInOut, expression_isIncoming as isIncoming, expression_isOutgoing as isOutgoing, expression_isRelation as isRelation, expression_isRelationExpression as isRelationExpression, expression_isRelationPredicateExpr as isRelationPredicateExpr, expression_isRelationWhere as isRelationWhere, expression_isWildcard as isWildcard };
+}
+
+declare namespace FqnRef {
+    /**
+     * 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.
+     */
+    type InsideInstanceRef<D = Fqn, M = Fqn> = {
+        deployment: D;
+        element: M;
+    };
+    const isInsideInstanceRef: (ref: FqnRef) => ref is InsideInstanceRef;
+    /**
+     * 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.
+     */
+    type DeploymentElementRef<F = Fqn> = {
+        deployment: F;
+    };
+    const isDeploymentElementRef: (ref: FqnRef) => ref is DeploymentElementRef;
+    type DeploymentRef<D = Fqn, M = Fqn> = DeploymentElementRef<D> | InsideInstanceRef<D, M>;
+    const isDeploymentRef: (ref: FqnRef) => ref is DeploymentRef;
+    /**
+     * Reference to logical model element
+     */
+    type ModelRef<F = Fqn> = {
+        model: F;
+    };
+    const isModelRef: (ref: FqnRef) => ref is ModelRef;
+    const toDeploymentRef: (ref: FqnRef) => DeploymentRef;
+}
+type FqnRef<D = Fqn, M = Fqn> = ExclusiveUnion<{
+    InsideInstanceRef: FqnRef.InsideInstanceRef<D, M>;
+    DeploymentRef: FqnRef.DeploymentRef<D>;
+    ModelRef: FqnRef.ModelRef<M>;
+}>;
+declare namespace FqnExpr {
+    type Wildcard = {
+        wildcard: true;
+    };
+    const isWildcard: (expr: ExpressionV2) => expr is Wildcard;
+    type ModelRef<M = Fqn> = {
+        ref: FqnRef.ModelRef<M>;
+        selector?: PredicateSelector;
+    };
+    const isModelRef: (ref: ExpressionV2) => ref is ModelRef;
+    type DeploymentRef<D = Fqn, M = Fqn> = {
+        ref: FqnRef.DeploymentRef<D> | FqnRef.InsideInstanceRef<D, M>;
+        selector?: PredicateSelector;
+    };
+    const isDeploymentRef: (ref: ExpressionV2) => ref is FqnExpr.DeploymentRef;
+    type NonWildcard<D = Fqn, M = Fqn> = ExclusiveUnion<{
+        ModelRef: ModelRef<M>;
+        DeploymentRef: DeploymentRef<D, M>;
+    }>;
+}
+type FqnExpr<D = Fqn, M = Fqn> = ExclusiveUnion<{
+    Wildcard: FqnExpr.Wildcard;
+    ModelRef: FqnExpr.ModelRef<M>;
+    DeploymentRef: FqnExpr.DeploymentRef<D, M>;
+}>;
+declare namespace RelationExpr {
+    type Direct<D = Fqn, M = Fqn> = {
+        source: FqnExpr<D, M>;
+        target: FqnExpr<D, M>;
+        isBidirectional?: boolean;
+    };
+    const isDirect: (expr: ExpressionV2) => expr is Direct;
+    type Incoming<D = Fqn, M = Fqn> = {
+        incoming: FqnExpr<D, M>;
+    };
+    const isIncoming: (expr: ExpressionV2) => expr is Incoming;
+    type Outgoing<D = Fqn, M = Fqn> = {
+        outgoing: FqnExpr<D, M>;
+    };
+    const isOutgoing: (expr: ExpressionV2) => expr is Outgoing;
+    type InOut<D = Fqn, M = Fqn> = {
+        inout: FqnExpr<D, M>;
+    };
+    const isInOut: (expr: ExpressionV2) => expr is InOut;
+}
+type RelationExpr<D = Fqn, M = Fqn> = ExclusiveUnion<{
+    Direct: RelationExpr.Direct<D, M>;
+    Incoming: RelationExpr.Incoming<D, M>;
+    Outgoing: RelationExpr.Outgoing<D, M>;
+    InOut: RelationExpr.InOut<D, M>;
+}>;
+/**
+ * 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 ExpressionV2<D = Fqn, M = Fqn> = ExclusiveUnion<{
+    Wildcard: FqnExpr.Wildcard;
+    ModelRef: FqnExpr.ModelRef<M>;
+    DeploymentRef: FqnExpr.DeploymentRef<D, M>;
+    Direct: RelationExpr.Direct<D, M>;
+    Incoming: RelationExpr.Incoming<D, M>;
+    Outgoing: RelationExpr.Outgoing<D, M>;
+    InOut: RelationExpr.InOut<D, M>;
+}>;
+declare namespace ExpressionV2 {
+    const isFqnExpr: (expr: ExpressionV2) => expr is FqnExpr;
+    const isRelation: (expr: ExpressionV2) => expr is RelationExpr;
 }
 
 type GlobalPredicateId = Tagged<string, 'GlobalPredicateId'>;
@@ -309,9 +318,9 @@ type GlobalDynamicPredicates = NonEmptyArray<DynamicViewIncludeRule>;
 type GlobalStyleID = Tagged<string, 'GlobalStyleID'>;
 type GlobalStyles = NonEmptyTuple<ViewRuleStyle>;
 interface ModelGlobals {
-    predicates: Record<GlobalPredicateId, GlobalPredicates>;
-    dynamicPredicates: Record<GlobalPredicateId, GlobalDynamicPredicates>;
-    styles: Record<GlobalStyleID, GlobalStyles>;
+    readonly predicates: Record<GlobalPredicateId, GlobalPredicates>;
+    readonly dynamicPredicates: Record<GlobalPredicateId, GlobalDynamicPredicates>;
+    readonly styles: Record<GlobalStyleID, GlobalStyles>;
 }
 
 type ElementNotation = {
@@ -441,14 +450,14 @@ type CustomColorDefinitions = {
     [key: string]: ThemeColorValues;
 };
 type DeploymentViewRulePredicate = {
-    include: DeploymentExpression[];
+    include: ExpressionV2[];
     exclude?: never;
 } | {
     include?: never;
-    exclude: DeploymentExpression[];
+    exclude: ExpressionV2[];
 };
 type DeploymentViewRuleStyle = {
-    targets: DeploymentExpression[];
+    targets: FqnExpr[];
     notation?: string;
     style: ElementStyle & {
         color?: Color;
@@ -604,7 +613,7 @@ type BBox = {
     width: number;
     height: number;
 };
-declare function getBBoxCenter({ x, y, width, height }: BBox): XYPoint;
+declare function getBBoxCenter({ x, y, width, height, }: BBox): XYPoint;
 interface DiagramNode extends ComputedNode {
     width: number;
     height: number;
@@ -662,28 +671,31 @@ type RelationId = Tagged<string, 'RelationID'>;
 type RelationshipKind<Kinds extends string = string> = Tagged<Kinds, 'RelationshipKind'>;
 type RelationshipLineType = 'dashed' | 'solid' | 'dotted';
 type RelationshipArrowType = 'none' | 'normal' | 'onormal' | 'dot' | 'odot' | 'diamond' | 'odiamond' | 'crow' | 'open' | 'vee';
-declare const DefaultLineStyle = "dashed";
-declare const DefaultArrowType = "normal";
-declare const DefaultRelationshipColor = "gray";
-interface Relation {
+declare const DefaultLineStyle: RelationshipLineType;
+declare const DefaultArrowType: RelationshipArrowType;
+declare const DefaultRelationshipColor: ThemeColor;
+interface AbstractRelation {
     readonly id: RelationId;
-    readonly source: Fqn;
-    readonly target: Fqn;
-    readonly title: string;
+    readonly title?: string;
     readonly description?: string;
     readonly technology?: string;
-    readonly tags?: NonEmptyArray<Tag>;
+    readonly tags?: NonEmptyArray<Tag> | null;
     readonly kind?: RelationshipKind;
     readonly color?: Color;
     readonly line?: RelationshipLineType;
     readonly head?: RelationshipArrowType;
     readonly tail?: RelationshipArrowType;
-    readonly links?: NonEmptyArray<Link>;
+    readonly links?: NonEmptyArray<Link> | null;
     readonly navigateTo?: ViewId;
     readonly metadata?: {
         [key: string]: string;
     };
 }
+interface ModelRelation extends AbstractRelation {
+    readonly source: Fqn;
+    readonly target: Fqn;
+    readonly title: string;
+}
 interface RelationshipKindSpecification {
     readonly technology?: string;
     readonly notation?: string;
@@ -694,7 +706,7 @@ interface RelationshipKindSpecification {
 }
 
 type DeploymentNodeKind<Kinds extends string = string> = Tagged<Kinds, 'DeploymentNodeKind'>;
-type PhysicalElementStyle = ElementStyle & {
+type DeploymentElementStyle = ElementStyle & {
     readonly icon?: IconUrl;
     readonly shape?: ElementShape;
     readonly color?: Color;
@@ -702,7 +714,7 @@ type PhysicalElementStyle = ElementStyle & {
 interface DeploymentNodeKindSpecification {
     readonly technology?: string;
     readonly notation?: string;
-    readonly style: PhysicalElementStyle;
+    readonly style: DeploymentElementStyle;
 }
 interface DeploymentNode {
     readonly id: Fqn;
@@ -712,7 +724,7 @@ interface DeploymentNode {
     readonly technology?: string | null;
     readonly tags?: NonEmptyArray<Tag> | null;
     readonly links?: NonEmptyArray<Link> | null;
-    readonly style?: PhysicalElementStyle;
+    readonly style?: DeploymentElementStyle;
     readonly notation?: string;
     readonly metadata?: Record<string, string>;
 }
@@ -728,7 +740,7 @@ interface DeployedInstance {
     readonly technology?: string | null;
     readonly tags?: NonEmptyArray<Tag> | null;
     readonly links?: NonEmptyArray<Link> | null;
-    readonly style?: PhysicalElementStyle;
+    readonly style?: DeploymentElementStyle;
     readonly notation?: string;
     readonly metadata?: Record<string, string>;
 }
@@ -737,6 +749,7 @@ declare namespace DeploymentElement {
     const isDeploymentNode: (el: DeploymentElement) => el is DeploymentNode;
     const isInstance: (el: DeploymentElement) => el is DeployedInstance;
 }
+type PredicateSelector = 'children' | 'expanded' | 'descendants';
 interface DeploymentRef {
     readonly id: Fqn;
     readonly element?: Fqn;
@@ -744,89 +757,28 @@ interface DeploymentRef {
 /**
  * NOTE:
  */
-interface DeploymentRelation {
+interface DeploymentRelation extends AbstractRelation {
     readonly id: RelationId;
     readonly source: DeploymentRef;
     readonly target: DeploymentRef;
-    readonly title?: string;
-    readonly tags?: NonEmptyArray<Tag> | null;
-    readonly description?: string;
-    readonly technology?: string;
-    readonly kind?: RelationshipKind;
-    readonly color?: Color;
-    readonly line?: RelationshipLineType;
-    readonly head?: RelationshipArrowType;
-    readonly tail?: RelationshipArrowType;
-    readonly links?: NonEmptyArray<Link> | null;
-    readonly navigateTo?: ViewId;
-    readonly metadata?: {
-        [key: string]: string;
-    };
-}
-type AllNever<Expressions> = UnionToIntersection<{
-    [Name in keyof Expressions]: {
-        -readonly [Key in keyof Expressions[Name]]?: never;
-    };
-}[keyof Expressions]>;
-type ExclusiveUnion<Expressions> = Expressions extends object ? {
-    [Name in keyof Expressions]: Simplify<Omit<AllNever<Expressions>, keyof Expressions[Name]> & Expressions[Name]>;
-}[keyof Expressions] : Expressions;
-declare namespace DeploymentRelationExpression {
-    type Direct = {
-        source: DeploymentElementExpression;
-        target: DeploymentElementExpression;
-        isBidirectional?: boolean;
-    };
-    const isDirect: (expr: DeploymentExpression) => expr is Direct;
-    type Incoming = {
-        incoming: DeploymentElementExpression;
-    };
-    const isIncoming: (expr: DeploymentExpression) => expr is Incoming;
-    type Outgoing = {
-        outgoing: DeploymentElementExpression;
-    };
-    const isOutgoing: (expr: DeploymentExpression) => expr is Outgoing;
-    type InOut = {
-        inout: DeploymentElementExpression;
-    };
-    const isInOut: (expr: DeploymentExpression) => expr is InOut;
-}
-type DeploymentRelationExpression = ExclusiveUnion<{
-    Direct: DeploymentRelationExpression.Direct;
-    Incoming: DeploymentRelationExpression.Incoming;
-    Outgoing: DeploymentRelationExpression.Outgoing;
-    InOut: DeploymentRelationExpression.InOut;
-}>;
-declare namespace DeploymentElementExpression {
-    type Ref = {
-        ref: DeploymentRef;
-        selector?: 'children' | 'expanded' | 'descendants';
-    };
-    const isRef: (expr: DeploymentExpression) => expr is Ref;
-    type Wildcard = {
-        wildcard: true;
-    };
-    const isWildcard: (expr: DeploymentExpression) => expr is Wildcard;
-}
-type DeploymentElementExpression = ExclusiveUnion<{
-    DeploymentRef: DeploymentElementExpression.Ref;
-    Wildcard: DeploymentElementExpression.Wildcard;
-}>;
-type DeploymentExpression = ExclusiveUnion<{
-    Element: DeploymentElementExpression;
-    Relation: DeploymentRelationExpression;
-}>;
-declare namespace DeploymentExpression {
-    type Element = DeploymentElementExpression;
-    type Relation = DeploymentRelationExpression;
-    const isElement: (expr: DeploymentExpression) => expr is DeploymentElementExpression;
-    const isRelation: (expr: DeploymentExpression) => expr is DeploymentRelationExpression;
 }
 
 /**
- * Parsed elements, relations, and views.
+ * Represents a LikeC4 model with customizable type parameters,
+ * parsed from DSL or result from Builder
+ *
+ * !IMPORTANT: This is a low-level type, use `LikeC4Model` instead.
+ * !NOTE: Views are not computed yet.
+ *
+ * @typeParam ElementKinds - Types of elements in the model (defaults to string)
+ * @typeParam RelationKinds - Types of relationships (defaults to string)
+ * @typeParam Tags - Types of tags that can be applied (defaults to string)
+ * @typeParam Fqns - Fully Qualified Names for elements (defaults to string)
+ * @typeParam Views - Types of views in the model (defaults to string)
+ * @typeParam DeploymentFqns - Fully Qualified Names for deployment nodes (defaults to string)
  */
 interface ParsedLikeC4Model<ElementKinds extends string = string, RelationKinds extends string = string, Tags extends string = string, Fqns extends string = string, Views extends string = string, DeploymentFqns extends string = string> {
+    __?: never;
     specification: {
         tags: Tag<Tags>[];
         elements: Record<ElementKinds, ElementKindSpecification>;
@@ -834,7 +786,7 @@ interface ParsedLikeC4Model<ElementKinds extends string = string, RelationKinds
         relationships: Record<RelationKinds, RelationshipKindSpecification>;
     };
     elements: Record<Fqns, TypedElement<Fqns, ElementKinds, Tags>>;
-    relations: Record<RelationId, Relation>;
+    relations: Record<RelationId, ModelRelation>;
     globals: ModelGlobals;
     views: Record<Views, LikeC4View<Views, Tags>>;
     /**
@@ -845,10 +797,11 @@ interface ParsedLikeC4Model<ElementKinds extends string = string, RelationKinds
         relations: Record<RelationId, DeploymentRelation>;
     };
 }
+type AnyParsedLikeC4Model = ParsedLikeC4Model<any, any, any, any, any, any>;
 /**
  * Hook to get types from dump
  */
-type ParsedLikeC4ModelDump = {
+type LikeC4ModelDump = {
     elements: {
         [kind: string]: object;
     };
@@ -861,23 +814,19 @@ type ParsedLikeC4ModelDump = {
         [kind: string]: object;
     };
 };
-interface AnyLikeC4Model<Fqns extends string = string, DeploymentFqns extends string = string, Views extends string = string, Tags extends string = string, T = 'computed' | 'layouted'> extends Omit<ParsedLikeC4Model<string, string, Tags, Fqns, Views, DeploymentFqns>, 'views'> {
-    __?: T;
-    views: Record<Views, ComputedView | DiagramView>;
-}
 /**
- * Same as `ParsedLikeC4Model` but with computed views.
+ * Same as {@link ParsedLikeC4Model}, but with computed views or layouted views.
  */
-interface ComputedLikeC4Model<Fqns extends string = string, DeploymentFqns extends string = string, Views extends string = string, Tags extends string = string> extends Omit<AnyLikeC4Model<Fqns, DeploymentFqns, Views, Tags, 'computed'>, 'views'> {
-    views: Record<Views, ComputedView>;
+interface GenericLikeC4Model<Fqns extends string = string, DeploymentFqns extends string = string, Views extends string = string, Tags extends string = string, T = 'computed' | 'layouted'> extends Omit<ParsedLikeC4Model<string, string, Tags, Fqns, Views, DeploymentFqns>, 'views' | '__'> {
+    __?: T;
+    views: Record<Views, ComputedView<Views> | DiagramView<Views>>;
 }
-type ComputedLikeC4ModelFromParsed<M> = M extends ParsedLikeC4Model ? ComputedLikeC4Model<KeysOf<M['elements']>, KeysOf<M['deployments']['elements']>, KeysOf<M['views']>> : ComputedLikeC4Model;
-/**
- * Same as `ParsedLikeC4Model` but with layouted views (DiagramView)
- */
-interface LayoutedLikeC4Model<Fqns extends string = string, DeploymentFqns extends string = string, Views extends string = string, Tags extends string = string> extends Omit<AnyLikeC4Model<Fqns, DeploymentFqns, Views, Tags, 'layouted'>, 'views'> {
+interface ComputedLikeC4Model<Fqns extends string = string, DeploymentFqns extends string = string, Views extends string = string, Tags extends string = string> extends Omit<GenericLikeC4Model<Fqns, DeploymentFqns, Views, Tags, 'computed'>, 'views'> {
+    views: Record<Views, ComputedView<Views>>;
+}
+interface LayoutedLikeC4Model<Fqns extends string = string, DeploymentFqns extends string = string, Views extends string = string, Tags extends string = string> extends Omit<GenericLikeC4Model<Fqns, DeploymentFqns, Views, Tags, 'layouted'>, 'views'> {
     __: 'layouted';
     views: Record<Views, DiagramView<Views, Tags>>;
 }
 
-export { type TypedElement as $, type AutoLayoutDirection as A, type BorderStyle as B, type ComputedLikeC4ModelFromParsed as C, type DeploymentNodeKindSpecification as D, type Element as E, type Fqn as F, AsFqn as G, type HexColorLiteral as H, type IconUrl as I, BorderStyles as J, type KeysOf as K, type LikeC4View as L, type ModelGlobals as M, type NonEmptyArray as N, ElementKind as O, type ParsedLikeC4Model as P, ElementShapes as Q, type Relation as R, DefaultThemeColor as S, type ThemeColorValues as T, DefaultElementShape as U, type ViewRuleStyle as V, type ElementStyle as W, type XYPoint as X, type Tag as Y, type TagSpec as Z, type Link as _, ComputedView as a, type ElementThemeColors as a$, type ElementKindSpecificationStyle as a0, type ElementRefExpr as a1, isElementRef as a2, type ExpandedElementExpr as a3, isExpandedElementExpr as a4, isCustomElement as a5, type WildcardExpr as a6, isWildcard as a7, type ElementKindExpr as a8, isElementKindExpr as a9, type GlobalStyleID as aA, type GlobalStyles as aB, type ParsedLikeC4ModelDump as aC, type AnyLikeC4Model as aD, type LayoutedLikeC4Model as aE, type EqualOperator as aF, type TagEqual as aG, isTagEqual as aH, type KindEqual as aI, isKindEqual as aJ, type NotOperator as aK, isNotOperator as aL, type AndOperator as aM, isAndOperator as aN, type OrOperator as aO, isOrOperator as aP, type WhereOperator as aQ, type Filterable as aR, whereOperatorAsPredicate as aS, type RelationshipKind as aT, DefaultLineStyle as aU, DefaultArrowType as aV, DefaultRelationshipColor as aW, type ThemeColor as aX, type ColorLiteral as aY, isThemeColor as aZ, type ElementThemeColorValues as a_, type ElementTagExpr as aa, isElementTagExpr as ab, type ElementExpression as ac, isElement as ad, type ElementWhereExpr as ae, isElementWhere as af, type ElementPredicateExpression as ag, isElementPredicateExpr as ah, type RelationExpr as ai, isRelation as aj, type InOutExpr as ak, isInOut as al, type IncomingExpr as am, isIncoming as an, type OutgoingExpr as ao, isOutgoing as ap, type RelationExpression as aq, isRelationExpression as ar, type RelationWhereExpr as as, isRelationWhere as at, isCustomRelationExpr as au, type RelationPredicateExpression as av, isRelationPredicateExpr as aw, type GlobalPredicateId as ax, type GlobalPredicates as ay, type GlobalDynamicPredicates as az, type RelationId as b, type RelationshipThemeColorValues as b0, type RelationshipThemeColors as b1, type LikeC4Theme as b2, type ViewId as b3, type ViewRulePredicate as b4, isViewRulePredicate as b5, type ViewRuleGlobalPredicateRef as b6, isViewRuleGlobalPredicateRef as b7, isViewRuleStyle as b8, type ViewRuleGlobalStyle as b9, isDynamicView as bA, isElementView as bB, isExtendsElementView as bC, isScopedElementView as bD, type NodeId as bE, type EdgeId as bF, type StepEdgeIdLiteral as bG, type StepEdgeId as bH, stepEdgeId as bI, isStepEdgeId as bJ, extractStep as bK, getParallelStepsPrefix as bL, ComputedNode as bM, type ComputedEdge as bN, type ViewWithHash as bO, type ViewWithNotation as bP, type ViewAutoLayout as bQ, type ComputedElementView as bR, type ComputedDynamicView as bS, type ComputedDeploymentView as bT, type BBox as bU, getBBoxCenter as bV, DiagramNode as bW, type DiagramEdge as bX, type DiagramView as bY, type ViewManualLayout as bZ, type ElementNotation as b_, isViewRuleGlobalStyle as ba, type ViewRuleStyleOrGlobalRef as bb, isAutoLayoutDirection as bc, type ViewRuleAutoLayout as bd, isViewRuleAutoLayout as be, type ViewRuleGroup as bf, isViewRuleGroup as bg, type ViewRule as bh, type BasicView as bi, type BasicElementView as bj, type ScopedElementView as bk, type ExtendsElementView as bl, type ElementView as bm, type DynamicViewStep as bn, type DynamicViewParallelSteps as bo, type DynamicViewStepOrParallel as bp, type DynamicViewIncludeRule as bq, type DynamicViewRule as br, type DynamicView as bs, isDynamicViewParallelSteps as bt, type CustomColorDefinitions as bu, type DeploymentViewRulePredicate as bv, type DeploymentViewRuleStyle as bw, type DeploymentViewRule as bx, type DeploymentView as by, isDeploymentView as bz, type ComputedLikeC4Model as c, type ElementKindSpecification as d, type RelationshipKindSpecification as e, type ElementShape as f, type Color as g, type RelationshipArrowType as h, type RelationshipLineType as i, DeploymentElement as j, type DeploymentRelation as k, type Expression as l, type CustomElementExpr as m, type CustomRelationExpr as n, DeploymentExpression as o, expression as p, type NonEmptyReadonlyArray as q, type CustomColor as r, type Point as s, type DeploymentNodeKind as t, type PhysicalElementStyle as u, type DeploymentNode as v, type DeployedInstance as w, type DeploymentRef as x, DeploymentRelationExpression as y, DeploymentElementExpression as z };
+export { type GlobalDynamicPredicates as $, type CustomElementExpr as A, type CustomRelationExpr as B, ComputedView as C, DeploymentElement as D, type DirectRelationExpr as E, type ElementExpression as F, type ElementKindExpr as G, type ElementPredicateExpression as H, type ElementRefExpr as I, type ElementTagExpr as J, type ElementWhereExpr as K, type LikeC4View as L, type ExpandedElementExpr as M, type Expression as N, type IncomingExpr as O, type PredicateSelector as P, type InOutExpr as Q, type NonWilcard as R, type OutgoingExpr as S, type RelationExpression as T, type RelationPredicateExpression as U, type RelationWhereExpr as V, type WildcardExpr as W, ExpressionV2 as X, FqnExpr as Y, FqnRef as Z, RelationExpr as _, type ComputedLikeC4Model as a, type DeploymentView as a$, type GlobalPredicateId as a0, type GlobalPredicates as a1, type GlobalStyleID as a2, type GlobalStyles as a3, type ModelGlobals as a4, type AnyParsedLikeC4Model as a5, type GenericLikeC4Model as a6, type LayoutedLikeC4Model as a7, type LikeC4ModelDump as a8, type ParsedLikeC4Model as a9, extractStep as aA, getBBoxCenter as aB, getParallelStepsPrefix as aC, isAutoLayoutDirection as aD, isDeploymentView as aE, isDynamicView as aF, isDynamicViewParallelSteps as aG, isElementView as aH, isExtendsElementView as aI, isScopedElementView as aJ, isStepEdgeId as aK, isViewRuleAutoLayout as aL, isViewRuleGlobalPredicateRef as aM, isViewRuleGlobalStyle as aN, isViewRuleGroup as aO, isViewRulePredicate as aP, isViewRuleStyle as aQ, stepEdgeId as aR, type AutoLayoutDirection as aS, type BasicElementView as aT, type BasicView as aU, type BBox as aV, type ComputedDeploymentView as aW, type ComputedDynamicView as aX, type ComputedEdge as aY, type ComputedElementView as aZ, type CustomColorDefinitions as a_, isAndOperator as aa, isKindEqual as ab, isNotOperator as ac, isOrOperator as ad, isTagEqual as ae, whereOperatorAsPredicate as af, type AndOperator as ag, type EqualOperator as ah, type Filterable as ai, type KindEqual as aj, type NotOperator as ak, type OrOperator as al, type TagEqual as am, type WhereOperator as an, DefaultArrowType as ao, DefaultLineStyle as ap, DefaultRelationshipColor as aq, type AbstractRelation as ar, type ModelRelation as as, type RelationId as at, type RelationshipArrowType as au, type RelationshipKind as av, type RelationshipKindSpecification as aw, type RelationshipLineType as ax, ComputedNode as ay, DiagramNode as az, type DeployedInstance as b, type DeploymentViewRule as b0, type DeploymentViewRulePredicate as b1, type DeploymentViewRuleStyle as b2, type DiagramEdge as b3, type DiagramView as b4, type DynamicView as b5, type DynamicViewIncludeRule as b6, type DynamicViewParallelSteps as b7, type DynamicViewRule as b8, type DynamicViewStep as b9, type DynamicViewStepOrParallel as ba, type EdgeId as bb, type ElementView as bc, type ExtendsElementView as bd, type NodeId as be, type ScopedElementView as bf, type StepEdgeId as bg, type StepEdgeIdLiteral as bh, type ViewAutoLayout as bi, type ViewId as bj, type ViewManualLayout as bk, type ViewRule as bl, type ViewRuleAutoLayout as bm, type ViewRuleGlobalPredicateRef as bn, type ViewRuleGlobalStyle as bo, type ViewRuleGroup as bp, type ViewRulePredicate as bq, type ViewRuleStyle as br, type ViewRuleStyleOrGlobalRef as bs, type ViewWithHash as bt, type ViewWithNotation as bu, type ElementNotation as bv, type DeploymentElementStyle as c, type DeploymentNode as d, expression as e, type DeploymentNodeKind as f, type DeploymentNodeKindSpecification as g, type DeploymentRef as h, type DeploymentRelation as i, isCustomElement as j, isCustomRelationExpr as k, isElement as l, isElementKindExpr as m, isElementPredicateExpr as n, isElementRef as o, isElementTagExpr as p, isElementWhere as q, isExpandedElementExpr as r, isIncoming as s, isInOut as t, isOutgoing as u, isRelation as v, isRelationExpression as w, isRelationPredicateExpr as x, isRelationWhere as y, isWildcard as z };