@likec4/core 1.38.0 → 1.39.0

package/dist/shared/{core.CE_hG7EJ.d.mts → core.aWJgARyY.d.mts}

@@ -1,487 +1,11 @@
 import { Simplify, MergeExclusive, Tagged, NonEmptyTuple, IsNever, IsAny } from 'type-fest';
-import { A as Any, U as Unknown, g as ElementId, P as ProjectId, F as Fqn, s as DeploymentId, u as Tag, y as AllKinds, T as Tags, m as StrictViewId, k as ElementKind, W as WithOptionalTags, z as WithOptionalLinks, e as _stage, f as _type, B as WithMetadata, h as Metadata, R as RelationKind, V as ViewId, p as DeploymentFqn, D as DeploymentKind, j as MetadataKey, E as ExtractOnStage, M as ModelStage, d as UnknownParsed, b as UnknownComputed, c as UnknownLayouted, S as SpecAux, a as Aux, N as Never } from './core.O6FG0HF9.mjs';
-import { E as ExclusiveUnion, N as NonEmptyArray, L as Link, K as KeysOf } from './core.DuSLYTG6.mjs';
-import { M as MarkdownOrString, I as Icon, d as RelationId, T as Tag$1, P as ProjectId$1, N as NodeId, j as EdgeId, m as StepEdgeKind } from './core.DX-WYEPA.mjs';
-import { i as Color, R as RelationshipLineType, f as RelationshipArrowType, c as ElementShape, b as BorderStyle, a as ShapeSize, S as SpacingSize, T as TextSize, h as ThemeColor, C as ColorLiteral, e as CustomColorDefinitions } from './core.CzdwsPmY.mjs';
-
-declare namespace FqnRef {
-    /**
-     * Reference to logical model element
-     */
-    interface ElementRef<A extends Any = Unknown> {
-        project?: never;
-        model: ElementId<A>;
-    }
-    function isElementRef<A extends Any>(ref: FqnRef<A>): ref is ElementRef<A>;
-    /**
-     * Reference to imported logical model element
-     */
-    interface ImportRef<A extends Any = Unknown> {
-        project: ProjectId<A>;
-        model: ElementId<A>;
-    }
-    function isImportRef<A extends Any>(ref: FqnRef<A>): ref is ImportRef<A>;
-    function flatten<A extends Any>(ref: FqnRef<A>): Fqn<A>;
-    type ModelRef<A extends Any = Unknown> = ImportRef<A> | ElementRef<A>;
-    function isModelRef<A extends Any>(ref: FqnRef<A>): ref is ModelRef<A>;
-    /**
-     * Represents a reference to an instance within a deployment.
-     *
-     * @template D - The type representing the deployment fqn. Defaults to `Fqn`.
-     * @template M - The type representing the model fqn. Defaults to `Fqn`.
-     *
-     * @property {D} deployment - TThe fully qualified name (FQN) of the deployed instance.
-     * @property {M} element - The element reference within the deployment.
-     */
-    interface InsideInstanceRef<A extends Any = Unknown> {
-        deployment: DeploymentId<A>;
-        element: ElementId<A>;
-    }
-    function isInsideInstanceRef<A extends Any>(ref: FqnRef<A>): ref is InsideInstanceRef<A>;
-    /**
-     * Represents a reference to a deployment element.
-     *
-     * @template F - The type of the fully qualified name (FQN) of the deployment element. Defaults to `Fqn`.
-     * @property {F} deployment - The fully qualified name (FQN) of the deployment element.
-     */
-    interface DeploymentElementRef<A extends Any> {
-        deployment: DeploymentId<A>;
-        element?: never;
-    }
-    function isDeploymentElementRef<A extends Any>(ref: FqnRef<A>): ref is DeploymentElementRef<A>;
-    type DeploymentRef<A extends Any> = DeploymentElementRef<A> | InsideInstanceRef<A>;
-    function isDeploymentRef<A extends Any>(ref: FqnRef<A>): ref is DeploymentRef<A>;
-}
-type FqnRef<A extends Any = Unknown> = ExclusiveUnion<{
-    DeploymentRef: FqnRef.DeploymentRef<A>;
-    ModelRef: FqnRef.ModelRef<A>;
-}>;
-
-type EqualOperator<V> = {
-    eq: V;
-    neq?: never;
-} | {
-    eq?: never;
-    neq: V;
-};
-type AllNever = {
-    not?: never;
-    and?: never;
-    or?: never;
-    tag?: never;
-    kind?: never;
-    participant?: never;
-    operator?: never;
-};
-type TagEqual<A extends Any> = Omit<AllNever, 'tag'> & {
-    tag: EqualOperator<Tag<A>> | Tag<A>;
-};
-declare function isTagEqual<A extends Any>(operator: WhereOperator<A>): operator is TagEqual<A>;
-type KindEqual<A extends Any> = Omit<AllNever, 'kind'> & {
-    kind: EqualOperator<AllKinds<A>> | AllKinds<A>;
-};
-declare function isKindEqual<A extends Any>(operator: WhereOperator<A>): operator is KindEqual<A>;
-type Participant = 'source' | 'target';
-type ParticipantOperator<A extends Any> = Omit<AllNever, 'participant' | 'operator'> & {
-    participant: Participant;
-    operator: KindEqual<A> | TagEqual<A>;
-};
-declare function isParticipantOperator<A extends Any>(operator: WhereOperator<A>): operator is ParticipantOperator<A>;
-type NotOperator<A extends Any> = Omit<AllNever, 'not'> & {
-    not: WhereOperator<A>;
-};
-declare function isNotOperator<A extends Any>(operator: WhereOperator<A>): operator is NotOperator<A>;
-type AndOperator<A extends Any> = Omit<AllNever, 'and'> & {
-    and: NonEmptyArray<WhereOperator<A>>;
-};
-declare function isAndOperator<A extends Any>(operator: WhereOperator<A>): operator is AndOperator<A>;
-type OrOperator<A extends Any> = Omit<AllNever, 'or'> & {
-    or: NonEmptyArray<WhereOperator<A>>;
-};
-declare function isOrOperator<A extends Any>(operator: WhereOperator<A>): operator is OrOperator<A>;
-type WhereOperator<A extends Any = Any> = TagEqual<A> | KindEqual<A> | ParticipantOperator<A> | NotOperator<A> | AndOperator<A> | OrOperator<A>;
-type Filterable<A extends Any> = {
-    tags?: Tags<A> | null | undefined;
-    kind?: AllKinds<A> | null | undefined;
-    source?: Filterable<A>;
-    target?: Filterable<A>;
-};
-type OperatorPredicate<A extends Any> = (value: Filterable<A>) => boolean;
-declare function whereOperatorAsPredicate<A extends Any>(operator: WhereOperator<A>): OperatorPredicate<A>;
-
-type PredicateSelector = 'children' | 'expanded' | 'descendants';
-declare namespace FqnExpr {
-    type Wildcard = {
-        wildcard: true;
-    };
-    function isWildcard<A extends Any>(expr: Expression<A>): expr is FqnExpr.Wildcard;
-    interface ModelRef<M extends Any = Any> {
-        ref: FqnRef.ModelRef<M>;
-        selector?: PredicateSelector;
-    }
-    function isModelRef<A extends Any>(ref: Expression<A>): ref is FqnExpr.ModelRef<A>;
-    interface DeploymentRef<A extends Any = Any> {
-        ref: FqnRef.DeploymentRef<A>;
-        selector?: PredicateSelector;
-    }
-    function isDeploymentRef<A extends Any>(expr: Expression<A>): expr is FqnExpr.DeploymentRef<A>;
-    interface ElementKindExpr<A extends Any = Any> {
-        elementKind: ElementKind<A>;
-        isEqual: boolean;
-    }
-    function isElementKindExpr<A extends Any>(expr: Expression<A>): expr is ElementKindExpr<A>;
-    interface ElementTagExpr<A extends Any = Any> {
-        elementTag: Tag<A>;
-        isEqual: boolean;
-    }
-    function isElementTagExpr<A extends Any>(expr: Expression<A>): expr is ElementTagExpr<A>;
-    type NonWildcard<A extends Any = Any> = ExclusiveUnion<{
-        ModelRef: ModelRef<A>;
-        DeploymentRef: DeploymentRef<A>;
-        ElementKind: ElementKindExpr<A>;
-        ElementTag: ElementTagExpr<A>;
-    }>;
-    interface Where<A extends Any = Any> {
-        where: {
-            expr: ExclusiveUnion<{
-                Wildcard: Wildcard;
-                ModelRef: ModelRef<A>;
-                DeploymentRef: DeploymentRef<A>;
-                ElementKind: ElementKindExpr<A>;
-                ElementTag: ElementTagExpr<A>;
-            }>;
-            condition: WhereOperator<A>;
-        };
-    }
-    function isWhere<A extends Any>(expr: Expression<A>): expr is FqnExpr.Where<A>;
-    interface Custom<A extends Any = Any> {
-        custom: {
-            expr: OrWhere<A>;
-            title?: string;
-            description?: MarkdownOrString;
-            technology?: string;
-            notation?: string;
-            shape?: ElementShape;
-            color?: Color;
-            icon?: Icon;
-            border?: BorderStyle;
-            opacity?: number;
-            navigateTo?: StrictViewId<A>;
-            multiple?: boolean;
-            size?: ShapeSize;
-            padding?: ShapeSize;
-            textSize?: ShapeSize;
-        };
-    }
-    function isCustom<A extends Any>(expr: Expression<A>): expr is Custom<A>;
-    function is<A extends Any>(expr: Expression<A>): expr is FqnExpr<A>;
-    type OrWhere<A extends Any = Any> = ExclusiveUnion<{
-        Wildcard: FqnExpr.Wildcard;
-        ModelRef: FqnExpr.ModelRef<A>;
-        DeploymentRef: FqnExpr.DeploymentRef<A>;
-        ElementKind: ElementKindExpr<A>;
-        ElementTag: ElementTagExpr<A>;
-        Where: FqnExpr.Where<A>;
-    }>;
-    type Any<A extends Any = Any> = ExclusiveUnion<{
-        Wildcard: Wildcard;
-        ModelRef: ModelRef<A>;
-        DeploymentRef: DeploymentRef<A>;
-        ElementKind: ElementKindExpr<A>;
-        ElementTag: ElementTagExpr<A>;
-        Where: Where<A>;
-        Custom: Custom<A>;
-    }>;
-    function unwrap<A extends Any>(expr: FqnExpr.Any<A>): Wildcard | ModelRef<A> | DeploymentRef<A> | ElementKindExpr<A> | ElementTagExpr<A>;
-}
-type FqnExpr<A extends Any = Any> = ExclusiveUnion<{
-    Wildcard: FqnExpr.Wildcard;
-    ModelRef: FqnExpr.ModelRef<A>;
-    DeploymentRef: FqnExpr.DeploymentRef<A>;
-    ElementKind: FqnExpr.ElementKindExpr<A>;
-    ElementTag: FqnExpr.ElementTagExpr<A>;
-}>;
-declare namespace RelationExpr {
-    type Endpoint<A extends Any = Any> = FqnExpr.Where<A>['where']['expr'];
-    interface Direct<A extends Any = Any> {
-        source: Endpoint<A>;
-        target: Endpoint<A>;
-        isBidirectional?: boolean;
-    }
-    function isDirect<A extends Any>(expr: Expression<A>): expr is RelationExpr.Direct<A>;
-    interface Incoming<A extends Any = Any> {
-        incoming: Endpoint<A>;
-    }
-    function isIncoming<A extends Any>(expr: Expression<A>): expr is RelationExpr.Incoming<A>;
-    interface Outgoing<A extends Any = Any> {
-        outgoing: Endpoint<A>;
-    }
-    function isOutgoing<A extends Any>(expr: Expression<A>): expr is RelationExpr.Outgoing<A>;
-    interface InOut<A extends Any = Any> {
-        inout: Endpoint<A>;
-    }
-    function isInOut<A extends Any>(expr: Expression<A>): expr is RelationExpr.InOut<A>;
-    interface Where<A extends Any = Any> {
-        where: {
-            expr: ExclusiveUnion<{
-                Direct: RelationExpr.Direct<A>;
-                Incoming: RelationExpr.Incoming<A>;
-                Outgoing: RelationExpr.Outgoing<A>;
-                InOut: RelationExpr.InOut<A>;
-            }>;
-            condition: WhereOperator<A>;
-        };
-    }
-    function isWhere<A extends Any>(expr: Expression<A>): expr is RelationExpr.Where<A>;
-    interface Custom<A extends Any = Any> {
-        customRelation: {
-            expr: OrWhere<A>;
-            title?: string;
-            description?: string;
-            technology?: string;
-            notation?: string;
-            navigateTo?: StrictViewId<A>;
-            notes?: string;
-            color?: Color;
-            line?: RelationshipLineType;
-            head?: RelationshipArrowType;
-            tail?: RelationshipArrowType;
-        };
-    }
-    function isCustom<A extends Any>(expr: Expression<A>): expr is Custom<A>;
-    function is<A extends Any>(expr: Expression<A>): expr is RelationExpr<A>;
-    type OrWhere<A extends Any = Any> = ExclusiveUnion<{
-        Direct: Direct<A>;
-        Incoming: Incoming<A>;
-        Outgoing: Outgoing<A>;
-        InOut: InOut<A>;
-        Where: Where<A>;
-    }>;
-    type Any<A extends Any = Any> = ExclusiveUnion<{
-        Direct: Direct<A>;
-        Incoming: Incoming<A>;
-        Outgoing: Outgoing<A>;
-        InOut: InOut<A>;
-        Where: Where<A>;
-        Custom: Custom<A>;
-    }>;
-    function unwrap<A extends Any>(expr: RelationExpr.Any<A>): Direct<A> | Incoming<A> | Outgoing<A> | InOut<A>;
-}
-type RelationExpr<A extends Any = Any> = ExclusiveUnion<{
-    Direct: RelationExpr.Direct<A>;
-    Incoming: RelationExpr.Incoming<A>;
-    Outgoing: RelationExpr.Outgoing<A>;
-    InOut: RelationExpr.InOut<A>;
-}>;
-/**
- * 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 Expression<A extends Any = Any> = ExclusiveUnion<{
-    Wildcard: FqnExpr.Wildcard;
-    ModelRef: FqnExpr.ModelRef<A>;
-    DeploymentRef: FqnExpr.DeploymentRef<A>;
-    ElementKind: FqnExpr.ElementKindExpr<A>;
-    ElementTag: FqnExpr.ElementTagExpr<A>;
-    Custom: FqnExpr.Custom<A>;
-    Direct: RelationExpr.Direct<A>;
-    Incoming: RelationExpr.Incoming<A>;
-    Outgoing: RelationExpr.Outgoing<A>;
-    InOut: RelationExpr.InOut<A>;
-    Where: Expression.Where<A>;
-    CustomRelation: RelationExpr.Custom<A>;
-}>;
-declare namespace Expression {
-    type Where<A extends Any = Any> = FqnExpr.Where<A> | RelationExpr.Where<A>;
-    function isWhere<A extends Any>(expr: Expression<A>): expr is Expression.Where<A>;
-    function isRelationWhere<A extends Any>(expr: Expression<A>): expr is RelationExpr.Where<A>;
-    function isFqnExprWhere<A extends Any>(expr: Expression<A>): expr is FqnExpr.Where<A>;
-    function isFqnExpr<A extends Any>(expr: Expression<A>): expr is FqnExpr.Any<A>;
-    function isRelation<A extends Any>(expr: Expression<A>): expr is RelationExpr.Any<A>;
-}
-
-declare namespace ModelFqnExpr {
-    type Wildcard = {
-        wildcard: true;
-    };
-    function isWildcard<A extends Any>(expr: ModelExpression<A>): expr is ModelFqnExpr.Wildcard;
-    interface Ref<M extends Any> {
-        ref: FqnRef.ModelRef<M>;
-        selector?: PredicateSelector;
-    }
-    function isModelRef<A extends Any>(ref: ModelExpression<A>): ref is ModelFqnExpr.Ref<A>;
-    interface ElementKindExpr<A extends Any = Any> {
-        elementKind: ElementKind<A>;
-        isEqual: boolean;
-    }
-    function isElementKindExpr<A extends Any>(expr: ModelExpression<A>): expr is ElementKindExpr<A>;
-    interface ElementTagExpr<A extends Any> {
-        elementTag: Tag<A>;
-        isEqual: boolean;
-    }
-    function isElementTagExpr<A extends Any>(expr: ModelExpression<A>): expr is ElementTagExpr<A>;
-    type NonWildcard<A extends Any = Any> = ExclusiveUnion<{
-        Ref: Ref<A>;
-        ElementKind: ElementKindExpr<A>;
-        ElementTag: ElementTagExpr<A>;
-    }>;
-    interface Where<A extends Any = Any> {
-        where: {
-            expr: ExclusiveUnion<{
-                Wildcard: Wildcard;
-                Ref: Ref<A>;
-                ElementKind: ElementKindExpr<A>;
-                ElementTag: ElementTagExpr<A>;
-            }>;
-            condition: WhereOperator<A>;
-        };
-    }
-    function isWhere<A extends Any>(expr: ModelExpression<A>): expr is ModelFqnExpr.Where<A>;
-    interface Custom<A extends Any = Any> {
-        custom: {
-            expr: OrWhere<A>;
-            title?: string;
-            description?: MarkdownOrString;
-            technology?: string;
-            notation?: string;
-            shape?: ElementShape;
-            color?: Color;
-            icon?: Icon;
-            border?: BorderStyle;
-            opacity?: number;
-            navigateTo?: StrictViewId<A>;
-            multiple?: boolean;
-            size?: ShapeSize;
-            padding?: ShapeSize;
-            textSize?: ShapeSize;
-        };
-    }
-    function isCustom<A extends Any>(expr: ModelExpression<A>): expr is Custom<A>;
-    function is<A extends Any>(expr: ModelExpression<A>): expr is ModelFqnExpr<A>;
-    type OrWhere<A extends Any = Any> = ExclusiveUnion<{
-        Wildcard: ModelFqnExpr.Wildcard;
-        Ref: ModelFqnExpr.Ref<A>;
-        ElementKind: ElementKindExpr<A>;
-        ElementTag: ElementTagExpr<A>;
-        Where: ModelFqnExpr.Where<A>;
-    }>;
-    type Any<A extends Any = Any> = ExclusiveUnion<{
-        Wildcard: Wildcard;
-        Ref: Ref<A>;
-        ElementKind: ElementKindExpr<A>;
-        ElementTag: ElementTagExpr<A>;
-        Where: Where<A>;
-        Custom: Custom<A>;
-    }>;
-    function unwrap<A extends Any>(expr: ModelFqnExpr.Any<A>): Wildcard | Ref<A> | ElementKindExpr<A> | ElementTagExpr<A>;
-}
-type ModelFqnExpr<A extends Any = Any> = ExclusiveUnion<{
-    Wildcard: ModelFqnExpr.Wildcard;
-    Ref: ModelFqnExpr.Ref<A>;
-    ElementKind: ModelFqnExpr.ElementKindExpr<A>;
-    ElementTag: ModelFqnExpr.ElementTagExpr<A>;
-}>;
-declare namespace ModelRelationExpr {
-    type Endpoint<A extends Any = Any> = ModelFqnExpr.Where<A>['where']['expr'];
-    interface Direct<A extends Any = Any> {
-        source: Endpoint<A>;
-        target: Endpoint<A>;
-        isBidirectional?: boolean;
-    }
-    function isDirect<A extends Any>(expr: ModelExpression<A>): expr is ModelRelationExpr.Direct<A>;
-    interface Incoming<A extends Any = Any> {
-        incoming: Endpoint<A>;
-    }
-    function isIncoming<A extends Any>(expr: ModelExpression<A>): expr is ModelRelationExpr.Incoming<A>;
-    interface Outgoing<A extends Any = Any> {
-        outgoing: Endpoint<A>;
-    }
-    function isOutgoing<A extends Any>(expr: ModelExpression<A>): expr is ModelRelationExpr.Outgoing<A>;
-    interface InOut<A extends Any = Any> {
-        inout: Endpoint<A>;
-    }
-    function isInOut<A extends Any>(expr: ModelExpression<A>): expr is ModelRelationExpr.InOut<A>;
-    interface Where<A extends Any = Any> {
-        where: {
-            expr: ExclusiveUnion<{
-                Direct: ModelRelationExpr.Direct<A>;
-                Incoming: ModelRelationExpr.Incoming<A>;
-                Outgoing: ModelRelationExpr.Outgoing<A>;
-                InOut: ModelRelationExpr.InOut<A>;
-            }>;
-            condition: WhereOperator<A>;
-        };
-    }
-    function isWhere<A extends Any>(expr: ModelExpression<A>): expr is ModelRelationExpr.Where<A>;
-    interface Custom<A extends Any = Any> {
-        customRelation: {
-            expr: OrWhere<A>;
-            title?: string;
-            description?: string;
-            technology?: string;
-            notation?: string;
-            navigateTo?: StrictViewId<A>;
-            notes?: string;
-            color?: Color;
-            line?: RelationshipLineType;
-            head?: RelationshipArrowType;
-            tail?: RelationshipArrowType;
-        };
-    }
-    function isCustom<A extends Any>(expr: ModelExpression<A>): expr is Custom<A>;
-    function is<A extends Any>(expr: ModelExpression<A>): expr is ModelRelationExpr<A>;
-    type OrWhere<A extends Any = Any> = ExclusiveUnion<{
-        Direct: Direct<A>;
-        Incoming: Incoming<A>;
-        Outgoing: Outgoing<A>;
-        InOut: InOut<A>;
-        Where: Where<A>;
-    }>;
-    type Any<A extends Any = Any> = ExclusiveUnion<{
-        Direct: Direct<A>;
-        Incoming: Incoming<A>;
-        Outgoing: Outgoing<A>;
-        InOut: InOut<A>;
-        Where: Where<A>;
-        Custom: Custom<A>;
-    }>;
-    function unwrap<A extends Any>(expr: ModelRelationExpr.Any<A>): Direct<A> | Incoming<A> | Outgoing<A> | InOut<A>;
-}
-type ModelRelationExpr<A extends Any = Any> = ExclusiveUnion<{
-    Direct: ModelRelationExpr.Direct<A>;
-    Incoming: ModelRelationExpr.Incoming<A>;
-    Outgoing: ModelRelationExpr.Outgoing<A>;
-    InOut: ModelRelationExpr.InOut<A>;
-}>;
-/**
- * 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 Any = Any> = ExclusiveUnion<{
-    Wildcard: ModelFqnExpr.Wildcard;
-    Ref: ModelFqnExpr.Ref<A>;
-    ElementKind: ModelFqnExpr.ElementKindExpr<A>;
-    ElementTag: ModelFqnExpr.ElementTagExpr<A>;
-    Custom: ModelFqnExpr.Custom<A>;
-    Direct: ModelRelationExpr.Direct<A>;
-    Incoming: ModelRelationExpr.Incoming<A>;
-    Outgoing: ModelRelationExpr.Outgoing<A>;
-    InOut: ModelRelationExpr.InOut<A>;
-    Where: ModelExpression.Where<A>;
-    CustomRelation: ModelRelationExpr.Custom<A>;
-}>;
-declare namespace ModelExpression {
-    type Where<A extends Any = Any> = ModelFqnExpr.Where<A> | ModelRelationExpr.Where<A>;
-    function isWhere<A extends Any>(expr: ModelExpression<A>): expr is ModelExpression.Where<A>;
-    function isRelationWhere<A extends Any>(expr: ModelExpression<A>): expr is ModelRelationExpr.Where<A>;
-    function isFqnExprWhere<A extends Any>(expr: ModelExpression<A>): expr is ModelFqnExpr.Where<A>;
-    function isFqnExpr<A extends Any>(expr: ModelExpression<A>): expr is ModelFqnExpr.Any<A>;
-    function isRelationExpr<A extends Any>(expr: ModelExpression<A>): expr is ModelRelationExpr.Any<A>;
-}
+import { A as Any, W as WithOptionalTags, z as WithOptionalLinks, g as StrictViewId, e as _stage, f as _type, F as Fqn, B as WithMetadata, h as ElementKind, l as Tags, m as Metadata, R as RelationKind, V as ViewId, U as Unknown, s as DeploymentFqn, o as DeploymentKind, T as Tag, n as MetadataKey, E as ExtractOnStage, M as ModelStage, P as ProjectId$1, j as ElementId, D as DeploymentId, d as UnknownParsed, b as UnknownComputed, c as UnknownLayouted, S as SpecAux, a as Aux, N as Never } from './core.DdzRtJ9d.mjs';
+import { N as NonEmptyArray, E as ExclusiveUnion, L as Link, K as KeysOf } from './core.DuSLYTG6.mjs';
+import { ModelExpression, ModelFqnExpr } from '../types/expression-model.mjs';
+import { I as Icon, M as MarkdownOrString, d as RelationId, T as Tag$1, P as ProjectId, N as NodeId, j as EdgeId, m as StepEdgeKind } from './core.DX-WYEPA.mjs';
+import { b as BorderStyle, a as ShapeSize, S as SpacingSize, T as TextSize, i as Color, c as ElementShape, R as RelationshipLineType, f as RelationshipArrowType, h as ThemeColor, C as ColorLiteral, e as CustomColorDefinitions } from './core.CzdwsPmY.mjs';
+import { FqnRef } from '../types/fqnRef.mjs';
+import { E as Expression, F as FqnExpr } from './core.20m8Um0g.mjs';
 
 type Point = readonly [x: number, y: number];
 interface XYPoint {
@@ -907,7 +431,7 @@ interface LikeC4Project {
     /**
      * ID of the project, casted to {@link scalar.ProjectId}
      */
-    readonly id: ProjectId$1;
+    readonly id: ProjectId;
     title?: string;
 }
 
@@ -1119,7 +643,7 @@ declare function isDeploymentView<V extends AnyView<any>>(view: V): view is View
 declare function isDynamicView<V extends AnyView<any>>(view: V): view is ViewWithType<V, 'dynamic'>;
 
 interface BaseLikeC4ModelData<A extends Any> {
-    projectId: ProjectId<A>;
+    projectId: ProjectId$1<A>;
     project: LikeC4Project;
     specification: Specification<A>;
     elements: Record<ElementId<A>, Element<A>>;
@@ -1294,4 +818,4 @@ declare class RichText {
     equals(other: unknown): boolean;
 }
 
-export { type ElementSpecification as $, type AuxFromLikeC4ModelData as A, BBox as B, type ComputedLikeC4ModelData as C, type DeploymentElementStyle as D, Expression as E, FqnExpr as F, type GlobalPredicateId as G, type AuxFromDump as H, DefaultThemeColor as I, DefaultElementShape as J, DefaultShapeSize as K, type LayoutedLikeC4ModelData as L, ModelFqnExpr as M, DefaultPaddingSize as N, DefaultTextSize as O, type PredicateSelector as P, type ElementStyle as Q, RichText as R, type SpecificationDump as S, type Element as T, DefaultLineStyle as U, DefaultArrowType as V, DefaultRelationshipColor as W, type XYPoint as X, type AbstractRelationship as Y, type Relationship as Z, type ModelRelation as _, type RichTextEmpty as a, type ComputedDeploymentView as a$, type TagSpecification as a0, isTagColorSpecified as a1, type RelationshipSpecification as a2, type Specification as a3, type EqualOperator as a4, type TagEqual as a5, isTagEqual as a6, type KindEqual as a7, isKindEqual as a8, type Participant as a9, isElementView as aA, isScopedElementView as aB, isExtendsElementView as aC, isDeploymentView as aD, isDynamicView as aE, type AnyIncludePredicate as aF, type AnyExcludePredicate as aG, type AnyViewRuleStyle as aH, type ViewRuleGlobalStyle as aI, isViewRuleGlobalStyle as aJ, type ViewRuleGlobalPredicateRef as aK, isViewRuleGlobalPredicateRef as aL, type AutoLayoutDirection as aM, isAutoLayoutDirection as aN, type ViewRuleAutoLayout as aO, isViewRuleAutoLayout as aP, type ViewAutoLayout as aQ, type ViewManualLayout as aR, type ViewType as aS, type BaseViewProperties as aT, type BaseParsedViewProperties as aU, type NodeNotation as aV, type ViewWithNotation as aW, type ViewWithHash as aX, type ComputedNode as aY, type ComputedEdge as aZ, type ComputedElementView as a_, type ParticipantOperator as aa, isParticipantOperator as ab, type NotOperator as ac, isNotOperator as ad, type AndOperator as ae, isAndOperator as af, type OrOperator as ag, isOrOperator as ah, type WhereOperator as ai, type Filterable as aj, type OperatorPredicate as ak, whereOperatorAsPredicate as al, type LikeC4Project as am, type ParsedView as an, type LayoutedView as ao, isDiagramView as ap, type ComputedView as aq, type ProcessedView as ar, type AnyView as as, type ViewOnStage as at, type ViewWithType as au, type ViewRule as av, type ViewRulePredicate as aw, isViewRulePredicate as ax, isViewRuleStyle as ay, isComputedView as az, type RichTextOrEmpty as b, type ComputedDynamicView as b0, type DiagramNode as b1, type DiagramEdge as b2, type LayoutedElementView as b3, type LayoutedDeploymentView as b4, type LayoutedDynamicView as b5, type DeploymentViewIncludePredicate as b6, type DeploymentViewExcludePredicate as b7, type DeploymentViewPredicate as b8, type DeploymentViewRuleStyle as b9, type DeploymentViewRule as ba, type ParsedDeploymentView as bb, type DynamicViewStep as bc, type DynamicViewParallelSteps as bd, getParallelStepsPrefix as be, type DynamicViewStepOrParallel as bf, type DynamicViewIncludeRule as bg, type DynamicViewRule as bh, type ParsedDynamicView as bi, isDynamicViewParallelSteps as bj, type ElementViewIncludePredicate as bk, type ElementViewExcludePredicate as bl, type ElementViewPredicate as bm, type ElementViewRuleGroup as bn, isViewRuleGroup as bo, type ElementViewRuleStyle as bp, type ElementViewRule as bq, type ParsedElementView as br, RelationExpr as c, ModelRelationExpr as d, ModelExpression as e, FqnRef as f, type Point as g, RectBox as h, type GlobalPredicates as i, type GlobalDynamicPredicates as j, type GlobalStyleID as k, type GlobalStyles as l, type ModelGlobals as m, type ParsedLikeC4ModelData as n, type LikeC4ModelData as o, type DeploymentNode as p, type DeployedInstance as q, type DeploymentElement as r, type DeploymentElementRef as s, isDeploymentNode as t, isDeployedInstance as u, type DeploymentRelationship as v, type DeploymentRelation as w, type SpecTypesFromDump as x, type LikeC4ModelDump as y, type ProjectDump as z };
+export { isDiagramView as $, type AuxFromLikeC4ModelData as A, BBox as B, type ComputedLikeC4ModelData as C, type DeploymentElementStyle as D, type ElementStyle as E, type Element as F, type GlobalPredicateId as G, DefaultLineStyle as H, DefaultArrowType as I, DefaultRelationshipColor as J, type AbstractRelationship as K, type LayoutedLikeC4ModelData as L, type ModelGlobals as M, type Relationship as N, type ModelRelation as O, type Point as P, type ElementSpecification as Q, RichText as R, type SpecificationDump as S, type TagSpecification as T, isTagColorSpecified as U, type RelationshipSpecification as V, type Specification as W, type XYPoint as X, type LikeC4Project as Y, type ParsedView as Z, type LayoutedView as _, type RichTextEmpty as a, type ElementViewRuleStyle as a$, type ComputedView as a0, type ProcessedView as a1, type AnyView as a2, type ViewOnStage as a3, type ViewWithType as a4, type ViewRule as a5, type ViewRulePredicate as a6, isViewRulePredicate as a7, isViewRuleStyle as a8, isComputedView as a9, type ComputedElementView as aA, type ComputedDeploymentView as aB, type ComputedDynamicView as aC, type DiagramNode as aD, type DiagramEdge as aE, type LayoutedElementView as aF, type LayoutedDeploymentView as aG, type LayoutedDynamicView as aH, type DeploymentViewIncludePredicate as aI, type DeploymentViewExcludePredicate as aJ, type DeploymentViewPredicate as aK, type DeploymentViewRuleStyle as aL, type DeploymentViewRule as aM, type ParsedDeploymentView as aN, type DynamicViewStep as aO, type DynamicViewParallelSteps as aP, getParallelStepsPrefix as aQ, type DynamicViewStepOrParallel as aR, type DynamicViewIncludeRule as aS, type DynamicViewRule as aT, type ParsedDynamicView as aU, isDynamicViewParallelSteps as aV, type ElementViewIncludePredicate as aW, type ElementViewExcludePredicate as aX, type ElementViewPredicate as aY, type ElementViewRuleGroup as aZ, isViewRuleGroup as a_, isElementView as aa, isScopedElementView as ab, isExtendsElementView as ac, isDeploymentView as ad, isDynamicView as ae, type AnyIncludePredicate as af, type AnyExcludePredicate as ag, type AnyViewRuleStyle as ah, type ViewRuleGlobalStyle as ai, isViewRuleGlobalStyle as aj, type ViewRuleGlobalPredicateRef as ak, isViewRuleGlobalPredicateRef as al, type AutoLayoutDirection as am, isAutoLayoutDirection as an, type ViewRuleAutoLayout as ao, isViewRuleAutoLayout as ap, type ViewAutoLayout as aq, type ViewManualLayout as ar, type ViewType as as, type BaseViewProperties as at, type BaseParsedViewProperties as au, type NodeNotation as av, type ViewWithNotation as aw, type ViewWithHash as ax, type ComputedNode as ay, type ComputedEdge as az, type RichTextOrEmpty as b, type ElementViewRule as b0, type ParsedElementView as b1, RectBox as c, type GlobalPredicates as d, type GlobalDynamicPredicates as e, type GlobalStyleID as f, type GlobalStyles as g, type ParsedLikeC4ModelData as h, type LikeC4ModelData as i, type DeploymentNode as j, type DeployedInstance as k, type DeploymentElement as l, type DeploymentElementRef as m, isDeploymentNode as n, isDeployedInstance as o, type DeploymentRelationship as p, type DeploymentRelation as q, type SpecTypesFromDump as r, type LikeC4ModelDump as s, type ProjectDump as t, type AuxFromDump as u, DefaultThemeColor as v, DefaultElementShape as w, DefaultShapeSize as x, DefaultPaddingSize as y, DefaultTextSize as z };

package/dist/shared/{core.BvlHvikl.d.mts → core.v1iEaXaR.d.mts}

@@ -1,17 +1,19 @@
-import { A as Any, R as RelationKind, T as Tags, h as Metadata, j as MetadataKey, L as LooseTag, F as Fqn, g as ElementId, k as ElementKind, D as DeploymentKind, E as ExtractOnStage, l as RelationId$1, m as StrictViewId, f as _type, n as LooseElementId, o as LooseDeploymentId, p as DeploymentFqn, t as toComputed, q as toLayouted, r as Stage, s as DeploymentId, U as Unknown, V as ViewId, u as Tag, v as toParsed, P as ProjectId$1, w as LooseViewId, a as Aux, S as SpecAux, d as UnknownParsed, b as UnknownComputed, c as UnknownLayouted } from './core.O6FG0HF9.mjs';
+import { A as Any, R as RelationKind, l as Tags, m as Metadata, n as MetadataKey, L as LooseTag, F as Fqn, j as ElementId, h as ElementKind, o as DeploymentKind, E as ExtractOnStage, p as RelationId$1, g as StrictViewId, f as _type, q as LooseElementId, r as LooseDeploymentId, s as DeploymentFqn, t as toComputed, u as toLayouted, v as Stage, D as DeploymentId, U as Unknown, V as ViewId, T as Tag, w as toParsed, P as ProjectId$1, x as LooseViewId, a as Aux, S as SpecAux, d as UnknownParsed, b as UnknownComputed, c as UnknownLayouted } from './core.DdzRtJ9d.mjs';
 import { d as RelationId, P as ProjectId, a as IconUrl, N as NodeId, G as GroupElementKind, j as EdgeId, k as StepEdgeId, V as ViewId$1 } from './core.DX-WYEPA.mjs';
 import { D as DefaultMap } from './core.CywrQs86.mjs';
 import { SetRequired } from 'type-fest';
-import { b as RichTextOrEmpty, Z as Relationship, T as Element, Q as ElementStyle, au as ViewWithType, aq as ComputedView, ao as LayoutedView, n as ParsedLikeC4ModelData, C as ComputedLikeC4ModelData, L as LayoutedLikeC4ModelData, f as FqnRef, q as DeployedInstance, D as DeploymentElementStyle, v as DeploymentRelationship, r as DeploymentElement, p as DeploymentNode, y as LikeC4ModelDump, H as AuxFromDump, am as LikeC4Project, a3 as Specification, m as ModelGlobals, ai as WhereOperator } from './core.CE_hG7EJ.mjs';
+import { b as RichTextOrEmpty, N as Relationship, F as Element, E as ElementStyle, a4 as ViewWithType, a0 as ComputedView, _ as LayoutedView, h as ParsedLikeC4ModelData, C as ComputedLikeC4ModelData, L as LayoutedLikeC4ModelData, k as DeployedInstance, D as DeploymentElementStyle, p as DeploymentRelationship, l as DeploymentElement, j as DeploymentNode, s as LikeC4ModelDump, u as AuxFromDump, Y as LikeC4Project, W as Specification, M as ModelGlobals } from './core.aWJgARyY.mjs';
 import { I as IteratorLike, L as Link, N as NonEmptyArray } from './core.DuSLYTG6.mjs';
 import { i as Color, R as RelationshipLineType, c as ElementShape } from './core.CzdwsPmY.mjs';
+import { W as WhereOperator } from './core.20m8Um0g.mjs';
+import { FqnRef } from '../types/fqnRef.mjs';
 
 type RelationshipsIterator<A extends Any> = IteratorLike<RelationshipModel<A>>;
 /**
  * A relationship between two elements (in logical or deployment model)
  * use {@link isDeploymentRelationModel} guard to check if the relationship is a deployment relationship
  */
-interface AnyRelationshipModel<A extends Any> extends WithTags<A>, WithMetadata<A> {
+interface AnyRelationshipModel<A extends Any = Any> extends WithTags<A>, WithMetadata<A> {
     readonly id: RelationId;
     readonly expression: string;
     readonly title: string | null;

package/dist/shared/core.yHe79zEl.mjs

@@ -0,0 +1,98 @@
+import { isTruthy, anyPass, allPass, isNot, isString, isNullish } from 'remeda';
+import { n as nonexhaustive } from './core.D4npX2q8.mjs';
+
+function isOnStage(value, stage) {
+  return value[_stage] === stage;
+}
+const _stage = "_stage";
+const _type = "_type";
+
+function isDeploymentNode(el) {
+  return "kind" in el && !isTruthy(el.element);
+}
+function isDeployedInstance(el) {
+  return "element" in el && isTruthy(el.element);
+}
+
+function isTagEqual(operator) {
+  return "tag" in operator;
+}
+function isKindEqual(operator) {
+  return "kind" in operator;
+}
+function isParticipantOperator(operator) {
+  return "participant" in operator;
+}
+function isNotOperator(operator) {
+  return "not" in operator;
+}
+function isAndOperator(operator) {
+  return "and" in operator;
+}
+function isOrOperator(operator) {
+  return "or" in operator;
+}
+function whereOperatorAsPredicate(operator) {
+  switch (true) {
+    case isParticipantOperator(operator): {
+      const participant = operator.participant;
+      const participantPredicate = whereOperatorAsPredicate(operator.operator);
+      return participantIs(participant, participantPredicate);
+    }
+    case isTagEqual(operator): {
+      if (isString(operator.tag) || "eq" in operator.tag) {
+        const tag2 = isString(operator.tag) ? operator.tag : operator.tag.eq;
+        return (value) => {
+          return Array.isArray(value.tags) && value.tags.includes(tag2);
+        };
+      }
+      const tag = operator.tag.neq;
+      return (value) => {
+        return !Array.isArray(value.tags) || !value.tags.includes(tag);
+      };
+    }
+    case isKindEqual(operator): {
+      if (isString(operator.kind) || "eq" in operator.kind) {
+        const kind2 = isString(operator.kind) ? operator.kind : operator.kind.eq;
+        return (value) => {
+          return value.kind === kind2;
+        };
+      }
+      const kind = operator.kind.neq;
+      return (value) => {
+        return isNullish(value.kind) || value.kind !== kind;
+      };
+    }
+    case isNotOperator(operator): {
+      const predicate = whereOperatorAsPredicate(operator.not);
+      return isNot(predicate);
+    }
+    case isAndOperator(operator): {
+      const predicates = operator.and.map(whereOperatorAsPredicate);
+      return allPass(predicates);
+    }
+    case isOrOperator(operator): {
+      const predicates = operator.or.map(whereOperatorAsPredicate);
+      return anyPass(predicates);
+    }
+    default:
+      nonexhaustive(operator);
+  }
+}
+function participantIs(participant, predicate) {
+  return (value) => {
+    if (!value.source || !value.target) {
+      return false;
+    }
+    switch (participant) {
+      case "source": {
+        return predicate(value.source);
+      }
+      case "target": {
+        return predicate(value.target);
+      }
+    }
+  };
+}
+
+export { _stage as _, _type as a, isDeploymentNode as b, isDeployedInstance as c, isTagEqual as d, isKindEqual as e, isParticipantOperator as f, isNotOperator as g, isAndOperator as h, isOnStage as i, isOrOperator as j, whereOperatorAsPredicate as w };