@likec4/core 1.17.1 → 1.18.0

package/dist/shared/{core.CoLQkcYL.d.mts → core.DMYY7C8s.d.mts}

@@ -1,4 +1,4 @@
-import { Tagged, LiteralUnion, TupleToUnion, NonEmptyTuple } from 'type-fest';
+import { Tagged, LiteralUnion, TupleToUnion, NonEmptyTuple, Simplify, MergeExclusive, UnionToIntersection } from 'type-fest';
 
 type NonEmptyArray<T> = [T, ...T[]];
 type NonEmptyReadonlyArray<T> = readonly [T, ...T[]];
@@ -9,6 +9,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 = typeof ThemeColors[number];
@@ -57,8 +58,13 @@ type ElementShape = TupleToUnion<typeof ElementShapes>;
 declare const DefaultThemeColor = "primary";
 declare const DefaultElementShape = "rectangle";
 interface ElementStyle {
-    border?: BorderStyle;
-    opacity?: number;
+    readonly border?: BorderStyle;
+    /**
+     * In percentage 0-100, 0 is fully transparent
+     *
+     * @default 100
+     */
+    readonly opacity?: number;
 }
 type Tag<Tags extends string = string> = Tagged<Tags, 'Tag'>;
 interface TagSpec {
@@ -107,30 +113,30 @@ 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>;
 };
 declare const isTagEqual: <Tag>(operator: WhereOperator<Tag, any>) => operator is TagEqual<Tag>;
-type KindEqual<Kind> = Omit<AllNever, 'kind'> & {
+type KindEqual<Kind> = Omit<AllNever$1, 'kind'> & {
     kind: EqualOperator<Kind>;
 };
 declare const isKindEqual: <Kind>(operator: WhereOperator<any, Kind>) => operator is KindEqual<Kind>;
-type NotOperator<Tag, Kind> = Omit<AllNever, 'not'> & {
+type NotOperator<Tag, Kind> = Omit<AllNever$1, 'not'> & {
     not: WhereOperator<Tag, Kind>;
 };
 declare const isNotOperator: <Tag, Kind>(operator: WhereOperator<Tag, Kind>) => operator is NotOperator<Tag, Kind>;
-type AndOperator<Tag, Kind> = Omit<AllNever, 'and'> & {
+type AndOperator<Tag, Kind> = Omit<AllNever$1, 'and'> & {
     and: NonEmptyArray<WhereOperator<Tag, Kind>>;
 };
 declare const isAndOperator: <Tag, Kind>(operator: WhereOperator<Tag, Kind>) => operator is AndOperator<Tag, Kind>;
-type OrOperator<Tag, Kind> = Omit<AllNever, 'or'> & {
+type OrOperator<Tag, Kind> = Omit<AllNever$1, 'or'> & {
     or: NonEmptyArray<WhereOperator<Tag, Kind>>;
 };
 declare const isOrOperator: <Tag, Kind>(operator: WhereOperator<Tag, Kind>) => operator is OrOperator<Tag, Kind>;
@@ -142,6 +148,161 @@ type Filterable<FTag extends string = string, FKind extends string = string> = {
 type OperatorPredicate<V extends Filterable> = (value: V) => boolean;
 declare function whereOperatorAsPredicate<FTag extends string = string, FKind extends string = string>(operator: WhereOperator<FTag, FKind>): OperatorPredicate<Filterable<FTag, FKind>>;
 
+interface BaseExpr {
+    where?: never;
+    element?: never;
+    custom?: never;
+    expanded?: never;
+    elementKind?: never;
+    elementTag?: never;
+    isEqual?: never;
+    isChildren?: never;
+    isDescendants?: never;
+    wildcard?: never;
+    source?: never;
+    target?: never;
+    inout?: never;
+    incoming?: never;
+    outgoing?: never;
+    customRelation?: never;
+}
+interface ElementRefExpr extends Omit<BaseExpr, 'element' | 'isChildren' | 'isDescendants'> {
+    element: Fqn;
+    isChildren?: boolean;
+    isDescendants?: boolean;
+}
+declare function isElementRef(expr: Expression): expr is ElementRefExpr;
+interface ExpandedElementExpr extends Omit<BaseExpr, 'expanded'> {
+    expanded: Fqn;
+}
+declare function isExpandedElementExpr(expr: Expression): expr is ExpandedElementExpr;
+interface CustomElementExpr extends Omit<BaseExpr, 'custom'> {
+    custom: {
+        expr: ElementExpression | ElementWhereExpr;
+        title?: string;
+        description?: string;
+        technology?: string;
+        notation?: string;
+        shape?: ElementShape;
+        color?: Color;
+        icon?: IconUrl;
+        border?: BorderStyle;
+        opacity?: number;
+        navigateTo?: ViewId;
+    };
+}
+declare function isCustomElement(expr: Expression): expr is CustomElementExpr;
+interface WildcardExpr extends Omit<BaseExpr, 'wildcard'> {
+    wildcard: true;
+}
+declare function isWildcard(expr: Expression): expr is WildcardExpr;
+interface ElementKindExpr extends Omit<BaseExpr, 'elementKind' | 'isEqual'> {
+    elementKind: ElementKind;
+    isEqual: boolean;
+}
+declare function isElementKindExpr(expr: Expression): expr is ElementKindExpr;
+interface ElementTagExpr extends Omit<BaseExpr, 'elementTag' | 'isEqual'> {
+    elementTag: Tag;
+    isEqual: boolean;
+}
+declare function isElementTagExpr(expr: Expression): expr is ElementTagExpr;
+type ElementExpression = ElementRefExpr | WildcardExpr | ElementKindExpr | ElementTagExpr | ExpandedElementExpr;
+declare function isElement(expr: Expression): expr is ElementExpression;
+interface ElementWhereExpr extends Omit<BaseExpr, 'where'> {
+    where: {
+        expr: ElementExpression;
+        condition: WhereOperator<string, string>;
+    };
+}
+declare function isElementWhere(expr: Expression): expr is ElementWhereExpr;
+type ElementPredicateExpression = ElementExpression | ElementWhereExpr | CustomElementExpr;
+declare function isElementPredicateExpr(expr: Expression): expr is ElementPredicateExpression;
+interface RelationExpr extends Omit<BaseExpr, 'source' | 'target'> {
+    source: ElementExpression;
+    target: ElementExpression;
+    isBidirectional?: boolean;
+}
+declare function isRelation(expr: Expression): expr is RelationExpr;
+interface InOutExpr extends Omit<BaseExpr, 'inout'> {
+    inout: ElementExpression;
+}
+declare function isInOut(expr: Expression): expr is InOutExpr;
+interface IncomingExpr extends Omit<BaseExpr, 'incoming'> {
+    incoming: ElementExpression;
+}
+declare function isIncoming(expr: Expression): expr is IncomingExpr;
+interface OutgoingExpr extends Omit<BaseExpr, 'outgoing'> {
+    outgoing: ElementExpression;
+}
+declare function isOutgoing(expr: Expression): expr is OutgoingExpr;
+type RelationExpression = RelationExpr | InOutExpr | IncomingExpr | OutgoingExpr;
+declare function isRelationExpression(expr: Expression): expr is RelationExpression;
+interface RelationWhereExpr extends Omit<BaseExpr, 'where'> {
+    where: {
+        expr: RelationExpression;
+        condition: WhereOperator<string, string>;
+    };
+}
+declare function isRelationWhere(expr: Expression): expr is RelationWhereExpr;
+interface CustomRelationExpr extends Omit<BaseExpr, 'customRelation'> {
+    customRelation: {
+        relation: RelationExpression | RelationWhereExpr;
+        title?: string;
+        description?: string;
+        technology?: string;
+        notation?: string;
+        navigateTo?: ViewId;
+        notes?: string;
+        color?: Color;
+        line?: RelationshipLineType;
+        head?: RelationshipArrowType;
+        tail?: RelationshipArrowType;
+    };
+}
+declare function isCustomRelationExpr(expr: Expression): expr is CustomRelationExpr;
+type RelationPredicateExpression = RelationExpression | RelationWhereExpr | CustomRelationExpr;
+declare function isRelationPredicateExpr(expr: Expression): expr is RelationPredicateExpression;
+type Expression = ElementPredicateExpression | RelationPredicateExpression;
+
+type expression_CustomElementExpr = CustomElementExpr;
+type expression_CustomRelationExpr = CustomRelationExpr;
+type expression_ElementExpression = ElementExpression;
+type expression_ElementKindExpr = ElementKindExpr;
+type expression_ElementPredicateExpression = ElementPredicateExpression;
+type expression_ElementRefExpr = ElementRefExpr;
+type expression_ElementTagExpr = ElementTagExpr;
+type expression_ElementWhereExpr = ElementWhereExpr;
+type expression_ExpandedElementExpr = ExpandedElementExpr;
+type expression_Expression = Expression;
+type expression_InOutExpr = InOutExpr;
+type expression_IncomingExpr = IncomingExpr;
+type expression_OutgoingExpr = OutgoingExpr;
+type expression_RelationExpr = RelationExpr;
+type expression_RelationExpression = RelationExpression;
+type expression_RelationPredicateExpression = RelationPredicateExpression;
+type expression_RelationWhereExpr = RelationWhereExpr;
+type expression_WildcardExpr = WildcardExpr;
+declare const expression_isCustomElement: typeof isCustomElement;
+declare const expression_isCustomRelationExpr: typeof isCustomRelationExpr;
+declare const expression_isElement: typeof isElement;
+declare const expression_isElementKindExpr: typeof isElementKindExpr;
+declare const expression_isElementPredicateExpr: typeof isElementPredicateExpr;
+declare const expression_isElementRef: typeof isElementRef;
+declare const expression_isElementTagExpr: typeof isElementTagExpr;
+declare const expression_isElementWhere: typeof isElementWhere;
+declare const expression_isExpandedElementExpr: typeof isExpandedElementExpr;
+declare const expression_isInOut: typeof isInOut;
+declare const expression_isIncoming: typeof isIncoming;
+declare const expression_isOutgoing: typeof isOutgoing;
+declare const expression_isRelation: typeof isRelation;
+declare const expression_isRelationExpression: typeof isRelationExpression;
+declare const expression_isRelationPredicateExpr: typeof isRelationPredicateExpr;
+declare const expression_isRelationWhere: typeof isRelationWhere;
+declare const expression_isWildcard: typeof isWildcard;
+declare namespace expression {
+  export { type expression_CustomElementExpr as CustomElementExpr, type expression_CustomRelationExpr as CustomRelationExpr, type expression_ElementExpression as ElementExpression, type expression_ElementKindExpr as ElementKindExpr, type expression_ElementPredicateExpression as ElementPredicateExpression, type expression_ElementRefExpr as ElementRefExpr, type expression_ElementTagExpr as ElementTagExpr, type expression_ElementWhereExpr as ElementWhereExpr, type expression_ExpandedElementExpr as ExpandedElementExpr, type expression_Expression as Expression, type expression_InOutExpr as InOutExpr, type expression_IncomingExpr as IncomingExpr, type expression_OutgoingExpr as OutgoingExpr, type expression_RelationExpr as RelationExpr, type expression_RelationExpression as RelationExpression, type expression_RelationPredicateExpression as RelationPredicateExpression, type expression_RelationWhereExpr as RelationWhereExpr, type expression_WildcardExpr as WildcardExpr, expression_isCustomElement as isCustomElement, expression_isCustomRelationExpr as isCustomRelationExpr, expression_isElement as isElement, expression_isElementKindExpr as isElementKindExpr, expression_isElementPredicateExpr as isElementPredicateExpr, expression_isElementRef as isElementRef, expression_isElementTagExpr as isElementTagExpr, expression_isElementWhere as isElementWhere, expression_isExpandedElementExpr as isExpandedElementExpr, expression_isInOut as isInOut, expression_isIncoming as isIncoming, expression_isOutgoing as isOutgoing, expression_isRelation as isRelation, expression_isRelationExpression as isRelationExpression, expression_isRelationPredicateExpr as isRelationPredicateExpr, expression_isRelationWhere as isRelationWhere, expression_isWildcard as isWildcard };
+}
+
 type GlobalPredicateId = Tagged<string, 'GlobalPredicateId'>;
 type GlobalPredicates = NonEmptyArray<ViewRulePredicate>;
 type GlobalDynamicPredicates = NonEmptyArray<DynamicViewIncludeRule>;
@@ -154,13 +315,13 @@ interface ModelGlobals {
 }
 
 type ElementNotation = {
-    kinds: ElementKind[];
+    kinds: string[];
     shape: ElementShape;
     color: Color;
     title: string;
 };
 
-type ViewID<Id extends string = string> = Tagged<Id, 'ViewID'>;
+type ViewId<Id extends string = string> = Tagged<Id, 'ViewID'>;
 type ViewRulePredicate = {
     include: Expression[];
     exclude?: never;
@@ -168,6 +329,8 @@ type ViewRulePredicate = {
     include?: never;
     exclude: Expression[];
 };
+declare function isViewRulePredicate(rule: DeploymentViewRule): rule is DeploymentViewRulePredicate;
+declare function isViewRulePredicate(rule: DynamicViewRule): rule is DynamicViewIncludeRule;
 declare function isViewRulePredicate(rule: ViewRule): rule is ViewRulePredicate;
 interface ViewRuleGlobalPredicateRef {
     predicateId: GlobalPredicateId;
@@ -182,6 +345,7 @@ interface ViewRuleStyle {
         icon?: IconUrl;
     };
 }
+declare function isViewRuleStyle(rule: DeploymentViewRule): rule is DeploymentViewRuleStyle;
 declare function isViewRuleStyle(rule: ViewRule): rule is ViewRuleStyle;
 interface ViewRuleGlobalStyle {
     styleId: GlobalStyleID;
@@ -195,7 +359,7 @@ interface ViewRuleAutoLayout {
     nodeSep?: number;
     rankSep?: number;
 }
-declare function isViewRuleAutoLayout(rule: ViewRule): rule is ViewRuleAutoLayout;
+declare function isViewRuleAutoLayout(rule: DeploymentViewRule | DynamicViewRule | ViewRule): rule is ViewRuleAutoLayout;
 interface ViewRuleGroup {
     groupRules: Array<ViewRulePredicate | ViewRuleGroup>;
     title: string | null;
@@ -205,9 +369,9 @@ interface ViewRuleGroup {
 }
 declare function isViewRuleGroup(rule: ViewRule): rule is ViewRuleGroup;
 type ViewRule = ViewRulePredicate | ViewRuleGlobalPredicateRef | ViewRuleGroup | ViewRuleStyle | ViewRuleGlobalStyle | ViewRuleAutoLayout;
-interface BasicView<ViewType extends 'element' | 'dynamic', ViewIDs extends string, Tags extends string> {
+interface BasicView<ViewType extends 'element' | 'dynamic' | 'deployment', ViewIDs extends string, Tags extends string> {
     readonly __?: ViewType;
-    readonly id: ViewID<ViewIDs>;
+    readonly id: ViewId<ViewIDs>;
     readonly title: string | null;
     readonly description: string | null;
     readonly tags: NonEmptyArray<Tag<Tags>> | null;
@@ -240,7 +404,7 @@ interface ScopedElementView<ViewIDs extends string, Tags extends string> extends
     readonly viewOf: Fqn;
 }
 interface ExtendsElementView<ViewIDs extends string, Tags extends string> extends BasicElementView<ViewIDs, Tags> {
-    readonly extends: ViewID<ViewIDs>;
+    readonly extends: ViewId<ViewIDs>;
 }
 type ElementView<ViewIDs extends string = string, Tags extends string = string> = ScopedElementView<ViewIDs, Tags> | ExtendsElementView<ViewIDs, Tags> | BasicElementView<ViewIDs, Tags>;
 interface DynamicViewStep {
@@ -256,7 +420,7 @@ interface DynamicViewStep {
     readonly head?: RelationshipArrowType;
     readonly tail?: RelationshipArrowType;
     readonly isBackward?: boolean;
-    readonly navigateTo?: ViewID;
+    readonly navigateTo?: ViewId;
     __parallel?: never;
 }
 interface DynamicViewParallelSteps {
@@ -266,7 +430,6 @@ type DynamicViewStepOrParallel = DynamicViewStep | DynamicViewParallelSteps;
 type DynamicViewIncludeRule = {
     include: ElementPredicateExpression[];
 };
-declare function isDynamicViewIncludeRule(rule: DynamicViewRule): rule is DynamicViewIncludeRule;
 type DynamicViewRule = DynamicViewIncludeRule | ViewRuleGlobalPredicateRef | ViewRuleStyle | ViewRuleGlobalStyle | ViewRuleAutoLayout;
 interface DynamicView<ViewIDs extends string = string, Tags extends string = string> extends BasicView<'dynamic', ViewIDs, Tags> {
     readonly __: 'dynamic';
@@ -277,7 +440,32 @@ declare function isDynamicViewParallelSteps(step: DynamicViewStepOrParallel): st
 type CustomColorDefinitions = {
     [key: string]: ThemeColorValues;
 };
-type LikeC4View<ViewIDs extends string = string, Tags extends string = string> = ElementView<ViewIDs, Tags> | DynamicView<ViewIDs, Tags>;
+type DeploymentViewRulePredicate = {
+    include: DeploymentExpression[];
+    exclude?: never;
+} | {
+    include?: never;
+    exclude: DeploymentExpression[];
+};
+type DeploymentViewRuleStyle = {
+    targets: DeploymentExpression[];
+    notation?: string;
+    style: ElementStyle & {
+        color?: Color;
+        shape?: ElementShape;
+        icon?: IconUrl;
+    };
+};
+type DeploymentViewRule = DeploymentViewRulePredicate | ViewRuleAutoLayout | DeploymentViewRuleStyle;
+interface DeploymentView<ViewIDs extends string = string, Tags extends string = string> extends BasicView<'deployment', ViewIDs, Tags> {
+    readonly __: 'deployment';
+    readonly rules: DeploymentViewRule[];
+}
+type LikeC4View<ViewIDs extends string = string, Tags extends string = string> = ElementView<ViewIDs, Tags> | DynamicView<ViewIDs, Tags> | DeploymentView<ViewIDs, Tags>;
+declare function isDeploymentView(view: LikeC4View): view is DeploymentView;
+declare function isDeploymentView<V extends {
+    __?: string;
+}>(view: V): boolean;
 declare function isDynamicView(view: LikeC4View): view is DynamicView;
 declare function isElementView(view: LikeC4View): view is ElementView;
 declare function isExtendsElementView(view: LikeC4View): view is ExtendsElementView<string, string>;
@@ -286,14 +474,24 @@ type NodeId<IDs extends string = string> = Tagged<IDs, 'Fqn'>;
 type EdgeId = Tagged<string, 'EdgeId'>;
 type StepEdgeIdLiteral = `step-${number}` | `step-${number}.${number}`;
 type StepEdgeId = Tagged<StepEdgeIdLiteral, 'EdgeId'>;
-declare function StepEdgeId(step: number, parallelStep?: number): StepEdgeId;
+declare function stepEdgeId(step: number, parallelStep?: number): StepEdgeId;
 declare function isStepEdgeId(id: string): id is StepEdgeId;
 declare function extractStep(id: EdgeId): number;
 declare function getParallelStepsPrefix(id: string): string | null;
 interface ComputedNode {
     id: NodeId;
-    kind: ElementKind;
+    kind: string;
     parent: NodeId | null;
+    /**
+     * Reference to model element
+     * If 1 - node id is a reference
+     */
+    modelRef?: 1 | Fqn;
+    /**
+     * Reference to deployment element
+     * If 1 - node id is a reference
+     */
+    deploymentRef?: 1 | Fqn;
     title: string;
     description: string | null;
     technology: string | null;
@@ -304,16 +502,13 @@ interface ComputedNode {
     inEdges: EdgeId[];
     outEdges: EdgeId[];
     shape: ElementShape;
-    /**
-     * @deprecated Use `style` instead
-     */
     color: Color;
     /**
      * @deprecated Use `style` instead
      */
     icon?: IconUrl;
     style: ElementStyle;
-    navigateTo?: ViewID;
+    navigateTo?: ViewId;
     level: number;
     depth?: number;
     /**
@@ -322,6 +517,8 @@ interface ComputedNode {
     isCustomized?: boolean;
 }
 declare namespace ComputedNode {
+    function modelRef(node: ComputedNode): Fqn | null;
+    function deploymentRef(node: ComputedNode): Fqn | null;
     /**
      * Nodes group is a special kind of node, exisiting only in view
      */
@@ -335,7 +532,7 @@ interface ComputedEdge {
     label: string | null;
     description?: string;
     technology?: string;
-    relations: RelationID[];
+    relations: RelationId[];
     kind?: RelationshipKind;
     notation?: string;
     notes?: string;
@@ -344,7 +541,7 @@ interface ComputedEdge {
     head?: RelationshipArrowType;
     tail?: RelationshipArrowType;
     tags?: NonEmptyArray<Tag>;
-    navigateTo?: ViewID;
+    navigateTo?: ViewId;
     /**
      * If this edge is derived from custom relationship predicate
      */
@@ -353,7 +550,7 @@ interface ComputedEdge {
      * For layouting purposes
      * @default 'forward'
      */
-    dir?: 'forward' | 'back';
+    dir?: 'forward' | 'back' | 'both';
 }
 interface ViewWithHash {
     /**
@@ -373,7 +570,7 @@ interface ViewAutoLayout {
     nodeSep?: number;
 }
 interface ComputedElementView<ViewIDs extends string = string, Tags extends string = string> extends Omit<ElementView<ViewIDs, Tags>, 'rules' | 'docUri'>, ViewWithHash, ViewWithNotation {
-    readonly extends?: ViewID<ViewIDs>;
+    readonly extends?: ViewId<ViewIDs>;
     readonly autoLayout: ViewAutoLayout;
     readonly nodes: ComputedNode[];
     readonly edges: ComputedEdge[];
@@ -388,9 +585,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>;
-declare function isComputedElementView(view: ComputedView): view is ComputedElementView;
+interface ComputedDeploymentView<ViewIDs extends string = string, Tags extends string = string> extends Omit<DeploymentView<ViewIDs, Tags>, 'rules' | 'docUri'>, ViewWithHash, ViewWithNotation {
+    readonly autoLayout: ViewAutoLayout;
+    readonly nodes: ComputedNode[];
+    readonly edges: ComputedEdge[];
+    rules?: never;
+    docUri?: never;
+}
+type ComputedView<ViewIDs extends string = string, Tags extends string = string> = ComputedElementView<ViewIDs, Tags> | ComputedDynamicView<ViewIDs, Tags> | ComputedDeploymentView<ViewIDs, Tags>;
+declare namespace ComputedView {
+    function isDeployment(view: ComputedView): view is ComputedDeploymentView;
+    function isDynamic(view: ComputedView): view is ComputedDynamicView;
+    function isElement(view: ComputedView): view is ComputedElementView;
+}
 type BBox = {
     x: number;
     y: number;
@@ -405,6 +612,8 @@ interface DiagramNode extends ComputedNode {
     labelBBox: BBox;
 }
 declare namespace DiagramNode {
+    function modelRef(node: DiagramNode): Fqn | null;
+    function deploymentRef(node: DiagramNode): Fqn | null;
     /**
      * Nodes group is a special kind of node, exisiting only in view
      */
@@ -449,7 +658,7 @@ type ViewManualLayout = {
     }>;
 };
 
-type RelationID = Tagged<string, 'RelationID'>;
+type RelationId = Tagged<string, 'RelationID'>;
 type RelationshipKind<Kinds extends string = string> = Tagged<Kinds, 'RelationshipKind'>;
 type RelationshipLineType = 'dashed' | 'solid' | 'dotted';
 type RelationshipArrowType = 'none' | 'normal' | 'onormal' | 'dot' | 'odot' | 'diamond' | 'odiamond' | 'crow' | 'open' | 'vee';
@@ -457,7 +666,7 @@ declare const DefaultLineStyle = "dashed";
 declare const DefaultArrowType = "normal";
 declare const DefaultRelationshipColor = "gray";
 interface Relation {
-    readonly id: RelationID;
+    readonly id: RelationId;
     readonly source: Fqn;
     readonly target: Fqn;
     readonly title: string;
@@ -470,7 +679,7 @@ interface Relation {
     readonly head?: RelationshipArrowType;
     readonly tail?: RelationshipArrowType;
     readonly links?: NonEmptyArray<Link>;
-    readonly navigateTo?: ViewID;
+    readonly navigateTo?: ViewId;
     readonly metadata?: {
         [key: string]: string;
     };
@@ -484,251 +693,191 @@ interface RelationshipKindSpecification {
     readonly tail?: RelationshipArrowType;
 }
 
-interface BaseExpr {
-    where?: never;
-    element?: never;
-    custom?: never;
-    expanded?: never;
-    elementKind?: never;
-    elementTag?: never;
-    isEqual?: never;
-    isDescedants?: never;
-    wildcard?: never;
-    source?: never;
-    target?: never;
-    inout?: never;
-    incoming?: never;
-    outgoing?: never;
-    customRelation?: never;
-}
-interface ElementRefExpr extends Omit<BaseExpr, 'element' | 'isDescedants'> {
-    element: Fqn;
-    isDescedants?: boolean;
+type DeploymentNodeKind<Kinds extends string = string> = Tagged<Kinds, 'DeploymentNodeKind'>;
+type PhysicalElementStyle = ElementStyle & {
+    readonly icon?: IconUrl;
+    readonly shape?: ElementShape;
+    readonly color?: Color;
+};
+interface DeploymentNodeKindSpecification {
+    readonly technology?: string;
+    readonly notation?: string;
+    readonly style: PhysicalElementStyle;
 }
-declare function isElementRef(expr: Expression): expr is ElementRefExpr;
-interface ExpandedElementExpr extends Omit<BaseExpr, 'expanded'> {
-    expanded: Fqn;
+interface DeploymentNode {
+    readonly id: Fqn;
+    readonly kind: DeploymentNodeKind;
+    readonly title: string;
+    readonly description?: string | null;
+    readonly technology?: string | null;
+    readonly tags?: NonEmptyArray<Tag> | null;
+    readonly links?: NonEmptyArray<Link> | null;
+    readonly style?: PhysicalElementStyle;
+    readonly notation?: string;
+    readonly metadata?: Record<string, string>;
 }
-declare function isExpandedElementExpr(expr: Expression): expr is ExpandedElementExpr;
-interface CustomElementExpr extends Omit<BaseExpr, 'custom'> {
-    custom: {
-        expr: ElementExpression | ElementWhereExpr;
-        title?: string;
-        description?: string;
-        technology?: string;
-        notation?: string;
-        shape?: ElementShape;
-        color?: Color;
-        icon?: IconUrl;
-        border?: BorderStyle;
-        opacity?: number;
-        navigateTo?: ViewID;
-    };
+interface DeployedInstance {
+    /**
+     * Format: `<DeploymentNode Fqn>.<Instance Id>`
+     * i.e parent fqn is deployment target
+     */
+    readonly id: Fqn;
+    readonly element: Fqn;
+    readonly title?: string;
+    readonly description?: string | null;
+    readonly technology?: string | null;
+    readonly tags?: NonEmptyArray<Tag> | null;
+    readonly links?: NonEmptyArray<Link> | null;
+    readonly style?: PhysicalElementStyle;
+    readonly notation?: string;
+    readonly metadata?: Record<string, string>;
 }
-declare function isCustomElement(expr: Expression): expr is CustomElementExpr;
-interface WildcardExpr extends Omit<BaseExpr, 'wildcard'> {
-    wildcard: true;
+type DeploymentElement = Simplify<MergeExclusive<DeploymentNode, DeployedInstance>>;
+declare namespace DeploymentElement {
+    const isDeploymentNode: (el: DeploymentElement) => el is DeploymentNode;
+    const isInstance: (el: DeploymentElement) => el is DeployedInstance;
 }
-declare function isWildcard(expr: Expression): expr is WildcardExpr;
-interface ElementKindExpr extends Omit<BaseExpr, 'elementKind' | 'isEqual'> {
-    elementKind: ElementKind;
-    isEqual: boolean;
+interface DeploymentRef {
+    readonly id: Fqn;
+    readonly element?: Fqn;
 }
-declare function isElementKindExpr(expr: Expression): expr is ElementKindExpr;
-interface ElementTagExpr extends Omit<BaseExpr, 'elementTag' | 'isEqual'> {
-    elementTag: Tag;
-    isEqual: boolean;
-}
-declare function isElementTagExpr(expr: Expression): expr is ElementTagExpr;
-type ElementExpression = ElementRefExpr | WildcardExpr | ElementKindExpr | ElementTagExpr | ExpandedElementExpr;
-declare function isElement(expr: Expression): expr is ElementExpression;
-interface ElementWhereExpr extends Omit<BaseExpr, 'where'> {
-    where: {
-        expr: ElementExpression;
-        condition: WhereOperator<string, string>;
+/**
+ * NOTE:
+ */
+interface DeploymentRelation {
+    readonly id: RelationId;
+    readonly source: DeploymentRef;
+    readonly target: DeploymentRef;
+    readonly title?: string;
+    readonly tags?: NonEmptyArray<Tag> | null;
+    readonly description?: string;
+    readonly technology?: string;
+    readonly kind?: RelationshipKind;
+    readonly color?: Color;
+    readonly line?: RelationshipLineType;
+    readonly head?: RelationshipArrowType;
+    readonly tail?: RelationshipArrowType;
+    readonly links?: NonEmptyArray<Link> | null;
+    readonly navigateTo?: ViewId;
+    readonly metadata?: {
+        [key: string]: string;
     };
 }
-declare function isElementWhere(expr: Expression): expr is ElementWhereExpr;
-type ElementPredicateExpression = ElementExpression | ElementWhereExpr | CustomElementExpr;
-declare function isElementPredicateExpr(expr: Expression): expr is ElementPredicateExpression;
-interface RelationExpr extends Omit<BaseExpr, 'source' | 'target'> {
-    source: ElementExpression;
-    target: ElementExpression;
-    isBidirectional?: boolean;
-}
-declare function isRelation(expr: Expression): expr is RelationExpr;
-interface InOutExpr extends Omit<BaseExpr, 'inout'> {
-    inout: ElementExpression;
-}
-declare function isInOut(expr: Expression): expr is InOutExpr;
-interface IncomingExpr extends Omit<BaseExpr, 'incoming'> {
-    incoming: ElementExpression;
-}
-declare function isIncoming(expr: Expression): expr is IncomingExpr;
-interface OutgoingExpr extends Omit<BaseExpr, 'outgoing'> {
-    outgoing: ElementExpression;
-}
-declare function isOutgoing(expr: Expression): expr is OutgoingExpr;
-type RelationExpression = RelationExpr | InOutExpr | IncomingExpr | OutgoingExpr;
-declare function isRelationExpression(expr: Expression): expr is RelationExpression;
-interface RelationWhereExpr extends Omit<BaseExpr, 'where'> {
-    where: {
-        expr: RelationExpression;
-        condition: WhereOperator<string, string>;
+type AllNever<Expressions> = UnionToIntersection<{
+    [Name in keyof Expressions]: {
+        -readonly [Key in keyof Expressions[Name]]?: never;
     };
-}
-declare function isRelationWhere(expr: Expression): expr is RelationWhereExpr;
-interface CustomRelationExpr extends Omit<BaseExpr, 'customRelation'> {
-    customRelation: {
-        relation: RelationExpression | RelationWhereExpr;
-        title?: string;
-        description?: string;
-        technology?: string;
-        notation?: string;
-        navigateTo?: ViewID;
-        notes?: string;
-        color?: Color;
-        line?: RelationshipLineType;
-        head?: RelationshipArrowType;
-        tail?: RelationshipArrowType;
+}[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 {
+    type Direct = {
+        source: DeploymentElementExpression;
+        target: DeploymentElementExpression;
+        isBidirectional?: boolean;
     };
-}
-declare function isCustomRelationExpr(expr: Expression): expr is CustomRelationExpr;
-type RelationPredicateExpression = RelationExpression | RelationWhereExpr | CustomRelationExpr;
-declare function isRelationPredicateExpr(expr: Expression): expr is RelationPredicateExpression;
-type Expression = ElementPredicateExpression | RelationPredicateExpression;
-
-type expression_CustomElementExpr = CustomElementExpr;
-type expression_CustomRelationExpr = CustomRelationExpr;
-type expression_ElementExpression = ElementExpression;
-type expression_ElementKindExpr = ElementKindExpr;
-type expression_ElementPredicateExpression = ElementPredicateExpression;
-type expression_ElementRefExpr = ElementRefExpr;
-type expression_ElementTagExpr = ElementTagExpr;
-type expression_ElementWhereExpr = ElementWhereExpr;
-type expression_ExpandedElementExpr = ExpandedElementExpr;
-type expression_Expression = Expression;
-type expression_InOutExpr = InOutExpr;
-type expression_IncomingExpr = IncomingExpr;
-type expression_OutgoingExpr = OutgoingExpr;
-type expression_RelationExpr = RelationExpr;
-type expression_RelationExpression = RelationExpression;
-type expression_RelationPredicateExpression = RelationPredicateExpression;
-type expression_RelationWhereExpr = RelationWhereExpr;
-type expression_WildcardExpr = WildcardExpr;
-declare const expression_isCustomElement: typeof isCustomElement;
-declare const expression_isCustomRelationExpr: typeof isCustomRelationExpr;
-declare const expression_isElement: typeof isElement;
-declare const expression_isElementKindExpr: typeof isElementKindExpr;
-declare const expression_isElementPredicateExpr: typeof isElementPredicateExpr;
-declare const expression_isElementRef: typeof isElementRef;
-declare const expression_isElementTagExpr: typeof isElementTagExpr;
-declare const expression_isElementWhere: typeof isElementWhere;
-declare const expression_isExpandedElementExpr: typeof isExpandedElementExpr;
-declare const expression_isInOut: typeof isInOut;
-declare const expression_isIncoming: typeof isIncoming;
-declare const expression_isOutgoing: typeof isOutgoing;
-declare const expression_isRelation: typeof isRelation;
-declare const expression_isRelationExpression: typeof isRelationExpression;
-declare const expression_isRelationPredicateExpr: typeof isRelationPredicateExpr;
-declare const expression_isRelationWhere: typeof isRelationWhere;
-declare const expression_isWildcard: typeof isWildcard;
-declare namespace expression {
-  export { type expression_CustomElementExpr as CustomElementExpr, type expression_CustomRelationExpr as CustomRelationExpr, type expression_ElementExpression as ElementExpression, type expression_ElementKindExpr as ElementKindExpr, type expression_ElementPredicateExpression as ElementPredicateExpression, type expression_ElementRefExpr as ElementRefExpr, type expression_ElementTagExpr as ElementTagExpr, type expression_ElementWhereExpr as ElementWhereExpr, type expression_ExpandedElementExpr as ExpandedElementExpr, type expression_Expression as Expression, type expression_InOutExpr as InOutExpr, type expression_IncomingExpr as IncomingExpr, type expression_OutgoingExpr as OutgoingExpr, type expression_RelationExpr as RelationExpr, type expression_RelationExpression as RelationExpression, type expression_RelationPredicateExpression as RelationPredicateExpression, type expression_RelationWhereExpr as RelationWhereExpr, type expression_WildcardExpr as WildcardExpr, expression_isCustomElement as isCustomElement, expression_isCustomRelationExpr as isCustomRelationExpr, expression_isElement as isElement, expression_isElementKindExpr as isElementKindExpr, expression_isElementPredicateExpr as isElementPredicateExpr, expression_isElementRef as isElementRef, expression_isElementTagExpr as isElementTagExpr, expression_isElementWhere as isElementWhere, expression_isExpandedElementExpr as isExpandedElementExpr, expression_isInOut as isInOut, expression_isIncoming as isIncoming, expression_isOutgoing as isOutgoing, expression_isRelation as isRelation, expression_isRelationExpression as isRelationExpression, expression_isRelationPredicateExpr as isRelationPredicateExpr, expression_isRelationWhere as isRelationWhere, expression_isWildcard as isWildcard };
+    const isDirect: (expr: DeploymentExpression) => expr is Direct;
+    type Incoming = {
+        incoming: DeploymentElementExpression;
+    };
+    const isIncoming: (expr: DeploymentExpression) => expr is Incoming;
+    type Outgoing = {
+        outgoing: DeploymentElementExpression;
+    };
+    const isOutgoing: (expr: DeploymentExpression) => expr is Outgoing;
+    type InOut = {
+        inout: DeploymentElementExpression;
+    };
+    const isInOut: (expr: DeploymentExpression) => expr is InOut;
+}
+type DeploymentRelationExpression = ExclusiveUnion<{
+    Direct: DeploymentRelationExpression.Direct;
+    Incoming: DeploymentRelationExpression.Incoming;
+    Outgoing: DeploymentRelationExpression.Outgoing;
+    InOut: DeploymentRelationExpression.InOut;
+}>;
+declare namespace DeploymentElementExpression {
+    type Ref = {
+        ref: DeploymentRef;
+        selector?: 'children' | 'expanded' | 'descendants';
+    };
+    const isRef: (expr: DeploymentExpression) => expr is Ref;
+    type Wildcard = {
+        wildcard: true;
+    };
+    const isWildcard: (expr: DeploymentExpression) => expr is Wildcard;
+}
+type DeploymentElementExpression = ExclusiveUnion<{
+    DeploymentRef: DeploymentElementExpression.Ref;
+    Wildcard: DeploymentElementExpression.Wildcard;
+}>;
+type DeploymentExpression = ExclusiveUnion<{
+    Element: DeploymentElementExpression;
+    Relation: DeploymentRelationExpression;
+}>;
+declare namespace DeploymentExpression {
+    type Element = DeploymentElementExpression;
+    type Relation = DeploymentRelationExpression;
+    const isElement: (expr: DeploymentExpression) => expr is DeploymentElementExpression;
+    const isRelation: (expr: DeploymentExpression) => expr is DeploymentRelationExpression;
 }
 
 /**
  * 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<Tags>[];
         elements: Record<ElementKinds, ElementKindSpecification>;
+        deployments: Record<DeploymentNodeKind, DeploymentNodeKindSpecification>;
         relationships: Record<RelationKinds, RelationshipKindSpecification>;
     };
     elements: Record<Fqns, TypedElement<Fqns, ElementKinds, Tags>>;
-    relations: Record<RelationID, Relation>;
+    relations: Record<RelationId, Relation>;
     globals: ModelGlobals;
     views: Record<Views, LikeC4View<Views, Tags>>;
+    /**
+     * Deployment Model.
+     */
+    deployments: {
+        elements: Record<DeploymentFqns, DeploymentElement>;
+        relations: Record<RelationId, DeploymentRelation>;
+    };
 }
 /**
- * Same as `ParsedLikeC4Model` but with computed views.
+ * Hook to get types from dump
  */
-interface ComputedLikeC4Model extends Omit<ParsedLikeC4Model, 'views'> {
-    __?: never;
-    views: Record<ViewID, ComputedView>;
+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 layouted views (DiagramView)
+ * Same as `ParsedLikeC4Model` but with computed views.
  */
-interface LayoutedLikeC4Model extends Omit<ParsedLikeC4Model, 'views'> {
-    __: 'layouted';
-    views: Record<ViewID, DiagramView>;
+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>;
 }
-
+type ComputedLikeC4ModelFromParsed<M> = M extends ParsedLikeC4Model ? ComputedLikeC4Model<KeysOf<M['elements']>, KeysOf<M['deployments']['elements']>, KeysOf<M['views']>> : ComputedLikeC4Model;
 /**
- * OverviewGraph is a graph representation of all views in a model
+ * Same as `ParsedLikeC4Model` but with layouted views (DiagramView)
  */
-declare namespace OverviewGraph {
-    type Node = {
-        id: string;
-        type: 'folder' | 'file';
-        path: string;
-        label: string;
-        parentId: string | null;
-        position: XYPoint;
-        width: number;
-        height: number;
-    } | {
-        id: string;
-        type: 'view';
-        viewId: ViewID;
-        label: string;
-        parentId: string | null;
-        position: XYPoint;
-        width: number;
-        height: number;
-    };
-    /**
-     * Edge represents a navigational link from one view to another
-     */
-    type Edge = {
-        id: string;
-        source: string;
-        target: string;
-        points: NonEmptyArray<Point>;
-    };
-}
-interface OverviewGraph {
-    nodes: OverviewGraph.Node[];
-    edges: OverviewGraph.Edge[];
-    bounds: BBox;
-}
-
-declare namespace ViewChange {
-    interface ChangeElementStyle {
-        op: 'change-element-style';
-        style: {
-            border?: BorderStyle;
-            opacity?: number;
-            shape?: ElementShape;
-            color?: ThemeColor;
-        };
-        targets: NonEmptyArray<Fqn>;
-    }
-    interface SaveManualLayout {
-        op: 'save-manual-layout';
-        layout: ViewManualLayout;
-    }
-    interface ChangeAutoLayout {
-        op: 'change-autolayout';
-        layout: {
-            direction: AutoLayoutDirection;
-            nodeSep?: number | null;
-            rankSep?: number | null;
-        };
-    }
+interface LayoutedLikeC4Model<Fqns extends string = string, DeploymentFqns extends string = string, Views extends string = string, Tags extends string = string> extends Omit<AnyLikeC4Model<Fqns, DeploymentFqns, Views, Tags, 'layouted'>, 'views'> {
+    __: 'layouted';
+    views: Record<Views, DiagramView<Views, Tags>>;
 }
-type ViewChange = ViewChange.ChangeElementStyle | ViewChange.SaveManualLayout | ViewChange.ChangeAutoLayout;
 
-export { type ExpandedElementExpr as $, type AutoLayoutDirection as A, type BorderStyle as B, type Color as C, type DiagramView as D, type ElementKindSpecification as E, type Fqn as F, AsFqn as G, type HexColorLiteral as H, type IconUrl as I, BorderStyles as J, ElementShapes as K, type LikeC4View as L, DefaultThemeColor as M, type NonEmptyArray as N, DefaultElementShape as O, type ParsedLikeC4Model as P, type ElementStyle as Q, type RelationshipKindSpecification as R, type TagSpec as S, type ThemeColorValues as T, type Link as U, type ViewRuleStyle as V, type TypedElement as W, type XYPoint as X, type ElementKindSpecificationStyle as Y, type ElementRefExpr as Z, isElementRef as _, type ElementShape as a, type ViewRuleGlobalPredicateRef as a$, isExpandedElementExpr as a0, isCustomElement as a1, type WildcardExpr as a2, isWildcard as a3, type ElementKindExpr as a4, isElementKindExpr as a5, type ElementTagExpr as a6, isElementTagExpr as a7, type ElementExpression as a8, isElement as a9, type TagEqual as aA, isTagEqual as aB, type KindEqual as aC, isKindEqual as aD, type NotOperator as aE, isNotOperator as aF, type AndOperator as aG, isAndOperator as aH, type OrOperator as aI, isOrOperator as aJ, type WhereOperator as aK, type Filterable as aL, whereOperatorAsPredicate as aM, OverviewGraph as aN, DefaultLineStyle as aO, DefaultArrowType as aP, DefaultRelationshipColor as aQ, type ThemeColor as aR, type ColorLiteral as aS, isThemeColor as aT, type ElementThemeColorValues as aU, type ElementThemeColors as aV, type RelationshipThemeColorValues as aW, type RelationshipThemeColors as aX, type LikeC4Theme as aY, type ViewRulePredicate as aZ, isViewRulePredicate as a_, type ElementWhereExpr as aa, isElementWhere as ab, type ElementPredicateExpression as ac, isElementPredicateExpr as ad, type RelationExpr as ae, isRelation as af, type InOutExpr as ag, isInOut as ah, type IncomingExpr as ai, isIncoming as aj, type OutgoingExpr as ak, isOutgoing as al, type RelationExpression as am, isRelationExpression as an, type RelationWhereExpr as ao, isRelationWhere as ap, isCustomRelationExpr as aq, type RelationPredicateExpression as ar, isRelationPredicateExpr as as, type GlobalPredicateId as at, type GlobalPredicates as au, type GlobalDynamicPredicates as av, type GlobalStyleID as aw, type GlobalStyles as ax, type ModelGlobals as ay, type EqualOperator as az, type RelationshipArrowType as b, isViewRuleGlobalPredicateRef as b0, isViewRuleStyle as b1, type ViewRuleGlobalStyle as b2, isViewRuleGlobalStyle as b3, type ViewRuleStyleOrGlobalRef as b4, isAutoLayoutDirection as b5, type ViewRuleAutoLayout as b6, isViewRuleAutoLayout as b7, type ViewRuleGroup as b8, isViewRuleGroup as b9, type ViewAutoLayout as bA, type ComputedElementView as bB, type ComputedDynamicView as bC, isComputedDynamicView as bD, isComputedElementView as bE, type BBox as bF, getBBoxCenter as bG, type ViewManualLayout as bH, ViewChange as bI, type ElementNotation as bJ, type ViewRule as ba, type BasicView as bb, type BasicElementView as bc, type ScopedElementView as bd, type ExtendsElementView as be, type ElementView as bf, type DynamicViewStep as bg, type DynamicViewParallelSteps as bh, type DynamicViewStepOrParallel as bi, type DynamicViewIncludeRule as bj, isDynamicViewIncludeRule as bk, type DynamicViewRule as bl, type DynamicView as bm, isDynamicViewParallelSteps as bn, type CustomColorDefinitions as bo, isDynamicView as bp, isElementView as bq, isExtendsElementView as br, isScopedElementView as bs, type StepEdgeIdLiteral as bt, StepEdgeId as bu, isStepEdgeId as bv, extractStep as bw, getParallelStepsPrefix as bx, type ViewWithHash as by, type ViewWithNotation as bz, type RelationshipLineType as c, type Element as d, type Relation as e, type Expression as f, type CustomElementExpr as g, type CustomRelationExpr as h, type RelationID as i, type ViewID as j, type EdgeId as k, type ComputedView as l, type Tag as m, ComputedNode as n, type NodeId as o, ElementKind as p, type ComputedEdge as q, type ComputedLikeC4Model as r, type LayoutedLikeC4Model as s, type RelationshipKind as t, DiagramNode as u, type DiagramEdge as v, expression as w, type NonEmptyReadonlyArray as x, type CustomColor as y, type Point as z };
+export { type TypedElement as $, type AutoLayoutDirection as A, type BorderStyle as B, type ComputedLikeC4ModelFromParsed as C, type DeploymentNodeKindSpecification as D, type Element as E, type Fqn as F, AsFqn as G, type HexColorLiteral as H, type IconUrl as I, BorderStyles as J, type KeysOf as K, type LikeC4View as L, type ModelGlobals as M, type NonEmptyArray as N, ElementKind as O, type ParsedLikeC4Model as P, ElementShapes as Q, type Relation as R, DefaultThemeColor as S, type ThemeColorValues as T, DefaultElementShape as U, type ViewRuleStyle as V, type ElementStyle as W, type XYPoint as X, type Tag as Y, type TagSpec as Z, type Link as _, ComputedView as a, type ElementThemeColors as a$, type ElementKindSpecificationStyle as a0, type ElementRefExpr as a1, isElementRef as a2, type ExpandedElementExpr as a3, isExpandedElementExpr as a4, isCustomElement as a5, type WildcardExpr as a6, isWildcard as a7, type ElementKindExpr as a8, isElementKindExpr as a9, type GlobalStyleID as aA, type GlobalStyles as aB, type ParsedLikeC4ModelDump as aC, type AnyLikeC4Model as aD, type LayoutedLikeC4Model as aE, type EqualOperator as aF, type TagEqual as aG, isTagEqual as aH, type KindEqual as aI, isKindEqual as aJ, type NotOperator as aK, isNotOperator as aL, type AndOperator as aM, isAndOperator as aN, type OrOperator as aO, isOrOperator as aP, type WhereOperator as aQ, type Filterable as aR, whereOperatorAsPredicate as aS, type RelationshipKind as aT, DefaultLineStyle as aU, DefaultArrowType as aV, DefaultRelationshipColor as aW, type ThemeColor as aX, type ColorLiteral as aY, isThemeColor as aZ, type ElementThemeColorValues as a_, type ElementTagExpr as aa, isElementTagExpr as ab, type ElementExpression as ac, isElement as ad, type ElementWhereExpr as ae, isElementWhere as af, type ElementPredicateExpression as ag, isElementPredicateExpr as ah, type RelationExpr as ai, isRelation as aj, type InOutExpr as ak, isInOut as al, type IncomingExpr as am, isIncoming as an, type OutgoingExpr as ao, isOutgoing as ap, type RelationExpression as aq, isRelationExpression as ar, type RelationWhereExpr as as, isRelationWhere as at, isCustomRelationExpr as au, type RelationPredicateExpression as av, isRelationPredicateExpr as aw, type GlobalPredicateId as ax, type GlobalPredicates as ay, type GlobalDynamicPredicates as az, type RelationId as b, type RelationshipThemeColorValues as b0, type RelationshipThemeColors as b1, type LikeC4Theme as b2, type ViewId as b3, type ViewRulePredicate as b4, isViewRulePredicate as b5, type ViewRuleGlobalPredicateRef as b6, isViewRuleGlobalPredicateRef as b7, isViewRuleStyle as b8, type ViewRuleGlobalStyle as b9, isDynamicView as bA, isElementView as bB, isExtendsElementView as bC, isScopedElementView as bD, type NodeId as bE, type EdgeId as bF, type StepEdgeIdLiteral as bG, type StepEdgeId as bH, stepEdgeId as bI, isStepEdgeId as bJ, extractStep as bK, getParallelStepsPrefix as bL, ComputedNode as bM, type ComputedEdge as bN, type ViewWithHash as bO, type ViewWithNotation as bP, type ViewAutoLayout as bQ, type ComputedElementView as bR, type ComputedDynamicView as bS, type ComputedDeploymentView as bT, type BBox as bU, getBBoxCenter as bV, DiagramNode as bW, type DiagramEdge as bX, type DiagramView as bY, type ViewManualLayout as bZ, type ElementNotation as b_, isViewRuleGlobalStyle as ba, type ViewRuleStyleOrGlobalRef as bb, isAutoLayoutDirection as bc, type ViewRuleAutoLayout as bd, isViewRuleAutoLayout as be, type ViewRuleGroup as bf, isViewRuleGroup as bg, type ViewRule as bh, type BasicView as bi, type BasicElementView as bj, type ScopedElementView as bk, type ExtendsElementView as bl, type ElementView as bm, type DynamicViewStep as bn, type DynamicViewParallelSteps as bo, type DynamicViewStepOrParallel as bp, type DynamicViewIncludeRule as bq, type DynamicViewRule as br, type DynamicView as bs, isDynamicViewParallelSteps as bt, type CustomColorDefinitions as bu, type DeploymentViewRulePredicate as bv, type DeploymentViewRuleStyle as bw, type DeploymentViewRule as bx, type DeploymentView as by, isDeploymentView as bz, type ComputedLikeC4Model as c, type ElementKindSpecification as d, type RelationshipKindSpecification as e, type ElementShape as f, type Color as g, type RelationshipArrowType as h, type RelationshipLineType as i, DeploymentElement as j, type DeploymentRelation as k, type Expression as l, type CustomElementExpr as m, type CustomRelationExpr as n, DeploymentExpression as o, expression as p, type NonEmptyReadonlyArray as q, type CustomColor as r, type Point as s, type DeploymentNodeKind as t, type PhysicalElementStyle as u, type DeploymentNode as v, type DeployedInstance as w, type DeploymentRef as x, DeploymentRelationExpression as y, DeploymentElementExpression as z };