@likec4/core 1.31.0 → 1.32.1

package/dist/model/index.d.mts

@@ -1,10 +1,154 @@
-import { A as AnyAux, d as DeploymentElementModel, E as ElementModel, D as DeployedInstanceModel, e as DeploymentNodeModel } from '../shared/core.CQDU11hR.mjs';
-export { b as Aux, f as DeploymentRelationModel, g as EdgeModel, h as LikeC4DeploymentModel, L as LikeC4Model, i as LikeC4ViewModel, N as NodeModel, R as RelationshipModel } from '../shared/core.CQDU11hR.mjs';
-import { C as Connection, D as DeploymentConnectionModel, a as ConnectionModel } from '../shared/core.Dx7siloV.mjs';
-import { I as IterableContainer, R as ReorderedArray } from '../shared/core.D2830qgg.mjs';
+import { E as ElementModel, D as DeploymentElementModel, a as RelationshipsAccum, b as DeploymentNodeModel, R as RelationshipModel, c as DeploymentRelationModel, d as DeployedInstanceModel, A as AnyRelationshipModel, N as NestedElementOfDeployedInstanceModel, e as LikeC4ViewModel, f as NodeModel, g as EdgeModel } from '../shared/core.znRaUX_A.mjs';
+export { h as AnyLikeC4Model, k as DeploymentOrFqn, i as DeploymentRelationEndpoint, l as EdgeOrId, m as ElementOrFqn, I as IncomingFilter, j as LikeC4DeploymentModel, L as LikeC4Model, n as NodeOrId, O as OutgoingFilter } from '../shared/core.znRaUX_A.mjs';
+import { A as Any, h as EdgeId, U as Unknown } from '../shared/core.BaYE_r29.mjs';
+export { b as Aux, S as SpecAux, a as aux } from '../shared/core.BaYE_r29.mjs';
+import { F as Fqn, I as IteratorLike } from '../shared/core.BuO4ncfY.mjs';
+import { I as IterableContainer, R as ReorderedArray } from '../shared/core.Pf5I9o0e.mjs';
+export { y as AuxFromDump, A as AuxFromLikeC4ModelData } from '../shared/core.DXzRBkuI.mjs';
+import '../shared/core.CywrQs86.mjs';
 import 'type-fest';
-import '../shared/core.SjLhMA7a.mjs';
-import '../shared/core.DJvmfnEi.mjs';
+
+interface Connection<Elem = ElementModel<Any> | DeploymentElementModel<Any>, Id = string> {
+    readonly id: Id;
+    readonly source: Elem;
+    readonly target: Elem;
+    /**
+     * Common ancestor of the source and target elements.
+     * 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 {  };
+}
+
+declare const customInspectSymbol: unique symbol;
+
+/**
+ * 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<A extends Any = Any> implements Connection<DeploymentElementModel<A>, EdgeId> {
+    readonly source: DeploymentElementModel<A>;
+    readonly target: DeploymentElementModel<A>;
+    readonly relations: RelationshipsAccum<A>;
+    readonly id: EdgeId;
+    constructor(source: DeploymentElementModel<A>, target: DeploymentElementModel<A>, relations: RelationshipsAccum<A>);
+    /**
+     * Human readable expression of the connection
+     * Mostly used for testing and debugging
+     */
+    get expression(): string;
+    private _boundary;
+    /**
+     * Common ancestor of the source and target elements.
+     * Represents the boundary of the connection.
+     */
+    get boundary(): DeploymentNodeModel<A> | null;
+    nonEmpty(): boolean;
+    [customInspectSymbol](depth: any, inspectOptions: any, inspect: any): string;
+    toString(): string;
+    /**
+     * Check if connection contains deployment relation,
+     * that is directly connected to source or target.
+     */
+    hasDirectDeploymentRelation(): boolean;
+    values(): IteratorLike<RelationshipModel<A> | DeploymentRelationModel<A>>;
+    /**
+     * Merge with another connections, if it has the same source and target.
+     * Returns new connection with union of relationships.
+     */
+    mergeWith(others: DeploymentConnectionModel<A>[]): DeploymentConnectionModel<A>;
+    /**
+     * Merge with another connection, if it has the same source and target.
+     * Returns new connection with union of relationships.
+     */
+    mergeWith(other: DeploymentConnectionModel<A>): DeploymentConnectionModel<A>;
+    difference(other: DeploymentConnectionModel<A>): DeploymentConnectionModel<A>;
+    intersect(other: DeploymentConnectionModel<A>): DeploymentConnectionModel<A>;
+    equals(other: Connection): boolean;
+    /**
+     * Creates a clone of the current `DeploymentConnectionModel` instance with optional overrides.
+     * if `null` is provided in overrides, the corresponding relation set will be empty.
+     */
+    update(overrides?: {
+        model?: ReadonlySet<RelationshipModel<A>> | null;
+        deployment?: ReadonlySet<DeploymentRelationModel<A>> | null;
+    }): DeploymentConnectionModel<A>;
+}
+
+/**
+ * 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<A extends Any = Unknown> implements Connection<ElementModel<A>, EdgeId> {
+    readonly source: ElementModel<A>;
+    readonly target: ElementModel<A>;
+    readonly relations: ReadonlySet<RelationshipModel<A>>;
+    readonly id: EdgeId;
+    constructor(source: ElementModel<A>, target: ElementModel<A>, relations?: ReadonlySet<RelationshipModel<A>>);
+    private _boundary;
+    /**
+     * Common ancestor of the source and target elements.
+     * Represents the boundary of the connection.
+     */
+    get boundary(): ElementModel<A> | null;
+    /**
+     * Human readable expression of the connection
+     * Mostly used for testing and debugging
+     */
+    get expression(): string;
+    /**
+     * Returns true if only includes relations between the source and target elements.
+     */
+    get isDirect(): boolean;
+    /**
+     * Returns true if includes relations between nested elements of the source and target elements.
+     */
+    get isImplicit(): boolean;
+    get directRelations(): ReadonlySet<RelationshipModel<A>>;
+    nonEmpty(): boolean;
+    mergeWith(other: ConnectionModel<A>): ConnectionModel<A>;
+    difference(other: ConnectionModel<A>): ConnectionModel<A>;
+    intersect(other: ConnectionModel<A>): ConnectionModel<A>;
+    equals(other: Connection): boolean;
+    /**
+     * 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.
+     */
+    update(relations: ReadonlySet<RelationshipModel<A>>): ConnectionModel<A>;
+    [customInspectSymbol](depth: any, inspectOptions: any, inspect: any): string;
+    toString(): string;
+    /**
+     * 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
+     */
+    reversed(search?: boolean): ConnectionModel<A>;
+}
 
 /**
  * Check if connection is nested inside another connection
@@ -36,12 +180,12 @@ declare function findAscendingConnections<C extends ConnectionElemId>(connection
  * 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[];
+declare function mergeConnections<C extends IterableContainer<Connection<any, any>>>(connections: C): Array<C[number]>;
 /**
  * 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[];
+declare function differenceConnections<C extends Connection<any, any>>(source: Iterable<C>, exclude: Iterable<C>): C[];
 type WithSourceTarget<T = unknown> = {
     source: T;
     target: T;
@@ -68,20 +212,20 @@ declare function isAnyInOut<T extends string>(a: WithSourceTarget<WithId<T>>, so
  *
  * @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 [];
+declare function findConnection$1<M extends Any>(source: DeploymentElementModel<M>, target: DeploymentElementModel<NoInfer<M>>, direction: 'directed'): readonly [DeploymentConnectionModel<M>] | readonly [];
+declare function findConnection$1<M extends Any>(source: DeploymentElementModel<M>, target: DeploymentElementModel<NoInfer<M>>, direction: 'both'): readonly [DeploymentConnectionModel<M>, DeploymentConnectionModel<M>] | readonly [DeploymentConnectionModel<M>] | readonly [];
+declare function findConnection$1<M extends Any>(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>[];
+declare function findConnectionsBetween$1<M extends Any>(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 function findConnectionsWithin$1<M extends Any>(elements: Iterable<DeploymentElementModel<M>>): readonly DeploymentConnectionModel<M>[];
 
 declare namespace find$1 {
   export { findConnection$1 as findConnection, findConnectionsBetween$1 as findConnectionsBetween, findConnectionsWithin$1 as findConnectionsWithin };
@@ -93,17 +237,17 @@ declare namespace find$1 {
  * @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>] | [];
+declare function findConnection<A extends Any>(source: ElementModel<A>, target: ElementModel<A>, direction?: 'directed' | 'both'): [ConnectionModel<A>, ConnectionModel<A>] | [ConnectionModel<A>] | [];
 /**
  * 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>[];
+declare function findConnectionsBetween<M extends Any>(element: ElementModel<M>, others: Iterable<ElementModel<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 function findConnectionsWithin<M extends Any>(elements: Iterable<ElementModel<M>>): readonly ConnectionModel<M>[];
 
 declare const find_findConnection: typeof findConnection;
 declare const find_findConnectionsBetween: typeof findConnectionsBetween;
@@ -112,7 +256,17 @@ declare namespace find {
   export { find_findConnection as findConnection, find_findConnectionsBetween as findConnectionsBetween, find_findConnectionsWithin as findConnectionsWithin };
 }
 
-declare function isDeploymentNode(model: DeploymentElementModel): model is DeploymentNodeModel;
-declare function isDeployedInstance(model: DeploymentElementModel): model is DeployedInstanceModel;
+type AnyModel<A extends Any> = DeploymentNodeModel<A> | DeployedInstanceModel<A> | DeploymentRelationModel<A> | AnyRelationshipModel<A> | NestedElementOfDeployedInstanceModel<A> | ElementModel<A> | RelationshipModel<A> | LikeC4ViewModel<A> | NodeModel<A> | EdgeModel<A>;
+declare function isDeploymentNodeModel<M extends Any>(model: AnyModel<M>): model is DeploymentNodeModel<M>;
+declare function isDeployedInstanceModel<M extends Any>(model: AnyModel<M>): model is DeployedInstanceModel<M>;
+declare function isDeploymentElementModel<M extends Any>(model: AnyModel<M>): model is DeploymentElementModel<M>;
+declare function isNestedElementOfDeployedInstanceModel<M extends Any>(model: AnyModel<M>): model is NestedElementOfDeployedInstanceModel<M>;
+declare function isDeploymentRelationModel<M extends Any>(x: AnyModel<M>): x is DeploymentRelationModel<M>;
+declare function isRelationModel<M extends Any>(x: AnyModel<M>): x is RelationshipModel<M>;
+
+declare function isElementModel<M extends Any>(element: AnyModel<M>): element is ElementModel<M>;
+declare function isLikeC4ViewModel<M extends Any>(view: AnyModel<M>): view is LikeC4ViewModel<M>;
+declare function isNodeModel<M extends Any>(node: AnyModel<M>): node is NodeModel<M>;
+declare function isEdgeModel<M extends Any>(edge: AnyModel<M>): edge is EdgeModel<M>;
 
-export { AnyAux, Connection, ConnectionModel, DeployedInstanceModel, DeploymentConnectionModel, DeploymentElementModel, DeploymentNodeModel, ElementModel, find$1 as deploymentConnection, differenceConnections, findAscendingConnections, findDeepestNestedConnection, findDescendantConnections, hasSameSource, hasSameSourceTarget, hasSameTarget, isAnyInOut, isDeployedInstance, isDeploymentNode, isIncoming, isNestedConnection, isOutgoing, mergeConnections, find as modelConnection, sortConnectionsByBoundaryHierarchy, sortDeepestFirst };
+export { Any, Any as AnyAux, Connection, ConnectionModel, DeployedInstanceModel, DeploymentConnectionModel, DeploymentElementModel, DeploymentNodeModel, DeploymentRelationModel, EdgeModel, ElementModel, LikeC4ViewModel, NodeModel, RelationshipModel, RelationshipsAccum, find$1 as deploymentConnection, differenceConnections, findAscendingConnections, findDeepestNestedConnection, findDescendantConnections, hasSameSource, hasSameSourceTarget, hasSameTarget, isAnyInOut, isDeployedInstanceModel, isDeploymentElementModel, isDeploymentNodeModel, isDeploymentRelationModel, isEdgeModel, isElementModel, isIncoming, isLikeC4ViewModel, isRelationModel as isModelRelation, isNestedConnection, isNestedElementOfDeployedInstanceModel, isNodeModel, isOutgoing, isRelationModel, isRelationModel as isRelationshipModel, mergeConnections, find as modelConnection, sortConnectionsByBoundaryHierarchy, sortDeepestFirst };

package/dist/model/index.mjs

@@ -1 +1,6 @@
-export { C as Connection, e as ConnectionModel, D as DeployedInstanceModel, f as DeploymentConnectionModel, g as DeploymentNodeModel, h as DeploymentRelationModel, E as EdgeModel, j as ElementModel, k as LikeC4DeploymentModel, L as LikeC4Model, m as LikeC4ViewModel, N as NodeModel, R as RelationshipModel, n as deploymentConnection, o as differenceConnections, p as findAscendingConnections, q as findDeepestNestedConnection, s as findDescendantConnections, v as hasSameSource, x as hasSameSourceTarget, y as hasSameTarget, z as isAnyInOut, M as isDeployedInstance, O as isDeploymentNode, A as isIncoming, B as isNestedConnection, F as isOutgoing, H as mergeConnections, I as modelConnection, J as sortConnectionsByBoundaryHierarchy, K as sortDeepestFirst } from '../shared/core.Bq753SYD.mjs';
+export { C as Connection, z as ConnectionModel, I as DeployedInstanceModel, D as DeploymentConnectionModel, J as DeploymentNodeModel, K as DeploymentRelationModel, N as EdgeModel, E as ElementModel, M as LikeC4DeploymentModel, L as LikeC4Model, O as LikeC4ViewModel, P as NodeModel, A as RelationshipModel, R as RelationshipsAccum, d as deploymentConnection, c as differenceConnections, f as findAscendingConnections, v as findDeepestNestedConnection, u as findDescendantConnections, B as hasSameSource, F as hasSameSourceTarget, G as hasSameTarget, w as isAnyInOut, l as isDeployedInstanceModel, o as isDeploymentElementModel, n as isDeploymentNodeModel, Q as isDeploymentRelationModel, V as isEdgeModel, j as isElementModel, y as isIncoming, T as isLikeC4ViewModel, S as isModelRelation, e as isNestedConnection, k as isNestedElementOfDeployedInstanceModel, U as isNodeModel, x as isOutgoing, S as isRelationModel, S as isRelationshipModel, m as mergeConnections, q as modelConnection, s as sortConnectionsByBoundaryHierarchy, H as sortDeepestFirst } from '../shared/core.cbA9VZ02.mjs';
+import '../shared/core.rmvsy0n3.mjs';
+import '../shared/core.Cy9smucx.mjs';
+import '../shared/core.CUYDgv2-.mjs';
+import '../shared/core.DbRvwARP.mjs';
+import '../shared/core.DoK86JEe.mjs';

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

@@ -0,0 +1,258 @@
+import { IfNever, IsNever, IsLiteral } from 'type-fest';
+import { D as DeploymentFqn$1, C as Coalesce, F as Fqn$1, R as RelationId$1, N as NodeId$1, E as EdgeId$1, P as ProjectId$1, V as ViewId$1, T as Tag$1, a as ElementKind$1, b as DeploymentKind$1, c as RelationshipKind, L as Link } from './core.BuO4ncfY.mjs';
+
+/**
+ * Determines the stage of the model:
+ * 1. `parsed` - parsed from DSL or returned from Builder
+ * 2. `computed` - views are computed
+ * 3. `layouted` - views are layouted
+ *
+ * @internal
+ */
+type ModelStage = 'parsed' | 'computed' | 'layouted';
+type ExtractOnStage<T, S extends ModelStage> = Extract<T, {
+    [_stage]: S;
+}>;
+declare function isOnStage<T extends {
+    [_stage]: ModelStage;
+}, S extends ModelStage>(value: T, stage: S): value is ExtractOnStage<T, S>;
+/**
+ * Property name to store the stage of the model
+ *
+ * @internal
+ */
+declare const _stage = "_stage";
+type _stage = typeof _stage;
+/**
+ * Property name to store type information, used to identify the type of the view
+ *
+ * @internal
+ */
+declare const _type = "_type";
+type _type = typeof _type;
+
+/**
+ * Specification types (kinds, tags, metadata keys)
+ *
+ * @param ElementKind - Literal union of element kinds
+ * @param DeploymentKind - Literal union of deployment kinds
+ * @param RelationKind - Literal union of relationship kinds
+ * @param Tag - Literal union of tags
+ * @param MetadataKey - Literal union of metadata keys
+ */
+interface SpecAux<ElementKind extends string, DeploymentKind extends string, RelationKind extends string, Tag extends string, MetadataKey extends string> {
+    ElementKind: ElementKind;
+    DeploymentKind: DeploymentKind;
+    RelationKind: RelationKind;
+    Tag: Tag;
+    MetadataKey: MetadataKey;
+}
+type AnySpec = SpecAux<any, any, any, any, any>;
+/**
+ * Auxilary interface to keep inferred types
+ *
+ * @typeParam Stage - View stage
+ * @typeParam Element - Literal union of FQNs of model elements
+ * @typeParam Deployment - Literal union of FQNs of deployment elements
+ * @typeParam View - Literal union of view identifiers
+ * @typeParam Project - Project identifier type
+ * @typeParam Spec - Specification types (kinds, tags, metadata keys)
+ */
+interface Aux<Stage extends ModelStage, Element extends string, Deployment extends string, View extends string, Project extends string, Spec extends SpecAux<string, string, string, string, string>> {
+    Stage: Stage;
+    ProjectId: Project;
+    ElementId: Element;
+    DeploymentId: Deployment;
+    ViewId: View;
+    ElementKind: Spec['ElementKind'];
+    DeploymentKind: Spec['DeploymentKind'];
+    RelationKind: Spec['RelationKind'];
+    Tag: Spec['Tag'];
+    MetadataKey: Spec['MetadataKey'];
+}
+type Any = Aux<any, any, any, any, any, SpecAux<any, any, any, any, any>>;
+
+type Never = Aux<never, never, never, never, never, SpecAux<never, never, never, never, never>>;
+/**
+ * Fallback when {@link Aux} can't be inferred.
+ * By default assumes non parsed model
+ */
+type Unknown = Aux<'layouted' | 'computed', string, string, string, string, SpecAux<string, string, string, string, string>>;
+type UnknownParsed = Aux<'parsed', string, string, string, string, SpecAux<string, string, string, string, string>>;
+type UnknownComputed = Aux<'computed', string, string, string, string, SpecAux<string, string, string, string, string>>;
+type UnknownLayouted = Aux<'layouted', string, string, string, string, SpecAux<string, string, string, string, string>>;
+/**
+ * Reads stage from Aux
+ */
+type Stage<A> = A extends Aux<infer S, any, any, any, any, any> ? IfNever<S, never, Coalesce<S, ModelStage>> : never;
+/**
+ * Picks type based on stage from Aux
+ */
+type PickByStage<A extends Any, OnParsed, OnComputed, OnLayouted = OnComputed> = {
+    parsed: OnParsed;
+    computed: OnComputed;
+    layouted: OnLayouted;
+}[A['Stage']];
+type setStage<A, S extends ModelStage> = A extends Aux<any, infer E, infer D, infer V, infer P, infer Spec> ? Aux<S, E, D, V, P, Spec> : never;
+type toParsed<A> = A extends Aux<any, infer E, infer D, infer V, infer P, infer Spec> ? Aux<'parsed', E, D, V, P, Spec> : never;
+type toComputed<A> = A extends Aux<any, infer E, infer D, infer V, infer P, infer Spec> ? Aux<'computed', E, D, V, P, Spec> : never;
+type toLayouted<A> = A extends Aux<any, infer E, infer D, infer V, infer P, infer Spec> ? Aux<'layouted', E, D, V, P, Spec> : never;
+/**
+ * Project identifier from Aux
+ */
+type ProjectId<A> = A extends infer T extends Any ? Coalesce<T['ProjectId']> : never;
+/**
+ * Element FQN from Aux as branded type
+ */
+type Fqn<A> = A extends infer T extends Any ? Fqn$1<ElementId<T>> : never;
+/**
+ * Element FQN from Aux as a literal union
+ */
+type ElementId<A> = A extends infer T extends Any ? Coalesce<T['ElementId']> : never;
+/**
+ * Deployment FQN from Aux as branded type
+ */
+type DeploymentFqn<A> = A extends infer T extends Any ? DeploymentFqn$1<DeploymentId<T>> : never;
+/**
+ * Deployment FQN from Aux as a literal union
+ * @alias {@link DeploymentFqn}
+ */
+type DeploymentId<A> = A extends infer T extends Any ? Coalesce<T['DeploymentId']> : never;
+/**
+ * View identifier from Aux as a literal union
+ */
+type ViewId<A> = A extends infer T extends Any ? Coalesce<T['ViewId']> : never;
+type RelationId = RelationId$1;
+type NodeId = NodeId$1;
+type EdgeId = EdgeId$1;
+/**
+ * ElementKind from Aux as a literal union
+ */
+type ElementKind<A> = A extends infer T extends Any ? Coalesce<T['ElementKind']> : never;
+/**
+ * DeploymentKind from Aux as a literal union
+ */
+type DeploymentKind<A> = A extends infer T extends Any ? Coalesce<T['DeploymentKind']> : never;
+/**
+ * RelationKind from Aux as a literal union
+ */
+type RelationKind<A> = A extends infer T extends Any ? Coalesce<T['RelationKind']> : never;
+/**
+ * Tags from Aux as a literal union
+ */
+type Tag<A> = A extends infer T extends Any ? Coalesce<T['Tag']> : never;
+/**
+ * Array of tags from Aux
+ */
+type Tags<A extends Any> = readonly Tag<A>[];
+/**
+ * Metadata key from Aux
+ */
+type MetadataKey<A> = A extends infer T extends Any ? Coalesce<T['MetadataKey']> : never;
+/**
+ * Metadata object from Aux
+ */
+type Metadata<A extends Any> = IsNever<A['MetadataKey']> extends true ? never : IsLiteral<A['MetadataKey']> extends true ? {
+    [key in Coalesce<A['MetadataKey']>]?: string;
+} : Record<string, string>;
+/**
+ * All known kinds from Aux as a literal union.
+ */
+type AllKinds<A> = ElementKind<A> | DeploymentKind<A> | RelationKind<A>;
+/**
+ * Specification from Aux
+ */
+type Spec<A> = A extends Aux<any, any, any, any, any, infer S> ? S : never;
+type StrictProjectId<A> = A extends infer T extends Any ? ProjectId$1<ProjectId<T>> : never;
+
+type StrictViewId<A> = A extends infer T extends Any ? ViewId$1<ViewId<T>> : never;
+type StrictTag<A> = A extends infer T extends Any ? Tag$1<Tag<T>> : never;
+type StrictElementKind<A> = A extends infer T extends Any ? ElementKind$1<ElementKind<T>> : never;
+type StrictDeploymentKind<A> = A extends infer T extends Any ? DeploymentKind$1<DeploymentKind<T>> : never;
+type StrictRelationKind<A> = A extends infer T extends Any ? RelationshipKind<RelationKind<T>> : never;
+type WithTags<A extends Any> = {
+    readonly tags: Tags<A>;
+};
+type WithOptionalTags<A extends Any> = {
+    readonly tags?: Tags<A> | null;
+};
+type WithLinks = {
+    readonly links: readonly Link[];
+};
+type WithOptionalLinks = {
+    readonly links?: readonly Link[] | null;
+};
+type WithMetadata<A extends Any> = {
+    readonly metadata?: Metadata<A>;
+};
+/**
+ * @see {@link LiteralUnion} from type-fest (https://github.com/sindresorhus/type-fest/blob/main/source/literal-union.d.ts)
+ */
+type OrString = string & Record<never, never>;
+type LooseElementId<A extends Any> = Coalesce<A['ElementId']> | OrString;
+type LooseDeploymentId<A extends Any> = Coalesce<A['DeploymentId']> | OrString;
+type LooseViewId<A extends Any> = Coalesce<A['ViewId']> | OrString;
+type LooseTag<A extends Any> = Coalesce<A['Tag']> | OrString;
+type LooseTags<A extends Any> = readonly (Coalesce<A['Tag']> | OrString)[];
+type LooseElementKind<A extends Any> = Coalesce<A['ElementKind']> | OrString;
+type LooseDeploymentKind<A extends Any> = Coalesce<A['DeploymentKind']> | OrString;
+type LooseRelationKind<A extends Any> = Coalesce<A['RelationKind']> | OrString;
+
+type aux_AllKinds<A> = AllKinds<A>;
+type aux_Any = Any;
+type aux_AnySpec = AnySpec;
+type aux_Aux<Stage extends ModelStage, Element extends string, Deployment extends string, View extends string, Project extends string, Spec extends SpecAux<string, string, string, string, string>> = Aux<Stage, Element, Deployment, View, Project, Spec>;
+type aux_DeploymentFqn<A> = DeploymentFqn<A>;
+type aux_DeploymentId<A> = DeploymentId<A>;
+type aux_DeploymentKind<A> = DeploymentKind<A>;
+type aux_EdgeId = EdgeId;
+type aux_ElementId<A> = ElementId<A>;
+type aux_ElementKind<A> = ElementKind<A>;
+type aux_Fqn<A> = Fqn<A>;
+type aux_LooseDeploymentId<A extends Any> = LooseDeploymentId<A>;
+type aux_LooseDeploymentKind<A extends Any> = LooseDeploymentKind<A>;
+type aux_LooseElementId<A extends Any> = LooseElementId<A>;
+type aux_LooseElementKind<A extends Any> = LooseElementKind<A>;
+type aux_LooseRelationKind<A extends Any> = LooseRelationKind<A>;
+type aux_LooseTag<A extends Any> = LooseTag<A>;
+type aux_LooseTags<A extends Any> = LooseTags<A>;
+type aux_LooseViewId<A extends Any> = LooseViewId<A>;
+type aux_Metadata<A extends Any> = Metadata<A>;
+type aux_MetadataKey<A> = MetadataKey<A>;
+type aux_Never = Never;
+type aux_NodeId = NodeId;
+type aux_OrString = OrString;
+type aux_PickByStage<A extends Any, OnParsed, OnComputed, OnLayouted = OnComputed> = PickByStage<A, OnParsed, OnComputed, OnLayouted>;
+type aux_ProjectId<A> = ProjectId<A>;
+type aux_RelationId = RelationId;
+type aux_RelationKind<A> = RelationKind<A>;
+type aux_Spec<A> = Spec<A>;
+type aux_SpecAux<ElementKind extends string, DeploymentKind extends string, RelationKind extends string, Tag extends string, MetadataKey extends string> = SpecAux<ElementKind, DeploymentKind, RelationKind, Tag, MetadataKey>;
+type aux_Stage<A> = Stage<A>;
+type aux_StrictDeploymentKind<A> = StrictDeploymentKind<A>;
+type aux_StrictElementKind<A> = StrictElementKind<A>;
+type aux_StrictProjectId<A> = StrictProjectId<A>;
+type aux_StrictRelationKind<A> = StrictRelationKind<A>;
+type aux_StrictTag<A> = StrictTag<A>;
+type aux_StrictViewId<A> = StrictViewId<A>;
+type aux_Tag<A> = Tag<A>;
+type aux_Tags<A extends Any> = Tags<A>;
+type aux_Unknown = Unknown;
+type aux_UnknownComputed = UnknownComputed;
+type aux_UnknownLayouted = UnknownLayouted;
+type aux_UnknownParsed = UnknownParsed;
+type aux_ViewId<A> = ViewId<A>;
+type aux_WithLinks = WithLinks;
+type aux_WithMetadata<A extends Any> = WithMetadata<A>;
+type aux_WithOptionalLinks = WithOptionalLinks;
+type aux_WithOptionalTags<A extends Any> = WithOptionalTags<A>;
+type aux_WithTags<A extends Any> = WithTags<A>;
+type aux_setStage<A, S extends ModelStage> = setStage<A, S>;
+type aux_toComputed<A> = toComputed<A>;
+type aux_toLayouted<A> = toLayouted<A>;
+type aux_toParsed<A> = toParsed<A>;
+declare namespace aux {
+  export type { aux_AllKinds as AllKinds, aux_Any as Any, Any as AnyAux, aux_AnySpec as AnySpec, aux_Aux as Aux, aux_DeploymentFqn as DeploymentFqn, aux_DeploymentId as DeploymentId, aux_DeploymentKind as DeploymentKind, aux_EdgeId as EdgeId, aux_ElementId as ElementId, aux_ElementKind as ElementKind, aux_Fqn as Fqn, aux_LooseDeploymentId as LooseDeploymentId, aux_LooseDeploymentKind as LooseDeploymentKind, aux_LooseElementId as LooseElementId, aux_LooseElementKind as LooseElementKind, aux_LooseRelationKind as LooseRelationKind, aux_LooseTag as LooseTag, aux_LooseTags as LooseTags, aux_LooseViewId as LooseViewId, aux_Metadata as Metadata, aux_MetadataKey as MetadataKey, aux_Never as Never, aux_NodeId as NodeId, aux_OrString as OrString, aux_PickByStage as PickByStage, aux_ProjectId as ProjectId, aux_RelationId as RelationId, aux_RelationKind as RelationKind, aux_Spec as Spec, aux_SpecAux as SpecAux, aux_Stage as Stage, DeploymentFqn as StrictDeploymentFqn, aux_StrictDeploymentKind as StrictDeploymentKind, aux_StrictElementKind as StrictElementKind, Fqn as StrictFqn, aux_StrictProjectId as StrictProjectId, aux_StrictRelationKind as StrictRelationKind, aux_StrictTag as StrictTag, aux_StrictViewId as StrictViewId, aux_Tag as Tag, aux_Tags as Tags, aux_Unknown as Unknown, aux_UnknownComputed as UnknownComputed, aux_UnknownLayouted as UnknownLayouted, aux_UnknownParsed as UnknownParsed, aux_ViewId as ViewId, aux_WithLinks as WithLinks, aux_WithMetadata as WithMetadata, aux_WithOptionalLinks as WithOptionalLinks, aux_WithOptionalTags as WithOptionalTags, aux_WithTags as WithTags, aux_setStage as setStage, aux_toComputed as toComputed, aux_toLayouted as toLayouted, aux_toParsed as toParsed };
+}
+
+export { type WithLinks as $, type Any as A, type WithMetadata as B, type AnySpec as C, type DeploymentKind as D, type ExtractOnStage as E, type Fqn as F, type PickByStage as G, type setStage as H, type NodeId as I, type Spec as J, type StrictProjectId as K, type LooseTag as L, type ModelStage as M, type Never as N, type StrictTag as O, type ProjectId as P, type StrictElementKind as Q, type RelationKind as R, type SpecAux as S, type Tags as T, type Unknown as U, type ViewId as V, type WithOptionalTags as W, type StrictDeploymentKind as X, type StrictRelationKind as Y, type WithTags as Z, _stage as _, aux as a, type OrString as a0, type LooseTags as a1, type LooseElementKind as a2, type LooseDeploymentKind as a3, type LooseRelationKind as a4, type Aux as b, type UnknownComputed as c, type UnknownLayouted as d, type UnknownParsed as e, _type as f, type ElementId as g, type EdgeId as h, isOnStage as i, type Metadata as j, type MetadataKey as k, type ElementKind as l, type RelationId as m, type StrictViewId as n, type LooseElementId as o, type LooseDeploymentId as p, type DeploymentFqn as q, type toLayouted as r, type Stage as s, type toComputed as t, type DeploymentId as u, type Tag as v, type toParsed as w, type LooseViewId as x, type AllKinds as y, type WithOptionalLinks as z };