@likec4/core 1.17.1 → 1.19.0

package/dist/shared/{core.CoLQkcYL.d.cts → core.C05RDLhi.d.ts}

@@ -1,104 +1,5 @@
-import { Tagged, LiteralUnion, TupleToUnion, NonEmptyTuple } from 'type-fest';
-
-type NonEmptyArray<T> = [T, ...T[]];
-type NonEmptyReadonlyArray<T> = readonly [T, ...T[]];
-type IconUrl = Tagged<string, 'IconUrl'> | 'none';
-type CustomColor = string;
-type Point = readonly [x: number, y: number];
-interface XYPoint {
-    x: number;
-    y: number;
-}
-
-declare const ThemeColors: readonly ["amber", "blue", "gray", "slate", "green", "indigo", "muted", "primary", "red", "secondary", "sky"];
-type ThemeColor = typeof ThemeColors[number];
-type HexColorLiteral = `#${string}`;
-type ColorLiteral = HexColorLiteral;
-type Color = LiteralUnion<ThemeColor, string>;
-declare function isThemeColor(color: Color): color is ThemeColor;
-interface ElementThemeColorValues {
-    fill: ColorLiteral;
-    stroke: ColorLiteral;
-    hiContrast: ColorLiteral;
-    loContrast: ColorLiteral;
-}
-type ElementThemeColors = {
-    [key in ThemeColor]: ElementThemeColorValues;
-};
-interface RelationshipThemeColorValues {
-    lineColor: ColorLiteral;
-    labelBgColor: ColorLiteral;
-    labelColor: ColorLiteral;
-}
-interface ThemeColorValues {
-    elements: ElementThemeColorValues;
-    relationships: RelationshipThemeColorValues;
-}
-type RelationshipThemeColors = {
-    [key in ThemeColor]: RelationshipThemeColorValues;
-};
-interface LikeC4Theme {
-    font: 'Arial';
-    shadow: ColorLiteral;
-    relationships: RelationshipThemeColors;
-    elements: ElementThemeColors;
-}
-
-type Fqn<Id extends string = string> = Tagged<Id, 'Fqn'>;
-declare function AsFqn(name: string, parent?: Fqn | null): Fqn;
-declare const BorderStyles: readonly ["solid", "dashed", "dotted", "none"];
-type BorderStyle = TupleToUnion<typeof BorderStyles>;
-type ElementKind<Kinds extends string = string> = Tagged<Kinds, 'ElementKind'>;
-declare namespace ElementKind {
-    const Group: ElementKind;
-}
-declare const ElementShapes: readonly ["rectangle", "person", "browser", "mobile", "cylinder", "storage", "queue"];
-type ElementShape = TupleToUnion<typeof ElementShapes>;
-declare const DefaultThemeColor = "primary";
-declare const DefaultElementShape = "rectangle";
-interface ElementStyle {
-    border?: BorderStyle;
-    opacity?: number;
-}
-type Tag<Tags extends string = string> = Tagged<Tags, 'Tag'>;
-interface TagSpec {
-    readonly id: Tag;
-    readonly style: ElementStyle;
-}
-interface Link {
-    readonly title?: string;
-    readonly url: string;
-    readonly relative?: string;
-}
-interface TypedElement<Ids extends string, Kinds extends string, Tags extends string, MetadataKeys extends string = never> {
-    readonly id: Fqn<Ids>;
-    readonly kind: ElementKind<Kinds>;
-    readonly title: string;
-    readonly description: string | null;
-    readonly technology: string | null;
-    readonly tags: NonEmptyArray<Tag<Tags>> | null;
-    readonly links: NonEmptyArray<Link> | null;
-    readonly icon?: IconUrl;
-    readonly shape?: ElementShape;
-    readonly color?: Color;
-    readonly style?: ElementStyle;
-    readonly notation?: string;
-    readonly metadata?: Record<MetadataKeys, string>;
-}
-interface Element extends TypedElement<string, string, string, string> {
-}
-interface ElementKindSpecificationStyle {
-    shape?: ElementShape;
-    icon?: IconUrl;
-    color?: Color;
-    border?: BorderStyle;
-    opacity?: number;
-}
-interface ElementKindSpecification {
-    readonly technology?: string;
-    readonly notation?: string;
-    readonly style: ElementKindSpecificationStyle;
-}
+import { Tagged, NonEmptyTuple, Simplify, MergeExclusive } from 'type-fest';
+import { N as NonEmptyArray, F as Fqn, l as ElementShape, s as Color, I as IconUrl, h as BorderStyle, f as ElementKind, o as Tag, E as ExclusiveUnion, m as ElementStyle, n as Link, T as ThemeColorValues, X as XYPoint, P as Point, x as ThemeColor, j as ElementKindSpecification, q as TypedElement } from './core.D74xkKkG.js';
 
 type EqualOperator<V> = {
     eq: V;
@@ -136,31 +37,300 @@ type OrOperator<Tag, Kind> = Omit<AllNever, 'or'> & {
 declare const isOrOperator: <Tag, Kind>(operator: WhereOperator<Tag, Kind>) => operator is OrOperator<Tag, Kind>;
 type WhereOperator<Tag, Kind> = TagEqual<Tag> | KindEqual<Kind> | NotOperator<Tag, Kind> | AndOperator<Tag, Kind> | OrOperator<Tag, Kind>;
 type Filterable<FTag extends string = string, FKind extends string = string> = {
-    tags?: FTag[] | null;
+    tags?: readonly FTag[] | null;
     kind?: FKind;
 };
 type OperatorPredicate<V extends Filterable> = (value: V) => boolean;
 declare function whereOperatorAsPredicate<FTag extends string = string, FKind extends string = string>(operator: WhereOperator<FTag, FKind>): OperatorPredicate<Filterable<FTag, FKind>>;
 
+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;
+    };
+}
+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.
+     *
+     * @template D - The type representing the deployment fqn. Defaults to `Fqn`.
+     * @template M - The type representing the model fqn. Defaults to `Fqn`.
+     *
+     * @property {D} deployment - TThe fully qualified name (FQN) of the deployed instance.
+     * @property {M} element - The element reference within the deployment.
+     */
+    type InsideInstanceRef<D = Fqn, M = Fqn> = {
+        deployment: D;
+        element: M;
+    };
+    const isInsideInstanceRef: (ref: FqnRef) => ref is InsideInstanceRef;
+    /**
+     * Represents a reference to a deployment element.
+     *
+     * @template F - The type of the fully qualified name (FQN) of the deployment element. Defaults to `Fqn`.
+     * @property {F} deployment - The fully qualified name (FQN) of the deployment element.
+     */
+    type DeploymentElementRef<F = Fqn> = {
+        deployment: F;
+    };
+    const isDeploymentElementRef: (ref: FqnRef) => ref is DeploymentElementRef;
+    type DeploymentRef<D = Fqn, M = Fqn> = DeploymentElementRef<D> | InsideInstanceRef<D, M>;
+    const isDeploymentRef: (ref: FqnRef) => ref is DeploymentRef;
+    /**
+     * Reference to logical model element
+     */
+    type ModelRef<F = Fqn> = {
+        model: F;
+    };
+    const isModelRef: (ref: FqnRef) => ref is ModelRef;
+    const toDeploymentRef: (ref: FqnRef) => DeploymentRef;
+}
+type FqnRef<D = Fqn, M = Fqn> = ExclusiveUnion<{
+    InsideInstanceRef: FqnRef.InsideInstanceRef<D, M>;
+    DeploymentRef: FqnRef.DeploymentRef<D>;
+    ModelRef: FqnRef.ModelRef<M>;
+}>;
+declare namespace FqnExpr {
+    type Wildcard = {
+        wildcard: true;
+    };
+    const isWildcard: (expr: ExpressionV2) => expr is Wildcard;
+    type ModelRef<M = Fqn> = {
+        ref: FqnRef.ModelRef<M>;
+        selector?: PredicateSelector;
+    };
+    const isModelRef: (ref: ExpressionV2) => ref is ModelRef;
+    type DeploymentRef<D = Fqn, M = Fqn> = {
+        ref: FqnRef.DeploymentRef<D> | FqnRef.InsideInstanceRef<D, M>;
+        selector?: PredicateSelector;
+    };
+    const isDeploymentRef: (ref: ExpressionV2) => ref is FqnExpr.DeploymentRef;
+    type NonWildcard<D = Fqn, M = Fqn> = ExclusiveUnion<{
+        ModelRef: ModelRef<M>;
+        DeploymentRef: DeploymentRef<D, M>;
+    }>;
+}
+type FqnExpr<D = Fqn, M = Fqn> = ExclusiveUnion<{
+    Wildcard: FqnExpr.Wildcard;
+    ModelRef: FqnExpr.ModelRef<M>;
+    DeploymentRef: FqnExpr.DeploymentRef<D, M>;
+}>;
+declare namespace RelationExpr {
+    type Direct<D = Fqn, M = Fqn> = {
+        source: FqnExpr<D, M>;
+        target: FqnExpr<D, M>;
+        isBidirectional?: boolean;
+    };
+    const isDirect: (expr: ExpressionV2) => expr is Direct;
+    type Incoming<D = Fqn, M = Fqn> = {
+        incoming: FqnExpr<D, M>;
+    };
+    const isIncoming: (expr: ExpressionV2) => expr is Incoming;
+    type Outgoing<D = Fqn, M = Fqn> = {
+        outgoing: FqnExpr<D, M>;
+    };
+    const isOutgoing: (expr: ExpressionV2) => expr is Outgoing;
+    type InOut<D = Fqn, M = Fqn> = {
+        inout: FqnExpr<D, M>;
+    };
+    const isInOut: (expr: ExpressionV2) => expr is InOut;
+}
+type RelationExpr<D = Fqn, M = Fqn> = ExclusiveUnion<{
+    Direct: RelationExpr.Direct<D, M>;
+    Incoming: RelationExpr.Incoming<D, M>;
+    Outgoing: RelationExpr.Outgoing<D, M>;
+    InOut: RelationExpr.InOut<D, M>;
+}>;
+/**
+ * Represents a version 2 expression which can be one of several types.
+ *
+ * @template D - The type for the deployment FQN, defaults to `Fqn`.
+ * @template M - The type for the model FQN, defaults to `Fqn`.
+ */
+type ExpressionV2<D = Fqn, M = Fqn> = ExclusiveUnion<{
+    Wildcard: FqnExpr.Wildcard;
+    ModelRef: FqnExpr.ModelRef<M>;
+    DeploymentRef: FqnExpr.DeploymentRef<D, M>;
+    Direct: RelationExpr.Direct<D, M>;
+    Incoming: RelationExpr.Incoming<D, M>;
+    Outgoing: RelationExpr.Outgoing<D, M>;
+    InOut: RelationExpr.InOut<D, M>;
+}>;
+declare namespace ExpressionV2 {
+    const isFqnExpr: (expr: ExpressionV2) => expr is FqnExpr;
+    const isRelation: (expr: ExpressionV2) => expr is RelationExpr;
+}
+
 type GlobalPredicateId = Tagged<string, 'GlobalPredicateId'>;
 type GlobalPredicates = NonEmptyArray<ViewRulePredicate>;
 type GlobalDynamicPredicates = NonEmptyArray<DynamicViewIncludeRule>;
 type GlobalStyleID = Tagged<string, 'GlobalStyleID'>;
 type GlobalStyles = NonEmptyTuple<ViewRuleStyle>;
 interface ModelGlobals {
-    predicates: Record<GlobalPredicateId, GlobalPredicates>;
-    dynamicPredicates: Record<GlobalPredicateId, GlobalDynamicPredicates>;
-    styles: Record<GlobalStyleID, GlobalStyles>;
+    readonly predicates: Record<GlobalPredicateId, GlobalPredicates>;
+    readonly dynamicPredicates: Record<GlobalPredicateId, GlobalDynamicPredicates>;
+    readonly styles: Record<GlobalStyleID, GlobalStyles>;
 }
 
 type ElementNotation = {
-    kinds: ElementKind[];
+    kinds: string[];
     shape: ElementShape;
     color: Color;
     title: string;
 };
 
-type ViewID<Id extends string = string> = Tagged<Id, 'ViewID'>;
+type ViewId<Id extends string = string> = Tagged<Id, 'ViewID'>;
 type ViewRulePredicate = {
     include: Expression[];
     exclude?: never;
@@ -168,6 +338,8 @@ type ViewRulePredicate = {
     include?: never;
     exclude: Expression[];
 };
+declare function isViewRulePredicate(rule: DeploymentViewRule): rule is DeploymentViewRulePredicate;
+declare function isViewRulePredicate(rule: DynamicViewRule): rule is DynamicViewIncludeRule;
 declare function isViewRulePredicate(rule: ViewRule): rule is ViewRulePredicate;
 interface ViewRuleGlobalPredicateRef {
     predicateId: GlobalPredicateId;
@@ -182,6 +354,7 @@ interface ViewRuleStyle {
         icon?: IconUrl;
     };
 }
+declare function isViewRuleStyle(rule: DeploymentViewRule): rule is DeploymentViewRuleStyle;
 declare function isViewRuleStyle(rule: ViewRule): rule is ViewRuleStyle;
 interface ViewRuleGlobalStyle {
     styleId: GlobalStyleID;
@@ -195,7 +368,7 @@ interface ViewRuleAutoLayout {
     nodeSep?: number;
     rankSep?: number;
 }
-declare function isViewRuleAutoLayout(rule: ViewRule): rule is ViewRuleAutoLayout;
+declare function isViewRuleAutoLayout(rule: DeploymentViewRule | DynamicViewRule | ViewRule): rule is ViewRuleAutoLayout;
 interface ViewRuleGroup {
     groupRules: Array<ViewRulePredicate | ViewRuleGroup>;
     title: string | null;
@@ -205,9 +378,9 @@ interface ViewRuleGroup {
 }
 declare function isViewRuleGroup(rule: ViewRule): rule is ViewRuleGroup;
 type ViewRule = ViewRulePredicate | ViewRuleGlobalPredicateRef | ViewRuleGroup | ViewRuleStyle | ViewRuleGlobalStyle | ViewRuleAutoLayout;
-interface BasicView<ViewType extends 'element' | 'dynamic', ViewIDs extends string, Tags extends string> {
+interface BasicView<ViewType extends 'element' | 'dynamic' | 'deployment', ViewIDs extends string, Tags extends string> {
     readonly __?: ViewType;
-    readonly id: ViewID<ViewIDs>;
+    readonly id: ViewId<ViewIDs>;
     readonly title: string | null;
     readonly description: string | null;
     readonly tags: NonEmptyArray<Tag<Tags>> | null;
@@ -240,7 +413,7 @@ interface ScopedElementView<ViewIDs extends string, Tags extends string> extends
     readonly viewOf: Fqn;
 }
 interface ExtendsElementView<ViewIDs extends string, Tags extends string> extends BasicElementView<ViewIDs, Tags> {
-    readonly extends: ViewID<ViewIDs>;
+    readonly extends: ViewId<ViewIDs>;
 }
 type ElementView<ViewIDs extends string = string, Tags extends string = string> = ScopedElementView<ViewIDs, Tags> | ExtendsElementView<ViewIDs, Tags> | BasicElementView<ViewIDs, Tags>;
 interface DynamicViewStep {
@@ -256,7 +429,7 @@ interface DynamicViewStep {
     readonly head?: RelationshipArrowType;
     readonly tail?: RelationshipArrowType;
     readonly isBackward?: boolean;
-    readonly navigateTo?: ViewID;
+    readonly navigateTo?: ViewId;
     __parallel?: never;
 }
 interface DynamicViewParallelSteps {
@@ -266,7 +439,6 @@ type DynamicViewStepOrParallel = DynamicViewStep | DynamicViewParallelSteps;
 type DynamicViewIncludeRule = {
     include: ElementPredicateExpression[];
 };
-declare function isDynamicViewIncludeRule(rule: DynamicViewRule): rule is DynamicViewIncludeRule;
 type DynamicViewRule = DynamicViewIncludeRule | ViewRuleGlobalPredicateRef | ViewRuleStyle | ViewRuleGlobalStyle | ViewRuleAutoLayout;
 interface DynamicView<ViewIDs extends string = string, Tags extends string = string> extends BasicView<'dynamic', ViewIDs, Tags> {
     readonly __: 'dynamic';
@@ -277,7 +449,32 @@ declare function isDynamicViewParallelSteps(step: DynamicViewStepOrParallel): st
 type CustomColorDefinitions = {
     [key: string]: ThemeColorValues;
 };
-type LikeC4View<ViewIDs extends string = string, Tags extends string = string> = ElementView<ViewIDs, Tags> | DynamicView<ViewIDs, Tags>;
+type DeploymentViewRulePredicate = {
+    include: ExpressionV2[];
+    exclude?: never;
+} | {
+    include?: never;
+    exclude: ExpressionV2[];
+};
+type DeploymentViewRuleStyle = {
+    targets: FqnExpr[];
+    notation?: string;
+    style: ElementStyle & {
+        color?: Color;
+        shape?: ElementShape;
+        icon?: IconUrl;
+    };
+};
+type DeploymentViewRule = DeploymentViewRulePredicate | ViewRuleAutoLayout | DeploymentViewRuleStyle;
+interface DeploymentView<ViewIDs extends string = string, Tags extends string = string> extends BasicView<'deployment', ViewIDs, Tags> {
+    readonly __: 'deployment';
+    readonly rules: DeploymentViewRule[];
+}
+type LikeC4View<ViewIDs extends string = string, Tags extends string = string> = ElementView<ViewIDs, Tags> | DynamicView<ViewIDs, Tags> | DeploymentView<ViewIDs, Tags>;
+declare function isDeploymentView(view: LikeC4View): view is DeploymentView;
+declare function isDeploymentView<V extends {
+    __?: string;
+}>(view: V): boolean;
 declare function isDynamicView(view: LikeC4View): view is DynamicView;
 declare function isElementView(view: LikeC4View): view is ElementView;
 declare function isExtendsElementView(view: LikeC4View): view is ExtendsElementView<string, string>;
@@ -286,14 +483,24 @@ type NodeId<IDs extends string = string> = Tagged<IDs, 'Fqn'>;
 type EdgeId = Tagged<string, 'EdgeId'>;
 type StepEdgeIdLiteral = `step-${number}` | `step-${number}.${number}`;
 type StepEdgeId = Tagged<StepEdgeIdLiteral, 'EdgeId'>;
-declare function StepEdgeId(step: number, parallelStep?: number): StepEdgeId;
+declare function stepEdgeId(step: number, parallelStep?: number): StepEdgeId;
 declare function isStepEdgeId(id: string): id is StepEdgeId;
 declare function extractStep(id: EdgeId): number;
 declare function getParallelStepsPrefix(id: string): string | null;
 interface ComputedNode {
     id: NodeId;
-    kind: ElementKind;
+    kind: string;
     parent: NodeId | null;
+    /**
+     * Reference to model element
+     * If 1 - node id is a reference
+     */
+    modelRef?: 1 | Fqn;
+    /**
+     * Reference to deployment element
+     * If 1 - node id is a reference
+     */
+    deploymentRef?: 1 | Fqn;
     title: string;
     description: string | null;
     technology: string | null;
@@ -304,16 +511,13 @@ interface ComputedNode {
     inEdges: EdgeId[];
     outEdges: EdgeId[];
     shape: ElementShape;
-    /**
-     * @deprecated Use `style` instead
-     */
     color: Color;
     /**
      * @deprecated Use `style` instead
      */
     icon?: IconUrl;
     style: ElementStyle;
-    navigateTo?: ViewID;
+    navigateTo?: ViewId;
     level: number;
     depth?: number;
     /**
@@ -322,6 +526,8 @@ interface ComputedNode {
     isCustomized?: boolean;
 }
 declare namespace ComputedNode {
+    function modelRef(node: ComputedNode): Fqn | null;
+    function deploymentRef(node: ComputedNode): Fqn | null;
     /**
      * Nodes group is a special kind of node, exisiting only in view
      */
@@ -335,7 +541,7 @@ interface ComputedEdge {
     label: string | null;
     description?: string;
     technology?: string;
-    relations: RelationID[];
+    relations: RelationId[];
     kind?: RelationshipKind;
     notation?: string;
     notes?: string;
@@ -344,7 +550,7 @@ interface ComputedEdge {
     head?: RelationshipArrowType;
     tail?: RelationshipArrowType;
     tags?: NonEmptyArray<Tag>;
-    navigateTo?: ViewID;
+    navigateTo?: ViewId;
     /**
      * If this edge is derived from custom relationship predicate
      */
@@ -353,7 +559,7 @@ interface ComputedEdge {
      * For layouting purposes
      * @default 'forward'
      */
-    dir?: 'forward' | 'back';
+    dir?: 'forward' | 'back' | 'both';
 }
 interface ViewWithHash {
     /**
@@ -373,7 +579,7 @@ interface ViewAutoLayout {
     nodeSep?: number;
 }
 interface ComputedElementView<ViewIDs extends string = string, Tags extends string = string> extends Omit<ElementView<ViewIDs, Tags>, 'rules' | 'docUri'>, ViewWithHash, ViewWithNotation {
-    readonly extends?: ViewID<ViewIDs>;
+    readonly extends?: ViewId<ViewIDs>;
     readonly autoLayout: ViewAutoLayout;
     readonly nodes: ComputedNode[];
     readonly edges: ComputedEdge[];
@@ -388,16 +594,26 @@ interface ComputedDynamicView<ViewIDs extends string = string, Tags extends stri
     rules?: never;
     docUri?: never;
 }
-declare function isComputedDynamicView(view: ComputedView): view is ComputedDynamicView;
-type ComputedView<ViewIDs extends string = string, Tags extends string = string> = ComputedElementView<ViewIDs, Tags> | ComputedDynamicView<ViewIDs, Tags>;
-declare function isComputedElementView(view: ComputedView): view is ComputedElementView;
+interface ComputedDeploymentView<ViewIDs extends string = string, Tags extends string = string> extends Omit<DeploymentView<ViewIDs, Tags>, 'rules' | 'docUri'>, ViewWithHash, ViewWithNotation {
+    readonly autoLayout: ViewAutoLayout;
+    readonly nodes: ComputedNode[];
+    readonly edges: ComputedEdge[];
+    rules?: never;
+    docUri?: never;
+}
+type ComputedView<ViewIDs extends string = string, Tags extends string = string> = ComputedElementView<ViewIDs, Tags> | ComputedDynamicView<ViewIDs, Tags> | ComputedDeploymentView<ViewIDs, Tags>;
+declare namespace ComputedView {
+    function isDeployment(view: ComputedView): view is ComputedDeploymentView;
+    function isDynamic(view: ComputedView): view is ComputedDynamicView;
+    function isElement(view: ComputedView): view is ComputedElementView;
+}
 type BBox = {
     x: number;
     y: number;
     width: number;
     height: number;
 };
-declare function getBBoxCenter({ x, y, width, height }: BBox): XYPoint;
+declare function getBBoxCenter({ x, y, width, height, }: BBox): XYPoint;
 interface DiagramNode extends ComputedNode {
     width: number;
     height: number;
@@ -405,6 +621,8 @@ interface DiagramNode extends ComputedNode {
     labelBBox: BBox;
 }
 declare namespace DiagramNode {
+    function modelRef(node: DiagramNode): Fqn | null;
+    function deploymentRef(node: DiagramNode): Fqn | null;
     /**
      * Nodes group is a special kind of node, exisiting only in view
      */
@@ -449,32 +667,35 @@ type ViewManualLayout = {
     }>;
 };
 
-type RelationID = Tagged<string, 'RelationID'>;
+type RelationId = Tagged<string, 'RelationID'>;
 type RelationshipKind<Kinds extends string = string> = Tagged<Kinds, 'RelationshipKind'>;
 type RelationshipLineType = 'dashed' | 'solid' | 'dotted';
 type RelationshipArrowType = 'none' | 'normal' | 'onormal' | 'dot' | 'odot' | 'diamond' | 'odiamond' | 'crow' | 'open' | 'vee';
-declare const DefaultLineStyle = "dashed";
-declare const DefaultArrowType = "normal";
-declare const DefaultRelationshipColor = "gray";
-interface Relation {
-    readonly id: RelationID;
-    readonly source: Fqn;
-    readonly target: Fqn;
-    readonly title: string;
+declare const DefaultLineStyle: RelationshipLineType;
+declare const DefaultArrowType: RelationshipArrowType;
+declare const DefaultRelationshipColor: ThemeColor;
+interface AbstractRelation {
+    readonly id: RelationId;
+    readonly title?: string;
     readonly description?: string;
     readonly technology?: string;
-    readonly tags?: NonEmptyArray<Tag>;
+    readonly tags?: NonEmptyArray<Tag> | null;
     readonly kind?: RelationshipKind;
     readonly color?: Color;
     readonly line?: RelationshipLineType;
     readonly head?: RelationshipArrowType;
     readonly tail?: RelationshipArrowType;
-    readonly links?: NonEmptyArray<Link>;
-    readonly navigateTo?: ViewID;
+    readonly links?: NonEmptyArray<Link> | null;
+    readonly navigateTo?: ViewId;
     readonly metadata?: {
         [key: string]: string;
     };
 }
+interface ModelRelation extends AbstractRelation {
+    readonly source: Fqn;
+    readonly target: Fqn;
+    readonly title: string;
+}
 interface RelationshipKindSpecification {
     readonly technology?: string;
     readonly notation?: string;
@@ -484,251 +705,128 @@ interface RelationshipKindSpecification {
     readonly tail?: RelationshipArrowType;
 }
 
-interface BaseExpr {
-    where?: never;
-    element?: never;
-    custom?: never;
-    expanded?: never;
-    elementKind?: never;
-    elementTag?: never;
-    isEqual?: never;
-    isDescedants?: never;
-    wildcard?: never;
-    source?: never;
-    target?: never;
-    inout?: never;
-    incoming?: never;
-    outgoing?: never;
-    customRelation?: never;
-}
-interface ElementRefExpr extends Omit<BaseExpr, 'element' | 'isDescedants'> {
-    element: Fqn;
-    isDescedants?: 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;
-    };
-}
-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 ElementExpression = ElementRefExpr | WildcardExpr | ElementKindExpr | ElementTagExpr | ExpandedElementExpr;
-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 RelationExpr extends Omit<BaseExpr, 'source' | 'target'> {
-    source: ElementExpression;
-    target: ElementExpression;
-    isBidirectional?: boolean;
-}
-declare function isRelation(expr: Expression): expr is RelationExpr;
-interface InOutExpr extends Omit<BaseExpr, 'inout'> {
-    inout: ElementExpression;
+type DeploymentNodeKind<Kinds extends string = string> = Tagged<Kinds, 'DeploymentNodeKind'>;
+type DeploymentElementStyle = ElementStyle & {
+    readonly icon?: IconUrl;
+    readonly shape?: ElementShape;
+    readonly color?: Color;
+};
+interface DeploymentNodeKindSpecification {
+    readonly technology?: string;
+    readonly notation?: string;
+    readonly style: DeploymentElementStyle;
 }
-declare function isInOut(expr: Expression): expr is InOutExpr;
-interface IncomingExpr extends Omit<BaseExpr, 'incoming'> {
-    incoming: ElementExpression;
+interface DeploymentNode {
+    readonly id: Fqn;
+    readonly kind: DeploymentNodeKind;
+    readonly title: string;
+    readonly description?: string | null;
+    readonly technology?: string | null;
+    readonly tags?: NonEmptyArray<Tag> | null;
+    readonly links?: NonEmptyArray<Link> | null;
+    readonly style?: DeploymentElementStyle;
+    readonly notation?: string;
+    readonly metadata?: Record<string, string>;
 }
-declare function isIncoming(expr: Expression): expr is IncomingExpr;
-interface OutgoingExpr extends Omit<BaseExpr, 'outgoing'> {
-    outgoing: ElementExpression;
+interface DeployedInstance {
+    /**
+     * Format: `<DeploymentNode Fqn>.<Instance Id>`
+     * i.e parent fqn is deployment target
+     */
+    readonly id: Fqn;
+    readonly element: Fqn;
+    readonly title?: string;
+    readonly description?: string | null;
+    readonly technology?: string | null;
+    readonly tags?: NonEmptyArray<Tag> | null;
+    readonly links?: NonEmptyArray<Link> | null;
+    readonly style?: DeploymentElementStyle;
+    readonly notation?: string;
+    readonly metadata?: Record<string, string>;
 }
-declare function isOutgoing(expr: Expression): expr is OutgoingExpr;
-type RelationExpression = RelationExpr | InOutExpr | IncomingExpr | OutgoingExpr;
-declare function isRelationExpression(expr: Expression): expr is RelationExpression;
-interface RelationWhereExpr extends Omit<BaseExpr, 'where'> {
-    where: {
-        expr: RelationExpression;
-        condition: WhereOperator<string, string>;
-    };
+type DeploymentElement = Simplify<MergeExclusive<DeploymentNode, DeployedInstance>>;
+declare namespace DeploymentElement {
+    const isDeploymentNode: (el: DeploymentElement) => el is DeploymentNode;
+    const isInstance: (el: DeploymentElement) => el is DeployedInstance;
 }
-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;
-    };
+type PredicateSelector = 'children' | 'expanded' | 'descendants';
+interface DeploymentRef {
+    readonly id: Fqn;
+    readonly element?: Fqn;
 }
-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_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_OutgoingExpr = OutgoingExpr;
-type expression_RelationExpr = RelationExpr;
-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_ElementExpression as ElementExpression, type expression_ElementKindExpr as ElementKindExpr, type expression_ElementPredicateExpression as ElementPredicateExpression, type expression_ElementRefExpr as ElementRefExpr, type expression_ElementTagExpr as ElementTagExpr, type expression_ElementWhereExpr as ElementWhereExpr, type expression_ExpandedElementExpr as ExpandedElementExpr, type expression_Expression as Expression, type expression_InOutExpr as InOutExpr, type expression_IncomingExpr as IncomingExpr, type expression_OutgoingExpr as OutgoingExpr, type expression_RelationExpr as RelationExpr, type expression_RelationExpression as RelationExpression, type expression_RelationPredicateExpression as RelationPredicateExpression, type expression_RelationWhereExpr as RelationWhereExpr, type expression_WildcardExpr as WildcardExpr, expression_isCustomElement as isCustomElement, expression_isCustomRelationExpr as isCustomRelationExpr, expression_isElement as isElement, expression_isElementKindExpr as isElementKindExpr, expression_isElementPredicateExpr as isElementPredicateExpr, expression_isElementRef as isElementRef, expression_isElementTagExpr as isElementTagExpr, expression_isElementWhere as isElementWhere, expression_isExpandedElementExpr as isExpandedElementExpr, expression_isInOut as isInOut, expression_isIncoming as isIncoming, expression_isOutgoing as isOutgoing, expression_isRelation as isRelation, expression_isRelationExpression as isRelationExpression, expression_isRelationPredicateExpr as isRelationPredicateExpr, expression_isRelationWhere as isRelationWhere, expression_isWildcard as isWildcard };
+/**
+ * NOTE:
+ */
+interface DeploymentRelation extends AbstractRelation {
+    readonly id: RelationId;
+    readonly source: DeploymentRef;
+    readonly target: DeploymentRef;
 }
 
 /**
- * Parsed elements, relations, and views.
+ * Represents a LikeC4 model with customizable type parameters,
+ * parsed from DSL or result from Builder
+ *
+ * !IMPORTANT: This is a low-level type, use `LikeC4Model` instead.
+ * !NOTE: Views are not computed yet.
+ *
+ * @typeParam ElementKinds - Types of elements in the model (defaults to string)
+ * @typeParam RelationKinds - Types of relationships (defaults to string)
+ * @typeParam Tags - Types of tags that can be applied (defaults to string)
+ * @typeParam Fqns - Fully Qualified Names for elements (defaults to string)
+ * @typeParam Views - Types of views in the model (defaults to string)
+ * @typeParam DeploymentFqns - Fully Qualified Names for deployment nodes (defaults to string)
  */
-interface ParsedLikeC4Model<ElementKinds extends string = string, RelationKinds extends string = string, Tags extends string = string, Fqns extends string = string, Views extends string = string> {
+interface ParsedLikeC4Model<ElementKinds extends string = string, RelationKinds extends string = string, Tags extends string = string, Fqns extends string = string, Views extends string = string, DeploymentFqns extends string = string> {
+    __?: never;
     specification: {
         tags: Tag<Tags>[];
         elements: Record<ElementKinds, ElementKindSpecification>;
+        deployments: Record<DeploymentNodeKind, DeploymentNodeKindSpecification>;
         relationships: Record<RelationKinds, RelationshipKindSpecification>;
     };
     elements: Record<Fqns, TypedElement<Fqns, ElementKinds, Tags>>;
-    relations: Record<RelationID, Relation>;
+    relations: Record<RelationId, ModelRelation>;
     globals: ModelGlobals;
     views: Record<Views, LikeC4View<Views, Tags>>;
+    /**
+     * Deployment Model.
+     */
+    deployments: {
+        elements: Record<DeploymentFqns, DeploymentElement>;
+        relations: Record<RelationId, DeploymentRelation>;
+    };
 }
+type AnyParsedLikeC4Model = ParsedLikeC4Model<any, any, any, any, any, any>;
 /**
- * Same as `ParsedLikeC4Model` but with computed views.
- */
-interface ComputedLikeC4Model extends Omit<ParsedLikeC4Model, 'views'> {
-    __?: never;
-    views: Record<ViewID, ComputedView>;
-}
-/**
- * Same as `ParsedLikeC4Model` but with layouted views (DiagramView)
- */
-interface LayoutedLikeC4Model extends Omit<ParsedLikeC4Model, 'views'> {
-    __: 'layouted';
-    views: Record<ViewID, DiagramView>;
-}
-
-/**
- * OverviewGraph is a graph representation of all views in a model
+ * Hook to get types from dump
  */
-declare namespace OverviewGraph {
-    type Node = {
-        id: string;
-        type: 'folder' | 'file';
-        path: string;
-        label: string;
-        parentId: string | null;
-        position: XYPoint;
-        width: number;
-        height: number;
-    } | {
-        id: string;
-        type: 'view';
-        viewId: ViewID;
-        label: string;
-        parentId: string | null;
-        position: XYPoint;
-        width: number;
-        height: number;
+type LikeC4ModelDump = {
+    elements: {
+        [kind: string]: object;
     };
-    /**
-     * Edge represents a navigational link from one view to another
-     */
-    type Edge = {
-        id: string;
-        source: string;
-        target: string;
-        points: NonEmptyArray<Point>;
+    deployments: {
+        elements: {
+            [kind: string]: object;
+        };
+    };
+    views: {
+        [kind: string]: object;
     };
+};
+/**
+ * Same as {@link ParsedLikeC4Model}, but with computed views or layouted views.
+ */
+interface GenericLikeC4Model<Fqns extends string = string, DeploymentFqns extends string = string, Views extends string = string, Tags extends string = string, T = 'computed' | 'layouted'> extends Omit<ParsedLikeC4Model<string, string, Tags, Fqns, Views, DeploymentFqns>, 'views' | '__'> {
+    __?: T;
+    views: Record<Views, ComputedView<Views> | DiagramView<Views>>;
 }
-interface OverviewGraph {
-    nodes: OverviewGraph.Node[];
-    edges: OverviewGraph.Edge[];
-    bounds: BBox;
+interface ComputedLikeC4Model<Fqns extends string = string, DeploymentFqns extends string = string, Views extends string = string, Tags extends string = string> extends Omit<GenericLikeC4Model<Fqns, DeploymentFqns, Views, Tags, 'computed'>, 'views'> {
+    views: Record<Views, ComputedView<Views>>;
 }
-
-declare namespace ViewChange {
-    interface ChangeElementStyle {
-        op: 'change-element-style';
-        style: {
-            border?: BorderStyle;
-            opacity?: number;
-            shape?: ElementShape;
-            color?: ThemeColor;
-        };
-        targets: NonEmptyArray<Fqn>;
-    }
-    interface SaveManualLayout {
-        op: 'save-manual-layout';
-        layout: ViewManualLayout;
-    }
-    interface ChangeAutoLayout {
-        op: 'change-autolayout';
-        layout: {
-            direction: AutoLayoutDirection;
-            nodeSep?: number | null;
-            rankSep?: number | null;
-        };
-    }
+interface LayoutedLikeC4Model<Fqns extends string = string, DeploymentFqns extends string = string, Views extends string = string, Tags extends string = string> extends Omit<GenericLikeC4Model<Fqns, DeploymentFqns, Views, Tags, 'layouted'>, 'views'> {
+    __: 'layouted';
+    views: Record<Views, DiagramView<Views, Tags>>;
 }
-type ViewChange = ViewChange.ChangeElementStyle | ViewChange.SaveManualLayout | ViewChange.ChangeAutoLayout;
 
-export { type ExpandedElementExpr as $, type AutoLayoutDirection as A, type BorderStyle as B, type Color as C, type DiagramView as D, type ElementKindSpecification as E, type Fqn as F, AsFqn as G, type HexColorLiteral as H, type IconUrl as I, BorderStyles as J, ElementShapes as K, type LikeC4View as L, DefaultThemeColor as M, type NonEmptyArray as N, DefaultElementShape as O, type ParsedLikeC4Model as P, type ElementStyle as Q, type RelationshipKindSpecification as R, type TagSpec as S, type ThemeColorValues as T, type Link as U, type ViewRuleStyle as V, type TypedElement as W, type XYPoint as X, type ElementKindSpecificationStyle as Y, type ElementRefExpr as Z, isElementRef as _, type ElementShape as a, type ViewRuleGlobalPredicateRef as a$, isExpandedElementExpr as a0, isCustomElement as a1, type WildcardExpr as a2, isWildcard as a3, type ElementKindExpr as a4, isElementKindExpr as a5, type ElementTagExpr as a6, isElementTagExpr as a7, type ElementExpression as a8, isElement as a9, type TagEqual as aA, isTagEqual as aB, type KindEqual as aC, isKindEqual as aD, type NotOperator as aE, isNotOperator as aF, type AndOperator as aG, isAndOperator as aH, type OrOperator as aI, isOrOperator as aJ, type WhereOperator as aK, type Filterable as aL, whereOperatorAsPredicate as aM, OverviewGraph as aN, DefaultLineStyle as aO, DefaultArrowType as aP, DefaultRelationshipColor as aQ, type ThemeColor as aR, type ColorLiteral as aS, isThemeColor as aT, type ElementThemeColorValues as aU, type ElementThemeColors as aV, type RelationshipThemeColorValues as aW, type RelationshipThemeColors as aX, type LikeC4Theme as aY, type ViewRulePredicate as aZ, isViewRulePredicate as a_, type ElementWhereExpr as aa, isElementWhere as ab, type ElementPredicateExpression as ac, isElementPredicateExpr as ad, type RelationExpr as ae, isRelation as af, type InOutExpr as ag, isInOut as ah, type IncomingExpr as ai, isIncoming as aj, type OutgoingExpr as ak, isOutgoing as al, type RelationExpression as am, isRelationExpression as an, type RelationWhereExpr as ao, isRelationWhere as ap, isCustomRelationExpr as aq, type RelationPredicateExpression as ar, isRelationPredicateExpr as as, type GlobalPredicateId as at, type GlobalPredicates as au, type GlobalDynamicPredicates as av, type GlobalStyleID as aw, type GlobalStyles as ax, type ModelGlobals as ay, type EqualOperator as az, type RelationshipArrowType as b, isViewRuleGlobalPredicateRef as b0, isViewRuleStyle as b1, type ViewRuleGlobalStyle as b2, isViewRuleGlobalStyle as b3, type ViewRuleStyleOrGlobalRef as b4, isAutoLayoutDirection as b5, type ViewRuleAutoLayout as b6, isViewRuleAutoLayout as b7, type ViewRuleGroup as b8, isViewRuleGroup as b9, type ViewAutoLayout as bA, type ComputedElementView as bB, type ComputedDynamicView as bC, isComputedDynamicView as bD, isComputedElementView as bE, type BBox as bF, getBBoxCenter as bG, type ViewManualLayout as bH, ViewChange as bI, type ElementNotation as bJ, type ViewRule as ba, type BasicView as bb, type BasicElementView as bc, type ScopedElementView as bd, type ExtendsElementView as be, type ElementView as bf, type DynamicViewStep as bg, type DynamicViewParallelSteps as bh, type DynamicViewStepOrParallel as bi, type DynamicViewIncludeRule as bj, isDynamicViewIncludeRule as bk, type DynamicViewRule as bl, type DynamicView as bm, isDynamicViewParallelSteps as bn, type CustomColorDefinitions as bo, isDynamicView as bp, isElementView as bq, isExtendsElementView as br, isScopedElementView as bs, type StepEdgeIdLiteral as bt, StepEdgeId as bu, isStepEdgeId as bv, extractStep as bw, getParallelStepsPrefix as bx, type ViewWithHash as by, type ViewWithNotation as bz, type RelationshipLineType as c, type Element as d, type Relation as e, type Expression as f, type CustomElementExpr as g, type CustomRelationExpr as h, type RelationID as i, type ViewID as j, type EdgeId as k, type ComputedView as l, type Tag as m, ComputedNode as n, type NodeId as o, ElementKind as p, type ComputedEdge as q, type ComputedLikeC4Model as r, type LayoutedLikeC4Model as s, type RelationshipKind as t, DiagramNode as u, type DiagramEdge as v, expression as w, type NonEmptyReadonlyArray as x, type CustomColor as y, type Point as z };
+export { type GlobalDynamicPredicates as $, type CustomElementExpr as A, type CustomRelationExpr as B, ComputedView as C, DeploymentElement as D, type DirectRelationExpr as E, type ElementExpression as F, type ElementKindExpr as G, type ElementPredicateExpression as H, type ElementRefExpr as I, type ElementTagExpr as J, type ElementWhereExpr as K, type LikeC4View as L, type ExpandedElementExpr as M, type Expression as N, type IncomingExpr as O, type PredicateSelector as P, type InOutExpr as Q, type NonWilcard as R, type OutgoingExpr as S, type RelationExpression as T, type RelationPredicateExpression as U, type RelationWhereExpr as V, type WildcardExpr as W, ExpressionV2 as X, FqnExpr as Y, FqnRef as Z, RelationExpr as _, type ComputedLikeC4Model as a, type DeploymentView as a$, type GlobalPredicateId as a0, type GlobalPredicates as a1, type GlobalStyleID as a2, type GlobalStyles as a3, type ModelGlobals as a4, type AnyParsedLikeC4Model as a5, type GenericLikeC4Model as a6, type LayoutedLikeC4Model as a7, type LikeC4ModelDump as a8, type ParsedLikeC4Model as a9, extractStep as aA, getBBoxCenter as aB, getParallelStepsPrefix as aC, isAutoLayoutDirection as aD, isDeploymentView as aE, isDynamicView as aF, isDynamicViewParallelSteps as aG, isElementView as aH, isExtendsElementView as aI, isScopedElementView as aJ, isStepEdgeId as aK, isViewRuleAutoLayout as aL, isViewRuleGlobalPredicateRef as aM, isViewRuleGlobalStyle as aN, isViewRuleGroup as aO, isViewRulePredicate as aP, isViewRuleStyle as aQ, stepEdgeId as aR, type AutoLayoutDirection as aS, type BasicElementView as aT, type BasicView as aU, type BBox as aV, type ComputedDeploymentView as aW, type ComputedDynamicView as aX, type ComputedEdge as aY, type ComputedElementView as aZ, type CustomColorDefinitions as a_, isAndOperator as aa, isKindEqual as ab, isNotOperator as ac, isOrOperator as ad, isTagEqual as ae, whereOperatorAsPredicate as af, type AndOperator as ag, type EqualOperator as ah, type Filterable as ai, type KindEqual as aj, type NotOperator as ak, type OrOperator as al, type TagEqual as am, type WhereOperator as an, DefaultArrowType as ao, DefaultLineStyle as ap, DefaultRelationshipColor as aq, type AbstractRelation as ar, type ModelRelation as as, type RelationId as at, type RelationshipArrowType as au, type RelationshipKind as av, type RelationshipKindSpecification as aw, type RelationshipLineType as ax, ComputedNode as ay, DiagramNode as az, type DeployedInstance as b, type DeploymentViewRule as b0, type DeploymentViewRulePredicate as b1, type DeploymentViewRuleStyle as b2, type DiagramEdge as b3, type DiagramView as b4, type DynamicView as b5, type DynamicViewIncludeRule as b6, type DynamicViewParallelSteps as b7, type DynamicViewRule as b8, type DynamicViewStep as b9, type DynamicViewStepOrParallel as ba, type EdgeId as bb, type ElementView as bc, type ExtendsElementView as bd, type NodeId as be, type ScopedElementView as bf, type StepEdgeId as bg, type StepEdgeIdLiteral as bh, type ViewAutoLayout as bi, type ViewId as bj, type ViewManualLayout as bk, type ViewRule as bl, type ViewRuleAutoLayout as bm, type ViewRuleGlobalPredicateRef as bn, type ViewRuleGlobalStyle as bo, type ViewRuleGroup as bp, type ViewRulePredicate as bq, type ViewRuleStyle as br, type ViewRuleStyleOrGlobalRef as bs, type ViewWithHash as bt, type ViewWithNotation as bu, type ElementNotation as bv, type DeploymentElementStyle as c, type DeploymentNode as d, expression as e, type DeploymentNodeKind as f, type DeploymentNodeKindSpecification as g, type DeploymentRef as h, type DeploymentRelation as i, isCustomElement as j, isCustomRelationExpr as k, isElement as l, isElementKindExpr as m, isElementPredicateExpr as n, isElementRef as o, isElementTagExpr as p, isElementWhere as q, isExpandedElementExpr as r, isIncoming as s, isInOut as t, isOutgoing as u, isRelation as v, isRelationExpression as w, isRelationPredicateExpr as x, isRelationWhere as y, isWildcard as z };