@likec4/core 1.10.1 → 1.12.0

package/dist/index.d.mts

@@ -1,5 +1,6 @@
-import { H as HexColorLiteral, T as ThemeColorValues, L as LiteralUnion, F as Fqn$1, R as RelationID$1, V as ViewID$1, E as EdgeId$1, C as ComputedView, a as Tag, b as ComputedNode, N as NodeId, c as ElementKind, d as ElementShape, e as Color, f as ComputedEdge, g as ComputedLikeC4Model, h as Element, i as Relation, j as RelationshipKind, k as NonEmptyArray } from './shared/core.Czd51Dd8.mjs';
-export { aq as AndOperator, A as AsFqn, aP as AutoLayoutDirection, bl as BBox, aU as BasicElementView, aT as BasicView, o as BorderStyle, B as BorderStyles, aE as ColorLiteral, bi as ComputedDynamicView, bh as ComputedElementView, n as CustomColor, b4 as CustomColorDefinitions, G as CustomElementExpr, ad as CustomRelationExpr, aA as DefaultArrowType, q as DefaultElementShape, az as DefaultLineStyle, aB as DefaultRelationshipColor, D as DefaultThemeColor, bo as DiagramEdge, bn as DiagramNode, bp as DiagramView, b2 as DynamicView, a$ as DynamicViewIncludeRule, aZ as DynamicViewParallelSteps, b1 as DynamicViewRule, aY as DynamicViewStep, a_ as DynamicViewStepOrParallel, U as ElementExpression, M as ElementKindExpr, v as ElementKindSpecification, u as ElementKindSpecificationStyle, bs as ElementNotation, $ as ElementPredicateExpression, w as ElementRefExpr, p as ElementShapes, r as ElementStyle, Q as ElementTagExpr, aG as ElementThemeColorValues, aH as ElementThemeColors, aX as ElementView, Z as ElementWhereExpr, aj as EqualOperator, y as ExpandedElementExpr, l as Expr, ah as Expression, aW as ExtendsElementView, I as IconUrl, a3 as InOutExpr, a5 as IncomingExpr, am as KindEqual, aK as LikeC4Theme, b5 as LikeC4View, t as Link, m as NonEmptyReadonlyArray, ao as NotOperator, as as OrOperator, a7 as OutgoingExpr, aw as OverviewGraph, ai as ParsedLikeC4Model, P as Point, a1 as RelationExpr, a9 as RelationExpression, af as RelationPredicateExpression, ab as RelationWhereExpr, ay as RelationshipArrowType, aC as RelationshipKindSpecification, ax as RelationshipLineType, aI as RelationshipThemeColorValues, aJ as RelationshipThemeColors, aV as ScopedElementView, bb as StepEdgeId, ba as StepEdgeIdLiteral, ak as TagEqual, s as TagSpec, aD as ThemeColor, br as ViewChange, bq as ViewManualLayout, aS as ViewRule, aQ as ViewRuleAutoLayout, aL as ViewRulePredicate, aN as ViewRuleStyle, bf as ViewWithHash, bg as ViewWithNotation, au as WhereOperator, W as WildcardExpr, X as XYPoint, bd as extractStep, bm as getBBoxCenter, be as getParallelStepsPrefix, ar as isAndOperator, bj as isComputedDynamicView, bk as isComputedElementView, J as isCustomElement, ae as isCustomRelationExpr, b6 as isDynamicView, b0 as isDynamicViewIncludeRule, b3 as isDynamicViewParallelSteps, Y as isElement, O as isElementKindExpr, a0 as isElementPredicateExpr, x as isElementRef, S as isElementTagExpr, b7 as isElementView, _ as isElementWhere, z as isExpandedElementExpr, b8 as isExtendsElementView, a4 as isInOut, a6 as isIncoming, an as isKindEqual, ap as isNotOperator, at as isOrOperator, a8 as isOutgoing, a2 as isRelation, aa as isRelationExpression, ag as isRelationPredicateExpr, ac as isRelationWhere, b9 as isScopedElementView, bc as isStepEdgeId, al as isTagEqual, aF as isThemeColor, aR as isViewRuleAutoLayout, aM as isViewRulePredicate, aO as isViewRuleStyle, K as isWildcard, av as whereOperatorAsPredicate } from './shared/core.Czd51Dd8.mjs';
+import { H as HexColorLiteral, T as ThemeColorValues, F as Fqn$1, R as RelationID$1, V as ViewID$1, E as EdgeId$1, C as ComputedView, a as Tag, b as ComputedNode, N as NodeId, c as ElementKind, d as ElementShape, e as Color, f as ComputedEdge, g as ComputedLikeC4Model, L as LayoutedLikeC4Model, h as Element, i as Relation, j as RelationshipKind, D as DiagramView, k as DiagramNode, l as DiagramEdge, m as NonEmptyArray } from './shared/core.Ik3-ZP2n.mjs';
+export { at as AndOperator, A as AsFqn, aS as AutoLayoutDirection, bq as BBox, aY as BasicElementView, aX as BasicView, q as BorderStyle, B as BorderStyles, aH as ColorLiteral, bn as ComputedDynamicView, bm as ComputedElementView, p as CustomColor, b8 as CustomColorDefinitions, M as CustomElementExpr, ag as CustomRelationExpr, aD as DefaultArrowType, t as DefaultElementShape, aC as DefaultLineStyle, aE as DefaultRelationshipColor, s as DefaultThemeColor, b6 as DynamicView, b3 as DynamicViewIncludeRule, b1 as DynamicViewParallelSteps, b5 as DynamicViewRule, b0 as DynamicViewStep, b2 as DynamicViewStepOrParallel, _ as ElementExpression, S as ElementKindExpr, y as ElementKindSpecification, x as ElementKindSpecificationStyle, bu as ElementNotation, a2 as ElementPredicateExpression, z as ElementRefExpr, r as ElementShapes, u as ElementStyle, Y as ElementTagExpr, aJ as ElementThemeColorValues, aK as ElementThemeColors, a$ as ElementView, a0 as ElementWhereExpr, am as EqualOperator, J as ExpandedElementExpr, n as Expr, ak as Expression, a_ as ExtendsElementView, I as IconUrl, a6 as InOutExpr, a8 as IncomingExpr, ap as KindEqual, aN as LikeC4Theme, b9 as LikeC4View, w as Link, o as NonEmptyReadonlyArray, ar as NotOperator, av as OrOperator, aa as OutgoingExpr, az as OverviewGraph, al as ParsedLikeC4Model, P as Point, a4 as RelationExpr, ac as RelationExpression, ai as RelationPredicateExpression, ae as RelationWhereExpr, aB as RelationshipArrowType, aF as RelationshipKindSpecification, aA as RelationshipLineType, aL as RelationshipThemeColorValues, aM as RelationshipThemeColors, aZ as ScopedElementView, bf as StepEdgeId, be as StepEdgeIdLiteral, an as TagEqual, v as TagSpec, aG as ThemeColor, bl as ViewAutoLayout, bt as ViewChange, bs as ViewManualLayout, aW as ViewRule, aU as ViewRuleAutoLayout, aO as ViewRulePredicate, aQ as ViewRuleStyle, bj as ViewWithHash, bk as ViewWithNotation, ax as WhereOperator, W as WildcardExpr, X as XYPoint, bh as extractStep, br as getBBoxCenter, bi as getParallelStepsPrefix, au as isAndOperator, aT as isAutoLayoutDirection, bo as isComputedDynamicView, bp as isComputedElementView, O as isCustomElement, ah as isCustomRelationExpr, ba as isDynamicView, b4 as isDynamicViewIncludeRule, b7 as isDynamicViewParallelSteps, $ as isElement, U as isElementKindExpr, a3 as isElementPredicateExpr, G as isElementRef, Z as isElementTagExpr, bb as isElementView, a1 as isElementWhere, K as isExpandedElementExpr, bc as isExtendsElementView, a7 as isInOut, a9 as isIncoming, aq as isKindEqual, as as isNotOperator, aw as isOrOperator, ab as isOutgoing, a5 as isRelation, ad as isRelationExpression, aj as isRelationPredicateExpr, af as isRelationWhere, bd as isScopedElementView, bg as isStepEdgeId, ao as isTagEqual, aI as isThemeColor, aV as isViewRuleAutoLayout, aP as isViewRulePredicate, aR as isViewRuleStyle, Q as isWildcard, ay as whereOperatorAsPredicate } from './shared/core.Ik3-ZP2n.mjs';
+import { LiteralUnion, IsNumericLiteral } from 'type-fest';
 
 declare const ElementColors: {
     readonly primary: {
@@ -267,19 +268,25 @@ 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 viewOf(): LikeC4Model.ElementModel<LikeC4ViewModel>;
     get tags(): Tag[];
     roots(): ReadonlyArray<LikeC4ViewModel.Element>;
     elements(): ReadonlyArray<LikeC4ViewModel.Element>;
@@ -287,23 +294,23 @@ declare class LikeC4ViewModel {
     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 {
     /**
@@ -322,7 +329,7 @@ declare namespace LikeC4ViewModel {
         get shape(): ElementShape;
         get color(): Color;
         get tags(): Tag[];
-        model(): LikeC4Model.Element;
+        model(): LikeC4Model.ElementModel<LikeC4ViewModel>;
         parent(): LikeC4ViewModel.Element | null;
         metadata(key: string): string | undefined;
         metadata(key: string, defaultValue: string): string;
@@ -333,8 +340,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>;
     }
     /**
@@ -352,98 +359,110 @@ declare namespace LikeC4ViewModel {
         /**
          * 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[], relations: Relation[]);
     /**
      * 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;
@@ -452,10 +471,43 @@ declare class LikeC4Model {
     private _internalOf;
 }
 declare namespace LikeC4Model {
-    class 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;
+        private model;
+        constructor(relationship: Relation, model: LikeC4Model<M>);
+        get id(): RelationID$1;
+        get title(): string;
+        get kind(): RelationshipKind;
+        get tags(): Tag[];
+        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;
         private model;
-        constructor(element: Element, model: LikeC4Model);
+        constructor(element: Element, model: LikeC4Model<M>);
         get id(): Fqn$1;
         get title(): string;
         get kind(): ElementKind;
@@ -464,37 +516,116 @@ declare namespace LikeC4Model {
         get shape(): ElementShape;
         get color(): Color;
         get tags(): Tag[];
-        parent(): LikeC4Model.Element | null;
+        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;
-        private model;
-        constructor(relationship: Relation, 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[];
+    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;
+        get kind(): ElementKind;
+        get isRoot(): boolean;
+        get hasNested(): boolean;
+        get shape(): ElementShape;
+        get color(): Color;
         get tags(): Tag[];
-        get source(): LikeC4Model.Element;
-        get target(): LikeC4Model.Element;
+        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[];
+        get color(): Color;
+        /**
+         * Model relationships
+         */
+        relationships(): ReadonlyArray<LikeC4Model.Relationship<LikeC4DiagramModel>>;
     }
 }
 
@@ -547,179 +678,6 @@ declare function sortNaturalByFqn<T extends {
     id: string;
 }, A extends IterableContainer$1<T>>(array: A): ReorderedArray<A>;
 
-/**
-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<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<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],
@@ -800,7 +758,9 @@ declare function hasAtLeast(minimum: number): (data: IterableContainer) => boole
 declare function isString(value: unknown): value is string;
 declare function isNonEmptyArray<A>(arr: ArrayLike<A> | undefined): arr is NonEmptyArray<A>;
 
-declare function delay(ms?: number): Promise<unknown>;
+declare function delay(): Promise<string>;
+declare function delay(ms: number): Promise<string>;
+declare function delay(randomFrom: number, randomTo: number): Promise<string>;
 
 /**
  * Compares two relations hierarchically.
@@ -811,4 +771,4 @@ declare const compareRelations: <T extends {
     target: string;
 }>(a: T, b: T) => 0 | 1 | -1;
 
-export { Color, ComputedEdge, ComputedLikeC4Model, ComputedNode, ComputedView, EdgeId$1 as EdgeId, Element, ElementColors, ElementKind, ElementShape, Fqn$1 as Fqn, HexColorLiteral, LikeC4Model, LikeC4ViewModel, NodeId, NonEmptyArray, Relation, RelationID$1 as RelationID, RelationshipColors, RelationshipKind, Tag, ThemeColorValues, ViewID$1 as ViewID, ancestorsFqn, commonAncestor, compareByFqnHierarchically, compareFqnHierarchically, compareNatural, compareRelations, computeColorValues, defaultTheme, delay, hasAtLeast, invariant, isAncestor, isDescendantOf, isNonEmptyArray, isSameHierarchy, isString, nameFromFqn, nonNullable, nonexhaustive, notDescendantOf, parentFqn, parentFqnPredicate, sortByFqnHierarchically, sortNaturalByFqn };
+export { Color, ComputedEdge, ComputedLikeC4Model, ComputedNode, ComputedView, DiagramEdge, DiagramNode, DiagramView, EdgeId$1 as EdgeId, Element, ElementColors, ElementKind, ElementShape, Fqn$1 as Fqn, HexColorLiteral, LayoutedLikeC4Model, LikeC4DiagramModel, LikeC4Model, LikeC4ViewModel, NodeId, NonEmptyArray, Relation, RelationID$1 as RelationID, RelationshipColors, RelationshipKind, Tag, ThemeColorValues, ViewID$1 as ViewID, ancestorsFqn, commonAncestor, compareByFqnHierarchically, compareFqnHierarchically, compareNatural, compareRelations, computeColorValues, defaultTheme, delay, hasAtLeast, invariant, isAncestor, isDescendantOf, isNonEmptyArray, isSameHierarchy, isString, nameFromFqn, nonNullable, nonexhaustive, notDescendantOf, parentFqn, parentFqnPredicate, sortByFqnHierarchically, sortNaturalByFqn };