@likec4/core 1.17.1 → 1.18.0

package/dist/model/index.d.mts

@@ -0,0 +1,642 @@
+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';
+
+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>;
+    /**
+     * 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>;
+}
+
+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>;
+    }
+}
+
+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>>;
+    /**
+     * Get all sibling (i.e. same parent)
+     */
+    siblings(element: M['DeploymentOrFqn']): DeploymentElementsIterator<M>;
+    /**
+     * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
+     * (from closest to root)
+     */
+    ancestors(element: M['DeploymentOrFqn']): DeploymentNodesIterator<M>;
+    /**
+     * Get all descendant elements (i.e. children, children’s children, etc.)
+     */
+    descendants(element: M['DeploymentOrFqn']): DeploymentElementsIterator<M>;
+    /**
+     * Incoming relationships to the element and its descendants
+     * @see incomers
+     */
+    incoming(element: M['DeploymentOrFqn'], filter?: IncomingFilter): IteratorLike<DeploymentRelationModel<M>>;
+    /**
+     * Outgoing relationships from the element and its descendants
+     * @see outgoers
+     */
+    outgoing(element: M['DeploymentOrFqn'], filter?: OutgoingFilter): IteratorLike<DeploymentRelationModel<M>>;
+    private addElement;
+    private addRelation;
+}
+
+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;
+    /**
+     * We return only relationships that are not already present in nested instances
+     */
+    outgoingFromModel(): RelationshipsIterator<M>;
+    /**
+     * We return only relationships that are not already present in nested instances
+     */
+    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
+     */
+    constructor(model: ReadonlySet<RelationshipModel<M>>, deployment: ReadonlySet<DeploymentRelationModel<M>>);
+    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<M>): RelationshipsAccum<M>;
+    /**
+     * Returns new Accum containing all the elements which are both in this and otherAccum
+     */
+    difference(otherAccum: RelationshipsAccum<M>): RelationshipsAccum<M>;
+    /**
+     * Returns new Accum containing all the elements from both
+     */
+    union(otherAccum: RelationshipsAccum<M>): RelationshipsAccum<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;
+}
+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>>>;
+}
+
+export { LikeC4DeploymentModel, LikeC4Model, Aux as LikeC4ModelAux, LikeC4ViewModel };