@likec4/core 1.27.2 → 1.28.0

package/dist/shared/{core.z6g06scf.d.mts → core.DJvmfnEi.d.mts}

@@ -1,5 +1,134 @@
-import { Tagged, NonEmptyTuple, Simplify, MergeExclusive } from 'type-fest';
-import { N as NonEmptyArray, F as Fqn, j as ElementKind, s as Tag, p as ElementShape, x as Color, I as IconUrl, l as BorderStyle, S as ShapeSize, E as ExclusiveUnion, q as ElementStyle, r as Link, P as Point, X as XYPoint, T as ThemeColorValues, M as SpacingSize, O as TextSize, Q as ThemeColor, n as ElementKindSpecification, u as TypedElement } from './core.30yYKXcZ.mjs';
+import { d as IconUrl, F as Fqn, N as NonEmptyArray, T as Tag, E as ExclusiveUnion, e as ProjectId, P as Point, X as XYPoint } from './core.SjLhMA7a.mjs';
+import { LiteralUnion, TupleToUnion, Tagged, NonEmptyTuple, Simplify, MergeExclusive } from 'type-fest';
+
+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>;
+type ShapeSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+/**
+ * For padding, margin, etc.
+ */
+type SpacingSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+type TextSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+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;
+    sizes: {
+        [key in ShapeSize]: {
+            width: number;
+            height: number;
+        };
+    };
+    spacing: {
+        [key in SpacingSize]: number;
+    };
+    textSizes: {
+        [key in TextSize]: number;
+    };
+}
+
+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: ThemeColor;
+declare const DefaultElementShape: ElementShape;
+declare const DefaultShapeSize: ShapeSize;
+declare const DefaultPaddingSize: SpacingSize;
+declare const DefaultTextSize: TextSize;
+interface ElementStyle {
+    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;
+}
+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;
+    size?: ShapeSize;
+    padding?: SpacingSize;
+    textSize?: TextSize;
+}
+interface ElementKindSpecification {
+    readonly technology?: string;
+    readonly notation?: string;
+    readonly style: ElementKindSpecificationStyle;
+}
 
 type EqualOperator<V> = {
     eq: V;
@@ -52,167 +181,6 @@ type Filterable<FTag extends string | null = string | null, FKind extends string
 type OperatorPredicate<V extends Filterable> = (value: V) => boolean;
 declare function whereOperatorAsPredicate<FTag extends string | null = string | null, FKind extends string | null = string | null>(operator: WhereOperator<FTag, FKind>): OperatorPredicate<Filterable>;
 
-interface BaseExpr {
-    where?: never;
-    element?: never;
-    custom?: never;
-    expanded?: never;
-    elementKind?: never;
-    elementTag?: never;
-    isEqual?: never;
-    isChildren?: never;
-    isDescendants?: never;
-    wildcard?: never;
-    source?: never;
-    target?: never;
-    inout?: never;
-    incoming?: never;
-    outgoing?: never;
-    customRelation?: never;
-}
-interface ElementRefExpr extends Omit<BaseExpr, 'element' | 'isChildren' | 'isDescendants'> {
-    element: Fqn;
-    isChildren?: boolean;
-    isDescendants?: boolean;
-}
-declare function isElementRef(expr: Expression): expr is ElementRefExpr;
-interface ExpandedElementExpr extends Omit<BaseExpr, 'expanded'> {
-    expanded: Fqn;
-}
-declare function isExpandedElementExpr(expr: Expression): expr is ExpandedElementExpr;
-interface CustomElementExpr extends Omit<BaseExpr, 'custom'> {
-    custom: {
-        expr: ElementExpression | ElementWhereExpr;
-        title?: string;
-        description?: string;
-        technology?: string;
-        notation?: string;
-        shape?: ElementShape;
-        color?: Color;
-        icon?: IconUrl;
-        border?: BorderStyle;
-        opacity?: number;
-        navigateTo?: ViewId;
-        multiple?: boolean;
-        size?: ShapeSize;
-        padding?: ShapeSize;
-        textSize?: ShapeSize;
-    };
-}
-declare function isCustomElement(expr: Expression): expr is CustomElementExpr;
-interface WildcardExpr extends Omit<BaseExpr, 'wildcard'> {
-    wildcard: true;
-}
-declare function isWildcard(expr: Expression): expr is WildcardExpr;
-interface ElementKindExpr extends Omit<BaseExpr, 'elementKind' | 'isEqual'> {
-    elementKind: ElementKind;
-    isEqual: boolean;
-}
-declare function isElementKindExpr(expr: Expression): expr is ElementKindExpr;
-interface ElementTagExpr extends Omit<BaseExpr, 'elementTag' | 'isEqual'> {
-    elementTag: Tag;
-    isEqual: boolean;
-}
-declare function isElementTagExpr(expr: Expression): expr is ElementTagExpr;
-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: {
-        expr: ElementExpression;
-        condition: WhereOperator<string, string>;
-    };
-}
-declare function isElementWhere(expr: Expression): expr is ElementWhereExpr;
-type ElementPredicateExpression = ElementExpression | ElementWhereExpr | CustomElementExpr;
-declare function isElementPredicateExpr(expr: Expression): expr is ElementPredicateExpression;
-interface DirectRelationExpr extends Omit<BaseExpr, 'source' | 'target'> {
-    source: ElementExpression;
-    target: ElementExpression;
-    isBidirectional?: boolean;
-}
-declare function isRelation(expr: Expression): expr is DirectRelationExpr;
-interface InOutExpr extends Omit<BaseExpr, 'inout'> {
-    inout: ElementExpression;
-}
-declare function isInOut(expr: Expression): expr is InOutExpr;
-interface IncomingExpr extends Omit<BaseExpr, 'incoming'> {
-    incoming: ElementExpression;
-}
-declare function isIncoming(expr: Expression): expr is IncomingExpr;
-interface OutgoingExpr extends Omit<BaseExpr, 'outgoing'> {
-    outgoing: ElementExpression;
-}
-declare function isOutgoing(expr: Expression): expr is OutgoingExpr;
-type RelationExpression = DirectRelationExpr | InOutExpr | IncomingExpr | OutgoingExpr;
-declare function isRelationExpression(expr: Expression): expr is RelationExpression;
-interface RelationWhereExpr extends Omit<BaseExpr, 'where'> {
-    where: {
-        expr: RelationExpression;
-        condition: WhereOperator<string, string>;
-    };
-}
-declare function isRelationWhere(expr: Expression): expr is RelationWhereExpr;
-interface CustomRelationExpr extends Omit<BaseExpr, 'customRelation'> {
-    customRelation: {
-        relation: RelationExpression | RelationWhereExpr;
-        title?: string;
-        description?: string;
-        technology?: string;
-        notation?: string;
-        navigateTo?: ViewId;
-        notes?: string;
-        color?: Color;
-        line?: RelationshipLineType;
-        head?: RelationshipArrowType;
-        tail?: RelationshipArrowType;
-    };
-}
-declare function isCustomRelationExpr(expr: Expression): expr is CustomRelationExpr;
-type RelationPredicateExpression = RelationExpression | RelationWhereExpr | CustomRelationExpr;
-declare function isRelationPredicateExpr(expr: Expression): expr is RelationPredicateExpression;
-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;
-type expression_ElementRefExpr = ElementRefExpr;
-type expression_ElementTagExpr = ElementTagExpr;
-type expression_ElementWhereExpr = ElementWhereExpr;
-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_RelationExpression = RelationExpression;
-type expression_RelationPredicateExpression = RelationPredicateExpression;
-type expression_RelationWhereExpr = RelationWhereExpr;
-type expression_WildcardExpr = WildcardExpr;
-declare const expression_isCustomElement: typeof isCustomElement;
-declare const expression_isCustomRelationExpr: typeof isCustomRelationExpr;
-declare const expression_isElement: typeof isElement;
-declare const expression_isElementKindExpr: typeof isElementKindExpr;
-declare const expression_isElementPredicateExpr: typeof isElementPredicateExpr;
-declare const expression_isElementRef: typeof isElementRef;
-declare const expression_isElementTagExpr: typeof isElementTagExpr;
-declare const expression_isElementWhere: typeof isElementWhere;
-declare const expression_isExpandedElementExpr: typeof isExpandedElementExpr;
-declare const expression_isInOut: typeof isInOut;
-declare const expression_isIncoming: typeof isIncoming;
-declare const expression_isOutgoing: typeof isOutgoing;
-declare const expression_isRelation: typeof isRelation;
-declare const expression_isRelationExpression: typeof isRelationExpression;
-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_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.
@@ -247,71 +215,185 @@ declare namespace FqnRef {
         model: F;
     };
     const isModelRef: (ref: FqnRef) => ref is ModelRef;
+    /**
+     * Reference to imported logical model element
+     */
+    type ImportRef<F = Fqn> = {
+        project: ProjectId;
+        model: F;
+    };
+    const isImportRef: (ref: FqnRef) => ref is ImportRef;
     const toDeploymentRef: (ref: FqnRef) => DeploymentRef;
+    const toModelFqn: (ref: FqnRef) => Fqn;
 }
 type FqnRef<D = Fqn, M = Fqn> = ExclusiveUnion<{
     InsideInstanceRef: FqnRef.InsideInstanceRef<D, M>;
     DeploymentRef: FqnRef.DeploymentRef<D>;
     ModelRef: FqnRef.ModelRef<M>;
+    ImportRef: FqnRef.ImportRef<M>;
 }>;
 declare namespace FqnExpr {
     type Wildcard = {
         wildcard: true;
     };
-    const isWildcard: (expr: ExpressionV2) => expr is Wildcard;
+    const isWildcard: (expr: ExpressionV2) => expr is FqnExpr.Wildcard;
     type ModelRef<M = Fqn> = {
-        ref: FqnRef.ModelRef<M>;
+        ref: FqnRef.ModelRef<M> | FqnRef.ImportRef<M>;
         selector?: PredicateSelector;
     };
-    const isModelRef: (ref: ExpressionV2) => ref is ModelRef;
+    const isModelRef: (ref: ExpressionV2) => ref is FqnExpr.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 ElementKindExpr = {
+        elementKind: ElementKind;
+        isEqual: boolean;
+    };
+    function isElementKindExpr(expr: ExpressionV2): expr is ElementKindExpr;
+    type ElementTagExpr = {
+        elementTag: Tag;
+        isEqual: boolean;
+    };
+    function isElementTagExpr(expr: ExpressionV2): expr is ElementTagExpr;
     type NonWildcard<D = Fqn, M = Fqn> = ExclusiveUnion<{
         ModelRef: ModelRef<M>;
         DeploymentRef: DeploymentRef<D, M>;
+        ElementKind: ElementKindExpr;
+        ElementTag: ElementTagExpr;
+    }>;
+    type Where<D = Fqn, M = Fqn> = {
+        where: {
+            expr: ExclusiveUnion<{
+                Wildcard: Wildcard;
+                ModelRef: ModelRef<M>;
+                DeploymentRef: DeploymentRef<D, M>;
+                ElementKind: ElementKindExpr;
+                ElementTag: ElementTagExpr;
+            }>;
+            condition: WhereOperator<string, string>;
+        };
+    };
+    const isWhere: (expr: ExpressionV2) => expr is FqnExpr.Where;
+    type Custom<D = Fqn, M = Fqn> = {
+        custom: {
+            expr: OrWhere<D, M>;
+            title?: string;
+            description?: string;
+            technology?: string;
+            notation?: string;
+            shape?: ElementShape;
+            color?: Color;
+            icon?: IconUrl;
+            border?: BorderStyle;
+            opacity?: number;
+            navigateTo?: ViewId;
+            multiple?: boolean;
+            size?: ShapeSize;
+            padding?: ShapeSize;
+            textSize?: ShapeSize;
+        };
+    };
+    const isCustom: (expr: ExpressionV2) => expr is Custom;
+    const is: (expr: ExpressionV2) => expr is FqnExpr;
+    type OrWhere<D = Fqn, M = Fqn> = ExclusiveUnion<{
+        Wildcard: FqnExpr.Wildcard;
+        ModelRef: FqnExpr.ModelRef<M>;
+        DeploymentRef: FqnExpr.DeploymentRef<D, M>;
+        ElementKind: ElementKindExpr;
+        ElementTag: ElementTagExpr;
+        Where: FqnExpr.Where<D, M>;
+    }>;
+    type Any<D = Fqn, M = Fqn> = ExclusiveUnion<{
+        Wildcard: Wildcard;
+        ModelRef: ModelRef<M>;
+        DeploymentRef: DeploymentRef<D, M>;
+        ElementKind: ElementKindExpr;
+        ElementTag: ElementTagExpr;
+        Where: Where<D, M>;
+        Custom: Custom<D, M>;
     }>;
+    const unwrap: (expr: FqnExpr) => Wildcard | ModelRef | DeploymentRef | ElementKindExpr | ElementTagExpr;
 }
 type FqnExpr<D = Fqn, M = Fqn> = ExclusiveUnion<{
     Wildcard: FqnExpr.Wildcard;
     ModelRef: FqnExpr.ModelRef<M>;
     DeploymentRef: FqnExpr.DeploymentRef<D, M>;
+    ElementKind: FqnExpr.ElementKindExpr;
+    ElementTag: FqnExpr.ElementTagExpr;
 }>;
 declare namespace RelationExpr {
+    type Endpoint<D = Fqn, M = Fqn> = FqnExpr.Where<D, M>['where']['expr'];
     type Direct<D = Fqn, M = Fqn> = {
-        source: FqnExpr<D, M>;
-        target: FqnExpr<D, M>;
+        source: Endpoint<D, M>;
+        target: Endpoint<D, M>;
         isBidirectional?: boolean;
     };
-    const isDirect: (expr: ExpressionV2) => expr is Direct;
+    const isDirect: (expr: ExpressionV2) => expr is RelationExpr.Direct;
     type Incoming<D = Fqn, M = Fqn> = {
-        incoming: FqnExpr<D, M>;
+        incoming: Endpoint<D, M>;
     };
-    const isIncoming: (expr: ExpressionV2) => expr is Incoming;
+    const isIncoming: (expr: ExpressionV2) => expr is RelationExpr.Incoming;
     type Outgoing<D = Fqn, M = Fqn> = {
-        outgoing: FqnExpr<D, M>;
+        outgoing: Endpoint<D, M>;
     };
-    const isOutgoing: (expr: ExpressionV2) => expr is Outgoing;
+    const isOutgoing: (expr: ExpressionV2) => expr is RelationExpr.Outgoing;
     type InOut<D = Fqn, M = Fqn> = {
-        inout: FqnExpr<D, M>;
+        inout: Endpoint<D, M>;
     };
-    const isInOut: (expr: ExpressionV2) => expr is InOut;
+    const isInOut: (expr: ExpressionV2) => expr is RelationExpr.InOut;
     type Where<D = Fqn, M = Fqn> = {
         where: {
-            expr: ExpressionV2<D, M>;
+            expr: ExclusiveUnion<{
+                Direct: RelationExpr.Direct<D, M>;
+                Incoming: RelationExpr.Incoming<D, M>;
+                Outgoing: RelationExpr.Outgoing<D, M>;
+                InOut: RelationExpr.InOut<D, M>;
+            }>;
             condition: WhereOperator<string, string>;
         };
     };
-    const isWhere: (expr: ExpressionV2) => expr is Where;
+    const isWhere: (expr: ExpressionV2) => expr is RelationExpr.Where;
+    type Custom<D = Fqn, M = Fqn> = {
+        customRelation: {
+            expr: OrWhere<D, M>;
+            title?: string;
+            description?: string;
+            technology?: string;
+            notation?: string;
+            navigateTo?: ViewId;
+            notes?: string;
+            color?: Color;
+            line?: RelationshipLineType;
+            head?: RelationshipArrowType;
+            tail?: RelationshipArrowType;
+        };
+    };
+    const isCustom: (expr: ExpressionV2) => expr is Custom;
+    const is: (expr: ExpressionV2) => expr is RelationExpr;
+    type OrWhere<D = Fqn, M = Fqn> = ExclusiveUnion<{
+        Direct: Direct<D, M>;
+        Incoming: Incoming<D, M>;
+        Outgoing: Outgoing<D, M>;
+        InOut: InOut<D, M>;
+        Where: Where<D, M>;
+    }>;
+    type Any<D = Fqn, M = Fqn> = ExclusiveUnion<{
+        Direct: Direct<D, M>;
+        Incoming: Incoming<D, M>;
+        Outgoing: Outgoing<D, M>;
+        InOut: InOut<D, M>;
+        Where: Where<D, M>;
+        Custom: Custom<D, M>;
+    }>;
+    const unwrap: (expr: RelationExpr) => Direct | Incoming | Outgoing | 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>;
-    Where: RelationExpr.Where<D, M>;
 }>;
 /**
  * Represents a version 2 expression which can be one of several types.
@@ -323,15 +405,227 @@ type ExpressionV2<D = Fqn, M = Fqn> = ExclusiveUnion<{
     Wildcard: FqnExpr.Wildcard;
     ModelRef: FqnExpr.ModelRef<M>;
     DeploymentRef: FqnExpr.DeploymentRef<D, M>;
+    ElementKind: FqnExpr.ElementKindExpr;
+    ElementTag: FqnExpr.ElementTagExpr;
+    Custom: FqnExpr.Custom<D, M>;
     Direct: RelationExpr.Direct<D, M>;
     Incoming: RelationExpr.Incoming<D, M>;
     Outgoing: RelationExpr.Outgoing<D, M>;
     InOut: RelationExpr.InOut<D, M>;
-    RelationPredicateOrWhere: RelationExpr.Where<D, M>;
+    Where: ExpressionV2.Where<D, M>;
+    CustomRelation: RelationExpr.Custom<D, M>;
 }>;
 declare namespace ExpressionV2 {
-    const isFqnExpr: (expr: ExpressionV2) => expr is FqnExpr;
-    const isRelation: (expr: ExpressionV2) => expr is RelationExpr;
+    type Where<D = Fqn, M = Fqn> = FqnExpr.Where<D, M> | RelationExpr.Where<D, M>;
+    const isWhere: (expr: ExpressionV2) => expr is ExpressionV2.Where;
+    const isRelationWhere: (expr: ExpressionV2) => expr is RelationExpr.Where;
+    const isFqnExprWhere: (expr: ExpressionV2) => expr is FqnExpr.Where;
+    const isFqnExpr: (expr: ExpressionV2) => expr is FqnExpr.Any;
+    const isRelation: (expr: ExpressionV2) => expr is RelationExpr.Any;
+}
+
+declare namespace ModelLayer {
+    namespace FqnRef {
+        /**
+         * Reference to logical model element
+         */
+        type ModelRef<F = Fqn> = {
+            model: F;
+        };
+        const isModelRef: (ref: FqnRef) => ref is ModelRef;
+        /**
+         * Reference to imported logical model element
+         */
+        type ImportRef<F = Fqn> = {
+            project: ProjectId;
+            model: F;
+        };
+        const isImportRef: (ref: FqnRef) => ref is ImportRef;
+        const toFqn: (ref: FqnRef) => Fqn;
+    }
+    type FqnRef<M = Fqn> = ExclusiveUnion<{
+        ModelRef: FqnRef.ModelRef<M>;
+        ImportRef: FqnRef.ImportRef<M>;
+    }>;
+    namespace FqnExpr {
+        type Wildcard = {
+            wildcard: true;
+        };
+        const isWildcard: (expr: Expression) => expr is FqnExpr.Wildcard;
+        type ModelRef<M = Fqn> = {
+            ref: FqnRef.ModelRef<M> | FqnRef.ImportRef<M>;
+            selector?: PredicateSelector;
+        };
+        const isModelRef: (ref: Expression) => ref is FqnExpr.ModelRef;
+        type ElementKindExpr = {
+            elementKind: ElementKind;
+            isEqual: boolean;
+        };
+        function isElementKindExpr(expr: Expression): expr is ElementKindExpr;
+        type ElementTagExpr = {
+            elementTag: Tag;
+            isEqual: boolean;
+        };
+        function isElementTagExpr(expr: Expression): expr is ElementTagExpr;
+        type NonWildcard<M = Fqn> = ExclusiveUnion<{
+            ModelRef: ModelRef<M>;
+            ElementKind: ElementKindExpr;
+            ElementTag: ElementTagExpr;
+        }>;
+        type Where<M = Fqn> = {
+            where: {
+                expr: ExclusiveUnion<{
+                    Wildcard: Wildcard;
+                    ModelRef: ModelRef<M>;
+                    ElementKind: ElementKindExpr;
+                    ElementTag: ElementTagExpr;
+                }>;
+                condition: WhereOperator<string, string>;
+            };
+        };
+        const isWhere: (expr: Expression) => expr is FqnExpr.Where;
+        type Custom<M = Fqn> = {
+            custom: {
+                expr: FqnExprOrWhere<M>;
+                title?: string;
+                description?: string;
+                technology?: string;
+                notation?: string;
+                shape?: ElementShape;
+                color?: Color;
+                icon?: IconUrl;
+                border?: BorderStyle;
+                opacity?: number;
+                navigateTo?: ViewId;
+                multiple?: boolean;
+                size?: ShapeSize;
+                padding?: ShapeSize;
+                textSize?: ShapeSize;
+            };
+        };
+        const isCustom: (expr: Expression) => expr is FqnExpr.Custom;
+        const is: (expr: Expression) => expr is FqnExpr;
+    }
+    type FqnExpr<M = Fqn> = ExclusiveUnion<{
+        Wildcard: FqnExpr.Wildcard;
+        ModelRef: FqnExpr.ModelRef<M>;
+        ElementKind: FqnExpr.ElementKindExpr;
+        ElementTag: FqnExpr.ElementTagExpr;
+    }>;
+    type FqnExprOrWhere<M = Fqn> = ExclusiveUnion<{
+        Wildcard: FqnExpr.Wildcard;
+        ModelRef: FqnExpr.ModelRef<M>;
+        ElementKind: FqnExpr.ElementKindExpr;
+        ElementTag: FqnExpr.ElementTagExpr;
+        Where: FqnExpr.Where<M>;
+    }>;
+    type AnyFqnExpr<M = Fqn> = ExclusiveUnion<{
+        Wildcard: FqnExpr.Wildcard;
+        ModelRef: FqnExpr.ModelRef<M>;
+        ElementKind: FqnExpr.ElementKindExpr;
+        ElementTag: FqnExpr.ElementTagExpr;
+        Where: FqnExpr.Where<M>;
+        Custom: FqnExpr.Custom<M>;
+    }>;
+    function isAnyFqnExpr(expr: Expression): expr is AnyFqnExpr;
+    namespace RelationExpr {
+        type Direct<M = Fqn> = {
+            source: FqnExpr<M>;
+            target: FqnExpr<M>;
+            isBidirectional?: boolean;
+        };
+        const isDirect: (expr: Expression) => expr is RelationExpr.Direct;
+        type Incoming<M = Fqn> = {
+            incoming: FqnExpr<M>;
+        };
+        const isIncoming: (expr: Expression) => expr is RelationExpr.Incoming;
+        type Outgoing<M = Fqn> = {
+            outgoing: FqnExpr<M>;
+        };
+        const isOutgoing: (expr: Expression) => expr is RelationExpr.Outgoing;
+        type InOut<M = Fqn> = {
+            inout: FqnExpr<M>;
+        };
+        const isInOut: (expr: Expression) => expr is RelationExpr.InOut;
+        type Where<M = Fqn> = {
+            where: {
+                expr: ExclusiveUnion<{
+                    Direct: RelationExpr.Direct<M>;
+                    Incoming: RelationExpr.Incoming<M>;
+                    Outgoing: RelationExpr.Outgoing<M>;
+                    InOut: RelationExpr.InOut<M>;
+                }>;
+                condition: WhereOperator<string, string>;
+            };
+        };
+        const isWhere: (expr: Expression) => expr is RelationExpr.Where;
+        type Custom<M = Fqn> = {
+            customRelation: {
+                expr: RelationExprOrWhere<M>;
+                title?: string;
+                description?: string;
+                technology?: string;
+                notation?: string;
+                navigateTo?: ViewId;
+                notes?: string;
+                color?: Color;
+                line?: RelationshipLineType;
+                head?: RelationshipArrowType;
+                tail?: RelationshipArrowType;
+            };
+        };
+        const isCustom: (expr: Expression) => expr is Custom;
+        const is: (expr: Expression) => expr is RelationExpr;
+    }
+    type RelationExpr<M = Fqn> = ExclusiveUnion<{
+        Direct: RelationExpr.Direct<M>;
+        Incoming: RelationExpr.Incoming<M>;
+        Outgoing: RelationExpr.Outgoing<M>;
+        InOut: RelationExpr.InOut<M>;
+    }>;
+    type RelationExprOrWhere<M = Fqn> = ExclusiveUnion<{
+        Direct: RelationExpr.Direct<M>;
+        Incoming: RelationExpr.Incoming<M>;
+        Outgoing: RelationExpr.Outgoing<M>;
+        InOut: RelationExpr.InOut<M>;
+        Where: RelationExpr.Where<M>;
+    }>;
+    type AnyRelationExpr<M = Fqn> = ExclusiveUnion<{
+        Direct: RelationExpr.Direct<M>;
+        Incoming: RelationExpr.Incoming<M>;
+        Outgoing: RelationExpr.Outgoing<M>;
+        InOut: RelationExpr.InOut<M>;
+        Where: RelationExpr.Where<M>;
+        CustomRelation: RelationExpr.Custom<M>;
+    }>;
+    function isAnyRelationExpr(expr: Expression): expr is AnyRelationExpr;
+    /**
+     * Represents a version 2 expression which can be one of several types.
+     *
+     * @template M - The type for the model FQN, defaults to `Fqn`.
+     */
+    type Expression<M = Fqn> = ExclusiveUnion<{
+        Wildcard: FqnExpr.Wildcard;
+        ModelRef: FqnExpr.ModelRef<M>;
+        ElementKind: FqnExpr.ElementKindExpr;
+        ElementTag: FqnExpr.ElementTagExpr;
+        Custom: FqnExpr.Custom<M>;
+        Direct: RelationExpr.Direct<M>;
+        Incoming: RelationExpr.Incoming<M>;
+        Outgoing: RelationExpr.Outgoing<M>;
+        InOut: RelationExpr.InOut<M>;
+        CustomRelation: RelationExpr.Custom<M>;
+        Where: Expression.Where<M>;
+    }>;
+    function isExpression(expr: any): expr is Expression;
+    namespace Expression {
+        type Where<M = Fqn> = FqnExpr.Where<M> | RelationExpr.Where<M>;
+        const isWhere: (expr: Expression) => expr is Expression.Where;
+        const isCustomFqnExpr: (expr: Expression) => expr is FqnExpr.Custom;
+        const isCustomRelationExpr: (expr: Expression) => expr is RelationExpr.Custom;
+        const isFqnExpr: (expr: Expression) => expr is FqnExpr;
+        const isRelation: (expr: Expression) => expr is RelationExpr;
+    }
 }
 
 type GlobalPredicateId = Tagged<string, 'GlobalPredicateId'>;
@@ -354,11 +648,11 @@ type ElementNotation = {
 
 type ViewId<Id extends string = string> = Tagged<Id, 'ViewID'>;
 type ViewRulePredicate = {
-    include: Expression[];
+    include: ModelLayer.Expression[];
     exclude?: never;
 } | {
     include?: never;
-    exclude: Expression[];
+    exclude: ModelLayer.Expression[];
 };
 declare function isViewRulePredicate(rule: DeploymentViewRule): rule is DeploymentViewRulePredicate;
 declare function isViewRulePredicate(rule: DynamicViewRule): rule is DynamicViewIncludeRule;
@@ -368,7 +662,7 @@ interface ViewRuleGlobalPredicateRef {
 }
 declare function isViewRuleGlobalPredicateRef(rule: ViewRule): rule is ViewRuleGlobalPredicateRef;
 interface ViewRuleStyle {
-    targets: ElementExpression[];
+    targets: ModelLayer.FqnExpr[];
     notation?: string;
     style: ElementStyle & {
         color?: Color;
@@ -463,7 +757,7 @@ interface DynamicViewParallelSteps {
 }
 type DynamicViewStepOrParallel = DynamicViewStep | DynamicViewParallelSteps;
 type DynamicViewIncludeRule = {
-    include: ElementPredicateExpression[];
+    include: ModelLayer.AnyFqnExpr[];
 };
 type DynamicViewRule = DynamicViewIncludeRule | ViewRuleGlobalPredicateRef | ViewRuleStyle | ViewRuleGlobalStyle | ViewRuleAutoLayout;
 interface DynamicView<ViewIDs extends string = string, Tags extends string = string> extends BasicView<'dynamic', ViewIDs, Tags> {
@@ -647,12 +941,12 @@ interface DiagramNode extends ComputedNode {
     labelBBox: BBox;
 }
 declare namespace DiagramNode {
-    function modelRef(node: DiagramNode): Fqn | null;
-    function deploymentRef(node: DiagramNode): Fqn | null;
+    function modelRef(node: Pick<DiagramNode, 'id' | 'modelRef'>): Fqn | null;
+    function deploymentRef(node: Pick<DiagramNode, 'id' | 'deploymentRef'>): Fqn | null;
     /**
      * Nodes group is a special kind of node, exisiting only in view
      */
-    function isNodesGroup(node: DiagramNode): boolean;
+    function isNodesGroup(node: Pick<DiagramNode, 'kind'>): boolean;
 }
 interface DiagramEdge extends ComputedEdge {
     points: NonEmptyArray<Point>;
@@ -822,6 +1116,7 @@ interface ParsedLikeC4ModelData<ElementKinds extends string = string, RelationKi
         elements: Record<DeploymentFqns, DeploymentElement>;
         relations: Record<RelationId, DeploymentRelation>;
     };
+    imports: Record<ProjectId, NonEmptyArray<Element>>;
 }
 type AnyParsedLikeC4ModelData = ParsedLikeC4ModelData<any, any, any, any, any, any>;
 /**
@@ -855,4 +1150,4 @@ interface LayoutedLikeC4ModelData<Fqns extends string = string, DeploymentFqns e
     views: Record<Views, DiagramView<Views, Tags>>;
 }
 
-export { type GlobalDynamicPredicates as $, type CustomElementExpr as A, type CustomRelationExpr as B, type ComputedLikeC4ModelData 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 _, ComputedView as a, type ComputedDeploymentView as a$, type GlobalPredicateId as a0, type GlobalPredicates as a1, type GlobalStyleID as a2, type GlobalStyles as a3, type ModelGlobals as a4, type AnyParsedLikeC4ModelData as a5, type GenericLikeC4ModelData as a6, type LayoutedLikeC4ModelData as a7, type LikeC4ModelDump as a8, type ParsedLikeC4ModelData as a9, type RelationshipKind as aA, type RelationshipKindSpecification as aB, type RelationshipLineType as aC, ComputedNode as aD, DiagramNode as aE, extractStep as aF, getBBoxCenter as aG, getParallelStepsPrefix as aH, isAutoLayoutDirection as aI, isDeploymentView as aJ, isDynamicView as aK, isDynamicViewParallelSteps as aL, isElementView as aM, isExtendsElementView as aN, isScopedElementView as aO, isStepEdgeId as aP, isViewRuleAutoLayout as aQ, isViewRuleGlobalPredicateRef as aR, isViewRuleGlobalStyle as aS, isViewRuleGroup as aT, isViewRulePredicate as aU, isViewRuleStyle as aV, stepEdgeId as aW, type AutoLayoutDirection as aX, type BasicElementView as aY, type BasicView as aZ, type BBox as a_, isAndOperator as aa, isKindEqual as ab, isNotOperator as ac, isOrOperator as ad, isParticipantOperator as ae, isTagEqual as af, whereOperatorAsPredicate as ag, type AllNever as ah, type AndOperator as ai, type EqualOperator as aj, type Filterable as ak, type KindEqual as al, type NotOperator as am, type OperatorPredicate as an, type OrOperator as ao, type Participant as ap, type ParticipantOperator as aq, type TagEqual as ar, type WhereOperator as as, DefaultArrowType as at, DefaultLineStyle as au, DefaultRelationshipColor as av, type AbstractRelation as aw, type ModelRelation as ax, type RelationId as ay, type RelationshipArrowType as az, type DeployedInstance as b, type ComputedDynamicView as b0, type ComputedEdge as b1, type ComputedElementView as b2, type CustomColorDefinitions as b3, type DeploymentView as b4, type DeploymentViewRule as b5, type DeploymentViewRulePredicate as b6, type DeploymentViewRuleStyle as b7, type DiagramEdge as b8, type DiagramView as b9, type ElementNotation as bA, type DynamicView as ba, type DynamicViewIncludeRule as bb, type DynamicViewParallelSteps as bc, type DynamicViewRule as bd, type DynamicViewStep as be, type DynamicViewStepOrParallel as bf, type EdgeId as bg, type ElementView as bh, type ExtendsElementView as bi, type NodeId as bj, type ScopedElementView as bk, type StepEdgeId as bl, type StepEdgeIdLiteral as bm, type ViewAutoLayout as bn, type ViewId as bo, type ViewManualLayout as bp, type ViewRule as bq, type ViewRuleAutoLayout as br, type ViewRuleGlobalPredicateRef as bs, type ViewRuleGlobalStyle as bt, type ViewRuleGroup as bu, type ViewRulePredicate as bv, type ViewRuleStyle as bw, type ViewRuleStyleOrGlobalRef as bx, type ViewWithHash as by, type ViewWithNotation as bz, 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 };
+export { isTagEqual as $, type GlobalPredicateId as A, BorderStyles as B, type ComputedLikeC4ModelData as C, DeploymentElement as D, ElementKind as E, FqnExpr as F, type GlobalDynamicPredicates as G, type HexColorLiteral as H, type GlobalPredicates as I, type GlobalStyleID as J, type GlobalStyles as K, type LikeC4View as L, ModelLayer as M, type ModelGlobals as N, type AnyParsedLikeC4ModelData as O, type PredicateSelector as P, type GenericLikeC4ModelData as Q, RelationExpr as R, type LayoutedLikeC4ModelData as S, type ThemeColorValues as T, type LikeC4ModelDump as U, type ParsedLikeC4ModelData as V, isAndOperator as W, isKindEqual as X, isNotOperator as Y, isOrOperator as Z, isParticipantOperator as _, ComputedView as a, type CustomColorDefinitions as a$, whereOperatorAsPredicate as a0, type AllNever as a1, type AndOperator as a2, type EqualOperator as a3, type Filterable as a4, type KindEqual as a5, type NotOperator as a6, type OperatorPredicate as a7, type OrOperator as a8, type Participant as a9, DiagramNode as aA, extractStep as aB, getBBoxCenter as aC, getParallelStepsPrefix as aD, isAutoLayoutDirection as aE, isDeploymentView as aF, isDynamicView as aG, isDynamicViewParallelSteps as aH, isElementView as aI, isExtendsElementView as aJ, isScopedElementView as aK, isStepEdgeId as aL, isViewRuleAutoLayout as aM, isViewRuleGlobalPredicateRef as aN, isViewRuleGlobalStyle as aO, isViewRuleGroup as aP, isViewRulePredicate as aQ, isViewRuleStyle as aR, stepEdgeId as aS, type AutoLayoutDirection as aT, type BasicElementView as aU, type BasicView as aV, type BBox as aW, type ComputedDeploymentView as aX, type ComputedDynamicView as aY, type ComputedEdge as aZ, type ComputedElementView as a_, type ParticipantOperator as aa, type TagEqual as ab, type WhereOperator as ac, DefaultArrowType as ad, DefaultLineStyle as ae, DefaultRelationshipColor as af, type AbstractRelation as ag, type ModelRelation as ah, type RelationId as ai, type RelationshipArrowType as aj, type RelationshipKind as ak, type RelationshipKindSpecification as al, type RelationshipLineType as am, isThemeColor as an, ThemeColors as ao, type Color as ap, type ColorLiteral as aq, type ElementThemeColors as ar, type ElementThemeColorValues as as, type RelationshipThemeColors as at, type RelationshipThemeColorValues as au, type ShapeSize as av, type SpacingSize as aw, type TextSize as ax, type ThemeColor as ay, ComputedNode as az, type LikeC4Theme as b, type DeploymentView as b0, type DeploymentViewRule as b1, type DeploymentViewRulePredicate as b2, type DeploymentViewRuleStyle as b3, type DiagramEdge as b4, type DiagramView as b5, type DynamicView as b6, type DynamicViewIncludeRule as b7, type DynamicViewParallelSteps as b8, type DynamicViewRule as b9, type DynamicViewStep as ba, type DynamicViewStepOrParallel as bb, type EdgeId as bc, type ElementView as bd, type ExtendsElementView as be, type NodeId as bf, type ScopedElementView as bg, type StepEdgeId as bh, type StepEdgeIdLiteral as bi, type ViewAutoLayout as bj, type ViewId as bk, type ViewManualLayout as bl, type ViewRule as bm, type ViewRuleAutoLayout as bn, type ViewRuleGlobalPredicateRef as bo, type ViewRuleGlobalStyle as bp, type ViewRuleGroup as bq, type ViewRulePredicate as br, type ViewRuleStyle as bs, type ViewRuleStyleOrGlobalRef as bt, type ViewWithHash as bu, type ViewWithNotation as bv, type ElementNotation as bw, type DeployedInstance as c, type DeploymentElementStyle as d, type DeploymentNode as e, type DeploymentNodeKind as f, type DeploymentNodeKindSpecification as g, type DeploymentRef as h, type DeploymentRelation as i, DefaultElementShape as j, DefaultPaddingSize as k, DefaultShapeSize as l, DefaultTextSize as m, DefaultThemeColor as n, ElementShapes as o, type BorderStyle as p, type Element as q, type ElementKindSpecification as r, type ElementKindSpecificationStyle as s, type ElementShape as t, type ElementStyle as u, type Link as v, type TagSpec as w, type TypedElement as x, ExpressionV2 as y, FqnRef as z };