likec4 1.12.2 → 1.13.0

package/dist/index.d.mts

@@ -1,4 +1,13 @@
-import { LiteralUnion, Tagged, UnwrapTagged, IsNumericLiteral, SetRequired, ValueOf, ConditionalPick } from 'type-fest';
+import { LiteralUnion, Tagged, TupleToUnion, Class, IsNumericLiteral, IfNever, Simplify, SetRequired, ValueOf, ConditionalPick } from 'type-fest';
+
+type NonEmptyArray<T> = [T, ...T[]];
+type IconUrl = Tagged<string, 'IconUrl'>;
+type CustomColor$1 = string;
+type Point = readonly [x: number, y: number];
+interface XYPoint {
+    x: number;
+    y: number;
+}
 
 declare const ThemeColors: readonly ["amber", "blue", "gray", "slate", "green", "indigo", "muted", "primary", "red", "secondary", "sky"];
 type ThemeColor$1 = typeof ThemeColors[number];
@@ -21,47 +30,38 @@ interface ThemeColorValues {
     relationships: RelationshipThemeColorValues;
 }
 
-type NonEmptyArray<T> = [T, ...T[]];
-type IconUrl = Tagged<string, 'IconUrl'>;
-type CustomColor$1 = string;
-type Point = readonly [x: number, y: number];
-interface XYPoint {
-    x: number;
-    y: number;
-}
-
-type Fqn$1 = Tagged<string, 'Fqn'>;
+type Fqn$1<Id extends string = string> = Tagged<Id, 'Fqn'>;
 declare const BorderStyles: readonly ["solid", "dashed", "dotted", "none"];
-type BorderStyle = typeof BorderStyles[number];
-type ElementKind$1 = Tagged<string, 'ElementKind'>;
+type BorderStyle = TupleToUnion<typeof BorderStyles>;
+type ElementKind$1<Kinds extends string = string> = Tagged<Kinds, 'ElementKind'>;
 declare const ElementShapes: readonly ["rectangle", "person", "browser", "mobile", "cylinder", "storage", "queue"];
-type ElementShape$1 = typeof ElementShapes[number];
+type ElementShape$1 = TupleToUnion<typeof ElementShapes>;
 interface ElementStyle {
     border?: BorderStyle;
     opacity?: number;
 }
-type Tag$1 = Tagged<string, 'Tag'>;
+type Tag$1<Tags extends string = string> = Tagged<Tags, 'Tag'>;
 interface Link {
     readonly title?: string;
     readonly url: string;
     readonly relative?: string;
 }
-interface Element$1 {
-    readonly id: Fqn$1;
-    readonly kind: ElementKind$1;
+interface TypedElement<Ids extends string, Kinds extends string, Tags extends string, MetadataKeys extends string = never> {
+    readonly id: Fqn$1<Ids>;
+    readonly kind: ElementKind$1<Kinds>;
     readonly title: string;
     readonly description: string | null;
     readonly technology: string | null;
-    readonly tags: NonEmptyArray<Tag$1> | null;
+    readonly tags: NonEmptyArray<Tag$1<Tags>> | null;
     readonly links: NonEmptyArray<Link> | null;
     readonly icon?: IconUrl;
     readonly shape?: ElementShape$1;
     readonly color?: Color$1;
     readonly style?: ElementStyle;
     readonly notation?: string;
-    readonly metadata?: {
-        [key: string]: string;
-    };
+    readonly metadata?: Record<MetadataKeys, string>;
+}
+interface Element$1 extends TypedElement<string, string, string, string> {
 }
 interface ElementKindSpecificationStyle {
     shape?: ElementShape$1;
@@ -107,135 +107,6 @@ type OrOperator<Tag, Kind> = Omit<AllNever, 'or'> & {
 };
 type WhereOperator<Tag, Kind> = TagEqual<Tag> | KindEqual<Kind> | NotOperator<Tag, Kind> | AndOperator<Tag, Kind> | OrOperator<Tag, Kind>;
 
-type RelationID$1 = Tagged<string, 'RelationID'>;
-type RelationshipKind$1 = Tagged<string, 'RelationshipKind'>;
-type RelationshipLineType = 'dashed' | 'solid' | 'dotted';
-type RelationshipArrowType = 'none' | 'normal' | 'onormal' | 'dot' | 'odot' | 'diamond' | 'odiamond' | 'crow' | 'open' | 'vee';
-interface Relation$1 {
-    readonly id: RelationID$1;
-    readonly source: Fqn$1;
-    readonly target: Fqn$1;
-    readonly title: string;
-    readonly description?: string;
-    readonly technology?: string;
-    readonly tags?: NonEmptyArray<Tag$1>;
-    readonly kind?: RelationshipKind$1;
-    readonly color?: Color$1;
-    readonly line?: RelationshipLineType;
-    readonly head?: RelationshipArrowType;
-    readonly tail?: RelationshipArrowType;
-    readonly links?: NonEmptyArray<Link>;
-    readonly navigateTo?: ViewID$1;
-    readonly metadata?: {
-        [key: string]: string;
-    };
-}
-interface RelationshipKindSpecification {
-    readonly technology?: string;
-    readonly notation?: string;
-    readonly color?: Color$1;
-    readonly line?: RelationshipLineType;
-    readonly head?: RelationshipArrowType;
-    readonly tail?: RelationshipArrowType;
-}
-
-interface BaseExpr {
-    where?: never;
-    element?: never;
-    custom?: never;
-    expanded?: never;
-    elementKind?: never;
-    elementTag?: never;
-    isEqual?: never;
-    isDescedants?: never;
-    wildcard?: never;
-    source?: never;
-    target?: never;
-    inout?: never;
-    incoming?: never;
-    outgoing?: never;
-    customRelation?: never;
-}
-interface ElementRefExpr extends Omit<BaseExpr, 'element' | 'isDescedants'> {
-    element: Fqn$1;
-    isDescedants?: boolean;
-}
-interface ExpandedElementExpr extends Omit<BaseExpr, 'expanded'> {
-    expanded: Fqn$1;
-}
-interface CustomElementExpr extends Omit<BaseExpr, 'custom'> {
-    custom: {
-        expr: ElementExpression$1 | ElementWhereExpr;
-        title?: string;
-        description?: string;
-        technology?: string;
-        notation?: string;
-        shape?: ElementShape$1;
-        color?: Color$1;
-        icon?: IconUrl;
-        border?: BorderStyle;
-        opacity?: number;
-        navigateTo?: ViewID$1;
-    };
-}
-interface WildcardExpr extends Omit<BaseExpr, 'wildcard'> {
-    wildcard: true;
-}
-interface ElementKindExpr extends Omit<BaseExpr, 'elementKind' | 'isEqual'> {
-    elementKind: ElementKind$1;
-    isEqual: boolean;
-}
-interface ElementTagExpr extends Omit<BaseExpr, 'elementTag' | 'isEqual'> {
-    elementTag: Tag$1;
-    isEqual: boolean;
-}
-type ElementExpression$1 = ElementRefExpr | WildcardExpr | ElementKindExpr | ElementTagExpr | ExpandedElementExpr;
-interface ElementWhereExpr extends Omit<BaseExpr, 'where'> {
-    where: {
-        expr: ElementExpression$1;
-        condition: WhereOperator<string, string>;
-    };
-}
-type ElementPredicateExpression = ElementExpression$1 | ElementWhereExpr | CustomElementExpr;
-interface RelationExpr extends Omit<BaseExpr, 'source' | 'target'> {
-    source: ElementExpression$1;
-    target: ElementExpression$1;
-    isBidirectional?: boolean;
-}
-interface InOutExpr extends Omit<BaseExpr, 'inout'> {
-    inout: ElementExpression$1;
-}
-interface IncomingExpr extends Omit<BaseExpr, 'incoming'> {
-    incoming: ElementExpression$1;
-}
-interface OutgoingExpr extends Omit<BaseExpr, 'outgoing'> {
-    outgoing: ElementExpression$1;
-}
-type RelationExpression$1 = RelationExpr | InOutExpr | IncomingExpr | OutgoingExpr;
-interface RelationWhereExpr extends Omit<BaseExpr, 'where'> {
-    where: {
-        expr: RelationExpression$1;
-        condition: WhereOperator<string, string>;
-    };
-}
-interface CustomRelationExpr extends Omit<BaseExpr, 'customRelation'> {
-    customRelation: {
-        relation: RelationExpression$1 | RelationWhereExpr;
-        title?: string;
-        description?: string;
-        technology?: string;
-        notation?: string;
-        navigateTo?: ViewID$1;
-        notes?: string;
-        color?: Color$1;
-        line?: RelationshipLineType;
-        head?: RelationshipArrowType;
-        tail?: RelationshipArrowType;
-    };
-}
-type RelationPredicateExpression = RelationExpression$1 | RelationWhereExpr | CustomRelationExpr;
-type Expression$1 = ElementPredicateExpression | RelationPredicateExpression;
-
 type ElementNotation = {
     kinds: ElementKind$1[];
     shape: ElementShape$1;
@@ -243,7 +114,7 @@ type ElementNotation = {
     title: string;
 };
 
-type ViewID$1 = Tagged<string, 'ViewID'>;
+type ViewID$1<Id extends string = string> = Tagged<Id, 'ViewID'>;
 type ViewRulePredicate$1 = {
     include: Expression$1[];
     exclude?: never;
@@ -267,12 +138,12 @@ interface ViewRuleAutoLayout$1 {
     rankSep?: number;
 }
 type ViewRule$1 = ViewRulePredicate$1 | ViewRuleStyle$1 | ViewRuleAutoLayout$1;
-interface BasicView<ViewType extends 'element' | 'dynamic'> {
+interface BasicView<ViewType extends 'element' | 'dynamic', ViewIDs extends string, Tags extends string> {
     readonly __?: ViewType;
-    readonly id: ViewID$1;
+    readonly id: ViewID$1<ViewIDs>;
     readonly title: string | null;
     readonly description: string | null;
-    readonly tags: NonEmptyArray<Tag$1> | null;
+    readonly tags: NonEmptyArray<Tag$1<Tags>> | null;
     readonly links: NonEmptyArray<Link> | null;
     /**
      * URI to the source file of this view.
@@ -294,17 +165,17 @@ interface BasicView<ViewType extends 'element' | 'dynamic'> {
     readonly manualLayout?: ViewManualLayout | undefined;
     readonly customColorDefinitions: CustomColorDefinitions;
 }
-interface BasicElementView extends BasicView<'element'> {
+interface BasicElementView<ViewIDs extends string, Tags extends string> extends BasicView<'element', ViewIDs, Tags> {
     readonly viewOf?: Fqn$1;
     readonly rules: ViewRule$1[];
 }
-interface ScopedElementView extends BasicElementView {
+interface ScopedElementView<ViewIDs extends string, Tags extends string> extends BasicElementView<ViewIDs, Tags> {
     readonly viewOf: Fqn$1;
 }
-interface ExtendsElementView extends BasicElementView {
-    readonly extends: ViewID$1;
+interface ExtendsElementView<ViewIDs extends string, Tags extends string> extends BasicElementView<ViewIDs, Tags> {
+    readonly extends: ViewID$1<ViewIDs>;
 }
-type ElementView$1 = ScopedElementView | ExtendsElementView | BasicElementView;
+type ElementView$1<ViewIDs extends string = string, Tags extends string = string> = ScopedElementView<ViewIDs, Tags> | ExtendsElementView<ViewIDs, Tags> | BasicElementView<ViewIDs, Tags>;
 interface DynamicViewStep$1 {
     readonly source: Fqn$1;
     readonly target: Fqn$1;
@@ -329,7 +200,7 @@ type DynamicViewIncludeRule = {
     include: ElementPredicateExpression[];
 };
 type DynamicViewRule$1 = DynamicViewIncludeRule | ViewRuleStyle$1 | ViewRuleAutoLayout$1;
-interface DynamicView$1 extends BasicView<'dynamic'> {
+interface DynamicView$1<ViewIDs extends string = string, Tags extends string = string> extends BasicView<'dynamic', ViewIDs, Tags> {
     readonly __: 'dynamic';
     readonly steps: DynamicViewStepOrParallel[];
     readonly rules: DynamicViewRule$1[];
@@ -337,8 +208,8 @@ interface DynamicView$1 extends BasicView<'dynamic'> {
 type CustomColorDefinitions = {
     [key: string]: ThemeColorValues;
 };
-type LikeC4View$1 = ElementView$1 | DynamicView$1;
-type NodeId = Tagged<string, 'Fqn'>;
+type LikeC4View$1<ViewIDs extends string = string, Tags extends string = string> = ElementView$1<ViewIDs, Tags> | DynamicView$1<ViewIDs, Tags>;
+type NodeId<IDs extends string = string> = Tagged<IDs, 'Fqn'>;
 type EdgeId$1 = Tagged<string, 'EdgeId'>;
 type StepEdgeIdLiteral = `step-${number}` | `step-${number}.${number}`;
 type StepEdgeId = Tagged<StepEdgeIdLiteral, 'EdgeId'>;
@@ -421,15 +292,15 @@ interface ViewAutoLayout {
     rankSep?: number;
     nodeSep?: number;
 }
-interface ComputedElementView extends Omit<ElementView$1, 'rules' | 'docUri'>, ViewWithHash, ViewWithNotation {
-    readonly extends?: ViewID$1;
+interface ComputedElementView<ViewIDs extends string = string, Tags extends string = string> extends Omit<ElementView$1<ViewIDs, Tags>, 'rules' | 'docUri'>, ViewWithHash, ViewWithNotation {
+    readonly extends?: ViewID$1<ViewIDs>;
     readonly autoLayout: ViewAutoLayout;
     readonly nodes: ComputedNode[];
     readonly edges: ComputedEdge[];
     rules?: never;
     docUri?: never;
 }
-interface ComputedDynamicView extends Omit<DynamicView$1, 'rules' | 'steps' | 'docUri'>, ViewWithHash, ViewWithNotation {
+interface ComputedDynamicView<ViewIDs extends string = string, Tags extends string = string> extends Omit<DynamicView$1<ViewIDs, Tags>, 'rules' | 'steps' | 'docUri'>, ViewWithHash, ViewWithNotation {
     readonly autoLayout: ViewAutoLayout;
     readonly nodes: ComputedNode[];
     readonly edges: ComputedEdge[];
@@ -438,7 +309,7 @@ interface ComputedDynamicView extends Omit<DynamicView$1, 'rules' | 'steps' | 'd
     docUri?: never;
 }
 declare function isComputedDynamicView(view: ComputedView): view is ComputedDynamicView;
-type ComputedView = ComputedElementView | ComputedDynamicView;
+type ComputedView<ViewIDs extends string = string, Tags extends string = string> = ComputedElementView<ViewIDs, Tags> | ComputedDynamicView<ViewIDs, Tags>;
 type BBox = {
     x: number;
     y: number;
@@ -457,7 +328,7 @@ interface DiagramEdge extends ComputedEdge {
     labelBBox?: BBox | null;
     dotpos?: string;
 }
-interface DiagramView extends Omit<ComputedView, 'nodes' | 'edges' | 'manualLayout'> {
+interface DiagramView<ViewIDs extends string = string, Tags extends string = string> extends Omit<ComputedView<ViewIDs, Tags>, 'nodes' | 'edges' | 'manualLayout'> {
     readonly nodes: DiagramNode[];
     readonly edges: DiagramEdge[];
     readonly bounds: BBox;
@@ -490,18 +361,147 @@ type ViewManualLayout = {
     }>;
 };
 
+type RelationID$1 = Tagged<string, 'RelationID'>;
+type RelationshipKind$1<Kinds extends string = string> = Tagged<Kinds, 'RelationshipKind'>;
+type RelationshipLineType = 'dashed' | 'solid' | 'dotted';
+type RelationshipArrowType = 'none' | 'normal' | 'onormal' | 'dot' | 'odot' | 'diamond' | 'odiamond' | 'crow' | 'open' | 'vee';
+interface Relation$1 {
+    readonly id: RelationID$1;
+    readonly source: Fqn$1;
+    readonly target: Fqn$1;
+    readonly title: string;
+    readonly description?: string;
+    readonly technology?: string;
+    readonly tags?: NonEmptyArray<Tag$1>;
+    readonly kind?: RelationshipKind$1;
+    readonly color?: Color$1;
+    readonly line?: RelationshipLineType;
+    readonly head?: RelationshipArrowType;
+    readonly tail?: RelationshipArrowType;
+    readonly links?: NonEmptyArray<Link>;
+    readonly navigateTo?: ViewID$1;
+    readonly metadata?: {
+        [key: string]: string;
+    };
+}
+interface RelationshipKindSpecification {
+    readonly technology?: string;
+    readonly notation?: string;
+    readonly color?: Color$1;
+    readonly line?: RelationshipLineType;
+    readonly head?: RelationshipArrowType;
+    readonly tail?: RelationshipArrowType;
+}
+
+interface BaseExpr {
+    where?: never;
+    element?: never;
+    custom?: never;
+    expanded?: never;
+    elementKind?: never;
+    elementTag?: never;
+    isEqual?: never;
+    isDescedants?: never;
+    wildcard?: never;
+    source?: never;
+    target?: never;
+    inout?: never;
+    incoming?: never;
+    outgoing?: never;
+    customRelation?: never;
+}
+interface ElementRefExpr extends Omit<BaseExpr, 'element' | 'isDescedants'> {
+    element: Fqn$1;
+    isDescedants?: boolean;
+}
+interface ExpandedElementExpr extends Omit<BaseExpr, 'expanded'> {
+    expanded: Fqn$1;
+}
+interface CustomElementExpr extends Omit<BaseExpr, 'custom'> {
+    custom: {
+        expr: ElementExpression$1 | ElementWhereExpr;
+        title?: string;
+        description?: string;
+        technology?: string;
+        notation?: string;
+        shape?: ElementShape$1;
+        color?: Color$1;
+        icon?: IconUrl;
+        border?: BorderStyle;
+        opacity?: number;
+        navigateTo?: ViewID$1;
+    };
+}
+interface WildcardExpr extends Omit<BaseExpr, 'wildcard'> {
+    wildcard: true;
+}
+interface ElementKindExpr extends Omit<BaseExpr, 'elementKind' | 'isEqual'> {
+    elementKind: ElementKind$1;
+    isEqual: boolean;
+}
+interface ElementTagExpr extends Omit<BaseExpr, 'elementTag' | 'isEqual'> {
+    elementTag: Tag$1;
+    isEqual: boolean;
+}
+type ElementExpression$1 = ElementRefExpr | WildcardExpr | ElementKindExpr | ElementTagExpr | ExpandedElementExpr;
+interface ElementWhereExpr extends Omit<BaseExpr, 'where'> {
+    where: {
+        expr: ElementExpression$1;
+        condition: WhereOperator<string, string>;
+    };
+}
+type ElementPredicateExpression = ElementExpression$1 | ElementWhereExpr | CustomElementExpr;
+interface RelationExpr extends Omit<BaseExpr, 'source' | 'target'> {
+    source: ElementExpression$1;
+    target: ElementExpression$1;
+    isBidirectional?: boolean;
+}
+interface InOutExpr extends Omit<BaseExpr, 'inout'> {
+    inout: ElementExpression$1;
+}
+interface IncomingExpr extends Omit<BaseExpr, 'incoming'> {
+    incoming: ElementExpression$1;
+}
+interface OutgoingExpr extends Omit<BaseExpr, 'outgoing'> {
+    outgoing: ElementExpression$1;
+}
+type RelationExpression$1 = RelationExpr | InOutExpr | IncomingExpr | OutgoingExpr;
+interface RelationWhereExpr extends Omit<BaseExpr, 'where'> {
+    where: {
+        expr: RelationExpression$1;
+        condition: WhereOperator<string, string>;
+    };
+}
+interface CustomRelationExpr extends Omit<BaseExpr, 'customRelation'> {
+    customRelation: {
+        relation: RelationExpression$1 | RelationWhereExpr;
+        title?: string;
+        description?: string;
+        technology?: string;
+        notation?: string;
+        navigateTo?: ViewID$1;
+        notes?: string;
+        color?: Color$1;
+        line?: RelationshipLineType;
+        head?: RelationshipArrowType;
+        tail?: RelationshipArrowType;
+    };
+}
+type RelationPredicateExpression = RelationExpression$1 | RelationWhereExpr | CustomRelationExpr;
+type Expression$1 = ElementPredicateExpression | RelationPredicateExpression;
+
 /**
  * Parsed elements, relations, and views.
  */
-interface ParsedLikeC4Model {
+interface ParsedLikeC4Model<ElementKinds extends string = string, RelationKinds extends string = string, Tags extends string = string, Fqns extends string = string, Views extends string = string> {
     specification: {
-        tags: Tag$1[];
-        elements: Record<UnwrapTagged<ElementKind$1>, ElementKindSpecification>;
-        relationships: Record<UnwrapTagged<ElementKind$1>, RelationshipKindSpecification>;
+        tags: Tag$1<Tags>[];
+        elements: Record<ElementKinds, ElementKindSpecification>;
+        relationships: Record<RelationKinds, RelationshipKindSpecification>;
     };
-    elements: Record<Fqn$1, Element$1>;
+    elements: Record<Fqns, TypedElement<Fqns, ElementKinds, Tags>>;
     relations: Record<RelationID$1, Relation$1>;
-    views: Record<ViewID$1, LikeC4View$1>;
+    views: Record<Views, LikeC4View$1<Views, Tags>>;
 }
 /**
  * Same as `ParsedLikeC4Model` but with computed views.
@@ -574,11 +574,274 @@ declare namespace ViewChange {
     }
     interface ChangeAutoLayout {
         op: 'change-autolayout';
-        layout: ViewRuleAutoLayout$1;
+        layout: {
+            direction: AutoLayoutDirection;
+            nodeSep?: number | null;
+            rankSep?: number | null;
+        };
     }
 }
 type ViewChange = ViewChange.ChangeElementStyle | ViewChange.SaveManualLayout | ViewChange.ChangeAutoLayout;
 
+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$1;
+    color?: Color$1;
+    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$1;
+    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$1): Builder<T>;
+    addRelation(relation: Omit<Relation$1, 'id'>): Builder<T>;
+    /**
+     * Create a fully qualified name from an id (for nested models)
+     */
+    fqn(id: string): Fqn$1;
+    addSourcelessRelation(relation: Omit<Relation$1, '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$1): 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$1[]): ViewBuilder<T>;
+    exclude(...exprs: Expression$1[]): ViewBuilder<T>;
+    style(rule: ViewRuleStyle$1): 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$1, '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$1['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']>;
+    };
+}
+
 declare const ElementColors: {
     readonly primary: {
         fill: "#3b82f6";
@@ -856,11 +1119,11 @@ type ElementOrFqn = Fqn | {
 declare class LikeC4ViewModel {
     readonly view: ComputedView;
     readonly model: LikeC4Model<LikeC4ViewModel>;
-    private _rootElements;
-    private _elements;
-    private _connections;
+    private readonly _rootElements;
+    private readonly _elements;
+    private readonly _connections;
     constructor(view: ComputedView, model: LikeC4Model<LikeC4ViewModel>);
-    get id(): ViewID$1;
+    get id(): ViewID$1<string>;
     get title(): string;
     get viewOf(): LikeC4Model.ElementModel<LikeC4ViewModel>;
     get tags(): Tag$1[];
@@ -895,9 +1158,9 @@ declare namespace LikeC4ViewModel {
      */
     class Element {
         readonly node: ComputedNode;
-        private viewmodel;
+        private readonly viewmodel;
         constructor(node: ComputedNode, viewmodel: LikeC4ViewModel);
-        get id(): NodeId;
+        get id(): NodeId<string>;
         get title(): string;
         get kind(): ElementKind$1;
         get isRoot(): boolean;
@@ -926,7 +1189,7 @@ declare namespace LikeC4ViewModel {
      */
     class Connection {
         readonly edge: ComputedEdge;
-        private viewmodel;
+        private readonly viewmodel;
         constructor(edge: ComputedEdge, viewmodel: LikeC4ViewModel);
         get id(): EdgeId$1;
         get source(): LikeC4ViewModel.Element;
@@ -953,10 +1216,7 @@ declare class LikeC4Model<M extends LikeC4Model.ViewModel = LikeC4Model.ViewMode
     private _internal;
     private _cacheAscendingSiblings;
     private _views;
-    static create(source: LikeC4Model.SourceModel): PickBySource<typeof source>;
-    static computed(source: ComputedLikeC4Model): LikeC4Model<LikeC4ViewModel>;
-    static layouted(source: LayoutedLikeC4Model): LikeC4Model<LikeC4DiagramModel>;
-    protected constructor(type: LikeC4Model.ModelType<M>, sourcemodel: LikeC4Model.SourceModel<M>, elements: Element$1[], relations: Relation$1[]);
+    constructor(type: LikeC4Model.ModelType<M>, sourcemodel: LikeC4Model.SourceModel<M>, elements: Element$1[], relations: Relation$1[], views: LikeC4Model.SourceModel<M>['views'], ViewModelClass: Class<M>);
     /**
      * Returns the root elements of the model.
      */
@@ -1047,10 +1307,14 @@ declare class LikeC4Model<M extends LikeC4Model.ViewModel = LikeC4Model.ViewMode
     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;
     }
@@ -1066,13 +1330,13 @@ declare namespace LikeC4Model {
     }
     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> {
+    class Relationship<M extends ViewModel = ViewModel> {
         readonly relationship: Relation$1;
-        private model;
+        private readonly model;
         constructor(relationship: Relation$1, model: LikeC4Model<M>);
         get id(): RelationID$1;
         get title(): string;
-        get kind(): RelationshipKind$1;
+        get kind(): RelationshipKind$1<string>;
         get tags(): Tag$1[];
         get source(): ElementModel<M>;
         get target(): ElementModel<M>;
@@ -1080,11 +1344,11 @@ declare namespace LikeC4Model {
         metadata(key: string, defaultValue: string): string;
         hasMetadata(key: string): boolean;
     }
-    class ElementModel<M extends ViewModel> {
+    class ElementModel<M extends ViewModel = ViewModel> {
         readonly element: Element$1;
-        private model;
+        private readonly model;
         constructor(element: Element$1, model: LikeC4Model<M>);
-        get id(): Fqn$1;
+        get id(): Fqn$1<string>;
         get title(): string;
         get kind(): ElementKind$1;
         get isRoot(): boolean;
@@ -1100,6 +1364,10 @@ declare namespace LikeC4Model {
         siblings(): readonly ElementModel<M>[];
         descendants(): readonly ElementModel<M>[];
         children(): readonly ElementModel<M>[];
+        /**
+         * All views 'view of' current element
+         */
+        viewsOf(): M[];
         /**
          * Views that contain this element
          */
@@ -1109,6 +1377,11 @@ declare namespace LikeC4Model {
         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>[];
     }
 }
 
@@ -1118,12 +1391,12 @@ declare namespace LikeC4Model {
 declare class LikeC4DiagramModel {
     readonly view: DiagramView;
     readonly model: LikeC4Model.Layouted;
-    private _rootElements;
-    private _elements;
-    private _connections;
+    private readonly _rootElements;
+    private readonly _elements;
+    private readonly _connections;
     constructor(view: DiagramView, model: LikeC4Model.Layouted);
     get isDynamic(): boolean;
-    get id(): ViewID$1;
+    get id(): ViewID$1<string>;
     get title(): string;
     get viewOf(): LikeC4Model.ElementModel<LikeC4DiagramModel>;
     get tags(): Tag$1[];
@@ -1158,9 +1431,9 @@ declare namespace LikeC4DiagramModel {
      */
     class Element {
         readonly node: DiagramNode;
-        private view;
+        private readonly view;
         constructor(node: DiagramNode, view: LikeC4DiagramModel);
-        get id(): NodeId;
+        get id(): NodeId<string>;
         get title(): string;
         get kind(): ElementKind$1;
         get isRoot(): boolean;
@@ -1191,7 +1464,7 @@ declare namespace LikeC4DiagramModel {
      */
     class Connection {
         readonly edge: DiagramEdge;
-        private view;
+        private readonly view;
         constructor(edge: DiagramEdge, view: LikeC4DiagramModel);
         get id(): EdgeId$1;
         get source(): LikeC4DiagramModel.Element;
@@ -1204,7 +1477,7 @@ declare namespace LikeC4DiagramModel {
         relationships(): ReadonlyArray<LikeC4Model.Relationship<LikeC4DiagramModel>>;
     }
 }
-declare function nameFromFqn(fqn: Fqn$1): string;
+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;
@@ -1214,13 +1487,13 @@ declare function isSameHierarchy<E extends {
 declare function isDescendantOf<E extends {
     id: Fqn$1;
 }>(ancestors: E[]): (e: E) => boolean;
-declare function commonAncestor(first: Fqn$1, second: Fqn$1): Fqn$1;
-declare function parentFqn(fqn: Fqn$1): Fqn$1 | null;
+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;
 /**
  * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
  * (from closest to root)
  */
-declare function ancestorsFqn(fqn: Fqn$1): Fqn$1[];
+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
@@ -15417,6 +15690,7 @@ interface ModelViews extends AstNode {
     readonly $container: LikeC4Grammar;
     readonly $type: 'ModelViews';
     name: 'views';
+    styles: Array<ViewRuleStyle>;
     views: Array<LikeC4View>;
 }
 declare const ModelViews = "ModelViews";
@@ -15609,7 +15883,7 @@ interface ViewRuleAutoLayout extends AstNode {
 }
 declare const ViewRuleAutoLayout = "ViewRuleAutoLayout";
 interface ViewRuleStyle extends AstNode {
-    readonly $container: DynamicViewBody | ElementViewBody;
+    readonly $container: DynamicViewBody | ElementViewBody | ModelViews;
     readonly $type: 'ViewRuleStyle';
     props: Array<NotationProperty | StyleProperty>;
     target: ElementExpressionsIterator;
@@ -16024,11 +16298,15 @@ declare class LikeC4ModelParser {
     private parseRelationPredicateWith;
     private parseRelationExpr;
     private parseViewRule;
+    private parseViewRuleStyle;
+    private parseRuleStyle;
     private parseViewManualLaout;
     private parseDynamicParallelSteps;
     private parseDynamicStep;
     private parseElementView;
     private parseDynamicElementView;
+    private parseDynamicViewRule;
+    private parseDynamicViewIncludePredicate;
     protected resolveFqn(node: Element | ExtendElement): Fqn$1;
     private getAstNodePath;
     private getMetadata;
@@ -16960,4 +17238,4 @@ declare class LikeC4 {
     dispose(): void;
 }
 
-export { type AutoLayoutDirection, type BBox, BorderStyles, type Color$1 as Color, type ComputedDynamicView, type ComputedEdge, type ComputedElementView, type ComputedLikeC4Model, type ComputedNode, type ComputedView, type DiagramEdge, type DiagramNode, type DiagramView, type DynamicView$1 as DynamicView, type EdgeId$1 as EdgeId, type Element$1 as Element, ElementColors, type ElementKind$1 as ElementKind, ElementShapes, type ElementView$1 as ElementView, type Fqn$1 as Fqn, type HexColorLiteral, type LayoutedLikeC4Model, LikeC4, LikeC4DiagramModel, LikeC4Model, type LikeC4View$1 as LikeC4View, LikeC4ViewModel, type NodeId, type ParsedLikeC4Model, type Point, type Relation$1 as Relation, type RelationExpr, type RelationID$1 as RelationID, RelationshipColors, StepEdgeId, type Tag$1 as Tag, type ThemeColor$1 as ThemeColor, type ViewID$1 as ViewID, type XYPoint, ancestorsFqn, commonAncestor, compareByFqnHierarchically, compareFqnHierarchically, compareRelations, defaultTheme, extractStep, hasAtLeast, invariant, isAncestor, isComputedDynamicView, isDescendantOf, isSameHierarchy, isStepEdgeId, nameFromFqn, nonNullable, nonexhaustive, parentFqn };
+export { type AutoLayoutDirection, type BBox, BorderStyles, Builder, type BuilderSpecification, type Color$1 as Color, type ComputedDynamicView, type ComputedEdge, type ComputedElementView, type ComputedLikeC4Model, type ComputedNode, type ComputedView, type DiagramEdge, type DiagramNode, type DiagramView, type DynamicView$1 as DynamicView, type EdgeId$1 as EdgeId, type Element$1 as Element, ElementColors, type ElementKind$1 as ElementKind, ElementShapes, type ElementView$1 as ElementView, type Fqn$1 as Fqn, type HexColorLiteral, type LayoutedLikeC4Model, LikeC4, Builder as LikeC4Builder, LikeC4DiagramModel, LikeC4Model, type LikeC4View$1 as LikeC4View, LikeC4ViewModel, type NodeId, type ParsedLikeC4Model, type Point, type Relation$1 as Relation, type RelationExpr, type RelationID$1 as RelationID, RelationshipColors, StepEdgeId, type Tag$1 as Tag, type ThemeColor$1 as ThemeColor, type ViewID$1 as ViewID, type XYPoint, ancestorsFqn, commonAncestor, compareByFqnHierarchically, compareFqnHierarchically, compareRelations, defaultTheme, extractStep, hasAtLeast, invariant, isAncestor, isComputedDynamicView, isDescendantOf, isSameHierarchy, isStepEdgeId, nameFromFqn, nonNullable, nonexhaustive, parentFqn };