@likec4/core 1.31.0 → 1.32.0

package/dist/shared/core.Dpq3P3YJ.d.mts

@@ -0,0 +1,1265 @@
+import { TupleToUnion, Tagged, Simplify, MergeExclusive, NonEmptyTuple, IsNever, IsAny } from 'type-fest';
+import { f as ExclusiveUnion, d as NonEmptyArray, i as Icon, L as Link, R as RelationId, T as Tag$1, N as NodeId, E as EdgeId, r as StepEdgeKind, K as KeysOf } from './core.BuO4ncfY.mjs';
+import { A as Any, U as Unknown, g as ElementId, P as ProjectId, F as Fqn, u as DeploymentId, v as Tag, y as AllKinds, T as Tags, n as StrictViewId, l as ElementKind, W as WithOptionalTags, z as WithOptionalLinks, _ as _stage, f as _type, B as WithMetadata, j as Metadata, R as RelationKind, V as ViewId, q as DeploymentFqn, D as DeploymentKind, k as MetadataKey, E as ExtractOnStage, M as ModelStage, e as UnknownParsed, c as UnknownComputed, d as UnknownLayouted, S as SpecAux, b as Aux, N as Never } from './core.BaYE_r29.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>;
+
+/**
+ * For padding, margin, etc.
+ */
+type SpacingSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+type TextSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+type ShapeSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+declare const BorderStyles: readonly ["solid", "dashed", "dotted", "none"];
+type BorderStyle = TupleToUnion<typeof BorderStyles>;
+declare const ElementShapes: readonly ["rectangle", "person", "browser", "mobile", "cylinder", "storage", "queue"];
+type ElementShape = TupleToUnion<typeof ElementShapes>;
+type HexColor = `#${string}`;
+type Comma = ',' | ', ';
+type ColorLiteral = HexColor | `rgb(${number}${Comma}${number}${Comma}${number})` | `rgba(${number}${Comma}${number}${Comma}${number}${Comma}${number})`;
+type CustomColor<T = string> = Tagged<T, 'CustomColor'>;
+type CustomColorDefinitions = {
+    [key: string]: ThemeColorValues;
+};
+type RelationshipLineType = 'dashed' | 'solid' | 'dotted';
+type RelationshipArrowType = 'none' | 'normal' | 'onormal' | 'dot' | 'odot' | 'diamond' | 'odiamond' | 'crow' | 'open' | 'vee';
+declare const ThemeColors: readonly ["amber", "blue", "gray", "slate", "green", "indigo", "muted", "primary", "red", "secondary", "sky"];
+type ThemeColor = typeof ThemeColors[number];
+/**
+ * Backward compatibility alias
+ * @deprecated Use {@link ThemeColor} instead
+ */
+type Color = ThemeColor | HexColor;
+declare function isThemeColor(color: string): color is ThemeColor;
+interface ElementThemeColorValues {
+    fill: HexColor;
+    stroke: HexColor;
+    hiContrast: HexColor;
+    loContrast: HexColor;
+}
+type ElementThemeColors = {
+    [key in ThemeColor]: ElementThemeColorValues;
+};
+interface RelationshipThemeColorValues {
+    lineColor: HexColor;
+    labelBgColor: HexColor;
+    labelColor: HexColor;
+}
+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;
+    };
+}
+
+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?: string;
+            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?: string;
+            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>;
+}
+
+type Point = readonly [x: number, y: number];
+interface XYPoint {
+    x: number;
+    y: number;
+}
+interface BBox {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+declare namespace BBox {
+    function center({ x, y, width, height }: BBox): XYPoint;
+    function fromPoints(points: Point[]): BBox;
+    function merge(...boxes: BBox[]): BBox;
+    function toRectBox(box: BBox): RectBox;
+}
+interface RectBox {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+}
+declare namespace RectBox {
+    function center({ x1, y1, x2, y2 }: RectBox): XYPoint;
+    function fromPoints(points: Point[]): RectBox;
+    function merge(...boxes: RectBox[]): RectBox;
+    function toBBox(box: RectBox): BBox;
+}
+
+interface AnyIncludePredicate<Expr> {
+    include: Expr[];
+    exclude?: never;
+}
+interface AnyExcludePredicate<Expr> {
+    include?: never;
+    exclude: Expr[];
+}
+interface AnyViewRuleStyle<Expr> {
+    targets: Expr[];
+    notation?: string;
+    style: {
+        border?: BorderStyle;
+        opacity?: number;
+        multiple?: boolean;
+        size?: ShapeSize;
+        padding?: SpacingSize;
+        textSize?: TextSize;
+        color?: Color;
+        shape?: ElementShape;
+        icon?: Icon;
+    };
+}
+interface ViewRuleGlobalStyle {
+    styleId: GlobalStyleID;
+}
+declare function isViewRuleGlobalStyle(rule: object): rule is ViewRuleGlobalStyle;
+interface ViewRuleGlobalPredicateRef {
+    predicateId: GlobalPredicateId;
+}
+declare function isViewRuleGlobalPredicateRef(rule: object): rule is ViewRuleGlobalPredicateRef;
+type AutoLayoutDirection = 'TB' | 'BT' | 'LR' | 'RL';
+declare function isAutoLayoutDirection(autoLayout: unknown): autoLayout is AutoLayoutDirection;
+interface ViewRuleAutoLayout {
+    direction: AutoLayoutDirection;
+    nodeSep?: number;
+    rankSep?: number;
+}
+declare function isViewRuleAutoLayout(rule: object): rule is ViewRuleAutoLayout;
+interface ViewAutoLayout {
+    direction: ViewRuleAutoLayout['direction'];
+    rankSep?: number;
+    nodeSep?: number;
+}
+type ViewManualLayout = {
+    readonly hash: string;
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+    readonly autoLayout: ViewAutoLayout;
+    readonly nodes: Record<string, {
+        isCompound: boolean;
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }>;
+    readonly edges: Record<string, {
+        dotpos?: string;
+        points: NonEmptyArray<Point>;
+        controlPoints?: NonEmptyArray<XYPoint>;
+        labelBBox?: BBox;
+    }>;
+};
+type ViewType = 'element' | 'dynamic' | 'deployment';
+interface BaseViewProperties<A extends Any> extends WithOptionalTags<A>, WithOptionalLinks {
+    readonly id: StrictViewId<A>;
+    readonly title: string | null;
+    readonly description: string | null;
+    /**
+     * For all views we find common ancestor path.
+     * This is used to generate relative paths, i.e.:
+     * - "/home/project/index.c4" becomes "index.c4"
+     * - "/home/project/subdir/views.c4" becomes "subdir/views.c4"
+     *
+     * Undefined if the view is auto-generated.
+     */
+    readonly relativePath?: string | undefined;
+}
+interface BaseParsedViewProperties<A extends Any> extends BaseViewProperties<A> {
+    /**
+     * Internal field to identify the stage of the view.
+     * This is used to create the correct type of the view.
+     */
+    readonly [_stage]: 'parsed';
+    /**
+     * URI to the source file of this view.
+     * Undefined if the view is auto-generated.
+     */
+    readonly docUri?: string | undefined;
+    /**
+     * If the view is changed manually this field contains the layout data.
+     */
+    readonly manualLayout?: ViewManualLayout | undefined;
+}
+type NodeNotation = {
+    kinds: string[];
+    shape: ElementShape;
+    color: Color;
+    title: string;
+};
+interface ViewWithNotation {
+    notation?: {
+        nodes: NodeNotation[];
+    };
+}
+interface ViewWithHash {
+    /**
+     * Hash of the view object.
+     * This is used to detect changes in layout
+     */
+    hash: string;
+}
+
+/**
+ * Predicates scoped to logical model
+ */
+interface ElementViewIncludePredicate<A extends Any = Any> extends AnyIncludePredicate<ModelExpression<A>> {
+}
+interface ElementViewExcludePredicate<A extends Any = Any> extends AnyExcludePredicate<ModelExpression<A>> {
+}
+type ElementViewPredicate<A extends Any = Any> = ElementViewIncludePredicate<A> | ElementViewExcludePredicate<A>;
+interface ElementViewRuleGroup<A extends Any = Any> {
+    groupRules: Array<ElementViewPredicate<A> | ElementViewRuleGroup<A>>;
+    title: string | null;
+    color?: Color;
+    border?: BorderStyle;
+    opacity?: number;
+    multiple?: boolean;
+    size?: ShapeSize;
+    padding?: SpacingSize;
+    textSize?: TextSize;
+}
+declare function isViewRuleGroup<A extends Any>(rule: ElementViewRule<A>): rule is ElementViewRuleGroup<A>;
+interface ElementViewRuleStyle<A extends Any = Any> extends AnyViewRuleStyle<ModelFqnExpr<A>> {
+}
+type ElementViewRule<A extends Any = Any> = ExclusiveUnion<{
+    IncludePredicate: ElementViewIncludePredicate<A>;
+    ExcludePredicate: ElementViewExcludePredicate<A>;
+    Group: ElementViewRuleGroup<A>;
+    Style: ElementViewRuleStyle<A>;
+    GlobalStyle: ViewRuleGlobalStyle;
+    GlobalPredicateRef: ViewRuleGlobalPredicateRef;
+    AutoLayout: ViewRuleAutoLayout;
+}>;
+interface ParsedElementView<A extends Any = Any> extends BaseParsedViewProperties<A> {
+    [_type]: 'element';
+    readonly rules: ElementViewRule<A>[];
+    readonly viewOf?: Fqn<A>;
+    readonly extends?: StrictViewId<A>;
+}
+
+interface DynamicViewStep<A extends Any = Any> {
+    readonly source: Fqn<A>;
+    readonly target: Fqn<A>;
+    readonly title: string | null;
+    readonly description?: string;
+    readonly technology?: string;
+    readonly notation?: string;
+    readonly notes?: string;
+    readonly color?: Color;
+    readonly line?: RelationshipLineType;
+    readonly head?: RelationshipArrowType;
+    readonly tail?: RelationshipArrowType;
+    readonly isBackward?: boolean;
+    readonly navigateTo?: StrictViewId<A>;
+}
+interface DynamicViewParallelSteps<A extends Any = Any> {
+    readonly __parallel: DynamicViewStep<A>[];
+}
+declare function getParallelStepsPrefix(id: string): string | null;
+type DynamicViewStepOrParallel<A extends Any = Any> = Simplify<MergeExclusive<DynamicViewStep<A>, DynamicViewParallelSteps<A>>>;
+interface DynamicViewIncludeRule<A extends Any = Any> {
+    include: ModelFqnExpr.Any<A>[];
+}
+type DynamicViewRule<A extends Any = Any> = ExclusiveUnion<{
+    Include: DynamicViewIncludeRule<A>;
+    GlobalPredicateRef: ViewRuleGlobalPredicateRef;
+    ElementViewRuleStyle: ElementViewRuleStyle<A>;
+    GlobalStyle: ViewRuleGlobalStyle;
+    AutoLayout: ViewRuleAutoLayout;
+}>;
+interface ParsedDynamicView<A extends Any = Any> extends BaseParsedViewProperties<A> {
+    [_type]: 'dynamic';
+    readonly steps: DynamicViewStepOrParallel<A>[];
+    readonly rules: DynamicViewRule<A>[];
+}
+declare function isDynamicViewParallelSteps<A extends Any>(step: DynamicViewStepOrParallel<A>): step is DynamicViewParallelSteps<A>;
+
+type GlobalPredicateId = Tagged<string, 'GlobalPredicateId'>;
+type GlobalPredicates<A extends Any = Any> = NonEmptyArray<ElementViewPredicate<A>>;
+type GlobalDynamicPredicates<A extends Any = Any> = NonEmptyArray<DynamicViewIncludeRule<A>>;
+type GlobalStyleID = Tagged<string, 'GlobalStyleID'>;
+type GlobalStyles<A extends Any = Any> = NonEmptyTuple<ElementViewRuleStyle<A>>;
+interface ModelGlobals<A extends Any = Any> {
+    readonly predicates: Record<GlobalPredicateId, GlobalPredicates<A>>;
+    readonly dynamicPredicates: Record<GlobalPredicateId, GlobalDynamicPredicates<A>>;
+    readonly styles: Record<GlobalStyleID, GlobalStyles<A>>;
+}
+
+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 Element<A extends Any = Any> extends WithOptionalTags<A>, WithOptionalLinks, WithMetadata<A> {
+    readonly id: Fqn<A>;
+    readonly kind: ElementKind<A>;
+    readonly title: string;
+    readonly description?: string | null;
+    readonly technology?: string | null;
+    readonly tags?: Tags<A> | null;
+    readonly links?: readonly Link[] | null;
+    readonly icon?: Icon;
+    readonly shape?: ElementShape;
+    readonly color?: Color;
+    readonly style?: ElementStyle;
+    readonly notation?: string;
+    readonly metadata?: Metadata<A>;
+}
+declare const DefaultLineStyle: RelationshipLineType;
+declare const DefaultArrowType: RelationshipArrowType;
+declare const DefaultRelationshipColor: ThemeColor;
+interface AbstractRelationship<A extends Any> extends WithOptionalTags<A>, WithOptionalLinks, WithMetadata<A> {
+    readonly id: RelationId;
+    readonly title?: string | null;
+    readonly description?: string | null;
+    readonly technology?: string | null;
+    readonly kind?: RelationKind<A>;
+    readonly color?: Color;
+    readonly line?: RelationshipLineType;
+    readonly head?: RelationshipArrowType;
+    readonly tail?: RelationshipArrowType;
+    readonly tags?: Tags<A> | null;
+    readonly links?: readonly Link[] | null;
+    readonly navigateTo?: ViewId<A>;
+    readonly metadata?: Metadata<A>;
+}
+/**
+ * Relationship between two model elements
+ */
+interface Relationship<A extends Any = Any> extends AbstractRelationship<A> {
+    readonly source: FqnRef.ModelRef<A>;
+    readonly target: FqnRef.ModelRef<A>;
+}
+/**
+ * Backward compatibility alias
+ * @deprecated Use {@link Relationship} instead
+ */
+type ModelRelation<A extends Any = Any> = Relationship<A>;
+
+interface DeploymentElementStyle extends ElementStyle {
+    readonly icon?: Icon;
+    readonly shape?: ElementShape;
+    readonly color?: Color;
+}
+interface DeploymentNode<A extends Any = Unknown> extends WithOptionalTags<A>, WithOptionalLinks, WithMetadata<A> {
+    element?: never;
+    readonly id: DeploymentFqn<A>;
+    readonly kind: DeploymentKind<A>;
+    readonly title: string;
+    readonly description?: string | null;
+    readonly technology?: string | null;
+    readonly tags?: Tags<A> | null;
+    readonly links?: readonly Link[] | null;
+    readonly style: DeploymentElementStyle;
+    readonly notation?: string;
+    readonly metadata?: Metadata<A>;
+}
+interface DeployedInstance<A extends Any = Unknown> extends WithOptionalTags<A>, WithOptionalLinks, WithMetadata<A> {
+    kind?: never;
+    /**
+     * Format: `<DeploymentNode Fqn>.<Instance Id>`
+     * i.e parent fqn is deployment target
+     */
+    readonly id: DeploymentFqn<A>;
+    readonly element: Fqn<A>;
+    readonly title?: string;
+    readonly description?: string | null;
+    readonly technology?: string | null;
+    readonly tags?: Tags<A> | null;
+    readonly links?: readonly Link[] | null;
+    readonly style?: DeploymentElementStyle;
+    readonly notation?: string;
+    readonly metadata?: Metadata<A>;
+}
+type DeploymentElement<A extends Any = Unknown> = DeploymentNode<A> | DeployedInstance<A>;
+type DeploymentElementRef<A extends Any = Unknown> = {
+    readonly id: DeploymentFqn<A>;
+    readonly element?: Fqn<A>;
+};
+declare function isDeploymentNode<A extends Any>(el: DeploymentElement<A>): el is DeploymentNode<A>;
+declare function isDeployedInstance<A extends Any>(el: DeploymentElement<A>): el is DeployedInstance<A>;
+/**
+ * Relationship in deployment model
+ */
+interface DeploymentRelationship<A extends Any = Unknown> extends AbstractRelationship<A> {
+    readonly source: FqnRef.DeploymentRef<A>;
+    readonly target: FqnRef.DeploymentRef<A>;
+}
+/**
+ * Backward compatibility alias
+ * @deprecated Use {@link DeploymentRelationship} instead
+ */
+type DeploymentRelation<A extends Any = Unknown> = DeploymentRelationship<A>;
+
+/**
+ * Element and deployment kind specification
+ */
+interface ElementSpecification {
+    tags?: Tag$1[];
+    technology?: string;
+    notation?: string;
+    style: {
+        shape?: ElementShape;
+        icon?: Icon;
+        color?: Color;
+        border?: BorderStyle;
+        opacity?: number;
+        size?: ShapeSize;
+        padding?: SpacingSize;
+        textSize?: TextSize;
+        multiple?: boolean;
+    };
+}
+interface TagSpecification {
+    color: ThemeColor | ColorLiteral;
+}
+/**
+ * Checks if tag color is defined in the specification
+ * Expects HEX, `rgb(...)` or `rgba(...)` color
+ */
+declare function isTagColorSpecified(spec: string | TagSpecification): spec is {
+    color: ColorLiteral;
+};
+interface RelationshipSpecification {
+    technology?: string;
+    notation?: string;
+    color?: Color;
+    line?: RelationshipLineType;
+    head?: RelationshipArrowType;
+    tail?: RelationshipArrowType;
+}
+type Specification<A> = A extends Any ? {
+    tags: {
+        [key in Tag<A>]: TagSpecification;
+    };
+    elements: {
+        [key in ElementKind<A>]: Partial<ElementSpecification>;
+    };
+    deployments: {
+        [key in DeploymentKind<A>]: Partial<ElementSpecification>;
+    };
+    relationships: {
+        [key in RelationKind<A>]: Partial<RelationshipSpecification>;
+    };
+    metadataKeys?: IsNever<MetadataKey<A>> extends true ? never : MetadataKey<A>[];
+    customColors?: CustomColorDefinitions;
+} : never;
+
+interface ComputedNode<A extends Any = Any> extends WithOptionalLinks {
+    id: NodeId;
+    kind: ElementKind<A> | DeploymentKind<A> | '@group';
+    parent: NodeId | null;
+    /**
+     * Reference to model element
+     * If 1 - node id is a reference
+     */
+    modelRef?: Fqn<A> | undefined;
+    /**
+     * Reference to deployment element
+     * If 1 - node id is a reference
+     */
+    deploymentRef?: DeploymentFqn<A> | undefined;
+    title: string;
+    description?: string | null;
+    technology?: string | null;
+    notation?: string;
+    children: NodeId[];
+    inEdges: EdgeId[];
+    outEdges: EdgeId[];
+    tags: Tags<A>;
+    shape: ElementShape;
+    color: Color;
+    icon?: Icon;
+    style: ElementStyle;
+    navigateTo?: StrictViewId<A> | null;
+    level: number;
+    depth?: number;
+    /**
+     * If this node was customized in the view
+     */
+    isCustomized?: boolean;
+}
+interface ComputedEdge<A extends Any = Any> extends WithOptionalTags<A> {
+    id: EdgeId;
+    parent: NodeId | null;
+    source: NodeId;
+    target: NodeId;
+    label: string | null;
+    description?: string;
+    technology?: string;
+    relations: RelationId[];
+    kind?: RelationKind<A> | typeof StepEdgeKind;
+    notation?: string;
+    notes?: string;
+    color?: Color;
+    line?: RelationshipLineType;
+    head?: RelationshipArrowType;
+    tail?: RelationshipArrowType;
+    navigateTo?: StrictViewId<A> | null;
+    /**
+     * If this edge is derived from custom relationship predicate
+     */
+    isCustomized?: boolean;
+    /**
+     * For layouting purposes
+     * @default 'forward'
+     */
+    dir?: 'forward' | 'back' | 'both';
+}
+interface BaseComputedViewProperties<A extends Any> extends BaseViewProperties<A>, ViewWithHash, ViewWithNotation {
+    readonly [_stage]: 'computed';
+    readonly autoLayout: ViewAutoLayout;
+    readonly nodes: ComputedNode<A>[];
+    readonly edges: ComputedEdge<A>[];
+    /**
+     * If the view is changed manually this field contains the layout data.
+     */
+    readonly manualLayout?: ViewManualLayout | undefined;
+}
+interface ComputedElementView<A extends Any = Any> extends BaseComputedViewProperties<A> {
+    readonly [_type]: 'element';
+    readonly viewOf?: Fqn<A>;
+    readonly extends?: StrictViewId<A>;
+}
+interface ComputedDeploymentView<A extends Any = Any> extends BaseComputedViewProperties<A> {
+    readonly [_type]: 'deployment';
+}
+interface ComputedDynamicView<A extends Any = Any> extends BaseComputedViewProperties<A> {
+    readonly [_type]: 'dynamic';
+}
+
+interface DiagramNode<A extends Any = Any> extends ComputedNode<A>, BBox {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /**
+     * Absolute position, top left
+     * @deprecated Use `x` and `y` instead
+     */
+    position: Point;
+    /**
+     * Bounding box of label
+     * (Absolute coordinates)
+     */
+    labelBBox: BBox;
+}
+interface DiagramEdge<A extends Any = Any> extends ComputedEdge<A> {
+    /**
+     * Bezier points
+     * (Absolute coordinates)
+     */
+    points: NonEmptyArray<Point>;
+    /**
+     * Control points to adjust the edge
+     * (Absolute coordinates)
+     */
+    controlPoints?: NonEmptyArray<XYPoint>;
+    /**
+     * Bounding box of label
+     * (Absolute coordinates)
+     */
+    labelBBox?: BBox | null;
+    /**
+     * Graphviz edge POS
+     *
+     * TODO: temporary solution, should be moved out
+     * @deprecated
+     */
+    dotpos?: string;
+}
+interface BaseLayoutedViewProperties<A extends Any> extends BaseViewProperties<A>, ViewWithHash, ViewWithNotation {
+    readonly [_stage]: 'layouted';
+    readonly autoLayout: ViewAutoLayout;
+    readonly nodes: DiagramNode<A>[];
+    readonly edges: DiagramEdge<A>[];
+    readonly bounds: BBox;
+    /**
+     * If diagram has manual layout
+     * But was changed and layout should be recalculated
+     */
+    hasLayoutDrift?: boolean;
+}
+interface LayoutedElementView<A extends Any = Any> extends BaseLayoutedViewProperties<A> {
+    readonly [_type]: 'element';
+    readonly viewOf?: Fqn<A>;
+    readonly extends?: StrictViewId<A>;
+}
+interface LayoutedDeploymentView<A extends Any = Any> extends BaseLayoutedViewProperties<A> {
+    readonly [_type]: 'deployment';
+}
+interface LayoutedDynamicView<A extends Any = Any> extends BaseLayoutedViewProperties<A> {
+    readonly [_type]: 'dynamic';
+}
+
+/**
+ * Predicates scoped to deployment model
+ */
+interface DeploymentViewIncludePredicate<A extends Any = Unknown> extends AnyIncludePredicate<Expression<A>> {
+}
+interface DeploymentViewExcludePredicate<A extends Any = Unknown> extends AnyExcludePredicate<Expression<A>> {
+}
+type DeploymentViewPredicate<A extends Any = Unknown> = DeploymentViewIncludePredicate<A> | DeploymentViewExcludePredicate<A>;
+interface DeploymentViewRuleStyle<A extends Any = Unknown> extends AnyViewRuleStyle<FqnExpr<A>> {
+}
+type DeploymentViewRule<A extends Any = Unknown> = ExclusiveUnion<{
+    Include: DeploymentViewIncludePredicate<A>;
+    Exclude: DeploymentViewExcludePredicate<A>;
+    Style: DeploymentViewRuleStyle<A>;
+    AutoLayout: ViewRuleAutoLayout;
+}>;
+interface ParsedDeploymentView<A extends Any = Unknown> extends BaseParsedViewProperties<A> {
+    [_type]: 'deployment';
+    readonly rules: DeploymentViewRule<A>[];
+}
+
+type ParsedView<A extends Any = Any> = ParsedElementView<A> | ParsedDeploymentView<A> | ParsedDynamicView<A>;
+
+type ComputedView<A extends Any = Any> = ComputedElementView<A> | ComputedDeploymentView<A> | ComputedDynamicView<A>;
+type LayoutedView<A extends Any = Any> = LayoutedElementView<A> | LayoutedDeploymentView<A> | LayoutedDynamicView<A>;
+type ProcessedView<A extends Any = Any> = ComputedView<A> | LayoutedView<A>;
+
+type AnyView<A extends Any = Any> = ParsedElementView<A> | ParsedDeploymentView<A> | ParsedDynamicView<A> | ComputedElementView<A> | ComputedDeploymentView<A> | ComputedDynamicView<A> | LayoutedElementView<A> | LayoutedDeploymentView<A> | LayoutedDynamicView<A>;
+type ViewOnStage<V extends AnyView<Any>, T extends ModelStage> = Extract<V, {
+    [_stage]: T;
+}>;
+type ViewWithType<V extends AnyView<Any>, T extends ViewType> = Extract<V, {
+    [_type]: T;
+}>;
+type ViewRule<A extends Any = Any> = ParsedView<A>['rules'][number];
+type ViewRulePredicate<A extends Any = Any> = Extract<ViewRule<A>, {
+    include: any[];
+} | {
+    exclude: any[];
+}>;
+declare function isViewRulePredicate<V extends ViewRule<any>>(rule: V): rule is Extract<V, {
+    include: any[];
+} | {
+    exclude: any[];
+}>;
+declare function isViewRuleStyle<V extends ViewRule<any>>(rule: V): rule is Extract<V, {
+    targets: any[];
+    style: {};
+}>;
+declare function isComputedView<V extends AnyView<any>>(view: V): view is ExtractOnStage<V, 'computed'>;
+declare function isDiagramView<V extends AnyView<any>>(view: V): view is ExtractOnStage<V, 'layouted'>;
+
+declare function isElementView<V extends AnyView<any>>(view: V): view is ViewWithType<V, 'element'>;
+declare function isScopedElementView<V extends AnyView<any>>(view: V): view is ViewWithType<V, 'element'> & {
+    viewOf: Fqn<Any>;
+};
+declare function isExtendsElementView<V extends AnyView<any>>(view: V): view is ViewWithType<V, 'element'> & {
+    extends: StrictViewId<Any>;
+};
+declare function isDeploymentView<V extends AnyView<any>>(view: V): view is ViewWithType<V, 'deployment'>;
+declare function isDynamicView<V extends AnyView<any>>(view: V): view is ViewWithType<V, 'dynamic'>;
+
+interface BaseLikeC4ModelData<A extends Any> {
+    projectId: ProjectId<A>;
+    specification: Specification<A>;
+    elements: Record<ElementId<A>, Element<A>>;
+    deployments: {
+        elements: Record<DeploymentId<A>, DeploymentElement<A>>;
+        relations: Record<RelationId, DeploymentRelationship<A>>;
+    };
+    relations: Record<RelationId, Relationship<A>>;
+    globals: ModelGlobals;
+    imports: Record<string, NonEmptyArray<Element<A>>>;
+}
+type AuxFromLikeC4ModelData<D> = D extends BaseLikeC4ModelData<infer A extends Any> ? IsAny<A> extends true ? never : A : never;
+/**
+ * Represents a LikeC4 model with customizable type parameters,
+ * parsed from DSL or result from Builder
+ *
+ * !IMPORTANT: This is a low-level type, use `LikeC4Model` instead.
+ * !NOTE: Views are not computed yet.
+ *
+ * @typeParam ElementKinds - Types of elements in the model (defaults to string)
+ * @typeParam RelationKinds - Types of relationships (defaults to string)
+ * @typeParam Tags - Types of tags that can be applied (defaults to string)
+ * @typeParam Fqns - Fully Qualified Names for elements (defaults to string)
+ * @typeParam Views - Types of views in the model (defaults to string)
+ * @typeParam DeploymentFqns - Fully Qualified Names for deployment nodes (defaults to string)
+ */
+interface ParsedLikeC4ModelData<A extends Any = UnknownParsed> extends BaseLikeC4ModelData<A> {
+    [_stage]: 'parsed';
+    views: Record<ViewId<A>, ParsedView<A>>;
+}
+interface ComputedLikeC4ModelData<A extends Any = UnknownComputed> extends BaseLikeC4ModelData<A> {
+    [_stage]: 'computed';
+    views: Record<ViewId<A>, ComputedView<A>>;
+}
+interface LayoutedLikeC4ModelData<A extends Any = UnknownLayouted> extends BaseLikeC4ModelData<A> {
+    [_stage]: 'layouted';
+    views: Record<ViewId<A>, LayoutedView<A>>;
+}
+type LikeC4ModelData<A extends Any> = ParsedLikeC4ModelData<A> | ComputedLikeC4ModelData<A> | LayoutedLikeC4ModelData<A>;
+
+/**
+ * JSON representation of {@link Specification}
+ */
+interface SpecificationDump {
+    elements: {
+        [kind: string]: object;
+    };
+    tags?: {
+        [tag: string]: object;
+    };
+    deployments?: {
+        [kind: string]: object;
+    };
+    relationships?: {
+        [kind: string]: object;
+    };
+    metadataKeys?: string[];
+    customColors?: {
+        [kind: string]: object;
+    };
+}
+type SpecTypesFromDump<J> = J extends SpecificationDump ? SpecAux<KeysOf<J['elements']>, KeysOf<J['deployments']>, KeysOf<J['relationships']>, KeysOf<J['tags']>, J['metadataKeys'] extends readonly [string, ...string[]] ? J['metadataKeys'][number] : never> : SpecAux<never, never, never, never, never>;
+/**
+ * Dump differs from {@link ParsedLikeC4ModelData} by the fact that it is computed or layouted
+ */
+type LikeC4ModelDump = {
+    [_stage]?: 'computed' | 'layouted';
+    projectId?: string;
+    specification: SpecificationDump;
+    elements?: {
+        [kind: string]: object;
+    };
+    deployments: {
+        elements?: {
+            [kind: string]: object;
+        };
+        relations?: {};
+    };
+    views?: {
+        [kind: string]: object;
+    };
+    relations?: {};
+    globals?: {
+        predicates?: {};
+        dynamicPredicates?: {};
+        styles?: {};
+    };
+    imports?: {};
+};
+type AuxFromDump<D> = D extends LikeC4ModelDump ? Aux<D[_stage] extends infer S extends string & 'computed' | 'layouted' ? S : 'computed' | 'layouted' | 'parsed', KeysOf<D['elements']>, KeysOf<D['deployments']['elements']>, KeysOf<D['views']>, D['projectId'] extends infer P extends string ? P : never, SpecTypesFromDump<D['specification']>> : Never;
+
+export { type TagSpecification as $, type AuxFromLikeC4ModelData as A, BBox as B, type ColorLiteral as C, type DeploymentElementStyle as D, Expression as E, FqnExpr as F, type GlobalPredicateId as G, DefaultElementShape as H, DefaultShapeSize as I, DefaultPaddingSize as J, DefaultTextSize as K, type LikeC4Theme as L, ModelFqnExpr as M, type ElementStyle as N, type Element as O, type PredicateSelector as P, DefaultLineStyle as Q, RelationExpr as R, type SpecificationDump as S, type ThemeColorValues as T, DefaultArrowType as U, DefaultRelationshipColor as V, type AbstractRelationship as W, type XYPoint as X, type Relationship as Y, type ModelRelation as Z, type ElementSpecification as _, ModelRelationExpr as a, isViewRuleGlobalStyle as a$, isTagColorSpecified as a0, type RelationshipSpecification as a1, type Specification as a2, type EqualOperator as a3, type TagEqual as a4, isTagEqual as a5, type KindEqual as a6, isKindEqual as a7, type Participant as a8, type ParticipantOperator as a9, isThemeColor as aA, type ElementThemeColorValues as aB, type ElementThemeColors as aC, type RelationshipThemeColorValues as aD, type RelationshipThemeColors as aE, type ParsedView as aF, type LayoutedView as aG, isDiagramView as aH, type ComputedView as aI, type ProcessedView as aJ, type AnyView as aK, type ViewOnStage as aL, type ViewWithType as aM, type ViewRule as aN, type ViewRulePredicate as aO, isViewRulePredicate as aP, isViewRuleStyle as aQ, isComputedView as aR, isElementView as aS, isScopedElementView as aT, isExtendsElementView as aU, isDeploymentView as aV, isDynamicView as aW, type AnyIncludePredicate as aX, type AnyExcludePredicate as aY, type AnyViewRuleStyle as aZ, type ViewRuleGlobalStyle as a_, isParticipantOperator as aa, type NotOperator as ab, isNotOperator as ac, type AndOperator as ad, isAndOperator as ae, type OrOperator as af, isOrOperator as ag, type WhereOperator as ah, type Filterable as ai, type OperatorPredicate as aj, whereOperatorAsPredicate as ak, type SpacingSize as al, type TextSize as am, type ShapeSize as an, BorderStyles as ao, type BorderStyle as ap, ElementShapes as aq, type ElementShape as ar, type HexColor as as, type CustomColor as at, type CustomColorDefinitions as au, type RelationshipLineType as av, type RelationshipArrowType as aw, ThemeColors as ax, type ThemeColor as ay, type Color as az, ModelExpression as b, type ViewRuleGlobalPredicateRef as b0, isViewRuleGlobalPredicateRef as b1, type AutoLayoutDirection as b2, isAutoLayoutDirection as b3, type ViewRuleAutoLayout as b4, isViewRuleAutoLayout as b5, type ViewAutoLayout as b6, type ViewManualLayout as b7, type ViewType as b8, type BaseViewProperties as b9, type ParsedDynamicView as bA, isDynamicViewParallelSteps as bB, type ElementViewIncludePredicate as bC, type ElementViewExcludePredicate as bD, type ElementViewPredicate as bE, type ElementViewRuleGroup as bF, isViewRuleGroup as bG, type ElementViewRuleStyle as bH, type ElementViewRule as bI, type ParsedElementView as bJ, type BaseParsedViewProperties as ba, type NodeNotation as bb, type ViewWithNotation as bc, type ViewWithHash as bd, type ComputedNode as be, type ComputedEdge as bf, type ComputedElementView as bg, type ComputedDeploymentView as bh, type ComputedDynamicView as bi, type DiagramNode as bj, type DiagramEdge as bk, type LayoutedElementView as bl, type LayoutedDeploymentView as bm, type LayoutedDynamicView as bn, type DeploymentViewIncludePredicate as bo, type DeploymentViewExcludePredicate as bp, type DeploymentViewPredicate as bq, type DeploymentViewRuleStyle as br, type DeploymentViewRule as bs, type ParsedDeploymentView as bt, type DynamicViewStep as bu, type DynamicViewParallelSteps as bv, getParallelStepsPrefix as bw, type DynamicViewStepOrParallel as bx, type DynamicViewIncludeRule as by, type DynamicViewRule as bz, FqnRef as c, type Point as d, RectBox as e, type GlobalPredicates as f, type GlobalDynamicPredicates as g, type GlobalStyleID as h, type GlobalStyles as i, type ModelGlobals as j, type ParsedLikeC4ModelData as k, type ComputedLikeC4ModelData as l, type LayoutedLikeC4ModelData as m, type LikeC4ModelData as n, type DeploymentNode as o, type DeployedInstance as p, type DeploymentElement as q, type DeploymentElementRef as r, isDeploymentNode as s, isDeployedInstance as t, type DeploymentRelationship as u, type DeploymentRelation as v, type SpecTypesFromDump as w, type LikeC4ModelDump as x, type AuxFromDump as y, DefaultThemeColor as z };