likec4 1.10.1 → 1.12.0

package/dist/index.d.mts

@@ -1,168 +1,4 @@
-/**
-Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive).
-
-@category Type
-*/
-type Primitive$1 =
-	| 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$1,
-> = LiteralType | (BaseType & Record<never, never>);
-
-declare const tag$1: unique symbol;
-
-type TagContainer$1<Token> = {
-	readonly [tag$1]: Token;
-};
-
-type Tag$1$1<Token extends PropertyKey, TagMetadata> = TagContainer$1<{[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$1<Type, TagName extends PropertyKey, TagMetadata = never> = Type & Tag$1$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$1<PropertyKey, any>> =
-RemoveAllTags<TaggedType>;
-
-type RemoveAllTags<T> = T extends Tag$1$1<PropertyKey, any>
-	? {
-		[ThisTag in keyof T[typeof tag$1]]: T extends Tagged$1<infer Type, ThisTag, T[typeof tag$1][ThisTag]>
-			? RemoveAllTags<Type>
-			: never
-	}[keyof T[typeof tag$1]]
-	: T;
+import { LiteralUnion, Tagged, UnwrapTagged, IsNumericLiteral, SetRequired, ValueOf, ConditionalPick } from 'type-fest';
 
 declare const ThemeColors: readonly ["amber", "blue", "gray", "slate", "green", "indigo", "muted", "primary", "red", "secondary", "sky"];
 type ThemeColor$1 = typeof ThemeColors[number];
@@ -186,7 +22,7 @@ interface ThemeColorValues {
 }
 
 type NonEmptyArray<T> = [T, ...T[]];
-type IconUrl = Tagged$1<string, 'IconUrl'>;
+type IconUrl = Tagged<string, 'IconUrl'>;
 type CustomColor$1 = string;
 type Point = readonly [x: number, y: number];
 interface XYPoint {
@@ -194,17 +30,17 @@ interface XYPoint {
     y: number;
 }
 
-type Fqn$1 = Tagged$1<string, 'Fqn'>;
+type Fqn$1 = Tagged<string, 'Fqn'>;
 declare const BorderStyles: readonly ["solid", "dashed", "dotted", "none"];
 type BorderStyle = typeof BorderStyles[number];
-type ElementKind$1 = Tagged$1<string, 'ElementKind'>;
+type ElementKind$1 = Tagged<string, 'ElementKind'>;
 declare const ElementShapes: readonly ["rectangle", "person", "browser", "mobile", "cylinder", "storage", "queue"];
 type ElementShape$1 = typeof ElementShapes[number];
 interface ElementStyle {
     border?: BorderStyle;
     opacity?: number;
 }
-type Tag$2 = Tagged$1<string, 'Tag'>;
+type Tag$1 = Tagged<string, 'Tag'>;
 interface Link {
     readonly title?: string;
     readonly url: string;
@@ -216,7 +52,7 @@ interface Element$1 {
     readonly title: string;
     readonly description: string | null;
     readonly technology: string | null;
-    readonly tags: NonEmptyArray<Tag$2> | null;
+    readonly tags: NonEmptyArray<Tag$1> | null;
     readonly links: NonEmptyArray<Link> | null;
     readonly icon?: IconUrl;
     readonly shape?: ElementShape$1;
@@ -271,6 +107,135 @@ type OrOperator<Tag, Kind> = Omit<AllNever, 'or'> & {
 };
 type WhereOperator<Tag, Kind> = TagEqual<Tag> | KindEqual<Kind> | NotOperator<Tag, Kind> | AndOperator<Tag, Kind> | OrOperator<Tag, Kind>;
 
+type RelationID$1 = Tagged<string, 'RelationID'>;
+type RelationshipKind$1 = Tagged<string, '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 title: string;
+    readonly description?: string;
+    readonly technology?: string;
+    readonly tags?: NonEmptyArray<Tag$1>;
+    readonly kind?: RelationshipKind$1;
+    readonly color?: Color$1;
+    readonly line?: RelationshipLineType;
+    readonly head?: RelationshipArrowType;
+    readonly tail?: RelationshipArrowType;
+    readonly links?: NonEmptyArray<Link>;
+    readonly navigateTo?: ViewID$1;
+    readonly metadata?: {
+        [key: string]: string;
+    };
+}
+interface RelationshipKindSpecification {
+    readonly technology?: string;
+    readonly notation?: string;
+    readonly color?: Color$1;
+    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$1;
+    isDescedants?: boolean;
+}
+interface ExpandedElementExpr extends Omit<BaseExpr, 'expanded'> {
+    expanded: Fqn$1;
+}
+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 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$1;
+        notes?: string;
+        color?: Color$1;
+        line?: RelationshipLineType;
+        head?: RelationshipArrowType;
+        tail?: RelationshipArrowType;
+    };
+}
+type RelationPredicateExpression = RelationExpression$1 | RelationWhereExpr | CustomRelationExpr;
+type Expression$1 = ElementPredicateExpression | RelationPredicateExpression;
+
 type ElementNotation = {
     kinds: ElementKind$1[];
     shape: ElementShape$1;
@@ -278,7 +243,7 @@ type ElementNotation = {
     title: string;
 };
 
-type ViewID$1 = Tagged$1<string, 'ViewID'>;
+type ViewID$1 = Tagged<string, 'ViewID'>;
 type ViewRulePredicate$1 = {
     include: Expression$1[];
     exclude?: never;
@@ -297,7 +262,9 @@ interface ViewRuleStyle$1 {
 }
 type AutoLayoutDirection = 'TB' | 'BT' | 'LR' | 'RL';
 interface ViewRuleAutoLayout$1 {
-    autoLayout: AutoLayoutDirection;
+    direction: AutoLayoutDirection;
+    nodeSep?: number;
+    rankSep?: number;
 }
 type ViewRule$1 = ViewRulePredicate$1 | ViewRuleStyle$1 | ViewRuleAutoLayout$1;
 interface BasicView<ViewType extends 'element' | 'dynamic'> {
@@ -305,7 +272,7 @@ interface BasicView<ViewType extends 'element' | 'dynamic'> {
     readonly id: ViewID$1;
     readonly title: string | null;
     readonly description: string | null;
-    readonly tags: NonEmptyArray<Tag$2> | null;
+    readonly tags: NonEmptyArray<Tag$1> | null;
     readonly links: NonEmptyArray<Link> | null;
     /**
      * URI to the source file of this view.
@@ -371,10 +338,10 @@ type CustomColorDefinitions = {
     [key: string]: ThemeColorValues;
 };
 type LikeC4View$1 = ElementView$1 | DynamicView$1;
-type NodeId = Tagged$1<string, 'Fqn'>;
-type EdgeId$1 = Tagged$1<string, 'EdgeId'>;
+type NodeId = Tagged<string, 'Fqn'>;
+type EdgeId$1 = Tagged<string, 'EdgeId'>;
 type StepEdgeIdLiteral = `step-${number}` | `step-${number}.${number}`;
-type StepEdgeId = Tagged$1<StepEdgeIdLiteral, 'EdgeId'>;
+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;
@@ -386,7 +353,7 @@ interface ComputedNode {
     description: string | null;
     technology: string | null;
     notation?: string;
-    tags: NonEmptyArray<Tag$2> | null;
+    tags: NonEmptyArray<Tag$1> | null;
     links: NonEmptyArray<Link> | null;
     children: NodeId[];
     inEdges: EdgeId$1[];
@@ -425,7 +392,7 @@ interface ComputedEdge {
     line?: RelationshipLineType;
     head?: RelationshipArrowType;
     tail?: RelationshipArrowType;
-    tags?: NonEmptyArray<Tag$2>;
+    tags?: NonEmptyArray<Tag$1>;
     navigateTo?: ViewID$1;
     /**
      * If this edge is derived from custom relationship predicate
@@ -449,16 +416,21 @@ interface ViewWithNotation {
         elements: ElementNotation[];
     };
 }
+interface ViewAutoLayout {
+    direction: ViewRuleAutoLayout$1['direction'];
+    rankSep?: number;
+    nodeSep?: number;
+}
 interface ComputedElementView extends Omit<ElementView$1, 'rules' | 'docUri'>, ViewWithHash, ViewWithNotation {
     readonly extends?: ViewID$1;
-    readonly autoLayout: ViewRuleAutoLayout$1['autoLayout'];
+    readonly autoLayout: ViewAutoLayout;
     readonly nodes: ComputedNode[];
     readonly edges: ComputedEdge[];
     rules?: never;
     docUri?: never;
 }
 interface ComputedDynamicView extends Omit<DynamicView$1, 'rules' | 'steps' | 'docUri'>, ViewWithHash, ViewWithNotation {
-    readonly autoLayout: ViewRuleAutoLayout$1['autoLayout'];
+    readonly autoLayout: ViewAutoLayout;
     readonly nodes: ComputedNode[];
     readonly edges: ComputedEdge[];
     steps?: never;
@@ -502,7 +474,7 @@ type ViewManualLayout = {
     readonly y: number;
     readonly width: number;
     readonly height: number;
-    readonly autoLayout: AutoLayoutDirection;
+    readonly autoLayout: ViewAutoLayout;
     readonly nodes: Record<string, {
         isCompound: boolean;
         x: number;
@@ -518,153 +490,32 @@ type ViewManualLayout = {
     }>;
 };
 
-type RelationID$1 = Tagged$1<string, 'RelationID'>;
-type RelationshipKind$1 = Tagged$1<string, '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 title: string;
-    readonly description?: string;
-    readonly technology?: string;
-    readonly tags?: NonEmptyArray<Tag$2>;
-    readonly kind?: RelationshipKind$1;
-    readonly color?: Color$1;
-    readonly line?: RelationshipLineType;
-    readonly head?: RelationshipArrowType;
-    readonly tail?: RelationshipArrowType;
-    readonly links?: NonEmptyArray<Link>;
-    readonly navigateTo?: ViewID$1;
-    readonly metadata?: {
-        [key: string]: string;
+/**
+ * Parsed elements, relations, and views.
+ */
+interface ParsedLikeC4Model {
+    specification: {
+        tags: Tag$1[];
+        elements: Record<UnwrapTagged<ElementKind$1>, ElementKindSpecification>;
+        relationships: Record<UnwrapTagged<ElementKind$1>, RelationshipKindSpecification>;
     };
+    elements: Record<Fqn$1, Element$1>;
+    relations: Record<RelationID$1, Relation$1>;
+    views: Record<ViewID$1, LikeC4View$1>;
 }
-interface RelationshipKindSpecification {
-    readonly technology?: string;
-    readonly notation?: string;
-    readonly color?: Color$1;
-    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$1;
-    isDescedants?: boolean;
+/**
+ * Same as `ParsedLikeC4Model` but with computed views.
+ */
+interface ComputedLikeC4Model extends Omit<ParsedLikeC4Model, 'views'> {
+    __?: never;
+    views: Record<ViewID$1, ComputedView>;
 }
-interface ExpandedElementExpr extends Omit<BaseExpr, 'expanded'> {
-    expanded: Fqn$1;
-}
-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 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$2;
-    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$1;
-        notes?: string;
-        color?: Color$1;
-        line?: RelationshipLineType;
-        head?: RelationshipArrowType;
-        tail?: RelationshipArrowType;
-    };
-}
-type RelationPredicateExpression = RelationExpression$1 | RelationWhereExpr | CustomRelationExpr;
-type Expression$1 = ElementPredicateExpression | RelationPredicateExpression;
-
-/**
- * Parsed elements, relations, and views.
- */
-interface ParsedLikeC4Model {
-    specification: {
-        tags: Tag$2[];
-        elements: Record<UnwrapTagged<ElementKind$1>, ElementKindSpecification>;
-        relationships: Record<UnwrapTagged<ElementKind$1>, RelationshipKindSpecification>;
-    };
-    elements: Record<Fqn$1, Element$1>;
-    relations: Record<RelationID$1, Relation$1>;
-    views: Record<ViewID$1, LikeC4View$1>;
-}
-/**
- * Same as `ParsedLikeC4Model` but with computed views.
- */
-interface ComputedLikeC4Model extends Omit<ParsedLikeC4Model, 'views'> {
-    views: Record<ViewID$1, ComputedView>;
+/**
+ * Same as `ParsedLikeC4Model` but with layouted views (DiagramView)
+ */
+interface LayoutedLikeC4Model extends Omit<ParsedLikeC4Model, 'views'> {
+    __: 'layouted';
+    views: Record<ViewID$1, DiagramView>;
 }
 
 /**
@@ -993,43 +844,49 @@ 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;
+};
 
-type ElementOrFqn$1 = Fqn | LikeC4ViewModel.Element;
 /**
  * All methods are view-scoped, i.e. only return elements and connections in the view.
  */
 declare class LikeC4ViewModel {
-    #private;
     readonly view: ComputedView;
-    readonly model: LikeC4Model;
-    constructor(view: ComputedView, model: LikeC4Model);
+    readonly model: LikeC4Model<LikeC4ViewModel>;
+    private _rootElements;
+    private _elements;
+    private _connections;
+    constructor(view: ComputedView, model: LikeC4Model<LikeC4ViewModel>);
     get id(): ViewID$1;
     get title(): string;
-    get viewOf(): LikeC4Model.Element;
-    get tags(): Tag$2[];
+    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$1, target: ElementOrFqn$1, direction?: 'both' | 'direct'): ReadonlyArray<LikeC4ViewModel.Connection>;
-    parent(element: ElementOrFqn$1): LikeC4ViewModel.Element | null;
-    children(element: ElementOrFqn$1): ReadonlyArray<LikeC4ViewModel.Element>;
-    siblings(element: ElementOrFqn$1): ReadonlyArray<LikeC4ViewModel.Element>;
+    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$1): ReadonlyArray<LikeC4ViewModel.Element>;
-    descendants(element: ElementOrFqn$1): ReadonlyArray<LikeC4ViewModel.Element>;
-    incoming(element: ElementOrFqn$1, filter?: 'all' | 'direct' | 'to-descendants'): ReadonlyArray<LikeC4ViewModel.Connection>;
-    incomers(element: ElementOrFqn$1, filter?: 'all' | 'direct' | 'to-descendants'): ReadonlyArray<LikeC4ViewModel.Element>;
+    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$1, filter?: 'all' | 'direct' | 'from-descendants'): ReadonlyArray<LikeC4ViewModel.Connection>;
-    outgoers(element: ElementOrFqn$1, filter?: 'all' | 'direct' | 'from-descendants'): ReadonlyArray<LikeC4ViewModel.Element>;
+    outgoing(element: ElementOrFqn, filter?: OutgoingFilter): ReadonlyArray<LikeC4ViewModel.Connection>;
+    outgoers(element: ElementOrFqn, filter?: OutgoingFilter): ReadonlyArray<LikeC4ViewModel.Element>;
 }
 declare namespace LikeC4ViewModel {
     /**
@@ -1047,8 +904,8 @@ declare namespace LikeC4ViewModel {
         get hasNested(): boolean;
         get shape(): ElementShape$1;
         get color(): Color$1;
-        get tags(): Tag$2[];
-        model(): LikeC4Model.Element;
+        get tags(): Tag$1[];
+        model(): LikeC4Model.ElementModel<LikeC4ViewModel>;
         parent(): LikeC4ViewModel.Element | null;
         metadata(key: string): string | undefined;
         metadata(key: string, defaultValue: string): string;
@@ -1059,8 +916,8 @@ declare namespace LikeC4ViewModel {
         children(): ReadonlyArray<LikeC4ViewModel.Element>;
         incoming(filter?: 'all' | 'direct' | 'to-descendants'): ReadonlyArray<LikeC4ViewModel.Connection>;
         incomers(filter?: 'all' | 'direct' | 'to-descendants'): ReadonlyArray<LikeC4ViewModel.Element>;
-        outgoing(filter?: 'all' | 'direct' | 'from-descendants'): ReadonlyArray<LikeC4ViewModel.Connection>;
-        outgoers(filter?: 'all' | 'direct' | 'from-descendants'): ReadonlyArray<LikeC4ViewModel.Element>;
+        outgoing(filter?: OutgoingFilter): ReadonlyArray<LikeC4ViewModel.Connection>;
+        outgoers(filter?: OutgoingFilter): ReadonlyArray<LikeC4ViewModel.Element>;
         connectionsTo(target: Fqn | LikeC4ViewModel.Element): ReadonlyArray<LikeC4ViewModel.Connection>;
     }
     /**
@@ -1074,102 +931,114 @@ declare namespace LikeC4ViewModel {
         get id(): EdgeId$1;
         get source(): LikeC4ViewModel.Element;
         get target(): LikeC4ViewModel.Element;
-        get tags(): Tag$2[];
+        get tags(): Tag$1[];
         /**
          * Model relationships
          */
-        relationships(): ReadonlyArray<LikeC4Model.Relationship>;
+        relationships(): ReadonlyArray<LikeC4Model.Relationship<LikeC4ViewModel>>;
     }
 }
 
-type ElementOrFqn = Fqn | LikeC4Model.Element;
-declare class LikeC4Model {
-    #private;
-    protected computed: ComputedLikeC4Model;
-    static from(computed: ComputedLikeC4Model): LikeC4Model;
-    protected constructor(computed: ComputedLikeC4Model);
+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;
+    static create(source: LikeC4Model.SourceModel): PickBySource<typeof source>;
+    static computed(source: ComputedLikeC4Model): LikeC4Model<LikeC4ViewModel>;
+    static layouted(source: LayoutedLikeC4Model): LikeC4Model<LikeC4DiagramModel>;
+    protected constructor(type: LikeC4Model.ModelType<M>, sourcemodel: LikeC4Model.SourceModel<M>, elements: Element$1[], relations: Relation$1[]);
     /**
      * Returns the root elements of the model.
      */
-    roots(): ReadonlyArray<LikeC4Model.Element>;
+    roots(): ReadonlyArray<LikeC4Model.ElementModel<M>>;
     /**
      * Returns all elements in the model.
      */
-    elements(): ReadonlyArray<LikeC4Model.Element>;
+    elements(): ReadonlyArray<LikeC4Model.ElementModel<M>>;
     /**
      * Returns a specific element by its FQN.
      */
-    element(id: Fqn): LikeC4Model.Element;
+    element(id: Fqn): LikeC4Model.ElementModel<M>;
     /**
      * Returns all relationships in the model.
      */
-    relationships(): ReadonlyArray<LikeC4Model.Relationship>;
+    relationships(): ReadonlyArray<LikeC4Model.Relationship<M>>;
     /**
      * Returns a specific relationship by its ID.
      */
-    relationship(id: RelationID): LikeC4Model.Relationship;
+    relationship(id: RelationID): LikeC4Model.Relationship<M>;
     /**
      * Returns all views in the model.
      */
-    views(): ReadonlyArray<LikeC4ViewModel>;
+    views(): ReadonlyArray<M>;
     /**
      * Returns a specific view by its ID.
      */
-    view(viewId: ViewID): LikeC4ViewModel;
+    view(viewId: ViewID): M;
     /**
      * Returns the parent element of given element.
      * @see ancestors
      */
-    parent(element: ElementOrFqn): LikeC4Model.Element | null;
+    parent(element: ElementOrFqn): LikeC4Model.ElementModel<M> | null;
     /**
      * Get all children of the element (only direct children),
      * @see descendants
      */
-    children(element: ElementOrFqn): ReadonlyArray<LikeC4Model.Element>;
+    children(element: ElementOrFqn): ReadonlyArray<LikeC4Model.ElementModel<M>>;
     /**
      * Get all sibling (i.e. same parent)
      */
-    siblings(element: ElementOrFqn): ReadonlyArray<LikeC4Model.Element>;
+    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.Element>;
+    ancestors(element: ElementOrFqn): ReadonlyArray<LikeC4Model.ElementModel<M>>;
     /**
      * Get all descendant elements (i.e. children, children’s children, etc.)
      */
-    descendants(element: ElementOrFqn): ReadonlyArray<LikeC4Model.Element>;
+    descendants(element: ElementOrFqn): ReadonlyArray<LikeC4Model.ElementModel<M>>;
     /**
      * Incoming relationships to the element and its descendants
      * @see incomers
      */
-    incoming(element: ElementOrFqn, filter?: 'all' | 'direct' | 'to-descendants'): ReadonlyArray<LikeC4Model.Relationship>;
+    incoming(element: ElementOrFqn, filter?: IncomingFilter): ReadonlyArray<LikeC4Model.Relationship<M>>;
     /**
      * Source elements of incoming relationships
      */
-    incomers(element: ElementOrFqn, filter?: 'all' | 'direct' | 'to-descendants'): ReadonlyArray<LikeC4Model.Element>;
+    incomers(element: ElementOrFqn, filter?: IncomingFilter): ReadonlyArray<LikeC4Model.ElementModel<M>>;
     /**
      * Outgoing relationships from the element and its descendants
      * @see outgoers
      */
-    outgoing(element: ElementOrFqn, filter?: 'all' | 'direct' | 'from-descendants'): ReadonlyArray<LikeC4Model.Relationship>;
+    outgoing(element: ElementOrFqn, filter?: OutgoingFilter): ReadonlyArray<LikeC4Model.Relationship<M>>;
     /**
      * Target elements of outgoing relationships
      */
-    outgoers(element: ElementOrFqn, filter?: 'all' | 'direct' | 'from-descendants'): ReadonlyArray<LikeC4Model.Element>;
+    outgoers(element: ElementOrFqn, filter?: OutgoingFilter): ReadonlyArray<LikeC4Model.ElementModel<M>>;
     /**
      * Relationships inside the element, among descendants
      */
-    internal(element: ElementOrFqn): ReadonlyArray<LikeC4Model.Relationship>;
+    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.Element>;
+    ascendingSiblings(element: ElementOrFqn): ReadonlyArray<LikeC4Model.ElementModel<M>>;
     /**
      * Resolve all views that contain the element
      */
-    viewsWithElement(element: ElementOrFqn): ReadonlyArray<LikeC4ViewModel>;
+    viewsWithElement(element: ElementOrFqn): ReadonlyArray<M>;
     private addElement;
     private addRelation;
     private _childrenOf;
@@ -1178,10 +1047,43 @@ declare class LikeC4Model {
     private _internalOf;
 }
 declare namespace LikeC4Model {
-    class Element {
-        readonly element: Element;
+    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 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> {
+        readonly relationship: Relation$1;
+        private model;
+        constructor(relationship: Relation$1, model: LikeC4Model<M>);
+        get id(): RelationID$1;
+        get title(): string;
+        get kind(): RelationshipKind$1;
+        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> {
+        readonly element: Element$1;
         private model;
-        constructor(element: Element, model: LikeC4Model);
+        constructor(element: Element$1, model: LikeC4Model<M>);
         get id(): Fqn$1;
         get title(): string;
         get kind(): ElementKind$1;
@@ -1189,38 +1091,117 @@ declare namespace LikeC4Model {
         get hasNested(): boolean;
         get shape(): ElementShape$1;
         get color(): Color$1;
-        get tags(): Tag$2[];
-        parent(): LikeC4Model.Element | null;
+        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 Element[];
-        siblings(): readonly Element[];
-        descendants(): readonly Element[];
-        children(): readonly Element[];
+        ancestors(): readonly ElementModel<M>[];
+        siblings(): readonly ElementModel<M>[];
+        descendants(): readonly ElementModel<M>[];
+        children(): readonly ElementModel<M>[];
         /**
          * Views that contain this element
          */
-        views(): readonly LikeC4ViewModel[];
-        incoming(filter?: 'all' | 'direct' | 'to-descendants'): readonly Relationship[];
-        incomers(filter?: 'all' | 'direct' | 'to-descendants'): readonly Element[];
-        outgoing(filter?: 'all' | 'direct' | 'from-descendants'): readonly Relationship[];
-        outgoers(filter?: 'all' | 'direct' | 'from-descendants'): readonly Element[];
-        internal(): readonly Relationship[];
+        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>[];
     }
-    class Relationship {
-        readonly relationship: Relation$1;
-        private model;
-        constructor(relationship: Relation$1, model: LikeC4Model);
-        get id(): RelationID$1;
+}
+
+/**
+ * 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 _rootElements;
+    private _elements;
+    private _connections;
+    constructor(view: DiagramView, model: LikeC4Model.Layouted);
+    get isDynamic(): boolean;
+    get id(): ViewID$1;
+    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 view;
+        constructor(node: DiagramNode, view: LikeC4DiagramModel);
+        get id(): NodeId;
         get title(): string;
-        get kind(): RelationshipKind$1;
-        get tags(): Tag$2[];
-        get source(): LikeC4Model.Element;
-        get target(): LikeC4Model.Element;
+        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 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: Fqn$1): string;
@@ -1233,7 +1214,6 @@ declare function isSameHierarchy<E extends {
 declare function isDescendantOf<E extends {
     id: Fqn$1;
 }>(ancestors: E[]): (e: E) => boolean;
-declare function notDescendantOf(ancestors: Element$1[]): (e: Element$1) => boolean;
 declare function commonAncestor(first: Fqn$1, second: Fqn$1): Fqn$1;
 declare function parentFqn(fqn: Fqn$1): Fqn$1 | null;
 /**
@@ -1256,179 +1236,6 @@ declare function compareByFqnHierarchically<T extends {
     id: string;
 }>(a: T, b: T): 0 | 1 | -1;
 
-/**
-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;
-	}
-}
-
-type Numeric = number | bigint;
-
-/**
-Returns a boolean for whether the given type is `never`.
-
-@link https://github.com/microsoft/TypeScript/issues/31751#issuecomment-498526919
-@link https://stackoverflow.com/a/53984913/10292952
-@link https://www.zhenghao.io/posts/ts-never
-
-Useful in type utilities, such as checking if something does not occur.
-
-@example
-```
-import type {IsNever, And} from 'type-fest';
-
-// https://github.com/andnp/SimplyTyped/blob/master/src/types/strings.ts
-type AreStringsEqual<A extends string, B extends string> =
-	And<
-		IsNever<Exclude<A, B>> extends true ? true : false,
-		IsNever<Exclude<B, A>> extends true ? true : false
-	>;
-
-type EndIfEqual<I extends string, O extends string> =
-	AreStringsEqual<I, O> extends true
-		? never
-		: void;
-
-function endIfEqual<I extends string, O extends string>(input: I, output: O): EndIfEqual<I, O> {
-	if (input === output) {
-		process.exit(0);
-	}
-}
-
-endIfEqual('abc', 'abc');
-//=> never
-
-endIfEqual('abc', '123');
-//=> void
-```
-
-@category Type Guard
-@category Utilities
-*/
-type IsNever$1<T> = [T] extends [never] ? true : false;
-
-/**
-Returns a boolean for whether the given type `T` is the specified `LiteralType`.
-
-@link https://stackoverflow.com/a/52806744/10292952
-
-@example
-```
-LiteralCheck<1, number>
-//=> true
-
-LiteralCheck<number, number>
-//=> false
-
-LiteralCheck<1, string>
-//=> false
-```
-*/
-type LiteralCheck<T, LiteralType extends Primitive> = (
-	IsNever$1<T> extends false // Must be wider than `never`
-		? [T] extends [LiteralType & infer U] // Remove any branding
-			? [U] extends [LiteralType] // Must be narrower than `LiteralType`
-				? [LiteralType] extends [U] // Cannot be wider than `LiteralType`
-					? false
-					: true
-				: false
-			: false
-		: false
-);
-
-/**
-Returns a boolean for whether the given type `T` is one of the specified literal types in `LiteralUnionType`.
-
-@example
-```
-LiteralChecks<1, Numeric>
-//=> true
-
-LiteralChecks<1n, Numeric>
-//=> true
-
-LiteralChecks<bigint, Numeric>
-//=> false
-```
-*/
-type LiteralChecks<T, LiteralUnionType> = (
-	// Conditional type to force union distribution.
-	// If `T` is none of the literal types in the union `LiteralUnionType`, then `LiteralCheck<T, LiteralType>` will evaluate to `false` for the whole union.
-	// If `T` is one of the literal types in the union, it will evaluate to `boolean` (i.e. `true | false`)
-	IsNotFalse<LiteralUnionType extends Primitive
-		? LiteralCheck<T, LiteralUnionType>
-		: never
-	>
-);
-
-/**
-Returns a boolean for whether the given type is a `number` or `bigint` [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
-
-Useful for:
-	- providing strongly-typed functions when given literal arguments
-	- type utilities, such as when constructing parsers and ASTs
-
-@example
-```
-import type {IsNumericLiteral} from 'type-fest';
-
-// https://github.com/inocan-group/inferred-types/blob/master/src/types/boolean-logic/EndsWith.ts
-type EndsWith<TValue, TEndsWith extends string> =
-	TValue extends string
-		? IsStringLiteral<TEndsWith> extends true
-			? IsStringLiteral<TValue> extends true
-				? TValue extends `${string}${TEndsWith}`
-					? true
-					: false
-				: boolean
-			: boolean
-		: TValue extends number
-			? IsNumericLiteral<TValue> extends true
-				? EndsWith<`${TValue}`, TEndsWith>
-				: false
-			: false;
-
-function endsWith<Input extends string | number, End extends string>(input: Input, end: End) {
-	return `${input}`.endsWith(end) as EndsWith<Input, End>;
-}
-
-endsWith('abc', 'c');
-//=> true
-
-endsWith(123456, '456');
-//=> true
-
-const end = '123' as string;
-
-endsWith('abc123', end);
-//=> boolean
-```
-
-@category Type Guard
-@category Utilities
-*/
-type IsNumericLiteral<T> = LiteralChecks<T, Numeric>;
-
-/**
-Returns a boolean for whether the given `boolean` is not `false`.
-*/
-type IsNotFalse<T extends boolean> = [T] extends [false] ? false : true;
-
 /**
  * This should only be used for defining generics which extend any kind of JS
  * array under the hood, this includes arrays *AND* tuples (of the form [x, y],
@@ -4161,697 +3968,150 @@ type InlineValueContext = {
  */
 declare namespace InlineValueContext {
     /**
-     * Creates a new InlineValueContext literal.
-     */
-    function create(frameId: integer, stoppedLocation: Range$1): InlineValueContext;
-    /**
-     * Checks whether the given literal conforms to the {@link InlineValueContext} interface.
-     */
-    function is(value: any): value is InlineValueContext;
-}
-/**
- * Inlay hint kinds.
- *
- * @since 3.17.0
- */
-declare namespace InlayHintKind {
-    /**
-     * An inlay hint that for a type annotation.
-     */
-    const Type = 1;
-    /**
-     * An inlay hint that is for a parameter.
-     */
-    const Parameter = 2;
-    function is(value: number): value is InlayHintKind;
-}
-type InlayHintKind = 1 | 2;
-/**
- * An inlay hint label part allows for interactive and composite labels
- * of inlay hints.
- *
- * @since 3.17.0
- */
-type InlayHintLabelPart = {
-    /**
-     * The value of this label part.
-     */
-    value: string;
-    /**
-     * The tooltip text when you hover over this label part. Depending on
-     * the client capability `inlayHint.resolveSupport` clients might resolve
-     * this property late using the resolve request.
-     */
-    tooltip?: string | MarkupContent;
-    /**
-     * An optional source code location that represents this
-     * label part.
-     *
-     * The editor will use this location for the hover and for code navigation
-     * features: This part will become a clickable link that resolves to the
-     * definition of the symbol at the given location (not necessarily the
-     * location itself), it shows the hover that shows at the given location,
-     * and it shows a context menu with further code navigation commands.
-     *
-     * Depending on the client capability `inlayHint.resolveSupport` clients
-     * might resolve this property late using the resolve request.
-     */
-    location?: Location;
-    /**
-     * An optional command for this label part.
-     *
-     * Depending on the client capability `inlayHint.resolveSupport` clients
-     * might resolve this property late using the resolve request.
-     */
-    command?: Command;
-};
-declare namespace InlayHintLabelPart {
-    function create(value: string): InlayHintLabelPart;
-    function is(value: any): value is InlayHintLabelPart;
-}
-/**
- * Inlay hint information.
- *
- * @since 3.17.0
- */
-type InlayHint = {
-    /**
-     * The position of this hint.
-     */
-    position: Position$2;
-    /**
-     * The label of this hint. A human readable string or an array of
-     * InlayHintLabelPart label parts.
-     *
-     * *Note* that neither the string nor the label part can be empty.
-     */
-    label: string | InlayHintLabelPart[];
-    /**
-     * The kind of this hint. Can be omitted in which case the client
-     * should fall back to a reasonable default.
-     */
-    kind?: InlayHintKind;
-    /**
-     * Optional text edits that are performed when accepting this inlay hint.
-     *
-     * *Note* that edits are expected to change the document so that the inlay
-     * hint (or its nearest variant) is now part of the document and the inlay
-     * hint itself is now obsolete.
-     */
-    textEdits?: TextEdit$1[];
-    /**
-     * The tooltip text when you hover over this item.
-     */
-    tooltip?: string | MarkupContent;
-    /**
-     * Render padding before the hint.
-     *
-     * Note: Padding should use the editor's background color, not the
-     * background color of the hint itself. That means padding can be used
-     * to visually align/separate an inlay hint.
-     */
-    paddingLeft?: boolean;
-    /**
-     * Render padding after the hint.
-     *
-     * Note: Padding should use the editor's background color, not the
-     * background color of the hint itself. That means padding can be used
-     * to visually align/separate an inlay hint.
-     */
-    paddingRight?: boolean;
-    /**
-     * A data entry field that is preserved on an inlay hint between
-     * a `textDocument/inlayHint` and a `inlayHint/resolve` request.
-     */
-    data?: LSPAny;
-};
-declare namespace InlayHint {
-    function create(position: Position$2, label: string | InlayHintLabelPart[], kind?: InlayHintKind): InlayHint;
-    function is(value: any): value is InlayHint;
-}
-/**
- * A workspace folder inside a client.
- */
-interface WorkspaceFolder {
-    /**
-     * The associated URI for this workspace folder.
-     */
-    uri: URI$1;
-    /**
-     * The name of the workspace folder. Used to refer to this
-     * workspace folder in the user interface.
-     */
-    name: string;
-}
-declare namespace WorkspaceFolder {
-    function is(value: any): value is WorkspaceFolder;
-}
-
-/**
- * @hidden
- */
-type $keywords<T extends string> = {
-  [key in T]: key;
-};
-
-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;
-	}
-}
-
-/**
-Returns a boolean for whether the two given types are equal.
-
-@link https://github.com/microsoft/TypeScript/issues/27024#issuecomment-421529650
-@link https://stackoverflow.com/questions/68961864/how-does-the-equals-work-in-typescript/68963796#68963796
-
-Use-cases:
-- If you want to make a conditional branch based on the result of a comparison of two types.
-
-@example
-```
-import type {IsEqual} from 'type-fest';
-
-// This type returns a boolean for whether the given array includes the given item.
-// `IsEqual` is used to compare the given array at position 0 and the given item and then return true if they are equal.
-type Includes<Value extends readonly any[], Item> =
-	Value extends readonly [Value[0], ...infer rest]
-		? IsEqual<Value[0], Item> extends true
-			? true
-			: Includes<rest, Item>
-		: false;
-```
-
-@category Type Guard
-@category Utilities
-*/
-type IsEqual<A, B> =
-	(<G>() => G extends A ? 1 : 2) extends
-	(<G>() => G extends B ? 1 : 2)
-		? true
-		: false;
-
-/**
-Filter out keys from an object.
-
-Returns `never` if `Exclude` is strictly equal to `Key`.
-Returns `never` if `Key` extends `Exclude`.
-Returns `Key` otherwise.
-
-@example
-```
-type Filtered = Filter<'foo', 'foo'>;
-//=> never
-```
-
-@example
-```
-type Filtered = Filter<'bar', string>;
-//=> never
-```
-
-@example
-```
-type Filtered = Filter<'bar', 'foo'>;
-//=> 'bar'
-```
-
-@see {Except}
-*/
-type Filter<KeyType, ExcludeType> = IsEqual<KeyType, ExcludeType> extends true ? never : (KeyType extends ExcludeType ? never : KeyType);
-
-type ExceptOptions = {
-	/**
-	Disallow assigning non-specified properties.
-
-	Note that any omitted properties in the resulting type will be present in autocomplete as `undefined`.
-
-	@default false
-	*/
-	requireExactProps?: boolean;
-};
-
-/**
-Create a type from an object type without certain keys.
-
-We recommend setting the `requireExactProps` option to `true`.
-
-This type is a stricter version of [`Omit`](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-5.html#the-omit-helper-type). The `Omit` type does not restrict the omitted keys to be keys present on the given type, while `Except` does. The benefits of a stricter type are avoiding typos and allowing the compiler to pick up on rename refactors automatically.
-
-This type was proposed to the TypeScript team, which declined it, saying they prefer that libraries implement stricter versions of the built-in types ([microsoft/TypeScript#30825](https://github.com/microsoft/TypeScript/issues/30825#issuecomment-523668235)).
-
-@example
-```
-import type {Except} from 'type-fest';
-
-type Foo = {
-	a: number;
-	b: string;
-};
-
-type FooWithoutA = Except<Foo, 'a'>;
-//=> {b: string}
-
-const fooWithoutA: FooWithoutA = {a: 1, b: '2'};
-//=> errors: 'a' does not exist in type '{ b: string; }'
-
-type FooWithoutB = Except<Foo, 'b', {requireExactProps: true}>;
-//=> {a: number} & Partial<Record<"b", never>>
-
-const fooWithoutB: FooWithoutB = {a: 1, b: '2'};
-//=> errors at 'b': Type 'string' is not assignable to type 'undefined'.
-```
-
-@category Object
-*/
-type Except<ObjectType, KeysType extends keyof ObjectType, Options extends ExceptOptions = {requireExactProps: false}> = {
-	[KeyType in keyof ObjectType as Filter<KeyType, KeysType>]: ObjectType[KeyType];
-} & (Options['requireExactProps'] extends true
-	? Partial<Record<KeysType, never>>
-	: {});
-
-/**
-Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
-
-@example
-```
-import type {Simplify} from 'type-fest';
-
-type PositionProps = {
-	top: number;
-	left: number;
-};
-
-type SizeProps = {
-	width: number;
-	height: number;
-};
-
-// In your editor, hovering over `Props` will show a flattened object with all the properties.
-type Props = Simplify<PositionProps & SizeProps>;
-```
-
-Sometimes it is desired to pass a value as a function argument that has a different type. At first inspection it may seem assignable, and then you discover it is not because the `value`'s type definition was defined as an interface. In the following example, `fn` requires an argument of type `Record<string, unknown>`. If the value is defined as a literal, then it is assignable. And if the `value` is defined as type using the `Simplify` utility the value is assignable.  But if the `value` is defined as an interface, it is not assignable because the interface is not sealed and elsewhere a non-string property could be added to the interface.
-
-If the type definition must be an interface (perhaps it was defined in a third-party npm package), then the `value` can be defined as `const value: Simplify<SomeInterface> = ...`. Then `value` will be assignable to the `fn` argument.  Or the `value` can be cast as `Simplify<SomeInterface>` if you can't re-declare the `value`.
-
-@example
-```
-import type {Simplify} from 'type-fest';
-
-interface SomeInterface {
-	foo: number;
-	bar?: string;
-	baz: number | undefined;
-}
-
-type SomeType = {
-	foo: number;
-	bar?: string;
-	baz: number | undefined;
-};
-
-const literal = {foo: 123, bar: 'hello', baz: 456};
-const someType: SomeType = literal;
-const someInterface: SomeInterface = literal;
-
-function fn(object: Record<string, unknown>): void {}
-
-fn(literal); // Good: literal object type is sealed
-fn(someType); // Good: type is sealed
-fn(someInterface); // Error: Index signature for type 'string' is missing in type 'someInterface'. Because `interface` can be re-opened
-fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface` into a `type`
-```
-
-@link https://github.com/microsoft/TypeScript/issues/15300
-@see SimplifyDeep
-@category Object
-*/
-type Simplify<T> = {[KeyType in keyof T]: T[KeyType]} & {};
-
-/**
-Returns a boolean for whether the given type is `never`.
-
-@link https://github.com/microsoft/TypeScript/issues/31751#issuecomment-498526919
-@link https://stackoverflow.com/a/53984913/10292952
-@link https://www.zhenghao.io/posts/ts-never
-
-Useful in type utilities, such as checking if something does not occur.
-
-@example
-```
-import type {IsNever, And} from 'type-fest';
-
-// https://github.com/andnp/SimplyTyped/blob/master/src/types/strings.ts
-type AreStringsEqual<A extends string, B extends string> =
-	And<
-		IsNever<Exclude<A, B>> extends true ? true : false,
-		IsNever<Exclude<B, A>> extends true ? true : false
-	>;
-
-type EndIfEqual<I extends string, O extends string> =
-	AreStringsEqual<I, O> extends true
-		? never
-		: void;
-
-function endIfEqual<I extends string, O extends string>(input: I, output: O): EndIfEqual<I, O> {
-	if (input === output) {
-		process.exit(0);
-	}
-}
-
-endIfEqual('abc', 'abc');
-//=> never
-
-endIfEqual('abc', '123');
-//=> void
-```
-
-@category Type Guard
-@category Utilities
-*/
-type IsNever<T> = [T] extends [never] ? true : false;
-
-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>;
-
-/**
-Create a type that makes the given keys required. The remaining keys are kept as is. The sister of the `SetOptional` type.
-
-Use-case: You want to define a single model where the only thing that changes is whether or not some of the keys are required.
-
-@example
-```
-import type {SetRequired} from 'type-fest';
-
-type Foo = {
-	a?: number;
-	b: string;
-	c?: boolean;
-}
-
-type SomeRequired = SetRequired<Foo, 'b' | 'c'>;
-// type SomeRequired = {
-// 	a?: number;
-// 	b: string; // Was already required and still is.
-// 	c: boolean; // Is now required.
-// }
-```
-
-@category Object
-*/
-type SetRequired<BaseType, Keys extends keyof BaseType> =
-	// `extends unknown` is always going to be the case and is used to convert any
-	// union into a [distributive conditional
-	// type](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
-	BaseType extends unknown
-		? Simplify<
-		// Pick just the keys that are optional from the base type.
-		Except<BaseType, Keys> &
-		// Pick the keys that should be required from the base type and make them required.
-		Required<Pick<BaseType, Keys>>
-		>
-		: never;
-
-/**
-Create a union of the given object's values, and optionally specify which keys to get the values from.
-
-Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/31438) if you want to have this type as a built-in in TypeScript.
-
-@example
-```
-// data.json
-{
-	'foo': 1,
-	'bar': 2,
-	'biz': 3
-}
-
-// main.ts
-import type {ValueOf} from 'type-fest';
-import data = require('./data.json');
-
-export function getData(name: string): ValueOf<typeof data> {
-	return data[name];
-}
-
-export function onlyBar(name: string): ValueOf<typeof data, 'bar'> {
-	return data[name];
-}
-
-// file.ts
-import {getData, onlyBar} from './main';
-
-getData('foo');
-//=> 1
-
-onlyBar('foo');
-//=> TypeError ...
-
-onlyBar('bar');
-//=> 2
-```
-
-@category Object
-*/
-type ValueOf<ObjectType, ValueType extends keyof ObjectType = keyof ObjectType> = ObjectType[ValueType];
-
-/**
-An if-else-like type that resolves depending on whether the given type is `never`.
-
-@see {@link IsNever}
-
-@example
-```
-import type {IfNever} from 'type-fest';
-
-type ShouldBeTrue = IfNever<never>;
-//=> true
-
-type ShouldBeBar = IfNever<'not never', 'foo', 'bar'>;
-//=> 'bar'
-```
-
-@category Type Guard
-@category Utilities
-*/
-type IfNever<T, TypeIfNever = true, TypeIfNotNever = false> = (
-	IsNever<T> extends true ? TypeIfNever : TypeIfNotNever
-);
-
-/**
-Extract the keys from a type where the value type of the key extends the given `Condition`.
-
-Internally this is used for the `ConditionalPick` and `ConditionalExcept` types.
-
-@example
-```
-import type {ConditionalKeys} from 'type-fest';
-
-interface Example {
-	a: string;
-	b: string | number;
-	c?: string;
-	d: {};
+     * Creates a new InlineValueContext literal.
+     */
+    function create(frameId: integer, stoppedLocation: Range$1): InlineValueContext;
+    /**
+     * Checks whether the given literal conforms to the {@link InlineValueContext} interface.
+     */
+    function is(value: any): value is InlineValueContext;
 }
-
-type StringKeysOnly = ConditionalKeys<Example, string>;
-//=> 'a'
-```
-
-To support partial types, make sure your `Condition` is a union of undefined (for example, `string | undefined`) as demonstrated below.
-
-@example
-```
-import type {ConditionalKeys} from 'type-fest';
-
-type StringKeysAndUndefined = ConditionalKeys<Example, string | undefined>;
-//=> 'a' | 'c'
-```
-
-@category Object
-*/
-type ConditionalKeys<Base, Condition> =
-{
-	// Map through all the keys of the given base type.
-	[Key in keyof Base]-?:
-	// Pick only keys with types extending the given `Condition` type.
-	Base[Key] extends Condition
-	// Retain this key
-	// If the value for the key extends never, only include it if `Condition` also extends never
-		? IfNever<Base[Key], IfNever<Condition, Key, never>, Key>
-	// Discard this key since the condition fails.
-		: never;
-	// Convert the produced object into a union type of the keys which passed the conditional test.
-}[keyof Base];
-
 /**
-Pick keys from the shape that matches the given `Condition`.
-
-This is useful when you want to create a new type from a specific subset of an existing type. For example, you might want to pick all the primitive properties from a class and form a new automatically derived type.
-
-@example
-```
-import type {Primitive, ConditionalPick} from 'type-fest';
-
-class Awesome {
-	name: string;
-	successes: number;
-	failures: bigint;
-
-	run() {}
-}
-
-type PickPrimitivesFromAwesome = ConditionalPick<Awesome, Primitive>;
-//=> {name: string; successes: number; failures: bigint}
-```
-
-@example
-```
-import type {ConditionalPick} from 'type-fest';
-
-interface Example {
-	a: string;
-	b: string | number;
-	c: () => void;
-	d: {};
-}
-
-type StringKeysOnly = ConditionalPick<Example, string>;
-//=> {a: string}
-```
-
-@category Object
-*/
-type ConditionalPick<Base, Condition> = Pick<
-Base,
-ConditionalKeys<Base, Condition>
->;
-
-declare module 'ts-graphviz' {
-    namespace ClusterSubgraphAttributeKey {
-        interface $values extends $keywords<'likec4_type' | 'likec4_path' | 'likec4_id' | 'likec4_level' | 'likec4_depth'> {
-        }
-    }
-    namespace NodeAttributeKey {
-        interface $values extends $keywords<'likec4_type' | 'likec4_path' | 'likec4_id' | 'likec4_level'> {
-        }
-    }
-    namespace EdgeAttributeKey {
-        interface $values extends $keywords<'likec4_id'> {
-        }
-    }
-    namespace Attribute {
-        interface $keys extends $keywords<'likec4_type' | 'likec4_path' | 'likec4_id' | 'likec4_level' | 'likec4_depth'> {
-        }
-        interface $types {
-            likec4_type: 'folder' | 'file' | 'view';
-            likec4_path: string;
-            likec4_id: string;
-            likec4_level: number;
-            likec4_depth: number;
-        }
-    }
+ * Inlay hint kinds.
+ *
+ * @since 3.17.0
+ */
+declare namespace InlayHintKind {
+    /**
+     * An inlay hint that for a type annotation.
+     */
+    const Type = 1;
+    /**
+     * An inlay hint that is for a parameter.
+     */
+    const Parameter = 2;
+    function is(value: number): value is InlayHintKind;
 }
-type DotSource = Tagged<string, 'DotSource'>;
-type DotLayoutResult = {
-    dot: DotSource;
-    diagram: DiagramView;
+type InlayHintKind = 1 | 2;
+/**
+ * An inlay hint label part allows for interactive and composite labels
+ * of inlay hints.
+ *
+ * @since 3.17.0
+ */
+type InlayHintLabelPart = {
+    /**
+     * The value of this label part.
+     */
+    value: string;
+    /**
+     * The tooltip text when you hover over this label part. Depending on
+     * the client capability `inlayHint.resolveSupport` clients might resolve
+     * this property late using the resolve request.
+     */
+    tooltip?: string | MarkupContent;
+    /**
+     * An optional source code location that represents this
+     * label part.
+     *
+     * The editor will use this location for the hover and for code navigation
+     * features: This part will become a clickable link that resolves to the
+     * definition of the symbol at the given location (not necessarily the
+     * location itself), it shows the hover that shows at the given location,
+     * and it shows a context menu with further code navigation commands.
+     *
+     * Depending on the client capability `inlayHint.resolveSupport` clients
+     * might resolve this property late using the resolve request.
+     */
+    location?: Location;
+    /**
+     * An optional command for this label part.
+     *
+     * Depending on the client capability `inlayHint.resolveSupport` clients
+     * might resolve this property late using the resolve request.
+     */
+    command?: Command;
 };
-
-interface GraphvizPort {
-    unflatten(dot: DotSource): Promise<DotSource>;
-    acyclic(dot: DotSource): Promise<DotSource>;
-    layoutJson(dot: DotSource): Promise<string>;
-    svg(dot: DotSource): Promise<string>;
+declare namespace InlayHintLabelPart {
+    function create(value: string): InlayHintLabelPart;
+    function is(value: any): value is InlayHintLabelPart;
 }
-type LayoutResult = {
-    dot: DotSource;
-    diagram: DiagramView;
+/**
+ * Inlay hint information.
+ *
+ * @since 3.17.0
+ */
+type InlayHint = {
+    /**
+     * The position of this hint.
+     */
+    position: Position$2;
+    /**
+     * The label of this hint. A human readable string or an array of
+     * InlayHintLabelPart label parts.
+     *
+     * *Note* that neither the string nor the label part can be empty.
+     */
+    label: string | InlayHintLabelPart[];
+    /**
+     * The kind of this hint. Can be omitted in which case the client
+     * should fall back to a reasonable default.
+     */
+    kind?: InlayHintKind;
+    /**
+     * Optional text edits that are performed when accepting this inlay hint.
+     *
+     * *Note* that edits are expected to change the document so that the inlay
+     * hint (or its nearest variant) is now part of the document and the inlay
+     * hint itself is now obsolete.
+     */
+    textEdits?: TextEdit$1[];
+    /**
+     * The tooltip text when you hover over this item.
+     */
+    tooltip?: string | MarkupContent;
+    /**
+     * Render padding before the hint.
+     *
+     * Note: Padding should use the editor's background color, not the
+     * background color of the hint itself. That means padding can be used
+     * to visually align/separate an inlay hint.
+     */
+    paddingLeft?: boolean;
+    /**
+     * Render padding after the hint.
+     *
+     * Note: Padding should use the editor's background color, not the
+     * background color of the hint itself. That means padding can be used
+     * to visually align/separate an inlay hint.
+     */
+    paddingRight?: boolean;
+    /**
+     * A data entry field that is preserved on an inlay hint between
+     * a `textDocument/inlayHint` and a `inlayHint/resolve` request.
+     */
+    data?: LSPAny;
 };
-declare class GraphvizLayouter {
-    private graphviz;
-    constructor(graphviz: GraphvizPort);
-    get port(): GraphvizPort;
-    changePort(graphviz: GraphvizPort): void;
-    layout(view: ComputedView): Promise<LayoutResult>;
-    svg(view: ComputedView): Promise<{
-        svg: string;
-        dot: DotSource;
-    }>;
-    dot(computedView: ComputedView): Promise<DotSource>;
-    layoutOverviewGraph(views: ComputedView[]): Promise<OverviewGraph>;
+declare namespace InlayHint {
+    function create(position: Position$2, label: string | InlayHintLabelPart[], kind?: InlayHintKind): InlayHint;
+    function is(value: any): value is InlayHint;
+}
+/**
+ * A workspace folder inside a client.
+ */
+interface WorkspaceFolder {
+    /**
+     * The associated URI for this workspace folder.
+     */
+    uri: URI$1;
+    /**
+     * The name of the workspace folder. Used to refer to this
+     * workspace folder in the user interface.
+     */
+    name: string;
+}
+declare namespace WorkspaceFolder {
+    function is(value: any): value is WorkspaceFolder;
 }
 
 type ParserMethod<ARGS extends unknown[], R> = (...args: ARGS) => R;
@@ -15739,6 +14999,34 @@ interface ChangeViewRequestParams {
     change: ViewChange;
 }
 
+declare class LikeC4CodeLensProvider implements CodeLensProvider {
+    private services;
+    constructor(services: LikeC4Services);
+    provideCodeLens(doc: LangiumDocument, _params: CodeLensParams, cancelToken?: CancellationToken): Promise<CodeLens[] | undefined>;
+}
+
+declare class LikeC4CompletionProvider extends DefaultCompletionProvider {
+    readonly completionOptions: {
+        triggerCharacters: string[];
+    };
+    protected completionForKeyword(context: CompletionContext, keyword: Keyword, acceptor: CompletionAcceptor): MaybePromise<void>;
+}
+
+declare class LikeC4DocumentHighlightProvider extends DefaultDocumentHighlightProvider {
+    /**
+     * Override this method to determine the highlight kind of the given reference.
+     */
+    protected createDocumentHighlight(reference: ReferenceDescription): DocumentHighlight;
+}
+
+declare class LikeC4DocumentLinkProvider implements DocumentLinkProvider {
+    private services;
+    constructor(services: LikeC4Services);
+    getDocumentLinks(doc: LangiumDocument, _params: DocumentLinkParams): MaybePromise<DocumentLink[]>;
+    resolveLink(doc: LangiumDocument, link: string): string;
+    relativeLink(doc: LangiumDocument, link: string): string | null;
+}
+
 /******************************************************************************
  * This file was generated by langium-cli 3.2.0.
  * DO NOT EDIT MANUALLY!
@@ -16316,6 +15604,8 @@ interface ViewRuleAutoLayout extends AstNode {
     readonly $container: DynamicViewBody | ElementViewBody;
     readonly $type: 'ViewRuleAutoLayout';
     direction: ViewLayoutDirection;
+    nodeSep?: number;
+    rankSep?: number;
 }
 declare const ViewRuleAutoLayout = "ViewRuleAutoLayout";
 interface ViewRuleStyle extends AstNode {
@@ -16521,7 +15811,7 @@ type ParsedElementStyle = {
     opacity?: number;
 };
 interface ParsedAstSpecification {
-    tags: Set<Tag$2>;
+    tags: Set<Tag$1>;
     elements: Record<ElementKind$1, {
         technology?: string;
         notation?: string;
@@ -16546,7 +15836,7 @@ interface ParsedAstElement {
     title: string;
     description?: string;
     technology?: string;
-    tags?: NonEmptyArray<Tag$2>;
+    tags?: NonEmptyArray<Tag$1>;
     links?: NonEmptyArray<ParsedLink>;
     style: ParsedElementStyle;
     metadata?: {
@@ -16559,7 +15849,7 @@ interface ParsedAstRelation {
     source: Fqn$1;
     target: Fqn$1;
     kind?: RelationshipKind$1;
-    tags?: NonEmptyArray<Tag$2>;
+    tags?: NonEmptyArray<Tag$1>;
     title: string;
     description?: string;
     technology?: string;
@@ -16581,7 +15871,7 @@ interface ParsedAstElementView {
     astPath: string;
     title: string | null;
     description: string | null;
-    tags: NonEmptyArray<Tag$2> | null;
+    tags: NonEmptyArray<Tag$1> | null;
     links: NonEmptyArray<ParsedLink> | null;
     rules: ViewRule$1[];
     manualLayout?: ViewManualLayout;
@@ -16592,7 +15882,7 @@ interface ParsedAstDynamicView {
     astPath: string;
     title: string | null;
     description: string | null;
-    tags: NonEmptyArray<Tag$2> | null;
+    tags: NonEmptyArray<Tag$1> | null;
     links: NonEmptyArray<ParsedLink> | null;
     steps: DynamicViewStepOrParallel[];
     rules: Array<DynamicViewRule$1>;
@@ -16616,38 +15906,11 @@ interface LikeC4DocumentProps {
     c4Views?: ParsedAstView[];
     c4fqnIndex?: MultiMap<Fqn$1, DocFqnIndexAstNodeDescription>;
 }
-interface LikeC4LangiumDocument extends Omit<LangiumDocument<LikeC4Grammar>, 'diagnostics'>, LikeC4DocumentProps {
-}
-interface FqnIndexedDocument extends Omit<LangiumDocument<LikeC4Grammar>, 'diagnostics'>, SetRequired<LikeC4DocumentProps, 'c4fqnIndex'> {
-}
-interface ParsedLikeC4LangiumDocument extends Omit<LangiumDocument<LikeC4Grammar>, 'diagnostics'>, Required<LikeC4DocumentProps> {
-}
-
-declare class LikeC4CodeLensProvider implements CodeLensProvider {
-    private services;
-    constructor(services: LikeC4Services);
-    provideCodeLens(doc: LangiumDocument, _params: CodeLensParams, cancelToken?: CancellationToken): Promise<CodeLens[] | undefined>;
-}
-
-declare class LikeC4CompletionProvider extends DefaultCompletionProvider {
-    readonly completionOptions: {
-        triggerCharacters: string[];
-    };
-}
-
-declare class LikeC4DocumentHighlightProvider extends DefaultDocumentHighlightProvider {
-    /**
-     * Override this method to determine the highlight kind of the given reference.
-     */
-    protected createDocumentHighlight(reference: ReferenceDescription): DocumentHighlight;
+interface LikeC4LangiumDocument extends Omit<LangiumDocument<LikeC4Grammar>, 'diagnostics'>, LikeC4DocumentProps {
 }
-
-declare class LikeC4DocumentLinkProvider implements DocumentLinkProvider {
-    private services;
-    constructor(services: LikeC4Services);
-    getDocumentLinks(doc: LangiumDocument, _params: DocumentLinkParams): MaybePromise<DocumentLink[]>;
-    resolveLink(doc: LangiumDocument, link: string): string;
-    relativeLink(doc: LangiumDocument, link: string): string | null;
+interface FqnIndexedDocument extends Omit<LangiumDocument<LikeC4Grammar>, 'diagnostics'>, SetRequired<LikeC4DocumentProps, 'c4fqnIndex'> {
+}
+interface ParsedLikeC4LangiumDocument extends Omit<LangiumDocument<LikeC4Grammar>, 'diagnostics'>, Required<LikeC4DocumentProps> {
 }
 
 declare class LikeC4DocumentSymbolProvider implements DocumentSymbolProvider {
@@ -16680,6 +15943,98 @@ declare class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider
     private highlightAstElement;
     private highlightView;
 }
+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>;
+    /**
+     * Returns descedant elements with unique names in the scope
+     */
+    uniqueDescedants(parent: Fqn$1): Stream<AstNodeDescription>;
+}
+
+type ModelParsedListener$1 = (docs: URI[]) => void;
+declare class LikeC4ModelBuilder {
+    private services;
+    private langiumDocuments;
+    private listeners;
+    constructor(services: LikeC4Services);
+    /**
+     * WARNING:
+     * This method is internal and should to be called only when all documents are known to be parsed.
+     * Otherwise, the model may be incomplete.
+     */
+    unsafeSyncBuildModel(): ParsedLikeC4Model | null;
+    buildModel(cancelToken?: CancellationToken): Promise<ParsedLikeC4Model | null>;
+    private previousViews;
+    /**
+     * WARNING:
+     * This method is internal and should to be called only when all documents are known to be parsed.
+     * Otherwise, the model may be incomplete.
+     */
+    unsafeSyncBuildComputedModel(model: ParsedLikeC4Model): ComputedLikeC4Model;
+    buildComputedModel(cancelToken?: CancellationToken): Promise<ComputedLikeC4Model | null>;
+    computeView(viewId: ViewID$1, cancelToken?: CancellationToken): Promise<ComputedView | null>;
+    onModelParsed(callback: ModelParsedListener$1): Disposable;
+    private documents;
+    private notifyListeners;
+}
+
+declare class LikeC4ModelLocator {
+    private services;
+    private fqnIndex;
+    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): {
+        doc: ParsedLikeC4LangiumDocument;
+        view: ParsedAstView;
+        viewAst: LikeC4View;
+    };
+    locateView(viewId: ViewID$1): Location | null;
+}
+declare class LikeC4ModelParser {
+    private services;
+    private fqnIndex;
+    constructor(services: LikeC4Services);
+    parse(doc: LangiumDocument | LangiumDocument[]): ParsedLikeC4LangiumDocument[];
+    protected parseLikeC4Document(_doc: FqnIndexedDocument): ParsedLikeC4LangiumDocument;
+    private parseSpecification;
+    private parseModel;
+    private parseElement;
+    private parseRelation;
+    private parseViews;
+    private parseViewRulePredicate;
+    private parsePredicate;
+    private parseElementExpressionsIterator;
+    private parseElementPredicate;
+    private parseElementExpr;
+    private parseElementPredicateWith;
+    private parseElementPredicateWhere;
+    private parseRelationPredicate;
+    private parseRelationPredicateWhere;
+    private parseRelationPredicateWith;
+    private parseRelationExpr;
+    private parseViewRule;
+    private parseViewManualLaout;
+    private parseDynamicParallelSteps;
+    private parseDynamicStep;
+    private parseElementView;
+    private parseDynamicElementView;
+    protected resolveFqn(node: Element | ExtendElement): Fqn$1;
+    private getAstNodePath;
+    private getMetadata;
+    private convertTags;
+    private convertLinks;
+}
 
 declare class LikeC4ModelChanges {
     private services;
@@ -16797,97 +16152,63 @@ interface LikeC4AddedServices {
     shared?: LikeC4SharedServices;
 }
 type LikeC4Services = LangiumServices & LikeC4AddedServices;
-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>;
-    /**
-     * Returns descedant elements with unique names in the scope
-     */
-    uniqueDescedants(parent: Fqn$1): Stream<AstNodeDescription>;
-}
 
-type ModelParsedListener$1 = (docs: URI[]) => void;
-declare class LikeC4ModelBuilder {
-    private services;
-    private langiumDocuments;
-    private listeners;
-    constructor(services: LikeC4Services);
-    /**
-     * WARNING:
-     * This method is internal and should to be called only when all documents are known to be parsed.
-     * Otherwise, the model may be incomplete.
-     */
-    unsafeSyncBuildModel(): ParsedLikeC4Model | null;
-    buildModel(cancelToken?: CancellationToken): Promise<ParsedLikeC4Model | null>;
-    private previousViews;
-    /**
-     * WARNING:
-     * This method is internal and should to be called only when all documents are known to be parsed.
-     * Otherwise, the model may be incomplete.
-     */
-    unsafeSyncBuildComputedModel(model: ParsedLikeC4Model): ComputedLikeC4Model;
-    buildComputedModel(cancelToken?: CancellationToken): Promise<ComputedLikeC4Model | null>;
-    computeView(viewId: ViewID$1, cancelToken?: CancellationToken): Promise<ComputedView | null>;
-    onModelParsed(callback: ModelParsedListener$1): Disposable;
-    private documents;
-    private notifyListeners;
+/**
+ * @hidden
+ */
+type $keywords<T extends string> = {
+  [key in T]: key;
+};
+
+declare module 'ts-graphviz' {
+    namespace ClusterSubgraphAttributeKey {
+        interface $values extends $keywords<'likec4_type' | 'likec4_path' | 'likec4_id' | 'likec4_level' | 'likec4_depth'> {
+        }
+    }
+    namespace NodeAttributeKey {
+        interface $values extends $keywords<'likec4_type' | 'likec4_path' | 'likec4_id' | 'likec4_level'> {
+        }
+    }
+    namespace EdgeAttributeKey {
+        interface $values extends $keywords<'likec4_id'> {
+        }
+    }
+    namespace Attribute {
+        interface $keys extends $keywords<'likec4_type' | 'likec4_path' | 'likec4_id' | 'likec4_level' | 'likec4_depth'> {
+        }
+        interface $types {
+            likec4_type: 'folder' | 'file' | 'view';
+            likec4_path: string;
+            likec4_id: string;
+            likec4_level: number;
+            likec4_depth: number;
+        }
+    }
 }
+type DotSource = Tagged<string, 'DotSource'>;
 
-declare class LikeC4ModelLocator {
-    private services;
-    private fqnIndex;
-    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): {
-        doc: ParsedLikeC4LangiumDocument;
-        view: ParsedAstView;
-        viewAst: LikeC4View;
-    };
-    locateView(viewId: ViewID$1): Location | null;
+interface GraphvizPort {
+    unflatten(dot: DotSource): Promise<DotSource>;
+    acyclic(dot: DotSource): Promise<DotSource>;
+    layoutJson(dot: DotSource): Promise<string>;
+    svg(dot: DotSource): Promise<string>;
 }
-declare class LikeC4ModelParser {
-    private services;
-    private fqnIndex;
-    constructor(services: LikeC4Services);
-    parse(doc: LangiumDocument | LangiumDocument[]): ParsedLikeC4LangiumDocument[];
-    protected parseLikeC4Document(_doc: FqnIndexedDocument): ParsedLikeC4LangiumDocument;
-    private parseSpecification;
-    private parseModel;
-    private parseElement;
-    private parseRelation;
-    private parseViews;
-    private parseViewRulePredicate;
-    private parsePredicate;
-    private parseElementExpressionsIterator;
-    private parseElementPredicate;
-    private parseElementExpr;
-    private parseElementPredicateWith;
-    private parseElementPredicateWhere;
-    private parseRelationPredicate;
-    private parseRelationPredicateWhere;
-    private parseRelationPredicateWith;
-    private parseRelationExpr;
-    private parseViewRule;
-    private parseViewManualLaout;
-    private parseDynamicParallelSteps;
-    private parseDynamicStep;
-    private parseElementView;
-    private parseDynamicElementView;
-    protected resolveFqn(node: Element | ExtendElement): Fqn$1;
-    private getAstNodePath;
-    private getMetadata;
-    private convertTags;
-    private convertLinks;
+type LayoutResult = {
+    dot: DotSource;
+    diagram: DiagramView;
+};
+declare class GraphvizLayouter {
+    private graphviz;
+    constructor(graphviz: GraphvizPort);
+    get port(): GraphvizPort;
+    changePort(graphviz: GraphvizPort): void;
+    layout(view: ComputedView): Promise<LayoutResult>;
+    svg(view: ComputedView): Promise<{
+        svg: string;
+        dot: DotSource;
+    }>;
+    dot(computedView: ComputedView): Promise<DotSource>;
+    layoutOverviewGraph(views: ComputedView[]): Promise<OverviewGraph>;
 }
 
 // This definition file follows a somewhat unusual format. ESTree allows
@@ -17525,8 +16846,12 @@ type CliAddedServices = {
 type CliServices = LikeC4Services & CliAddedServices;
 
 type GraphvizOut = {
+    dot: string;
+    diagram: DiagramView;
+};
+type GraphvizSvgOut = {
     id: ViewID$1;
-    dot: DotSource;
+    dot: string;
     svg: string;
 };
 declare class Views {
@@ -17538,9 +16863,9 @@ declare class Views {
     constructor(services: CliServices);
     private inflightRequest;
     computedViews(): Promise<ComputedView[]>;
-    layoutViews(): Promise<Array<Readonly<DotLayoutResult>>>;
+    layoutViews(): Promise<Array<Readonly<GraphvizOut>>>;
     diagrams(): Promise<Array<DiagramView>>;
-    viewsAsGraphvizOut(): Promise<Array<GraphvizOut>>;
+    viewsAsGraphvizOut(): Promise<Array<GraphvizSvgOut>>;
     overviewGraph(): Promise<OverviewGraph>;
 }
 
@@ -17560,9 +16885,10 @@ type LikeC4Options = {
     throwIfInvalid?: boolean;
     /**
      * Logger to use for the language service.
+     * false - no output
      * @default 'default'
      */
-    logger?: Logger | 'vite' | 'default';
+    logger?: Logger | 'vite' | 'default' | false;
     /**
      * Whether to use the `dot` binary for layouting or the WebAssembly version.
      * @default 'wasm'
@@ -17578,19 +16904,37 @@ declare class LikeC4 {
      * Prevents multiple instances of LikeC4 for the same workspace
      */
     private static likec4Instances;
-    static fromWorkspace(path: string, opts?: LikeC4Options): Promise<LikeC4>;
-    private cachedModel;
+    /**
+     * Initializes a LikeC4 instance from the specified workspace path.
+     * By default in current folder
+     */
+    static fromWorkspace(path?: string, opts?: LikeC4Options): Promise<LikeC4>;
+    private modelComputedRef;
+    private modelLayoutedRef;
     private logger;
     private langiumDocuments;
     readonly views: Views;
     private constructor();
-    computed(): Promise<ComputedLikeC4Model>;
-    model(): LikeC4Model;
     /**
      * Diagram is a computed view, layouted using Graphviz
      * Used in React components
      */
     diagrams(): Promise<DiagramView[]>;
+    /**
+     * @deprecated use computedModel
+     */
+    model(): LikeC4Model.Computed;
+    /**
+     * Synchronously builds architecture model
+     * Only compute views predicates {@link ComputedView} - i.e. no layout
+     * Not ready for rendering, but enough to traverse
+     */
+    computedModel(): LikeC4Model.Computed;
+    /**
+     * Same as {@link computedModel()}, after applies layout
+     * Ready for rendering
+     */
+    layoutedModel(): Promise<LikeC4Model.Layouted>;
     getErrors(): {
         message: string;
         line: number;
@@ -17609,8 +16953,11 @@ declare class LikeC4 {
         changed?: string;
         removed?: string;
     }): Promise<boolean>;
+    /**
+     * @returns a function to dispose the listener
+     */
     onModelUpdate(listener: () => void): () => void;
     dispose(): void;
 }
 
-export { type AutoLayoutDirection, type BBox, BorderStyles, type Color$1 as Color, type ComputedDynamicView, type ComputedEdge, type ComputedElementView, type ComputedLikeC4Model, type ComputedNode, type ComputedView, type DiagramEdge, type DiagramNode, type DiagramView, type DynamicView$1 as DynamicView, type EdgeId$1 as EdgeId, type Element$1 as Element, ElementColors, type ElementKind$1 as ElementKind, ElementShapes, type ElementView$1 as ElementView, type Fqn$1 as Fqn, type HexColorLiteral, LikeC4, 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$2 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, notDescendantOf, parentFqn };
+export { type AutoLayoutDirection, type BBox, BorderStyles, type Color$1 as Color, type ComputedDynamicView, type ComputedEdge, type ComputedElementView, type ComputedLikeC4Model, type ComputedNode, type ComputedView, type DiagramEdge, type DiagramNode, type DiagramView, type DynamicView$1 as DynamicView, type EdgeId$1 as EdgeId, type Element$1 as Element, ElementColors, type ElementKind$1 as ElementKind, ElementShapes, type ElementView$1 as ElementView, type Fqn$1 as Fqn, type HexColorLiteral, type LayoutedLikeC4Model, LikeC4, 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 };