@likec4/core 1.18.0 → 1.19.1

package/dist/model/index.d.mts

@@ -1,642 +1,254 @@
-import { IsLiteral, LiteralUnion, Simplify, SetRequired } from 'type-fest';
-import { F as Fqn, b3 as ViewId, b as RelationId, bE as NodeId, bF as EdgeId, aD as AnyLikeC4Model, K as KeysOf, aE as LayoutedLikeC4Model, bY as DiagramView, a as ComputedView, aC as ParsedLikeC4ModelDump, R as Relation, Y as Tag, _ as Link, E as Element, O as ElementKind, f as ElementShape, aX as ThemeColor, t as DeploymentNodeKind, g as Color, bS as ComputedDynamicView, bH as StepEdgeId, bR as ComputedElementView, bT as ComputedDeploymentView, x as DeploymentRef, v as DeploymentNode, w as DeployedInstance, u as PhysicalElementStyle, k as DeploymentRelation } from '../shared/core.DMYY7C8s.mjs';
+import { E as ElementModel, D as DeploymentElementModel, A as AnyAux, f as DeploymentNodeModel, g as DeployedInstanceModel, R as RelationshipsAccum, h as RelationshipModel, i as DeploymentRelationModel } from '../shared/core.BZ9Msq7w.mjs';
+export { b as Aux, j as EdgeModel, L as LikeC4DeploymentModel, d as LikeC4Model, e as LikeC4ViewModel, N as NodeModel } from '../shared/core.BZ9Msq7w.mjs';
+import { F as Fqn, a as IteratorLike } from '../shared/core.D74xkKkG.mjs';
+import { I as IterableContainer, R as ReorderedArray } from '../shared/core.sLaWHBjR.mjs';
+import 'type-fest';
+import '../shared/core.CmYMqgha.mjs';
 
-type IncomingFilter = 'all' | 'direct' | 'to-descendants';
-type OutgoingFilter = 'all' | 'direct' | 'from-descendants';
-type IteratorLike<T> = IteratorObject<T, BuiltinIteratorReturn>;
-type WithId<Id> = {
-    id: Id;
-};
-type WithViews<Id extends string, ViewType> = {
-    views: Record<Id, ViewType>;
-};
-type AnyAux = Aux<string, string, string, any>;
-/**
- * Auxilary type to keep track
- */
-interface Aux<Element extends string, Deployment extends string, Views extends string, ViewType> {
-    Fqn: IsLiteral<Element> extends true ? Fqn<Element> : Fqn;
-    Element: Element;
-    ElementOrFqn: Element | WithId<this['Fqn']>;
-    DeploymentFqn: IsLiteral<Deployment> extends true ? Fqn<Deployment> : Fqn;
-    Deployment: Deployment;
-    DeploymentOrFqn: Deployment | WithId<this['DeploymentFqn']>;
-    ViewId: IsLiteral<Views> extends true ? ViewId<Views> : ViewId;
-    ViewIdLiteral: Views;
-    ViewType: ViewType;
-    RelationId: RelationId;
-    NodeId: NodeId;
-    NodeIdLiteral: string;
-    EdgeId: EdgeId;
-    EdgeIdLiteral: string;
-    NodeOrId: LiteralUnion<this['NodeIdLiteral'], string> | WithId<this['NodeId']>;
-    EdgeOrId: LiteralUnion<this['EdgeIdLiteral'], string> | WithId<this['EdgeId']>;
-    Model: Simplify<Omit<AnyLikeC4Model, 'views'> & WithViews<this['ViewId'], ViewType>>;
-}
-declare namespace Aux {
-    type FromModel<M> = M extends AnyLikeC4Model ? Aux<KeysOf<M['elements']>, KeysOf<M['deployments']['elements']>, KeysOf<M['views']>, M extends LayoutedLikeC4Model ? DiagramView<ViewId<KeysOf<M['views']>>, string> : ComputedView<ViewId<KeysOf<M['views']>>, string>> : never;
-    type FromDump<M> = M extends ParsedLikeC4ModelDump ? Aux<KeysOf<M['elements']>, KeysOf<M['deployments']['elements']>, KeysOf<M['views']>, DiagramView<ViewId<KeysOf<M['views']>>, string>> : never;
-}
-
-type RelationshipsIterator<M extends AnyAux> = IteratorLike<RelationshipModel<M>>;
-declare class RelationshipModel<M extends AnyAux> {
-    readonly model: LikeC4Model<M>;
-    readonly $relationship: Relation;
-    readonly source: ElementModel<M>;
-    readonly target: ElementModel<M>;
+interface Connection<Elem = ElementModel | DeploymentElementModel, Id = string> {
+    readonly id: Id;
+    readonly source: Elem;
+    readonly target: Elem;
     /**
      * Common ancestor of the source and target elements.
-     * Represents the boundary of the Relation.
-     */
-    readonly boundary: ElementModel<M> | null;
-    constructor(model: LikeC4Model<M>, $relationship: Relation);
-    get id(): M['RelationId'];
-    get expression(): string;
-    get title(): string | null;
-    get technology(): string | null;
-    get description(): string | null;
-    get navigateTo(): LikeC4ViewModel<M> | null;
-    get tags(): ReadonlyArray<Tag>;
-    get links(): ReadonlyArray<Link>;
-    /**
-     * Iterate over all views that include this relationship.
-     */
-    views(): ViewsIterator<M>;
-}
-
-type ElementsIterator<M extends AnyAux> = IteratorLike<ElementModel<M>>;
-declare class ElementModel<M extends AnyAux> {
-    readonly model: LikeC4Model<M>;
-    readonly $element: Element;
-    constructor(model: LikeC4Model<M>, $element: Element);
-    get id(): M['Fqn'];
-    get kind(): ElementKind;
-    get shape(): ElementShape;
-    get color(): ThemeColor;
-    get tags(): ReadonlyArray<Tag>;
-    get title(): string;
-    get description(): string | null;
-    get technology(): string | null;
-    get links(): ReadonlyArray<Link>;
-    get parent(): ElementModel<M> | null;
-    get defaultView(): LikeC4ViewModel<M> | null;
-    /**
-     * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
-     * (from closest to root)
-     */
-    ancestors(): ElementsIterator<M>;
-    /**
-     * Returns the common ancestor of this element and another element.
-     */
-    commonAncestor(another: ElementModel<M>): ElementModel<M> | null;
-    children(): ReadonlySet<ElementModel<M>>;
-    /**
-     * Get all descendant elements (i.e. children, children’s children, etc.)
-     */
-    descendants(): ElementsIterator<M>;
-    /**
-     * Get all sibling (i.e. same parent)
-     */
-    siblings(): ElementsIterator<M>;
-    /**
-     * Resolve siblings of the element and its ancestors
-     *  (from closest to root)
-     */
-    ascendingSiblings(): ElementsIterator<M>;
-    incoming(filter?: IncomingFilter): RelationshipsIterator<M>;
-    incomers(filter?: IncomingFilter): ElementsIterator<M>;
-    outgoing(filter?: OutgoingFilter): RelationshipsIterator<M>;
-    outgoers(filter?: OutgoingFilter): ElementsIterator<M>;
-    protected cachedOutgoing: Set<RelationshipModel<M>> | null;
-    protected cachedIncoming: Set<RelationshipModel<M>> | null;
-    get allOutgoing(): ReadonlySet<RelationshipModel<M>>;
-    get allIncoming(): ReadonlySet<RelationshipModel<M>>;
-    /**
-     * Iterate over all views that include this element.
-     */
-    views(): ViewsIterator<M>;
-    /**
-     * Iterate over all views that scope this element.
-     * It is possible that element is not included in the view.
-     */
-    scopedViews(): ViewsIterator<M>;
-    /**
-     * @returns true if the element is deployed
-     */
-    isDeployed(): boolean;
-    deployments(): DeployedInstancesIterator<M>;
-}
-
-type NodesIterator<M extends AnyAux, V extends ComputedView | DiagramView> = IteratorLike<NodeModel<M, V>>;
-declare namespace NodeModel {
-    interface WithParent<M extends AnyAux, V extends ComputedView | DiagramView> extends NodeModel<M, V> {
-        parent: NodeModel<M, V>;
-    }
-    interface WithElement<M extends AnyAux, V extends ComputedView | DiagramView> extends NodeModel<M, V> {
-        kind: ElementKind;
-        element: ElementModel<M>;
-    }
-    interface WithDeploymentElement<M extends AnyAux, V extends ComputedView | DiagramView> extends NodeModel<M, V> {
-        kind: DeploymentNodeKind;
-        deployment: DeploymentElementModel<M>;
-    }
-    interface WithDeployedInstance<M extends AnyAux, V extends ComputedView | DiagramView> extends NodeModel<M, V> {
-        kind: 'instance';
-        element: ElementModel<M>;
-        deployment: DeployedInstanceModel<M>;
-    }
-    interface IsGroup<M extends AnyAux, V extends ComputedView | DiagramView> extends NodeModel<M, V> {
-        kind: typeof ElementKind.Group;
-        element: null;
-        deployment: null;
-    }
-}
-declare class NodeModel<M extends AnyAux, V extends ComputedView | DiagramView = M['ViewType']> {
-    readonly $view: LikeC4ViewModel<M, V>;
-    readonly $node: V['nodes'][number];
-    constructor($view: LikeC4ViewModel<M, V>, $node: V['nodes'][number]);
-    get id(): NodeId;
-    get title(): string;
-    get kind(): ElementKind | DeploymentNodeKind | typeof ElementKind.Group | 'instance';
-    get description(): string | null;
-    get technology(): string | null;
-    get parent(): NodeModel<M, V> | null;
-    get element(): ElementModel<M> | null;
-    get deployment(): DeploymentElementModel<M> | null;
-    get shape(): ElementShape;
-    get color(): Color;
-    get tags(): ReadonlyArray<Tag>;
-    get links(): ReadonlyArray<Link>;
-    get navigateTo(): LikeC4ViewModel<M> | null;
-    /**
-     * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
-     * (from closest to root)
-     */
-    ancestors(): NodesIterator<M, V>;
-    children(): NodesIterator<M, V>;
-    sublings(): NodesIterator<M, V>;
-    incoming(filter?: IncomingFilter): EdgesIterator<M, V>;
-    incomers(filter?: IncomingFilter): NodesIterator<M, V>;
-    outgoing(filter?: OutgoingFilter): EdgesIterator<M, V>;
-    outgoers(filter?: OutgoingFilter): NodesIterator<M, V>;
-    isDiagramNode(): this is NodeModel<M, DiagramView>;
-    hasChildren(): boolean;
-    hasParent(): this is NodeModel.WithParent<M, V>;
-    /**
-     * Check if this node references to logical model element.
-     */
-    hasElement(): this is NodeModel.WithElement<M, V>;
-    /**
-     * Check if this node references to deployment element (Node or Instance).
-     */
-    hasDeployment(): this is NodeModel.WithDeploymentElement<M, V>;
-    /**
-     * Check if this node references to deployed instance
-     * Deployed instance always references to element and deployment element.
-     */
-    hasDeployedInstance(): this is NodeModel.WithDeployedInstance<M, V>;
-    isGroup(): this is NodeModel.IsGroup<M, V>;
+     * Represents the boundary of the connection.
+     */
+    readonly boundary: Elem | null;
+    /**
+     * Human readable expression of the connection
+     * Mostly used for testing and debugging
+     */
+    readonly expression: string;
+    mergeWith(this: Connection<Elem, Id>, other: typeof this): typeof this;
+    nonEmpty(): boolean;
+    difference(this: Connection<Elem, Id>, other: typeof this): typeof this;
+    intersect(this: Connection<Elem, Id>, other: typeof this): typeof this;
+    equals(other: Connection): boolean;
+}
+declare namespace Connection {
+    type ConnectionPredicate = <C extends Connection<{
+        id: string;
+    }, any>>(connection: C) => boolean;
+    type ElementId = Fqn | string;
+    export const isInside: (fqn: ElementId) => ConnectionPredicate;
+    export const isDirectedBetween: (source: ElementId, target: ElementId) => ConnectionPredicate;
+    export const isAnyBetween: (source: ElementId, target: ElementId) => ConnectionPredicate;
+    export const isIncoming: (target: ElementId) => ConnectionPredicate;
+    export const isOutgoing: (source: ElementId) => ConnectionPredicate;
+    export const isAnyInOut: (source: ElementId) => ConnectionPredicate;
+    export {  };
 }
 
-type EdgesIterator<M extends AnyAux, V extends ComputedView | DiagramView> = IteratorLike<EdgeModel<M, V>>;
-declare class EdgeModel<M extends AnyAux, V extends ComputedView | DiagramView = M['ViewType']> {
-    readonly view: LikeC4ViewModel<M, V>;
-    readonly $edge: V['edges'][number];
-    readonly source: NodeModel<M, V>;
-    readonly target: NodeModel<M, V>;
-    constructor(view: LikeC4ViewModel<M, V>, $edge: V['edges'][number], source: NodeModel<M, V>, target: NodeModel<M, V>);
-    get id(): M['EdgeId'];
-    get parent(): NodeModel<M, V> | null;
-    get label(): string | null;
-    get description(): string | null;
-    get technology(): string | null;
-    hasParent(): this is EdgeModel.WithParent<M, V>;
-    get tags(): ReadonlyArray<Tag>;
-    get stepNumber(): number | null;
-    get navigateTo(): LikeC4ViewModel<M> | null;
-    isStep(): this is EdgeModel.StepEdge<M, ComputedDynamicView>;
-    relationships(type: 'model'): IteratorLike<RelationshipModel<M>>;
-    relationships(type: 'deployment'): IteratorLike<DeploymentRelationModel<M>>;
-    relationships(type?: 'model' | 'deployment'): IteratorLike<LikeC4Model.AnyRelation<M>>;
-    includesRelation(rel: M['RelationId']): boolean;
-}
-declare namespace EdgeModel {
-    interface StepEdge<M extends AnyAux, V extends ComputedView | DiagramView> extends EdgeModel<M, V> {
-        id: StepEdgeId;
-        stepNumber: number;
-    }
-    interface WithParent<M extends AnyAux, V extends ComputedView | DiagramView> extends EdgeModel<M, V> {
-        parent: NodeModel<M, V>;
-    }
-}
+declare const customInspectSymbol: unique symbol;
 
-type ViewsIterator<M extends AnyAux> = IteratorLike<LikeC4ViewModel<M>>;
-declare class LikeC4ViewModel<M extends AnyAux, V extends ComputedView | DiagramView = M['ViewType']> {
-    #private;
-    readonly $model: LikeC4Model<M>;
-    readonly $view: V;
-    constructor($model: LikeC4Model<M>, $view: V);
-    get __(): NonNullable<M['ViewType']['__']>;
-    get id(): M['ViewId'];
-    get title(): string | null;
-    get tags(): ReadonlyArray<Tag>;
-    get links(): ReadonlyArray<Link>;
-    get viewOf(): ElementModel<M> | null;
-    /**
-     * All tags from nodes and edges.
-     */
-    get includedTags(): ReadonlyArray<Tag>;
-    roots(): NodesIterator<M, V>;
-    /**
-     * Iterate over all nodes that have children.
-     */
-    compounds(): NodesIterator<M, V>;
-    /**
-     * Get node by id.
-     * @throws Error if node is not found.
-     */
-    node(node: M['NodeOrId']): NodeModel<M, V>;
-    /**
-     * Find node by id.
-     */
-    findNode(node: M['NodeOrId']): NodeModel<M, V> | null;
-    /**
-     * Iterate over all nodes.
-     */
-    nodes(): NodesIterator<M, V>;
-    /**
-     * Find edge by id.
-     * @param edge Edge or id
-     * @returns EdgeModel
-     */
-    edge(edge: M['EdgeOrId']): EdgeModel<M, V>;
-    findEdge(edge: M['EdgeOrId']): EdgeModel<M, V> | null;
-    /**
-     * Iterate over all edges.
-     */
-    edges(): EdgesIterator<M, V>;
-    /**
-     * Iterate over all edges.
-     */
-    edgesWithRelation(relation: M['RelationId']): EdgesIterator<M, V>;
-    /**
-     * Nodes that have references to elements from logical model.
-     */
-    elements(): IteratorLike<NodeModel.WithElement<M, V>>;
-    includesElement(elementId: M['Element']): boolean;
-    includesDeployment(deploymentId: M['Deployment']): boolean;
-    includesRelation(relationId: M['RelationId']): boolean;
-    /**
-     * Below are type guards.
-     */
-    isComputed(): this is LikeC4ViewModel<M, ComputedView>;
-    isDiagram(): this is LikeC4ViewModel<M, DiagramView>;
-    isElementView(): this is LikeC4ViewModel<M, ComputedElementView>;
-    isDeploymentView(): this is LikeC4ViewModel<M, ComputedDeploymentView>;
-    isDynamicView(): this is LikeC4ViewModel<M, ComputedDynamicView>;
-}
-
-declare class LikeC4DeploymentModel<M extends AnyAux = AnyAux> {
-    #private;
-    readonly $model: LikeC4Model<M>;
-    readonly $deployments: AnyLikeC4Model['deployments'];
-    constructor($model: LikeC4Model<M>, $deployments: AnyLikeC4Model['deployments']);
-    element(el: M['DeploymentOrFqn']): DeploymentElementModel<M>;
-    findElement(el: M['Deployment']): DeploymentElementModel<M> | null;
-    node(el: M['DeploymentOrFqn']): DeploymentNodeModel<M>;
-    findNode(el: M['Deployment']): DeploymentNodeModel<M> | null;
-    instance(el: M['DeploymentOrFqn']): DeployedInstanceModel<M>;
-    findInstance(el: M['Deployment']): DeployedInstanceModel<M> | null;
-    /**
-     * Returns the root elements of the model.
-     */
-    roots(): DeploymentNodesIterator<M>;
-    /**
-     * Returns all elements in the model.
-     */
-    elements(): DeploymentElementsIterator<M>;
-    /**
-     * Returns all elements in the model.
-     */
-    nodes(): DeploymentNodesIterator<M>;
-    instances(): DeployedInstancesIterator<M>;
-    /**
-     * Iterate over all instances of the given logical element.
-     */
-    instancesOf(element: M['ElementOrFqn']): DeployedInstancesIterator<M>;
-    deploymentRef(ref: DeploymentRef): DeploymentElementModel<M> | NestedElementOfDeployedInstanceModel<M>;
-    /**
-     * Returns all relationships in the model.
-     */
-    relationships(): IteratorLike<DeploymentRelationModel<M>>;
-    /**
-     * Returns a specific relationship by its ID.
-     */
-    relationship(id: M['RelationId']): DeploymentRelationModel<M>;
-    findRelationship(id: LiteralUnion<M['RelationId'], string>): DeploymentRelationModel<M> | null;
-    /**
-     * Returns all deployment views in the model.
-     */
-    views(): IteratorLike<LikeC4ViewModel<M, ComputedDeploymentView>>;
-    /**
-     * Returns the parent element of given element.
-     * @see ancestors
-     */
-    parent(element: M['DeploymentOrFqn']): DeploymentNodeModel<M> | null;
-    /**
-     * Get all children of the element (only direct children),
-     * @see descendants
-     */
-    children(element: M['DeploymentOrFqn']): ReadonlySet<DeploymentElementModel<M>>;
+/**
+ * Connection is ephemeral entity, result of a resolving relationships between source and target.
+ * Includes direct relationships and/or between their nested elements.
+ */
+declare class DeploymentConnectionModel<M extends AnyAux = AnyAux> implements Connection<DeploymentElementModel<M>, M['EdgeId']> {
+    readonly source: DeploymentNodeModel<M> | DeployedInstanceModel<M>;
+    readonly target: DeploymentNodeModel<M> | DeployedInstanceModel<M>;
+    readonly relations: RelationshipsAccum<M>;
+    constructor(source: DeploymentNodeModel<M> | DeployedInstanceModel<M>, target: DeploymentNodeModel<M> | DeployedInstanceModel<M>, relations: RelationshipsAccum<M>);
+    readonly id: M['EdgeId'];
     /**
-     * Get all sibling (i.e. same parent)
+     * Human readable expression of the connection
+     * Mostly used for testing and debugging
      */
-    siblings(element: M['DeploymentOrFqn']): DeploymentElementsIterator<M>;
+    get expression(): string;
+    private _boundary;
     /**
-     * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
-     * (from closest to root)
+     * Common ancestor of the source and target elements.
+     * Represents the boundary of the connection.
      */
-    ancestors(element: M['DeploymentOrFqn']): DeploymentNodesIterator<M>;
+    get boundary(): DeploymentNodeModel<M> | null;
+    nonEmpty(): boolean;
+    [customInspectSymbol](depth: any, inspectOptions: any, inspect: any): string;
+    toString(): string;
     /**
-     * Get all descendant elements (i.e. children, children’s children, etc.)
+     * Check if connection contains deployment relation,
+     * that is directly connected to source or target.
      */
-    descendants(element: M['DeploymentOrFqn']): DeploymentElementsIterator<M>;
+    hasDirectDeploymentRelation(): boolean;
+    values(): IteratorLike<RelationshipModel<M> | DeploymentRelationModel<M>>;
     /**
-     * Incoming relationships to the element and its descendants
-     * @see incomers
+     * Merge with another connection, if it has the same source and target.
+     * Returns new connection with union of relationships.
      */
-    incoming(element: M['DeploymentOrFqn'], filter?: IncomingFilter): IteratorLike<DeploymentRelationModel<M>>;
+    mergeWith(other: DeploymentConnectionModel<M>): DeploymentConnectionModel<M>;
+    difference(other: DeploymentConnectionModel<M>): DeploymentConnectionModel<M>;
+    intersect(other: DeploymentConnectionModel<M>): DeploymentConnectionModel<M>;
+    equals(other: Connection): boolean;
     /**
-     * Outgoing relationships from the element and its descendants
-     * @see outgoers
+     * Creates a clone of the current `DeploymentConnectionModel` instance with optional overrides.
+     * if `null` is provided in overrides, the corresponding relation set will be empty.
      */
-    outgoing(element: M['DeploymentOrFqn'], filter?: OutgoingFilter): IteratorLike<DeploymentRelationModel<M>>;
-    private addElement;
-    private addRelation;
+    update(overrides?: {
+        model?: ReadonlySet<RelationshipModel<M>> | null;
+        deployment?: ReadonlySet<DeploymentRelationModel<M>> | null;
+    }): DeploymentConnectionModel<M>;
 }
 
-type DeploymentElementsIterator<M extends AnyAux> = IteratorLike<DeploymentElementModel<M>>;
-type DeployedInstancesIterator<M extends AnyAux> = IteratorLike<DeployedInstanceModel<M>>;
-type DeploymentNodesIterator<M extends AnyAux> = IteratorLike<DeploymentNodeModel<M>>;
-declare abstract class DeploymentElementModel<M extends AnyAux = AnyAux> {
-    abstract readonly $model: LikeC4DeploymentModel<M>;
-    abstract readonly $node: DeploymentNode | DeployedInstance;
-    get id(): M['DeploymentFqn'];
-    get style(): SetRequired<PhysicalElementStyle, 'shape' | 'color'>;
-    get shape(): ElementShape;
-    get color(): ThemeColor;
-    get tags(): ReadonlyArray<Tag>;
-    get title(): string;
-    get description(): string | null;
-    get technology(): string | null;
-    get parent(): DeploymentNodeModel<M> | null;
-    get links(): ReadonlyArray<Link>;
-    /**
-     * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
-     * (from closest to root)
-     */
-    ancestors(): DeploymentNodesIterator<M>;
-    /**
-     * Returns the common ancestor of this element and another element.
-     */
-    commonAncestor(another: DeploymentElementModel<M>): DeploymentNodeModel<M> | null;
-    /**
-     * Get all sibling (i.e. same parent)
-     */
-    siblings(): DeploymentElementsIterator<M>;
-    /**
-     * Check if the element is a sibling of another element
-     */
-    isSibling(other: DeploymentElementModel<M>): boolean;
-    /**
-     * Resolve siblings of the element and its ancestors
-     *  (from closest to root)
-     */
-    ascendingSiblings(): DeploymentElementsIterator<M>;
-    incoming(filter?: IncomingFilter): IteratorLike<DeploymentRelationModel<M>>;
-    outgoing(filter?: OutgoingFilter): IteratorLike<DeploymentRelationModel<M>>;
-    incomers(filter?: IncomingFilter): IteratorLike<DeploymentRelationEndpoint<M>>;
-    outgoers(filter?: OutgoingFilter): IteratorLike<DeploymentRelationEndpoint<M>>;
-    /**
-     * Iterate over all views that include this deployment element.
-     */
-    views(): IteratorLike<LikeC4ViewModel<M, ComputedDeploymentView>>;
-    isDeploymentNode(): this is DeploymentNodeModel<M>;
-    isInstance(): this is DeployedInstanceModel<M>;
-    abstract outgoingFromModel(): RelationshipsIterator<M>;
-    abstract incomingFromModel(): RelationshipsIterator<M>;
-    protected cachedOutgoing: RelationshipsAccum<M> | null;
-    protected cachedIncoming: RelationshipsAccum<M> | null;
-    get allOutgoing(): RelationshipsAccum<M>;
-    get allIncoming(): RelationshipsAccum<M>;
-}
-declare class DeploymentNodeModel<M extends AnyAux = AnyAux> extends DeploymentElementModel<M> {
-    readonly $model: LikeC4DeploymentModel<M>;
-    readonly $node: DeploymentNode;
-    constructor($model: LikeC4DeploymentModel<M>, $node: DeploymentNode);
-    get kind(): DeploymentNodeKind;
-    children(): ReadonlySet<DeploymentElementModel<M>>;
-    descendants(): DeploymentElementsIterator<M>;
-    isDeploymentNode(): this is DeploymentNodeModel<M>;
-    /**
-     * Iterate over all instances nested in this deployment node.
-     */
-    instances(): DeployedInstancesIterator<M>;
-    /**
-     * Returns deployed instance inside this deployment node
-     * if only there are no more instances
-     */
-    onlyOneInstance(): DeployedInstanceModel<M> | null;
-    /**
-     * Cached result of relationships from instances
-     */
-    private _relationshipsFromInstances;
-    private relationshipsFromInstances;
+/**
+ * Connection refers to any relationships between two elements,
+ * both direct and implicit ones (between their nested elements).
+ *
+ * Merges relationships together to an single edge on the diagram.
+ */
+declare class ConnectionModel<M extends AnyAux = AnyAux> implements Connection<ElementModel<M>, M['EdgeId']> {
+    readonly source: ElementModel<M>;
+    readonly target: ElementModel<M>;
+    readonly relations: ReadonlySet<RelationshipModel<M>>;
+    readonly id: M['EdgeId'];
+    constructor(source: ElementModel<M>, target: ElementModel<M>, relations?: ReadonlySet<RelationshipModel<M>>);
+    private _boundary;
     /**
-     * We return only relationships that are not already present in nested instances
+     * Common ancestor of the source and target elements.
+     * Represents the boundary of the connection.
      */
-    outgoingFromModel(): RelationshipsIterator<M>;
+    get boundary(): ElementModel<M> | null;
     /**
-     * We return only relationships that are not already present in nested instances
+     * Human readable expression of the connection
+     * Mostly used for testing and debugging
      */
-    incomingFromModel(): RelationshipsIterator<M>;
-}
-declare class DeployedInstanceModel<M extends AnyAux = AnyAux> extends DeploymentElementModel<M> {
-    readonly $model: LikeC4DeploymentModel<M>;
-    readonly $instance: DeployedInstance;
-    readonly $element: ElementModel<M>;
-    constructor($model: LikeC4DeploymentModel<M>, $instance: DeployedInstance, $element: ElementModel<M>);
-    get parent(): DeploymentNodeModel<M>;
-    get $node(): DeployedInstance;
-    get style(): SetRequired<PhysicalElementStyle, 'shape' | 'color'>;
-    get shape(): ElementShape;
-    get color(): ThemeColor;
-    get tags(): ReadonlyArray<Tag>;
-    get title(): string;
-    get description(): string | null;
-    get technology(): string | null;
-    get links(): ReadonlyArray<Link>;
-    isInstance(): this is DeployedInstanceModel<M>;
-    outgoingFromModel(): RelationshipsIterator<M>;
-    incomingFromModel(): RelationshipsIterator<M>;
-}
-declare class NestedElementOfDeployedInstanceModel<M extends AnyAux> {
-    readonly instance: DeployedInstanceModel<M>;
-    readonly element: ElementModel<M>;
-    constructor(instance: DeployedInstanceModel<M>, element: ElementModel<M>);
-    get id(): M['DeploymentFqn'];
-    get style(): SetRequired<PhysicalElementStyle, 'shape' | 'color'>;
-    get shape(): ElementShape;
-    get color(): ThemeColor;
-    get title(): string;
-    get description(): string | null;
-    get technology(): string | null;
-    isDeploymentNode(): this is DeploymentNodeModel<M>;
-    isInstance(): this is DeployedInstanceModel<M>;
-}
-type DeploymentRelationEndpoint<M extends AnyAux> = DeploymentElementModel<M> | NestedElementOfDeployedInstanceModel<M>;
-declare class DeploymentRelationModel<M extends AnyAux> {
-    readonly $model: LikeC4DeploymentModel<M>;
-    readonly $relationship: DeploymentRelation;
-    boundary: DeploymentNodeModel<M> | null;
-    source: DeploymentRelationEndpoint<M>;
-    target: DeploymentRelationEndpoint<M>;
-    constructor($model: LikeC4DeploymentModel<M>, $relationship: DeploymentRelation);
-    get id(): M['RelationId'];
     get expression(): string;
-    get title(): string | null;
-    get technology(): string | null;
-    get description(): string | null;
-    get tags(): ReadonlyArray<Tag>;
-    get navigateTo(): LikeC4ViewModel<M> | null;
-    get links(): ReadonlyArray<Link>;
-    views(): IteratorLike<LikeC4ViewModel<M, ComputedDeploymentView>>;
-}
-declare class RelationshipsAccum<M extends AnyAux> {
-    readonly model: ReadonlySet<RelationshipModel<M>>;
-    readonly deployment: ReadonlySet<DeploymentRelationModel<M>>;
     /**
-     * @param model relationships from logical model
-     * @param deployment relationships from deployment model
+     * Returns true if only includes relations between the source and target elements.
      */
-    constructor(model: ReadonlySet<RelationshipModel<M>>, deployment: ReadonlySet<DeploymentRelationModel<M>>);
-    get isEmpty(): boolean;
-    get nonEmpty(): boolean;
-    get size(): number;
+    get isDirect(): boolean;
     /**
-     * Returns new Accum containing all the elements which are both in this and otherAccum
+     * Returns true if includes relations between nested elements of the source and target elements.
      */
-    intersect(otherAccum: RelationshipsAccum<M>): RelationshipsAccum<M>;
+    get isImplicit(): boolean;
+    get directRelations(): ReadonlySet<RelationshipModel<M>>;
+    nonEmpty(): boolean;
+    mergeWith(other: ConnectionModel<M>): ConnectionModel<M>;
+    difference(other: ConnectionModel<M>): ConnectionModel<M>;
+    intersect(other: ConnectionModel<M>): ConnectionModel<M>;
+    equals(other: Connection): boolean;
     /**
-     * Returns new Accum containing all the elements which are both in this and otherAccum
+     * Returns a new instance with the updated relations.
+     *
+     * @param relations - A readonly set of `RelationshipModel` instances representing the new relations.
+     * @returns A new `ConnectionModel` instance with the updated relations.
      */
-    difference(otherAccum: RelationshipsAccum<M>): RelationshipsAccum<M>;
+    update(relations: ReadonlySet<RelationshipModel<M>>): ConnectionModel<M>;
+    [customInspectSymbol](depth: any, inspectOptions: any, inspect: any): string;
+    toString(): string;
     /**
-     * Returns new Accum containing all the elements from both
+     * Creates a new connection with reversed direction (target becomes source and vice versa)
+     * @param search - When true, attempts to find an existing connection between the reversed nodes
      */
-    union(otherAccum: RelationshipsAccum<M>): RelationshipsAccum<M>;
+    reversed(search?: boolean): ConnectionModel<M>;
 }
 
-declare class LikeC4Model<M extends AnyAux = LikeC4Model.Any> {
-    #private;
-    readonly $model: M['Model'];
-    /**
-     * Only available in compile time
-     */
-    readonly Aux: M;
-    readonly deployment: LikeC4DeploymentModel<M>;
-    static create<const M extends AnyLikeC4Model>(model: M): LikeC4Model<Aux.FromModel<M>>;
-    /**
-     * This method is supposed to be used only in dumps
-     */
-    static fromDump<const M extends ParsedLikeC4ModelDump>(dump: M): LikeC4Model<Aux.FromDump<M>>;
-    private constructor();
-    get type(): 'computed' | 'layouted';
-    element(el: M['ElementOrFqn']): ElementModel<M>;
-    findElement(el: LiteralUnion<M['Element'], string>): ElementModel<M> | null;
-    /**
-     * Returns the root elements of the model.
-     */
-    roots(): ElementsIterator<M>;
-    /**
-     * Returns all elements in the model.
-     */
-    elements(): ElementsIterator<M>;
-    /**
-     * Returns all relationships in the model.
-     */
-    relationships(): RelationshipsIterator<M>;
-    /**
-     * Returns a specific relationship by its ID.
-     * If the relationship is not found in the model, it will be searched in the deployment model.
-     * Search can be limited to the model or deployment model only.
-     */
-    relationship(id: M['RelationId'], type: 'model'): RelationshipModel<M>;
-    relationship(id: M['RelationId'], type: 'deployment'): DeploymentRelationModel<M>;
-    relationship(id: M['RelationId'], type?: 'model' | 'deployment'): RelationshipModel<M> | DeploymentRelationModel<M>;
-    findRelationship(id: LiteralUnion<M['RelationId'], string>, type: 'model'): RelationshipModel<M> | null;
-    findRelationship(id: LiteralUnion<M['RelationId'], string>, type: 'deployment'): DeploymentRelationModel<M> | null;
-    findRelationship(id: LiteralUnion<M['RelationId'], string>, type?: 'model' | 'deployment'): RelationshipModel<M> | DeploymentRelationModel<M> | null;
-    /**
-     * Returns all views in the model.
-     */
-    views(): MapIterator<LikeC4ViewModel<M, M["ViewType"]>>;
-    /**
-     * Returns a specific view by its ID.
-     */
-    view(viewId: M['ViewIdLiteral']): LikeC4ViewModel<M>;
-    findView(viewId: LiteralUnion<M['ViewId'], string>): LikeC4ViewModel<M>;
-    /**
-     * Returns the parent element of given element.
-     * @see ancestors
-     */
-    parent(element: M['ElementOrFqn']): ElementModel<M> | null;
-    /**
-     * Get all children of the element (only direct children),
-     * @see descendants
-     */
-    children(element: M['ElementOrFqn']): ReadonlySet<ElementModel<M>>;
-    /**
-     * Get all sibling (i.e. same parent)
-     */
-    siblings(element: M['ElementOrFqn']): ElementsIterator<M>;
-    /**
-     * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
-     * (from closest to root)
-     */
-    ancestors(element: M['ElementOrFqn']): ElementsIterator<M>;
-    /**
-     * Get all descendant elements (i.e. children, children’s children, etc.)
-     */
-    descendants(element: M['ElementOrFqn']): ElementsIterator<M>;
-    /**
-     * Incoming relationships to the element and its descendants
-     * @see incomers
-     */
-    incoming(element: M['ElementOrFqn'], filter?: IncomingFilter): RelationshipsIterator<M>;
-    /**
-     * Outgoing relationships from the element and its descendants
-     * @see outgoers
-     */
-    outgoing(element: M['ElementOrFqn'], filter?: OutgoingFilter): RelationshipsIterator<M>;
-    private addElement;
-    private addRelation;
+/**
+ * Check if connection is nested inside another connection
+ * (i.e. between descendants)
+ */
+declare function isNestedConnection<T extends {
+    id: string;
+}>(parent: WithSourceTarget<NoInfer<T>>): (nested: WithSourceTarget<T>) => boolean;
+declare function isNestedConnection<T extends {
+    id: string;
+}>(nested: WithSourceTarget<T>, parent: WithSourceTarget<T>): boolean;
+type ConnectionElemId = Connection<{
+    readonly id: string;
+}, any>;
+declare function findDeepestNestedConnection<C extends ConnectionElemId>(connections: ReadonlyArray<C>, connection: C): C | null;
+declare function sortDeepestFirst<C extends ConnectionElemId>(connections: ReadonlyArray<C>): C[];
+type WithBoundary = {
+    boundary: null | {
+        id: string;
+    };
+};
+declare function sortConnectionsByBoundaryHierarchy(sort?: 'asc' | 'desc'): <T extends WithBoundary, A extends IterableContainer<T>>(array: A) => ReorderedArray<A>;
+declare function sortConnectionsByBoundaryHierarchy<T extends WithBoundary, A extends IterableContainer<T>>(array: A, sort?: 'asc' | 'desc'): ReorderedArray<A>;
+/**
+ * Find connections that includes given connection (i.e between it's ancestors)
+ */
+declare function findAscendingConnections<C extends ConnectionElemId>(connections: ReadonlyArray<C>, connection: C): Array<C>;
+/**
+ * Find connections that includes given connection (i.e between it's descendants)
+ */
+declare function findDescendantConnections<C extends ConnectionElemId>(connections: ReadonlyArray<C>, connection: C): Array<C>;
+declare function mergeConnections<C extends Connection>(connections: ReadonlyArray<C>): C[];
+/**
+ * Excludes the values existing in `other` array.
+ * The output maintains the same order as the input.
+ */
+declare function differenceConnections<C extends Connection>(source: Iterable<C>, exclude: Iterable<C>): C[];
+type WithSourceTarget<T = unknown> = {
+    source: T;
+    target: T;
+};
+declare function hasSameSourceTarget<T>(a: WithSourceTarget<NoInfer<T>>): (b: WithSourceTarget<T>) => boolean;
+declare function hasSameSourceTarget<T>(a: WithSourceTarget<T>, b: WithSourceTarget<T>): boolean;
+declare function hasSameSource<T>(a: WithSourceTarget<NoInfer<T>>): (b: WithSourceTarget<T>) => boolean;
+declare function hasSameSource<T>(a: WithSourceTarget<T>, b: WithSourceTarget<T>): boolean;
+declare function hasSameTarget<T>(a: WithSourceTarget<NoInfer<T>>): (b: WithSourceTarget<T>) => boolean;
+declare function hasSameTarget<T>(a: WithSourceTarget<T>, b: WithSourceTarget<T>): boolean;
+type WithId<T> = {
+    id: T;
+};
+declare function isOutgoing<T extends string>(source: WithId<NoInfer<T>>): (a: WithSourceTarget<WithId<T>>) => boolean;
+declare function isOutgoing<T extends string>(a: WithSourceTarget<WithId<T>>, source: WithId<T>): boolean;
+declare function isIncoming<T extends string>(target: WithId<NoInfer<T>>): (a: WithSourceTarget<WithId<T>>) => boolean;
+declare function isIncoming<T extends string>(a: WithSourceTarget<WithId<T>>, target: WithId<T>): boolean;
+declare function isAnyInOut<T extends string>(source: WithId<NoInfer<T>>): (a: WithSourceTarget<WithId<T>>) => boolean;
+declare function isAnyInOut<T extends string>(a: WithSourceTarget<WithId<T>>, source: WithId<T>): boolean;
+
+/**
+ * Resolve connection from source to target
+ * If direction is `both`, also look for reverse connection
+ *
+ * @default direction directed
+ */
+declare function findConnection$1<M extends AnyAux>(source: DeploymentElementModel<M>, target: DeploymentElementModel<NoInfer<M>>, direction: 'directed'): readonly [DeploymentConnectionModel<M>] | readonly [];
+declare function findConnection$1<M extends AnyAux>(source: DeploymentElementModel<M>, target: DeploymentElementModel<NoInfer<M>>, direction: 'both'): readonly [DeploymentConnectionModel<M>, DeploymentConnectionModel<M>] | readonly [DeploymentConnectionModel<M>] | readonly [];
+declare function findConnection$1<M extends AnyAux>(source: DeploymentElementModel<M>, target: DeploymentElementModel<NoInfer<M>>, direction?: 'directed' | 'both'): readonly [DeploymentConnectionModel<M>, DeploymentConnectionModel<M>] | readonly [DeploymentConnectionModel<M>] | readonly [];
+/**
+ * Resolve all connections between element and others
+ * By default, look for both directions.
+ *
+ * @default direction both
+ */
+declare function findConnectionsBetween$1<M extends AnyAux>(element: DeploymentElementModel<M>, others: Iterable<DeploymentElementModel<NoInfer<M>>>, direction?: 'directed' | 'both'): readonly DeploymentConnectionModel<M>[];
+/**
+ * Resolve all connections within a given set of elements
+ */
+declare function findConnectionsWithin$1<M extends AnyAux>(elements: Iterable<DeploymentElementModel<M>>): readonly DeploymentConnectionModel<M>[];
+
+declare namespace find$1 {
+  export { findConnection$1 as findConnection, findConnectionsBetween$1 as findConnectionsBetween, findConnectionsWithin$1 as findConnectionsWithin };
 }
-declare namespace LikeC4Model {
-    type Any = Aux<string, string, string, ComputedView | DiagramView>;
-    type Element<M extends AnyAux = Any> = ElementModel<M>;
-    type Relation<M extends AnyAux = Any> = RelationshipModel<M>;
-    type AnyRelation<M extends AnyAux = Any> = RelationshipModel<M> | DeploymentRelationModel<M>;
-    type View<M extends AnyAux = Any, V extends ComputedView | DiagramView = M['ViewType']> = LikeC4ViewModel<M, V>;
-    type Node<M extends AnyAux = Any, V extends ComputedView | DiagramView = M['ViewType']> = NodeModel<M, V>;
-    type Edge<M extends AnyAux = Any, V extends ComputedView | DiagramView = M['ViewType']> = EdgeModel<M, V>;
-    type DeploymentModel<M extends AnyAux = AnyAux> = LikeC4DeploymentModel<M>;
-    type Deployment<M extends AnyAux = AnyAux> = DeploymentElementModel<M>;
-    type DeploymentNode<M extends AnyAux = AnyAux> = DeploymentNodeModel<M>;
-    type DeployedInstance<M extends AnyAux = AnyAux> = DeployedInstanceModel<M>;
-    type Typed<Elements extends string = string, Deployments extends string = string, Views extends string = string, ViewType = DiagramView<Views> | ComputedView<Views>> = Aux<Elements, Deployments, Views, ViewType>;
-    type Computed<Elements extends string = string, Deployments extends string = string, Views extends string = string> = LikeC4Model<Typed<Elements, Deployments, Views, ComputedView<Views>>>;
-    type Layouted<Elements extends string = string, Deployments extends string = string, Views extends string = string> = LikeC4Model<Typed<Elements, Deployments, Views, DiagramView<Views>>>;
+
+/**
+ * Resolve connection from source to target
+ *
+ * @param direction - if 'both', also returns connection from target to source
+ * @default `directed`
+ */
+declare function findConnection<M extends AnyAux>(source: ElementModel<M>, target: ElementModel<M>, direction?: 'directed' | 'both'): [ConnectionModel<M>, ConnectionModel<M>] | [ConnectionModel<M>] | [];
+/**
+ * Resolve all connections between element and others
+ * @param direction - if 'directed', only look for outgoing connections from the element to others
+ * @default `both`
+ */
+declare function findConnectionsBetween<M extends AnyAux>(element: ElementModel<M>, others: Iterable<ElementModel<NoInfer<M>>>, direction?: 'directed' | 'both'): readonly ConnectionModel<M>[];
+/**
+ * Resolve all connections within a given set of elements
+ */
+declare function findConnectionsWithin<M extends AnyAux>(elements: Iterable<ElementModel<M>>): readonly ConnectionModel<M>[];
+
+declare const find_findConnection: typeof findConnection;
+declare const find_findConnectionsBetween: typeof findConnectionsBetween;
+declare const find_findConnectionsWithin: typeof findConnectionsWithin;
+declare namespace find {
+  export { find_findConnection as findConnection, find_findConnectionsBetween as findConnectionsBetween, find_findConnectionsWithin as findConnectionsWithin };
 }
 
-export { LikeC4DeploymentModel, LikeC4Model, Aux as LikeC4ModelAux, LikeC4ViewModel };
+declare function isDeploymentNode(model: DeploymentElementModel): model is DeploymentNodeModel;
+declare function isDeployedInstance(model: DeploymentElementModel): model is DeployedInstanceModel;
+
+export { AnyAux, Connection, ConnectionModel, DeployedInstanceModel, DeploymentConnectionModel, DeploymentElementModel, DeploymentNodeModel, DeploymentRelationModel, ElementModel, RelationshipModel, find$1 as deploymentConnection, differenceConnections, findAscendingConnections, findDeepestNestedConnection, findDescendantConnections, hasSameSource, hasSameSourceTarget, hasSameTarget, isAnyInOut, isDeployedInstance, isDeploymentNode, isIncoming, isNestedConnection, isOutgoing, mergeConnections, find as modelConnection, sortConnectionsByBoundaryHierarchy, sortDeepestFirst };