@likec4/core 1.38.1 → 1.39.0

package/dist/theme/index.d.mts

@@ -1,132 +1,9 @@
-import { C as ColorLiteral, n as ThemeColorValues, L as LikeC4Theme } from '../shared/core.CzdwsPmY.mjs';
+import { l as ElementThemeColors, o as RelationshipThemeColors, C as ColorLiteral, n as ThemeColorValues, L as LikeC4Theme } from '../shared/core.CzdwsPmY.mjs';
 import 'type-fest';
 
-declare const ElementColors: {
-    readonly primary: {
-        fill: "#3b82f6";
-        stroke: "#2563eb";
-        hiContrast: "#eff6ff";
-        loContrast: "#bfdbfe";
-    };
-    readonly blue: {
-        fill: "#3b82f6";
-        stroke: "#2563eb";
-        hiContrast: "#eff6ff";
-        loContrast: "#bfdbfe";
-    };
-    readonly secondary: {
-        fill: "#0284c7";
-        stroke: "#0369a1";
-        hiContrast: "#f0f9ff";
-        loContrast: "#B6ECF7";
-    };
-    readonly sky: {
-        fill: "#0284c7";
-        stroke: "#0369a1";
-        hiContrast: "#f0f9ff";
-        loContrast: "#B6ECF7";
-    };
-    readonly muted: {
-        fill: "#64748b";
-        stroke: "#475569";
-        hiContrast: "#f8fafc";
-        loContrast: "#cbd5e1";
-    };
-    readonly slate: {
-        fill: "#64748b";
-        stroke: "#475569";
-        hiContrast: "#f8fafc";
-        loContrast: "#cbd5e1";
-    };
-    readonly gray: {
-        readonly fill: "#737373";
-        readonly stroke: "#525252";
-        readonly hiContrast: "#fafafa";
-        readonly loContrast: "#d4d4d4";
-    };
-    readonly red: {
-        readonly fill: "#AC4D39";
-        readonly stroke: "#853A2D";
-        readonly hiContrast: "#FBD3CB";
-        readonly loContrast: "#f5b2a3";
-    };
-    readonly green: {
-        readonly fill: "#428a4f";
-        readonly stroke: "#2d5d39";
-        readonly hiContrast: "#f8fafc";
-        readonly loContrast: "#c2f0c2";
-    };
-    readonly amber: {
-        readonly fill: "#A35829";
-        readonly stroke: "#7E451D";
-        readonly hiContrast: "#FFE0C2";
-        readonly loContrast: "#f9b27c";
-    };
-    readonly indigo: {
-        readonly fill: "#6366f1";
-        readonly stroke: "#4f46e5";
-        readonly hiContrast: "#eef2ff";
-        readonly loContrast: "#c7d2fe";
-    };
-};
+declare const ElementColors: ElementThemeColors;
 
-declare const RelationshipColors: {
-    amber: {
-        lineColor: "#b45309";
-        labelBgColor: "#78350f";
-        labelColor: "#FFE0C2";
-    };
-    blue: {
-        lineColor: "#3b82f6";
-        labelBgColor: "#172554";
-        labelColor: "#60a5fa";
-    };
-    gray: {
-        lineColor: "#6E6E6E";
-        labelBgColor: "#18191b";
-        labelColor: "#C6C6C6";
-    };
-    green: {
-        lineColor: "#15803d";
-        labelBgColor: "#052e16";
-        labelColor: "#22c55e";
-    };
-    indigo: {
-        lineColor: "#6366f1";
-        labelBgColor: "#1e1b4b";
-        labelColor: "#818cf8";
-    };
-    muted: {
-        lineColor: "#64748b";
-        labelBgColor: "#0f172a";
-        labelColor: "#cbd5e1";
-    };
-    primary: {
-        lineColor: "#3b82f6";
-        labelBgColor: "#172554";
-        labelColor: "#60a5fa";
-    };
-    red: {
-        lineColor: "#AC4D39";
-        labelBgColor: "#b91c1c";
-        labelColor: "#f5b2a3";
-    };
-    secondary: {
-        lineColor: "#0ea5e9";
-        labelBgColor: "#082f49";
-        labelColor: "#38bdf8";
-    };
-    sky: {
-        lineColor: "#0ea5e9";
-        labelBgColor: "#082f49";
-        labelColor: "#38bdf8";
-    };
-    slate: {
-        lineColor: "#64748b";
-        labelBgColor: "#0f172a";
-        labelColor: "#cbd5e1";
-    };
-};
+declare const RelationshipColors: RelationshipThemeColors;
 
 declare const defaultTheme: LikeC4Theme;
 declare function computeColorValues(color: ColorLiteral): ThemeColorValues;

package/dist/theme/index.mjs

@@ -1,7 +1,6 @@
 import { generateColors } from '@mantine/colors-generator';
 import chroma from 'chroma-js';
-import { k } from '../shared/core.BpJu1RrF.mjs';
-import '../shared/core.DbRvwARP.mjs';
+import { isDeepEqual } from 'remeda';
 
 const blue$1 = {
   fill: "#3b82f6",
@@ -222,7 +221,7 @@ function getContrastedColorsAPCA(refColor) {
     darkColorRgb = darkColorRgb.darken(CONTRAST_STEP_TONE_DIFFERENCE);
     contrastWithLight = chroma.contrastAPCA(refColorChroma, lightColorRgb);
     contrastWithDark = chroma.contrastAPCA(refColorChroma, darkColorRgb);
-  } while (Math.abs(contrastWithLight) < CONTRAST_MIN_WITH_FOREGROUND && Math.abs(contrastWithDark) < CONTRAST_MIN_WITH_FOREGROUND && (!k(lightColorRgb, previousLight) || !k(darkColorRgb, previousDark)));
+  } while (Math.abs(contrastWithLight) < CONTRAST_MIN_WITH_FOREGROUND && Math.abs(contrastWithDark) < CONTRAST_MIN_WITH_FOREGROUND && (!isDeepEqual(lightColorRgb, previousLight) || !isDeepEqual(darkColorRgb, previousDark)));
   if (Math.abs(contrastWithLight) > Math.abs(contrastWithDark)) {
     return [lightColorRgb.brighten(0.4).hex(), lightColorRgb.hex()];
   } else {

package/dist/types/_aux.d.mts

@@ -1,4 +1,4 @@
 import 'type-fest';
 import '../shared/core.DuSLYTG6.mjs';
-export { y as AllKinds, A as Any, A as AnyAux, G as AnySpec, a as Aux, p as DeploymentFqn, s as DeploymentId, D as DeploymentKind, C as EdgeId, g as ElementId, k as ElementKind, F as Fqn, o as LooseDeploymentId, a4 as LooseDeploymentKind, n as LooseElementId, a3 as LooseElementKind, a5 as LooseRelationKind, L as LooseTag, a2 as LooseTags, w as LooseViewId, h as Metadata, j as MetadataKey, N as Never, J as NodeId, a1 as OrString, H as PickByStage, P as ProjectId, l as RelationId, R as RelationKind, K as Spec, S as SpecAux, r as Stage, p as StrictDeploymentFqn, Y as StrictDeploymentKind, X as StrictElementKind, F as StrictFqn, O as StrictProjectId, Z as StrictRelationKind, Q as StrictTag, m as StrictViewId, u as Tag, T as Tags, U as Unknown, b as UnknownComputed, c as UnknownLayouted, d as UnknownParsed, V as ViewId, a0 as WithLinks, B as WithMetadata, z as WithOptionalLinks, W as WithOptionalTags, $ as WithTags, x as setProject, I as setStage, t as toComputed, q as toLayouted, v as toParsed } from '../shared/core.O6FG0HF9.mjs';
+export { k as AllKinds, A as Any, A as AnyAux, G as AnySpec, a as Aux, s as DeploymentFqn, D as DeploymentId, o as DeploymentKind, C as EdgeId, j as ElementId, h as ElementKind, F as Fqn, r as LooseDeploymentId, a4 as LooseDeploymentKind, q as LooseElementId, a3 as LooseElementKind, a5 as LooseRelationKind, L as LooseTag, a2 as LooseTags, x as LooseViewId, m as Metadata, n as MetadataKey, N as Never, J as NodeId, a1 as OrString, H as PickByStage, P as ProjectId, p as RelationId, R as RelationKind, K as Spec, S as SpecAux, v as Stage, s as StrictDeploymentFqn, Y as StrictDeploymentKind, X as StrictElementKind, F as StrictFqn, O as StrictProjectId, Z as StrictRelationKind, Q as StrictTag, g as StrictViewId, T as Tag, l as Tags, U as Unknown, b as UnknownComputed, c as UnknownLayouted, d as UnknownParsed, V as ViewId, a0 as WithLinks, B as WithMetadata, z as WithOptionalLinks, W as WithOptionalTags, $ as WithTags, y as setProject, I as setStage, t as toComputed, u as toLayouted, w as toParsed } from '../shared/core.DdzRtJ9d.mjs';
 import '../shared/core.DX-WYEPA.mjs';

package/dist/types/expression-model.d.mts

@@ -0,0 +1,191 @@
+import { A as Any, g as StrictViewId, h as ElementKind, T as Tag } from '../shared/core.DdzRtJ9d.mjs';
+import { E as ExclusiveUnion } from '../shared/core.DuSLYTG6.mjs';
+import { W as WhereOperator, P as PredicateSelector } from '../shared/core.20m8Um0g.mjs';
+import { FqnRef } from './fqnRef.mjs';
+import { M as MarkdownOrString, I as Icon } from '../shared/core.DX-WYEPA.mjs';
+import { i as Color, R as RelationshipLineType, f as RelationshipArrowType, c as ElementShape, b as BorderStyle, a as ShapeSize } from '../shared/core.CzdwsPmY.mjs';
+import 'type-fest';
+
+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> {
+        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;
+            shape?: ElementShape;
+            color?: Color;
+            icon?: Icon;
+            border?: BorderStyle;
+            opacity?: number;
+            navigateTo?: StrictViewId<A>;
+            multiple?: boolean;
+            size?: ShapeSize;
+            padding?: ShapeSize;
+            textSize?: ShapeSize;
+        };
+    }
+    function isCustom<A extends 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?: string;
+            technology?: string;
+            notation?: string;
+            navigateTo?: StrictViewId<A>;
+            notes?: string;
+            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>;
+}
+
+export { ModelExpression, ModelFqnExpr, ModelRelationExpr };

package/dist/types/expression-model.mjs

@@ -0,0 +1,112 @@
+import { FqnRef } from './fqnRef.mjs';
+import 'remeda';
+import '../shared/core.Be1n9a0i.mjs';
+import '../shared/core.D4npX2q8.mjs';
+
+var ModelFqnExpr;
+((ModelFqnExpr2) => {
+  function isWildcard(expr) {
+    return "wildcard" in expr && expr.wildcard === true;
+  }
+  ModelFqnExpr2.isWildcard = isWildcard;
+  function isModelRef(ref) {
+    return "ref" in ref && FqnRef.isModelRef(ref.ref);
+  }
+  ModelFqnExpr2.isModelRef = isModelRef;
+  function isElementKindExpr(expr) {
+    return "elementKind" in expr && "isEqual" in expr;
+  }
+  ModelFqnExpr2.isElementKindExpr = isElementKindExpr;
+  function isElementTagExpr(expr) {
+    return "elementTag" in expr && "isEqual" in expr;
+  }
+  ModelFqnExpr2.isElementTagExpr = isElementTagExpr;
+  function isWhere(expr) {
+    return "where" in expr && is(expr.where.expr);
+  }
+  ModelFqnExpr2.isWhere = isWhere;
+  function isCustom(expr) {
+    return "custom" in expr && (is(expr.custom.expr) || isWhere(expr.custom.expr));
+  }
+  ModelFqnExpr2.isCustom = isCustom;
+  function is(expr) {
+    return isWildcard(expr) || isModelRef(expr) || isElementKindExpr(expr) || isElementTagExpr(expr);
+  }
+  ModelFqnExpr2.is = is;
+  function unwrap(expr) {
+    if (isCustom(expr)) {
+      expr = expr.custom.expr;
+    }
+    if (isWhere(expr)) {
+      expr = expr.where.expr;
+    }
+    return expr;
+  }
+  ModelFqnExpr2.unwrap = unwrap;
+})(ModelFqnExpr || (ModelFqnExpr = {}));
+var ModelRelationExpr;
+((ModelRelationExpr2) => {
+  function isDirect(expr) {
+    return "source" in expr && "target" in expr;
+  }
+  ModelRelationExpr2.isDirect = isDirect;
+  function isIncoming(expr) {
+    return "incoming" in expr;
+  }
+  ModelRelationExpr2.isIncoming = isIncoming;
+  function isOutgoing(expr) {
+    return "outgoing" in expr;
+  }
+  ModelRelationExpr2.isOutgoing = isOutgoing;
+  function isInOut(expr) {
+    return "inout" in expr;
+  }
+  ModelRelationExpr2.isInOut = isInOut;
+  function isWhere(expr) {
+    return "where" in expr && (isDirect(expr.where.expr) || isIncoming(expr.where.expr) || isOutgoing(expr.where.expr) || isInOut(expr.where.expr));
+  }
+  ModelRelationExpr2.isWhere = isWhere;
+  function isCustom(expr) {
+    return "customRelation" in expr;
+  }
+  ModelRelationExpr2.isCustom = isCustom;
+  function is(expr) {
+    return isDirect(expr) || isIncoming(expr) || isOutgoing(expr) || isInOut(expr);
+  }
+  ModelRelationExpr2.is = is;
+  function unwrap(expr) {
+    if (isCustom(expr)) {
+      expr = expr.customRelation.expr;
+    }
+    if (isWhere(expr)) {
+      expr = expr.where.expr;
+    }
+    return expr;
+  }
+  ModelRelationExpr2.unwrap = unwrap;
+})(ModelRelationExpr || (ModelRelationExpr = {}));
+var ModelExpression;
+((ModelExpression2) => {
+  function isWhere(expr) {
+    return "where" in expr;
+  }
+  ModelExpression2.isWhere = isWhere;
+  function isRelationWhere(expr) {
+    return ModelRelationExpr.isWhere(expr);
+  }
+  ModelExpression2.isRelationWhere = isRelationWhere;
+  function isFqnExprWhere(expr) {
+    return ModelFqnExpr.isWhere(expr);
+  }
+  ModelExpression2.isFqnExprWhere = isFqnExprWhere;
+  function isFqnExpr(expr) {
+    return ModelFqnExpr.is(expr) || ModelFqnExpr.isWhere(expr) || ModelFqnExpr.isCustom(expr);
+  }
+  ModelExpression2.isFqnExpr = isFqnExpr;
+  function isRelationExpr(expr) {
+    return ModelRelationExpr.is(expr) || ModelRelationExpr.isWhere(expr) || ModelRelationExpr.isCustom(expr);
+  }
+  ModelExpression2.isRelationExpr = isRelationExpr;
+})(ModelExpression || (ModelExpression = {}));
+
+export { ModelExpression, ModelFqnExpr, ModelRelationExpr };

package/dist/types/expression.d.mts

@@ -0,0 +1,7 @@
+import '../shared/core.DdzRtJ9d.mjs';
+import '../shared/core.DuSLYTG6.mjs';
+import './fqnRef.mjs';
+export { E as Expression, F as FqnExpr, P as PredicateSelector, R as RelationExpr } from '../shared/core.20m8Um0g.mjs';
+import '../shared/core.DX-WYEPA.mjs';
+import '../shared/core.CzdwsPmY.mjs';
+import 'type-fest';

package/dist/types/expression.mjs

@@ -0,0 +1,116 @@
+import { FqnRef } from './fqnRef.mjs';
+import 'remeda';
+import '../shared/core.Be1n9a0i.mjs';
+import '../shared/core.D4npX2q8.mjs';
+
+var FqnExpr;
+((FqnExpr2) => {
+  function isWildcard(expr) {
+    return "wildcard" in expr && expr.wildcard === true;
+  }
+  FqnExpr2.isWildcard = isWildcard;
+  function isModelRef(ref) {
+    return "ref" in ref && FqnRef.isModelRef(ref.ref);
+  }
+  FqnExpr2.isModelRef = isModelRef;
+  function isDeploymentRef(expr) {
+    return "ref" in expr && FqnRef.isDeploymentRef(expr.ref);
+  }
+  FqnExpr2.isDeploymentRef = isDeploymentRef;
+  function isElementKindExpr(expr) {
+    return "elementKind" in expr && "isEqual" in expr;
+  }
+  FqnExpr2.isElementKindExpr = isElementKindExpr;
+  function isElementTagExpr(expr) {
+    return "elementTag" in expr && "isEqual" in expr;
+  }
+  FqnExpr2.isElementTagExpr = isElementTagExpr;
+  function isWhere(expr) {
+    return "where" in expr && is(expr.where.expr);
+  }
+  FqnExpr2.isWhere = isWhere;
+  function isCustom(expr) {
+    return "custom" in expr && (is(expr.custom.expr) || isWhere(expr.custom.expr));
+  }
+  FqnExpr2.isCustom = isCustom;
+  function is(expr) {
+    return isWildcard(expr) || isModelRef(expr) || isDeploymentRef(expr) || isElementKindExpr(expr) || isElementTagExpr(expr);
+  }
+  FqnExpr2.is = is;
+  function unwrap(expr) {
+    if (isCustom(expr)) {
+      expr = expr.custom.expr;
+    }
+    if (isWhere(expr)) {
+      expr = expr.where.expr;
+    }
+    return expr;
+  }
+  FqnExpr2.unwrap = unwrap;
+})(FqnExpr || (FqnExpr = {}));
+var RelationExpr;
+((RelationExpr2) => {
+  function isDirect(expr) {
+    return "source" in expr && "target" in expr;
+  }
+  RelationExpr2.isDirect = isDirect;
+  function isIncoming(expr) {
+    return "incoming" in expr;
+  }
+  RelationExpr2.isIncoming = isIncoming;
+  function isOutgoing(expr) {
+    return "outgoing" in expr;
+  }
+  RelationExpr2.isOutgoing = isOutgoing;
+  function isInOut(expr) {
+    return "inout" in expr;
+  }
+  RelationExpr2.isInOut = isInOut;
+  function isWhere(expr) {
+    return "where" in expr && (isDirect(expr.where.expr) || isIncoming(expr.where.expr) || isOutgoing(expr.where.expr) || isInOut(expr.where.expr));
+  }
+  RelationExpr2.isWhere = isWhere;
+  function isCustom(expr) {
+    return "customRelation" in expr;
+  }
+  RelationExpr2.isCustom = isCustom;
+  function is(expr) {
+    return isDirect(expr) || isIncoming(expr) || isOutgoing(expr) || isInOut(expr);
+  }
+  RelationExpr2.is = is;
+  function unwrap(expr) {
+    if (isCustom(expr)) {
+      expr = expr.customRelation.expr;
+    }
+    if (isWhere(expr)) {
+      expr = expr.where.expr;
+    }
+    return expr;
+  }
+  RelationExpr2.unwrap = unwrap;
+})(RelationExpr || (RelationExpr = {}));
+var Expression;
+((Expression2) => {
+  function isWhere(expr) {
+    return "where" in expr;
+  }
+  Expression2.isWhere = isWhere;
+  function isRelationWhere(expr) {
+    return RelationExpr.isWhere(expr);
+  }
+  Expression2.isRelationWhere = isRelationWhere;
+  function isFqnExprWhere(expr) {
+    return FqnExpr.isWhere(expr);
+  }
+  Expression2.isFqnExprWhere = isFqnExprWhere;
+  function isFqnExpr(expr) {
+    return FqnExpr.is(expr) || FqnExpr.isWhere(expr) || FqnExpr.isCustom(expr);
+  }
+  Expression2.isFqnExpr = isFqnExpr;
+  function isRelation(expr) {
+    return RelationExpr.is(expr) || RelationExpr.isWhere(expr) || RelationExpr.isCustom(expr);
+  }
+  Expression2.isRelation = isRelation;
+})(Expression || (Expression = {}));
+
+export { Expression, FqnExpr, RelationExpr };

package/dist/types/fqnRef.d.mts

@@ -0,0 +1,61 @@
+import { A as Any, U as Unknown$1, j as ElementId, P as ProjectId, F as Fqn, D as DeploymentId } from '../shared/core.DdzRtJ9d.mjs';
+import { E as ExclusiveUnion } from '../shared/core.DuSLYTG6.mjs';
+import 'type-fest';
+import '../shared/core.DX-WYEPA.mjs';
+
+type AnyAux = Any;
+type Unknown = Unknown$1;
+declare namespace FqnRef {
+    /**
+     * Reference to logical model element
+     */
+    interface ElementRef<A extends AnyAux = Unknown> {
+        project?: never;
+        model: ElementId<A>;
+    }
+    function isElementRef<A extends AnyAux>(ref: FqnRef<A>): ref is ElementRef<A>;
+    /**
+     * Reference to imported logical model element
+     */
+    interface ImportRef<A extends AnyAux = Unknown> {
+        project: ProjectId<A>;
+        model: ElementId<A>;
+    }
+    function isImportRef<A extends AnyAux>(ref: FqnRef<A>): ref is ImportRef<A>;
+    function flatten<A extends AnyAux>(ref: FqnRef<A>): Fqn<A>;
+    type ModelRef<A extends AnyAux = Unknown> = ImportRef<A> | ElementRef<A>;
+    function isModelRef<A extends AnyAux>(ref: FqnRef<A>): ref is ModelRef<A>;
+    /**
+     * Represents a reference to an instance within a deployment.
+     *
+     * @template D - The type representing the deployment fqn. Defaults to `Fqn`.
+     * @template M - The type representing the model fqn. Defaults to `Fqn`.
+     *
+     * @property {D} deployment - TThe fully qualified name (FQN) of the deployed instance.
+     * @property {M} element - The element reference within the deployment.
+     */
+    interface InsideInstanceRef<A extends AnyAux = Unknown> {
+        deployment: DeploymentId<A>;
+        element: ElementId<A>;
+    }
+    function isInsideInstanceRef<A extends AnyAux>(ref: FqnRef<A>): ref is InsideInstanceRef<A>;
+    /**
+     * Represents a reference to a deployment element.
+     *
+     * @template F - The type of the fully qualified name (FQN) of the deployment element. Defaults to `Fqn`.
+     * @property {F} deployment - The fully qualified name (FQN) of the deployment element.
+     */
+    interface DeploymentElementRef<A extends AnyAux> {
+        deployment: DeploymentId<A>;
+        element?: never;
+    }
+    function isDeploymentElementRef<A extends AnyAux>(ref: FqnRef<A>): ref is DeploymentElementRef<A>;
+    type DeploymentRef<A extends AnyAux> = DeploymentElementRef<A> | InsideInstanceRef<A>;
+    function isDeploymentRef<A extends AnyAux>(ref: FqnRef<A>): ref is DeploymentRef<A>;
+}
+type FqnRef<A extends AnyAux = Unknown> = ExclusiveUnion<{
+    DeploymentRef: FqnRef.DeploymentRef<A>;
+    ModelRef: FqnRef.ModelRef<A>;
+}>;
+
+export { FqnRef };