likec4 1.17.0 → 1.18.0

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { LiteralUnion, Tagged, TupleToUnion, NonEmptyTuple, Class, IsNumericLiteral, IfNever, Simplify, SetRequired, ValueOf, ConditionalPick } from 'type-fest';
+import { LiteralUnion, Tagged, Simplify, MergeExclusive, TupleToUnion, NonEmptyTuple, UnionToIntersection, IsLiteral, SetRequired, IsNumericLiteral, IfNever, ValueOf, ConditionalPick } from 'type-fest';
 
 type NonEmptyArray<T> = [T, ...T[]];
 type IconUrl = Tagged<string, 'IconUrl'> | 'none';
@@ -8,6 +8,7 @@ interface XYPoint {
     x: number;
     y: number;
 }
+type KeysOf<T> = keyof T extends infer K extends string ? K : never;
 
 declare const ThemeColors: readonly ["amber", "blue", "gray", "slate", "green", "indigo", "muted", "primary", "red", "secondary", "sky"];
 type ThemeColor$1 = typeof ThemeColors[number];
@@ -30,7 +31,7 @@ interface ThemeColorValues {
     relationships: RelationshipThemeColorValues;
 }
 
-type Fqn$1<Id extends string = string> = Tagged<Id, 'Fqn'>;
+type Fqn<Id extends string = string> = Tagged<Id, 'Fqn'>;
 declare const BorderStyles: readonly ["solid", "dashed", "dotted", "none"];
 type BorderStyle = TupleToUnion<typeof BorderStyles>;
 type ElementKind$1<Kinds extends string = string> = Tagged<Kinds, 'ElementKind'>;
@@ -40,8 +41,13 @@ declare namespace ElementKind$1 {
 declare const ElementShapes: readonly ["rectangle", "person", "browser", "mobile", "cylinder", "storage", "queue"];
 type ElementShape$1 = TupleToUnion<typeof ElementShapes>;
 interface ElementStyle {
-    border?: BorderStyle;
-    opacity?: number;
+    readonly border?: BorderStyle;
+    /**
+     * In percentage 0-100, 0 is fully transparent
+     *
+     * @default 100
+     */
+    readonly opacity?: number;
 }
 type Tag$1<Tags extends string = string> = Tagged<Tags, 'Tag'>;
 interface Link {
@@ -50,7 +56,7 @@ interface Link {
     readonly relative?: string;
 }
 interface TypedElement<Ids extends string, Kinds extends string, Tags extends string, MetadataKeys extends string = never> {
-    readonly id: Fqn$1<Ids>;
+    readonly id: Fqn<Ids>;
     readonly kind: ElementKind$1<Kinds>;
     readonly title: string;
     readonly description: string | null;
@@ -86,30 +92,129 @@ type EqualOperator<V> = {
     eq?: never;
     neq: V;
 };
-type AllNever = {
+type AllNever$1 = {
     not?: never;
     and?: never;
     or?: never;
     tag?: never;
     kind?: never;
 };
-type TagEqual<Tag> = Omit<AllNever, 'tag'> & {
+type TagEqual<Tag> = Omit<AllNever$1, 'tag'> & {
     tag: EqualOperator<Tag>;
 };
-type KindEqual<Kind> = Omit<AllNever, 'kind'> & {
+type KindEqual<Kind> = Omit<AllNever$1, 'kind'> & {
     kind: EqualOperator<Kind>;
 };
-type NotOperator<Tag, Kind> = Omit<AllNever, 'not'> & {
+type NotOperator<Tag, Kind> = Omit<AllNever$1, 'not'> & {
     not: WhereOperator<Tag, Kind>;
 };
-type AndOperator<Tag, Kind> = Omit<AllNever, 'and'> & {
+type AndOperator<Tag, Kind> = Omit<AllNever$1, 'and'> & {
     and: NonEmptyArray<WhereOperator<Tag, Kind>>;
 };
-type OrOperator<Tag, Kind> = Omit<AllNever, 'or'> & {
+type OrOperator<Tag, Kind> = Omit<AllNever$1, 'or'> & {
     or: NonEmptyArray<WhereOperator<Tag, Kind>>;
 };
 type WhereOperator<Tag, Kind> = TagEqual<Tag> | KindEqual<Kind> | NotOperator<Tag, Kind> | AndOperator<Tag, Kind> | OrOperator<Tag, Kind>;
 
+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;
+}
+interface ExpandedElementExpr extends Omit<BaseExpr, 'expanded'> {
+    expanded: Fqn;
+}
+interface CustomElementExpr extends Omit<BaseExpr, 'custom'> {
+    custom: {
+        expr: ElementExpression$1 | ElementWhereExpr;
+        title?: string;
+        description?: string;
+        technology?: string;
+        notation?: string;
+        shape?: ElementShape$1;
+        color?: Color$1;
+        icon?: IconUrl;
+        border?: BorderStyle;
+        opacity?: number;
+        navigateTo?: ViewId;
+    };
+}
+interface WildcardExpr extends Omit<BaseExpr, 'wildcard'> {
+    wildcard: true;
+}
+interface ElementKindExpr extends Omit<BaseExpr, 'elementKind' | 'isEqual'> {
+    elementKind: ElementKind$1;
+    isEqual: boolean;
+}
+interface ElementTagExpr extends Omit<BaseExpr, 'elementTag' | 'isEqual'> {
+    elementTag: Tag$1;
+    isEqual: boolean;
+}
+type ElementExpression$1 = ElementRefExpr | WildcardExpr | ElementKindExpr | ElementTagExpr | ExpandedElementExpr;
+interface ElementWhereExpr extends Omit<BaseExpr, 'where'> {
+    where: {
+        expr: ElementExpression$1;
+        condition: WhereOperator<string, string>;
+    };
+}
+type ElementPredicateExpression = ElementExpression$1 | ElementWhereExpr | CustomElementExpr;
+interface RelationExpr extends Omit<BaseExpr, 'source' | 'target'> {
+    source: ElementExpression$1;
+    target: ElementExpression$1;
+    isBidirectional?: boolean;
+}
+interface InOutExpr extends Omit<BaseExpr, 'inout'> {
+    inout: ElementExpression$1;
+}
+interface IncomingExpr extends Omit<BaseExpr, 'incoming'> {
+    incoming: ElementExpression$1;
+}
+interface OutgoingExpr extends Omit<BaseExpr, 'outgoing'> {
+    outgoing: ElementExpression$1;
+}
+type RelationExpression$1 = RelationExpr | InOutExpr | IncomingExpr | OutgoingExpr;
+interface RelationWhereExpr extends Omit<BaseExpr, 'where'> {
+    where: {
+        expr: RelationExpression$1;
+        condition: WhereOperator<string, string>;
+    };
+}
+interface CustomRelationExpr extends Omit<BaseExpr, 'customRelation'> {
+    customRelation: {
+        relation: RelationExpression$1 | RelationWhereExpr;
+        title?: string;
+        description?: string;
+        technology?: string;
+        notation?: string;
+        navigateTo?: ViewId;
+        notes?: string;
+        color?: Color$1;
+        line?: RelationshipLineType;
+        head?: RelationshipArrowType;
+        tail?: RelationshipArrowType;
+    };
+}
+type RelationPredicateExpression = RelationExpression$1 | RelationWhereExpr | CustomRelationExpr;
+type Expression$1 = ElementPredicateExpression | RelationPredicateExpression;
+
 type GlobalPredicateId = Tagged<string, 'GlobalPredicateId'>;
 type GlobalPredicates = NonEmptyArray<ViewRulePredicate$1>;
 type GlobalDynamicPredicates = NonEmptyArray<DynamicViewIncludeRule>;
@@ -122,13 +227,13 @@ interface ModelGlobals {
 }
 
 type ElementNotation = {
-    kinds: ElementKind$1[];
+    kinds: string[];
     shape: ElementShape$1;
     color: Color$1;
     title: string;
 };
 
-type ViewID$1<Id extends string = string> = Tagged<Id, 'ViewID'>;
+type ViewId<Id extends string = string> = Tagged<Id, 'ViewID'>;
 type ViewRulePredicate$1 = {
     include: Expression$1[];
     exclude?: never;
@@ -165,9 +270,9 @@ interface ViewRuleGroup$1 {
     opacity?: number;
 }
 type ViewRule$1 = ViewRulePredicate$1 | ViewRuleGlobalPredicateRef$1 | ViewRuleGroup$1 | ViewRuleStyle$1 | ViewRuleGlobalStyle$1 | ViewRuleAutoLayout$1;
-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$1<ViewIDs>;
+    readonly id: ViewId<ViewIDs>;
     readonly title: string | null;
     readonly description: string | null;
     readonly tags: NonEmptyArray<Tag$1<Tags>> | null;
@@ -193,19 +298,19 @@ interface BasicView<ViewType extends 'element' | 'dynamic', ViewIDs extends stri
     readonly customColorDefinitions: CustomColorDefinitions;
 }
 interface BasicElementView<ViewIDs extends string, Tags extends string> extends BasicView<'element', ViewIDs, Tags> {
-    readonly viewOf?: Fqn$1;
+    readonly viewOf?: Fqn;
     readonly rules: ViewRule$1[];
 }
 interface ScopedElementView<ViewIDs extends string, Tags extends string> extends BasicElementView<ViewIDs, Tags> {
-    readonly viewOf: Fqn$1;
+    readonly viewOf: Fqn;
 }
 interface ExtendsElementView<ViewIDs extends string, Tags extends string> extends BasicElementView<ViewIDs, Tags> {
-    readonly extends: ViewID$1<ViewIDs>;
+    readonly extends: ViewId<ViewIDs>;
 }
 type ElementView$1<ViewIDs extends string = string, Tags extends string = string> = ScopedElementView<ViewIDs, Tags> | ExtendsElementView<ViewIDs, Tags> | BasicElementView<ViewIDs, Tags>;
 interface DynamicViewStep$1 {
-    readonly source: Fqn$1;
-    readonly target: Fqn$1;
+    readonly source: Fqn;
+    readonly target: Fqn;
     readonly title: string | null;
     readonly description?: string;
     readonly technology?: string;
@@ -216,7 +321,7 @@ interface DynamicViewStep$1 {
     readonly head?: RelationshipArrowType;
     readonly tail?: RelationshipArrowType;
     readonly isBackward?: boolean;
-    readonly navigateTo?: ViewID$1;
+    readonly navigateTo?: ViewId;
     __parallel?: never;
 }
 interface DynamicViewParallelSteps$1 {
@@ -235,18 +340,54 @@ interface DynamicView$1<ViewIDs extends string = string, Tags extends string = s
 type CustomColorDefinitions = {
     [key: string]: ThemeColorValues;
 };
-type LikeC4View$1<ViewIDs extends string = string, Tags extends string = string> = ElementView$1<ViewIDs, Tags> | DynamicView$1<ViewIDs, Tags>;
+type DeploymentViewRulePredicate$1 = {
+    include: DeploymentExpression$1[];
+    exclude?: never;
+} | {
+    include?: never;
+    exclude: DeploymentExpression$1[];
+};
+type DeploymentViewRuleStyle$1 = {
+    targets: DeploymentExpression$1[];
+    notation?: string;
+    style: ElementStyle & {
+        color?: Color$1;
+        shape?: ElementShape$1;
+        icon?: IconUrl;
+    };
+};
+type DeploymentViewRule$1 = DeploymentViewRulePredicate$1 | ViewRuleAutoLayout$1 | DeploymentViewRuleStyle$1;
+interface DeploymentView$1<ViewIDs extends string = string, Tags extends string = string> extends BasicView<'deployment', ViewIDs, Tags> {
+    readonly __: 'deployment';
+    readonly rules: DeploymentViewRule$1[];
+}
+type LikeC4View$1<ViewIDs extends string = string, Tags extends string = string> = ElementView$1<ViewIDs, Tags> | DynamicView$1<ViewIDs, Tags> | DeploymentView$1<ViewIDs, Tags>;
+declare function isDeploymentView(view: LikeC4View$1): view is DeploymentView$1;
+declare function isDeploymentView<V extends {
+    __?: string;
+}>(view: V): boolean;
+declare function isDynamicView(view: LikeC4View$1): view is DynamicView$1;
+declare function isElementView(view: LikeC4View$1): view is ElementView$1;
 type NodeId<IDs extends string = string> = Tagged<IDs, 'Fqn'>;
-type EdgeId$1 = Tagged<string, 'EdgeId'>;
+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 isStepEdgeId(id: string): id is StepEdgeId;
-declare function extractStep(id: EdgeId$1): number;
+declare function extractStep(id: EdgeId): number;
 interface ComputedNode {
     id: NodeId;
-    kind: ElementKind$1;
+    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;
@@ -254,19 +395,16 @@ interface ComputedNode {
     tags: NonEmptyArray<Tag$1> | null;
     links: NonEmptyArray<Link> | null;
     children: NodeId[];
-    inEdges: EdgeId$1[];
-    outEdges: EdgeId$1[];
+    inEdges: EdgeId[];
+    outEdges: EdgeId[];
     shape: ElementShape$1;
-    /**
-     * @deprecated Use `style` instead
-     */
     color: Color$1;
     /**
      * @deprecated Use `style` instead
      */
     icon?: IconUrl;
     style: ElementStyle;
-    navigateTo?: ViewID$1;
+    navigateTo?: ViewId;
     level: number;
     depth?: number;
     /**
@@ -275,20 +413,22 @@ 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
      */
     function isNodesGroup(node: ComputedNode): boolean;
 }
 interface ComputedEdge {
-    id: EdgeId$1;
+    id: EdgeId;
     parent: NodeId | null;
     source: NodeId;
     target: NodeId;
     label: string | null;
     description?: string;
     technology?: string;
-    relations: RelationID$1[];
+    relations: RelationId[];
     kind?: RelationshipKind$1;
     notation?: string;
     notes?: string;
@@ -297,7 +437,7 @@ interface ComputedEdge {
     head?: RelationshipArrowType;
     tail?: RelationshipArrowType;
     tags?: NonEmptyArray<Tag$1>;
-    navigateTo?: ViewID$1;
+    navigateTo?: ViewId;
     /**
      * If this edge is derived from custom relationship predicate
      */
@@ -306,7 +446,7 @@ interface ComputedEdge {
      * For layouting purposes
      * @default 'forward'
      */
-    dir?: 'forward' | 'back';
+    dir?: 'forward' | 'back' | 'both';
 }
 interface ViewWithHash {
     /**
@@ -326,7 +466,7 @@ interface ViewAutoLayout {
     nodeSep?: number;
 }
 interface ComputedElementView<ViewIDs extends string = string, Tags extends string = string> extends Omit<ElementView$1<ViewIDs, Tags>, 'rules' | 'docUri'>, ViewWithHash, ViewWithNotation {
-    readonly extends?: ViewID$1<ViewIDs>;
+    readonly extends?: ViewId<ViewIDs>;
     readonly autoLayout: ViewAutoLayout;
     readonly nodes: ComputedNode[];
     readonly edges: ComputedEdge[];
@@ -341,8 +481,19 @@ 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>;
+interface ComputedDeploymentView<ViewIDs extends string = string, Tags extends string = string> extends Omit<DeploymentView$1<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;
@@ -356,6 +507,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
      */
@@ -400,14 +553,14 @@ type ViewManualLayout = {
     }>;
 };
 
-type RelationID$1 = Tagged<string, 'RelationID'>;
+type RelationId = Tagged<string, 'RelationID'>;
 type RelationshipKind$1<Kinds extends string = string> = Tagged<Kinds, 'RelationshipKind'>;
 type RelationshipLineType = 'dashed' | 'solid' | 'dotted';
 type RelationshipArrowType = 'none' | 'normal' | 'onormal' | 'dot' | 'odot' | 'diamond' | 'odiamond' | 'crow' | 'open' | 'vee';
 interface Relation$1 {
-    readonly id: RelationID$1;
-    readonly source: Fqn$1;
-    readonly target: Fqn$1;
+    readonly id: RelationId;
+    readonly source: Fqn;
+    readonly target: Fqn;
     readonly title: string;
     readonly description?: string;
     readonly technology?: string;
@@ -418,7 +571,7 @@ interface Relation$1 {
     readonly head?: RelationshipArrowType;
     readonly tail?: RelationshipArrowType;
     readonly links?: NonEmptyArray<Link>;
-    readonly navigateTo?: ViewID$1;
+    readonly navigateTo?: ViewId;
     readonly metadata?: {
         [key: string]: string;
     };
@@ -432,130 +585,828 @@ 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$1;
-    isDescedants?: boolean;
-}
-interface ExpandedElementExpr extends Omit<BaseExpr, 'expanded'> {
-    expanded: Fqn$1;
+type DeploymentNodeKind$1<Kinds extends string = string> = Tagged<Kinds, 'DeploymentNodeKind'>;
+type PhysicalElementStyle = ElementStyle & {
+    readonly icon?: IconUrl;
+    readonly shape?: ElementShape$1;
+    readonly color?: Color$1;
+};
+interface DeploymentNodeKindSpecification {
+    readonly technology?: string;
+    readonly notation?: string;
+    readonly style: PhysicalElementStyle;
 }
-interface CustomElementExpr extends Omit<BaseExpr, 'custom'> {
-    custom: {
-        expr: ElementExpression$1 | ElementWhereExpr;
-        title?: string;
-        description?: string;
-        technology?: string;
-        notation?: string;
-        shape?: ElementShape$1;
-        color?: Color$1;
-        icon?: IconUrl;
-        border?: BorderStyle;
-        opacity?: number;
-        navigateTo?: ViewID$1;
-    };
+interface DeploymentNode$1 {
+    readonly id: Fqn;
+    readonly kind: DeploymentNodeKind$1;
+    readonly title: string;
+    readonly description?: string | null;
+    readonly technology?: string | null;
+    readonly tags?: NonEmptyArray<Tag$1> | null;
+    readonly links?: NonEmptyArray<Link> | null;
+    readonly style?: PhysicalElementStyle;
+    readonly notation?: string;
+    readonly metadata?: Record<string, string>;
 }
-interface WildcardExpr extends Omit<BaseExpr, 'wildcard'> {
-    wildcard: true;
+interface DeployedInstance$1 {
+    /**
+     * 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$1> | null;
+    readonly links?: NonEmptyArray<Link> | null;
+    readonly style?: PhysicalElementStyle;
+    readonly notation?: string;
+    readonly metadata?: Record<string, string>;
 }
-interface ElementKindExpr extends Omit<BaseExpr, 'elementKind' | 'isEqual'> {
-    elementKind: ElementKind$1;
-    isEqual: boolean;
+type DeploymentElement$1 = Simplify<MergeExclusive<DeploymentNode$1, DeployedInstance$1>>;
+declare namespace DeploymentElement$1 {
+    const isDeploymentNode: (el: DeploymentElement$1) => el is DeploymentNode$1;
+    const isInstance: (el: DeploymentElement$1) => el is DeployedInstance$1;
 }
-interface ElementTagExpr extends Omit<BaseExpr, 'elementTag' | 'isEqual'> {
-    elementTag: Tag$1;
-    isEqual: boolean;
+interface DeploymentRef$1 {
+    readonly id: Fqn;
+    readonly element?: Fqn;
 }
-type ElementExpression$1 = ElementRefExpr | WildcardExpr | ElementKindExpr | ElementTagExpr | ExpandedElementExpr;
-interface ElementWhereExpr extends Omit<BaseExpr, 'where'> {
-    where: {
-        expr: ElementExpression$1;
-        condition: WhereOperator<string, string>;
+/**
+ * NOTE:
+ */
+interface DeploymentRelation$1 {
+    readonly id: RelationId;
+    readonly source: DeploymentRef$1;
+    readonly target: DeploymentRef$1;
+    readonly title?: string;
+    readonly tags?: NonEmptyArray<Tag$1> | null;
+    readonly description?: string;
+    readonly technology?: string;
+    readonly kind?: RelationshipKind$1;
+    readonly color?: Color$1;
+    readonly line?: RelationshipLineType;
+    readonly head?: RelationshipArrowType;
+    readonly tail?: RelationshipArrowType;
+    readonly links?: NonEmptyArray<Link> | null;
+    readonly navigateTo?: ViewId;
+    readonly metadata?: {
+        [key: string]: string;
     };
 }
-type ElementPredicateExpression = ElementExpression$1 | ElementWhereExpr | CustomElementExpr;
-interface RelationExpr extends Omit<BaseExpr, 'source' | 'target'> {
-    source: ElementExpression$1;
-    target: ElementExpression$1;
-    isBidirectional?: boolean;
-}
-interface InOutExpr extends Omit<BaseExpr, 'inout'> {
-    inout: ElementExpression$1;
-}
-interface IncomingExpr extends Omit<BaseExpr, 'incoming'> {
-    incoming: ElementExpression$1;
-}
-interface OutgoingExpr extends Omit<BaseExpr, 'outgoing'> {
-    outgoing: ElementExpression$1;
-}
-type RelationExpression$1 = RelationExpr | InOutExpr | IncomingExpr | OutgoingExpr;
-interface RelationWhereExpr extends Omit<BaseExpr, 'where'> {
-    where: {
-        expr: RelationExpression$1;
-        condition: WhereOperator<string, string>;
+type AllNever<Expressions> = UnionToIntersection<{
+    [Name in keyof Expressions]: {
+        -readonly [Key in keyof Expressions[Name]]?: never;
     };
-}
-interface CustomRelationExpr extends Omit<BaseExpr, 'customRelation'> {
-    customRelation: {
-        relation: RelationExpression$1 | RelationWhereExpr;
-        title?: string;
-        description?: string;
-        technology?: string;
-        notation?: string;
-        navigateTo?: ViewID$1;
-        notes?: string;
-        color?: Color$1;
-        line?: RelationshipLineType;
-        head?: RelationshipArrowType;
-        tail?: RelationshipArrowType;
+}[keyof Expressions]>;
+type ExclusiveUnion<Expressions> = Expressions extends object ? {
+    [Name in keyof Expressions]: Simplify<Omit<AllNever<Expressions>, keyof Expressions[Name]> & Expressions[Name]>;
+}[keyof Expressions] : Expressions;
+declare namespace DeploymentRelationExpression$1 {
+    type Direct = {
+        source: DeploymentElementExpression$1;
+        target: DeploymentElementExpression$1;
+        isBidirectional?: boolean;
+    };
+    const isDirect: (expr: DeploymentExpression$1) => expr is Direct;
+    type Incoming = {
+        incoming: DeploymentElementExpression$1;
+    };
+    const isIncoming: (expr: DeploymentExpression$1) => expr is Incoming;
+    type Outgoing = {
+        outgoing: DeploymentElementExpression$1;
+    };
+    const isOutgoing: (expr: DeploymentExpression$1) => expr is Outgoing;
+    type InOut = {
+        inout: DeploymentElementExpression$1;
+    };
+    const isInOut: (expr: DeploymentExpression$1) => expr is InOut;
+}
+type DeploymentRelationExpression$1 = ExclusiveUnion<{
+    Direct: DeploymentRelationExpression$1.Direct;
+    Incoming: DeploymentRelationExpression$1.Incoming;
+    Outgoing: DeploymentRelationExpression$1.Outgoing;
+    InOut: DeploymentRelationExpression$1.InOut;
+}>;
+declare namespace DeploymentElementExpression$1 {
+    type Ref = {
+        ref: DeploymentRef$1;
+        selector?: 'children' | 'expanded' | 'descendants';
     };
+    const isRef: (expr: DeploymentExpression$1) => expr is Ref;
+    type Wildcard = {
+        wildcard: true;
+    };
+    const isWildcard: (expr: DeploymentExpression$1) => expr is Wildcard;
+}
+type DeploymentElementExpression$1 = ExclusiveUnion<{
+    DeploymentRef: DeploymentElementExpression$1.Ref;
+    Wildcard: DeploymentElementExpression$1.Wildcard;
+}>;
+type DeploymentExpression$1 = ExclusiveUnion<{
+    Element: DeploymentElementExpression$1;
+    Relation: DeploymentRelationExpression$1;
+}>;
+declare namespace DeploymentExpression$1 {
+    type Element = DeploymentElementExpression$1;
+    type Relation = DeploymentRelationExpression$1;
+    const isElement: (expr: DeploymentExpression$1) => expr is DeploymentElementExpression$1;
+    const isRelation: (expr: DeploymentExpression$1) => expr is DeploymentRelationExpression$1;
 }
-type RelationPredicateExpression = RelationExpression$1 | RelationWhereExpr | CustomRelationExpr;
-type Expression$1 = ElementPredicateExpression | RelationPredicateExpression;
 
 /**
  * Parsed elements, relations, and views.
  */
-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> {
     specification: {
         tags: Tag$1<Tags>[];
         elements: Record<ElementKinds, ElementKindSpecification>;
+        deployments: Record<DeploymentNodeKind$1, DeploymentNodeKindSpecification>;
         relationships: Record<RelationKinds, RelationshipKindSpecification>;
     };
     elements: Record<Fqns, TypedElement<Fqns, ElementKinds, Tags>>;
-    relations: Record<RelationID$1, Relation$1>;
+    relations: Record<RelationId, Relation$1>;
     globals: ModelGlobals;
     views: Record<Views, LikeC4View$1<Views, Tags>>;
+    /**
+     * Deployment Model.
+     */
+    deployments: {
+        elements: Record<DeploymentFqns, DeploymentElement$1>;
+        relations: Record<RelationId, DeploymentRelation$1>;
+    };
+}
+/**
+ * Hook to get types from dump
+ */
+type ParsedLikeC4ModelDump = {
+    elements: {
+        [kind: string]: object;
+    };
+    deployments: {
+        elements: {
+            [kind: string]: object;
+        };
+    };
+    views: {
+        [kind: string]: object;
+    };
+};
+interface AnyLikeC4Model<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 | DiagramView>;
+}
+/**
+ * Same as `ParsedLikeC4Model` but with computed views.
+ */
+interface ComputedLikeC4Model<Fqns extends string = string, DeploymentFqns extends string = string, Views extends string = string, Tags extends string = string> extends Omit<AnyLikeC4Model<Fqns, DeploymentFqns, Views, Tags, 'computed'>, 'views'> {
+    views: Record<Views, ComputedView>;
+}
+/**
+ * Same as `ParsedLikeC4Model` but with layouted views (DiagramView)
+ */
+interface LayoutedLikeC4Model<Fqns extends string = string, DeploymentFqns extends string = string, Views extends string = string, Tags extends string = string> extends Omit<AnyLikeC4Model<Fqns, DeploymentFqns, Views, Tags, 'layouted'>, 'views'> {
+    __: 'layouted';
+    views: Record<Views, DiagramView<Views, Tags>>;
+}
+
+type IncomingFilter = 'all' | 'direct' | 'to-descendants';
+type OutgoingFilter = 'all' | 'direct' | 'from-descendants';
+type IteratorLike<T> = IteratorObject<T, BuiltinIteratorReturn>;
+type WithId<Id> = {
+    id: Id;
+};
+type WithViews<Id extends string, ViewType> = {
+    views: Record<Id, ViewType>;
+};
+type AnyAux = Aux<string, string, string, any>;
+/**
+ * Auxilary type to keep track
+ */
+interface Aux<Element extends string, Deployment extends string, Views extends string, ViewType> {
+    Fqn: IsLiteral<Element> extends true ? Fqn<Element> : Fqn;
+    Element: Element;
+    ElementOrFqn: Element | WithId<this['Fqn']>;
+    DeploymentFqn: IsLiteral<Deployment> extends true ? Fqn<Deployment> : Fqn;
+    Deployment: Deployment;
+    DeploymentOrFqn: Deployment | WithId<this['DeploymentFqn']>;
+    ViewId: IsLiteral<Views> extends true ? ViewId<Views> : ViewId;
+    ViewIdLiteral: Views;
+    ViewType: ViewType;
+    RelationId: RelationId;
+    NodeId: NodeId;
+    NodeIdLiteral: string;
+    EdgeId: EdgeId;
+    EdgeIdLiteral: string;
+    NodeOrId: LiteralUnion<this['NodeIdLiteral'], string> | WithId<this['NodeId']>;
+    EdgeOrId: LiteralUnion<this['EdgeIdLiteral'], string> | WithId<this['EdgeId']>;
+    Model: Simplify<Omit<AnyLikeC4Model, 'views'> & WithViews<this['ViewId'], ViewType>>;
+}
+declare namespace Aux {
+    type FromModel<M> = M extends AnyLikeC4Model ? Aux<KeysOf<M['elements']>, KeysOf<M['deployments']['elements']>, KeysOf<M['views']>, M extends LayoutedLikeC4Model ? DiagramView<ViewId<KeysOf<M['views']>>, string> : ComputedView<ViewId<KeysOf<M['views']>>, string>> : never;
+    type FromDump<M> = M extends ParsedLikeC4ModelDump ? Aux<KeysOf<M['elements']>, KeysOf<M['deployments']['elements']>, KeysOf<M['views']>, DiagramView<ViewId<KeysOf<M['views']>>, string>> : never;
+}
+
+type RelationshipsIterator<M extends AnyAux> = IteratorLike<RelationshipModel<M>>;
+declare class RelationshipModel<M extends AnyAux> {
+    readonly model: LikeC4Model<M>;
+    readonly $relationship: Relation$1;
+    readonly source: ElementModel<M>;
+    readonly target: ElementModel<M>;
+    /**
+     * Common ancestor of the source and target elements.
+     * Represents the boundary of the Relation.
+     */
+    readonly boundary: ElementModel<M> | null;
+    constructor(model: LikeC4Model<M>, $relationship: Relation$1);
+    get id(): M['RelationId'];
+    get expression(): string;
+    get title(): string | null;
+    get technology(): string | null;
+    get description(): string | null;
+    get navigateTo(): LikeC4ViewModel<M> | null;
+    get tags(): ReadonlyArray<Tag$1>;
+    get links(): ReadonlyArray<Link>;
+    /**
+     * Iterate over all views that include this relationship.
+     */
+    views(): ViewsIterator<M>;
+}
+
+type ElementsIterator<M extends AnyAux> = IteratorLike<ElementModel<M>>;
+declare class ElementModel<M extends AnyAux> {
+    readonly model: LikeC4Model<M>;
+    readonly $element: Element$1;
+    constructor(model: LikeC4Model<M>, $element: Element$1);
+    get id(): M['Fqn'];
+    get kind(): ElementKind$1;
+    get shape(): ElementShape$1;
+    get color(): ThemeColor$1;
+    get tags(): ReadonlyArray<Tag$1>;
+    get title(): string;
+    get description(): string | null;
+    get technology(): string | null;
+    get links(): ReadonlyArray<Link>;
+    get parent(): ElementModel<M> | null;
+    get defaultView(): LikeC4ViewModel<M> | null;
+    /**
+     * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
+     * (from closest to root)
+     */
+    ancestors(): ElementsIterator<M>;
+    /**
+     * Returns the common ancestor of this element and another element.
+     */
+    commonAncestor(another: ElementModel<M>): ElementModel<M> | null;
+    children(): ReadonlySet<ElementModel<M>>;
+    /**
+     * Get all descendant elements (i.e. children, children’s children, etc.)
+     */
+    descendants(): ElementsIterator<M>;
+    /**
+     * Get all sibling (i.e. same parent)
+     */
+    siblings(): ElementsIterator<M>;
+    /**
+     * Resolve siblings of the element and its ancestors
+     *  (from closest to root)
+     */
+    ascendingSiblings(): ElementsIterator<M>;
+    incoming(filter?: IncomingFilter): RelationshipsIterator<M>;
+    incomers(filter?: IncomingFilter): ElementsIterator<M>;
+    outgoing(filter?: OutgoingFilter): RelationshipsIterator<M>;
+    outgoers(filter?: OutgoingFilter): ElementsIterator<M>;
+    protected cachedOutgoing: Set<RelationshipModel<M>> | null;
+    protected cachedIncoming: Set<RelationshipModel<M>> | null;
+    get allOutgoing(): ReadonlySet<RelationshipModel<M>>;
+    get allIncoming(): ReadonlySet<RelationshipModel<M>>;
+    /**
+     * Iterate over all views that include this element.
+     */
+    views(): ViewsIterator<M>;
+    /**
+     * Iterate over all views that scope this element.
+     * It is possible that element is not included in the view.
+     */
+    scopedViews(): ViewsIterator<M>;
+    /**
+     * @returns true if the element is deployed
+     */
+    isDeployed(): boolean;
+    deployments(): DeployedInstancesIterator<M>;
+}
+
+type NodesIterator<M extends AnyAux, V extends ComputedView | DiagramView> = IteratorLike<NodeModel<M, V>>;
+declare namespace NodeModel {
+    interface WithParent<M extends AnyAux, V extends ComputedView | DiagramView> extends NodeModel<M, V> {
+        parent: NodeModel<M, V>;
+    }
+    interface WithElement<M extends AnyAux, V extends ComputedView | DiagramView> extends NodeModel<M, V> {
+        kind: ElementKind$1;
+        element: ElementModel<M>;
+    }
+    interface WithDeploymentElement<M extends AnyAux, V extends ComputedView | DiagramView> extends NodeModel<M, V> {
+        kind: DeploymentNodeKind$1;
+        deployment: DeploymentElementModel<M>;
+    }
+    interface WithDeployedInstance<M extends AnyAux, V extends ComputedView | DiagramView> extends NodeModel<M, V> {
+        kind: 'instance';
+        element: ElementModel<M>;
+        deployment: DeployedInstanceModel<M>;
+    }
+    interface IsGroup<M extends AnyAux, V extends ComputedView | DiagramView> extends NodeModel<M, V> {
+        kind: typeof ElementKind$1.Group;
+        element: null;
+        deployment: null;
+    }
+}
+declare class NodeModel<M extends AnyAux, V extends ComputedView | DiagramView = M['ViewType']> {
+    readonly $view: LikeC4ViewModel<M, V>;
+    readonly $node: V['nodes'][number];
+    constructor($view: LikeC4ViewModel<M, V>, $node: V['nodes'][number]);
+    get id(): NodeId;
+    get title(): string;
+    get kind(): ElementKind$1 | DeploymentNodeKind$1 | typeof ElementKind$1.Group | 'instance';
+    get description(): string | null;
+    get technology(): string | null;
+    get parent(): NodeModel<M, V> | null;
+    get element(): ElementModel<M> | null;
+    get deployment(): DeploymentElementModel<M> | null;
+    get shape(): ElementShape$1;
+    get color(): Color$1;
+    get tags(): ReadonlyArray<Tag$1>;
+    get links(): ReadonlyArray<Link>;
+    get navigateTo(): LikeC4ViewModel<M> | null;
+    /**
+     * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
+     * (from closest to root)
+     */
+    ancestors(): NodesIterator<M, V>;
+    children(): NodesIterator<M, V>;
+    sublings(): NodesIterator<M, V>;
+    incoming(filter?: IncomingFilter): EdgesIterator<M, V>;
+    incomers(filter?: IncomingFilter): NodesIterator<M, V>;
+    outgoing(filter?: OutgoingFilter): EdgesIterator<M, V>;
+    outgoers(filter?: OutgoingFilter): NodesIterator<M, V>;
+    isDiagramNode(): this is NodeModel<M, DiagramView>;
+    hasChildren(): boolean;
+    hasParent(): this is NodeModel.WithParent<M, V>;
+    /**
+     * Check if this node references to logical model element.
+     */
+    hasElement(): this is NodeModel.WithElement<M, V>;
+    /**
+     * Check if this node references to deployment element (Node or Instance).
+     */
+    hasDeployment(): this is NodeModel.WithDeploymentElement<M, V>;
+    /**
+     * Check if this node references to deployed instance
+     * Deployed instance always references to element and deployment element.
+     */
+    hasDeployedInstance(): this is NodeModel.WithDeployedInstance<M, V>;
+    isGroup(): this is NodeModel.IsGroup<M, V>;
+}
+
+type EdgesIterator<M extends AnyAux, V extends ComputedView | DiagramView> = IteratorLike<EdgeModel<M, V>>;
+declare class EdgeModel<M extends AnyAux, V extends ComputedView | DiagramView = M['ViewType']> {
+    readonly view: LikeC4ViewModel<M, V>;
+    readonly $edge: V['edges'][number];
+    readonly source: NodeModel<M, V>;
+    readonly target: NodeModel<M, V>;
+    constructor(view: LikeC4ViewModel<M, V>, $edge: V['edges'][number], source: NodeModel<M, V>, target: NodeModel<M, V>);
+    get id(): M['EdgeId'];
+    get parent(): NodeModel<M, V> | null;
+    get label(): string | null;
+    get description(): string | null;
+    get technology(): string | null;
+    hasParent(): this is EdgeModel.WithParent<M, V>;
+    get tags(): ReadonlyArray<Tag$1>;
+    get stepNumber(): number | null;
+    get navigateTo(): LikeC4ViewModel<M> | null;
+    isStep(): this is EdgeModel.StepEdge<M, ComputedDynamicView>;
+    relationships(type: 'model'): IteratorLike<RelationshipModel<M>>;
+    relationships(type: 'deployment'): IteratorLike<DeploymentRelationModel<M>>;
+    relationships(type?: 'model' | 'deployment'): IteratorLike<LikeC4Model.AnyRelation<M>>;
+    includesRelation(rel: M['RelationId']): boolean;
+}
+declare namespace EdgeModel {
+    interface StepEdge<M extends AnyAux, V extends ComputedView | DiagramView> extends EdgeModel<M, V> {
+        id: StepEdgeId;
+        stepNumber: number;
+    }
+    interface WithParent<M extends AnyAux, V extends ComputedView | DiagramView> extends EdgeModel<M, V> {
+        parent: NodeModel<M, V>;
+    }
+}
+
+type ViewsIterator<M extends AnyAux> = IteratorLike<LikeC4ViewModel<M>>;
+declare class LikeC4ViewModel<M extends AnyAux, V extends ComputedView | DiagramView = M['ViewType']> {
+    #private;
+    readonly $model: LikeC4Model<M>;
+    readonly $view: V;
+    constructor($model: LikeC4Model<M>, $view: V);
+    get __(): NonNullable<M['ViewType']['__']>;
+    get id(): M['ViewId'];
+    get title(): string | null;
+    get tags(): ReadonlyArray<Tag$1>;
+    get links(): ReadonlyArray<Link>;
+    get viewOf(): ElementModel<M> | null;
+    /**
+     * All tags from nodes and edges.
+     */
+    get includedTags(): ReadonlyArray<Tag$1>;
+    roots(): NodesIterator<M, V>;
+    /**
+     * Iterate over all nodes that have children.
+     */
+    compounds(): NodesIterator<M, V>;
+    /**
+     * Get node by id.
+     * @throws Error if node is not found.
+     */
+    node(node: M['NodeOrId']): NodeModel<M, V>;
+    /**
+     * Find node by id.
+     */
+    findNode(node: M['NodeOrId']): NodeModel<M, V> | null;
+    /**
+     * Iterate over all nodes.
+     */
+    nodes(): NodesIterator<M, V>;
+    /**
+     * Find edge by id.
+     * @param edge Edge or id
+     * @returns EdgeModel
+     */
+    edge(edge: M['EdgeOrId']): EdgeModel<M, V>;
+    findEdge(edge: M['EdgeOrId']): EdgeModel<M, V> | null;
+    /**
+     * Iterate over all edges.
+     */
+    edges(): EdgesIterator<M, V>;
+    /**
+     * Iterate over all edges.
+     */
+    edgesWithRelation(relation: M['RelationId']): EdgesIterator<M, V>;
+    /**
+     * Nodes that have references to elements from logical model.
+     */
+    elements(): IteratorLike<NodeModel.WithElement<M, V>>;
+    includesElement(elementId: M['Element']): boolean;
+    includesDeployment(deploymentId: M['Deployment']): boolean;
+    includesRelation(relationId: M['RelationId']): boolean;
+    /**
+     * Below are type guards.
+     */
+    isComputed(): this is LikeC4ViewModel<M, ComputedView>;
+    isDiagram(): this is LikeC4ViewModel<M, DiagramView>;
+    isElementView(): this is LikeC4ViewModel<M, ComputedElementView>;
+    isDeploymentView(): this is LikeC4ViewModel<M, ComputedDeploymentView>;
+    isDynamicView(): this is LikeC4ViewModel<M, ComputedDynamicView>;
+}
+
+declare class LikeC4DeploymentModel<M extends AnyAux = AnyAux> {
+    #private;
+    readonly $model: LikeC4Model<M>;
+    readonly $deployments: AnyLikeC4Model['deployments'];
+    constructor($model: LikeC4Model<M>, $deployments: AnyLikeC4Model['deployments']);
+    element(el: M['DeploymentOrFqn']): DeploymentElementModel<M>;
+    findElement(el: M['Deployment']): DeploymentElementModel<M> | null;
+    node(el: M['DeploymentOrFqn']): DeploymentNodeModel<M>;
+    findNode(el: M['Deployment']): DeploymentNodeModel<M> | null;
+    instance(el: M['DeploymentOrFqn']): DeployedInstanceModel<M>;
+    findInstance(el: M['Deployment']): DeployedInstanceModel<M> | null;
+    /**
+     * Returns the root elements of the model.
+     */
+    roots(): DeploymentNodesIterator<M>;
+    /**
+     * Returns all elements in the model.
+     */
+    elements(): DeploymentElementsIterator<M>;
+    /**
+     * Returns all elements in the model.
+     */
+    nodes(): DeploymentNodesIterator<M>;
+    instances(): DeployedInstancesIterator<M>;
+    /**
+     * Iterate over all instances of the given logical element.
+     */
+    instancesOf(element: M['ElementOrFqn']): DeployedInstancesIterator<M>;
+    deploymentRef(ref: DeploymentRef$1): DeploymentElementModel<M> | NestedElementOfDeployedInstanceModel<M>;
+    /**
+     * Returns all relationships in the model.
+     */
+    relationships(): IteratorLike<DeploymentRelationModel<M>>;
+    /**
+     * Returns a specific relationship by its ID.
+     */
+    relationship(id: M['RelationId']): DeploymentRelationModel<M>;
+    findRelationship(id: LiteralUnion<M['RelationId'], string>): DeploymentRelationModel<M> | null;
+    /**
+     * Returns all deployment views in the model.
+     */
+    views(): IteratorLike<LikeC4ViewModel<M, ComputedDeploymentView>>;
+    /**
+     * Returns the parent element of given element.
+     * @see ancestors
+     */
+    parent(element: M['DeploymentOrFqn']): DeploymentNodeModel<M> | null;
+    /**
+     * Get all children of the element (only direct children),
+     * @see descendants
+     */
+    children(element: M['DeploymentOrFqn']): ReadonlySet<DeploymentElementModel<M>>;
+    /**
+     * Get all sibling (i.e. same parent)
+     */
+    siblings(element: M['DeploymentOrFqn']): DeploymentElementsIterator<M>;
+    /**
+     * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
+     * (from closest to root)
+     */
+    ancestors(element: M['DeploymentOrFqn']): DeploymentNodesIterator<M>;
+    /**
+     * Get all descendant elements (i.e. children, children’s children, etc.)
+     */
+    descendants(element: M['DeploymentOrFqn']): DeploymentElementsIterator<M>;
+    /**
+     * Incoming relationships to the element and its descendants
+     * @see incomers
+     */
+    incoming(element: M['DeploymentOrFqn'], filter?: IncomingFilter): IteratorLike<DeploymentRelationModel<M>>;
+    /**
+     * Outgoing relationships from the element and its descendants
+     * @see outgoers
+     */
+    outgoing(element: M['DeploymentOrFqn'], filter?: OutgoingFilter): IteratorLike<DeploymentRelationModel<M>>;
+    private addElement;
+    private addRelation;
+}
+
+type DeploymentElementsIterator<M extends AnyAux> = IteratorLike<DeploymentElementModel<M>>;
+type DeployedInstancesIterator<M extends AnyAux> = IteratorLike<DeployedInstanceModel<M>>;
+type DeploymentNodesIterator<M extends AnyAux> = IteratorLike<DeploymentNodeModel<M>>;
+declare abstract class DeploymentElementModel<M extends AnyAux = AnyAux> {
+    abstract readonly $model: LikeC4DeploymentModel<M>;
+    abstract readonly $node: DeploymentNode$1 | DeployedInstance$1;
+    get id(): M['DeploymentFqn'];
+    get style(): SetRequired<PhysicalElementStyle, 'shape' | 'color'>;
+    get shape(): ElementShape$1;
+    get color(): ThemeColor$1;
+    get tags(): ReadonlyArray<Tag$1>;
+    get title(): string;
+    get description(): string | null;
+    get technology(): string | null;
+    get parent(): DeploymentNodeModel<M> | null;
+    get links(): ReadonlyArray<Link>;
+    /**
+     * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
+     * (from closest to root)
+     */
+    ancestors(): DeploymentNodesIterator<M>;
+    /**
+     * Returns the common ancestor of this element and another element.
+     */
+    commonAncestor(another: DeploymentElementModel<M>): DeploymentNodeModel<M> | null;
+    /**
+     * Get all sibling (i.e. same parent)
+     */
+    siblings(): DeploymentElementsIterator<M>;
+    /**
+     * Check if the element is a sibling of another element
+     */
+    isSibling(other: DeploymentElementModel<M>): boolean;
+    /**
+     * Resolve siblings of the element and its ancestors
+     *  (from closest to root)
+     */
+    ascendingSiblings(): DeploymentElementsIterator<M>;
+    incoming(filter?: IncomingFilter): IteratorLike<DeploymentRelationModel<M>>;
+    outgoing(filter?: OutgoingFilter): IteratorLike<DeploymentRelationModel<M>>;
+    incomers(filter?: IncomingFilter): IteratorLike<DeploymentRelationEndpoint<M>>;
+    outgoers(filter?: OutgoingFilter): IteratorLike<DeploymentRelationEndpoint<M>>;
+    /**
+     * Iterate over all views that include this deployment element.
+     */
+    views(): IteratorLike<LikeC4ViewModel<M, ComputedDeploymentView>>;
+    isDeploymentNode(): this is DeploymentNodeModel<M>;
+    isInstance(): this is DeployedInstanceModel<M>;
+    abstract outgoingFromModel(): RelationshipsIterator<M>;
+    abstract incomingFromModel(): RelationshipsIterator<M>;
+    protected cachedOutgoing: RelationshipsAccum<M> | null;
+    protected cachedIncoming: RelationshipsAccum<M> | null;
+    get allOutgoing(): RelationshipsAccum<M>;
+    get allIncoming(): RelationshipsAccum<M>;
+}
+declare class DeploymentNodeModel<M extends AnyAux = AnyAux> extends DeploymentElementModel<M> {
+    readonly $model: LikeC4DeploymentModel<M>;
+    readonly $node: DeploymentNode$1;
+    constructor($model: LikeC4DeploymentModel<M>, $node: DeploymentNode$1);
+    get kind(): DeploymentNodeKind$1;
+    children(): ReadonlySet<DeploymentElementModel<M>>;
+    descendants(): DeploymentElementsIterator<M>;
+    isDeploymentNode(): this is DeploymentNodeModel<M>;
+    /**
+     * Iterate over all instances nested in this deployment node.
+     */
+    instances(): DeployedInstancesIterator<M>;
+    /**
+     * Returns deployed instance inside this deployment node
+     * if only there are no more instances
+     */
+    onlyOneInstance(): DeployedInstanceModel<M> | null;
+    /**
+     * Cached result of relationships from instances
+     */
+    private _relationshipsFromInstances;
+    private relationshipsFromInstances;
+    /**
+     * We return only relationships that are not already present in nested instances
+     */
+    outgoingFromModel(): RelationshipsIterator<M>;
+    /**
+     * We return only relationships that are not already present in nested instances
+     */
+    incomingFromModel(): RelationshipsIterator<M>;
+}
+declare class DeployedInstanceModel<M extends AnyAux = AnyAux> extends DeploymentElementModel<M> {
+    readonly $model: LikeC4DeploymentModel<M>;
+    readonly $instance: DeployedInstance$1;
+    readonly $element: ElementModel<M>;
+    constructor($model: LikeC4DeploymentModel<M>, $instance: DeployedInstance$1, $element: ElementModel<M>);
+    get parent(): DeploymentNodeModel<M>;
+    get $node(): DeployedInstance$1;
+    get style(): SetRequired<PhysicalElementStyle, 'shape' | 'color'>;
+    get shape(): ElementShape$1;
+    get color(): ThemeColor$1;
+    get tags(): ReadonlyArray<Tag$1>;
+    get title(): string;
+    get description(): string | null;
+    get technology(): string | null;
+    get links(): ReadonlyArray<Link>;
+    isInstance(): this is DeployedInstanceModel<M>;
+    outgoingFromModel(): RelationshipsIterator<M>;
+    incomingFromModel(): RelationshipsIterator<M>;
+}
+declare class NestedElementOfDeployedInstanceModel<M extends AnyAux> {
+    readonly instance: DeployedInstanceModel<M>;
+    readonly element: ElementModel<M>;
+    constructor(instance: DeployedInstanceModel<M>, element: ElementModel<M>);
+    get id(): M['DeploymentFqn'];
+    get style(): SetRequired<PhysicalElementStyle, 'shape' | 'color'>;
+    get shape(): ElementShape$1;
+    get color(): ThemeColor$1;
+    get title(): string;
+    get description(): string | null;
+    get technology(): string | null;
+    isDeploymentNode(): this is DeploymentNodeModel<M>;
+    isInstance(): this is DeployedInstanceModel<M>;
+}
+type DeploymentRelationEndpoint<M extends AnyAux> = DeploymentElementModel<M> | NestedElementOfDeployedInstanceModel<M>;
+declare class DeploymentRelationModel<M extends AnyAux> {
+    readonly $model: LikeC4DeploymentModel<M>;
+    readonly $relationship: DeploymentRelation$1;
+    boundary: DeploymentNodeModel<M> | null;
+    source: DeploymentRelationEndpoint<M>;
+    target: DeploymentRelationEndpoint<M>;
+    constructor($model: LikeC4DeploymentModel<M>, $relationship: DeploymentRelation$1);
+    get id(): M['RelationId'];
+    get expression(): string;
+    get title(): string | null;
+    get technology(): string | null;
+    get description(): string | null;
+    get tags(): ReadonlyArray<Tag$1>;
+    get navigateTo(): LikeC4ViewModel<M> | null;
+    get links(): ReadonlyArray<Link>;
+    views(): IteratorLike<LikeC4ViewModel<M, ComputedDeploymentView>>;
+}
+declare class RelationshipsAccum<M extends AnyAux> {
+    readonly model: ReadonlySet<RelationshipModel<M>>;
+    readonly deployment: ReadonlySet<DeploymentRelationModel<M>>;
+    /**
+     * @param model relationships from logical model
+     * @param deployment relationships from deployment model
+     */
+    constructor(model: ReadonlySet<RelationshipModel<M>>, deployment: ReadonlySet<DeploymentRelationModel<M>>);
+    get isEmpty(): boolean;
+    get nonEmpty(): boolean;
+    get size(): number;
+    /**
+     * Returns new Accum containing all the elements which are both in this and otherAccum
+     */
+    intersect(otherAccum: RelationshipsAccum<M>): RelationshipsAccum<M>;
+    /**
+     * Returns new Accum containing all the elements which are both in this and otherAccum
+     */
+    difference(otherAccum: RelationshipsAccum<M>): RelationshipsAccum<M>;
+    /**
+     * Returns new Accum containing all the elements from both
+     */
+    union(otherAccum: RelationshipsAccum<M>): RelationshipsAccum<M>;
 }
-/**
- * Same as `ParsedLikeC4Model` but with computed views.
- */
-interface ComputedLikeC4Model extends Omit<ParsedLikeC4Model, 'views'> {
-    __?: never;
-    views: Record<ViewID$1, ComputedView>;
+
+declare class LikeC4Model<M extends AnyAux = LikeC4Model.Any> {
+    #private;
+    readonly $model: M['Model'];
+    /**
+     * Only available in compile time
+     */
+    readonly Aux: M;
+    readonly deployment: LikeC4DeploymentModel<M>;
+    static create<const M extends AnyLikeC4Model>(model: M): LikeC4Model<Aux.FromModel<M>>;
+    /**
+     * This method is supposed to be used only in dumps
+     */
+    static fromDump<const M extends ParsedLikeC4ModelDump>(dump: M): LikeC4Model<Aux.FromDump<M>>;
+    private constructor();
+    get type(): 'computed' | 'layouted';
+    element(el: M['ElementOrFqn']): ElementModel<M>;
+    findElement(el: LiteralUnion<M['Element'], string>): ElementModel<M> | null;
+    /**
+     * Returns the root elements of the model.
+     */
+    roots(): ElementsIterator<M>;
+    /**
+     * Returns all elements in the model.
+     */
+    elements(): ElementsIterator<M>;
+    /**
+     * Returns all relationships in the model.
+     */
+    relationships(): RelationshipsIterator<M>;
+    /**
+     * Returns a specific relationship by its ID.
+     * If the relationship is not found in the model, it will be searched in the deployment model.
+     * Search can be limited to the model or deployment model only.
+     */
+    relationship(id: M['RelationId'], type: 'model'): RelationshipModel<M>;
+    relationship(id: M['RelationId'], type: 'deployment'): DeploymentRelationModel<M>;
+    relationship(id: M['RelationId'], type?: 'model' | 'deployment'): RelationshipModel<M> | DeploymentRelationModel<M>;
+    findRelationship(id: LiteralUnion<M['RelationId'], string>, type: 'model'): RelationshipModel<M> | null;
+    findRelationship(id: LiteralUnion<M['RelationId'], string>, type: 'deployment'): DeploymentRelationModel<M> | null;
+    findRelationship(id: LiteralUnion<M['RelationId'], string>, type?: 'model' | 'deployment'): RelationshipModel<M> | DeploymentRelationModel<M> | null;
+    /**
+     * Returns all views in the model.
+     */
+    views(): MapIterator<LikeC4ViewModel<M, M["ViewType"]>>;
+    /**
+     * Returns a specific view by its ID.
+     */
+    view(viewId: M['ViewIdLiteral']): LikeC4ViewModel<M>;
+    findView(viewId: LiteralUnion<M['ViewId'], string>): LikeC4ViewModel<M>;
+    /**
+     * Returns the parent element of given element.
+     * @see ancestors
+     */
+    parent(element: M['ElementOrFqn']): ElementModel<M> | null;
+    /**
+     * Get all children of the element (only direct children),
+     * @see descendants
+     */
+    children(element: M['ElementOrFqn']): ReadonlySet<ElementModel<M>>;
+    /**
+     * Get all sibling (i.e. same parent)
+     */
+    siblings(element: M['ElementOrFqn']): ElementsIterator<M>;
+    /**
+     * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
+     * (from closest to root)
+     */
+    ancestors(element: M['ElementOrFqn']): ElementsIterator<M>;
+    /**
+     * Get all descendant elements (i.e. children, children’s children, etc.)
+     */
+    descendants(element: M['ElementOrFqn']): ElementsIterator<M>;
+    /**
+     * Incoming relationships to the element and its descendants
+     * @see incomers
+     */
+    incoming(element: M['ElementOrFqn'], filter?: IncomingFilter): RelationshipsIterator<M>;
+    /**
+     * Outgoing relationships from the element and its descendants
+     * @see outgoers
+     */
+    outgoing(element: M['ElementOrFqn'], filter?: OutgoingFilter): RelationshipsIterator<M>;
+    private addElement;
+    private addRelation;
 }
-/**
- * Same as `ParsedLikeC4Model` but with layouted views (DiagramView)
- */
-interface LayoutedLikeC4Model extends Omit<ParsedLikeC4Model, 'views'> {
-    __: 'layouted';
-    views: Record<ViewID$1, DiagramView>;
+declare namespace LikeC4Model {
+    type Any = Aux<string, string, string, ComputedView | DiagramView>;
+    type Element<M extends AnyAux = Any> = ElementModel<M>;
+    type Relation<M extends AnyAux = Any> = RelationshipModel<M>;
+    type AnyRelation<M extends AnyAux = Any> = RelationshipModel<M> | DeploymentRelationModel<M>;
+    type View<M extends AnyAux = Any, V extends ComputedView | DiagramView = M['ViewType']> = LikeC4ViewModel<M, V>;
+    type Node<M extends AnyAux = Any, V extends ComputedView | DiagramView = M['ViewType']> = NodeModel<M, V>;
+    type Edge<M extends AnyAux = Any, V extends ComputedView | DiagramView = M['ViewType']> = EdgeModel<M, V>;
+    type DeploymentModel<M extends AnyAux = AnyAux> = LikeC4DeploymentModel<M>;
+    type Deployment<M extends AnyAux = AnyAux> = DeploymentElementModel<M>;
+    type DeploymentNode<M extends AnyAux = AnyAux> = DeploymentNodeModel<M>;
+    type DeployedInstance<M extends AnyAux = AnyAux> = DeployedInstanceModel<M>;
+    type Typed<Elements extends string = string, Deployments extends string = string, Views extends string = string, ViewType = DiagramView<Views> | ComputedView<Views>> = Aux<Elements, Deployments, Views, ViewType>;
+    type Computed<Elements extends string = string, Deployments extends string = string, Views extends string = string> = LikeC4Model<Typed<Elements, Deployments, Views, ComputedView<Views>>>;
+    type Layouted<Elements extends string = string, Deployments extends string = string, Views extends string = string> = LikeC4Model<Typed<Elements, Deployments, Views, DiagramView<Views>>>;
 }
 
 /**
@@ -574,7 +1425,7 @@ declare namespace OverviewGraph {
     } | {
         id: string;
         type: 'view';
-        viewId: ViewID$1;
+        viewId: ViewId;
         label: string;
         parentId: string | null;
         position: XYPoint;
@@ -606,7 +1457,7 @@ declare namespace ViewChange {
             shape?: ElementShape$1;
             color?: ThemeColor$1;
         };
-        targets: NonEmptyArray<Fqn$1>;
+        targets: NonEmptyArray<Fqn>;
     }
     interface SaveManualLayout {
         op: 'save-manual-layout';
@@ -623,12 +1474,16 @@ declare namespace ViewChange {
 }
 type ViewChange = ViewChange.ChangeElementStyle | ViewChange.SaveManualLayout | ViewChange.ChangeAutoLayout;
 
-type KeysOf<T> = keyof T extends infer K extends string ? K : never;
 type BuilderSpecification = {
     elements: {
         [kind: string]: Partial<ElementKindSpecification>;
     };
-    relationships?: Record<string, Partial<RelationshipKindSpecification>>;
+    relationships?: {
+        [kind: string]: Partial<RelationshipKindSpecification>;
+    };
+    deployments?: {
+        [kind: string]: Partial<DeploymentNodeKindSpecification>;
+    };
     tags?: [string, ...string[]];
     metadataKeys?: [string, ...string[]];
 };
@@ -651,6 +1506,24 @@ type NewElementProps<Tag, Metadata> = {
         opacity?: number;
     };
 };
+type NewDeploymentNodeProps<Tag, Metadata> = {
+    title?: string;
+    description?: string;
+    technology?: string;
+    tags?: IfNever<Tag, never, [Tag, ...Tag[]]>;
+    metadata?: Metadata;
+    icon?: string;
+    shape?: ElementShape$1;
+    color?: Color$1;
+    links?: NonEmptyArray<string | {
+        title?: string;
+        url: string;
+    }>;
+    style?: {
+        border?: BorderStyle;
+        opacity?: number;
+    };
+};
 type NewViewProps<Tag> = {
     title?: string;
     description?: string;
@@ -671,7 +1544,7 @@ type NewRelationProps<Kind, Tag, Metadata> = {
     tail?: RelationshipArrowType;
     line?: RelationshipLineType;
     color?: Color$1;
-    links?: Array<string | {
+    links?: NonEmptyArray<string | {
         title?: string;
         url: string;
     }>;
@@ -680,35 +1553,93 @@ type Invalid<Message extends string> = Tagged<Message, 'Error'>;
 /**
  * When building nested objects
  */
-interface TypesNested<Parent extends string, ElementKind extends string, Fqn extends string, ViewId extends string, RelationshipKind extends string, Tag extends string, MetadataKey extends string> extends Types<ElementKind, Fqn, ViewId, RelationshipKind, Tag, MetadataKey> {
+interface TypesNested<Parent extends string, ElementKind extends string, Fqn extends string, ViewId extends string, RelationshipKind extends string, Tag extends string, MetadataKey extends string, DeploymentKind extends string, DeploymentFqn extends string> extends Types<ElementKind, Fqn, ViewId, RelationshipKind, Tag, MetadataKey, DeploymentKind, DeploymentFqn> {
     Parent: Parent;
 }
-type AnyTypes = Types<any, any, any, any, any, any>;
-type AnyTypesNested = TypesNested<any, any, any, any, any, any, any>;
+type AnyTypes = Types<any, any, any, any, any, any, any, any>;
+type AnyTypesNested = TypesNested<any, any, any, any, any, any, any, any, any>;
 /**
  * Auxilary type to keep track of the types in builder
  */
-interface Types<ElementKind extends string, Fqn extends string, ViewId extends string, RelationshipKind extends string, Tag extends string, MetadataKey extends string> {
+interface Types<ElementKind extends string, Fqn extends string, ViewId extends string, RelationshipKind extends string, Tag extends string, MetadataKey extends string, DeploymentKind extends string, DeploymentFqn extends string> {
     ElementKind: ElementKind;
     Fqn: Fqn;
     ViewId: ViewId;
     RelationshipKind: RelationshipKind;
     Tag: Tag;
     MetadataKey: MetadataKey;
+    DeploymentKind: DeploymentKind;
+    DeploymentFqn: DeploymentFqn;
     Tags: IfNever<Tag, never, [Tag, ...Tag[]]>;
     NewElementProps: NewElementProps<Tag, Metadata<MetadataKey>>;
     NewRelationshipProps: NewRelationProps<RelationshipKind, Tag, Metadata<MetadataKey>>;
     NewViewProps: NewViewProps<Tag>;
+    NewDeploymentNodeProps: NewDeploymentNodeProps<Tag, Metadata<MetadataKey>>;
 }
 declare namespace Types {
-    type FromSpecification<Spec> = Spec extends BuilderSpecification ? Types<KeysOf<Spec['elements']>, never, never, KeysOf<Spec['relationships']>, TupleToUnion<Spec['tags']>, TupleToUnion<Spec['metadataKeys']>> : never;
-    type AddFqn<T, Id extends string> = T extends TypesNested<infer P, any, any, any, any, any, any> ? TypesNested<P, T['ElementKind'], `${P}.${Id}` | T['Fqn'], T['ViewId'], T['RelationshipKind'], T['Tag'], T['MetadataKey']> : T extends AnyTypes ? Types<T['ElementKind'], Id | T['Fqn'], T['ViewId'], T['RelationshipKind'], T['Tag'], T['MetadataKey']> : never;
-    type AddView<T, Id extends string> = T extends TypesNested<infer P, any, any, any, any, any, any> ? TypesNested<P, T['ElementKind'], T['Fqn'], Id | T['ViewId'], T['RelationshipKind'], T['Tag'], T['MetadataKey']> : T extends AnyTypes ? Types<T['ElementKind'], T['Fqn'], Id | T['ViewId'], T['RelationshipKind'], T['Tag'], T['MetadataKey']> : never;
+    type FromSpecification<Spec> = Spec extends BuilderSpecification ? Types<KeysOf<Spec['elements']>, never, never, KeysOf<Spec['relationships']>, TupleToUnion<Spec['tags']>, TupleToUnion<Spec['metadataKeys']>, KeysOf<Spec['deployments']>, never> : never;
+    type AddFqn<T, Id extends string> = T extends TypesNested<infer P, any, any, any, any, any, any, any, any> ? TypesNested<P, T['ElementKind'], `${P}.${Id}` | T['Fqn'], T['ViewId'], T['RelationshipKind'], T['Tag'], T['MetadataKey'], T['DeploymentKind'], T['DeploymentFqn']> : T extends AnyTypes ? Types<T['ElementKind'], Id | T['Fqn'], T['ViewId'], T['RelationshipKind'], T['Tag'], T['MetadataKey'], T['DeploymentKind'], T['DeploymentFqn']> : never;
+    type AddDeploymentFqn<T, Id extends string> = T extends TypesNested<infer P, any, any, any, any, any, any, any, any> ? TypesNested<P, T['ElementKind'], T['Fqn'], T['ViewId'], T['RelationshipKind'], T['Tag'], T['MetadataKey'], T['DeploymentKind'], `${P}.${Id}` | T['DeploymentFqn']> : T extends AnyTypes ? Types<T['ElementKind'], T['Fqn'], T['ViewId'], T['RelationshipKind'], T['Tag'], T['MetadataKey'], T['DeploymentKind'], Id | T['DeploymentFqn']> : never;
+    type AddView<T, Id extends string> = T extends TypesNested<infer P, any, any, any, any, any, any, any, any> ? TypesNested<P, T['ElementKind'], T['Fqn'], Id | T['ViewId'], T['RelationshipKind'], T['Tag'], T['MetadataKey'], T['DeploymentKind'], T['DeploymentFqn']> : T extends AnyTypes ? Types<T['ElementKind'], T['Fqn'], Id | T['ViewId'], T['RelationshipKind'], T['Tag'], T['MetadataKey'], T['DeploymentKind'], T['DeploymentFqn']> : never;
     type ToParsedLikeC4Model<T> = T extends AnyTypes ? ParsedLikeC4Model<T['ElementKind'], T['RelationshipKind'], T['Tag'], T['Fqn'], T['ViewId']> : never;
 }
 
-type ToNested<T, Id extends string> = T extends TypesNested<infer P, any, infer F, any, any, any, any> ? TypesNested<`${P}.${Id}`, T['ElementKind'], `${P}.${Id}` | F, T['ViewId'], T['RelationshipKind'], T['Tag'], T['MetadataKey']> : T extends AnyTypes ? TypesNested<Id, T['ElementKind'], Id | T['Fqn'], T['ViewId'], T['RelationshipKind'], T['Tag'], T['MetadataKey']> : never;
-type FromNested<T extends AnyTypes, N> = N extends TypesNested<any, any, infer F, any, any, any, any> ? T extends TypesNested<infer P, any, any, any, any, any, any> ? TypesNested<P, T['ElementKind'], F, T['ViewId'], T['RelationshipKind'], T['Tag'], T['MetadataKey']> : T extends AnyTypes ? Types<T['ElementKind'], F, T['ViewId'], T['RelationshipKind'], T['Tag'], T['MetadataKey']> : never : never;
+type ToNested$1<T, Id extends string> = T extends TypesNested<infer P, any, any, any, any, any, any, any, infer F> ? TypesNested<`${P}.${Id}`, T['ElementKind'], T['Fqn'], T['ViewId'], T['RelationshipKind'], T['Tag'], T['MetadataKey'], T['DeploymentKind'], `${P}.${Id}` | F> : T extends AnyTypes ? TypesNested<Id, T['ElementKind'], T['Fqn'], T['ViewId'], T['RelationshipKind'], T['Tag'], T['MetadataKey'], T['DeploymentKind'], Id | T['DeploymentFqn']> : never;
+type FromNested$1<T extends AnyTypes, N> = N extends TypesNested<any, any, any, any, any, any, any, any, infer F> ? T extends TypesNested<infer P, any, any, any, any, any, any, any, any> ? TypesNested<P, T['ElementKind'], T['Fqn'], T['ViewId'], T['RelationshipKind'], T['Tag'], T['MetadataKey'], T['DeploymentKind'], F> : T extends AnyTypes ? Types<T['ElementKind'], T['Fqn'], T['ViewId'], T['RelationshipKind'], T['Tag'], T['MetadataKey'], T['DeploymentKind'], F> : never : never;
+/**
+ * Chainable builder to create deployment node
+ */
+interface AddDeploymentNode<Id extends string> {
+    <T extends AnyTypes>(builder: DeploymentModelBuilder<T>): DeploymentModelBuilder<Types.AddDeploymentFqn<T, Id>>;
+    with<T extends AnyTypes, A extends AnyTypes>(op1: (input: DeploymentModelBuilder<ToNested$1<T, Id>>) => DeploymentModelBuilder<A>): (builder: DeploymentModelBuilder<T>) => DeploymentModelBuilder<FromNested$1<T, A>>;
+    with<T extends AnyTypes, A extends AnyTypes, B extends AnyTypes>(op1: (input: DeploymentModelBuilder<ToNested$1<T, Id>>) => DeploymentModelBuilder<A>, op2: (input: DeploymentModelBuilder<A>) => DeploymentModelBuilder<B>): (builder: DeploymentModelBuilder<T>) => DeploymentModelBuilder<FromNested$1<T, B>>;
+    with<T extends AnyTypes, A extends AnyTypes, B extends AnyTypes, C extends AnyTypes>(op1: (input: DeploymentModelBuilder<ToNested$1<T, Id>>) => DeploymentModelBuilder<A>, op2: (input: DeploymentModelBuilder<A>) => DeploymentModelBuilder<B>, op3: (input: DeploymentModelBuilder<B>) => DeploymentModelBuilder<C>): (builder: DeploymentModelBuilder<T>) => DeploymentModelBuilder<FromNested$1<T, C>>;
+    with<T extends AnyTypes, A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes>(op1: (input: DeploymentModelBuilder<ToNested$1<T, Id>>) => DeploymentModelBuilder<A>, op2: (input: DeploymentModelBuilder<A>) => DeploymentModelBuilder<B>, op3: (input: DeploymentModelBuilder<B>) => DeploymentModelBuilder<C>, op4: (input: DeploymentModelBuilder<C>) => DeploymentModelBuilder<D>): (builder: DeploymentModelBuilder<T>) => DeploymentModelBuilder<FromNested$1<T, D>>;
+    with<T extends AnyTypes, A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes>(op1: (input: DeploymentModelBuilder<ToNested$1<T, Id>>) => DeploymentModelBuilder<A>, op2: (input: DeploymentModelBuilder<A>) => DeploymentModelBuilder<B>, op3: (input: DeploymentModelBuilder<B>) => DeploymentModelBuilder<C>, op4: (input: DeploymentModelBuilder<C>) => DeploymentModelBuilder<D>, op5: (input: DeploymentModelBuilder<D>) => DeploymentModelBuilder<E>): (builder: DeploymentModelBuilder<T>) => DeploymentModelBuilder<FromNested$1<T, E>>;
+    with<T extends AnyTypes, A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes, F extends AnyTypes>(op1: (input: DeploymentModelBuilder<ToNested$1<T, Id>>) => DeploymentModelBuilder<A>, op2: (input: DeploymentModelBuilder<A>) => DeploymentModelBuilder<B>, op3: (input: DeploymentModelBuilder<B>) => DeploymentModelBuilder<C>, op4: (input: DeploymentModelBuilder<C>) => DeploymentModelBuilder<D>, op5: (input: DeploymentModelBuilder<D>) => DeploymentModelBuilder<E>, op6: (input: DeploymentModelBuilder<E>) => DeploymentModelBuilder<F>): (builder: DeploymentModelBuilder<T>) => DeploymentModelBuilder<FromNested$1<T, F>>;
+    with<T extends AnyTypes, A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes, F extends AnyTypes, G extends AnyTypes>(op1: (input: DeploymentModelBuilder<ToNested$1<T, Id>>) => DeploymentModelBuilder<A>, op2: (input: DeploymentModelBuilder<A>) => DeploymentModelBuilder<B>, op3: (input: DeploymentModelBuilder<B>) => DeploymentModelBuilder<C>, op4: (input: DeploymentModelBuilder<C>) => DeploymentModelBuilder<D>, op5: (input: DeploymentModelBuilder<D>) => DeploymentModelBuilder<E>, op6: (input: DeploymentModelBuilder<E>) => DeploymentModelBuilder<F>, op7: (input: DeploymentModelBuilder<F>) => DeploymentModelBuilder<G>): (builder: DeploymentModelBuilder<T>) => DeploymentModelBuilder<FromNested$1<T, G>>;
+    with<T extends AnyTypes, A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes, F extends AnyTypes, G extends AnyTypes, H extends AnyTypes>(op1: (input: DeploymentModelBuilder<ToNested$1<T, Id>>) => DeploymentModelBuilder<A>, op2: (input: DeploymentModelBuilder<A>) => DeploymentModelBuilder<B>, op3: (input: DeploymentModelBuilder<B>) => DeploymentModelBuilder<C>, op4: (input: DeploymentModelBuilder<C>) => DeploymentModelBuilder<D>, op5: (input: DeploymentModelBuilder<D>) => DeploymentModelBuilder<E>, op6: (input: DeploymentModelBuilder<E>) => DeploymentModelBuilder<F>, op7: (input: DeploymentModelBuilder<F>) => DeploymentModelBuilder<G>, op8: (input: DeploymentModelBuilder<G>) => DeploymentModelBuilder<H>): (builder: DeploymentModelBuilder<T>) => DeploymentModelBuilder<FromNested$1<T, H>>;
+    with<T extends AnyTypes, A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes, F extends AnyTypes, G extends AnyTypes, H extends AnyTypes, I extends AnyTypes>(op1: (input: DeploymentModelBuilder<ToNested$1<T, Id>>) => DeploymentModelBuilder<A>, op2: (input: DeploymentModelBuilder<A>) => DeploymentModelBuilder<B>, op3: (input: DeploymentModelBuilder<B>) => DeploymentModelBuilder<C>, op4: (input: DeploymentModelBuilder<C>) => DeploymentModelBuilder<D>, op5: (input: DeploymentModelBuilder<D>) => DeploymentModelBuilder<E>, op6: (input: DeploymentModelBuilder<E>) => DeploymentModelBuilder<F>, op7: (input: DeploymentModelBuilder<F>) => DeploymentModelBuilder<G>, op8: (input: DeploymentModelBuilder<G>) => DeploymentModelBuilder<H>, op9: (input: DeploymentModelBuilder<H>) => DeploymentModelBuilder<I>): (builder: DeploymentModelBuilder<T>) => DeploymentModelBuilder<FromNested$1<T, I>>;
+    with<T extends AnyTypes, A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes, F extends AnyTypes, G extends AnyTypes, H extends AnyTypes, I extends AnyTypes, J extends AnyTypes>(op1: (input: DeploymentModelBuilder<ToNested$1<T, Id>>) => DeploymentModelBuilder<A>, op2: (input: DeploymentModelBuilder<A>) => DeploymentModelBuilder<B>, op3: (input: DeploymentModelBuilder<B>) => DeploymentModelBuilder<C>, op4: (input: DeploymentModelBuilder<C>) => DeploymentModelBuilder<D>, op5: (input: DeploymentModelBuilder<D>) => DeploymentModelBuilder<E>, op6: (input: DeploymentModelBuilder<E>) => DeploymentModelBuilder<F>, op7: (input: DeploymentModelBuilder<F>) => DeploymentModelBuilder<G>, op8: (input: DeploymentModelBuilder<G>) => DeploymentModelBuilder<H>, op9: (input: DeploymentModelBuilder<H>) => DeploymentModelBuilder<I>, op10: (input: DeploymentModelBuilder<I>) => DeploymentModelBuilder<J>): (builder: DeploymentModelBuilder<T>) => DeploymentModelBuilder<FromNested$1<T, J>>;
+}
+
+interface DeploymentModelBuilder<T extends AnyTypes> {
+    addDeployment(node: DeploymentElement$1): Builder<T>;
+    addDeploymentRelation(rel: Omit<DeploymentRelation$1, 'id'>): Builder<T>;
+    /**
+     * Create a fully qualified name from an id (for nested models)
+     */
+    fqn(id: string): Fqn;
+}
+declare function deployment<A extends AnyTypes, B extends AnyTypes>(op1: (input: DeploymentModelBuilder<A>) => DeploymentModelBuilder<B>): (input: Builder<A>) => Builder<B>;
+declare function deployment<A extends AnyTypes, B extends AnyTypes, C extends AnyTypes>(op1: (input: DeploymentModelBuilder<A>) => DeploymentModelBuilder<B>, op2: (input: DeploymentModelBuilder<B>) => DeploymentModelBuilder<C>): (input: Builder<A>) => Builder<C>;
+declare function deployment<A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes>(op1: (input: DeploymentModelBuilder<A>) => DeploymentModelBuilder<B>, op2: (input: DeploymentModelBuilder<B>) => DeploymentModelBuilder<C>, op3: (input: DeploymentModelBuilder<C>) => DeploymentModelBuilder<D>): (input: Builder<A>) => Builder<D>;
+declare function deployment<A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes>(op1: (input: DeploymentModelBuilder<A>) => DeploymentModelBuilder<B>, op2: (input: DeploymentModelBuilder<B>) => DeploymentModelBuilder<C>, op3: (input: DeploymentModelBuilder<C>) => DeploymentModelBuilder<D>, op4: (input: DeploymentModelBuilder<D>) => DeploymentModelBuilder<E>): (input: Builder<A>) => Builder<E>;
+declare function deployment<A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes, F extends AnyTypes>(op1: (input: DeploymentModelBuilder<A>) => DeploymentModelBuilder<B>, op2: (input: DeploymentModelBuilder<B>) => DeploymentModelBuilder<C>, op3: (input: DeploymentModelBuilder<C>) => DeploymentModelBuilder<D>, op4: (input: DeploymentModelBuilder<D>) => DeploymentModelBuilder<E>, op5: (input: DeploymentModelBuilder<E>) => DeploymentModelBuilder<F>): (input: Builder<A>) => Builder<F>;
+declare function deployment<A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes, F extends AnyTypes, G extends AnyTypes>(op1: (input: DeploymentModelBuilder<A>) => DeploymentModelBuilder<B>, op2: (input: DeploymentModelBuilder<B>) => DeploymentModelBuilder<C>, op3: (input: DeploymentModelBuilder<C>) => DeploymentModelBuilder<D>, op4: (input: DeploymentModelBuilder<D>) => DeploymentModelBuilder<E>, op5: (input: DeploymentModelBuilder<E>) => DeploymentModelBuilder<F>, op6: (input: DeploymentModelBuilder<F>) => DeploymentModelBuilder<G>): (input: Builder<A>) => Builder<G>;
+declare function deployment<A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes, F extends AnyTypes, G extends AnyTypes, H extends AnyTypes>(op1: (input: DeploymentModelBuilder<A>) => DeploymentModelBuilder<B>, op2: (input: DeploymentModelBuilder<B>) => DeploymentModelBuilder<C>, op3: (input: DeploymentModelBuilder<C>) => DeploymentModelBuilder<D>, op4: (input: DeploymentModelBuilder<D>) => DeploymentModelBuilder<E>, op5: (input: DeploymentModelBuilder<E>) => DeploymentModelBuilder<F>, op6: (input: DeploymentModelBuilder<F>) => DeploymentModelBuilder<G>, op7: (input: DeploymentModelBuilder<G>) => DeploymentModelBuilder<H>): (input: Builder<A>) => Builder<H>;
+declare function deployment<A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes, F extends AnyTypes, G extends AnyTypes, H extends AnyTypes, I extends AnyTypes>(op1: (input: DeploymentModelBuilder<A>) => DeploymentModelBuilder<B>, op2: (input: DeploymentModelBuilder<B>) => DeploymentModelBuilder<C>, op3: (input: DeploymentModelBuilder<C>) => DeploymentModelBuilder<D>, op4: (input: DeploymentModelBuilder<D>) => DeploymentModelBuilder<E>, op5: (input: DeploymentModelBuilder<E>) => DeploymentModelBuilder<F>, op6: (input: DeploymentModelBuilder<F>) => DeploymentModelBuilder<G>, op7: (input: DeploymentModelBuilder<G>) => DeploymentModelBuilder<H>, op8: (input: DeploymentModelBuilder<H>) => DeploymentModelBuilder<I>): (input: Builder<A>) => Builder<I>;
+declare function deployment<A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes, F extends AnyTypes, G extends AnyTypes, H extends AnyTypes, I extends AnyTypes, J extends AnyTypes>(op1: (input: DeploymentModelBuilder<A>) => DeploymentModelBuilder<B>, op2: (input: DeploymentModelBuilder<B>) => DeploymentModelBuilder<C>, op3: (input: DeploymentModelBuilder<C>) => DeploymentModelBuilder<D>, op4: (input: DeploymentModelBuilder<D>) => DeploymentModelBuilder<E>, op5: (input: DeploymentModelBuilder<E>) => DeploymentModelBuilder<F>, op6: (input: DeploymentModelBuilder<F>) => DeploymentModelBuilder<G>, op7: (input: DeploymentModelBuilder<G>) => DeploymentModelBuilder<H>, op8: (input: DeploymentModelBuilder<H>) => DeploymentModelBuilder<I>, op9: (input: DeploymentModelBuilder<I>) => DeploymentModelBuilder<J>): (input: Builder<A>) => Builder<J>;
+declare function deployment<A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes, F extends AnyTypes, G extends AnyTypes, H extends AnyTypes, I extends AnyTypes, J extends AnyTypes, K extends AnyTypes>(op1: (input: DeploymentModelBuilder<A>) => DeploymentModelBuilder<B>, op2: (input: DeploymentModelBuilder<B>) => DeploymentModelBuilder<C>, op3: (input: DeploymentModelBuilder<C>) => DeploymentModelBuilder<D>, op4: (input: DeploymentModelBuilder<D>) => DeploymentModelBuilder<E>, op5: (input: DeploymentModelBuilder<E>) => DeploymentModelBuilder<F>, op6: (input: DeploymentModelBuilder<F>) => DeploymentModelBuilder<G>, op7: (input: DeploymentModelBuilder<G>) => DeploymentModelBuilder<H>, op8: (input: DeploymentModelBuilder<H>) => DeploymentModelBuilder<I>, op9: (input: DeploymentModelBuilder<I>) => DeploymentModelBuilder<J>, op10: (input: DeploymentModelBuilder<J>) => DeploymentModelBuilder<K>): (input: Builder<A>) => Builder<K>;
+declare function deployment<A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes, F extends AnyTypes, G extends AnyTypes, H extends AnyTypes, I extends AnyTypes, J extends AnyTypes, K extends AnyTypes, L extends AnyTypes>(op1: (input: DeploymentModelBuilder<A>) => DeploymentModelBuilder<B>, op2: (input: DeploymentModelBuilder<B>) => DeploymentModelBuilder<C>, op3: (input: DeploymentModelBuilder<C>) => DeploymentModelBuilder<D>, op4: (input: DeploymentModelBuilder<D>) => DeploymentModelBuilder<E>, op5: (input: DeploymentModelBuilder<E>) => DeploymentModelBuilder<F>, op6: (input: DeploymentModelBuilder<F>) => DeploymentModelBuilder<G>, op7: (input: DeploymentModelBuilder<G>) => DeploymentModelBuilder<H>, op8: (input: DeploymentModelBuilder<H>) => DeploymentModelBuilder<I>, op9: (input: DeploymentModelBuilder<I>) => DeploymentModelBuilder<J>, op10: (input: DeploymentModelBuilder<J>) => DeploymentModelBuilder<K>, op11: (input: DeploymentModelBuilder<K>) => DeploymentModelBuilder<L>): (input: Builder<A>) => Builder<L>;
+declare function deployment<A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes, F extends AnyTypes, G extends AnyTypes, H extends AnyTypes, I extends AnyTypes, J extends AnyTypes, K extends AnyTypes, L extends AnyTypes, M extends AnyTypes>(op1: (input: DeploymentModelBuilder<A>) => DeploymentModelBuilder<B>, op2: (input: DeploymentModelBuilder<B>) => DeploymentModelBuilder<C>, op3: (input: DeploymentModelBuilder<C>) => DeploymentModelBuilder<D>, op4: (input: DeploymentModelBuilder<D>) => DeploymentModelBuilder<E>, op5: (input: DeploymentModelBuilder<E>) => DeploymentModelBuilder<F>, op6: (input: DeploymentModelBuilder<F>) => DeploymentModelBuilder<G>, op7: (input: DeploymentModelBuilder<G>) => DeploymentModelBuilder<H>, op8: (input: DeploymentModelBuilder<H>) => DeploymentModelBuilder<I>, op9: (input: DeploymentModelBuilder<I>) => DeploymentModelBuilder<J>, op10: (input: DeploymentModelBuilder<J>) => DeploymentModelBuilder<K>, op11: (input: DeploymentModelBuilder<K>) => DeploymentModelBuilder<L>, op12: (input: DeploymentModelBuilder<L>) => DeploymentModelBuilder<M>): (input: Builder<A>) => Builder<M>;
+declare function deployment<A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes, F extends AnyTypes, G extends AnyTypes, H extends AnyTypes, I extends AnyTypes, J extends AnyTypes, K extends AnyTypes, L extends AnyTypes, M extends AnyTypes, N extends AnyTypes>(op1: (input: DeploymentModelBuilder<A>) => DeploymentModelBuilder<B>, op2: (input: DeploymentModelBuilder<B>) => DeploymentModelBuilder<C>, op3: (input: DeploymentModelBuilder<C>) => DeploymentModelBuilder<D>, op4: (input: DeploymentModelBuilder<D>) => DeploymentModelBuilder<E>, op5: (input: DeploymentModelBuilder<E>) => DeploymentModelBuilder<F>, op6: (input: DeploymentModelBuilder<F>) => DeploymentModelBuilder<G>, op7: (input: DeploymentModelBuilder<G>) => DeploymentModelBuilder<H>, op8: (input: DeploymentModelBuilder<H>) => DeploymentModelBuilder<I>, op9: (input: DeploymentModelBuilder<I>) => DeploymentModelBuilder<J>, op10: (input: DeploymentModelBuilder<J>) => DeploymentModelBuilder<K>, op11: (input: DeploymentModelBuilder<K>) => DeploymentModelBuilder<L>, op12: (input: DeploymentModelBuilder<L>) => DeploymentModelBuilder<M>, op13: (input: DeploymentModelBuilder<M>) => DeploymentModelBuilder<N>): (input: Builder<A>) => Builder<N>;
+declare function deployment<A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes, F extends AnyTypes, G extends AnyTypes, H extends AnyTypes, I extends AnyTypes, J extends AnyTypes, K extends AnyTypes, L extends AnyTypes, M extends AnyTypes, N extends AnyTypes, O extends AnyTypes>(op1: (input: DeploymentModelBuilder<A>) => DeploymentModelBuilder<B>, op2: (input: DeploymentModelBuilder<B>) => DeploymentModelBuilder<C>, op3: (input: DeploymentModelBuilder<C>) => DeploymentModelBuilder<D>, op4: (input: DeploymentModelBuilder<D>) => DeploymentModelBuilder<E>, op5: (input: DeploymentModelBuilder<E>) => DeploymentModelBuilder<F>, op6: (input: DeploymentModelBuilder<F>) => DeploymentModelBuilder<G>, op7: (input: DeploymentModelBuilder<G>) => DeploymentModelBuilder<H>, op8: (input: DeploymentModelBuilder<H>) => DeploymentModelBuilder<I>, op9: (input: DeploymentModelBuilder<I>) => DeploymentModelBuilder<J>, op10: (input: DeploymentModelBuilder<J>) => DeploymentModelBuilder<K>, op11: (input: DeploymentModelBuilder<K>) => DeploymentModelBuilder<L>, op12: (input: DeploymentModelBuilder<L>) => DeploymentModelBuilder<M>, op13: (input: DeploymentModelBuilder<M>) => DeploymentModelBuilder<N>, op14: (input: DeploymentModelBuilder<N>) => DeploymentModelBuilder<O>): (input: Builder<A>) => Builder<O>;
+declare function deployment<A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes, F extends AnyTypes, G extends AnyTypes, H extends AnyTypes, I extends AnyTypes, J extends AnyTypes, K extends AnyTypes, L extends AnyTypes, M extends AnyTypes, N extends AnyTypes, O extends AnyTypes, P extends AnyTypes>(op1: (input: DeploymentModelBuilder<A>) => DeploymentModelBuilder<B>, op2: (input: DeploymentModelBuilder<B>) => DeploymentModelBuilder<C>, op3: (input: DeploymentModelBuilder<C>) => DeploymentModelBuilder<D>, op4: (input: DeploymentModelBuilder<D>) => DeploymentModelBuilder<E>, op5: (input: DeploymentModelBuilder<E>) => DeploymentModelBuilder<F>, op6: (input: DeploymentModelBuilder<F>) => DeploymentModelBuilder<G>, op7: (input: DeploymentModelBuilder<G>) => DeploymentModelBuilder<H>, op8: (input: DeploymentModelBuilder<H>) => DeploymentModelBuilder<I>, op9: (input: DeploymentModelBuilder<I>) => DeploymentModelBuilder<J>, op10: (input: DeploymentModelBuilder<J>) => DeploymentModelBuilder<K>, op11: (input: DeploymentModelBuilder<K>) => DeploymentModelBuilder<L>, op12: (input: DeploymentModelBuilder<L>) => DeploymentModelBuilder<M>, op13: (input: DeploymentModelBuilder<M>) => DeploymentModelBuilder<N>, op14: (input: DeploymentModelBuilder<N>) => DeploymentModelBuilder<O>, op15: (input: DeploymentModelBuilder<O>) => DeploymentModelBuilder<P>): (input: Builder<A>) => Builder<P>;
+type AddDeploymentRelation<Props = unknown> = <T extends AnyTypes, Source extends string & T['DeploymentFqn'], Target extends string & T['DeploymentFqn']>(source: Source, target: Target, titleOrProps?: string | Props) => (builder: DeploymentModelBuilder<T>) => DeploymentModelBuilder<T>;
+type AddDeployedInstance<Props = unknown> = <const Id extends string, T extends AnyTypes, To extends string & T['Fqn']>(id: Id, to: To, titleOrProps?: string | Props | undefined) => (builder: DeploymentModelBuilder<T>) => DeploymentModelBuilder<Types.AddDeploymentFqn<T, Id>>;
+type AddDeploymentNodeHelper<T = unknown> = <const Id extends string>(id: Id, titleOrProps?: string | T) => AddDeploymentNode<Id>;
+type AddDeploymentNodeHelpers<T extends AnyTypes> = T extends Types<any, any, any, any, any, any, infer Kinds extends string, any> ? {
+    [Kind in Kinds]: AddDeploymentNodeHelper<T['NewDeploymentNodeProps']>;
+} : Invalid<'No Deployment Kinds'>;
+type DeloymentModelHelpers<T extends AnyTypes> = AddDeploymentNodeHelpers<T> & {
+    instanceOf: AddDeployedInstance<T['NewDeploymentNodeProps']>;
+    rel: AddDeploymentRelation<T['NewRelationshipProps']>;
+    deployment: typeof deployment;
+};
+
+type ToNested<T, Id extends string> = T extends TypesNested<infer P, any, infer F, any, any, any, any, any, any> ? TypesNested<`${P}.${Id}`, T['ElementKind'], `${P}.${Id}` | F, T['ViewId'], T['RelationshipKind'], T['Tag'], T['MetadataKey'], T['DeploymentKind'], T['DeploymentFqn']> : T extends AnyTypes ? TypesNested<Id, T['ElementKind'], Id | T['Fqn'], T['ViewId'], T['RelationshipKind'], T['Tag'], T['MetadataKey'], T['DeploymentKind'], T['DeploymentFqn']> : never;
+type FromNested<T extends AnyTypes, N> = N extends TypesNested<any, any, infer F, any, any, any, any, any, any> ? T extends TypesNested<infer P, any, any, any, any, any, any, any, any> ? TypesNested<P, T['ElementKind'], F, T['ViewId'], T['RelationshipKind'], T['Tag'], T['MetadataKey'], T['DeploymentKind'], T['DeploymentFqn']> : T extends AnyTypes ? Types<T['ElementKind'], F, T['ViewId'], T['RelationshipKind'], T['Tag'], T['MetadataKey'], T['DeploymentKind'], T['DeploymentFqn']> : never : never;
 /**
  * Chainable builder to create element
  */
@@ -725,10 +1656,6 @@ interface AddElement<Id extends string> {
     with<T extends AnyTypes, A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes, F extends AnyTypes, G extends AnyTypes, H extends AnyTypes, I extends AnyTypes>(op1: (input: ModelBuilder<ToNested<T, Id>>) => ModelBuilder<A>, op2: (input: ModelBuilder<A>) => ModelBuilder<B>, op3: (input: ModelBuilder<B>) => ModelBuilder<C>, op4: (input: ModelBuilder<C>) => ModelBuilder<D>, op5: (input: ModelBuilder<D>) => ModelBuilder<E>, op6: (input: ModelBuilder<E>) => ModelBuilder<F>, op7: (input: ModelBuilder<F>) => ModelBuilder<G>, op8: (input: ModelBuilder<G>) => ModelBuilder<H>, op9: (input: ModelBuilder<H>) => ModelBuilder<I>): (builder: ModelBuilder<T>) => ModelBuilder<FromNested<T, I>>;
     with<T extends AnyTypes, A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes, F extends AnyTypes, G extends AnyTypes, H extends AnyTypes, I extends AnyTypes, J extends AnyTypes>(op1: (input: ModelBuilder<ToNested<T, Id>>) => ModelBuilder<A>, op2: (input: ModelBuilder<A>) => ModelBuilder<B>, op3: (input: ModelBuilder<B>) => ModelBuilder<C>, op4: (input: ModelBuilder<C>) => ModelBuilder<D>, op5: (input: ModelBuilder<D>) => ModelBuilder<E>, op6: (input: ModelBuilder<E>) => ModelBuilder<F>, op7: (input: ModelBuilder<F>) => ModelBuilder<G>, op8: (input: ModelBuilder<G>) => ModelBuilder<H>, op9: (input: ModelBuilder<H>) => ModelBuilder<I>, op10: (input: ModelBuilder<I>) => ModelBuilder<J>): (builder: ModelBuilder<T>) => ModelBuilder<FromNested<T, J>>;
 }
-type AddElementHelper<T = unknown> = <const Id extends string>(id: Id, titleOrProps?: string | T) => AddElement<Id>;
-type AddElementHelpers<T extends AnyTypes> = T extends Types<infer Kinds extends string, any, any, any, any, any> ? {
-    [Kind in Kinds]: AddElementHelper<T['NewElementProps']>;
-} : Invalid<'No Element Kinds'>;
 
 interface ModelBuilder<T extends AnyTypes> {
     addElement(element: Element$1): Builder<T>;
@@ -736,7 +1663,7 @@ interface ModelBuilder<T extends AnyTypes> {
     /**
      * Create a fully qualified name from an id (for nested models)
      */
-    fqn(id: string): Fqn$1;
+    fqn(id: string): Fqn;
     addSourcelessRelation(relation: Omit<Relation$1, 'id' | 'source'>): Builder<T>;
 }
 declare function model<A extends AnyTypes, B extends AnyTypes>(op1: (input: ModelBuilder<A>) => ModelBuilder<B>): (input: Builder<A>) => Builder<B>;
@@ -756,6 +1683,10 @@ declare function model<A extends AnyTypes, B extends AnyTypes, C extends AnyType
 declare function model<A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes, F extends AnyTypes, G extends AnyTypes, H extends AnyTypes, I extends AnyTypes, J extends AnyTypes, K extends AnyTypes, L extends AnyTypes, M extends AnyTypes, N extends AnyTypes, O extends AnyTypes, P extends AnyTypes>(op1: (input: ModelBuilder<A>) => ModelBuilder<B>, op2: (input: ModelBuilder<B>) => ModelBuilder<C>, op3: (input: ModelBuilder<C>) => ModelBuilder<D>, op4: (input: ModelBuilder<D>) => ModelBuilder<E>, op5: (input: ModelBuilder<E>) => ModelBuilder<F>, op6: (input: ModelBuilder<F>) => ModelBuilder<G>, op7: (input: ModelBuilder<G>) => ModelBuilder<H>, op8: (input: ModelBuilder<H>) => ModelBuilder<I>, op9: (input: ModelBuilder<I>) => ModelBuilder<J>, op10: (input: ModelBuilder<J>) => ModelBuilder<K>, op11: (input: ModelBuilder<K>) => ModelBuilder<L>, op12: (input: ModelBuilder<L>) => ModelBuilder<M>, op13: (input: ModelBuilder<M>) => ModelBuilder<N>, op14: (input: ModelBuilder<N>) => ModelBuilder<O>, op15: (input: ModelBuilder<O>) => ModelBuilder<P>): (input: Builder<A>) => Builder<P>;
 type RelationshipHelper<Props = unknown> = <T extends AnyTypes, From extends string & T['Fqn'], To extends string & T['Fqn']>(from: From, to: To, titleOrProps?: string | Props) => (builder: ModelBuilder<T>) => ModelBuilder<T>;
 type NestedRelationshipHelper<Props = unknown> = <T extends AnyTypesNested, To extends string & T['Fqn']>(to: To, titleOrProps?: string | Props) => (builder: ModelBuilder<T>) => ModelBuilder<T>;
+type AddElementHelper<T = unknown> = <const Id extends string>(id: Id, titleOrProps?: string | T) => AddElement<Id>;
+type AddElementHelpers<T extends AnyTypes> = T extends Types<infer Kinds extends string, any, any, any, any, any, any, any> ? {
+    [Kind in Kinds]: AddElementHelper<T['NewElementProps']>;
+} : Invalid<'No Element Kinds'>;
 type ModelHelpers<T extends AnyTypes> = AddElementHelpers<T> & {
     model: typeof model;
     rel: RelationshipHelper<T['NewRelationshipProps']>;
@@ -781,20 +1712,40 @@ declare function views<A extends AnyTypes, B extends AnyTypes, C extends AnyType
 declare function views<A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes, F extends AnyTypes, G extends AnyTypes, H extends AnyTypes, I extends AnyTypes, J extends AnyTypes, K extends AnyTypes, L extends AnyTypes, M extends AnyTypes, N extends AnyTypes, O extends AnyTypes>(op1: (input: ViewsBuilder<A>) => ViewsBuilder<B>, op2: (input: ViewsBuilder<B>) => ViewsBuilder<C>, op3: (input: ViewsBuilder<C>) => ViewsBuilder<D>, op4: (input: ViewsBuilder<D>) => ViewsBuilder<E>, op5: (input: ViewsBuilder<E>) => ViewsBuilder<F>, op6: (input: ViewsBuilder<F>) => ViewsBuilder<G>, op7: (input: ViewsBuilder<G>) => ViewsBuilder<H>, op8: (input: ViewsBuilder<H>) => ViewsBuilder<I>, op9: (input: ViewsBuilder<I>) => ViewsBuilder<J>, op10: (input: ViewsBuilder<J>) => ViewsBuilder<K>, op11: (input: ViewsBuilder<K>) => ViewsBuilder<L>, op12: (input: ViewsBuilder<L>) => ViewsBuilder<M>, op13: (input: ViewsBuilder<M>) => ViewsBuilder<N>, op14: (input: ViewsBuilder<N>) => ViewsBuilder<O>): (input: Builder<A>) => Builder<O>;
 declare function views<A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes, F extends AnyTypes, G extends AnyTypes, H extends AnyTypes, I extends AnyTypes, J extends AnyTypes, K extends AnyTypes, L extends AnyTypes, M extends AnyTypes, N extends AnyTypes, O extends AnyTypes, P extends AnyTypes>(op1: (input: ViewsBuilder<A>) => ViewsBuilder<B>, op2: (input: ViewsBuilder<B>) => ViewsBuilder<C>, op3: (input: ViewsBuilder<C>) => ViewsBuilder<D>, op4: (input: ViewsBuilder<D>) => ViewsBuilder<E>, op5: (input: ViewsBuilder<E>) => ViewsBuilder<F>, op6: (input: ViewsBuilder<F>) => ViewsBuilder<G>, op7: (input: ViewsBuilder<G>) => ViewsBuilder<H>, op8: (input: ViewsBuilder<H>) => ViewsBuilder<I>, op9: (input: ViewsBuilder<I>) => ViewsBuilder<J>, op10: (input: ViewsBuilder<J>) => ViewsBuilder<K>, op11: (input: ViewsBuilder<K>) => ViewsBuilder<L>, op12: (input: ViewsBuilder<L>) => ViewsBuilder<M>, op13: (input: ViewsBuilder<M>) => ViewsBuilder<N>, op14: (input: ViewsBuilder<N>) => ViewsBuilder<O>, op15: (input: ViewsBuilder<O>) => ViewsBuilder<P>): (input: Builder<A>) => Builder<P>;
 
-interface ViewBuilder<T extends AnyTypes> {
-    include(...exprs: Expression$1[]): ViewBuilder<T>;
-    exclude(...exprs: Expression$1[]): ViewBuilder<T>;
-    style(rule: ViewRuleStyle$1): ViewBuilder<T>;
-    autoLayout(layout: AutoLayoutDirection): ViewBuilder<T>;
+interface AViewBuilder<Types extends AnyTypes, Fqn extends string, TypedExpr, ElementExpr extends string = ViewPredicate.ElementExpr<Fqn>, Expr extends string = ViewPredicate.AllExpression<ElementExpr>> {
+    Types: Types;
+    ElementExpr: ElementExpr;
+    Expr: Expr;
+    TypedExpr: TypedExpr;
+    $expr(expr: Expr | TypedExpr): TypedExpr;
+    include(...exprs: Expr[]): this;
+    exclude(...exprs: Expr[]): this;
+    style(rule: ViewRuleStyle$1): this;
+    autoLayout(layout: AutoLayoutDirection): this;
+}
+interface ViewBuilder<T extends AnyTypes> extends AViewBuilder<T, T['Fqn'], Expression$1> {
+    $expr(expr: ViewPredicate.Expression<T> | Expression$1): TypedC4Expression<T>;
+    include(...exprs: Expression$1[]): this;
+    exclude(...exprs: Expression$1[]): this;
+    style(rule: ViewRuleStyle$1): this;
+    autoLayout(layout: AutoLayoutDirection): this;
+}
+interface DeploymentViewBuilder<T extends AnyTypes> extends AViewBuilder<T, T['DeploymentFqn'], DeploymentExpression$1> {
+    $expr(expr: ViewPredicate.DeploymentExpression<T> | DeploymentExpression$1): TypedDeploymentExpression<T>;
+    include(...exprs: DeploymentExpression$1[]): this;
+    exclude(...exprs: DeploymentExpression$1[]): this;
+    style(rule: ViewRuleStyle$1): this;
+    autoLayout(layout: AutoLayoutDirection): this;
 }
 declare namespace ViewPredicate {
-    export type ElementExpr<Fqn extends string> = '*' | Fqn | `${Fqn}.*` | `${Fqn}._`;
+    type ElementExpr<Fqn extends string> = '*' | Fqn | `${Fqn}.*` | `${Fqn}._` | `${Fqn}.**`;
     type AllExpression<ElementExpr extends string> = ElementExpr | `-> ${ElementExpr} ->` | `-> ${ElementExpr}` | `${ElementExpr} ->` | `${ElementExpr} ${'->' | '<->'} ${ElementExpr}`;
-    export type Expression<T extends AnyTypes> = T extends Types<any, infer F extends string, any, any, any, any> ? AllExpression<ViewPredicate.ElementExpr<F>> : never;
-    export type WhereTag<Tag extends string> = `tag ${'is' | 'is not'} #${Tag}`;
-    export type WhereKind<Kind extends string> = `kind ${'is' | 'is not'} ${Kind}`;
-    export type WhereEq<Types extends AnyTypes> = ViewPredicate.WhereTag<Types['Tag']> | ViewPredicate.WhereKind<Types['ElementKind']>;
-    export type WhereOperator<Types extends AnyTypes> = ViewPredicate.WhereEq<Types> | {
+    type Expression<T extends AnyTypes> = T extends Types<any, infer F extends string, any, any, any, any, any, any> ? AllExpression<ViewPredicate.ElementExpr<F>> : never;
+    type DeploymentExpression<T extends AnyTypes> = T extends Types<any, any, any, any, any, any, any, infer F extends string> ? AllExpression<ViewPredicate.ElementExpr<F>> : never;
+    type WhereTag<Tag extends string> = `tag ${'is' | 'is not'} #${Tag}`;
+    type WhereKind<Kind extends string> = `kind ${'is' | 'is not'} ${Kind}`;
+    type WhereEq<Types extends AnyTypes> = ViewPredicate.WhereTag<Types['Tag']> | ViewPredicate.WhereKind<Types['ElementKind']>;
+    type WhereOperator<Types extends AnyTypes> = ViewPredicate.WhereEq<Types> | {
         and: NonEmptyArray<ViewPredicate.WhereOperator<Types>>;
         or?: never;
         not?: never;
@@ -807,15 +1758,15 @@ declare namespace ViewPredicate {
         and?: never;
         or?: never;
     };
-    export type Custom<Types extends AnyTypes> = {
+    type Custom<Types extends AnyTypes> = {
         where?: ViewPredicate.WhereOperator<Types>;
         with?: Simplify<Omit<CustomElementExpr['custom'] & CustomRelationExpr['customRelation'], 'expr' | 'relation' | 'navigateTo'> & {
             navigateTo?: Types['ViewId'];
         }>;
     };
-    export {  };
 }
-type ViewRuleBuilderOp<Types extends AnyTypes> = (b: ViewBuilder<Types>) => ViewBuilder<Types>;
+type Op<T> = (b: T) => T;
+type DeploymentViewRuleBuilderOp<Types extends AnyTypes> = (b: DeploymentViewBuilder<Types>) => DeploymentViewBuilder<Types>;
 interface AddViewHelper<Props = unknown> {
     <const Id extends string, T extends AnyTypes>(id: Id, builder: (b: ViewBuilder<T>) => ViewBuilder<T>): (builder: ViewsBuilder<T>) => ViewsBuilder<Types.AddView<T, Id>>;
     <const Id extends string, T extends AnyTypes>(id: Id, propsOrTitle: Props | string): (builder: ViewsBuilder<T>) => ViewsBuilder<Types.AddView<T, Id>>;
@@ -827,19 +1778,25 @@ interface AddViewOfHelper<Props = unknown> {
     <const Id extends string, T extends AnyTypes, Of extends string & T['Fqn']>(id: Id, of: Of, propsOrTitle: Props | string): (builder: ViewsBuilder<T>) => ViewsBuilder<Types.AddView<T, Id>>;
     <const Id extends string, T extends AnyTypes, Of extends string & T['Fqn']>(id: Id, of: Of, propsOrTitle: Props | string | undefined, builder: (b: ViewBuilder<T>) => ViewBuilder<T>): (builder: ViewsBuilder<T>) => ViewsBuilder<Types.AddView<T, Id>>;
 }
+interface AddDeploymentViewHelper<Props = unknown> {
+    <const Id extends string, T extends AnyTypes>(id: Id, builder: DeploymentViewRuleBuilderOp<T>): (builder: ViewsBuilder<T>) => ViewsBuilder<Types.AddView<T, Id>>;
+    <const Id extends string, T extends AnyTypes>(id: Id, propsOrTitle: Props | string | undefined, builder: DeploymentViewRuleBuilderOp<T>): (builder: ViewsBuilder<T>) => ViewsBuilder<Types.AddView<T, Id>>;
+}
 type TypedC4Expression<Types extends AnyTypes> = Tagged<Expression$1, 'typed', Types>;
-declare function $include<Types extends AnyTypes>(...args: [ViewPredicate.Expression<Types>] | [TypedC4Expression<Types>] | [ViewPredicate.Expression<Types>, ViewPredicate.Custom<Types>]): (b: ViewBuilder<Types>) => ViewBuilder<Types>;
-declare function $exclude<Types extends AnyTypes>(...args: [ViewPredicate.Expression<Types>] | [TypedC4Expression<Types>] | [ViewPredicate.Expression<Types>, ViewPredicate.Custom<Types>]): (b: ViewBuilder<Types>) => ViewBuilder<Types>;
-declare function $style<Types extends AnyTypes>(element: ViewPredicate.ElementExpr<Types['Fqn']> | NonEmptyArray<ViewPredicate.ElementExpr<Types['Fqn']>>, { notation, ...style }: ViewRuleStyle$1['style'] & {
+type TypedDeploymentExpression<Types extends AnyTypes> = Tagged<DeploymentExpression$1, 'typed', Types>;
+declare function $include<B extends AViewBuilder<AnyTypes, any, any>>(...args: [B['Expr']] | [B['Expr'], ViewPredicate.Custom<B['Types']>]): (b: B) => B;
+declare function $exclude<B extends AViewBuilder<AnyTypes, any, any>>(...args: [B['Expr']] | [B['Expr'], ViewPredicate.Custom<B['Types']>]): (b: B) => B;
+declare function $style<B extends AViewBuilder<AnyTypes, any, any>>(element: B['ElementExpr'] | NonEmptyArray<B['ElementExpr']>, { notation, ...style }: ViewRuleStyle$1['style'] & {
     notation?: string;
-}): (b: ViewBuilder<Types>) => ViewBuilder<Types>;
-declare function $autoLayout<Types extends AnyTypes>(layout: AutoLayoutDirection): (b: ViewBuilder<Types>) => ViewBuilder<Types>;
-declare function $rules<T extends AnyTypes>(...rules: ViewRuleBuilderOp<T>[]): (b: ViewBuilder<T>) => ViewBuilder<T>;
+}): (b: B) => B;
+declare function $autoLayout<B extends AViewBuilder<AnyTypes, any, any>>(layout: AutoLayoutDirection): (b: B) => B;
+declare function $rules<B extends AViewBuilder<AnyTypes, any, any>>(...rules: Op<B>[]): (b: B) => B;
 
 type ViewHelpers<T = unknown> = {
     views: typeof views;
     view: AddViewHelper<T>;
     viewOf: AddViewOfHelper<T>;
+    deploymentView: AddDeploymentViewHelper<T>;
     $include: typeof $include;
     $exclude: typeof $exclude;
     $style: typeof $style;
@@ -859,10 +1816,20 @@ interface Builder<T extends AnyTypes> {
     helpers(): {
         model: ModelHelpers<T>;
         views: ViewHelpers<T['NewViewProps']>;
+        deployment: DeloymentModelHelpers<T>;
     };
     __model(): ModelBuilder<T>;
     __views(): ViewsBuilder<T>;
-    build(): ParsedLikeC4Model<T['ElementKind'], T['RelationshipKind'], T['Tag'], T['Fqn'], T['ViewId']>;
+    __deployment(): DeploymentModelBuilder<T>;
+    /**
+     * Returns model as result of parsing only
+     * Model is not computed or layouted
+     */
+    build(): ParsedLikeC4Model<T['ElementKind'], T['RelationshipKind'], T['Tag'], T['Fqn'], T['ViewId'], T['DeploymentFqn']>;
+    /**
+     * Returns model with computed views
+     */
+    buildComputedModel(): LikeC4Model.Computed<T['Fqn'], T['DeploymentFqn'], T['ViewId']>;
     with<A extends AnyTypes>(op1: (input: Builder<T>) => Builder<A>): Builder<A>;
     with<A extends AnyTypes, B extends AnyTypes>(op1: (input: Builder<T>) => Builder<A>, op2: (input: Builder<A>) => Builder<B>): Builder<B>;
     with<A extends AnyTypes, B extends AnyTypes, C extends AnyTypes>(op1: (input: Builder<T>) => Builder<A>, op2: (input: Builder<A>) => Builder<B>, op3: (input: Builder<B>) => Builder<C>): Builder<C>;
@@ -878,6 +1845,7 @@ declare namespace Builder {
     function forSpecification<const Spec extends BuilderSpecification>(spec: Spec): {
         builder: Builder<Types.FromSpecification<Spec>>;
         model: ModelHelpers<Types.FromSpecification<Spec>>;
+        deployment: DeloymentModelHelpers<Types.FromSpecification<Spec>>;
         views: ViewHelpers<Types.FromSpecification<Spec>['NewViewProps']>;
     };
 }
@@ -1092,452 +2060,73 @@ declare const defaultTheme: {
         gray: {
             lineColor: "#6E6E6E";
             labelBgColor: "#18191b";
-            labelColor: "#C6C6C6";
-        };
-        green: {
-            lineColor: "#15803d";
-            labelBgColor: "#052e16";
-            labelColor: "#22c55e";
-        };
-        indigo: {
-            lineColor: "#6366f1";
-            labelBgColor: "#1e1b4b";
-            labelColor: "#818cf8";
-        };
-        muted: {
-            lineColor: "#64748b";
-            labelBgColor: "#0f172a";
-            labelColor: "#cbd5e1";
-        };
-        primary: {
-            lineColor: "#3b82f6";
-            labelBgColor: "#172554";
-            labelColor: "#60a5fa";
-        };
-        red: {
-            lineColor: "#AC4D39";
-            labelBgColor: "#b91c1c";
-            labelColor: "#f5b2a3";
-        };
-        secondary: {
-            lineColor: "#0ea5e9";
-            labelBgColor: "#082f49";
-            labelColor: "#38bdf8";
-        };
-        sky: {
-            lineColor: "#0ea5e9";
-            labelBgColor: "#082f49";
-            labelColor: "#38bdf8";
-        };
-        slate: {
-            lineColor: "#64748b";
-            labelBgColor: "#0f172a";
-            labelColor: "#cbd5e1";
-        };
-    };
-    font: "Arial";
-    shadow: "#0a0a0a";
-};
-
-declare function nonNullable<T>(value: T, message?: string): NonNullable<T>;
-declare function invariant(condition: any, message?: string): asserts condition;
-declare function nonexhaustive(value: never): never;
-
-type Fqn = LiteralUnion<Fqn$1, string>;
-type RelationID = LiteralUnion<RelationID$1, string>;
-type ViewID = LiteralUnion<ViewID$1, string>;
-type EdgeId = LiteralUnion<EdgeId$1, string>;
-type IncomingFilter = 'all' | 'direct' | 'to-descendants';
-type OutgoingFilter = 'all' | 'direct' | 'from-descendants';
-type ElementOrFqn = Fqn | {
-    id: Fqn;
-};
-
-/**
- * All methods are view-scoped, i.e. only return elements and connections in the view.
- */
-declare class LikeC4ViewModel {
-    readonly view: ComputedView;
-    readonly model: LikeC4Model<LikeC4ViewModel>;
-    private readonly _rootElements;
-    private readonly _elements;
-    private readonly _connections;
-    constructor(view: ComputedView, model: LikeC4Model<LikeC4ViewModel>);
-    get id(): ViewID$1<string>;
-    get title(): string;
-    get viewOf(): LikeC4Model.ElementModel<LikeC4ViewModel>;
-    get tags(): Tag$1[];
-    roots(): ReadonlyArray<LikeC4ViewModel.Element>;
-    elements(): ReadonlyArray<LikeC4ViewModel.Element>;
-    element(id: Fqn): LikeC4ViewModel.Element;
-    hasElement(id: Fqn): boolean;
-    connections(): ReadonlyArray<LikeC4ViewModel.Connection>;
-    connection(id: EdgeId): LikeC4ViewModel.Connection;
-    findConnections(source: ElementOrFqn, target: ElementOrFqn, direction?: 'both' | 'direct'): ReadonlyArray<LikeC4ViewModel.Connection>;
-    parent(element: ElementOrFqn): LikeC4ViewModel.Element | null;
-    children(element: ElementOrFqn): ReadonlyArray<LikeC4ViewModel.Element>;
-    siblings(element: ElementOrFqn): ReadonlyArray<LikeC4ViewModel.Element>;
-    /**
-     * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
-     * (from closest to root)
-     */
-    ancestors(element: ElementOrFqn): ReadonlyArray<LikeC4ViewModel.Element>;
-    descendants(element: ElementOrFqn): ReadonlyArray<LikeC4ViewModel.Element>;
-    incoming(element: ElementOrFqn, filter?: IncomingFilter): ReadonlyArray<LikeC4ViewModel.Connection>;
-    incomers(element: ElementOrFqn, filter?: IncomingFilter): ReadonlyArray<LikeC4ViewModel.Element>;
-    /**
-     * Outgoing relationships from the element and its descendants
-     */
-    outgoing(element: ElementOrFqn, filter?: OutgoingFilter): ReadonlyArray<LikeC4ViewModel.Connection>;
-    outgoers(element: ElementOrFqn, filter?: OutgoingFilter): ReadonlyArray<LikeC4ViewModel.Element>;
-}
-declare namespace LikeC4ViewModel {
-    /**
-     * Represents an element in the view. (Diagram node)
-     * All methods are view-scoped, i.e. `children` returns only children of the element in the view.
-     */
-    class Element {
-        readonly node: ComputedNode;
-        private readonly viewmodel;
-        constructor(node: ComputedNode, viewmodel: LikeC4ViewModel);
-        get id(): NodeId<string>;
-        get title(): string;
-        get kind(): ElementKind$1;
-        get isRoot(): boolean;
-        get hasNested(): boolean;
-        get shape(): ElementShape$1;
-        get color(): Color$1;
-        get tags(): Tag$1[];
-        model(): LikeC4Model.ElementModel<LikeC4ViewModel>;
-        parent(): LikeC4ViewModel.Element | null;
-        metadata(key: string): string | undefined;
-        metadata(key: string, defaultValue: string): string;
-        hasMetadata(key: string): boolean;
-        ancestors(): ReadonlyArray<LikeC4ViewModel.Element>;
-        siblings(): ReadonlyArray<LikeC4ViewModel.Element>;
-        descendants(): ReadonlyArray<LikeC4ViewModel.Element>;
-        children(): ReadonlyArray<LikeC4ViewModel.Element>;
-        incoming(filter?: 'all' | 'direct' | 'to-descendants'): ReadonlyArray<LikeC4ViewModel.Connection>;
-        incomers(filter?: 'all' | 'direct' | 'to-descendants'): ReadonlyArray<LikeC4ViewModel.Element>;
-        outgoing(filter?: OutgoingFilter): ReadonlyArray<LikeC4ViewModel.Connection>;
-        outgoers(filter?: OutgoingFilter): ReadonlyArray<LikeC4ViewModel.Element>;
-        connectionsTo(target: Fqn | LikeC4ViewModel.Element): ReadonlyArray<LikeC4ViewModel.Connection>;
-    }
-    /**
-     * Represents a connection between two elements.
-     * May be source from multiple model relationships.
-     */
-    class Connection {
-        readonly edge: ComputedEdge;
-        private readonly viewmodel;
-        constructor(edge: ComputedEdge, viewmodel: LikeC4ViewModel);
-        get id(): EdgeId$1;
-        get source(): LikeC4ViewModel.Element;
-        get target(): LikeC4ViewModel.Element;
-        get tags(): Tag$1[];
-        /**
-         * Model relationships
-         */
-        relationships(): ReadonlyArray<LikeC4Model.Relationship<LikeC4ViewModel>>;
-    }
-}
-
-type PickBySource<Source> = Source extends LikeC4Model.Layouted.SourceModel ? LikeC4Model.Layouted : Source extends LikeC4Model.Computed.SourceModel ? LikeC4Model.Computed : never;
-declare class LikeC4Model<M extends LikeC4Model.ViewModel = LikeC4Model.ViewModel> {
-    readonly type: LikeC4Model.ModelType<M>;
-    readonly sourcemodel: LikeC4Model.SourceModel<M>;
-    private _elements;
-    private _parents;
-    private _children;
-    private _rootElements;
-    private _relations;
-    private _incoming;
-    private _outgoing;
-    private _internal;
-    private _cacheAscendingSiblings;
-    private _views;
-    constructor(type: LikeC4Model.ModelType<M>, sourcemodel: LikeC4Model.SourceModel<M>, elements: Element$1[], relations: Relation$1[], views: LikeC4Model.SourceModel<M>['views'], ViewModelClass: Class<M>);
-    /**
-     * Returns the root elements of the model.
-     */
-    roots(): ReadonlyArray<LikeC4Model.ElementModel<M>>;
-    /**
-     * Returns all elements in the model.
-     */
-    elements(): ReadonlyArray<LikeC4Model.ElementModel<M>>;
-    /**
-     * Returns a specific element by its FQN.
-     */
-    element(id: Fqn): LikeC4Model.ElementModel<M>;
-    /**
-     * Returns all relationships in the model.
-     */
-    relationships(): ReadonlyArray<LikeC4Model.Relationship<M>>;
-    /**
-     * Returns a specific relationship by its ID.
-     */
-    relationship(id: RelationID): LikeC4Model.Relationship<M>;
-    /**
-     * Returns all views in the model.
-     */
-    views(): ReadonlyArray<M>;
-    /**
-     * Returns a specific view by its ID.
-     */
-    view(viewId: ViewID): M;
-    /**
-     * Returns the parent element of given element.
-     * @see ancestors
-     */
-    parent(element: ElementOrFqn): LikeC4Model.ElementModel<M> | null;
-    /**
-     * Get all children of the element (only direct children),
-     * @see descendants
-     */
-    children(element: ElementOrFqn): ReadonlyArray<LikeC4Model.ElementModel<M>>;
-    /**
-     * Get all sibling (i.e. same parent)
-     */
-    siblings(element: ElementOrFqn): ReadonlyArray<LikeC4Model.ElementModel<M>>;
-    /**
-     * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
-     * (from closest to root)
-     */
-    ancestors(element: ElementOrFqn): ReadonlyArray<LikeC4Model.ElementModel<M>>;
-    /**
-     * Get all descendant elements (i.e. children, children’s children, etc.)
-     */
-    descendants(element: ElementOrFqn): ReadonlyArray<LikeC4Model.ElementModel<M>>;
-    /**
-     * Incoming relationships to the element and its descendants
-     * @see incomers
-     */
-    incoming(element: ElementOrFqn, filter?: IncomingFilter): ReadonlyArray<LikeC4Model.Relationship<M>>;
-    /**
-     * Source elements of incoming relationships
-     */
-    incomers(element: ElementOrFqn, filter?: IncomingFilter): ReadonlyArray<LikeC4Model.ElementModel<M>>;
-    /**
-     * Outgoing relationships from the element and its descendants
-     * @see outgoers
-     */
-    outgoing(element: ElementOrFqn, filter?: OutgoingFilter): ReadonlyArray<LikeC4Model.Relationship<M>>;
-    /**
-     * Target elements of outgoing relationships
-     */
-    outgoers(element: ElementOrFqn, filter?: OutgoingFilter): ReadonlyArray<LikeC4Model.ElementModel<M>>;
-    /**
-     * Relationships inside the element, among descendants
-     */
-    internal(element: ElementOrFqn): ReadonlyArray<LikeC4Model.Relationship<M>>;
-    /**
-     * Resolve siblings of the element and siblings of ancestors
-     *  (from closest to root)
-     */
-    ascendingSiblings(element: ElementOrFqn): ReadonlyArray<LikeC4Model.ElementModel<M>>;
-    /**
-     * Resolve all views that contain the element
-     */
-    viewsWithElement(element: ElementOrFqn): ReadonlyArray<M>;
-    private addElement;
-    private addRelation;
-    private _childrenOf;
-    private _incomingTo;
-    private _outgoingFrom;
-    private _internalOf;
-}
-declare namespace LikeC4Model {
-    function create(source: LikeC4Model.SourceModel): PickBySource<typeof source>;
-    function computed(source: ComputedLikeC4Model): LikeC4Model<LikeC4ViewModel>;
-    function layouted(source: LayoutedLikeC4Model): LikeC4Model<LikeC4DiagramModel>;
-    function isModel(model: any): model is LikeC4Model;
-    type SourceModel<M extends ViewModel = ViewModel> = M extends LikeC4DiagramModel ? LayoutedLikeC4Model : ComputedLikeC4Model;
-    type ViewModel = LikeC4ViewModel | LikeC4DiagramModel;
-    namespace ViewModel {
-        type ElementModel = LikeC4ViewModel.Element | LikeC4DiagramModel.Element;
-        type Relationship = LikeC4Model.Relationship<ViewModel>;
-        function isLayouted(model: ViewModel): model is LikeC4DiagramModel;
-    }
-    type Computed = LikeC4Model<LikeC4ViewModel>;
-    namespace Computed {
-        type ViewModel = LikeC4ViewModel;
-        type SourceModel = LikeC4Model.SourceModel<ViewModel>;
-    }
-    type Layouted = LikeC4Model<LikeC4DiagramModel>;
-    namespace Layouted {
-        type ViewModel = LikeC4DiagramModel;
-        type SourceModel = LikeC4Model.SourceModel<ViewModel>;
-    }
-    type ModelType<M extends ViewModel = ViewModel> = M extends LikeC4DiagramModel ? 'layouted' : M extends LikeC4ViewModel ? 'computed' : never;
-    function isLayouted(model: LikeC4Model): model is Layouted;
-    class Relationship<M extends ViewModel = ViewModel> {
-        readonly relationship: Relation$1;
-        private readonly model;
-        constructor(relationship: Relation$1, model: LikeC4Model<M>);
-        get id(): RelationID$1;
-        get title(): string;
-        get kind(): RelationshipKind$1<string>;
-        get tags(): Tag$1[];
-        get source(): ElementModel<M>;
-        get target(): ElementModel<M>;
-        metadata(key: string): string | undefined;
-        metadata(key: string, defaultValue: string): string;
-        hasMetadata(key: string): boolean;
-    }
-    class ElementModel<M extends ViewModel = ViewModel> {
-        readonly element: Element$1;
-        private readonly model;
-        constructor(element: Element$1, model: LikeC4Model<M>);
-        get id(): Fqn$1<string>;
-        get title(): string;
-        get kind(): ElementKind$1;
-        get isRoot(): boolean;
-        get hasNested(): boolean;
-        get shape(): ElementShape$1;
-        get color(): Color$1;
-        get tags(): Tag$1[];
-        parent(): ElementModel<M> | null;
-        metadata(key: string): string | undefined;
-        metadata(key: string, defaultValue: string): string;
-        hasMetadata(key: string): boolean;
-        ancestors(): readonly ElementModel<M>[];
-        siblings(): readonly ElementModel<M>[];
-        descendants(): readonly ElementModel<M>[];
-        children(): readonly ElementModel<M>[];
-        /**
-         * First 'view of' current element
-         */
-        viewOf(): M;
-        /**
-         * All views 'view of' current element
-         */
-        viewsOf(): M[];
-        /**
-         * Views that contain this element
-         */
-        views(): readonly M[];
-        incoming(filter?: IncomingFilter): readonly Relationship<M>[];
-        incomers(filter?: IncomingFilter): readonly ElementModel<M>[];
-        outgoing(filter?: OutgoingFilter): readonly Relationship<M>[];
-        outgoers(filter?: OutgoingFilter): readonly ElementModel<M>[];
-        internal(): readonly Relationship<M>[];
-        /**
-         * Resolve siblings of the element and siblings of ancestors
-         *  (from closest to root)
-         */
-        ascendingSiblings(): readonly ElementModel<M>[];
-    }
-}
+            labelColor: "#C6C6C6";
+        };
+        green: {
+            lineColor: "#15803d";
+            labelBgColor: "#052e16";
+            labelColor: "#22c55e";
+        };
+        indigo: {
+            lineColor: "#6366f1";
+            labelBgColor: "#1e1b4b";
+            labelColor: "#818cf8";
+        };
+        muted: {
+            lineColor: "#64748b";
+            labelBgColor: "#0f172a";
+            labelColor: "#cbd5e1";
+        };
+        primary: {
+            lineColor: "#3b82f6";
+            labelBgColor: "#172554";
+            labelColor: "#60a5fa";
+        };
+        red: {
+            lineColor: "#AC4D39";
+            labelBgColor: "#b91c1c";
+            labelColor: "#f5b2a3";
+        };
+        secondary: {
+            lineColor: "#0ea5e9";
+            labelBgColor: "#082f49";
+            labelColor: "#38bdf8";
+        };
+        sky: {
+            lineColor: "#0ea5e9";
+            labelBgColor: "#082f49";
+            labelColor: "#38bdf8";
+        };
+        slate: {
+            lineColor: "#64748b";
+            labelBgColor: "#0f172a";
+            labelColor: "#cbd5e1";
+        };
+    };
+    font: "Arial";
+    shadow: "#0a0a0a";
+};
 
-/**
- * All methods are view-scoped, i.e. only return elements and connections in the view.
- */
-declare class LikeC4DiagramModel {
-    readonly view: DiagramView;
-    readonly model: LikeC4Model.Layouted;
-    private readonly _rootElements;
-    private readonly _elements;
-    private readonly _connections;
-    constructor(view: DiagramView, model: LikeC4Model.Layouted);
-    get isDynamic(): boolean;
-    get id(): ViewID$1<string>;
-    get title(): string;
-    get viewOf(): LikeC4Model.ElementModel<LikeC4DiagramModel>;
-    get tags(): Tag$1[];
-    roots(): ReadonlyArray<LikeC4DiagramModel.Element>;
-    elements(): ReadonlyArray<LikeC4DiagramModel.Element>;
-    element(id: Fqn): LikeC4DiagramModel.Element;
-    hasElement(id: Fqn): boolean;
-    connections(): ReadonlyArray<LikeC4DiagramModel.Connection>;
-    connection(id: EdgeId): LikeC4DiagramModel.Connection;
-    findConnections(source: ElementOrFqn, target: ElementOrFqn, direction?: 'both' | 'direct'): ReadonlyArray<LikeC4DiagramModel.Connection>;
-    parent(element: ElementOrFqn): LikeC4DiagramModel.Element | null;
-    children(element: ElementOrFqn): ReadonlyArray<LikeC4DiagramModel.Element>;
-    siblings(element: ElementOrFqn): ReadonlyArray<LikeC4DiagramModel.Element>;
-    /**
-     * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
-     * (from closest to root)
-     */
-    ancestors(element: ElementOrFqn): ReadonlyArray<LikeC4DiagramModel.Element>;
-    descendants(element: ElementOrFqn): ReadonlyArray<LikeC4DiagramModel.Element>;
-    incoming(element: ElementOrFqn, filter?: IncomingFilter): ReadonlyArray<LikeC4DiagramModel.Connection>;
-    incomers(element: ElementOrFqn, filter?: IncomingFilter): ReadonlyArray<LikeC4DiagramModel.Element>;
-    /**
-     * Outgoing relationships from the element and its descendants
-     */
-    outgoing(element: ElementOrFqn, filter?: OutgoingFilter): ReadonlyArray<LikeC4DiagramModel.Connection>;
-    outgoers(element: ElementOrFqn, filter?: OutgoingFilter): ReadonlyArray<LikeC4DiagramModel.Element>;
-}
-declare namespace LikeC4DiagramModel {
-    /**
-     * Represents an element in the view. (Diagram node)
-     * All methods are view-scoped, i.e. `children` returns only children of the element in the view.
-     */
-    class Element {
-        readonly node: DiagramNode;
-        private readonly view;
-        constructor(node: DiagramNode, view: LikeC4DiagramModel);
-        get id(): NodeId<string>;
-        get title(): string;
-        get kind(): ElementKind$1;
-        get isRoot(): boolean;
-        get hasNested(): boolean;
-        get shape(): ElementShape$1;
-        get color(): Color$1;
-        get tags(): Tag$1[];
-        get level(): number;
-        get depth(): number;
-        model(): LikeC4Model.ElementModel<LikeC4DiagramModel>;
-        parent(): LikeC4DiagramModel.Element | null;
-        metadata(key: string): string | undefined;
-        metadata(key: string, defaultValue: string): string;
-        hasMetadata(key: string): boolean;
-        ancestors(): ReadonlyArray<LikeC4DiagramModel.Element>;
-        siblings(): ReadonlyArray<LikeC4DiagramModel.Element>;
-        descendants(): ReadonlyArray<LikeC4DiagramModel.Element>;
-        children(): ReadonlyArray<LikeC4DiagramModel.Element>;
-        incoming(filter?: IncomingFilter): ReadonlyArray<LikeC4DiagramModel.Connection>;
-        incomers(filter?: IncomingFilter): ReadonlyArray<LikeC4DiagramModel.Element>;
-        outgoing(filter?: OutgoingFilter): ReadonlyArray<LikeC4DiagramModel.Connection>;
-        outgoers(filter?: OutgoingFilter): ReadonlyArray<LikeC4DiagramModel.Element>;
-        connectionsTo(target: Fqn | LikeC4DiagramModel.Element): ReadonlyArray<LikeC4DiagramModel.Connection>;
-    }
-    /**
-     * Represents a connection between two elements.
-     * May be source from multiple model relationships.
-     */
-    class Connection {
-        readonly edge: DiagramEdge;
-        private readonly view;
-        constructor(edge: DiagramEdge, view: LikeC4DiagramModel);
-        get id(): EdgeId$1;
-        get source(): LikeC4DiagramModel.Element;
-        get target(): LikeC4DiagramModel.Element;
-        get tags(): Tag$1[];
-        get color(): Color$1;
-        /**
-         * Model relationships
-         */
-        relationships(): ReadonlyArray<LikeC4Model.Relationship<LikeC4DiagramModel>>;
-    }
-}
-declare function nameFromFqn(fqn: LiteralUnion<Fqn$1, string>): string;
+declare function nonNullable<T>(value: T, message?: string): NonNullable<T>;
+declare function invariant(condition: any, message?: string): asserts condition;
+declare function nonexhaustive(value: never): never;
+declare function parentFqn<E extends string>(fqn: E): E | null;
+declare function nameFromFqn<E extends string>(fqn: E): string;
 declare function isAncestor<E extends {
-    id: Fqn$1;
+    id: string;
 }>(...args: [ancestor: string, another: string] | [ancestor: E, another: E]): boolean;
-declare function isSameHierarchy<E extends {
-    id: Fqn$1;
-}>(one: E | Fqn$1, another: E | Fqn$1): boolean;
+declare function isSameHierarchy<E extends string | {
+    id: Fqn;
+}>(one: E, another: E): boolean;
 declare function isDescendantOf<E extends {
-    id: Fqn$1;
+    id: Fqn;
 }>(ancestors: E[]): (e: E) => boolean;
-declare function commonAncestor<IDs extends string>(first: Fqn$1<IDs>, second: Fqn$1<IDs>): Fqn$1<IDs>;
-declare function parentFqn<IDs extends string>(fqn: Fqn$1<IDs>): Fqn$1<IDs> | null;
+declare function commonAncestor<E extends string>(first: E, second: E): E;
 /**
  * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
- * (from closest to root)
+ * going up from parent to the root
  */
-declare function ancestorsFqn<IDs extends string>(fqn: Fqn$1<IDs>): Fqn$1<IDs>[];
+declare function ancestorsFqn<Id extends string>(fqn: Id): Id[];
 /**
  * Compares two fully qualified names (fqns) hierarchically based on their depth.
  * From parent nodes to leaves
@@ -1559,7 +2148,8 @@ declare function compareByFqnHierarchically<T extends {
  * and of the form [x, ...y[]], etc...), and their readonly equivalent. This
  * allows us to be more inclusive to what functions can process.
  *
- * @example map<T extends ArrayLike>(items: T) { ... }
+ * @example
+ *   function map<T extends IterableContainer>(items: T) { ... }
  *
  * We would've named this `ArrayLike`, but that's already used by typescript...
  * @see This was inspired by the type-definition of Promise.all (https://github.com/microsoft/TypeScript/blob/1df5717b120cddd325deab8b0f2b2c3eecaf2b01/src/lib/es2015.promise.d.ts#L21)
@@ -5462,6 +6052,41 @@ interface ILexingError {
   message: string;
 }
 
+interface ILexerErrorMessageProvider {
+  /**
+   * An Unexpected Character Error occurs when the lexer is unable to match a range of one or more
+   * characters in the input text against any of the Token Types in it's Lexer definition
+   *
+   * @param fullText - Full original input text.
+   *
+   * @param startOffset - Offset in input text where error starts.
+   *
+   * @param length - Error length.
+   *
+   * @param line - Line number where the error occurred. (optional)
+   *                    Will not be provided when lexer is not defined to track lines/columns
+   *
+   * @param column - Column number where the error occurred. (optional)
+   *                    Will not be provided when lexer is not defined to track lines/columns
+   */
+  buildUnexpectedCharactersMessage(
+    fullText: string,
+    startOffset: number,
+    length: number,
+    line?: number,
+    column?: number,
+  ): string;
+
+  /**
+   * Unable To Pop Lexer Mode Error happens when lexer tries to pop the last remaining mode from the mode stack
+   * so that there is no longer any active lexer mode
+   * This error only relevant for multi-mode lexers
+   *
+   * @param token - The Token that requested pop mode.
+   */
+  buildUnableToPopLexerModeMessage(token: IToken): string;
+}
+
 type TokenPattern =
   | RegExp
   | string
@@ -6314,7 +6939,7 @@ interface UriComponents {
 }
 
 /******************************************************************************
- * This file was generated by langium-cli 3.2.0.
+ * This file was generated by langium-cli 3.3.0.
  * DO NOT EDIT MANUALLY!
  ******************************************************************************/
 
@@ -7220,7 +7845,7 @@ declare class LangiumCompletionParser extends AbstractLangiumParser {
  */
 declare class ChevrotainWrapper extends EmbeddedActionsParser {
     definitionErrors: IParserDefinitionError[];
-    constructor(tokens: TokenVocabulary, config?: IParserConfig);
+    constructor(tokens: TokenVocabulary, config: IParserConfig);
     get IS_RECORDING(): boolean;
     DEFINE_RULE(name: string, impl: RuleImpl): RuleResult;
     wrapSelfAnalysis(): void;
@@ -7805,12 +8430,52 @@ declare class SimpleCache<K, V> extends DisposableCache {
     delete(key: K): boolean;
     clear(): void;
 }
+declare class ContextCache<Context, Key, Value, ContextKey = Context> extends DisposableCache {
+    private readonly cache;
+    private readonly converter;
+    constructor(converter?: (input: Context) => ContextKey);
+    has(contextKey: Context, key: Key): boolean;
+    set(contextKey: Context, key: Key, value: Value): void;
+    get(contextKey: Context, key: Key): Value | undefined;
+    get(contextKey: Context, key: Key, provider: () => Value): Value;
+    delete(contextKey: Context, key: Key): boolean;
+    clear(): void;
+    clear(contextKey: Context): void;
+    protected cacheForContext(contextKey: Context): Map<Key, Value>;
+}
+/**
+ * Every key/value pair in this cache is scoped to a document.
+ * If this document is changed or deleted, all associated key/value pairs are deleted.
+ */
+declare class DocumentCache<K, V> extends ContextCache<URI | string, K, V, string> {
+    /**
+     * Creates a new document cache.
+     *
+     * @param sharedServices Service container instance to hook into document lifecycle events.
+     * @param state Optional document state on which the cache should evict.
+     * If not provided, the cache will evict on `DocumentBuilder#onUpdate`.
+     * *Deleted* documents are considered in both cases.
+     *
+     * Providing a state here will use `DocumentBuilder#onDocumentPhase` instead,
+     * which triggers on all documents that have been affected by this change, assuming that the
+     * state is `DocumentState.Linked` or a later state.
+     */
+    constructor(sharedServices: LangiumSharedCoreServices, state?: DocumentState);
+}
 /**
  * Every key/value pair in this cache is scoped to the whole workspace.
- * If any document in the workspace changes, the whole cache is evicted.
+ * If any document in the workspace is added, changed or deleted, the whole cache is evicted.
  */
 declare class WorkspaceCache<K, V> extends SimpleCache<K, V> {
-    constructor(sharedServices: LangiumSharedCoreServices);
+    /**
+     * Creates a new workspace cache.
+     *
+     * @param sharedServices Service container instance to hook into document lifecycle events.
+     * @param state Optional document state on which the cache should evict.
+     * If not provided, the cache will evict on `DocumentBuilder#onUpdate`.
+     * *Deleted* documents are considered in both cases.
+     */
+    constructor(sharedServices: LangiumSharedCoreServices, state?: DocumentState);
 }
 
 /******************************************************************************
@@ -7834,6 +8499,10 @@ interface NameProvider {
      */
     getNameNode(node: AstNode): CstNode | undefined;
 }
+declare class DefaultNameProvider implements NameProvider {
+    getName(node: AstNode): string | undefined;
+    getNameNode(node: AstNode): CstNode | undefined;
+}
 
 /******************************************************************************
  * Copyright 2021 TypeFox GmbH
@@ -8007,10 +8676,19 @@ interface DocumentationProvider {
  * This program and the accompanying materials are made available under the
  * terms of the MIT License, which is available in the project root.
  ******************************************************************************/
+/**
+ * Metadata of a language.
+ */
 interface LanguageMetaData {
     languageId: string;
     fileExtensions: readonly string[];
     caseInsensitive: boolean;
+    /**
+     * Mode used to optimize code for development or production environments.
+     *
+     * In production mode, all Chevrotain lexer/parser validations are disabled.
+     */
+    mode: 'development' | 'production';
 }
 
 /******************************************************************************
@@ -8112,9 +8790,7 @@ interface Linker {
     /**
      * Determines a candidate AST node description for linking the given reference.
      *
-     * @param node The AST node containing the reference.
-     * @param refId The reference identifier used to build a scope.
-     * @param reference The actual reference to resolve.
+     * @param refInfo Information about the reference.
      */
     getCandidate(refInfo: ReferenceInfo): AstNodeDescription | LinkingError;
     /**
@@ -8129,8 +8805,8 @@ interface Linker {
      *    and further resolution attempts will *not* be performed.
      *
      * @param node The containing AST node
+     * @param property The AST node property being referenced
      * @param refNode The corresponding CST node
-     * @param refId The cross reference identifier like '<entityTypeName>:<propertyName>'
      * @param refText The cross reference text denoting the target AstNode
      * @returns the desired Reference node, whose behavior wrt. resolving the cross reference is implementation specific.
      */
@@ -8184,8 +8860,9 @@ declare class Deferred<T = void> {
 /**
  * Async parser that allows cancellation of the current parsing process.
  *
- * @remark The sync parser implementation is blocking the event loop, which can become quite problematic for large files.
- * @remark The default implementation is not actually async. It just wraps the sync parser in a promise. A real implementation would create worker threads or web workers to offload the parsing work.
+ * @remarks
+ * The sync parser implementation is blocking the event loop, which can become quite problematic for large files.
+ * The default implementation is not actually async. It just wraps the sync parser in a promise. A real implementation would create worker threads or web workers to offload the parsing work.
  */
 interface AsyncParser {
     /**
@@ -8195,7 +8872,7 @@ interface AsyncParser {
      * @param cancelToken A cancellation token that can be used to cancel the parsing process.
      * @returns A promise that resolves to the parse result.
      *
-     * @throw `OperationCancelled` if the parsing process is cancelled.
+     * @throws `OperationCancelled` if the parsing process is cancelled.
      */
     parse<T extends AstNode>(text: string, cancelToken: CancellationToken): Promise<ParseResult<T>>;
 }
@@ -8388,7 +9065,7 @@ interface JsonSerializer {
     /**
      * Serialize an `AstNode` into a JSON `string`.
      * @param node The `AstNode` to be serialized.
-     * @param space Adds indentation, white space, and line break characters to the return-value JSON text to make it easier to read.
+     * @param options Serialization options
      */
     serialize(node: AstNode, options?: JsonSerializeOptions): string;
     /**
@@ -8428,6 +9105,19 @@ type DiagnosticInfo<N extends AstNode, P extends string = Properties<N>> = {
 type ValidationSeverity = 'error' | 'warning' | 'info' | 'hint';
 type ValidationAcceptor = <N extends AstNode>(severity: ValidationSeverity, message: string, info: DiagnosticInfo<N>) => void;
 type ValidationCheck<T extends AstNode = AstNode> = (node: T, accept: ValidationAcceptor, cancelToken: CancellationToken) => MaybePromise<void>;
+/**
+ * A utility type for describing functions which will be called once before or after all the AstNodes of an AST/Langium document are validated.
+ *
+ * The AST is represented by its root AstNode.
+ *
+ * The given validation acceptor helps to report some early or lately detected issues.
+ *
+ * The 'categories' indicate, which validation categories are executed for all the AstNodes.
+ * This helps to tailor the preparations/tear-down logic to the actually executed checks on the nodes.
+ *
+ * It is recommended to support interrupts during long-running logic with 'interruptAndCheck(cancelToken)'.
+ */
+type ValidationPreparation = (rootNode: AstNode, accept: ValidationAcceptor, categories: ValidationCategory[], cancelToken: CancellationToken) => MaybePromise<void>;
 /**
  * A utility type for associating non-primitive AST types to corresponding validation checks. For example:
  *
@@ -8470,6 +9160,8 @@ type ValidationCheckEntry = {
 declare class ValidationRegistry {
     private readonly entries;
     private readonly reflection;
+    private entriesBefore;
+    private entriesAfter;
     constructor(services: LangiumCoreServices);
     /**
      * Register a set of validation checks. Each value in the record can be either a single validation check (i.e. a function)
@@ -8481,8 +9173,46 @@ declare class ValidationRegistry {
      */
     register<T>(checksRecord: ValidationChecks<T>, thisObj?: ThisParameterType<unknown>, category?: ValidationCategory): void;
     protected wrapValidationException(check: ValidationCheck, thisObj: unknown): ValidationCheck;
+    protected handleException(functionality: () => MaybePromise<void>, messageContext: string, accept: ValidationAcceptor, node: AstNode): Promise<void>;
     protected addEntry(type: string, entry: ValidationCheckEntry): void;
     getChecks(type: string, categories?: ValidationCategory[]): Stream<ValidationCheck>;
+    /**
+     * Register logic which will be executed once before validating all the nodes of an AST/Langium document.
+     * This helps to prepare or initialize some information which are required or reusable for the following checks on the AstNodes.
+     *
+     * As an example, for validating unique fully-qualified names of nodes in the AST,
+     * here the map for mapping names to nodes could be established.
+     * During the usual checks on the nodes, they are put into this map with their name.
+     *
+     * Note that this approach makes validations stateful, which is relevant e.g. when cancelling the validation.
+     * Therefore it is recommended to clear stored information
+     * _before_ validating an AST to validate each AST unaffected from other ASTs
+     * AND _after_ validating the AST to free memory by information which are no longer used.
+     *
+     * @param checkBefore a set-up function which will be called once before actually validating an AST
+     * @param thisObj Optional object to be used as `this` when calling the validation check functions.
+     */
+    registerBeforeDocument(checkBefore: ValidationPreparation, thisObj?: ThisParameterType<unknown>): void;
+    /**
+     * Register logic which will be executed once after validating all the nodes of an AST/Langium document.
+     * This helps to finally evaluate information which are collected during the checks on the AstNodes.
+     *
+     * As an example, for validating unique fully-qualified names of nodes in the AST,
+     * here the map with all the collected nodes and their names is checked
+     * and validation hints are created for all nodes with the same name.
+     *
+     * Note that this approach makes validations stateful, which is relevant e.g. when cancelling the validation.
+     * Therefore it is recommended to clear stored information
+     * _before_ validating an AST to validate each AST unaffected from other ASTs
+     * AND _after_ validating the AST to free memory by information which are no longer used.
+     *
+     * @param checkBefore a set-up function which will be called once before actually validating an AST
+     * @param thisObj Optional object to be used as `this` when calling the validation check functions.
+     */
+    registerAfterDocument(checkAfter: ValidationPreparation, thisObj?: ThisParameterType<unknown>): void;
+    protected wrapPreparationException(check: ValidationPreparation, messageContext: string, thisObj: unknown): ValidationPreparation;
+    get checksBefore(): ValidationPreparation[];
+    get checksAfter(): ValidationPreparation[];
 }
 
 /******************************************************************************
@@ -13167,6 +13897,11 @@ interface WorkspaceManager {
      * Use this to ensure that the workspace manager has finished its initialization.
      */
     readonly ready: Promise<void>;
+    /**
+     * The workspace folders of the current workspace.
+     * Available only after the `ready` promise resolves.
+     */
+    get workspaceFolders(): readonly WorkspaceFolder[] | undefined;
     /**
      * When used in a language server context, this method is called when the server receives
      * the `initialize` request.
@@ -13200,6 +13935,7 @@ declare class DefaultWorkspaceManager implements WorkspaceManager {
     protected folders?: WorkspaceFolder[];
     constructor(services: LangiumSharedCoreServices);
     get ready(): Promise<void>;
+    get workspaceFolders(): readonly WorkspaceFolder[] | undefined;
     initialize(params: InitializeParams): void;
     initialized(_params: InitializedParams): Promise<void>;
     initializeWorkspace(folders: WorkspaceFolder[], cancelToken?: CancellationToken): Promise<void>;
@@ -13258,6 +13994,7 @@ type LangiumDefaultCoreServices = {
         readonly ValueConverter: ValueConverter;
         readonly LangiumParser: LangiumParser;
         readonly ParserErrorMessageProvider: IParserErrorMessageProvider;
+        readonly LexerErrorMessageProvider: ILexerErrorMessageProvider;
         readonly CompletionParser: LangiumCompletionParser;
         readonly TokenBuilder: TokenBuilder;
         readonly Lexer: Lexer;
@@ -15312,7 +16049,7 @@ declare class DefaultCompletionProvider implements CompletionProvider {
 }
 
 interface ChangeViewRequestParams {
-    viewId: ViewID$1;
+    viewId: ViewId;
     change: ViewChange;
 }
 
@@ -15345,7 +16082,7 @@ declare class LikeC4DocumentLinkProvider implements DocumentLinkProvider {
 }
 
 /******************************************************************************
- * This file was generated by langium-cli 3.2.0.
+ * This file was generated by langium-cli 3.3.0.
  * DO NOT EDIT MANUALLY!
  ******************************************************************************/
 
@@ -15353,6 +16090,18 @@ type ArrowType = 'crow' | 'diamond' | 'dot' | 'none' | 'normal' | 'odiamond' | '
 type BorderStyleValue = 'none' | LineOptions;
 type CustomColorId = 'element' | 'model' | ArrowType | ElementShape | LineOptions | string;
 type CustomColorValue = string;
+type DeploymentElement = DeployedInstance | DeploymentNode;
+declare const DeploymentElement = "DeploymentElement";
+type DeploymentElementExpression = DeploymentRefExpression | WildcardExpression;
+declare const DeploymentElementExpression = "DeploymentElementExpression";
+type DeploymentExpression = DeploymentElementExpression | DeploymentRelationExpression;
+declare const DeploymentExpression = "DeploymentExpression";
+type DeploymentReferenceable = DeployedInstance | DeploymentNode | Element;
+declare const DeploymentReferenceable = "DeploymentReferenceable";
+type DeploymentRelationExpression = DirectedDeploymentRelationExpression | InOutDeploymentRelationExpression | IncomingDeploymentRelationExpression | OutgoingDeploymentRelationExpression;
+declare const DeploymentRelationExpression = "DeploymentRelationExpression";
+type DeploymentViewRule = DeploymentViewRulePredicate | DeploymentViewRuleStyle | ViewRuleAutoLayout;
+declare const DeploymentViewRule = "DeploymentViewRule";
 type DynamicViewRule = DynamicViewGlobalPredicateRef | DynamicViewIncludePredicate | ViewRuleAutoLayout | ViewRuleStyleOrGlobalRef;
 declare const DynamicViewRule = "DynamicViewRule";
 type ElementExpression = ElementDescedantsExpression | ElementKindExpression | ElementRef | ElementTagExpression | ExpandElementExpression | WildcardExpression;
@@ -15364,9 +16113,11 @@ declare const ElementPredicateOrWhere = "ElementPredicateOrWhere";
 type ElementProperty = ElementStringProperty | ElementStyleProperty | IconProperty | LinkProperty | MetadataProperty;
 declare const ElementProperty = "ElementProperty";
 type ElementShape = 'browser' | 'cylinder' | 'mobile' | 'person' | 'queue' | 'rectangle' | 'storage';
+type FqnReferenceable = DeploymentReferenceable | Element | ExtendElement;
+declare const FqnReferenceable = "FqnReferenceable";
 type IconId = string;
-type Id = 'element' | 'group' | 'model' | ArrowType | ElementShape | LineOptions | ThemeColor | string;
-type LikeC4View = DynamicView | ElementView;
+type Id = 'deployment' | 'element' | 'group' | 'model' | 'node' | ArrowType | ElementShape | LineOptions | ThemeColor | string;
+type LikeC4View = DeploymentView | DynamicView | ElementView;
 declare const LikeC4View = "LikeC4View";
 type LineOptions = 'dashed' | 'dotted' | 'solid';
 type MetadataProperty = MetadataBody;
@@ -15420,14 +16171,14 @@ interface ArrowProperty extends AstNode {
 }
 declare const ArrowProperty = "ArrowProperty";
 interface BorderProperty extends AstNode {
-    readonly $container: CustomElementProperties | ElementStyleProperty | GlobalStyle | ViewRuleGroup | ViewRuleStyle;
+    readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleGroup | ViewRuleStyle;
     readonly $type: 'BorderProperty';
     key: 'border';
     value: BorderStyleValue;
 }
 declare const BorderProperty = "BorderProperty";
 interface ColorProperty extends AstNode {
-    readonly $container: CustomElementProperties | CustomRelationProperties | ElementStyleProperty | GlobalStyle | RelationStyleProperty | SpecificationRelationshipKind | ViewRuleGroup | ViewRuleStyle;
+    readonly $container: CustomElementProperties | CustomRelationProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | RelationStyleProperty | SpecificationRelationshipKind | ViewRuleGroup | ViewRuleStyle;
     readonly $type: 'ColorProperty';
     customColor?: Reference<CustomColor>;
     key: 'color';
@@ -15452,6 +16203,128 @@ interface CustomRelationProperties extends AstNode {
     props: Array<NotationProperty | NotesProperty | RelationNavigateToProperty | RelationStringProperty | RelationshipStyleProperty>;
 }
 declare const CustomRelationProperties = "CustomRelationProperties";
+interface DeployedInstance extends AstNode {
+    readonly $container: DeploymentNodeBody;
+    readonly $type: 'DeployedInstance';
+    body?: DeployedInstanceBody;
+    element: ElementRef;
+    name?: Id;
+    title?: string;
+}
+declare const DeployedInstance = "DeployedInstance";
+interface DeployedInstanceBody extends AstNode {
+    readonly $container: DeployedInstance;
+    readonly $type: 'DeployedInstanceBody';
+    props: Array<ElementProperty>;
+    tags?: Tags;
+}
+declare const DeployedInstanceBody = "DeployedInstanceBody";
+interface DeploymentExpressionIterator extends AstNode {
+    readonly $container: DeploymentExpressionIterator | DeploymentViewRuleStyle;
+    readonly $type: 'DeploymentExpressionIterator';
+    prev?: DeploymentExpressionIterator;
+    value: DeploymentElementExpression;
+}
+declare const DeploymentExpressionIterator = "DeploymentExpressionIterator";
+interface DeploymentNode extends AstNode {
+    readonly $container: DeploymentNodeBody | ModelDeployments;
+    readonly $type: 'DeploymentNode';
+    body?: DeploymentNodeBody;
+    kind: Reference<DeploymentNodeKind>;
+    name: Id;
+    title?: string;
+}
+declare const DeploymentNode = "DeploymentNode";
+interface DeploymentNodeBody extends AstNode {
+    readonly $container: DeploymentNode;
+    readonly $type: 'DeploymentNodeBody';
+    elements: Array<DeployedInstance | DeploymentNode | DeploymentRelation>;
+    props: Array<ElementProperty>;
+    tags?: Tags;
+}
+declare const DeploymentNodeBody = "DeploymentNodeBody";
+interface DeploymentNodeKind extends AstNode {
+    readonly $container: SpecificationDeploymentNodeKind;
+    readonly $type: 'DeploymentNodeKind';
+    name: Id;
+}
+declare const DeploymentNodeKind = "DeploymentNodeKind";
+interface DeploymentRef extends AstNode {
+    readonly $container: DeploymentRef | DeploymentRefExpression | DeploymentRelation;
+    readonly $type: 'DeploymentRef';
+    parent?: DeploymentRef;
+    value: Reference<DeploymentReferenceable>;
+}
+declare const DeploymentRef = "DeploymentRef";
+interface DeploymentRefExpression extends AstNode {
+    readonly $container: DeploymentExpressionIterator | DeploymentViewRulePredicateExpression | DirectedDeploymentRelationExpression | IncomingDeploymentRelationExpression | OutgoingDeploymentRelationExpression;
+    readonly $type: 'DeploymentRefExpression';
+    ref: DeploymentRef;
+    selector?: string;
+}
+declare const DeploymentRefExpression = "DeploymentRefExpression";
+interface DeploymentRelation extends AstNode {
+    readonly $container: DeploymentNodeBody | ModelDeployments;
+    readonly $type: 'DeploymentRelation';
+    body?: DeploymentRelationBody;
+    kind?: Reference<RelationshipKind>;
+    source: DeploymentRef;
+    tags?: Tags;
+    target: DeploymentRef;
+    technology?: string;
+    title?: string;
+}
+declare const DeploymentRelation = "DeploymentRelation";
+interface DeploymentRelationBody extends AstNode {
+    readonly $container: DeploymentRelation;
+    readonly $type: 'DeploymentRelationBody';
+    props: Array<RelationProperty>;
+    tags?: Tags;
+}
+declare const DeploymentRelationBody = "DeploymentRelationBody";
+interface DeploymentView extends AstNode {
+    readonly $container: ModelViews;
+    readonly $type: 'DeploymentView';
+    body?: DeploymentViewBody;
+    name: Id;
+}
+declare const DeploymentView = "DeploymentView";
+interface DeploymentViewBody extends AstNode {
+    readonly $container: DeploymentView;
+    readonly $type: 'DeploymentViewBody';
+    props: Array<ViewProperty>;
+    rules: Array<DeploymentViewRule>;
+    tags?: Tags;
+}
+declare const DeploymentViewBody = "DeploymentViewBody";
+interface DeploymentViewRulePredicate extends AstNode {
+    readonly $container: DeploymentViewBody;
+    readonly $type: 'DeploymentViewRulePredicate';
+    expr: DeploymentViewRulePredicateExpression;
+    isInclude: boolean;
+}
+declare const DeploymentViewRulePredicate = "DeploymentViewRulePredicate";
+interface DeploymentViewRulePredicateExpression extends AstNode {
+    readonly $container: DeploymentViewRulePredicate | DeploymentViewRulePredicateExpression;
+    readonly $type: 'DeploymentViewRulePredicateExpression';
+    prev?: DeploymentViewRulePredicateExpression;
+    value: DeploymentExpression;
+}
+declare const DeploymentViewRulePredicateExpression = "DeploymentViewRulePredicateExpression";
+interface DeploymentViewRuleStyle extends AstNode {
+    readonly $container: DeploymentViewBody;
+    readonly $type: 'DeploymentViewRuleStyle';
+    props: Array<NotationProperty | StyleProperty>;
+    target: DeploymentExpressionIterator;
+}
+declare const DeploymentViewRuleStyle = "DeploymentViewRuleStyle";
+interface DirectedDeploymentRelationExpression extends AstNode {
+    readonly $container: DeploymentViewRulePredicateExpression;
+    readonly $type: 'DirectedDeploymentRelationExpression';
+    source: OutgoingDeploymentRelationExpression;
+    target: DeploymentElementExpression;
+}
+declare const DirectedDeploymentRelationExpression = "DirectedDeploymentRelationExpression";
 interface DirectedRelationExpression extends AstNode {
     readonly $container: Predicates | RelationPredicateWhere | RelationPredicateWith;
     readonly $type: 'DirectedRelationExpression';
@@ -15538,6 +16411,7 @@ interface ElementDescedantsExpression extends AstNode {
     readonly $container: DirectedRelationExpression | DynamicViewPredicateIterator | ElementExpressionsIterator | ElementPredicateWhere | ElementPredicateWith | IncomingRelationExpression | OutgoingRelationExpression | Predicates;
     readonly $type: 'ElementDescedantsExpression';
     parent: ElementRef;
+    suffix: string;
 }
 declare const ElementDescedantsExpression = "ElementDescedantsExpression";
 interface ElementExpressionsIterator extends AstNode {
@@ -15575,21 +16449,21 @@ interface ElementPredicateWith extends AstNode {
 }
 declare const ElementPredicateWith = "ElementPredicateWith";
 interface ElementRef extends AstNode {
-    readonly $container: DirectedRelationExpression | DynamicViewPredicateIterator | DynamicViewStep | ElementDescedantsExpression | ElementExpressionsIterator | ElementPredicateWhere | ElementPredicateWith | ElementRef | ElementView | ExpandElementExpression | IncomingRelationExpression | OutgoingRelationExpression | Predicates | Relation;
+    readonly $container: DeployedInstance | DirectedRelationExpression | DynamicViewPredicateIterator | DynamicViewStep | ElementDescedantsExpression | ElementExpressionsIterator | ElementPredicateWhere | ElementPredicateWith | ElementRef | ElementView | ExpandElementExpression | IncomingRelationExpression | OutgoingRelationExpression | Predicates | Relation;
     readonly $type: 'ElementRef';
     el: Reference<Element>;
     parent?: ElementRef;
 }
 declare const ElementRef = "ElementRef";
 interface ElementStringProperty extends AstNode {
-    readonly $container: CustomElementProperties | ElementBody;
+    readonly $container: CustomElementProperties | DeployedInstanceBody | DeploymentNodeBody | ElementBody;
     readonly $type: 'ElementStringProperty';
     key: 'description' | 'technology' | 'title';
     value: string;
 }
 declare const ElementStringProperty = "ElementStringProperty";
 interface ElementStyleProperty extends AstNode {
-    readonly $container: ElementBody | SpecificationElementKind;
+    readonly $container: DeployedInstanceBody | DeploymentNodeBody | ElementBody | SpecificationDeploymentNodeKind | SpecificationElementKind;
     readonly $type: 'ElementStyleProperty';
     key: 'style';
     props: Array<StyleProperty>;
@@ -15701,7 +16575,7 @@ interface GlobalStyleId extends AstNode {
 }
 declare const GlobalStyleId = "GlobalStyleId";
 interface IconProperty extends AstNode {
-    readonly $container: CustomElementProperties | ElementBody | ElementStyleProperty | GlobalStyle | ViewRuleStyle;
+    readonly $container: CustomElementProperties | DeployedInstanceBody | DeploymentNodeBody | DeploymentViewRuleStyle | ElementBody | ElementStyleProperty | GlobalStyle | ViewRuleStyle;
     readonly $type: 'IconProperty';
     key: 'icon';
     libicon?: Reference<LibIcon>;
@@ -15714,12 +16588,24 @@ interface IncludePredicate extends AstNode {
     predicates: Predicates;
 }
 declare const IncludePredicate = "IncludePredicate";
+interface IncomingDeploymentRelationExpression extends AstNode {
+    readonly $container: DeploymentViewRulePredicateExpression | InOutDeploymentRelationExpression;
+    readonly $type: 'IncomingDeploymentRelationExpression';
+    to: DeploymentElementExpression;
+}
+declare const IncomingDeploymentRelationExpression = "IncomingDeploymentRelationExpression";
 interface IncomingRelationExpression extends AstNode {
     readonly $container: InOutRelationExpression | Predicates | RelationPredicateWhere | RelationPredicateWith;
     readonly $type: 'IncomingRelationExpression';
     to: ElementExpression;
 }
 declare const IncomingRelationExpression = "IncomingRelationExpression";
+interface InOutDeploymentRelationExpression extends AstNode {
+    readonly $container: DeploymentViewRulePredicateExpression;
+    readonly $type: 'InOutDeploymentRelationExpression';
+    inout: IncomingDeploymentRelationExpression;
+}
+declare const InOutDeploymentRelationExpression = "InOutDeploymentRelationExpression";
 interface InOutRelationExpression extends AstNode {
     readonly $container: Predicates | RelationPredicateWhere | RelationPredicateWith;
     readonly $type: 'InOutRelationExpression';
@@ -15734,6 +16620,7 @@ interface LibIcon extends AstNode {
 declare const LibIcon = "LibIcon";
 interface LikeC4Grammar extends AstNode {
     readonly $type: 'LikeC4Grammar';
+    deployments: Array<ModelDeployments>;
     globals: Array<Globals>;
     likec4lib: Array<LikeC4Lib>;
     models: Array<Model>;
@@ -15755,7 +16642,7 @@ interface LineProperty extends AstNode {
 }
 declare const LineProperty = "LineProperty";
 interface LinkProperty extends AstNode {
-    readonly $container: DynamicViewBody | ElementBody | ElementViewBody | RelationBody;
+    readonly $container: DeployedInstanceBody | DeploymentNodeBody | DeploymentRelationBody | DeploymentViewBody | DynamicViewBody | ElementBody | ElementViewBody | RelationBody;
     readonly $type: 'LinkProperty';
     key: 'link';
     title?: string;
@@ -15770,7 +16657,7 @@ interface MetadataAttribute extends AstNode {
 }
 declare const MetadataAttribute = "MetadataAttribute";
 interface MetadataBody extends AstNode {
-    readonly $container: ElementBody | RelationBody;
+    readonly $container: DeployedInstanceBody | DeploymentNodeBody | DeploymentRelationBody | ElementBody | RelationBody;
     readonly $type: 'MetadataBody';
     props: Array<MetadataAttribute>;
 }
@@ -15782,6 +16669,13 @@ interface Model extends AstNode {
     name: 'model';
 }
 declare const Model = "Model";
+interface ModelDeployments extends AstNode {
+    readonly $container: LikeC4Grammar;
+    readonly $type: 'ModelDeployments';
+    elements: Array<DeploymentNode | DeploymentRelation>;
+    name: 'deployment';
+}
+declare const ModelDeployments = "ModelDeployments";
 interface ModelViews extends AstNode {
     readonly $container: LikeC4Grammar;
     readonly $type: 'ModelViews';
@@ -15798,7 +16692,7 @@ interface NavigateToProperty extends AstNode {
 }
 declare const NavigateToProperty = "NavigateToProperty";
 interface NotationProperty extends AstNode {
-    readonly $container: CustomElementProperties | CustomRelationProperties | GlobalStyle | ViewRuleStyle;
+    readonly $container: CustomElementProperties | CustomRelationProperties | DeploymentViewRuleStyle | GlobalStyle | ViewRuleStyle;
     readonly $type: 'NotationProperty';
     key: 'notation';
     value: string;
@@ -15812,12 +16706,20 @@ interface NotesProperty extends AstNode {
 }
 declare const NotesProperty = "NotesProperty";
 interface OpacityProperty extends AstNode {
-    readonly $container: CustomElementProperties | ElementStyleProperty | GlobalStyle | ViewRuleGroup | ViewRuleStyle;
+    readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleGroup | ViewRuleStyle;
     readonly $type: 'OpacityProperty';
     key: 'opacity';
     value: string;
 }
 declare const OpacityProperty = "OpacityProperty";
+interface OutgoingDeploymentRelationExpression extends AstNode {
+    readonly $container: DeploymentViewRulePredicateExpression | DirectedDeploymentRelationExpression;
+    readonly $type: 'OutgoingDeploymentRelationExpression';
+    from: DeploymentElementExpression;
+    isBidirectional: boolean;
+    kind?: Reference<RelationshipKind>;
+}
+declare const OutgoingDeploymentRelationExpression = "OutgoingDeploymentRelationExpression";
 interface OutgoingRelationExpression extends AstNode {
     readonly $container: DirectedRelationExpression | Predicates | RelationPredicateWhere | RelationPredicateWith;
     readonly $type: 'OutgoingRelationExpression';
@@ -15853,7 +16755,7 @@ interface RelationBody extends AstNode {
 }
 declare const RelationBody = "RelationBody";
 interface RelationNavigateToProperty extends AstNode {
-    readonly $container: CustomRelationProperties | RelationBody;
+    readonly $container: CustomRelationProperties | DeploymentRelationBody | RelationBody;
     readonly $type: 'RelationNavigateToProperty';
     key: 'navigateTo';
     value: DynamicViewRef;
@@ -15880,21 +16782,21 @@ interface RelationshipKind extends AstNode {
 }
 declare const RelationshipKind = "RelationshipKind";
 interface RelationStringProperty extends AstNode {
-    readonly $container: CustomRelationProperties | RelationBody;
+    readonly $container: CustomRelationProperties | DeploymentRelationBody | RelationBody;
     readonly $type: 'RelationStringProperty';
     key: 'description' | 'technology' | 'title';
     value: string;
 }
 declare const RelationStringProperty = "RelationStringProperty";
 interface RelationStyleProperty extends AstNode {
-    readonly $container: RelationBody;
+    readonly $container: DeploymentRelationBody | RelationBody;
     readonly $type: 'RelationStyleProperty';
     key: 'style';
     props: Array<RelationshipStyleProperty>;
 }
 declare const RelationStyleProperty = "RelationStyleProperty";
 interface ShapeProperty extends AstNode {
-    readonly $container: CustomElementProperties | ElementStyleProperty | GlobalStyle | ViewRuleStyle;
+    readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleStyle;
     readonly $type: 'ShapeProperty';
     key: 'shape';
     value: ElementShape;
@@ -15907,6 +16809,13 @@ interface SpecificationColor extends AstNode {
     name: CustomColor;
 }
 declare const SpecificationColor = "SpecificationColor";
+interface SpecificationDeploymentNodeKind extends AstNode {
+    readonly $container: SpecificationRule;
+    readonly $type: 'SpecificationDeploymentNodeKind';
+    kind: DeploymentNodeKind;
+    props: Array<ElementStyleProperty | SpecificationElementStringProperty>;
+}
+declare const SpecificationDeploymentNodeKind = "SpecificationDeploymentNodeKind";
 interface SpecificationElementKind extends AstNode {
     readonly $container: SpecificationRule;
     readonly $type: 'SpecificationElementKind';
@@ -15915,7 +16824,7 @@ interface SpecificationElementKind extends AstNode {
 }
 declare const SpecificationElementKind = "SpecificationElementKind";
 interface SpecificationElementStringProperty extends AstNode {
-    readonly $container: SpecificationElementKind;
+    readonly $container: SpecificationDeploymentNodeKind | SpecificationElementKind;
     readonly $type: 'SpecificationElementStringProperty';
     key: 'notation' | 'technology';
     value: string;
@@ -15939,6 +16848,7 @@ interface SpecificationRule extends AstNode {
     readonly $container: LikeC4Grammar;
     readonly $type: 'SpecificationRule';
     colors: Array<SpecificationColor>;
+    deploymentNodes: Array<SpecificationDeploymentNodeKind>;
     elements: Array<SpecificationElementKind>;
     name: 'specification';
     relationships: Array<SpecificationRelationshipKind>;
@@ -15958,7 +16868,7 @@ interface Tag extends AstNode {
 }
 declare const Tag = "Tag";
 interface Tags extends AstNode {
-    readonly $container: DynamicViewBody | ElementBody | ElementViewBody | Relation | RelationBody | Tags;
+    readonly $container: DeployedInstanceBody | DeploymentNodeBody | DeploymentRelation | DeploymentRelationBody | DeploymentViewBody | DynamicViewBody | ElementBody | ElementViewBody | Relation | RelationBody | Tags;
     readonly $type: 'Tags';
     prev?: Tags;
     values: Array<Reference<Tag>>;
@@ -15971,7 +16881,7 @@ interface ViewRef extends AstNode {
 }
 declare const ViewRef = "ViewRef";
 interface ViewRuleAutoLayout extends AstNode {
-    readonly $container: DynamicViewBody | ElementViewBody;
+    readonly $container: DeploymentViewBody | DynamicViewBody | ElementViewBody;
     readonly $type: 'ViewRuleAutoLayout';
     direction: ViewLayoutDirection;
     nodeSep?: number;
@@ -16006,7 +16916,7 @@ interface ViewRuleStyle extends AstNode {
 }
 declare const ViewRuleStyle = "ViewRuleStyle";
 interface ViewStringProperty extends AstNode {
-    readonly $container: DynamicViewBody | ElementViewBody;
+    readonly $container: DeploymentViewBody | DynamicViewBody | ElementViewBody;
     readonly $type: 'ViewStringProperty';
     key: 'description' | 'title';
     value: string;
@@ -16065,7 +16975,7 @@ interface WhereRelationTag extends AstNode {
 }
 declare const WhereRelationTag = "WhereRelationTag";
 interface WildcardExpression extends AstNode {
-    readonly $container: DirectedRelationExpression | DynamicViewPredicateIterator | ElementExpressionsIterator | ElementPredicateWhere | ElementPredicateWith | IncomingRelationExpression | OutgoingRelationExpression | Predicates;
+    readonly $container: DeploymentExpressionIterator | DeploymentViewRulePredicateExpression | DirectedDeploymentRelationExpression | DirectedRelationExpression | DynamicViewPredicateIterator | ElementExpressionsIterator | ElementPredicateWhere | ElementPredicateWith | IncomingDeploymentRelationExpression | IncomingRelationExpression | OutgoingDeploymentRelationExpression | OutgoingRelationExpression | Predicates;
     readonly $type: 'WildcardExpression';
     isWildcard: boolean;
 }
@@ -16077,6 +16987,28 @@ type LikeC4AstType = {
     CustomColor: CustomColor;
     CustomElementProperties: CustomElementProperties;
     CustomRelationProperties: CustomRelationProperties;
+    DeployedInstance: DeployedInstance;
+    DeployedInstanceBody: DeployedInstanceBody;
+    DeploymentElement: DeploymentElement;
+    DeploymentElementExpression: DeploymentElementExpression;
+    DeploymentExpression: DeploymentExpression;
+    DeploymentExpressionIterator: DeploymentExpressionIterator;
+    DeploymentNode: DeploymentNode;
+    DeploymentNodeBody: DeploymentNodeBody;
+    DeploymentNodeKind: DeploymentNodeKind;
+    DeploymentRef: DeploymentRef;
+    DeploymentRefExpression: DeploymentRefExpression;
+    DeploymentReferenceable: DeploymentReferenceable;
+    DeploymentRelation: DeploymentRelation;
+    DeploymentRelationBody: DeploymentRelationBody;
+    DeploymentRelationExpression: DeploymentRelationExpression;
+    DeploymentView: DeploymentView;
+    DeploymentViewBody: DeploymentViewBody;
+    DeploymentViewRule: DeploymentViewRule;
+    DeploymentViewRulePredicate: DeploymentViewRulePredicate;
+    DeploymentViewRulePredicateExpression: DeploymentViewRulePredicateExpression;
+    DeploymentViewRuleStyle: DeploymentViewRuleStyle;
+    DirectedDeploymentRelationExpression: DirectedDeploymentRelationExpression;
     DirectedRelationExpression: DirectedRelationExpression;
     DynamicView: DynamicView;
     DynamicViewBody: DynamicViewBody;
@@ -16111,6 +17043,7 @@ type LikeC4AstType = {
     ExtendElement: ExtendElement;
     ExtendElementBody: ExtendElementBody;
     FqnElementRef: FqnElementRef;
+    FqnReferenceable: FqnReferenceable;
     GlobalDynamicPredicateGroup: GlobalDynamicPredicateGroup;
     GlobalPredicateGroup: GlobalPredicateGroup;
     GlobalStyle: GlobalStyle;
@@ -16118,8 +17051,10 @@ type LikeC4AstType = {
     GlobalStyleId: GlobalStyleId;
     Globals: Globals;
     IconProperty: IconProperty;
+    InOutDeploymentRelationExpression: InOutDeploymentRelationExpression;
     InOutRelationExpression: InOutRelationExpression;
     IncludePredicate: IncludePredicate;
+    IncomingDeploymentRelationExpression: IncomingDeploymentRelationExpression;
     IncomingRelationExpression: IncomingRelationExpression;
     LibIcon: LibIcon;
     LikeC4Grammar: LikeC4Grammar;
@@ -16131,11 +17066,13 @@ type LikeC4AstType = {
     MetadataBody: MetadataBody;
     MetadataProperty: MetadataProperty;
     Model: Model;
+    ModelDeployments: ModelDeployments;
     ModelViews: ModelViews;
     NavigateToProperty: NavigateToProperty;
     NotationProperty: NotationProperty;
     NotesProperty: NotesProperty;
     OpacityProperty: OpacityProperty;
+    OutgoingDeploymentRelationExpression: OutgoingDeploymentRelationExpression;
     OutgoingRelationExpression: OutgoingRelationExpression;
     Predicate: Predicate;
     Predicates: Predicates;
@@ -16154,6 +17091,7 @@ type LikeC4AstType = {
     RelationshipStyleProperty: RelationshipStyleProperty;
     ShapeProperty: ShapeProperty;
     SpecificationColor: SpecificationColor;
+    SpecificationDeploymentNodeKind: SpecificationDeploymentNodeKind;
     SpecificationElementKind: SpecificationElementKind;
     SpecificationElementStringProperty: SpecificationElementStringProperty;
     SpecificationRelationshipKind: SpecificationRelationshipKind;
@@ -16195,13 +17133,22 @@ type LikeC4AstType = {
 declare const idattr: unique symbol;
 declare module './generated/ast' {
     interface Element {
-        [idattr]?: Fqn$1 | undefined;
+        [idattr]?: Fqn | undefined;
     }
     interface ElementView {
-        [idattr]?: ViewID$1 | undefined;
+        [idattr]?: ViewId | undefined;
     }
     interface DynamicView {
-        [idattr]?: ViewID$1 | undefined;
+        [idattr]?: ViewId | undefined;
+    }
+    interface DeploymentView {
+        [idattr]?: ViewId | undefined;
+    }
+    interface DeploymentNode {
+        [idattr]?: Fqn | undefined;
+    }
+    interface DeployedInstance {
+        [idattr]?: Fqn | undefined;
     }
 }
 type ParsedElementStyle = {
@@ -16229,9 +17176,10 @@ interface ParsedAstSpecification {
     colors: Record<CustomColor$1, {
         color: HexColorLiteral;
     }>;
+    deployments: Record<DeploymentNodeKind$1, DeploymentNodeKindSpecification>;
 }
 interface ParsedAstElement {
-    id: Fqn$1;
+    id: Fqn;
     astPath: string;
     kind: ElementKind$1;
     title: string;
@@ -16245,10 +17193,10 @@ interface ParsedAstElement {
     };
 }
 interface ParsedAstRelation {
-    id: RelationID$1;
+    id: RelationId;
     astPath: string;
-    source: Fqn$1;
-    target: Fqn$1;
+    source: Fqn;
+    target: Fqn;
     kind?: RelationshipKind$1;
     tags?: NonEmptyArray<Tag$1>;
     title: string;
@@ -16259,17 +17207,25 @@ interface ParsedAstRelation {
     head?: RelationshipArrowType;
     tail?: RelationshipArrowType;
     links?: NonEmptyArray<ParsedLink>;
-    navigateTo?: ViewID$1;
+    navigateTo?: ViewId;
     metadata?: {
         [key: string]: string;
     };
 }
+type ParsedAstDeployment = DeploymentElement$1;
+declare namespace ParsedAstDeployment {
+    type Node = DeploymentNode$1;
+    type Instance = DeployedInstance$1;
+}
+type ParsedAstDeploymentRelation = DeploymentRelation$1 & {
+    astPath: string;
+};
 type ParsedAstGlobals = ModelGlobals;
 interface ParsedAstElementView {
     __: 'element';
-    id: ViewID$1;
-    viewOf?: Fqn$1;
-    extends?: ViewID$1;
+    id: ViewId;
+    viewOf?: Fqn;
+    extends?: ViewId;
     astPath: string;
     title: string | null;
     description: string | null;
@@ -16280,7 +17236,7 @@ interface ParsedAstElementView {
 }
 interface ParsedAstDynamicView {
     __: 'dynamic';
-    id: ViewID$1;
+    id: ViewId;
     astPath: string;
     title: string | null;
     description: string | null;
@@ -16290,13 +17246,26 @@ interface ParsedAstDynamicView {
     rules: Array<DynamicViewRule$1>;
     manualLayout?: ViewManualLayout;
 }
-type ParsedAstView = ParsedAstElementView | ParsedAstDynamicView;
+interface ParsedAstDeploymentView {
+    __: 'deployment';
+    id: ViewId;
+    astPath: string;
+    title: string | null;
+    description: string | null;
+    tags: NonEmptyArray<Tag$1> | null;
+    links: NonEmptyArray<ParsedLink> | null;
+    rules: Array<DeploymentViewRule$1>;
+}
+type ParsedAstView = ParsedAstElementView | ParsedAstDynamicView | ParsedAstDeploymentView;
 interface ParsedLink {
     title?: string;
     url: string;
 }
 interface DocFqnIndexAstNodeDescription extends AstNodeDescription {
-    fqn: Fqn$1;
+    fqn: Fqn;
+}
+interface DeploymentAstNodeDescription extends AstNodeDescription {
+    fqn: string;
 }
 type LikeC4AstNode = ValueOf<ConditionalPick<LikeC4AstType, AstNode>>;
 type LikeC4DocumentDiagnostic = Diagnostic & DiagnosticInfo<LikeC4AstNode>;
@@ -16307,14 +17276,26 @@ interface LikeC4DocumentProps {
     c4Relations?: ParsedAstRelation[];
     c4Globals?: ParsedAstGlobals;
     c4Views?: ParsedAstView[];
-    c4fqnIndex?: MultiMap<Fqn$1, DocFqnIndexAstNodeDescription>;
+    c4Deployments?: ParsedAstDeployment[];
+    c4DeploymentRelations?: ParsedAstDeploymentRelation[];
+    c4fqnIndex?: MultiMap<Fqn, DocFqnIndexAstNodeDescription>;
 }
-interface LikeC4LangiumDocument extends Omit<LangiumDocument<LikeC4Grammar>, 'diagnostics'>, LikeC4DocumentProps {
+type LikeC4GrammarDocument = Omit<LangiumDocument<LikeC4Grammar>, 'diagnostics'>;
+interface LikeC4LangiumDocument extends LikeC4GrammarDocument, LikeC4DocumentProps {
 }
-interface FqnIndexedDocument extends Omit<LangiumDocument<LikeC4Grammar>, 'diagnostics'>, SetRequired<LikeC4DocumentProps, 'c4fqnIndex'> {
+interface FqnIndexedDocument extends SetRequired<LikeC4LangiumDocument, 'c4fqnIndex'> {
 }
-interface ParsedLikeC4LangiumDocument extends Omit<LangiumDocument<LikeC4Grammar>, 'diagnostics'>, Required<LikeC4DocumentProps> {
+interface ParsedLikeC4LangiumDocument extends LikeC4GrammarDocument, Required<LikeC4DocumentProps> {
 }
+type Guard<N extends AstNode> = (n: AstNode) => n is N;
+type Guarded<G> = G extends Guard<infer N> ? N : never;
+declare const isValidatableAstNode: (n: AstNode) => n is ArrowProperty | SpecificationRelationshipKind | DynamicViewStep | RelationPredicateWith | DynamicViewParallelSteps | DynamicView | ExcludePredicate | IncludePredicate | GlobalPredicateGroup | ViewRuleGroup | ElementView | Globals | DeploymentNode | Relation | Element | ExtendElement | SpecificationRule | BorderProperty | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleStyle | ElementPredicateWith | DynamicViewPredicateIterator | DynamicViewIncludePredicate | GlobalDynamicPredicateGroup | DeploymentView | SpecificationDeploymentNodeKind | SpecificationElementKind | DeployedInstance | GlobalStyleGroup | ColorProperty | SpecificationColor | DeploymentRefExpression | WildcardExpression | DirectedDeploymentRelationExpression | IncomingDeploymentRelationExpression | OutgoingDeploymentRelationExpression | DeploymentViewRulePredicate | InOutDeploymentRelationExpression | DirectedRelationExpression | ElementPredicateWhere | IncomingRelationExpression | OutgoingRelationExpression | RelationPredicateWhere | InOutRelationExpression | ViewRuleAutoLayout | DynamicViewGlobalPredicateRef | ViewRuleGlobalStyle | ElementDescedantsExpression | ElementKindExpression | ElementRef | ElementTagExpression | ExpandElementExpression | ElementStringProperty | IconProperty | LinkProperty | MetadataBody | LineProperty | MetadataAttribute | NavigateToProperty | NotationProperty | NotesProperty | OpacityProperty | RelationStringProperty | ShapeProperty | SpecificationElementStringProperty | SpecificationRelationshipStringProperty | SpecificationTag | ViewStringProperty | Tags | ViewRuleGlobalPredicateRef;
+type ValidatableAstNode = Guarded<typeof isValidatableAstNode>;
+declare function checksFromDiagnostics(doc: LikeC4LangiumDocument): {
+    isValid: (n: ValidatableAstNode) => boolean;
+    invalidNodes: WeakSet<object>;
+};
+type ChecksFromDiagnostics = ReturnType<typeof checksFromDiagnostics>;
 
 declare class LikeC4DocumentSymbolProvider implements DocumentSymbolProvider {
     private services;
@@ -16336,6 +17317,7 @@ declare class LikeC4DocumentSymbolProvider implements DocumentSymbolProvider {
 }
 
 declare class LikeC4HoverProvider extends AstNodeHoverProvider {
+    private parser;
     private locator;
     constructor(services: LikeC4Services);
     protected getAstNodeHoverContent(node: AstNode): MaybePromise<Hover | undefined>;
@@ -16343,22 +17325,112 @@ declare class LikeC4HoverProvider extends AstNodeHoverProvider {
 
 declare class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
     protected highlightElement(node: AstNode, acceptor: SemanticTokenAcceptor): void | undefined | 'prune';
-    private highlightAstElement;
+    private highlightNameAndKind;
     private highlightView;
 }
+
+declare class LikeC4NameProvider extends DefaultNameProvider {
+    protected services: LikeC4Services;
+    constructor(services: LikeC4Services);
+    getNameStrict(node: AstNode): string;
+    getName(node: AstNode): string | undefined;
+    getNameNode(node: AstNode): CstNode | undefined;
+}
+
+type ElementsContainer = Model | ElementBody | ExtendElementBody;
+type DeploymentsContainer = ModelDeployments | DeploymentNodeBody;
+declare class LikeC4ScopeComputation extends DefaultScopeComputation {
+    constructor(services: LikeC4Services);
+    computeExports(document: LikeC4LangiumDocument, _cancelToken?: CancellationToken): Promise<AstNodeDescription[]>;
+    private exportViews;
+    private exportGlobals;
+    private exportModel;
+    private exportLibrary;
+    private exportSpecification;
+    private exportDeployments;
+    computeLocalScopes(document: LikeC4LangiumDocument, _cancelToken?: CancellationToken): Promise<PrecomputedScopes>;
+    protected processContainer(container: ElementsContainer, scopes: PrecomputedScopes, document: LikeC4LangiumDocument): AstNodeDescription[];
+    protected processDeployments(container: DeploymentsContainer, scopes: PrecomputedScopes, document: LikeC4LangiumDocument): AstNodeDescription[];
+}
+
+declare class LikeC4ScopeProvider extends DefaultScopeProvider {
+    private deploymentsIndex;
+    private fqnIndex;
+    constructor(services: LikeC4Services);
+    private directChildrenOf;
+    private uniqueDescedants;
+    private scopeElementRef;
+    private scopeExtendElement;
+    private scopeElementView;
+    getScope(context: ReferenceInfo): Scope;
+    protected getScopeForDeploymentRef(container: DeploymentRef, context: ReferenceInfo): Scope;
+    protected computeScope(context: ReferenceInfo, referenceType?: string): Scope;
+}
+
+declare class DeploymentsIndex {
+    private services;
+    protected Names: LikeC4NameProvider;
+    protected langiumDocuments: LangiumDocuments;
+    constructor(services: LikeC4Services);
+    private documents;
+    get(document: LikeC4LangiumDocument): DocumentDeploymentsIndex;
+    /**
+     * Nested elements (nodes/artifacts) of the node
+     * @param nodeName Name of the deployment node
+     * @returns Stream of artifacts
+     */
+    nested(node: DeploymentNode): Stream<DeploymentAstNodeDescription>;
+    byFqn(fqnName: string): Stream<DeploymentAstNodeDescription>;
+    getFqnName(node: DeploymentElement): Fqn;
+    createDocumentIndex(document: LikeC4LangiumDocument): DocumentDeploymentsIndex;
+}
+declare class DocumentDeploymentsIndex {
+    private _rootNodes;
+    /**
+     * Nested of a deployment node
+     */
+    private _nested;
+    /**
+     * All elements by FQN
+     */
+    private _byfqn;
+    static readonly EMPTY: DocumentDeploymentsIndex;
+    constructor(_rootNodes: Array<DeploymentAstNodeDescription>, 
+    /**
+     * Nested of a deployment node
+     */
+    _nested: MultiMap<string, DeploymentAstNodeDescription>, 
+    /**
+     * All elements by FQN
+     */
+    _byfqn: MultiMap<string, DeploymentAstNodeDescription>);
+    rootNodes(): readonly DeploymentAstNodeDescription[];
+    byFqn(fqnName: string): readonly DeploymentAstNodeDescription[];
+    /**
+     * Returns artifacts of a deployment node
+     * @param nodeName Name of the deployment node
+     * @returns Stream of artifacts
+     */
+    nested(nodeName: string): readonly DeploymentAstNodeDescription[];
+    /**
+     * Returns all deployment elements in the document,
+     * with unique combination "type and name"
+     */
+    unique(): readonly DeploymentAstNodeDescription[];
+}
 declare class FqnIndex {
     private services;
     protected langiumDocuments: LangiumDocuments;
     constructor(services: LikeC4Services);
     get documents(): Stream<FqnIndexedDocument>;
     private entries;
-    getFqn(el: Element): Fqn$1 | null;
-    byFqn(fqn: Fqn$1): Stream<AstNodeDescription>;
-    directChildrenOf(parent: Fqn$1): Stream<AstNodeDescription>;
+    getFqn(el: Element): Fqn | null;
+    byFqn(fqn: Fqn): Stream<AstNodeDescription>;
+    directChildrenOf(parent: Fqn): Stream<AstNodeDescription>;
     /**
      * Returns descedant elements with unique names in the scope
      */
-    uniqueDescedants(parent: Fqn$1): Stream<AstNodeDescription>;
+    uniqueDescedants(parent: Fqn): Stream<AstNodeDescription>;
 }
 
 type ModelParsedListener$1 = (docs: URI[]) => void;
@@ -16382,7 +17454,7 @@ declare class LikeC4ModelBuilder {
      */
     unsafeSyncBuildComputedModel(model: ParsedLikeC4Model): ComputedLikeC4Model;
     buildComputedModel(cancelToken?: CancellationToken): Promise<ComputedLikeC4Model | null>;
-    computeView(viewId: ViewID$1, cancelToken?: CancellationToken): Promise<ComputedView | null>;
+    computeView(viewId: ViewId, cancelToken?: CancellationToken): Promise<ComputedView | null>;
     onModelParsed(callback: ModelParsedListener$1): Disposable;
     private documents;
     private notifyListeners;
@@ -16391,26 +17463,30 @@ declare class LikeC4ModelBuilder {
 declare class LikeC4ModelLocator {
     private services;
     private fqnIndex;
+    private deploymentsIndex;
     private langiumDocuments;
     constructor(services: LikeC4Services);
     private documents;
-    getParsedElement(astNode: Element): ParsedAstElement | null;
-    locateElement(fqn: Fqn$1, _prop?: string): Location | null;
-    locateRelation(relationId: RelationID$1): Location | null;
-    locateViewAst(viewId: ViewID$1): {
+    getParsedElement(astNodeOrFqn: Element | Fqn): ParsedAstElement | null;
+    locateElement(fqn: Fqn, _prop?: string): Location | null;
+    locateDeploymentElement(fqn: Fqn, _prop?: string): Location | null;
+    locateRelation(relationId: RelationId): Location | null;
+    locateViewAst(viewId: ViewId): {
         doc: ParsedLikeC4LangiumDocument;
         view: ParsedAstView;
         viewAst: LikeC4View;
     };
-    locateView(viewId: ViewID$1): Location | null;
+    locateView(viewId: ViewId): Location | null;
 }
+type IsValidFn = ChecksFromDiagnostics['isValid'];
 declare class LikeC4ModelParser {
     private services;
     private fqnIndex;
     constructor(services: LikeC4Services);
-    parse(doc: LangiumDocument | LangiumDocument[]): ParsedLikeC4LangiumDocument[];
+    parse(doc: LangiumDocument): ParsedLikeC4LangiumDocument;
     protected parseLikeC4Document(_doc: FqnIndexedDocument): ParsedLikeC4LangiumDocument;
     private parseSpecification;
+    private parseSpecificationDeploymentNodeKind;
     private parseModel;
     private parseElement;
     private parseRelation;
@@ -16438,14 +17514,26 @@ declare class LikeC4ModelParser {
     private parseViewRuleGroup;
     private parseRuleStyle;
     private parseViewRuleGlobalStyle;
-    private parseViewManualLaout;
+    private parseViewManualLayout;
     private parseDynamicParallelSteps;
     private parseDynamicStep;
     private parseElementView;
     private parseDynamicElementView;
     private parseDynamicViewRule;
     private parseDynamicViewIncludePredicate;
-    protected resolveFqn(node: Element | ExtendElement): Fqn$1;
+    private parseDeployment;
+    parseDeploymentNode(astNode: DeploymentNode, isValid: IsValidFn): ParsedAstDeployment.Node;
+    parseDeployedInstance(astNode: DeployedInstance, isValid: IsValidFn): ParsedAstDeployment.Instance;
+    parseDeploymentRelation(astNode: DeploymentRelation, isValid: IsValidFn): ParsedAstDeploymentRelation;
+    private parseDeploymentView;
+    private parseDeploymentViewRule;
+    private parseDeploymentViewRulePredicate;
+    private parseDeploymentElementExpression;
+    private parseDeploymentRelationExpression;
+    private parseDeploymentExpressionIterator;
+    private parseDeploymentDef;
+    protected parseDeploymentViewRuleStyle(astRule: DeploymentViewRuleStyle, isValid: IsValidFn): DeploymentViewRuleStyle$1;
+    protected resolveFqn(node: FqnReferenceable): Fqn;
     private getAstNodePath;
     private getMetadata;
     private convertTags;
@@ -16464,34 +17552,6 @@ declare class LikeC4ModelChanges {
     };
 }
 
-type ElementsContainer = Model | ElementBody | ExtendElementBody;
-declare class LikeC4ScopeComputation extends DefaultScopeComputation {
-    computeExports(document: LikeC4LangiumDocument, _cancelToken?: CancellationToken): Promise<AstNodeDescription[]>;
-    private exportViews;
-    private exportGlobals;
-    private exportModel;
-    private exportLibrary;
-    private exportSpecification;
-    computeLocalScopes(document: LikeC4LangiumDocument, _cancelToken?: CancellationToken): Promise<PrecomputedScopes>;
-    protected processContainer(container: ElementsContainer, scopes: PrecomputedScopes, document: LikeC4LangiumDocument): MultiMap<string, AstNodeDescription>;
-}
-
-declare class LikeC4ScopeProvider extends DefaultScopeProvider {
-    private fqnIndex;
-    constructor(services: LikeC4Services);
-    private directChildrenOf;
-    private uniqueDescedants;
-    private scopeElementRef;
-    private scopeExtendElement;
-    private scopeElementView;
-    getScope(context: ReferenceInfo): Scope;
-    protected computeScope(context: ReferenceInfo): Scope;
-    /**
-     * Create a global scope filtered for the given reference type.
-     */
-    protected getGlobalScope(referenceType: string): Scope;
-}
-
 declare class Rpc implements Disposable {
     private services;
     private disposables;
@@ -16545,8 +17605,10 @@ type LikeC4SharedServices = LangiumSharedServices & LikeC4AddedSharedServices;
  */
 interface LikeC4AddedServices {
     WorkspaceCache: WorkspaceCache<string, any>;
+    DocumentCache: DocumentCache<string, any>;
     Rpc: Rpc;
     likec4: {
+        DeploymentsIndex: DeploymentsIndex;
         FqnIndex: FqnIndex;
         ModelParser: LikeC4ModelParser;
         ModelBuilder: LikeC4ModelBuilder;
@@ -16563,6 +17625,7 @@ interface LikeC4AddedServices {
         DocumentLinkProvider: LikeC4DocumentLinkProvider;
     };
     references: {
+        NameProvider: LikeC4NameProvider;
         ScopeComputation: LikeC4ScopeComputation;
         ScopeProvider: LikeC4ScopeProvider;
     };
@@ -17238,7 +18301,7 @@ declare global {
 
 type Logger = {
     info(msg: string): void;
-    warn(msg: string): void;
+    warn(msg: unknown): void;
     error(err: unknown): void;
 };
 
@@ -17267,7 +18330,7 @@ type GraphvizOut = {
     diagram: DiagramView;
 };
 type GraphvizSvgOut = {
-    id: ViewID$1;
+    id: ViewId;
     dot: string;
     svg: string;
 };
@@ -17329,9 +18392,9 @@ declare class LikeC4 {
     private modelComputedRef;
     private modelLayoutedRef;
     private logger;
-    private langiumDocuments;
     private constructor();
     get viewsService(): Views;
+    private get LangiumDocuments();
     /**
      * Diagram is a computed view, layouted using Graphviz
      * Used in React components
@@ -17373,4 +18436,4 @@ declare class LikeC4 {
     dispose(): void;
 }
 
-export { type AutoLayoutDirection, type BBox, BorderStyles, Builder, type BuilderSpecification, type Color$1 as Color, type ComputedDynamicView, type ComputedEdge, type ComputedElementView, type ComputedLikeC4Model, ComputedNode, type ComputedView, type DiagramEdge, DiagramNode, type DiagramView, type DynamicView$1 as DynamicView, type EdgeId$1 as EdgeId, type Element$1 as Element, ElementColors, ElementKind$1 as ElementKind, ElementShapes, type ElementView$1 as ElementView, type Fqn$1 as Fqn, type HexColorLiteral, type LayoutedLikeC4Model, LikeC4, Builder as LikeC4Builder, LikeC4DiagramModel, LikeC4Model, type LikeC4View$1 as LikeC4View, LikeC4ViewModel, type NodeId, type ParsedLikeC4Model, type Point, type Relation$1 as Relation, type RelationExpr, type RelationID$1 as RelationID, RelationshipColors, StepEdgeId, type Tag$1 as Tag, type ThemeColor$1 as ThemeColor, type ViewID$1 as ViewID, type XYPoint, ancestorsFqn, commonAncestor, compareByFqnHierarchically, compareFqnHierarchically, compareRelations, defaultTheme, extractStep, hasAtLeast, invariant, isAncestor, isComputedDynamicView, isDescendantOf, isSameHierarchy, isStepEdgeId, nameFromFqn, nonNullable, nonexhaustive, parentFqn };
+export { type AutoLayoutDirection, type BBox, BorderStyles, Builder, type BuilderSpecification, type Color$1 as Color, type ComputedDeploymentView, type ComputedDynamicView, type ComputedEdge, type ComputedElementView, type ComputedLikeC4Model, ComputedNode, ComputedView, type DeployedInstance$1 as DeployedInstance, DeploymentElement$1 as DeploymentElement, type DeploymentNode$1 as DeploymentNode, type DeploymentNodeKind$1 as DeploymentNodeKind, type DeploymentRelation$1 as DeploymentRelation, type DeploymentView$1 as DeploymentView, type DiagramEdge, DiagramNode, type DiagramView, type DynamicView$1 as DynamicView, type EdgeId, type Element$1 as Element, ElementColors, ElementKind$1 as ElementKind, ElementShapes, type ElementView$1 as ElementView, type Fqn, type HexColorLiteral, type LayoutedLikeC4Model, LikeC4, Builder as LikeC4Builder, LikeC4Model, type LikeC4View$1 as LikeC4View, type NodeId, type ParsedLikeC4Model, type Point, type Relation$1 as Relation, type RelationExpr, type RelationId, RelationshipColors, type StepEdgeId, type Tag$1 as Tag, type ThemeColor$1 as ThemeColor, type ViewId, type XYPoint, ancestorsFqn, commonAncestor, compareByFqnHierarchically, compareFqnHierarchically, compareRelations, defaultTheme, extractStep, hasAtLeast, invariant, isAncestor, isDeploymentView, isDescendantOf, isDynamicView, isElementView, isSameHierarchy, isStepEdgeId, nameFromFqn, nonNullable, nonexhaustive, parentFqn };