@likec4/core 1.30.0 → 1.32.0

package/dist/shared/core.CCWXGc6G.d.mts

@@ -0,0 +1,920 @@
+import { A as Any, T as Tags, R as RelationKind, j as Metadata, k as MetadataKey, L as LooseTag, F as Fqn, g as ElementId, l as ElementKind, D as DeploymentKind, E as ExtractOnStage, m as RelationId$1, f as _type, n as StrictViewId, o as LooseElementId, p as LooseDeploymentId, q as DeploymentFqn, t as toComputed, r as toLayouted, s as Stage, u as DeploymentId, U as Unknown, V as ViewId, v as Tag, w as toParsed, P as ProjectId$1, x as LooseViewId, b as Aux, S as SpecAux, e as UnknownParsed, c as UnknownComputed, d as UnknownLayouted } from './core.BaYE_r29.mjs';
+import { D as DefaultMap } from './core.CywrQs86.mjs';
+import { SetRequired } from 'type-fest';
+import { az as Color, av as RelationshipLineType, Y as Relationship, O as Element, ar as ElementShape, N as ElementStyle, aM as ViewWithType, aI as ComputedView, aG as LayoutedView, k as ParsedLikeC4ModelData, l as ComputedLikeC4ModelData, m as LayoutedLikeC4ModelData, b8 as ViewType, c as FqnRef, p as DeployedInstance, D as DeploymentElementStyle, u as DeploymentRelationship, q as DeploymentElement, o as DeploymentNode, x as LikeC4ModelDump, y as AuxFromDump, a2 as Specification, j as ModelGlobals, ah as WhereOperator } from './core.Dpq3P3YJ.mjs';
+import { I as IteratorLike, R as RelationId, L as Link, P as ProjectId, j as IconUrl, N as NodeId, G as GroupElementKind, E as EdgeId, p as StepEdgeId, V as ViewId$1 } from './core.BuO4ncfY.mjs';
+
+type RelationshipsIterator<A extends Any> = IteratorLike<RelationshipModel<A>>;
+/**
+ * A relationship between two elements (in logical or deployment model)
+ * use {@link isDeploymentRelationModel} guard to check if the relationship is a deployment relationship
+ */
+interface AnyRelationshipModel<A extends Any> {
+    get id(): RelationId;
+    get expression(): string;
+    get title(): string | null;
+    get technology(): string | null;
+    get description(): string | null;
+    get navigateTo(): LikeC4ViewModel<A> | null;
+    get tags(): Tags<A>;
+    get kind(): RelationKind<A> | null;
+    get links(): ReadonlyArray<Link>;
+    get color(): Color;
+    get line(): RelationshipLineType;
+    isDeploymentRelation(): this is DeploymentRelationModel<A>;
+    isModelRelation(): this is RelationshipModel<A>;
+    getMetadata(): Metadata<A>;
+    getMetadata(field: MetadataKey<A>): string | undefined;
+    views(): ViewsIterator<A>;
+    isTagged(tag: LooseTag<A>): boolean;
+}
+declare class RelationshipModel<A extends Any = Any> implements AnyRelationshipModel<A> {
+    readonly model: LikeC4Model<A>;
+    readonly $relationship: Relationship<A>;
+    readonly source: ElementModel<A>;
+    readonly target: ElementModel<A>;
+    /**
+     * Common ancestor of the source and target elements.
+     * Represents the boundary of the Relation.
+     */
+    readonly boundary: ElementModel<A> | null;
+    constructor(model: LikeC4Model<A>, $relationship: Relationship<A>);
+    get id(): RelationId;
+    get expression(): string;
+    get title(): string | null;
+    get technology(): string | null;
+    get description(): string | null;
+    get navigateTo(): LikeC4ViewModel<A> | null;
+    get tags(): Tags<A>;
+    get kind(): RelationKind<A> | null;
+    get links(): ReadonlyArray<Link>;
+    get color(): Color;
+    get line(): RelationshipLineType;
+    /**
+     * Iterate over all views that include this relationship.
+     */
+    views(): ViewsIterator<A>;
+    isDeploymentRelation(): this is DeploymentRelationModel<A>;
+    isModelRelation(): this is RelationshipModel<A>;
+    getMetadata(): Metadata<A>;
+    getMetadata(field: MetadataKey<A>): string | undefined;
+    /**
+     * Checks if the relationship has the given tag.
+     */
+    isTagged(tag: LooseTag<A>): boolean;
+}
+
+type ElementsIterator<M extends Any> = IteratorLike<ElementModel<M>>;
+declare class ElementModel<A extends Any = Any> {
+    readonly $model: LikeC4Model<A>;
+    readonly $element: Element<A>;
+    readonly id: Fqn<A>;
+    readonly _literalId: ElementId<A>;
+    readonly hierarchyLevel: number;
+    readonly imported: null | {
+        from: ProjectId;
+        fqn: Fqn<A>;
+    };
+    constructor($model: LikeC4Model<A>, $element: Element<A>);
+    get parent(): ElementModel<A> | null;
+    get kind(): ElementKind<A>;
+    get shape(): ElementShape;
+    get color(): Color;
+    get icon(): IconUrl | null;
+    /**
+     * Returns all tags of the element.
+     * It includes tags from the element and its kind.
+     */
+    get tags(): Tags<A>;
+    get title(): string;
+    get description(): string | null;
+    get technology(): string | null;
+    get links(): ReadonlyArray<Link>;
+    get defaultView(): LikeC4ViewModel<A, $ViewWithType<A, 'element'> & {
+        viewOf: Fqn<A>;
+    }> | null;
+    get isRoot(): boolean;
+    get style(): SetRequired<ElementStyle, 'size'>;
+    isAncestorOf(another: ElementModel<A>): boolean;
+    isDescendantOf(another: ElementModel<A>): boolean;
+    /**
+     * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
+     * (from closest to root)
+     */
+    ancestors(): ElementsIterator<A>;
+    /**
+     * Returns the common ancestor of this element and another element.
+     */
+    commonAncestor(another: ElementModel<A>): ElementModel<A> | null;
+    children(): ReadonlySet<ElementModel<A>>;
+    /**
+     * Get all descendant elements (i.e. children, children’s children, etc.)
+     */
+    descendants(sort?: 'asc' | 'desc'): ElementsIterator<A>;
+    /**
+     * Get all sibling (i.e. same parent)
+     */
+    siblings(): ElementsIterator<A>;
+    /**
+     * Resolve siblings of the element and its ancestors
+     * (from closest parent to root)
+     */
+    ascendingSiblings(): ElementsIterator<A>;
+    /**
+     * Resolve siblings of the element and its ancestors
+     *  (from root to closest)
+     */
+    descendingSiblings(): ElementsIterator<A>;
+    incoming(filter?: IncomingFilter): RelationshipsIterator<A>;
+    incomers(filter?: IncomingFilter): ElementsIterator<A>;
+    outgoing(filter?: OutgoingFilter): RelationshipsIterator<A>;
+    outgoers(filter?: OutgoingFilter): ElementsIterator<A>;
+    get allOutgoing(): ReadonlySet<RelationshipModel<A>>;
+    get allIncoming(): ReadonlySet<RelationshipModel<A>>;
+    /**
+     * Iterate over all views that include this element.
+     */
+    views(): ReadonlySet<LikeC4ViewModel<A>>;
+    /**
+     * Iterate over all views that scope this element.
+     * It is possible that element is not included in the view.
+     */
+    scopedViews(): ReadonlySet<LikeC4ViewModel<A, $ViewWithType<A, 'element'> & {
+        viewOf: Fqn<A>;
+    }>>;
+    /**
+     * @returns true if the element is deployed
+     */
+    isDeployed(): boolean;
+    deployments(): DeployedInstancesIterator<A>;
+    getMetadata(): Metadata<A>;
+    getMetadata(field: MetadataKey<A>): string | undefined;
+    /**
+     * Checks if the element has the given tag.
+     */
+    isTagged(tag: LooseTag<A>): boolean;
+}
+
+type NodesIterator<M extends Any, V extends $View<M>> = IteratorLike<NodeModel<M, V>>;
+declare class NodeModel<A extends Any = Any, V extends $View<A> = $View<A>> {
+    #private;
+    readonly $view: LikeC4ViewModel<A, V>;
+    readonly $node: V['nodes'][number];
+    constructor($view: LikeC4ViewModel<A, V>, $node: V['nodes'][number]);
+    get id(): NodeId;
+    get title(): string;
+    get kind(): ElementKind<A> | DeploymentKind<A> | typeof GroupElementKind | 'instance';
+    get description(): string | null;
+    get technology(): string | null;
+    get parent(): NodeModel<A, V> | null;
+    get element(): ElementModel<A> | null;
+    get deployment(): DeploymentElementModel<A> | null;
+    get shape(): ElementShape;
+    get color(): Color;
+    get icon(): IconUrl | null;
+    get tags(): Tags<A>;
+    get links(): ReadonlyArray<Link>;
+    get navigateTo(): LikeC4ViewModel<A> | null;
+    get style(): ElementStyle;
+    children(): ReadonlySet<NodeModel<A, V>>;
+    /**
+     * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
+     * (from closest to root)
+     */
+    ancestors(): NodesIterator<A, V>;
+    siblings(): NodesIterator<A, V>;
+    incoming(filter?: IncomingFilter): EdgesIterator<A, V>;
+    incomers(filter?: IncomingFilter): NodesIterator<A, V>;
+    outgoing(filter?: OutgoingFilter): EdgesIterator<A, V>;
+    outgoers(filter?: OutgoingFilter): NodesIterator<A, V>;
+    isDiagramNode(this: NodeModel<any, any>): this is NodeModel<A, ExtractOnStage<V, 'layouted'>>;
+    hasChildren(): boolean;
+    hasParent(): this is NodeModel.WithParent<A, V>;
+    /**
+     * Check if this node references to logical model element.
+     */
+    hasElement(): this is NodeModel.WithElement<A, V>;
+    /**
+     * Check if this node references to deployment element (Node or Instance).
+     */
+    hasDeployment(): this is NodeModel.WithDeploymentElement<A, V>;
+    /**
+     * Check if this node references to deployed instance
+     * Deployed instance always references to element and deployment element.
+     */
+    hasDeployedInstance(): this is NodeModel.WithDeployedInstance<A, V>;
+    isGroup(): this is NodeModel.IsGroup<A, V>;
+    /**
+     * Checks if the node has the given tag.
+     */
+    isTagged(tag: LooseTag<A>): boolean;
+}
+declare namespace NodeModel {
+    interface WithParent<A extends Any = Any, V extends $View<A> = $View<A>> extends NodeModel<A, V> {
+        parent: NodeModel<A, V>;
+    }
+    interface WithElement<A extends Any = Any, V extends $View<A> = $View<A>> extends NodeModel<A, V> {
+        kind: ElementKind<A>;
+        element: ElementModel<A>;
+    }
+    interface WithDeploymentElement<A extends Any = Any, V extends $View<A> = $View<A>> extends NodeModel<A, V> {
+        kind: DeploymentKind<A>;
+        deployment: DeploymentElementModel<A>;
+    }
+    interface WithDeployedInstance<A extends Any = Any, V extends $View<A> = $View<A>> extends NodeModel<A, V> {
+        kind: 'instance';
+        element: ElementModel<A>;
+        deployment: DeployedInstanceModel<A>;
+    }
+    interface IsGroup<A extends Any = Any, V extends $View<A> = $View<A>> extends NodeModel<A, V> {
+        kind: typeof GroupElementKind;
+        element: null;
+        deployment: null;
+    }
+}
+
+type EdgesIterator<A extends Any, V extends $View<A>> = IteratorLike<EdgeModel<A, V>>;
+declare class EdgeModel<A extends Any = Any, View extends $View<A> = $View<A>> {
+    #private;
+    readonly view: LikeC4ViewModel<A, View>;
+    readonly $edge: View['edges'][number];
+    readonly source: NodeModel<A, View>;
+    readonly target: NodeModel<A, View>;
+    constructor(view: LikeC4ViewModel<A, View>, $edge: View['edges'][number], source: NodeModel<A, View>, target: NodeModel<A, View>);
+    get id(): EdgeId;
+    get parent(): NodeModel<A, View> | null;
+    get label(): string | null;
+    get description(): string | null;
+    get technology(): string | null;
+    hasParent(): this is EdgeModel.WithParent<A, View>;
+    get tags(): Tags<A>;
+    get stepNumber(): number | null;
+    get navigateTo(): LikeC4ViewModel<A> | null;
+    get color(): Color;
+    get line(): RelationshipLineType;
+    isStep(): this is EdgeModel.StepEdge<A, View>;
+    relationships(type: 'model'): IteratorLike<RelationshipModel<A>>;
+    relationships(type: 'deployment'): IteratorLike<DeploymentRelationModel<A>>;
+    relationships(type?: 'model' | 'deployment'): IteratorLike<RelationshipModel<A> | DeploymentRelationModel<A>>;
+    includesRelation(rel: RelationId$1 | {
+        id: RelationId$1;
+    }): boolean;
+    isTagged(tag: LooseTag<A>): boolean;
+}
+declare namespace EdgeModel {
+    interface StepEdge<A extends Any, V extends $View<A>> extends EdgeModel<A, V> {
+        id: StepEdgeId;
+        stepNumber: number;
+    }
+    interface WithParent<A extends Any, V extends $View<A>> extends EdgeModel<A, V> {
+        parent: NodeModel<A, V>;
+    }
+}
+
+type ViewsIterator<A extends Any, V extends $View<A> = $View<A>> = IteratorLike<LikeC4ViewModel<A, V>>;
+declare class LikeC4ViewModel<A extends Any = Any, V extends $View<A> = $View<A>> {
+    #private;
+    /**
+     * Don't use in runtime, only for type inference
+     */
+    readonly Aux: A;
+    readonly $view: V;
+    readonly $model: LikeC4Model<A>;
+    constructor(model: LikeC4Model<A>, view: V);
+    get _type(): V[_type];
+    get id(): StrictViewId<A>;
+    get title(): string | null;
+    get tags(): Tags<A>;
+    get links(): ReadonlyArray<Link>;
+    get viewOf(): ElementModel<A> | null;
+    /**
+     * All tags from nodes and edges.
+     */
+    get includedTags(): Tags<A>;
+    roots(): NodesIterator<A, V>;
+    /**
+     * Iterate over all nodes that have children.
+     */
+    compounds(): NodesIterator<A, V>;
+    /**
+     * Get node by id.
+     * @throws Error if node is not found.
+     */
+    node(node: NodeOrId): NodeModel<A, V>;
+    /**
+     * Find node by id.
+     */
+    findNode(node: NodeOrId): NodeModel<A, V> | null;
+    findNodeWithElement(element: LooseElementId<A> | {
+        id: Fqn<A>;
+    }): NodeModel.WithElement<A, V> | null;
+    /**
+     * Iterate over all nodes.
+     */
+    nodes(): NodesIterator<A, V>;
+    /**
+     * Find edge by id.
+     * @param edge Edge or id
+     * @returns EdgeModel
+     */
+    edge(edge: EdgeOrId): EdgeModel<A, V>;
+    findEdge(edge: EdgeOrId): EdgeModel<A, V> | null;
+    /**
+     * Iterate over all edges.
+     */
+    edges(): EdgesIterator<A, V>;
+    /**
+     * Iterate over all edges.
+     */
+    edgesWithRelation(relation: RelationId$1): EdgesIterator<A, V>;
+    /**
+     * Nodes that have references to elements from logical model.
+     */
+    elements(): IteratorLike<NodeModel.WithElement<A, V>>;
+    /**
+     * Checks if the view has the given tag.
+     */
+    isTagged(tag: LooseTag<A>): boolean;
+    includesElement(element: LooseElementId<A> | {
+        id: Fqn<A>;
+    }): boolean;
+    includesDeployment(deployment: LooseDeploymentId<A> | {
+        id: DeploymentFqn<A>;
+    }): boolean;
+    includesRelation(relation: RelationId | {
+        id: RelationId;
+    }): boolean;
+    /**
+     * Below are type guards.
+     */
+    isComputed(this: LikeC4ViewModel<any, any>): this is LikeC4ViewModel<toComputed<A>>;
+    isDiagram(this: LikeC4ViewModel<any, any>): this is LikeC4ViewModel<toLayouted<A>>;
+    isElementView(this: LikeC4ViewModel<any, any>): this is LikeC4ViewModel.ElementView<A, V>;
+    isScopedElementView(this: LikeC4ViewModel<any, any>): this is LikeC4ViewModel.ScopedElementView<A, V>;
+    isDeploymentView(this: LikeC4ViewModel<any, any>): this is LikeC4ViewModel.DeploymentView<A, V>;
+    isDynamicView(this: LikeC4ViewModel<any, any>): this is LikeC4ViewModel.DynamicView<A, V>;
+}
+declare namespace LikeC4ViewModel {
+    interface ElementView<A extends Any, V extends $View<A> = $View<A>> extends LikeC4ViewModel<A, ViewWithType<V, 'element'>> {
+    }
+    interface ScopedElementView<A extends Any, V extends $View<A> = $View<A>> extends LikeC4ViewModel<A, ViewWithType<V, 'element'> & {
+        viewOf: Fqn<A>;
+    }> {
+        viewOf: ElementModel<A>;
+    }
+    interface DeploymentView<A extends Any, V extends $View<A> = $View<A>> extends LikeC4ViewModel<A, ViewWithType<V, 'deployment'>> {
+    }
+    interface DynamicView<A extends Any, V extends $View<A> = $View<A>> extends LikeC4ViewModel<A, ViewWithType<V, 'dynamic'>> {
+    }
+}
+
+type IncomingFilter = 'all' | 'direct' | 'to-descendants';
+type OutgoingFilter = 'all' | 'direct' | 'from-descendants';
+type ElementOrFqn<A extends Any> = ElementId<A> | {
+    id: Fqn<A>;
+};
+type DeploymentOrFqn<A extends Any> = DeploymentId<A> | {
+    id: DeploymentFqn<A>;
+};
+type NodeOrId = string | {
+    id: NodeId;
+};
+type EdgeOrId = string | {
+    id: EdgeId;
+};
+type RelationOrId = string | {
+    id: RelationId;
+};
+type $View<A extends Any> = {
+    parsed: never;
+    computed: ComputedView<A>;
+    layouted: LayoutedView<A>;
+}[Stage<A>];
+type $ViewWithType<A extends Any, V extends ViewType> = ViewWithType<$View<A>, V>;
+type $ViewModel<A extends Any> = {
+    parsed: never;
+    computed: LikeC4ViewModel<A>;
+    layouted: LikeC4ViewModel<A>;
+}[Stage<A>];
+type $ModelData<A extends Any> = {
+    parsed: ParsedLikeC4ModelData<A>;
+    computed: ComputedLikeC4ModelData<A>;
+    layouted: LayoutedLikeC4ModelData<A>;
+}[Stage<A>];
+
+declare class LikeC4DeploymentModel<A extends Any = Any> {
+    #private;
+    readonly $model: LikeC4Model<A>;
+    readonly $deployments: $ModelData<A>['deployments'];
+    constructor($model: LikeC4Model<A>);
+    element(el: DeploymentOrFqn<A>): DeploymentElementModel<A>;
+    findElement(el: LooseDeploymentId<A>): DeploymentElementModel<A> | null;
+    node(el: DeploymentOrFqn<A>): DeploymentNodeModel<A>;
+    findNode(el: LooseDeploymentId<A>): DeploymentNodeModel<A> | null;
+    instance(el: DeploymentOrFqn<A>): DeployedInstanceModel<A>;
+    findInstance(el: LooseDeploymentId<A>): DeployedInstanceModel<A> | null;
+    /**
+     * Returns the root elements of the model.
+     */
+    roots(): DeploymentNodesIterator<A>;
+    /**
+     * Returns all elements in the model.
+     */
+    elements(): DeploymentElementsIterator<A>;
+    /**
+     * Returns all elements in the model.
+     */
+    nodes(): DeploymentNodesIterator<A>;
+    nodesOfKind(kind: DeploymentKind<A>): DeploymentNodesIterator<A>;
+    instances(): DeployedInstancesIterator<A>;
+    /**
+     * Iterate over all instances of the given logical element.
+     */
+    instancesOf(element: ElementOrFqn<A>): DeployedInstancesIterator<A>;
+    deploymentRef(ref: FqnRef.DeploymentRef<A>): DeploymentElementModel<A> | NestedElementOfDeployedInstanceModel<A>;
+    /**
+     * Returns all relationships in the model.
+     */
+    relationships(): IteratorLike<DeploymentRelationModel<A>>;
+    /**
+     * Returns a specific relationship by its ID.
+     */
+    relationship(id: RelationOrId): DeploymentRelationModel<A>;
+    findRelationship(id: string): DeploymentRelationModel<A> | null;
+    /**
+     * Returns all deployment views in the model.
+     */
+    views(): IteratorLike<LikeC4ViewModel.DeploymentView<A>>;
+    /**
+     * Returns the parent element of given element.
+     * @see ancestors
+     */
+    parent(element: DeploymentOrFqn<A>): DeploymentNodeModel<A> | null;
+    /**
+     * Get all children of the element (only direct children),
+     * @see descendants
+     */
+    children(element: DeploymentOrFqn<A>): ReadonlySet<DeploymentElementModel<A>>;
+    /**
+     * Get all sibling (i.e. same parent)
+     */
+    siblings(element: DeploymentOrFqn<A>): DeploymentElementsIterator<A>;
+    /**
+     * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
+     * (from closest to root)
+     */
+    ancestors(element: DeploymentOrFqn<A>): DeploymentNodesIterator<A>;
+    /**
+     * Get all descendant elements (i.e. children, children’s children, etc.)
+     */
+    descendants(element: DeploymentOrFqn<A>, sort?: 'asc' | 'desc'): DeploymentElementsIterator<A>;
+    /**
+     * Incoming relationships to the element and its descendants
+     * @see incomers
+     */
+    incoming(element: DeploymentOrFqn<A>, filter?: IncomingFilter): IteratorLike<DeploymentRelationModel<A>>;
+    /**
+     * Outgoing relationships from the element and its descendants
+     * @see outgoers
+     */
+    outgoing(element: DeploymentOrFqn<A>, filter?: OutgoingFilter): IteratorLike<DeploymentRelationModel<A>>;
+    private addElement;
+    private addRelation;
+}
+
+type DeploymentElementsIterator<A extends Any> = IteratorLike<DeploymentElementModel<A>>;
+type DeployedInstancesIterator<A extends Any> = IteratorLike<DeployedInstanceModel<A>>;
+type DeploymentNodesIterator<A extends Any> = IteratorLike<DeploymentNodeModel<A>>;
+type DeploymentElementModel<A extends Any = Any> = DeploymentNodeModel<A> | DeployedInstanceModel<A>;
+declare abstract class AbstractDeploymentElementModel<A extends Any> {
+    abstract readonly id: DeploymentFqn<A>;
+    abstract readonly _literalId: DeploymentId<A>;
+    abstract readonly parent: DeploymentNodeModel<A> | null;
+    abstract readonly title: string;
+    abstract readonly hierarchyLevel: number;
+    abstract readonly $model: LikeC4DeploymentModel<A>;
+    abstract readonly $node: DeploymentElement<A>;
+    abstract readonly tags: Tags<A>;
+    get style(): SetRequired<DeploymentElementStyle, 'shape' | 'color' | 'size'>;
+    get shape(): ElementShape;
+    get color(): Color;
+    get description(): string | null;
+    get technology(): string | null;
+    get links(): ReadonlyArray<Link>;
+    /**
+     * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
+     * (from closest to root)
+     */
+    ancestors(): DeploymentNodesIterator<A>;
+    /**
+     * Returns the common ancestor of this element and another element.
+     */
+    commonAncestor(another: DeploymentElementModel<A>): DeploymentNodeModel<A> | null;
+    /**
+     * Get all sibling (i.e. same parent)
+     */
+    siblings(): DeploymentElementsIterator<A>;
+    /**
+     * Check if the element is a sibling of another element
+     */
+    isSibling(other: DeploymentElementModel<A>): boolean;
+    /**
+     * Resolve siblings of the element and its ancestors
+     *  (from closest to root)
+     */
+    ascendingSiblings(): DeploymentElementsIterator<A>;
+    /**
+     * Resolve siblings of the element and its ancestors
+     *  (from root to closest)
+     */
+    descendingSiblings(): DeploymentElementsIterator<A>;
+    incoming(filter?: IncomingFilter): IteratorLike<DeploymentRelationModel<A>>;
+    outgoing(filter?: OutgoingFilter): IteratorLike<DeploymentRelationModel<A>>;
+    incomers(filter?: IncomingFilter): IteratorLike<DeploymentRelationEndpoint<A>>;
+    outgoers(filter?: OutgoingFilter): IteratorLike<DeploymentRelationEndpoint<A>>;
+    /**
+     * Iterate over all views that include this deployment element.
+     */
+    views(): IteratorLike<LikeC4ViewModel.DeploymentView<A>>;
+    isDeploymentNode(): this is DeploymentNodeModel<A>;
+    isInstance(): this is DeployedInstanceModel<A>;
+    abstract outgoingModelRelationships(): RelationshipsIterator<A>;
+    abstract incomingModelRelationships(): RelationshipsIterator<A>;
+    get allOutgoing(): RelationshipsAccum<A>;
+    get allIncoming(): RelationshipsAccum<A>;
+    getMetadata(): Metadata<A>;
+    getMetadata(field: MetadataKey<A>): string | undefined;
+    /**
+     * Checks if the deployment element has the given tag.
+     */
+    isTagged(tag: LooseTag<A>): boolean;
+}
+declare class DeploymentNodeModel<A extends Any = Any> extends AbstractDeploymentElementModel<A> {
+    readonly $model: LikeC4DeploymentModel<A>;
+    readonly $node: DeploymentNode<A>;
+    id: DeploymentFqn<A>;
+    _literalId: DeploymentId<A>;
+    title: string;
+    hierarchyLevel: number;
+    constructor($model: LikeC4DeploymentModel<A>, $node: DeploymentNode<A>);
+    get parent(): DeploymentNodeModel<A> | null;
+    get kind(): DeploymentKind<A>;
+    get tags(): Tags<A>;
+    children(): ReadonlySet<DeploymentElementModel<A>>;
+    descendants(sort?: 'asc' | 'desc'): DeploymentElementsIterator<A>;
+    isDeploymentNode(): this is DeploymentNodeModel<A>;
+    /**
+     * Iterate over all instances nested in this deployment node.
+     */
+    instances(): DeployedInstancesIterator<A>;
+    /**
+     * Returns deployed instance inside this deployment node
+     * if only there are no more instances
+     */
+    onlyOneInstance(): DeployedInstanceModel<A> | null;
+    /**
+     * Cached result of relationships from instances
+     */
+    private _relationshipsFromInstances;
+    private relationshipsFromInstances;
+    /**
+     * We return only relationships that are not already present in nested instances
+     */
+    outgoingModelRelationships(): RelationshipsIterator<A>;
+    /**
+     * We return only relationships that are not already present in nested instances
+     */
+    incomingModelRelationships(): RelationshipsIterator<A>;
+    /**
+     * Returns an iterator of relationships between nested instances
+     */
+    internalModelRelationships(): ReadonlySet<RelationshipModel<A>>;
+}
+declare class DeployedInstanceModel<A extends Any = Any> extends AbstractDeploymentElementModel<A> {
+    readonly $model: LikeC4DeploymentModel<A>;
+    readonly $instance: DeployedInstance<A>;
+    readonly element: ElementModel<A>;
+    readonly id: DeploymentFqn<A>;
+    readonly _literalId: DeploymentId<A>;
+    readonly title: string;
+    readonly hierarchyLevel: number;
+    constructor($model: LikeC4DeploymentModel<A>, $instance: DeployedInstance<A>, element: ElementModel<A>);
+    get $node(): DeployedInstance<A>;
+    get parent(): DeploymentNodeModel<A>;
+    get style(): SetRequired<DeploymentElementStyle, 'shape' | 'color' | 'size'>;
+    get shape(): ElementShape;
+    get color(): Color;
+    get tags(): Tags<A>;
+    get kind(): ElementKind<A>;
+    get description(): string | null;
+    get technology(): string | null;
+    get links(): ReadonlyArray<Link>;
+    isInstance(): this is DeployedInstanceModel<A>;
+    outgoingModelRelationships(): RelationshipsIterator<A>;
+    incomingModelRelationships(): RelationshipsIterator<A>;
+    /**
+     * Iterate over all views that include this instance.
+     * (Some views may include the parent deployment node instead of the instance.)
+     */
+    views(): IteratorLike<LikeC4ViewModel.DeploymentView<A>>;
+}
+declare class NestedElementOfDeployedInstanceModel<A extends Any = Any> {
+    readonly instance: DeployedInstanceModel<A>;
+    readonly element: ElementModel<A>;
+    constructor(instance: DeployedInstanceModel<A>, element: ElementModel<A>);
+    get id(): DeploymentFqn<A>;
+    get _literalId(): DeploymentId<A>;
+    get style(): SetRequired<DeploymentElementStyle, 'shape' | 'color'>;
+    get shape(): ElementShape;
+    get color(): Color;
+    get title(): string;
+    get description(): string | null;
+    get technology(): string | null;
+    isDeploymentNode(): this is DeploymentNodeModel<A>;
+    isInstance(): this is DeployedInstanceModel<A>;
+}
+type DeploymentRelationEndpoint<A extends Any = Any> = DeploymentElementModel<A> | NestedElementOfDeployedInstanceModel<A>;
+declare class DeploymentRelationModel<A extends Any = Any> implements AnyRelationshipModel<A> {
+    readonly $model: LikeC4DeploymentModel<A>;
+    readonly $relationship: DeploymentRelationship<A>;
+    boundary: DeploymentNodeModel<A> | null;
+    source: DeploymentRelationEndpoint<A>;
+    target: DeploymentRelationEndpoint<A>;
+    constructor($model: LikeC4DeploymentModel<A>, $relationship: DeploymentRelationship<A>);
+    get id(): RelationId;
+    get expression(): string;
+    get title(): string | null;
+    get technology(): string | null;
+    get description(): string | null;
+    get tags(): Tags<A>;
+    get kind(): RelationKind<A> | null;
+    get navigateTo(): LikeC4ViewModel<A> | null;
+    get links(): ReadonlyArray<Link>;
+    get color(): Color;
+    get line(): RelationshipLineType;
+    views(): IteratorLike<LikeC4ViewModel.DeploymentView<A>>;
+    isDeploymentRelation(): this is DeploymentRelationModel<A>;
+    isModelRelation(): this is RelationshipModel<A>;
+    getMetadata(): Metadata<A>;
+    getMetadata(field: MetadataKey<A>): string | undefined;
+    /**
+     * Checks if the relationship has the given tag.
+     */
+    isTagged(tag: LooseTag<A>): boolean;
+}
+declare class RelationshipsAccum<A extends Any = Any> {
+    readonly model: ReadonlySet<RelationshipModel<A>>;
+    readonly deployment: ReadonlySet<DeploymentRelationModel<A>>;
+    static empty<A extends Any>(): RelationshipsAccum<A>;
+    static from<A extends Any>(model: Iterable<RelationshipModel<A>> | undefined, deployment?: Iterable<DeploymentRelationModel<A>>): RelationshipsAccum<A>;
+    /**
+     * @param model relationships from logical model
+     * @param deployment relationships from deployment model
+     */
+    constructor(model?: ReadonlySet<RelationshipModel<A>>, deployment?: ReadonlySet<DeploymentRelationModel<A>>);
+    get isEmpty(): boolean;
+    get nonEmpty(): boolean;
+    get size(): number;
+    /**
+     * Returns new Accum containing all the elements which are both in this and otherAccum
+     */
+    intersect(otherAccum: RelationshipsAccum<A>): RelationshipsAccum<A>;
+    /**
+     * Returns new Accum containing all the elements which are both in this and otherAccum
+     */
+    difference(otherAccum: RelationshipsAccum<A>): RelationshipsAccum<A>;
+    /**
+     * Returns new Accum containing all the elements from both
+     */
+    union(otherAccum: RelationshipsAccum<A>): RelationshipsAccum<A>;
+}
+
+/**
+ *  When you do not need types in the model
+ */
+type AnyLikeC4Model = LikeC4Model<any>;
+declare class LikeC4Model<A extends Any = Unknown> {
+    /**
+     * Don't use in runtime, only for type inference
+     */
+    readonly Aux: A;
+    protected readonly _elements: Map<Fqn<A>, ElementModel<A>>;
+    protected readonly _parents: Map<Fqn<A>, ElementModel<A>>;
+    protected readonly _children: DefaultMap<Fqn<A>, Set<ElementModel<A>>>;
+    protected readonly _rootElements: Set<ElementModel<A>>;
+    protected readonly _relations: Map<RelationId<string>, RelationshipModel<A>>;
+    protected readonly _incoming: DefaultMap<Fqn<A>, Set<RelationshipModel<A>>>;
+    protected readonly _outgoing: DefaultMap<Fqn<A>, Set<RelationshipModel<A>>>;
+    protected readonly _internal: DefaultMap<Fqn<A>, Set<RelationshipModel<A>>>;
+    protected readonly _views: Map<ViewId<A>, LikeC4ViewModel<A, $View<A>>>;
+    protected readonly _allTags: DefaultMap<Tag<A>, Set<ElementModel<A> | LikeC4ViewModel<A, $View<A>> | RelationshipModel<A>>>;
+    static fromParsed<T extends Any>(model: ParsedLikeC4ModelData<T>): LikeC4Model.Parsed<T>;
+    /**
+     * Creates a new LikeC4Model instance from the provided model data.
+     * Model with parsed data will not have views, as they must be computed
+     * (this model is used for computing views)
+     *
+     * @typeParam M - Type parameter constrained to AnyLikeC4Model
+     * @param model - The model data to create a LikeC4Model from
+     * @returns A new LikeC4Model instance with the type derived from the input model
+     */
+    static create<T extends Any>(model: ParsedLikeC4ModelData<T>): LikeC4Model.Parsed<T>;
+    static create<T extends Any>(model: LayoutedLikeC4ModelData<T>): LikeC4Model.Layouted<T>;
+    static create<T extends Any>(model: ComputedLikeC4ModelData<T>): LikeC4Model.Computed<T>;
+    /**
+     * Creates a new LikeC4Model instance and infers types from a model dump.\
+     * Model dump expected to be computed or layouted.
+     *
+     * @typeParam D - A constant type parameter extending LikeC4ModelDump
+     * @param dump - The model dump to create the instance from
+     * @returns A  new LikeC4Model instance with types inferred from the dump
+     */
+    static fromDump<const D extends LikeC4ModelDump>(dump: D): LikeC4Model<AuxFromDump<D>>;
+    readonly deployment: LikeC4DeploymentModel<A>;
+    readonly $data: $ModelData<A>;
+    constructor($data: $ModelData<A>);
+    /**
+     * Type narrows the model to the parsed stage.
+     * This is useful for tests
+     */
+    get asParsed(): LikeC4Model.Parsed<A>;
+    /**
+     * Type narrows the model to the layouted stage.
+     * This is useful for tests
+     */
+    get asComputed(): LikeC4Model.Computed<A>;
+    /**
+     * Type narrows the model to the layouted stage.
+     * This is useful for tests
+     */
+    get asLayouted(): LikeC4Model.Layouted<A>;
+    /**
+     * Type guard the model to the parsed stage.
+     */
+    isParsed(this: LikeC4Model<any>): this is LikeC4Model<toParsed<A>>;
+    /**
+     * Type guard the model to the layouted stage.
+     */
+    isLayouted(this: LikeC4Model<any>): this is LikeC4Model<toLayouted<A>>;
+    /**
+     * Type guard the model to the computed stage.
+     */
+    isComputed(this: LikeC4Model<any>): this is LikeC4Model<toComputed<A>>;
+    /**
+     * Keeping here for backward compatibility
+     * @deprecated use {@link $data}
+     */
+    get $model(): $ModelData<A>;
+    get stage(): Stage<A>;
+    get projectId(): ProjectId$1<A>;
+    get specification(): Specification<A>;
+    get globals(): ModelGlobals;
+    element(el: ElementOrFqn<A>): ElementModel<A>;
+    findElement(el: LooseElementId<A>): ElementModel<A> | null;
+    /**
+     * Returns the root elements of the model.
+     */
+    roots(): ElementsIterator<A>;
+    /**
+     * Returns all elements in the model.
+     */
+    elements(): ElementsIterator<A>;
+    /**
+     * Returns all relationships in the model.
+     */
+    relationships(): RelationshipsIterator<A>;
+    /**
+     * 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(rel: RelationOrId, type: 'model'): RelationshipModel<A>;
+    relationship(rel: RelationOrId, type: 'deployment'): DeploymentRelationModel<A>;
+    relationship(rel: RelationId, type?: 'model' | 'deployment'): RelationshipModel<A> | DeploymentRelationModel<A>;
+    findRelationship(id: string, type: 'model'): RelationshipModel<A> | null;
+    findRelationship(id: string, type: 'deployment'): DeploymentRelationModel<A> | null;
+    findRelationship(id: string, type?: 'model' | 'deployment'): RelationshipModel<A> | DeploymentRelationModel<A> | null;
+    /**
+     * Returns all views in the model.
+     */
+    views(): IteratorLike<LikeC4ViewModel<A, $View<A>>>;
+    /**
+     * Returns a specific view by its ID.
+     */
+    view(viewId: ViewId<A> | {
+        id: ViewId$1<ViewId<A>>;
+    }): LikeC4ViewModel<A, $View<A>>;
+    findView(viewId: LooseViewId<A>): LikeC4ViewModel<A, $View<A>> | null;
+    /**
+     * Returns the parent element of given element.
+     * @see ancestors
+     */
+    parent(element: ElementOrFqn<A>): ElementModel<A> | null;
+    /**
+     * Get all children of the element (only direct children),
+     * @see descendants
+     */
+    children(element: ElementOrFqn<A>): ReadonlySet<ElementModel<A>>;
+    /**
+     * Get all sibling (i.e. same parent)
+     */
+    siblings(element: ElementOrFqn<A>): ElementsIterator<A>;
+    /**
+     * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
+     * (from closest to root)
+     */
+    ancestors(element: ElementOrFqn<A>): ElementsIterator<A>;
+    /**
+     * Get all descendant elements (i.e. children, children’s children, etc.)
+     */
+    descendants(element: ElementOrFqn<A>): ElementsIterator<A>;
+    /**
+     * Incoming relationships to the element and its descendants
+     * @see incomers
+     */
+    incoming(element: ElementOrFqn<A>, filter?: IncomingFilter): RelationshipsIterator<A>;
+    /**
+     * Outgoing relationships from the element and its descendants
+     * @see outgoers
+     */
+    outgoing(element: ElementOrFqn<A>, filter?: OutgoingFilter): RelationshipsIterator<A>;
+    /**
+     * Returns all tags used in the model, sorted alphabetically.
+     */
+    get tags(): Tags<A>;
+    /**
+     * Returns all tags used in the model, sorted by usage count (descending).
+     */
+    get tagsSortedByUsage(): ReadonlyArray<{
+        tag: Tag<A>;
+        count: number;
+        tagged: ReadonlySet<ElementModel<A> | RelationshipModel<A> | LikeC4ViewModel<A>>;
+    }>;
+    /**
+     * Returns all elements, relationships and views marked with the given tag.
+     */
+    findByTag(tag: Tag<A>): IteratorLike<ElementModel<A> | RelationshipModel<A> | LikeC4ViewModel<A>>;
+    findByTag(tag: Tag<A>, type: 'elements'): IteratorLike<ElementModel<A>>;
+    findByTag(tag: Tag<A>, type: 'views'): IteratorLike<LikeC4ViewModel<A>>;
+    findByTag(tag: Tag<A>, type: 'relationships'): IteratorLike<RelationshipModel<A>>;
+    /**
+     * Returns all elements of the given kind.
+     */
+    elementsOfKind(kind: ElementKind<A>): IteratorLike<ElementModel<A>>;
+    /**
+     * Returns all elements that match the given where operator.
+     *
+     * @example
+     * ```ts
+     * model.where({
+     *   and: [
+     *     { kind: 'component' },
+     *     {
+     *       or: [
+     *         { tag: 'old' },
+     *         { tag: { neq: 'new' } },
+     *       ],
+     *     },
+     *   ],
+     * })
+     * ```
+     */
+    elementsWhere(where: WhereOperator<A>): IteratorLike<ElementModel<A>>;
+    /**
+     * Returns all **model** relationships that match the given where operator.
+     *
+     * @example
+     * ```ts
+     * model.relationshipsWhere({
+     *   and: [
+     *     { kind: 'uses' },
+     *     {
+     *       or: [
+     *         { tag: 'old' },
+     *         { tag: { neq: 'new' } },
+     *       ],
+     *     },
+     *   ],
+     * })
+     * ```
+     */
+    relationshipsWhere(where: WhereOperator<A>): IteratorLike<RelationshipModel<A>>;
+    private addElement;
+    private addImportedElement;
+    private addRelation;
+}
+declare namespace LikeC4Model {
+    const EMPTY: LikeC4Model<Aux<"computed", string, string, string, string, SpecAux<string, string, string, string, string>>>;
+    type Parsed<A = Unknown> = Unknown extends A ? LikeC4Model<UnknownParsed> : A extends Aux<any, infer E, infer D, infer V, infer P, infer Spec> ? LikeC4Model<Aux<'parsed', E, D, V, P, Spec>> : never;
+    type Computed<A = Unknown> = Unknown extends A ? LikeC4Model<UnknownComputed> : A extends Aux<any, infer E, infer D, infer V, infer P, infer Spec> ? LikeC4Model<Aux<'computed', E, D, V, P, Spec>> : never;
+    type Layouted<A = Unknown> = Unknown extends A ? LikeC4Model<UnknownLayouted> : A extends Aux<any, infer E, infer D, infer V, infer P, infer Spec> ? LikeC4Model<Aux<'layouted', E, D, V, P, Spec>> : never;
+    type Node<A = Unknown> = A extends Any ? NodeModel<A> : never;
+    type Element<A = Unknown> = A extends Any ? ElementModel<A> : never;
+    type Relationship<A = Unknown> = A extends Any ? RelationshipModel<A> : never;
+    type View<A = Unknown> = A extends Any ? $ViewModel<A> : never;
+    type DeploymentNode<A = Unknown> = A extends Any ? DeploymentNodeModel<A> : never;
+    type DeployedInstance<A = Unknown> = A extends Any ? DeployedInstanceModel<A> : never;
+    type AnyRelation<M = Unknown> = M extends Any ? RelationshipModel<M> | DeploymentRelationModel<M> : never;
+}
+
+export { type AnyRelationshipModel as A, type DeploymentElementModel as D, ElementModel as E, type IncomingFilter as I, LikeC4Model as L, NestedElementOfDeployedInstanceModel as N, type OutgoingFilter as O, RelationshipModel as R, RelationshipsAccum as a, DeploymentNodeModel as b, DeploymentRelationModel as c, DeployedInstanceModel as d, LikeC4ViewModel as e, NodeModel as f, EdgeModel as g, type AnyLikeC4Model as h, type DeploymentRelationEndpoint as i, LikeC4DeploymentModel as j, type DeploymentOrFqn as k, type EdgeOrId as l, type ElementOrFqn as m, type NodeOrId as n };