@likec4/core 1.17.1 → 1.19.0

package/dist/index.d.ts

@@ -1,265 +1,11 @@
-import { IfNever, TupleToUnion, Tagged, Simplify, LiteralUnion, Class, IsNumericLiteral } from 'type-fest';
-import { E as ElementKindSpecification, R as RelationshipKindSpecification, P as ParsedLikeC4Model, a as ElementShape, C as Color, B as BorderStyle, b as RelationshipArrowType, c as RelationshipLineType, d as Element, e as Relation, F as Fqn$1, L as LikeC4View, f as Expression, V as ViewRuleStyle, A as AutoLayoutDirection, N as NonEmptyArray, g as CustomElementExpr, h as CustomRelationExpr, H as HexColorLiteral, T as ThemeColorValues, i as RelationID$1, j as ViewID$1, k as EdgeId$1, l as ComputedView, m as Tag, n as ComputedNode, o as NodeId, p as ElementKind, q as ComputedEdge, r as ComputedLikeC4Model, s as LayoutedLikeC4Model, t as RelationshipKind, D as DiagramView, u as DiagramNode, v as DiagramEdge } from './shared/core.CoLQkcYL.js';
-export { aG as AndOperator, G as AsFqn, bF as BBox, bc as BasicElementView, bb as BasicView, J as BorderStyles, aS as ColorLiteral, bC as ComputedDynamicView, bB as ComputedElementView, y as CustomColor, bo as CustomColorDefinitions, aP as DefaultArrowType, O as DefaultElementShape, aO as DefaultLineStyle, aQ as DefaultRelationshipColor, M as DefaultThemeColor, bm as DynamicView, bj as DynamicViewIncludeRule, bh as DynamicViewParallelSteps, bl as DynamicViewRule, bg as DynamicViewStep, bi as DynamicViewStepOrParallel, a8 as ElementExpression, a4 as ElementKindExpr, Y as ElementKindSpecificationStyle, bJ as ElementNotation, ac as ElementPredicateExpression, Z as ElementRefExpr, K as ElementShapes, Q as ElementStyle, a6 as ElementTagExpr, aU as ElementThemeColorValues, aV as ElementThemeColors, bf as ElementView, aa as ElementWhereExpr, az as EqualOperator, $ as ExpandedElementExpr, w as Expr, be as ExtendsElementView, aL as Filterable, av as GlobalDynamicPredicates, at as GlobalPredicateId, au as GlobalPredicates, aw as GlobalStyleID, ax as GlobalStyles, I as IconUrl, ag as InOutExpr, ai as IncomingExpr, aC as KindEqual, aY as LikeC4Theme, U as Link, ay as ModelGlobals, x as NonEmptyReadonlyArray, aE as NotOperator, aI as OrOperator, ak as OutgoingExpr, aN as OverviewGraph, z as Point, ae as RelationExpr, am as RelationExpression, ar as RelationPredicateExpression, ao as RelationWhereExpr, aW as RelationshipThemeColorValues, aX as RelationshipThemeColors, bd as ScopedElementView, bu as StepEdgeId, bt as StepEdgeIdLiteral, aA as TagEqual, S as TagSpec, aR as ThemeColor, W as TypedElement, bA as ViewAutoLayout, bI as ViewChange, bH as ViewManualLayout, ba as ViewRule, b6 as ViewRuleAutoLayout, a$ as ViewRuleGlobalPredicateRef, b2 as ViewRuleGlobalStyle, b8 as ViewRuleGroup, aZ as ViewRulePredicate, b4 as ViewRuleStyleOrGlobalRef, by as ViewWithHash, bz as ViewWithNotation, aK as WhereOperator, a2 as WildcardExpr, X as XYPoint, bw as extractStep, bG as getBBoxCenter, bx as getParallelStepsPrefix, aH as isAndOperator, b5 as isAutoLayoutDirection, bD as isComputedDynamicView, bE as isComputedElementView, a1 as isCustomElement, aq as isCustomRelationExpr, bp as isDynamicView, bk as isDynamicViewIncludeRule, bn as isDynamicViewParallelSteps, a9 as isElement, a5 as isElementKindExpr, ad as isElementPredicateExpr, _ as isElementRef, a7 as isElementTagExpr, bq as isElementView, ab as isElementWhere, a0 as isExpandedElementExpr, br as isExtendsElementView, ah as isInOut, aj as isIncoming, aD as isKindEqual, aF as isNotOperator, aJ as isOrOperator, al as isOutgoing, af as isRelation, an as isRelationExpression, as as isRelationPredicateExpr, ap as isRelationWhere, bs as isScopedElementView, bv as isStepEdgeId, aB as isTagEqual, aT as isThemeColor, b7 as isViewRuleAutoLayout, b0 as isViewRuleGlobalPredicateRef, b3 as isViewRuleGlobalStyle, b9 as isViewRuleGroup, a_ as isViewRulePredicate, b1 as isViewRuleStyle, a3 as isWildcard, aM as whereOperatorAsPredicate } from './shared/core.CoLQkcYL.js';
-
-type KeysOf<T> = keyof T extends infer K extends string ? K : never;
-type BuilderSpecification = {
-    elements: {
-        [kind: string]: Partial<ElementKindSpecification>;
-    };
-    relationships?: Record<string, Partial<RelationshipKindSpecification>>;
-    tags?: [string, ...string[]];
-    metadataKeys?: [string, ...string[]];
-};
-type Metadata<MetadataKey extends string> = IfNever<MetadataKey, never, Record<MetadataKey, string>>;
-type NewElementProps<Tag, Metadata> = {
-    title?: string;
-    description?: string;
-    technology?: string;
-    tags?: IfNever<Tag, never, [Tag, ...Tag[]]>;
-    metadata?: Metadata;
-    icon?: string;
-    shape?: ElementShape;
-    color?: Color;
-    links?: Array<string | {
-        title?: string;
-        url: string;
-    }>;
-    style?: {
-        border?: BorderStyle;
-        opacity?: number;
-    };
-};
-type NewViewProps<Tag> = {
-    title?: string;
-    description?: string;
-    tags?: IfNever<Tag, never, [Tag, ...Tag[]]>;
-    links?: Array<string | {
-        title?: string;
-        url: string;
-    }>;
-};
-type NewRelationProps<Kind, Tag, Metadata> = {
-    kind?: Kind;
-    title?: string;
-    description?: string;
-    technology?: string;
-    tags?: IfNever<Tag, never, [Tag, ...Tag[]]>;
-    metadata?: Metadata;
-    head?: RelationshipArrowType;
-    tail?: RelationshipArrowType;
-    line?: RelationshipLineType;
-    color?: Color;
-    links?: Array<string | {
-        title?: string;
-        url: string;
-    }>;
-};
-type Invalid<Message extends string> = Tagged<Message, 'Error'>;
-/**
- * When building nested objects
- */
-interface TypesNested<Parent extends string, ElementKind extends string, Fqn extends string, ViewId extends string, RelationshipKind extends string, Tag extends string, MetadataKey extends string> extends Types<ElementKind, Fqn, ViewId, RelationshipKind, Tag, MetadataKey> {
-    Parent: Parent;
-}
-type AnyTypes = Types<any, any, any, any, any, any>;
-type AnyTypesNested = TypesNested<any, any, any, any, any, any, any>;
-/**
- * Auxilary type to keep track of the types in builder
- */
-interface Types<ElementKind extends string, Fqn extends string, ViewId extends string, RelationshipKind extends string, Tag extends string, MetadataKey extends string> {
-    ElementKind: ElementKind;
-    Fqn: Fqn;
-    ViewId: ViewId;
-    RelationshipKind: RelationshipKind;
-    Tag: Tag;
-    MetadataKey: MetadataKey;
-    Tags: IfNever<Tag, never, [Tag, ...Tag[]]>;
-    NewElementProps: NewElementProps<Tag, Metadata<MetadataKey>>;
-    NewRelationshipProps: NewRelationProps<RelationshipKind, Tag, Metadata<MetadataKey>>;
-    NewViewProps: NewViewProps<Tag>;
-}
-declare namespace Types {
-    type FromSpecification<Spec> = Spec extends BuilderSpecification ? Types<KeysOf<Spec['elements']>, never, never, KeysOf<Spec['relationships']>, TupleToUnion<Spec['tags']>, TupleToUnion<Spec['metadataKeys']>> : never;
-    type AddFqn<T, Id extends string> = T extends TypesNested<infer P, any, any, any, any, any, any> ? TypesNested<P, T['ElementKind'], `${P}.${Id}` | T['Fqn'], T['ViewId'], T['RelationshipKind'], T['Tag'], T['MetadataKey']> : T extends AnyTypes ? Types<T['ElementKind'], Id | T['Fqn'], T['ViewId'], T['RelationshipKind'], T['Tag'], T['MetadataKey']> : never;
-    type AddView<T, Id extends string> = T extends TypesNested<infer P, any, any, any, any, any, any> ? TypesNested<P, T['ElementKind'], T['Fqn'], Id | T['ViewId'], T['RelationshipKind'], T['Tag'], T['MetadataKey']> : T extends AnyTypes ? Types<T['ElementKind'], T['Fqn'], Id | T['ViewId'], T['RelationshipKind'], T['Tag'], T['MetadataKey']> : never;
-    type ToParsedLikeC4Model<T> = T extends AnyTypes ? ParsedLikeC4Model<T['ElementKind'], T['RelationshipKind'], T['Tag'], T['Fqn'], T['ViewId']> : never;
-}
-
-type ToNested<T, Id extends string> = T extends TypesNested<infer P, any, infer F, any, any, any, any> ? TypesNested<`${P}.${Id}`, T['ElementKind'], `${P}.${Id}` | F, T['ViewId'], T['RelationshipKind'], T['Tag'], T['MetadataKey']> : T extends AnyTypes ? TypesNested<Id, T['ElementKind'], Id | T['Fqn'], T['ViewId'], T['RelationshipKind'], T['Tag'], T['MetadataKey']> : never;
-type FromNested<T extends AnyTypes, N> = N extends TypesNested<any, any, infer F, any, any, any, any> ? T extends TypesNested<infer P, any, any, any, any, any, any> ? TypesNested<P, T['ElementKind'], F, T['ViewId'], T['RelationshipKind'], T['Tag'], T['MetadataKey']> : T extends AnyTypes ? Types<T['ElementKind'], F, T['ViewId'], T['RelationshipKind'], T['Tag'], T['MetadataKey']> : never : never;
-/**
- * Chainable builder to create element
- */
-interface AddElement<Id extends string> {
-    <T extends AnyTypes>(builder: ModelBuilder<T>): ModelBuilder<Types.AddFqn<T, Id>>;
-    with<T extends AnyTypes, A extends AnyTypes>(op1: (input: ModelBuilder<ToNested<T, Id>>) => ModelBuilder<A>): (builder: ModelBuilder<T>) => ModelBuilder<FromNested<T, A>>;
-    with<T extends AnyTypes, A extends AnyTypes, B extends AnyTypes>(op1: (input: ModelBuilder<ToNested<T, Id>>) => ModelBuilder<A>, op2: (input: ModelBuilder<A>) => ModelBuilder<B>): (builder: ModelBuilder<T>) => ModelBuilder<FromNested<T, B>>;
-    with<T extends AnyTypes, A extends AnyTypes, B extends AnyTypes, C extends AnyTypes>(op1: (input: ModelBuilder<ToNested<T, Id>>) => ModelBuilder<A>, op2: (input: ModelBuilder<A>) => ModelBuilder<B>, op3: (input: ModelBuilder<B>) => ModelBuilder<C>): (builder: ModelBuilder<T>) => ModelBuilder<FromNested<T, C>>;
-    with<T extends AnyTypes, A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes>(op1: (input: ModelBuilder<ToNested<T, Id>>) => ModelBuilder<A>, op2: (input: ModelBuilder<A>) => ModelBuilder<B>, op3: (input: ModelBuilder<B>) => ModelBuilder<C>, op4: (input: ModelBuilder<C>) => ModelBuilder<D>): (builder: ModelBuilder<T>) => ModelBuilder<FromNested<T, D>>;
-    with<T extends AnyTypes, A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes>(op1: (input: ModelBuilder<ToNested<T, Id>>) => ModelBuilder<A>, op2: (input: ModelBuilder<A>) => ModelBuilder<B>, op3: (input: ModelBuilder<B>) => ModelBuilder<C>, op4: (input: ModelBuilder<C>) => ModelBuilder<D>, op5: (input: ModelBuilder<D>) => ModelBuilder<E>): (builder: ModelBuilder<T>) => ModelBuilder<FromNested<T, E>>;
-    with<T extends AnyTypes, A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes, F extends AnyTypes>(op1: (input: ModelBuilder<ToNested<T, Id>>) => ModelBuilder<A>, op2: (input: ModelBuilder<A>) => ModelBuilder<B>, op3: (input: ModelBuilder<B>) => ModelBuilder<C>, op4: (input: ModelBuilder<C>) => ModelBuilder<D>, op5: (input: ModelBuilder<D>) => ModelBuilder<E>, op6: (input: ModelBuilder<E>) => ModelBuilder<F>): (builder: ModelBuilder<T>) => ModelBuilder<FromNested<T, F>>;
-    with<T extends AnyTypes, A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes, F extends AnyTypes, G extends AnyTypes>(op1: (input: ModelBuilder<ToNested<T, Id>>) => ModelBuilder<A>, op2: (input: ModelBuilder<A>) => ModelBuilder<B>, op3: (input: ModelBuilder<B>) => ModelBuilder<C>, op4: (input: ModelBuilder<C>) => ModelBuilder<D>, op5: (input: ModelBuilder<D>) => ModelBuilder<E>, op6: (input: ModelBuilder<E>) => ModelBuilder<F>, op7: (input: ModelBuilder<F>) => ModelBuilder<G>): (builder: ModelBuilder<T>) => ModelBuilder<FromNested<T, G>>;
-    with<T extends AnyTypes, A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes, F extends AnyTypes, G extends AnyTypes, H extends AnyTypes>(op1: (input: ModelBuilder<ToNested<T, Id>>) => ModelBuilder<A>, op2: (input: ModelBuilder<A>) => ModelBuilder<B>, op3: (input: ModelBuilder<B>) => ModelBuilder<C>, op4: (input: ModelBuilder<C>) => ModelBuilder<D>, op5: (input: ModelBuilder<D>) => ModelBuilder<E>, op6: (input: ModelBuilder<E>) => ModelBuilder<F>, op7: (input: ModelBuilder<F>) => ModelBuilder<G>, op8: (input: ModelBuilder<G>) => ModelBuilder<H>): (builder: ModelBuilder<T>) => ModelBuilder<FromNested<T, H>>;
-    with<T extends AnyTypes, A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes, F extends AnyTypes, G extends AnyTypes, H extends AnyTypes, I extends AnyTypes>(op1: (input: ModelBuilder<ToNested<T, Id>>) => ModelBuilder<A>, op2: (input: ModelBuilder<A>) => ModelBuilder<B>, op3: (input: ModelBuilder<B>) => ModelBuilder<C>, op4: (input: ModelBuilder<C>) => ModelBuilder<D>, op5: (input: ModelBuilder<D>) => ModelBuilder<E>, op6: (input: ModelBuilder<E>) => ModelBuilder<F>, op7: (input: ModelBuilder<F>) => ModelBuilder<G>, op8: (input: ModelBuilder<G>) => ModelBuilder<H>, op9: (input: ModelBuilder<H>) => ModelBuilder<I>): (builder: ModelBuilder<T>) => ModelBuilder<FromNested<T, I>>;
-    with<T extends AnyTypes, A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes, F extends AnyTypes, G extends AnyTypes, H extends AnyTypes, I extends AnyTypes, J extends AnyTypes>(op1: (input: ModelBuilder<ToNested<T, Id>>) => ModelBuilder<A>, op2: (input: ModelBuilder<A>) => ModelBuilder<B>, op3: (input: ModelBuilder<B>) => ModelBuilder<C>, op4: (input: ModelBuilder<C>) => ModelBuilder<D>, op5: (input: ModelBuilder<D>) => ModelBuilder<E>, op6: (input: ModelBuilder<E>) => ModelBuilder<F>, op7: (input: ModelBuilder<F>) => ModelBuilder<G>, op8: (input: ModelBuilder<G>) => ModelBuilder<H>, op9: (input: ModelBuilder<H>) => ModelBuilder<I>, op10: (input: ModelBuilder<I>) => ModelBuilder<J>): (builder: ModelBuilder<T>) => ModelBuilder<FromNested<T, J>>;
-}
-type AddElementHelper<T = unknown> = <const Id extends string>(id: Id, titleOrProps?: string | T) => AddElement<Id>;
-type AddElementHelpers<T extends AnyTypes> = T extends Types<infer Kinds extends string, any, any, any, any, any> ? {
-    [Kind in Kinds]: AddElementHelper<T['NewElementProps']>;
-} : Invalid<'No Element Kinds'>;
-
-interface ModelBuilder<T extends AnyTypes> {
-    addElement(element: Element): Builder<T>;
-    addRelation(relation: Omit<Relation, 'id'>): Builder<T>;
-    /**
-     * Create a fully qualified name from an id (for nested models)
-     */
-    fqn(id: string): Fqn$1;
-    addSourcelessRelation(relation: Omit<Relation, 'id' | 'source'>): Builder<T>;
-}
-declare function model<A extends AnyTypes, B extends AnyTypes>(op1: (input: ModelBuilder<A>) => ModelBuilder<B>): (input: Builder<A>) => Builder<B>;
-declare function model<A extends AnyTypes, B extends AnyTypes, C extends AnyTypes>(op1: (input: ModelBuilder<A>) => ModelBuilder<B>, op2: (input: ModelBuilder<B>) => ModelBuilder<C>): (input: Builder<A>) => Builder<C>;
-declare function model<A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes>(op1: (input: ModelBuilder<A>) => ModelBuilder<B>, op2: (input: ModelBuilder<B>) => ModelBuilder<C>, op3: (input: ModelBuilder<C>) => ModelBuilder<D>): (input: Builder<A>) => Builder<D>;
-declare function model<A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes>(op1: (input: ModelBuilder<A>) => ModelBuilder<B>, op2: (input: ModelBuilder<B>) => ModelBuilder<C>, op3: (input: ModelBuilder<C>) => ModelBuilder<D>, op4: (input: ModelBuilder<D>) => ModelBuilder<E>): (input: Builder<A>) => Builder<E>;
-declare function model<A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes, F extends AnyTypes>(op1: (input: ModelBuilder<A>) => ModelBuilder<B>, op2: (input: ModelBuilder<B>) => ModelBuilder<C>, op3: (input: ModelBuilder<C>) => ModelBuilder<D>, op4: (input: ModelBuilder<D>) => ModelBuilder<E>, op5: (input: ModelBuilder<E>) => ModelBuilder<F>): (input: Builder<A>) => Builder<F>;
-declare function model<A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes, F extends AnyTypes, G extends AnyTypes>(op1: (input: ModelBuilder<A>) => ModelBuilder<B>, op2: (input: ModelBuilder<B>) => ModelBuilder<C>, op3: (input: ModelBuilder<C>) => ModelBuilder<D>, op4: (input: ModelBuilder<D>) => ModelBuilder<E>, op5: (input: ModelBuilder<E>) => ModelBuilder<F>, op6: (input: ModelBuilder<F>) => ModelBuilder<G>): (input: Builder<A>) => Builder<G>;
-declare function model<A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes, F extends AnyTypes, G extends AnyTypes, H extends AnyTypes>(op1: (input: ModelBuilder<A>) => ModelBuilder<B>, op2: (input: ModelBuilder<B>) => ModelBuilder<C>, op3: (input: ModelBuilder<C>) => ModelBuilder<D>, op4: (input: ModelBuilder<D>) => ModelBuilder<E>, op5: (input: ModelBuilder<E>) => ModelBuilder<F>, op6: (input: ModelBuilder<F>) => ModelBuilder<G>, op7: (input: ModelBuilder<G>) => ModelBuilder<H>): (input: Builder<A>) => Builder<H>;
-declare function model<A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes, F extends AnyTypes, G extends AnyTypes, H extends AnyTypes, I extends AnyTypes>(op1: (input: ModelBuilder<A>) => ModelBuilder<B>, op2: (input: ModelBuilder<B>) => ModelBuilder<C>, op3: (input: ModelBuilder<C>) => ModelBuilder<D>, op4: (input: ModelBuilder<D>) => ModelBuilder<E>, op5: (input: ModelBuilder<E>) => ModelBuilder<F>, op6: (input: ModelBuilder<F>) => ModelBuilder<G>, op7: (input: ModelBuilder<G>) => ModelBuilder<H>, op8: (input: ModelBuilder<H>) => ModelBuilder<I>): (input: Builder<A>) => Builder<I>;
-declare function model<A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes, F extends AnyTypes, G extends AnyTypes, H extends AnyTypes, I extends AnyTypes, J extends AnyTypes>(op1: (input: ModelBuilder<A>) => ModelBuilder<B>, op2: (input: ModelBuilder<B>) => ModelBuilder<C>, op3: (input: ModelBuilder<C>) => ModelBuilder<D>, op4: (input: ModelBuilder<D>) => ModelBuilder<E>, op5: (input: ModelBuilder<E>) => ModelBuilder<F>, op6: (input: ModelBuilder<F>) => ModelBuilder<G>, op7: (input: ModelBuilder<G>) => ModelBuilder<H>, op8: (input: ModelBuilder<H>) => ModelBuilder<I>, op9: (input: ModelBuilder<I>) => ModelBuilder<J>): (input: Builder<A>) => Builder<J>;
-declare function model<A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes, F extends AnyTypes, G extends AnyTypes, H extends AnyTypes, I extends AnyTypes, J extends AnyTypes, K extends AnyTypes>(op1: (input: ModelBuilder<A>) => ModelBuilder<B>, op2: (input: ModelBuilder<B>) => ModelBuilder<C>, op3: (input: ModelBuilder<C>) => ModelBuilder<D>, op4: (input: ModelBuilder<D>) => ModelBuilder<E>, op5: (input: ModelBuilder<E>) => ModelBuilder<F>, op6: (input: ModelBuilder<F>) => ModelBuilder<G>, op7: (input: ModelBuilder<G>) => ModelBuilder<H>, op8: (input: ModelBuilder<H>) => ModelBuilder<I>, op9: (input: ModelBuilder<I>) => ModelBuilder<J>, op10: (input: ModelBuilder<J>) => ModelBuilder<K>): (input: Builder<A>) => Builder<K>;
-declare function model<A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes, F extends AnyTypes, G extends AnyTypes, H extends AnyTypes, I extends AnyTypes, J extends AnyTypes, K extends AnyTypes, L extends AnyTypes>(op1: (input: ModelBuilder<A>) => ModelBuilder<B>, op2: (input: ModelBuilder<B>) => ModelBuilder<C>, op3: (input: ModelBuilder<C>) => ModelBuilder<D>, op4: (input: ModelBuilder<D>) => ModelBuilder<E>, op5: (input: ModelBuilder<E>) => ModelBuilder<F>, op6: (input: ModelBuilder<F>) => ModelBuilder<G>, op7: (input: ModelBuilder<G>) => ModelBuilder<H>, op8: (input: ModelBuilder<H>) => ModelBuilder<I>, op9: (input: ModelBuilder<I>) => ModelBuilder<J>, op10: (input: ModelBuilder<J>) => ModelBuilder<K>, op11: (input: ModelBuilder<K>) => ModelBuilder<L>): (input: Builder<A>) => Builder<L>;
-declare function model<A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes, F extends AnyTypes, G extends AnyTypes, H extends AnyTypes, I extends AnyTypes, J extends AnyTypes, K extends AnyTypes, L extends AnyTypes, M extends AnyTypes>(op1: (input: ModelBuilder<A>) => ModelBuilder<B>, op2: (input: ModelBuilder<B>) => ModelBuilder<C>, op3: (input: ModelBuilder<C>) => ModelBuilder<D>, op4: (input: ModelBuilder<D>) => ModelBuilder<E>, op5: (input: ModelBuilder<E>) => ModelBuilder<F>, op6: (input: ModelBuilder<F>) => ModelBuilder<G>, op7: (input: ModelBuilder<G>) => ModelBuilder<H>, op8: (input: ModelBuilder<H>) => ModelBuilder<I>, op9: (input: ModelBuilder<I>) => ModelBuilder<J>, op10: (input: ModelBuilder<J>) => ModelBuilder<K>, op11: (input: ModelBuilder<K>) => ModelBuilder<L>, op12: (input: ModelBuilder<L>) => ModelBuilder<M>): (input: Builder<A>) => Builder<M>;
-declare function model<A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes, F extends AnyTypes, G extends AnyTypes, H extends AnyTypes, I extends AnyTypes, J extends AnyTypes, K extends AnyTypes, L extends AnyTypes, M extends AnyTypes, N extends AnyTypes>(op1: (input: ModelBuilder<A>) => ModelBuilder<B>, op2: (input: ModelBuilder<B>) => ModelBuilder<C>, op3: (input: ModelBuilder<C>) => ModelBuilder<D>, op4: (input: ModelBuilder<D>) => ModelBuilder<E>, op5: (input: ModelBuilder<E>) => ModelBuilder<F>, op6: (input: ModelBuilder<F>) => ModelBuilder<G>, op7: (input: ModelBuilder<G>) => ModelBuilder<H>, op8: (input: ModelBuilder<H>) => ModelBuilder<I>, op9: (input: ModelBuilder<I>) => ModelBuilder<J>, op10: (input: ModelBuilder<J>) => ModelBuilder<K>, op11: (input: ModelBuilder<K>) => ModelBuilder<L>, op12: (input: ModelBuilder<L>) => ModelBuilder<M>, op13: (input: ModelBuilder<M>) => ModelBuilder<N>): (input: Builder<A>) => Builder<N>;
-declare function model<A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes, F extends AnyTypes, G extends AnyTypes, H extends AnyTypes, I extends AnyTypes, J extends AnyTypes, K extends AnyTypes, L extends AnyTypes, M extends AnyTypes, N extends AnyTypes, O extends AnyTypes>(op1: (input: ModelBuilder<A>) => ModelBuilder<B>, op2: (input: ModelBuilder<B>) => ModelBuilder<C>, op3: (input: ModelBuilder<C>) => ModelBuilder<D>, op4: (input: ModelBuilder<D>) => ModelBuilder<E>, op5: (input: ModelBuilder<E>) => ModelBuilder<F>, op6: (input: ModelBuilder<F>) => ModelBuilder<G>, op7: (input: ModelBuilder<G>) => ModelBuilder<H>, op8: (input: ModelBuilder<H>) => ModelBuilder<I>, op9: (input: ModelBuilder<I>) => ModelBuilder<J>, op10: (input: ModelBuilder<J>) => ModelBuilder<K>, op11: (input: ModelBuilder<K>) => ModelBuilder<L>, op12: (input: ModelBuilder<L>) => ModelBuilder<M>, op13: (input: ModelBuilder<M>) => ModelBuilder<N>, op14: (input: ModelBuilder<N>) => ModelBuilder<O>): (input: Builder<A>) => Builder<O>;
-declare function model<A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes, F extends AnyTypes, G extends AnyTypes, H extends AnyTypes, I extends AnyTypes, J extends AnyTypes, K extends AnyTypes, L extends AnyTypes, M extends AnyTypes, N extends AnyTypes, O extends AnyTypes, P extends AnyTypes>(op1: (input: ModelBuilder<A>) => ModelBuilder<B>, op2: (input: ModelBuilder<B>) => ModelBuilder<C>, op3: (input: ModelBuilder<C>) => ModelBuilder<D>, op4: (input: ModelBuilder<D>) => ModelBuilder<E>, op5: (input: ModelBuilder<E>) => ModelBuilder<F>, op6: (input: ModelBuilder<F>) => ModelBuilder<G>, op7: (input: ModelBuilder<G>) => ModelBuilder<H>, op8: (input: ModelBuilder<H>) => ModelBuilder<I>, op9: (input: ModelBuilder<I>) => ModelBuilder<J>, op10: (input: ModelBuilder<J>) => ModelBuilder<K>, op11: (input: ModelBuilder<K>) => ModelBuilder<L>, op12: (input: ModelBuilder<L>) => ModelBuilder<M>, op13: (input: ModelBuilder<M>) => ModelBuilder<N>, op14: (input: ModelBuilder<N>) => ModelBuilder<O>, op15: (input: ModelBuilder<O>) => ModelBuilder<P>): (input: Builder<A>) => Builder<P>;
-type RelationshipHelper<Props = unknown> = <T extends AnyTypes, From extends string & T['Fqn'], To extends string & T['Fqn']>(from: From, to: To, titleOrProps?: string | Props) => (builder: ModelBuilder<T>) => ModelBuilder<T>;
-type NestedRelationshipHelper<Props = unknown> = <T extends AnyTypesNested, To extends string & T['Fqn']>(to: To, titleOrProps?: string | Props) => (builder: ModelBuilder<T>) => ModelBuilder<T>;
-type ModelHelpers<T extends AnyTypes> = AddElementHelpers<T> & {
-    model: typeof model;
-    rel: RelationshipHelper<T['NewRelationshipProps']>;
-    relTo: NestedRelationshipHelper<T['NewRelationshipProps']>;
-};
-
-interface ViewsBuilder<T extends AnyTypes> {
-    addView(view: LikeC4View): Builder<T>;
-}
-declare function views<A extends AnyTypes, B extends AnyTypes>(op1: (input: ViewsBuilder<A>) => ViewsBuilder<B>): (input: Builder<A>) => Builder<B>;
-declare function views<A extends AnyTypes, B extends AnyTypes, C extends AnyTypes>(op1: (input: ViewsBuilder<A>) => ViewsBuilder<B>, op2: (input: ViewsBuilder<B>) => ViewsBuilder<C>): (input: Builder<A>) => Builder<C>;
-declare function views<A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes>(op1: (input: ViewsBuilder<A>) => ViewsBuilder<B>, op2: (input: ViewsBuilder<B>) => ViewsBuilder<C>, op3: (input: ViewsBuilder<C>) => ViewsBuilder<D>): (input: Builder<A>) => Builder<D>;
-declare function views<A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes>(op1: (input: ViewsBuilder<A>) => ViewsBuilder<B>, op2: (input: ViewsBuilder<B>) => ViewsBuilder<C>, op3: (input: ViewsBuilder<C>) => ViewsBuilder<D>, op4: (input: ViewsBuilder<D>) => ViewsBuilder<E>): (input: Builder<A>) => Builder<E>;
-declare function views<A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes, F extends AnyTypes>(op1: (input: ViewsBuilder<A>) => ViewsBuilder<B>, op2: (input: ViewsBuilder<B>) => ViewsBuilder<C>, op3: (input: ViewsBuilder<C>) => ViewsBuilder<D>, op4: (input: ViewsBuilder<D>) => ViewsBuilder<E>, op5: (input: ViewsBuilder<E>) => ViewsBuilder<F>): (input: Builder<A>) => Builder<F>;
-declare function views<A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes, F extends AnyTypes, G extends AnyTypes>(op1: (input: ViewsBuilder<A>) => ViewsBuilder<B>, op2: (input: ViewsBuilder<B>) => ViewsBuilder<C>, op3: (input: ViewsBuilder<C>) => ViewsBuilder<D>, op4: (input: ViewsBuilder<D>) => ViewsBuilder<E>, op5: (input: ViewsBuilder<E>) => ViewsBuilder<F>, op6: (input: ViewsBuilder<F>) => ViewsBuilder<G>): (input: Builder<A>) => Builder<G>;
-declare function views<A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes, F extends AnyTypes, G extends AnyTypes, H extends AnyTypes>(op1: (input: ViewsBuilder<A>) => ViewsBuilder<B>, op2: (input: ViewsBuilder<B>) => ViewsBuilder<C>, op3: (input: ViewsBuilder<C>) => ViewsBuilder<D>, op4: (input: ViewsBuilder<D>) => ViewsBuilder<E>, op5: (input: ViewsBuilder<E>) => ViewsBuilder<F>, op6: (input: ViewsBuilder<F>) => ViewsBuilder<G>, op7: (input: ViewsBuilder<G>) => ViewsBuilder<H>): (input: Builder<A>) => Builder<H>;
-declare function views<A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes, F extends AnyTypes, G extends AnyTypes, H extends AnyTypes, I extends AnyTypes>(op1: (input: ViewsBuilder<A>) => ViewsBuilder<B>, op2: (input: ViewsBuilder<B>) => ViewsBuilder<C>, op3: (input: ViewsBuilder<C>) => ViewsBuilder<D>, op4: (input: ViewsBuilder<D>) => ViewsBuilder<E>, op5: (input: ViewsBuilder<E>) => ViewsBuilder<F>, op6: (input: ViewsBuilder<F>) => ViewsBuilder<G>, op7: (input: ViewsBuilder<G>) => ViewsBuilder<H>, op8: (input: ViewsBuilder<H>) => ViewsBuilder<I>): (input: Builder<A>) => Builder<I>;
-declare function views<A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes, F extends AnyTypes, G extends AnyTypes, H extends AnyTypes, I extends AnyTypes, J extends AnyTypes>(op1: (input: ViewsBuilder<A>) => ViewsBuilder<B>, op2: (input: ViewsBuilder<B>) => ViewsBuilder<C>, op3: (input: ViewsBuilder<C>) => ViewsBuilder<D>, op4: (input: ViewsBuilder<D>) => ViewsBuilder<E>, op5: (input: ViewsBuilder<E>) => ViewsBuilder<F>, op6: (input: ViewsBuilder<F>) => ViewsBuilder<G>, op7: (input: ViewsBuilder<G>) => ViewsBuilder<H>, op8: (input: ViewsBuilder<H>) => ViewsBuilder<I>, op9: (input: ViewsBuilder<I>) => ViewsBuilder<J>): (input: Builder<A>) => Builder<J>;
-declare function views<A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes, F extends AnyTypes, G extends AnyTypes, H extends AnyTypes, I extends AnyTypes, J extends AnyTypes, K extends AnyTypes>(op1: (input: ViewsBuilder<A>) => ViewsBuilder<B>, op2: (input: ViewsBuilder<B>) => ViewsBuilder<C>, op3: (input: ViewsBuilder<C>) => ViewsBuilder<D>, op4: (input: ViewsBuilder<D>) => ViewsBuilder<E>, op5: (input: ViewsBuilder<E>) => ViewsBuilder<F>, op6: (input: ViewsBuilder<F>) => ViewsBuilder<G>, op7: (input: ViewsBuilder<G>) => ViewsBuilder<H>, op8: (input: ViewsBuilder<H>) => ViewsBuilder<I>, op9: (input: ViewsBuilder<I>) => ViewsBuilder<J>, op10: (input: ViewsBuilder<J>) => ViewsBuilder<K>): (input: Builder<A>) => Builder<K>;
-declare function views<A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes, F extends AnyTypes, G extends AnyTypes, H extends AnyTypes, I extends AnyTypes, J extends AnyTypes, K extends AnyTypes, L extends AnyTypes>(op1: (input: ViewsBuilder<A>) => ViewsBuilder<B>, op2: (input: ViewsBuilder<B>) => ViewsBuilder<C>, op3: (input: ViewsBuilder<C>) => ViewsBuilder<D>, op4: (input: ViewsBuilder<D>) => ViewsBuilder<E>, op5: (input: ViewsBuilder<E>) => ViewsBuilder<F>, op6: (input: ViewsBuilder<F>) => ViewsBuilder<G>, op7: (input: ViewsBuilder<G>) => ViewsBuilder<H>, op8: (input: ViewsBuilder<H>) => ViewsBuilder<I>, op9: (input: ViewsBuilder<I>) => ViewsBuilder<J>, op10: (input: ViewsBuilder<J>) => ViewsBuilder<K>, op11: (input: ViewsBuilder<K>) => ViewsBuilder<L>): (input: Builder<A>) => Builder<L>;
-declare function views<A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes, F extends AnyTypes, G extends AnyTypes, H extends AnyTypes, I extends AnyTypes, J extends AnyTypes, K extends AnyTypes, L extends AnyTypes, M extends AnyTypes>(op1: (input: ViewsBuilder<A>) => ViewsBuilder<B>, op2: (input: ViewsBuilder<B>) => ViewsBuilder<C>, op3: (input: ViewsBuilder<C>) => ViewsBuilder<D>, op4: (input: ViewsBuilder<D>) => ViewsBuilder<E>, op5: (input: ViewsBuilder<E>) => ViewsBuilder<F>, op6: (input: ViewsBuilder<F>) => ViewsBuilder<G>, op7: (input: ViewsBuilder<G>) => ViewsBuilder<H>, op8: (input: ViewsBuilder<H>) => ViewsBuilder<I>, op9: (input: ViewsBuilder<I>) => ViewsBuilder<J>, op10: (input: ViewsBuilder<J>) => ViewsBuilder<K>, op11: (input: ViewsBuilder<K>) => ViewsBuilder<L>, op12: (input: ViewsBuilder<L>) => ViewsBuilder<M>): (input: Builder<A>) => Builder<M>;
-declare function views<A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes, F extends AnyTypes, G extends AnyTypes, H extends AnyTypes, I extends AnyTypes, J extends AnyTypes, K extends AnyTypes, L extends AnyTypes, M extends AnyTypes, N extends AnyTypes>(op1: (input: ViewsBuilder<A>) => ViewsBuilder<B>, op2: (input: ViewsBuilder<B>) => ViewsBuilder<C>, op3: (input: ViewsBuilder<C>) => ViewsBuilder<D>, op4: (input: ViewsBuilder<D>) => ViewsBuilder<E>, op5: (input: ViewsBuilder<E>) => ViewsBuilder<F>, op6: (input: ViewsBuilder<F>) => ViewsBuilder<G>, op7: (input: ViewsBuilder<G>) => ViewsBuilder<H>, op8: (input: ViewsBuilder<H>) => ViewsBuilder<I>, op9: (input: ViewsBuilder<I>) => ViewsBuilder<J>, op10: (input: ViewsBuilder<J>) => ViewsBuilder<K>, op11: (input: ViewsBuilder<K>) => ViewsBuilder<L>, op12: (input: ViewsBuilder<L>) => ViewsBuilder<M>, op13: (input: ViewsBuilder<M>) => ViewsBuilder<N>): (input: Builder<A>) => Builder<N>;
-declare function views<A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes, F extends AnyTypes, G extends AnyTypes, H extends AnyTypes, I extends AnyTypes, J extends AnyTypes, K extends AnyTypes, L extends AnyTypes, M extends AnyTypes, N extends AnyTypes, O extends AnyTypes>(op1: (input: ViewsBuilder<A>) => ViewsBuilder<B>, op2: (input: ViewsBuilder<B>) => ViewsBuilder<C>, op3: (input: ViewsBuilder<C>) => ViewsBuilder<D>, op4: (input: ViewsBuilder<D>) => ViewsBuilder<E>, op5: (input: ViewsBuilder<E>) => ViewsBuilder<F>, op6: (input: ViewsBuilder<F>) => ViewsBuilder<G>, op7: (input: ViewsBuilder<G>) => ViewsBuilder<H>, op8: (input: ViewsBuilder<H>) => ViewsBuilder<I>, op9: (input: ViewsBuilder<I>) => ViewsBuilder<J>, op10: (input: ViewsBuilder<J>) => ViewsBuilder<K>, op11: (input: ViewsBuilder<K>) => ViewsBuilder<L>, op12: (input: ViewsBuilder<L>) => ViewsBuilder<M>, op13: (input: ViewsBuilder<M>) => ViewsBuilder<N>, op14: (input: ViewsBuilder<N>) => ViewsBuilder<O>): (input: Builder<A>) => Builder<O>;
-declare function views<A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes, F extends AnyTypes, G extends AnyTypes, H extends AnyTypes, I extends AnyTypes, J extends AnyTypes, K extends AnyTypes, L extends AnyTypes, M extends AnyTypes, N extends AnyTypes, O extends AnyTypes, P extends AnyTypes>(op1: (input: ViewsBuilder<A>) => ViewsBuilder<B>, op2: (input: ViewsBuilder<B>) => ViewsBuilder<C>, op3: (input: ViewsBuilder<C>) => ViewsBuilder<D>, op4: (input: ViewsBuilder<D>) => ViewsBuilder<E>, op5: (input: ViewsBuilder<E>) => ViewsBuilder<F>, op6: (input: ViewsBuilder<F>) => ViewsBuilder<G>, op7: (input: ViewsBuilder<G>) => ViewsBuilder<H>, op8: (input: ViewsBuilder<H>) => ViewsBuilder<I>, op9: (input: ViewsBuilder<I>) => ViewsBuilder<J>, op10: (input: ViewsBuilder<J>) => ViewsBuilder<K>, op11: (input: ViewsBuilder<K>) => ViewsBuilder<L>, op12: (input: ViewsBuilder<L>) => ViewsBuilder<M>, op13: (input: ViewsBuilder<M>) => ViewsBuilder<N>, op14: (input: ViewsBuilder<N>) => ViewsBuilder<O>, op15: (input: ViewsBuilder<O>) => ViewsBuilder<P>): (input: Builder<A>) => Builder<P>;
-
-interface ViewBuilder<T extends AnyTypes> {
-    include(...exprs: Expression[]): ViewBuilder<T>;
-    exclude(...exprs: Expression[]): ViewBuilder<T>;
-    style(rule: ViewRuleStyle): ViewBuilder<T>;
-    autoLayout(layout: AutoLayoutDirection): ViewBuilder<T>;
-}
-declare namespace ViewPredicate {
-    export type ElementExpr<Fqn extends string> = '*' | Fqn | `${Fqn}.*` | `${Fqn}._`;
-    type AllExpression<ElementExpr extends string> = ElementExpr | `-> ${ElementExpr} ->` | `-> ${ElementExpr}` | `${ElementExpr} ->` | `${ElementExpr} ${'->' | '<->'} ${ElementExpr}`;
-    export type Expression<T extends AnyTypes> = T extends Types<any, infer F extends string, any, any, any, any> ? AllExpression<ViewPredicate.ElementExpr<F>> : never;
-    export type WhereTag<Tag extends string> = `tag ${'is' | 'is not'} #${Tag}`;
-    export type WhereKind<Kind extends string> = `kind ${'is' | 'is not'} ${Kind}`;
-    export type WhereEq<Types extends AnyTypes> = ViewPredicate.WhereTag<Types['Tag']> | ViewPredicate.WhereKind<Types['ElementKind']>;
-    export type WhereOperator<Types extends AnyTypes> = ViewPredicate.WhereEq<Types> | {
-        and: NonEmptyArray<ViewPredicate.WhereOperator<Types>>;
-        or?: never;
-        not?: never;
-    } | {
-        or: NonEmptyArray<ViewPredicate.WhereOperator<Types>>;
-        and?: never;
-        not?: never;
-    } | {
-        not: ViewPredicate.WhereOperator<Types>;
-        and?: never;
-        or?: never;
-    };
-    export type Custom<Types extends AnyTypes> = {
-        where?: ViewPredicate.WhereOperator<Types>;
-        with?: Simplify<Omit<CustomElementExpr['custom'] & CustomRelationExpr['customRelation'], 'expr' | 'relation' | 'navigateTo'> & {
-            navigateTo?: Types['ViewId'];
-        }>;
-    };
-    export {  };
-}
-type ViewRuleBuilderOp<Types extends AnyTypes> = (b: ViewBuilder<Types>) => ViewBuilder<Types>;
-interface AddViewHelper<Props = unknown> {
-    <const Id extends string, T extends AnyTypes>(id: Id, builder: (b: ViewBuilder<T>) => ViewBuilder<T>): (builder: ViewsBuilder<T>) => ViewsBuilder<Types.AddView<T, Id>>;
-    <const Id extends string, T extends AnyTypes>(id: Id, propsOrTitle: Props | string): (builder: ViewsBuilder<T>) => ViewsBuilder<Types.AddView<T, Id>>;
-    <const Id extends string, T extends AnyTypes>(id: Id, propsOrTitle: Props | string | undefined, builder: (b: ViewBuilder<T>) => ViewBuilder<T>): (builder: ViewsBuilder<T>) => ViewsBuilder<Types.AddView<T, Id>>;
-}
-interface AddViewOfHelper<Props = unknown> {
-    <const Id extends string, T extends AnyTypes, Of extends string & T['Fqn']>(id: Id, of: Of): (builder: ViewsBuilder<T>) => ViewsBuilder<Types.AddView<T, Id>>;
-    <const Id extends string, T extends AnyTypes, Of extends string & T['Fqn']>(id: Id, of: Of, builder: (b: ViewBuilder<T>) => ViewBuilder<T>): (builder: ViewsBuilder<T>) => ViewsBuilder<Types.AddView<T, Id>>;
-    <const Id extends string, T extends AnyTypes, Of extends string & T['Fqn']>(id: Id, of: Of, propsOrTitle: Props | string): (builder: ViewsBuilder<T>) => ViewsBuilder<Types.AddView<T, Id>>;
-    <const Id extends string, T extends AnyTypes, Of extends string & T['Fqn']>(id: Id, of: Of, propsOrTitle: Props | string | undefined, builder: (b: ViewBuilder<T>) => ViewBuilder<T>): (builder: ViewsBuilder<T>) => ViewsBuilder<Types.AddView<T, Id>>;
-}
-type TypedC4Expression<Types extends AnyTypes> = Tagged<Expression, 'typed', Types>;
-declare function $include<Types extends AnyTypes>(...args: [ViewPredicate.Expression<Types>] | [TypedC4Expression<Types>] | [ViewPredicate.Expression<Types>, ViewPredicate.Custom<Types>]): (b: ViewBuilder<Types>) => ViewBuilder<Types>;
-declare function $exclude<Types extends AnyTypes>(...args: [ViewPredicate.Expression<Types>] | [TypedC4Expression<Types>] | [ViewPredicate.Expression<Types>, ViewPredicate.Custom<Types>]): (b: ViewBuilder<Types>) => ViewBuilder<Types>;
-declare function $style<Types extends AnyTypes>(element: ViewPredicate.ElementExpr<Types['Fqn']> | NonEmptyArray<ViewPredicate.ElementExpr<Types['Fqn']>>, { notation, ...style }: ViewRuleStyle['style'] & {
-    notation?: string;
-}): (b: ViewBuilder<Types>) => ViewBuilder<Types>;
-declare function $autoLayout<Types extends AnyTypes>(layout: AutoLayoutDirection): (b: ViewBuilder<Types>) => ViewBuilder<Types>;
-declare function $rules<T extends AnyTypes>(...rules: ViewRuleBuilderOp<T>[]): (b: ViewBuilder<T>) => ViewBuilder<T>;
-
-type ViewHelpers<T = unknown> = {
-    views: typeof views;
-    view: AddViewHelper<T>;
-    viewOf: AddViewOfHelper<T>;
-    $include: typeof $include;
-    $exclude: typeof $exclude;
-    $style: typeof $style;
-    $rules: typeof $rules;
-    $autoLayout: typeof $autoLayout;
-};
-
-interface Builder<T extends AnyTypes> {
-    /**
-     * Only available in compile time
-     */
-    readonly Types: T;
-    clone(): Builder<T>;
-    /**
-     * Builders for each element kind
-     */
-    helpers(): {
-        model: ModelHelpers<T>;
-        views: ViewHelpers<T['NewViewProps']>;
-    };
-    __model(): ModelBuilder<T>;
-    __views(): ViewsBuilder<T>;
-    build(): ParsedLikeC4Model<T['ElementKind'], T['RelationshipKind'], T['Tag'], T['Fqn'], T['ViewId']>;
-    with<A extends AnyTypes>(op1: (input: Builder<T>) => Builder<A>): Builder<A>;
-    with<A extends AnyTypes, B extends AnyTypes>(op1: (input: Builder<T>) => Builder<A>, op2: (input: Builder<A>) => Builder<B>): Builder<B>;
-    with<A extends AnyTypes, B extends AnyTypes, C extends AnyTypes>(op1: (input: Builder<T>) => Builder<A>, op2: (input: Builder<A>) => Builder<B>, op3: (input: Builder<B>) => Builder<C>): Builder<C>;
-    with<A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes>(op1: (input: Builder<T>) => Builder<A>, op2: (input: Builder<A>) => Builder<B>, op3: (input: Builder<B>) => Builder<C>, op4: (input: Builder<C>) => Builder<D>): Builder<D>;
-    with<A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes>(op1: (input: Builder<T>) => Builder<A>, op2: (input: Builder<A>) => Builder<B>, op3: (input: Builder<B>) => Builder<C>, op4: (input: Builder<C>) => Builder<D>, op5: (input: Builder<D>) => Builder<E>): Builder<E>;
-    with<A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes, F extends AnyTypes>(op1: (input: Builder<T>) => Builder<A>, op2: (input: Builder<A>) => Builder<B>, op3: (input: Builder<B>) => Builder<C>, op4: (input: Builder<C>) => Builder<D>, op5: (input: Builder<D>) => Builder<E>, op6: (input: Builder<E>) => Builder<F>): Builder<F>;
-    with<A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes, F extends AnyTypes, G extends AnyTypes>(op1: (input: Builder<T>) => Builder<A>, op2: (input: Builder<A>) => Builder<B>, op3: (input: Builder<B>) => Builder<C>, op4: (input: Builder<C>) => Builder<D>, op5: (input: Builder<D>) => Builder<E>, op6: (input: Builder<E>) => Builder<F>, op7: (input: Builder<F>) => Builder<G>): Builder<G>;
-    with<A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes, F extends AnyTypes, G extends AnyTypes, H extends AnyTypes>(op1: (input: Builder<T>) => Builder<A>, op2: (input: Builder<A>) => Builder<B>, op3: (input: Builder<B>) => Builder<C>, op4: (input: Builder<C>) => Builder<D>, op5: (input: Builder<D>) => Builder<E>, op6: (input: Builder<E>) => Builder<F>, op7: (input: Builder<F>) => Builder<G>, op8: (input: Builder<G>) => Builder<H>): Builder<H>;
-    with<A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes, F extends AnyTypes, G extends AnyTypes, H extends AnyTypes, I extends AnyTypes>(op1: (input: Builder<T>) => Builder<A>, op2: (input: Builder<A>) => Builder<B>, op3: (input: Builder<B>) => Builder<C>, op4: (input: Builder<C>) => Builder<D>, op5: (input: Builder<D>) => Builder<E>, op6: (input: Builder<E>) => Builder<F>, op7: (input: Builder<F>) => Builder<G>, op8: (input: Builder<G>) => Builder<H>, op9: (input: Builder<H>) => Builder<I>): Builder<I>;
-    with<A extends AnyTypes, B extends AnyTypes, C extends AnyTypes, D extends AnyTypes, E extends AnyTypes, F extends AnyTypes, G extends AnyTypes, H extends AnyTypes, I extends AnyTypes, J extends AnyTypes>(op1: (input: Builder<T>) => Builder<A>, op2: (input: Builder<A>) => Builder<B>, op3: (input: Builder<B>) => Builder<C>, op4: (input: Builder<C>) => Builder<D>, op5: (input: Builder<D>) => Builder<E>, op6: (input: Builder<E>) => Builder<F>, op7: (input: Builder<F>) => Builder<G>, op8: (input: Builder<G>) => Builder<H>, op9: (input: Builder<H>) => Builder<I>, op10: (input: Builder<I>) => Builder<J>): Builder<J>;
-}
-declare namespace Builder {
-    function forSpecification<const Spec extends BuilderSpecification>(spec: Spec): {
-        builder: Builder<Types.FromSpecification<Spec>>;
-        model: ModelHelpers<Types.FromSpecification<Spec>>;
-        views: ViewHelpers<Types.FromSpecification<Spec>['NewViewProps']>;
-    };
-}
+import { L as LikeC4Theme, H as HexColorLiteral, T as ThemeColorValues } from './shared/core.D74xkKkG.js';
+export { A as AsFqn, h as BorderStyle, B as BorderStyles, s as Color, t as ColorLiteral, C as CustomColor, D as DefaultElementShape, e as DefaultThemeColor, i as Element, f as ElementKind, j as ElementKindSpecification, k as ElementKindSpecificationStyle, l as ElementShape, g as ElementShapes, m as ElementStyle, v as ElementThemeColorValues, u as ElementThemeColors, E as ExclusiveUnion, F as Fqn, I as IconUrl, a as IteratorLike, K as KeysOf, n as Link, c as NTuple, N as NonEmptyArray, b as NonEmptyReadonlyArray, P as Point, d as Predicate, w as RelationshipThemeColorValues, R as RelationshipThemeColors, o as Tag, p as TagSpec, x as ThemeColor, q as TypedElement, X as XYPoint, r as isThemeColor } from './shared/core.D74xkKkG.js';
+export { ar as AbstractRelation, ag as AndOperator, a5 as AnyParsedLikeC4Model, aS as AutoLayoutDirection, aV as BBox, aT as BasicElementView, aU as BasicView, aW as ComputedDeploymentView, aX as ComputedDynamicView, aY as ComputedEdge, aZ as ComputedElementView, a as ComputedLikeC4Model, ay as ComputedNode, C as ComputedView, a_ as CustomColorDefinitions, A as CustomElementExpr, B as CustomRelationExpr, ao as DefaultArrowType, ap as DefaultLineStyle, aq as DefaultRelationshipColor, b as DeployedInstance, D as DeploymentElement, c as DeploymentElementStyle, d as DeploymentNode, f as DeploymentNodeKind, g as DeploymentNodeKindSpecification, h as DeploymentRef, i as DeploymentRelation, a$ as DeploymentView, b0 as DeploymentViewRule, b1 as DeploymentViewRulePredicate, b2 as DeploymentViewRuleStyle, b3 as DiagramEdge, az as DiagramNode, b4 as DiagramView, E as DirectRelationExpr, b5 as DynamicView, b6 as DynamicViewIncludeRule, b7 as DynamicViewParallelSteps, b8 as DynamicViewRule, b9 as DynamicViewStep, ba as DynamicViewStepOrParallel, bb as EdgeId, F as ElementExpression, G as ElementKindExpr, bv as ElementNotation, H as ElementPredicateExpression, I as ElementRefExpr, J as ElementTagExpr, bc as ElementView, K as ElementWhereExpr, ah as EqualOperator, M as ExpandedElementExpr, e as Expr, N as Expression, X as ExpressionV2, bd as ExtendsElementView, ai as Filterable, Y as FqnExpr, Z as FqnRef, a6 as GenericLikeC4Model, $ as GlobalDynamicPredicates, a0 as GlobalPredicateId, a1 as GlobalPredicates, a2 as GlobalStyleID, a3 as GlobalStyles, Q as InOutExpr, O as IncomingExpr, aj as KindEqual, a7 as LayoutedLikeC4Model, a8 as LikeC4ModelDump, L as LikeC4View, a4 as ModelGlobals, as as ModelRelation, be as NodeId, R as NonWilcard, ak as NotOperator, al as OrOperator, S as OutgoingExpr, a9 as ParsedLikeC4Model, P as PredicateSelector, _ as RelationExpr, T as RelationExpression, at as RelationId, U as RelationPredicateExpression, V as RelationWhereExpr, au as RelationshipArrowType, av as RelationshipKind, aw as RelationshipKindSpecification, ax as RelationshipLineType, bf as ScopedElementView, bg as StepEdgeId, bh as StepEdgeIdLiteral, am as TagEqual, bi as ViewAutoLayout, bj as ViewId, bk as ViewManualLayout, bl as ViewRule, bm as ViewRuleAutoLayout, bn as ViewRuleGlobalPredicateRef, bo as ViewRuleGlobalStyle, bp as ViewRuleGroup, bq as ViewRulePredicate, br as ViewRuleStyle, bs as ViewRuleStyleOrGlobalRef, bt as ViewWithHash, bu as ViewWithNotation, an as WhereOperator, W as WildcardExpr, aA as extractStep, aB as getBBoxCenter, aC as getParallelStepsPrefix, aa as isAndOperator, aD as isAutoLayoutDirection, j as isCustomElement, k as isCustomRelationExpr, aE as isDeploymentView, aF as isDynamicView, aG as isDynamicViewParallelSteps, l as isElement, m as isElementKindExpr, n as isElementPredicateExpr, o as isElementRef, p as isElementTagExpr, aH as isElementView, q as isElementWhere, r as isExpandedElementExpr, aI as isExtendsElementView, t as isInOut, s as isIncoming, ab as isKindEqual, ac as isNotOperator, ad as isOrOperator, u as isOutgoing, v as isRelation, w as isRelationExpression, x as isRelationPredicateExpr, y as isRelationWhere, aJ as isScopedElementView, aK as isStepEdgeId, ae as isTagEqual, aL as isViewRuleAutoLayout, aM as isViewRuleGlobalPredicateRef, aN as isViewRuleGlobalStyle, aO as isViewRuleGroup, aP as isViewRulePredicate, aQ as isViewRuleStyle, z as isWildcard, aR as stepEdgeId, af as whereOperatorAsPredicate } from './shared/core.C05RDLhi.js';
+export { DefaultMap, LinkedList, commonHead, compareNatural, compareRelations, delay, difference, equalsSet, getOrCreate, hasAtLeast, ifilter, iflat, imap, intersection, ireduce, isIterable, isNonEmptyArray, isString, isome, iunique, objectHash, stringHash, symmetricDifference, toArray, toSet, union } from './utils/index.js';
+export { A as AnyAux, b as Aux, L as LikeC4DeploymentModel, d as LikeC4Model, e as LikeC4ViewModel } from './shared/core.BIfgabEw.js';
+export { OverviewGraph, ViewChange } from './types/index.js';
+export { I as IterableContainer, R as ReorderedArray, a as ancestorsFqn, c as commonAncestor, b as compareByFqnHierarchically, d as compareFqnHierarchically, h as hierarchyDistance, e as hierarchyLevel, i as isAncestor, f as isDescendantOf, g as isSameHierarchy, n as nameFromFqn, p as parentFqn, s as sortByFqnHierarchically, j as sortNaturalByFqn, k as sortParentsFirst } from './shared/core.D6-fWbM3.js';
+import 'type-fest';
 
 declare const ElementColors: {
     readonly primary: {
@@ -388,666 +134,11 @@ declare const RelationshipColors: {
     };
 };
 
-declare const defaultTheme: {
-    elements: {
-        readonly primary: {
-            fill: "#3b82f6";
-            stroke: "#2563eb";
-            hiContrast: "#eff6ff";
-            loContrast: "#bfdbfe";
-        };
-        readonly blue: {
-            fill: "#3b82f6";
-            stroke: "#2563eb";
-            hiContrast: "#eff6ff";
-            loContrast: "#bfdbfe";
-        };
-        readonly secondary: {
-            fill: "#0284c7";
-            stroke: "#0369a1";
-            hiContrast: "#f0f9ff";
-            loContrast: "#B6ECF7";
-        };
-        readonly sky: {
-            fill: "#0284c7";
-            stroke: "#0369a1";
-            hiContrast: "#f0f9ff";
-            loContrast: "#B6ECF7";
-        };
-        readonly muted: {
-            fill: "#64748b";
-            stroke: "#475569";
-            hiContrast: "#f8fafc";
-            loContrast: "#cbd5e1";
-        };
-        readonly slate: {
-            fill: "#64748b";
-            stroke: "#475569";
-            hiContrast: "#f8fafc";
-            loContrast: "#cbd5e1";
-        };
-        readonly gray: {
-            readonly fill: "#737373";
-            readonly stroke: "#525252";
-            readonly hiContrast: "#fafafa";
-            readonly loContrast: "#d4d4d4";
-        };
-        readonly red: {
-            readonly fill: "#AC4D39";
-            readonly stroke: "#853A2D";
-            readonly hiContrast: "#FBD3CB";
-            readonly loContrast: "#f5b2a3";
-        };
-        readonly green: {
-            readonly fill: "#428a4f";
-            readonly stroke: "#2d5d39";
-            readonly hiContrast: "#f8fafc";
-            readonly loContrast: "#c2f0c2";
-        };
-        readonly amber: {
-            readonly fill: "#A35829";
-            readonly stroke: "#7E451D";
-            readonly hiContrast: "#FFE0C2";
-            readonly loContrast: "#f9b27c";
-        };
-        readonly indigo: {
-            readonly fill: "#6366f1";
-            readonly stroke: "#4f46e5";
-            readonly hiContrast: "#eef2ff";
-            readonly loContrast: "#c7d2fe";
-        };
-    };
-    relationships: {
-        amber: {
-            lineColor: "#b45309";
-            labelBgColor: "#78350f";
-            labelColor: "#FFE0C2";
-        };
-        blue: {
-            lineColor: "#3b82f6";
-            labelBgColor: "#172554";
-            labelColor: "#60a5fa";
-        };
-        gray: {
-            lineColor: "#6E6E6E";
-            labelBgColor: "#18191b";
-            labelColor: "#C6C6C6";
-        };
-        green: {
-            lineColor: "#15803d";
-            labelBgColor: "#052e16";
-            labelColor: "#22c55e";
-        };
-        indigo: {
-            lineColor: "#6366f1";
-            labelBgColor: "#1e1b4b";
-            labelColor: "#818cf8";
-        };
-        muted: {
-            lineColor: "#64748b";
-            labelBgColor: "#0f172a";
-            labelColor: "#cbd5e1";
-        };
-        primary: {
-            lineColor: "#3b82f6";
-            labelBgColor: "#172554";
-            labelColor: "#60a5fa";
-        };
-        red: {
-            lineColor: "#AC4D39";
-            labelBgColor: "#b91c1c";
-            labelColor: "#f5b2a3";
-        };
-        secondary: {
-            lineColor: "#0ea5e9";
-            labelBgColor: "#082f49";
-            labelColor: "#38bdf8";
-        };
-        sky: {
-            lineColor: "#0ea5e9";
-            labelBgColor: "#082f49";
-            labelColor: "#38bdf8";
-        };
-        slate: {
-            lineColor: "#64748b";
-            labelBgColor: "#0f172a";
-            labelColor: "#cbd5e1";
-        };
-    };
-    font: "Arial";
-    shadow: "#0a0a0a";
-};
+declare const defaultTheme: LikeC4Theme;
 declare function computeColorValues(color: HexColorLiteral): ThemeColorValues;
 
 declare function nonNullable<T>(value: T, message?: string): NonNullable<T>;
 declare function invariant(condition: any, message?: string): asserts condition;
 declare function nonexhaustive(value: never): never;
 
-type Fqn = LiteralUnion<Fqn$1, string>;
-type RelationID = LiteralUnion<RelationID$1, string>;
-type ViewID = LiteralUnion<ViewID$1, string>;
-type EdgeId = LiteralUnion<EdgeId$1, string>;
-type IncomingFilter = 'all' | 'direct' | 'to-descendants';
-type OutgoingFilter = 'all' | 'direct' | 'from-descendants';
-type ElementOrFqn = Fqn | {
-    id: Fqn;
-};
-
-/**
- * All methods are view-scoped, i.e. only return elements and connections in the view.
- */
-declare class LikeC4ViewModel {
-    readonly view: ComputedView;
-    readonly model: LikeC4Model<LikeC4ViewModel>;
-    private readonly _rootElements;
-    private readonly _elements;
-    private readonly _connections;
-    constructor(view: ComputedView, model: LikeC4Model<LikeC4ViewModel>);
-    get id(): ViewID$1<string>;
-    get title(): string;
-    get viewOf(): LikeC4Model.ElementModel<LikeC4ViewModel>;
-    get tags(): Tag[];
-    roots(): ReadonlyArray<LikeC4ViewModel.Element>;
-    elements(): ReadonlyArray<LikeC4ViewModel.Element>;
-    element(id: Fqn): LikeC4ViewModel.Element;
-    hasElement(id: Fqn): boolean;
-    connections(): ReadonlyArray<LikeC4ViewModel.Connection>;
-    connection(id: EdgeId): LikeC4ViewModel.Connection;
-    findConnections(source: ElementOrFqn, target: ElementOrFqn, direction?: 'both' | 'direct'): ReadonlyArray<LikeC4ViewModel.Connection>;
-    parent(element: ElementOrFqn): LikeC4ViewModel.Element | null;
-    children(element: ElementOrFqn): ReadonlyArray<LikeC4ViewModel.Element>;
-    siblings(element: ElementOrFqn): ReadonlyArray<LikeC4ViewModel.Element>;
-    /**
-     * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
-     * (from closest to root)
-     */
-    ancestors(element: ElementOrFqn): ReadonlyArray<LikeC4ViewModel.Element>;
-    descendants(element: ElementOrFqn): ReadonlyArray<LikeC4ViewModel.Element>;
-    incoming(element: ElementOrFqn, filter?: IncomingFilter): ReadonlyArray<LikeC4ViewModel.Connection>;
-    incomers(element: ElementOrFqn, filter?: IncomingFilter): ReadonlyArray<LikeC4ViewModel.Element>;
-    /**
-     * Outgoing relationships from the element and its descendants
-     */
-    outgoing(element: ElementOrFqn, filter?: OutgoingFilter): ReadonlyArray<LikeC4ViewModel.Connection>;
-    outgoers(element: ElementOrFqn, filter?: OutgoingFilter): ReadonlyArray<LikeC4ViewModel.Element>;
-}
-declare namespace LikeC4ViewModel {
-    /**
-     * Represents an element in the view. (Diagram node)
-     * All methods are view-scoped, i.e. `children` returns only children of the element in the view.
-     */
-    class Element {
-        readonly node: ComputedNode;
-        private readonly viewmodel;
-        constructor(node: ComputedNode, viewmodel: LikeC4ViewModel);
-        get id(): NodeId<string>;
-        get title(): string;
-        get kind(): ElementKind;
-        get isRoot(): boolean;
-        get hasNested(): boolean;
-        get shape(): ElementShape;
-        get color(): Color;
-        get tags(): Tag[];
-        model(): LikeC4Model.ElementModel<LikeC4ViewModel>;
-        parent(): LikeC4ViewModel.Element | null;
-        metadata(key: string): string | undefined;
-        metadata(key: string, defaultValue: string): string;
-        hasMetadata(key: string): boolean;
-        ancestors(): ReadonlyArray<LikeC4ViewModel.Element>;
-        siblings(): ReadonlyArray<LikeC4ViewModel.Element>;
-        descendants(): ReadonlyArray<LikeC4ViewModel.Element>;
-        children(): ReadonlyArray<LikeC4ViewModel.Element>;
-        incoming(filter?: 'all' | 'direct' | 'to-descendants'): ReadonlyArray<LikeC4ViewModel.Connection>;
-        incomers(filter?: 'all' | 'direct' | 'to-descendants'): ReadonlyArray<LikeC4ViewModel.Element>;
-        outgoing(filter?: OutgoingFilter): ReadonlyArray<LikeC4ViewModel.Connection>;
-        outgoers(filter?: OutgoingFilter): ReadonlyArray<LikeC4ViewModel.Element>;
-        connectionsTo(target: Fqn | LikeC4ViewModel.Element): ReadonlyArray<LikeC4ViewModel.Connection>;
-    }
-    /**
-     * Represents a connection between two elements.
-     * May be source from multiple model relationships.
-     */
-    class Connection {
-        readonly edge: ComputedEdge;
-        private readonly viewmodel;
-        constructor(edge: ComputedEdge, viewmodel: LikeC4ViewModel);
-        get id(): EdgeId$1;
-        get source(): LikeC4ViewModel.Element;
-        get target(): LikeC4ViewModel.Element;
-        get tags(): Tag[];
-        /**
-         * Model relationships
-         */
-        relationships(): ReadonlyArray<LikeC4Model.Relationship<LikeC4ViewModel>>;
-    }
-}
-
-type PickBySource<Source> = Source extends LikeC4Model.Layouted.SourceModel ? LikeC4Model.Layouted : Source extends LikeC4Model.Computed.SourceModel ? LikeC4Model.Computed : never;
-declare class LikeC4Model<M extends LikeC4Model.ViewModel = LikeC4Model.ViewModel> {
-    readonly type: LikeC4Model.ModelType<M>;
-    readonly sourcemodel: LikeC4Model.SourceModel<M>;
-    private _elements;
-    private _parents;
-    private _children;
-    private _rootElements;
-    private _relations;
-    private _incoming;
-    private _outgoing;
-    private _internal;
-    private _cacheAscendingSiblings;
-    private _views;
-    constructor(type: LikeC4Model.ModelType<M>, sourcemodel: LikeC4Model.SourceModel<M>, elements: Element[], relations: Relation[], views: LikeC4Model.SourceModel<M>['views'], ViewModelClass: Class<M>);
-    /**
-     * Returns the root elements of the model.
-     */
-    roots(): ReadonlyArray<LikeC4Model.ElementModel<M>>;
-    /**
-     * Returns all elements in the model.
-     */
-    elements(): ReadonlyArray<LikeC4Model.ElementModel<M>>;
-    /**
-     * Returns a specific element by its FQN.
-     */
-    element(id: Fqn): LikeC4Model.ElementModel<M>;
-    /**
-     * Returns all relationships in the model.
-     */
-    relationships(): ReadonlyArray<LikeC4Model.Relationship<M>>;
-    /**
-     * Returns a specific relationship by its ID.
-     */
-    relationship(id: RelationID): LikeC4Model.Relationship<M>;
-    /**
-     * Returns all views in the model.
-     */
-    views(): ReadonlyArray<M>;
-    /**
-     * Returns a specific view by its ID.
-     */
-    view(viewId: ViewID): M;
-    /**
-     * Returns the parent element of given element.
-     * @see ancestors
-     */
-    parent(element: ElementOrFqn): LikeC4Model.ElementModel<M> | null;
-    /**
-     * Get all children of the element (only direct children),
-     * @see descendants
-     */
-    children(element: ElementOrFqn): ReadonlyArray<LikeC4Model.ElementModel<M>>;
-    /**
-     * Get all sibling (i.e. same parent)
-     */
-    siblings(element: ElementOrFqn): ReadonlyArray<LikeC4Model.ElementModel<M>>;
-    /**
-     * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
-     * (from closest to root)
-     */
-    ancestors(element: ElementOrFqn): ReadonlyArray<LikeC4Model.ElementModel<M>>;
-    /**
-     * Get all descendant elements (i.e. children, children’s children, etc.)
-     */
-    descendants(element: ElementOrFqn): ReadonlyArray<LikeC4Model.ElementModel<M>>;
-    /**
-     * Incoming relationships to the element and its descendants
-     * @see incomers
-     */
-    incoming(element: ElementOrFqn, filter?: IncomingFilter): ReadonlyArray<LikeC4Model.Relationship<M>>;
-    /**
-     * Source elements of incoming relationships
-     */
-    incomers(element: ElementOrFqn, filter?: IncomingFilter): ReadonlyArray<LikeC4Model.ElementModel<M>>;
-    /**
-     * Outgoing relationships from the element and its descendants
-     * @see outgoers
-     */
-    outgoing(element: ElementOrFqn, filter?: OutgoingFilter): ReadonlyArray<LikeC4Model.Relationship<M>>;
-    /**
-     * Target elements of outgoing relationships
-     */
-    outgoers(element: ElementOrFqn, filter?: OutgoingFilter): ReadonlyArray<LikeC4Model.ElementModel<M>>;
-    /**
-     * Relationships inside the element, among descendants
-     */
-    internal(element: ElementOrFqn): ReadonlyArray<LikeC4Model.Relationship<M>>;
-    /**
-     * Resolve siblings of the element and siblings of ancestors
-     *  (from closest to root)
-     */
-    ascendingSiblings(element: ElementOrFqn): ReadonlyArray<LikeC4Model.ElementModel<M>>;
-    /**
-     * Resolve all views that contain the element
-     */
-    viewsWithElement(element: ElementOrFqn): ReadonlyArray<M>;
-    private addElement;
-    private addRelation;
-    private _childrenOf;
-    private _incomingTo;
-    private _outgoingFrom;
-    private _internalOf;
-}
-declare namespace LikeC4Model {
-    function create(source: LikeC4Model.SourceModel): PickBySource<typeof source>;
-    function computed(source: ComputedLikeC4Model): LikeC4Model<LikeC4ViewModel>;
-    function layouted(source: LayoutedLikeC4Model): LikeC4Model<LikeC4DiagramModel>;
-    function isModel(model: any): model is LikeC4Model;
-    type SourceModel<M extends ViewModel = ViewModel> = M extends LikeC4DiagramModel ? LayoutedLikeC4Model : ComputedLikeC4Model;
-    type ViewModel = LikeC4ViewModel | LikeC4DiagramModel;
-    namespace ViewModel {
-        type ElementModel = LikeC4ViewModel.Element | LikeC4DiagramModel.Element;
-        type Relationship = LikeC4Model.Relationship<ViewModel>;
-        function isLayouted(model: ViewModel): model is LikeC4DiagramModel;
-    }
-    type Computed = LikeC4Model<LikeC4ViewModel>;
-    namespace Computed {
-        type ViewModel = LikeC4ViewModel;
-        type SourceModel = LikeC4Model.SourceModel<ViewModel>;
-    }
-    type Layouted = LikeC4Model<LikeC4DiagramModel>;
-    namespace Layouted {
-        type ViewModel = LikeC4DiagramModel;
-        type SourceModel = LikeC4Model.SourceModel<ViewModel>;
-    }
-    type ModelType<M extends ViewModel = ViewModel> = M extends LikeC4DiagramModel ? 'layouted' : M extends LikeC4ViewModel ? 'computed' : never;
-    function isLayouted(model: LikeC4Model): model is Layouted;
-    class Relationship<M extends ViewModel = ViewModel> {
-        readonly relationship: Relation;
-        private readonly model;
-        constructor(relationship: Relation, model: LikeC4Model<M>);
-        get id(): RelationID$1;
-        get title(): string;
-        get kind(): RelationshipKind<string>;
-        get tags(): Tag[];
-        get source(): ElementModel<M>;
-        get target(): ElementModel<M>;
-        metadata(key: string): string | undefined;
-        metadata(key: string, defaultValue: string): string;
-        hasMetadata(key: string): boolean;
-    }
-    class ElementModel<M extends ViewModel = ViewModel> {
-        readonly element: Element;
-        private readonly model;
-        constructor(element: Element, model: LikeC4Model<M>);
-        get id(): Fqn$1<string>;
-        get title(): string;
-        get kind(): ElementKind;
-        get isRoot(): boolean;
-        get hasNested(): boolean;
-        get shape(): ElementShape;
-        get color(): Color;
-        get tags(): Tag[];
-        parent(): ElementModel<M> | null;
-        metadata(key: string): string | undefined;
-        metadata(key: string, defaultValue: string): string;
-        hasMetadata(key: string): boolean;
-        ancestors(): readonly ElementModel<M>[];
-        siblings(): readonly ElementModel<M>[];
-        descendants(): readonly ElementModel<M>[];
-        children(): readonly ElementModel<M>[];
-        /**
-         * First 'view of' current element
-         */
-        viewOf(): M;
-        /**
-         * All views 'view of' current element
-         */
-        viewsOf(): M[];
-        /**
-         * Views that contain this element
-         */
-        views(): readonly M[];
-        incoming(filter?: IncomingFilter): readonly Relationship<M>[];
-        incomers(filter?: IncomingFilter): readonly ElementModel<M>[];
-        outgoing(filter?: OutgoingFilter): readonly Relationship<M>[];
-        outgoers(filter?: OutgoingFilter): readonly ElementModel<M>[];
-        internal(): readonly Relationship<M>[];
-        /**
-         * Resolve siblings of the element and siblings of ancestors
-         *  (from closest to root)
-         */
-        ascendingSiblings(): readonly ElementModel<M>[];
-    }
-}
-
-/**
- * All methods are view-scoped, i.e. only return elements and connections in the view.
- */
-declare class LikeC4DiagramModel {
-    readonly view: DiagramView;
-    readonly model: LikeC4Model.Layouted;
-    private readonly _rootElements;
-    private readonly _elements;
-    private readonly _connections;
-    constructor(view: DiagramView, model: LikeC4Model.Layouted);
-    get isDynamic(): boolean;
-    get id(): ViewID$1<string>;
-    get title(): string;
-    get viewOf(): LikeC4Model.ElementModel<LikeC4DiagramModel>;
-    get tags(): Tag[];
-    roots(): ReadonlyArray<LikeC4DiagramModel.Element>;
-    elements(): ReadonlyArray<LikeC4DiagramModel.Element>;
-    element(id: Fqn): LikeC4DiagramModel.Element;
-    hasElement(id: Fqn): boolean;
-    connections(): ReadonlyArray<LikeC4DiagramModel.Connection>;
-    connection(id: EdgeId): LikeC4DiagramModel.Connection;
-    findConnections(source: ElementOrFqn, target: ElementOrFqn, direction?: 'both' | 'direct'): ReadonlyArray<LikeC4DiagramModel.Connection>;
-    parent(element: ElementOrFqn): LikeC4DiagramModel.Element | null;
-    children(element: ElementOrFqn): ReadonlyArray<LikeC4DiagramModel.Element>;
-    siblings(element: ElementOrFqn): ReadonlyArray<LikeC4DiagramModel.Element>;
-    /**
-     * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
-     * (from closest to root)
-     */
-    ancestors(element: ElementOrFqn): ReadonlyArray<LikeC4DiagramModel.Element>;
-    descendants(element: ElementOrFqn): ReadonlyArray<LikeC4DiagramModel.Element>;
-    incoming(element: ElementOrFqn, filter?: IncomingFilter): ReadonlyArray<LikeC4DiagramModel.Connection>;
-    incomers(element: ElementOrFqn, filter?: IncomingFilter): ReadonlyArray<LikeC4DiagramModel.Element>;
-    /**
-     * Outgoing relationships from the element and its descendants
-     */
-    outgoing(element: ElementOrFqn, filter?: OutgoingFilter): ReadonlyArray<LikeC4DiagramModel.Connection>;
-    outgoers(element: ElementOrFqn, filter?: OutgoingFilter): ReadonlyArray<LikeC4DiagramModel.Element>;
-}
-declare namespace LikeC4DiagramModel {
-    /**
-     * Represents an element in the view. (Diagram node)
-     * All methods are view-scoped, i.e. `children` returns only children of the element in the view.
-     */
-    class Element {
-        readonly node: DiagramNode;
-        private readonly view;
-        constructor(node: DiagramNode, view: LikeC4DiagramModel);
-        get id(): NodeId<string>;
-        get title(): string;
-        get kind(): ElementKind;
-        get isRoot(): boolean;
-        get hasNested(): boolean;
-        get shape(): ElementShape;
-        get color(): Color;
-        get tags(): Tag[];
-        get level(): number;
-        get depth(): number;
-        model(): LikeC4Model.ElementModel<LikeC4DiagramModel>;
-        parent(): LikeC4DiagramModel.Element | null;
-        metadata(key: string): string | undefined;
-        metadata(key: string, defaultValue: string): string;
-        hasMetadata(key: string): boolean;
-        ancestors(): ReadonlyArray<LikeC4DiagramModel.Element>;
-        siblings(): ReadonlyArray<LikeC4DiagramModel.Element>;
-        descendants(): ReadonlyArray<LikeC4DiagramModel.Element>;
-        children(): ReadonlyArray<LikeC4DiagramModel.Element>;
-        incoming(filter?: IncomingFilter): ReadonlyArray<LikeC4DiagramModel.Connection>;
-        incomers(filter?: IncomingFilter): ReadonlyArray<LikeC4DiagramModel.Element>;
-        outgoing(filter?: OutgoingFilter): ReadonlyArray<LikeC4DiagramModel.Connection>;
-        outgoers(filter?: OutgoingFilter): ReadonlyArray<LikeC4DiagramModel.Element>;
-        connectionsTo(target: Fqn | LikeC4DiagramModel.Element): ReadonlyArray<LikeC4DiagramModel.Connection>;
-    }
-    /**
-     * Represents a connection between two elements.
-     * May be source from multiple model relationships.
-     */
-    class Connection {
-        readonly edge: DiagramEdge;
-        private readonly view;
-        constructor(edge: DiagramEdge, view: LikeC4DiagramModel);
-        get id(): EdgeId$1;
-        get source(): LikeC4DiagramModel.Element;
-        get target(): LikeC4DiagramModel.Element;
-        get tags(): Tag[];
-        get color(): Color;
-        /**
-         * Model relationships
-         */
-        relationships(): ReadonlyArray<LikeC4Model.Relationship<LikeC4DiagramModel>>;
-    }
-}
-
-/**
- * Common head of two arrays
- */
-declare function commonHead<T>(sources: ReadonlyArray<T>, targets: ReadonlyArray<T>, equals?: (a: T, b: T) => boolean): T[];
-
-declare function compareNatural(a: string | undefined, b: string | undefined): -1 | 0 | 1;
-
-type Predicate<T> = (x: T) => boolean;
-declare function nameFromFqn(fqn: LiteralUnion<Fqn$1, string>): string;
-declare function isAncestor<E extends {
-    id: Fqn$1;
-}>(...args: [ancestor: string, another: string] | [ancestor: E, another: E]): boolean;
-declare function isSameHierarchy<E extends {
-    id: Fqn$1;
-}>(one: E | Fqn$1, another: E | Fqn$1): boolean;
-declare function isDescendantOf<E extends {
-    id: Fqn$1;
-}>(ancestors: E[]): (e: E) => boolean;
-declare function notDescendantOf(ancestors: Element[]): (e: Element) => boolean;
-declare function commonAncestor<IDs extends string>(first: Fqn$1<IDs>, second: Fqn$1<IDs>): Fqn$1<IDs>;
-declare function parentFqn<IDs extends string>(fqn: Fqn$1<IDs>): Fqn$1<IDs> | null;
-declare function parentFqnPredicate<T extends {
-    parent: Fqn$1 | null;
-}>(parent: Fqn$1): Predicate<T>;
-/**
- * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
- * (from closest to root)
- */
-declare function ancestorsFqn<IDs extends string>(fqn: Fqn$1<IDs>): Fqn$1<IDs>[];
-/**
- * Compares two fully qualified names (fqns) hierarchically based on their depth.
- * From parent nodes to leaves
- *
- * @param {string} a - The first fqn to compare.
- * @param {string} b - The second fqn to compare.
- * @returns {number} - 0 if the fqns have the same depth.
- *                    - Positive number if a is deeper than b.
- *                    - Negative number if b is deeper than a.
- */
-declare function compareFqnHierarchically<T extends string = string>(a: T, b: T): -1 | 0 | 1;
-declare function compareByFqnHierarchically<T extends {
-    id: string;
-}>(a: T, b: T): 0 | 1 | -1;
-type IterableContainer$1<T = unknown> = ReadonlyArray<T> | readonly [];
-type ReorderedArray<T extends IterableContainer$1> = {
-    -readonly [P in keyof T]: T[number];
-};
-declare function sortByFqnHierarchically<T extends {
-    id: string;
-}, A extends IterableContainer$1<T>>(array: A): ReorderedArray<A>;
-declare function sortNaturalByFqn<T extends {
-    id: string;
-}, A extends IterableContainer$1<T>>(array: A): ReorderedArray<A>;
-
-/**
- * This should only be used for defining generics which extend any kind of JS
- * array under the hood, this includes arrays *AND* tuples (of the form [x, y],
- * and of the form [x, ...y[]], etc...), and their readonly equivalent. This
- * allows us to be more inclusive to what functions can process.
- *
- * @example
- *   function map<T extends IterableContainer>(items: T) { ... }
- *
- * We would've named this `ArrayLike`, but that's already used by typescript...
- * @see This was inspired by the type-definition of Promise.all (https://github.com/microsoft/TypeScript/blob/1df5717b120cddd325deab8b0f2b2c3eecaf2b01/src/lib/es2015.promise.d.ts#L21)
- */
-type IterableContainer<T = unknown> = ReadonlyArray<T> | readonly [];
-
-type ArraySetRequired<T extends IterableContainer, Min extends number, Iteration extends ReadonlyArray<unknown> = []> = number extends Min ? never : Iteration["length"] extends Min ? T : T extends readonly [] ? never : T extends [infer Head, ...infer Rest] ? [
-    Head,
-    ...ArraySetRequired<Rest, Min, [unknown, ...Iteration]>
-] : T extends readonly [infer Head, ...infer Rest] ? readonly [
-    Head,
-    ...ArraySetRequired<Rest, Min, [unknown, ...Iteration]>
-] : T extends Array<infer Item> ? [
-    Item,
-    ...ArraySetRequired<T, Min, [unknown, ...Iteration]>
-] : T extends ReadonlyArray<infer Item> ? readonly [
-    Item,
-    ...ArraySetRequired<T, Min, [unknown, ...Iteration]>
-] : never;
-/**
- * Checks if the given array has at least the defined number of elements. When
- * the minimum used is a literal (e.g. `3`) the output is refined accordingly so
- * that those indices are defined when accessing the array even when using
- * typescript's 'noUncheckedIndexAccess'.
- *
- * @param data - The input array.
- * @param minimum - The minimum number of elements the array must have.
- * @returns True if the array's length is *at least* `minimum`. When `minimum`
- * is a literal value, the output is narrowed to ensure the first items are
- * guaranteed.
- * @signature
- *   R.hasAtLeast(data, minimum)
- * @example
- *   R.hasAtLeast([], 4); // => false
- *
- *   const data: number[] = [1,2,3,4];
- *   R.hasAtLeast(data, 1); // => true
- *   data[0]; // 1, with type `number`
- * @dataFirst
- * @category Array
- */
-declare function hasAtLeast<T extends IterableContainer, N extends number>(data: IterableContainer | T, minimum: IsNumericLiteral<N> extends true ? N : never): data is ArraySetRequired<T, N>;
-declare function hasAtLeast(data: IterableContainer, minimum: number): boolean;
-/**
- * Checks if the given array has at least the defined number of elements. When
- * the minimum used is a literal (e.g. `3`) the output is refined accordingly so
- * that those indices are defined when accessing the array even when using
- * typescript's 'noUncheckedIndexAccess'.
- *
- * @param minimum - The minimum number of elements the array must have.
- * @returns True if the array's length is *at least* `minimum`. When `minimum`
- * is a literal value, the output is narrowed to ensure the first items are
- * guaranteed.
- * @signature
- *   R.hasAtLeast(minimum)(data)
- * @example
- *   R.pipe([], R.hasAtLeast(4)); // => false
- *
- *   const data = [[1,2], [3], [4,5]];
- *   R.pipe(
- *     data,
- *     R.filter(R.hasAtLeast(2)),
- *     R.map(([, second]) => second),
- *   ); // => [2,5], with type `number[]`
- * @dataLast
- * @category Array
- */
-declare function hasAtLeast<N extends number>(minimum: IsNumericLiteral<N> extends true ? N : never): <T extends IterableContainer>(data: IterableContainer | T) => data is ArraySetRequired<T, N>;
-declare function hasAtLeast(minimum: number): (data: IterableContainer) => boolean;
-
-declare function isString(value: unknown): value is string;
-declare function isNonEmptyArray<A>(arr: ArrayLike<A> | undefined): arr is NonEmptyArray<A>;
-
-declare function delay(): Promise<string>;
-declare function delay(ms: number): Promise<string>;
-declare function delay(randomFrom: number, randomTo: number): Promise<string>;
-
-/**
- * Compares two relations hierarchically.
- * From the most general (implicit) to the most specific.
- */
-declare const compareRelations: <T extends {
-    source: string;
-    target: string;
-}>(a: T, b: T) => 0 | 1 | -1;
-
-export { type AnyTypes, type AnyTypesNested, AutoLayoutDirection, BorderStyle, Builder, type BuilderSpecification, Color, ComputedEdge, ComputedLikeC4Model, ComputedNode, ComputedView, CustomElementExpr, CustomRelationExpr, DiagramEdge, DiagramNode, DiagramView, EdgeId$1 as EdgeId, Element, ElementColors, ElementKind, ElementKindSpecification, ElementShape, type Expression, Fqn$1 as Fqn, HexColorLiteral, LayoutedLikeC4Model, LikeC4DiagramModel, LikeC4Model, LikeC4View, LikeC4ViewModel, type ModelBuilder, type ModelHelpers, NodeId, NonEmptyArray, ParsedLikeC4Model, Relation, RelationID$1 as RelationID, RelationshipArrowType, RelationshipColors, RelationshipKind, RelationshipKindSpecification, RelationshipLineType, Tag, ThemeColorValues, Types, type TypesNested, type ViewBuilder, type ViewHelpers, ViewID$1 as ViewID, ViewRuleStyle, type ViewsBuilder, ancestorsFqn, commonAncestor, commonHead, compareByFqnHierarchically, compareFqnHierarchically, compareNatural, compareRelations, computeColorValues, defaultTheme, delay, hasAtLeast, invariant, isAncestor, isDescendantOf, isNonEmptyArray, isSameHierarchy, isString, nameFromFqn, nonNullable, nonexhaustive, notDescendantOf, parentFqn, parentFqnPredicate, sortByFqnHierarchically, sortNaturalByFqn };
+export { ElementColors, HexColorLiteral, LikeC4Theme, RelationshipColors, ThemeColorValues, computeColorValues, defaultTheme, invariant, nonNullable, nonexhaustive };