@likec4/core 1.10.0 → 1.11.0

package/dist/shared/{core.DeifT5lC.mjs → core.CUlHblBQ.mjs}

@@ -28,6 +28,10 @@ function t(...a){return u(e,a)}var e=(a,o)=>o.every(l=>l(a));
 
 function y(...a){return u(r,a)}var r=(a,o)=>o.some(e=>e(a));
 
+const DefaultLineStyle = "dashed";
+const DefaultArrowType = "normal";
+const DefaultRelationshipColor = "gray";
+
 function AsFqn(name, parent) {
   return parent ? parent + "." + name : name;
 }
@@ -175,10 +179,6 @@ function whereOperatorAsPredicate(operator) {
   }
 }
 
-const DefaultLineStyle = "dashed";
-const DefaultArrowType = "normal";
-const DefaultRelationshipColor = "gray";
-
 const ThemeColors = [
   "amber",
   "blue",
@@ -260,4 +260,4 @@ function getBBoxCenter({
   };
 }
 
-export { getBBoxCenter as $, AsFqn as A, BorderStyles as B, isNotOperator as C, DefaultElementShape as D, ElementShapes as E, isAndOperator as F, isOrOperator as G, whereOperatorAsPredicate as H, DefaultLineStyle as I, DefaultArrowType as J, DefaultRelationshipColor as K, isThemeColor as L, isViewRulePredicate as M, isViewRuleStyle as N, isViewRuleAutoLayout as O, isDynamicViewIncludeRule as P, isDynamicViewParallelSteps as Q, isDynamicView as R, isElementView as S, isExtendsElementView as T, isScopedElementView as U, StepEdgeId as V, isStepEdgeId as W, extractStep as X, getParallelStepsPrefix as Y, isComputedDynamicView as Z, isComputedElementView as _, DefaultThemeColor as a, nonexhaustive as b, expression as c, isElementRef as d, e$1 as e, isExpandedElementExpr as f, isCustomElement as g, isWildcard as h, invariant as i, isElementKindExpr as j, isElementTagExpr as k, isElement as l, isElementWhere as m, nonNullable as n, isElementPredicateExpr as o, isRelation as p, isInOut as q, isIncoming as r, isOutgoing as s, isRelationExpression as t, u, isRelationWhere as v, isCustomRelationExpr as w, isRelationPredicateExpr as x, isTagEqual as y, isKindEqual as z };
+export { getBBoxCenter as $, AsFqn as A, BorderStyles as B, isKindEqual as C, DefaultRelationshipColor as D, ElementShapes as E, isNotOperator as F, isAndOperator as G, isOrOperator as H, whereOperatorAsPredicate as I, DefaultLineStyle as J, DefaultArrowType as K, isThemeColor as L, isViewRulePredicate as M, isViewRuleStyle as N, isViewRuleAutoLayout as O, isDynamicViewIncludeRule as P, isDynamicViewParallelSteps as Q, isDynamicView as R, isElementView as S, isExtendsElementView as T, isScopedElementView as U, StepEdgeId as V, isStepEdgeId as W, extractStep as X, getParallelStepsPrefix as Y, isComputedDynamicView as Z, isComputedElementView as _, DefaultElementShape as a, DefaultThemeColor as b, expression as c, nonexhaustive as d, e$1 as e, isElementRef as f, isExpandedElementExpr as g, isCustomElement as h, invariant as i, isWildcard as j, isElementKindExpr as k, isElementTagExpr as l, isElement as m, nonNullable as n, isElementWhere as o, isElementPredicateExpr as p, isRelation as q, isInOut as r, isIncoming as s, isOutgoing as t, u, isRelationExpression as v, isRelationWhere as w, isCustomRelationExpr as x, isRelationPredicateExpr as y, isTagEqual as z };

package/dist/shared/{core.CpR2fq5B.d.cts → core.aVt8heZL.d.cts}

@@ -1,168 +1,4 @@
-/**
-Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive).
-
-@category Type
-*/
-type Primitive =
-	| null
-	| undefined
-	| string
-	| number
-	| boolean
-	| symbol
-	| bigint;
-
-declare global {
-	// eslint-disable-next-line @typescript-eslint/consistent-type-definitions -- It has to be an `interface` so that it can be merged.
-	interface SymbolConstructor {
-		readonly observable: symbol;
-	}
-}
-
-/**
-Allows creating a union type by combining primitive types and literal types without sacrificing auto-completion in IDEs for the literal type part of the union.
-
-Currently, when a union type of a primitive type is combined with literal types, TypeScript loses all information about the combined literals. Thus, when such type is used in an IDE with autocompletion, no suggestions are made for the declared literals.
-
-This type is a workaround for [Microsoft/TypeScript#29729](https://github.com/Microsoft/TypeScript/issues/29729). It will be removed as soon as it's not needed anymore.
-
-@example
-```
-import type {LiteralUnion} from 'type-fest';
-
-// Before
-
-type Pet = 'dog' | 'cat' | string;
-
-const pet: Pet = '';
-// Start typing in your TypeScript-enabled IDE.
-// You **will not** get auto-completion for `dog` and `cat` literals.
-
-// After
-
-type Pet2 = LiteralUnion<'dog' | 'cat', string>;
-
-const pet: Pet2 = '';
-// You **will** get auto-completion for `dog` and `cat` literals.
-```
-
-@category Type
-*/
-type LiteralUnion<
-	LiteralType,
-	BaseType extends Primitive,
-> = LiteralType | (BaseType & Record<never, never>);
-
-declare const tag: unique symbol;
-
-type TagContainer<Token> = {
-	readonly [tag]: Token;
-};
-
-type Tag$1<Token extends PropertyKey, TagMetadata> = TagContainer<{[K in Token]: TagMetadata}>;
-
-/**
-Attach a "tag" to an arbitrary type. This allows you to create distinct types, that aren't assignable to one another, for distinct concepts in your program that should not be interchangeable, even if their runtime values have the same type. (See examples.)
-
-A type returned by `Tagged` can be passed to `Tagged` again, to create a type with multiple tags.
-
-[Read more about tagged types.](https://medium.com/@KevinBGreene/surviving-the-typescript-ecosystem-branding-and-type-tagging-6cf6e516523d)
-
-A tag's name is usually a string (and must be a string, number, or symbol), but each application of a tag can also contain an arbitrary type as its "metadata". See {@link GetTagMetadata} for examples and explanation.
-
-A type `A` returned by `Tagged` is assignable to another type `B` returned by `Tagged` if and only if:
-  - the underlying (untagged) type of `A` is assignable to the underlying type of `B`;
-	- `A` contains at least all the tags `B` has;
-	- and the metadata type for each of `A`'s tags is assignable to the metadata type of `B`'s corresponding tag.
-
-There have been several discussions about adding similar features to TypeScript. Unfortunately, nothing has (yet) moved forward:
-	- [Microsoft/TypeScript#202](https://github.com/microsoft/TypeScript/issues/202)
-	- [Microsoft/TypeScript#4895](https://github.com/microsoft/TypeScript/issues/4895)
-	- [Microsoft/TypeScript#33290](https://github.com/microsoft/TypeScript/pull/33290)
-
-@example
-```
-import type {Tagged} from 'type-fest';
-
-type AccountNumber = Tagged<number, 'AccountNumber'>;
-type AccountBalance = Tagged<number, 'AccountBalance'>;
-
-function createAccountNumber(): AccountNumber {
-	// As you can see, casting from a `number` (the underlying type being tagged) is allowed.
-	return 2 as AccountNumber;
-}
-
-function getMoneyForAccount(accountNumber: AccountNumber): AccountBalance {
-	return 4 as AccountBalance;
-}
-
-// This will compile successfully.
-getMoneyForAccount(createAccountNumber());
-
-// But this won't, because it has to be explicitly passed as an `AccountNumber` type!
-// Critically, you could not accidentally use an `AccountBalance` as an `AccountNumber`.
-getMoneyForAccount(2);
-
-// You can also use tagged values like their underlying, untagged type.
-// I.e., this will compile successfully because an `AccountNumber` can be used as a regular `number`.
-// In this sense, the underlying base type is not hidden, which differentiates tagged types from opaque types in other languages.
-const accountNumber = createAccountNumber() + 2;
-```
-
-@example
-```
-import type {Tagged} from 'type-fest';
-
-// You can apply multiple tags to a type by using `Tagged` repeatedly.
-type Url = Tagged<string, 'URL'>;
-type SpecialCacheKey = Tagged<Url, 'SpecialCacheKey'>;
-
-// You can also pass a union of tag names, so this is equivalent to the above, although it doesn't give you the ability to assign distinct metadata to each tag.
-type SpecialCacheKey2 = Tagged<string, 'URL' | 'SpecialCacheKey'>;
-```
-
-@category Type
-*/
-type Tagged<Type, TagName extends PropertyKey, TagMetadata = never> = Type & Tag$1<TagName, TagMetadata>;
-
-/**
-Revert a tagged type back to its original type by removing all tags.
-
-Why is this necessary?
-
-1. Use a `Tagged` type as object keys
-2. Prevent TS4058 error: "Return type of exported function has or is using name X from external module Y but cannot be named"
-
-@example
-```
-import type {Tagged, UnwrapTagged} from 'type-fest';
-
-type AccountType = Tagged<'SAVINGS' | 'CHECKING', 'AccountType'>;
-
-const moneyByAccountType: Record<UnwrapTagged<AccountType>, number> = {
-	SAVINGS: 99,
-	CHECKING: 0.1
-};
-
-// Without UnwrapTagged, the following expression would throw a type error.
-const money = moneyByAccountType.SAVINGS; // TS error: Property 'SAVINGS' does not exist
-
-// Attempting to pass an non-Tagged type to UnwrapTagged will raise a type error.
-type WontWork = UnwrapTagged<string>;
-```
-
-@category Type
-*/
-type UnwrapTagged<TaggedType extends Tag$1<PropertyKey, any>> =
-RemoveAllTags<TaggedType>;
-
-type RemoveAllTags<T> = T extends Tag$1<PropertyKey, any>
-	? {
-		[ThisTag in keyof T[typeof tag]]: T extends Tagged<infer Type, ThisTag, T[typeof tag][ThisTag]>
-			? RemoveAllTags<Type>
-			: never
-	}[keyof T[typeof tag]]
-	: T;
+import { LiteralUnion, Tagged, UnwrapTagged } from 'type-fest';
 
 declare const ThemeColors: readonly ["amber", "blue", "gray", "slate", "green", "indigo", "muted", "primary", "red", "secondary", "sky"];
 type ThemeColor = typeof ThemeColors[number];
@@ -199,6 +35,7 @@ interface LikeC4Theme {
 }
 
 type NonEmptyArray<T> = [T, ...T[]];
+type NonEmptyReadonlyArray<T> = readonly [T, ...T[]];
 type IconUrl = Tagged<string, 'IconUrl'>;
 type CustomColor = string;
 type Point = readonly [x: number, y: number];
@@ -302,6 +139,194 @@ 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>>;
 
+type RelationID = Tagged<string, 'RelationID'>;
+type RelationshipKind = Tagged<string, 'RelationshipKind'>;
+type RelationshipLineType = 'dashed' | 'solid' | 'dotted';
+type RelationshipArrowType = 'none' | 'normal' | 'onormal' | 'dot' | 'odot' | 'diamond' | 'odiamond' | 'crow' | 'open' | 'vee';
+declare const DefaultLineStyle = "dashed";
+declare const DefaultArrowType = "normal";
+declare const DefaultRelationshipColor = "gray";
+interface Relation {
+    readonly id: RelationID;
+    readonly source: Fqn;
+    readonly target: Fqn;
+    readonly title: string;
+    readonly description?: string;
+    readonly technology?: string;
+    readonly tags?: NonEmptyArray<Tag>;
+    readonly kind?: RelationshipKind;
+    readonly color?: Color;
+    readonly line?: RelationshipLineType;
+    readonly head?: RelationshipArrowType;
+    readonly tail?: RelationshipArrowType;
+    readonly links?: NonEmptyArray<Link>;
+    readonly navigateTo?: ViewID;
+    readonly metadata?: {
+        [key: string]: string;
+    };
+}
+interface RelationshipKindSpecification {
+    readonly technology?: string;
+    readonly notation?: string;
+    readonly color?: Color;
+    readonly line?: RelationshipLineType;
+    readonly head?: RelationshipArrowType;
+    readonly tail?: RelationshipArrowType;
+}
+
+interface BaseExpr {
+    where?: never;
+    element?: never;
+    custom?: never;
+    expanded?: never;
+    elementKind?: never;
+    elementTag?: never;
+    isEqual?: never;
+    isDescedants?: never;
+    wildcard?: never;
+    source?: never;
+    target?: never;
+    inout?: never;
+    incoming?: never;
+    outgoing?: never;
+    customRelation?: never;
+}
+interface ElementRefExpr extends Omit<BaseExpr, 'element' | 'isDescedants'> {
+    element: Fqn;
+    isDescedants?: boolean;
+}
+declare function isElementRef(expr: Expression): expr is ElementRefExpr;
+interface ExpandedElementExpr extends Omit<BaseExpr, 'expanded'> {
+    expanded: Fqn;
+}
+declare function isExpandedElementExpr(expr: Expression): expr is ExpandedElementExpr;
+interface CustomElementExpr extends Omit<BaseExpr, 'custom'> {
+    custom: {
+        expr: ElementExpression | ElementWhereExpr;
+        title?: string;
+        description?: string;
+        technology?: string;
+        notation?: string;
+        shape?: ElementShape;
+        color?: Color;
+        icon?: IconUrl;
+        border?: BorderStyle;
+        opacity?: number;
+        navigateTo?: ViewID;
+    };
+}
+declare function isCustomElement(expr: Expression): expr is CustomElementExpr;
+interface WildcardExpr extends Omit<BaseExpr, 'wildcard'> {
+    wildcard: true;
+}
+declare function isWildcard(expr: Expression): expr is WildcardExpr;
+interface ElementKindExpr extends Omit<BaseExpr, 'elementKind' | 'isEqual'> {
+    elementKind: ElementKind;
+    isEqual: boolean;
+}
+declare function isElementKindExpr(expr: Expression): expr is ElementKindExpr;
+interface ElementTagExpr extends Omit<BaseExpr, 'elementTag' | 'isEqual'> {
+    elementTag: Tag;
+    isEqual: boolean;
+}
+declare function isElementTagExpr(expr: Expression): expr is ElementTagExpr;
+type ElementExpression = ElementRefExpr | WildcardExpr | ElementKindExpr | ElementTagExpr | ExpandedElementExpr;
+declare function isElement(expr: Expression): expr is ElementExpression;
+interface ElementWhereExpr extends Omit<BaseExpr, 'where'> {
+    where: {
+        expr: ElementExpression;
+        condition: WhereOperator<string, string>;
+    };
+}
+declare function isElementWhere(expr: Expression): expr is ElementWhereExpr;
+type ElementPredicateExpression = ElementExpression | ElementWhereExpr | CustomElementExpr;
+declare function isElementPredicateExpr(expr: Expression): expr is ElementPredicateExpression;
+interface RelationExpr extends Omit<BaseExpr, 'source' | 'target'> {
+    source: ElementExpression;
+    target: ElementExpression;
+    isBidirectional?: boolean;
+}
+declare function isRelation(expr: Expression): expr is RelationExpr;
+interface InOutExpr extends Omit<BaseExpr, 'inout'> {
+    inout: ElementExpression;
+}
+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 ElementNotation = {
     kinds: ElementKind[];
     shape: ElementShape;
@@ -561,194 +586,6 @@ type ViewManualLayout = {
     }>;
 };
 
-type RelationID = Tagged<string, 'RelationID'>;
-type RelationshipKind = Tagged<string, 'RelationshipKind'>;
-type RelationshipLineType = 'dashed' | 'solid' | 'dotted';
-type RelationshipArrowType = 'none' | 'normal' | 'onormal' | 'dot' | 'odot' | 'diamond' | 'odiamond' | 'crow' | 'open' | 'vee';
-declare const DefaultLineStyle = "dashed";
-declare const DefaultArrowType = "normal";
-declare const DefaultRelationshipColor = "gray";
-interface Relation {
-    readonly id: RelationID;
-    readonly source: Fqn;
-    readonly target: Fqn;
-    readonly title: string;
-    readonly description?: string;
-    readonly technology?: string;
-    readonly tags?: NonEmptyArray<Tag>;
-    readonly kind?: RelationshipKind;
-    readonly color?: Color;
-    readonly line?: RelationshipLineType;
-    readonly head?: RelationshipArrowType;
-    readonly tail?: RelationshipArrowType;
-    readonly links?: NonEmptyArray<Link>;
-    readonly navigateTo?: ViewID;
-    readonly metadata?: {
-        [key: string]: string;
-    };
-}
-interface RelationshipKindSpecification {
-    readonly technology?: string;
-    readonly notation?: string;
-    readonly color?: Color;
-    readonly line?: RelationshipLineType;
-    readonly head?: RelationshipArrowType;
-    readonly tail?: RelationshipArrowType;
-}
-
-interface BaseExpr {
-    where?: never;
-    element?: never;
-    custom?: never;
-    expanded?: never;
-    elementKind?: never;
-    elementTag?: never;
-    isEqual?: never;
-    isDescedants?: never;
-    wildcard?: never;
-    source?: never;
-    target?: never;
-    inout?: never;
-    incoming?: never;
-    outgoing?: never;
-    customRelation?: never;
-}
-interface ElementRefExpr extends Omit<BaseExpr, 'element' | 'isDescedants'> {
-    element: Fqn;
-    isDescedants?: boolean;
-}
-declare function isElementRef(expr: Expression): expr is ElementRefExpr;
-interface ExpandedElementExpr extends Omit<BaseExpr, 'expanded'> {
-    expanded: Fqn;
-}
-declare function isExpandedElementExpr(expr: Expression): expr is ExpandedElementExpr;
-interface CustomElementExpr extends Omit<BaseExpr, 'custom'> {
-    custom: {
-        expr: ElementExpression | ElementWhereExpr;
-        title?: string;
-        description?: string;
-        technology?: string;
-        notation?: string;
-        shape?: ElementShape;
-        color?: Color;
-        icon?: IconUrl;
-        border?: BorderStyle;
-        opacity?: number;
-        navigateTo?: ViewID;
-    };
-}
-declare function isCustomElement(expr: Expression): expr is CustomElementExpr;
-interface WildcardExpr extends Omit<BaseExpr, 'wildcard'> {
-    wildcard: true;
-}
-declare function isWildcard(expr: Expression): expr is WildcardExpr;
-interface ElementKindExpr extends Omit<BaseExpr, 'elementKind' | 'isEqual'> {
-    elementKind: ElementKind;
-    isEqual: boolean;
-}
-declare function isElementKindExpr(expr: Expression): expr is ElementKindExpr;
-interface ElementTagExpr extends Omit<BaseExpr, 'elementTag' | 'isEqual'> {
-    elementTag: Tag;
-    isEqual: boolean;
-}
-declare function isElementTagExpr(expr: Expression): expr is ElementTagExpr;
-type ElementExpression = ElementRefExpr | WildcardExpr | ElementKindExpr | ElementTagExpr | ExpandedElementExpr;
-declare function isElement(expr: Expression): expr is ElementExpression;
-interface ElementWhereExpr extends Omit<BaseExpr, 'where'> {
-    where: {
-        expr: ElementExpression;
-        condition: WhereOperator<string, string>;
-    };
-}
-declare function isElementWhere(expr: Expression): expr is ElementWhereExpr;
-type ElementPredicateExpression = ElementExpression | ElementWhereExpr | CustomElementExpr;
-declare function isElementPredicateExpr(expr: Expression): expr is ElementPredicateExpression;
-interface RelationExpr extends Omit<BaseExpr, 'source' | 'target'> {
-    source: ElementExpression;
-    target: ElementExpression;
-    isBidirectional?: boolean;
-}
-declare function isRelation(expr: Expression): expr is RelationExpr;
-interface InOutExpr extends Omit<BaseExpr, 'inout'> {
-    inout: ElementExpression;
-}
-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 };
-}
-
 /**
  * Parsed elements, relations, and views.
  */
@@ -766,8 +603,16 @@ interface ParsedLikeC4Model {
  * Same as `ParsedLikeC4Model` but with computed views.
  */
 interface ComputedLikeC4Model extends Omit<ParsedLikeC4Model, 'views'> {
+    __?: never;
     views: Record<ViewID, ComputedView>;
 }
+/**
+ * Same as `ParsedLikeC4Model` but with layouted views (DiagramView)
+ */
+interface LayoutedLikeC4Model extends Omit<ParsedLikeC4Model, 'views'> {
+    __: 'layouted';
+    views: Record<ViewID, DiagramView>;
+}
 
 /**
  * OverviewGraph is a graph representation of all views in a model
@@ -830,4 +675,4 @@ declare namespace ViewChange {
 }
 type ViewChange = ViewChange.ChangeElementStyle | ViewChange.SaveManualLayout | ViewChange.ChangeAutoLayout;
 
-export { type ElementPredicateExpression as $, AsFqn as A, BorderStyles as B, type ComputedView as C, DefaultThemeColor as D, type EdgeId as E, type Fqn as F, type CustomElementExpr as G, type HexColorLiteral as H, type IconUrl as I, isCustomElement as J, isWildcard as K, type LiteralUnion as L, type ElementKindExpr as M, type NodeId as N, isElementKindExpr as O, type Primitive as P, type ElementTagExpr as Q, type RelationID as R, isElementTagExpr as S, type ThemeColorValues as T, type ElementExpression as U, type ViewID as V, type WildcardExpr as W, type XYPoint as X, isElement as Y, type ElementWhereExpr as Z, isElementWhere as _, type Tag as a, type DynamicViewIncludeRule as a$, isElementPredicateExpr as a0, type RelationExpr as a1, isRelation as a2, type InOutExpr as a3, isInOut as a4, type IncomingExpr as a5, isIncoming as a6, type OutgoingExpr as a7, isOutgoing as a8, type RelationExpression as a9, DefaultArrowType as aA, DefaultRelationshipColor as aB, type RelationshipKindSpecification as aC, type ThemeColor as aD, type ColorLiteral as aE, isThemeColor as aF, type ElementThemeColorValues as aG, type ElementThemeColors as aH, type RelationshipThemeColorValues as aI, type RelationshipThemeColors as aJ, type LikeC4Theme as aK, type ViewRulePredicate as aL, isViewRulePredicate as aM, type ViewRuleStyle as aN, isViewRuleStyle as aO, type AutoLayoutDirection as aP, type ViewRuleAutoLayout as aQ, isViewRuleAutoLayout as aR, type ViewRule as aS, type BasicView as aT, type BasicElementView as aU, type ScopedElementView as aV, type ExtendsElementView as aW, type ElementView as aX, type DynamicViewStep as aY, type DynamicViewParallelSteps as aZ, type DynamicViewStepOrParallel as a_, isRelationExpression as aa, type RelationWhereExpr as ab, isRelationWhere as ac, type CustomRelationExpr as ad, isCustomRelationExpr as ae, type RelationPredicateExpression as af, isRelationPredicateExpr as ag, type Expression as ah, type ParsedLikeC4Model as ai, type EqualOperator as aj, type TagEqual as ak, isTagEqual as al, type KindEqual as am, isKindEqual as an, type NotOperator as ao, isNotOperator as ap, type AndOperator as aq, isAndOperator as ar, type OrOperator as as, isOrOperator as at, type WhereOperator as au, whereOperatorAsPredicate as av, OverviewGraph as aw, type RelationshipLineType as ax, type RelationshipArrowType as ay, DefaultLineStyle as az, type ComputedNode as b, isDynamicViewIncludeRule as b0, type DynamicViewRule as b1, type DynamicView as b2, isDynamicViewParallelSteps as b3, type CustomColorDefinitions as b4, type LikeC4View as b5, isDynamicView as b6, isElementView as b7, isExtendsElementView as b8, isScopedElementView as b9, type StepEdgeIdLiteral as ba, StepEdgeId as bb, isStepEdgeId as bc, extractStep as bd, getParallelStepsPrefix as be, type ViewWithHash as bf, type ViewWithNotation as bg, type ComputedElementView as bh, type ComputedDynamicView as bi, isComputedDynamicView as bj, isComputedElementView as bk, type BBox as bl, getBBoxCenter as bm, type DiagramNode as bn, type DiagramEdge as bo, type DiagramView as bp, type ViewManualLayout as bq, ViewChange as br, type ElementNotation as bs, type ElementKind as c, type ElementShape as d, type Color as e, type ComputedEdge as f, type ComputedLikeC4Model as g, type Element as h, type Relation as i, type RelationshipKind as j, type NonEmptyArray as k, expression as l, type CustomColor as m, type Point as n, type BorderStyle as o, ElementShapes as p, DefaultElementShape as q, type ElementStyle as r, type TagSpec as s, type Link as t, type ElementKindSpecificationStyle as u, type ElementKindSpecification as v, type ElementRefExpr as w, isElementRef as x, type ExpandedElementExpr as y, isExpandedElementExpr as z };
+export { isElement as $, AsFqn as A, BorderStyles as B, type ComputedView as C, type DiagramView as D, type EdgeId as E, type Fqn as F, isElementRef as G, type HexColorLiteral as H, type IconUrl as I, type ExpandedElementExpr as J, isExpandedElementExpr as K, type LayoutedLikeC4Model as L, type CustomElementExpr as M, type NodeId as N, isCustomElement as O, type Point as P, isWildcard as Q, type RelationID as R, type ElementKindExpr as S, type ThemeColorValues as T, isElementKindExpr as U, type ViewID as V, type WildcardExpr as W, type XYPoint as X, type ElementTagExpr as Y, isElementTagExpr as Z, type ElementExpression as _, type Tag as a, type DynamicViewStep as a$, type ElementWhereExpr as a0, isElementWhere as a1, type ElementPredicateExpression as a2, isElementPredicateExpr as a3, type RelationExpr as a4, isRelation as a5, type InOutExpr as a6, isInOut as a7, type IncomingExpr as a8, isIncoming as a9, type RelationshipLineType as aA, type RelationshipArrowType as aB, DefaultLineStyle as aC, DefaultArrowType as aD, DefaultRelationshipColor as aE, type RelationshipKindSpecification as aF, type ThemeColor as aG, type ColorLiteral as aH, isThemeColor as aI, type ElementThemeColorValues as aJ, type ElementThemeColors as aK, type RelationshipThemeColorValues as aL, type RelationshipThemeColors as aM, type LikeC4Theme as aN, type ViewRulePredicate as aO, isViewRulePredicate as aP, type ViewRuleStyle as aQ, isViewRuleStyle as aR, type AutoLayoutDirection as aS, type ViewRuleAutoLayout as aT, isViewRuleAutoLayout as aU, type ViewRule as aV, type BasicView as aW, type BasicElementView as aX, type ScopedElementView as aY, type ExtendsElementView as aZ, type ElementView as a_, type OutgoingExpr as aa, isOutgoing as ab, type RelationExpression as ac, isRelationExpression as ad, type RelationWhereExpr as ae, isRelationWhere as af, type CustomRelationExpr as ag, isCustomRelationExpr as ah, type RelationPredicateExpression as ai, isRelationPredicateExpr as aj, type Expression as ak, type ParsedLikeC4Model as al, type EqualOperator as am, type TagEqual as an, isTagEqual as ao, type KindEqual as ap, isKindEqual as aq, type NotOperator as ar, isNotOperator as as, type AndOperator as at, isAndOperator as au, type OrOperator as av, isOrOperator as aw, type WhereOperator as ax, whereOperatorAsPredicate as ay, OverviewGraph as az, type ComputedNode as b, type DynamicViewParallelSteps as b0, type DynamicViewStepOrParallel as b1, type DynamicViewIncludeRule as b2, isDynamicViewIncludeRule as b3, type DynamicViewRule as b4, type DynamicView as b5, isDynamicViewParallelSteps as b6, type CustomColorDefinitions as b7, type LikeC4View as b8, isDynamicView as b9, isElementView as ba, isExtendsElementView as bb, isScopedElementView as bc, type StepEdgeIdLiteral as bd, StepEdgeId as be, isStepEdgeId as bf, extractStep as bg, getParallelStepsPrefix as bh, type ViewWithHash as bi, type ViewWithNotation as bj, type ComputedElementView as bk, type ComputedDynamicView as bl, isComputedDynamicView as bm, isComputedElementView as bn, type BBox as bo, getBBoxCenter as bp, type ViewManualLayout as bq, ViewChange as br, type ElementNotation as bs, type ElementKind as c, type ElementShape as d, type Color as e, type ComputedEdge as f, type ComputedLikeC4Model as g, type Element as h, type Relation as i, type RelationshipKind as j, type DiagramNode as k, type DiagramEdge as l, type NonEmptyArray as m, expression as n, type NonEmptyReadonlyArray as o, type CustomColor as p, type BorderStyle as q, ElementShapes as r, DefaultThemeColor as s, DefaultElementShape as t, type ElementStyle as u, type TagSpec as v, type Link as w, type ElementKindSpecificationStyle as x, type ElementKindSpecification as y, type ElementRefExpr as z };