@likec4/core 1.30.0 → 1.32.0

package/dist/builder/index.d.mts

@@ -1,8 +1,9 @@
-import { LastArrayElement, Split, Simplify, Writable, IfNever, TupleToUnion, Tagged, IsStringLiteral as IsStringLiteral$1, IsLiteral } from 'type-fest';
-import { L as LikeC4Model } from '../shared/core.CiFKryGW.mjs';
-import { D as DeploymentElement, i as DeploymentRelation, q as Element, ah as ModelRelation, a9 as Participant, M as ModelLayer, bs as ViewRuleStyle, aT as AutoLayoutDirection, y as ExpressionV2, L as LikeC4View, b0 as DeploymentView, bd as ElementView, t as ElementShape, ap as Color, p as BorderStyle, av as ShapeSize, aw as SpacingSize, ax as TextSize, aj as RelationshipArrowType, am as RelationshipLineType, r as ElementKindSpecification, al as RelationshipKindSpecification, g as DeploymentNodeKindSpecification, V as ParsedLikeC4ModelData } from '../shared/core.DJvmfnEi.mjs';
-import { F as Fqn, N as NonEmptyArray, K as KeysOf } from '../shared/core.SjLhMA7a.mjs';
-import { IsStringLiteral } from 'type-fest/source/is-literal';
+import { LastArrayElement, Split, Simplify, IsLiteral, Writable, IfNever, TupleToUnion, Tagged } from 'type-fest';
+import { L as LikeC4Model } from '../shared/core.CCWXGc6G.mjs';
+import { D as DeploymentFqn, F as Fqn, d as NonEmptyArray, K as KeysOf } from '../shared/core.BuO4ncfY.mjs';
+import { q as DeploymentElement, u as DeploymentRelationship, O as Element, Z as ModelRelation, a8 as Participant, M as ModelFqnExpr, a as ModelRelationExpr, aZ as AnyViewRuleStyle, b2 as AutoLayoutDirection, E as Expression, aF as ParsedView, bt as ParsedDeploymentView, bJ as ParsedElementView, k as ParsedLikeC4ModelData, ar as ElementShape, ay as ThemeColor, ap as BorderStyle, an as ShapeSize, al as SpacingSize, am as TextSize, aw as RelationshipArrowType, av as RelationshipLineType, _ as ElementSpecification$1, a1 as RelationshipSpecification, $ as TagSpecification } from '../shared/core.Dpq3P3YJ.mjs';
+import { b as Aux, S as SpecAux, A as Any } from '../shared/core.BaYE_r29.mjs';
+import '../shared/core.CywrQs86.mjs';
 
 type ToNested$1<T, Id extends string> = T extends TypesNested<infer P, any, any, any, any, any, any, any, infer F> ? TypesNested<`${P}.${Id}`, T['ElementKind'], T['Fqn'], T['ViewId'], T['RelationshipKind'], T['Tag'], T['MetadataKey'], T['DeploymentKind'], `${P}.${Id}` | F> : T extends AnyTypes ? TypesNested<Id, T['ElementKind'], T['Fqn'], T['ViewId'], T['RelationshipKind'], T['Tag'], T['MetadataKey'], T['DeploymentKind'], Id | T['DeploymentFqn']> : never;
 type FromNested$1<T extends AnyTypes, N> = N extends TypesNested<any, any, any, any, any, any, any, any, infer F> ? T extends TypesNested<infer P, any, any, any, any, any, any, any, any> ? TypesNested<P, T['ElementKind'], T['Fqn'], T['ViewId'], T['RelationshipKind'], T['Tag'], T['MetadataKey'], T['DeploymentKind'], F> : T extends AnyTypes ? Types<T['ElementKind'], T['Fqn'], T['ViewId'], T['RelationshipKind'], T['Tag'], T['MetadataKey'], T['DeploymentKind'], F> : never : never;
@@ -26,11 +27,11 @@ interface AddDeploymentNode<Id extends string> {
 
 interface DeploymentModelBuilder<T extends AnyTypes> extends Builder<T> {
     __addDeployment(node: DeploymentElement): Builder<T>;
-    __addDeploymentRelation(rel: Omit<DeploymentRelation, 'id'>): Builder<T>;
+    __addDeploymentRelation(rel: Omit<DeploymentRelationship, 'id'>): Builder<T>;
     /**
      * Create a fully qualified name from an id (for nested models)
      */
-    __fqn(id: string): Fqn;
+    __deploymentFqn(id: string): DeploymentFqn;
 }
 declare function deployment<A extends AnyTypes>(): (input: Builder<A>) => Builder<A>;
 declare function deployment<A extends AnyTypes, B extends AnyTypes>(op1: (input: DeploymentModelBuilder<A>) => DeploymentModelBuilder<B>): (input: Builder<A>) => Builder<B>;
@@ -50,14 +51,80 @@ declare function deployment<A extends AnyTypes, B extends AnyTypes, C extends An
 declare function deployment<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: DeploymentModelBuilder<A>) => DeploymentModelBuilder<B>, op2: (input: DeploymentModelBuilder<B>) => DeploymentModelBuilder<C>, op3: (input: DeploymentModelBuilder<C>) => DeploymentModelBuilder<D>, op4: (input: DeploymentModelBuilder<D>) => DeploymentModelBuilder<E>, op5: (input: DeploymentModelBuilder<E>) => DeploymentModelBuilder<F>, op6: (input: DeploymentModelBuilder<F>) => DeploymentModelBuilder<G>, op7: (input: DeploymentModelBuilder<G>) => DeploymentModelBuilder<H>, op8: (input: DeploymentModelBuilder<H>) => DeploymentModelBuilder<I>, op9: (input: DeploymentModelBuilder<I>) => DeploymentModelBuilder<J>, op10: (input: DeploymentModelBuilder<J>) => DeploymentModelBuilder<K>, op11: (input: DeploymentModelBuilder<K>) => DeploymentModelBuilder<L>, op12: (input: DeploymentModelBuilder<L>) => DeploymentModelBuilder<M>, op13: (input: DeploymentModelBuilder<M>) => DeploymentModelBuilder<N>, op14: (input: DeploymentModelBuilder<N>) => DeploymentModelBuilder<O>, op15: (input: DeploymentModelBuilder<O>) => DeploymentModelBuilder<P>): (input: Builder<A>) => Builder<P>;
 type NameFromFqn<FQN extends string> = LastArrayElement<Split<FQN, '.'>>;
 type AddDeployedInstance<Props = unknown> = {
+    /**
+     * @example
+     * ```ts
+     * builder.deployment(({ node, instanceOf }, _) =>
+     *    _(
+     *      node('node1').with(
+     *        // Only FQN of the element
+     *        instanceOf('cloud.backend'),
+     *        // ID, FQN of the element and additional props
+     *        instanceOf('b2', 'cloud.backend', {
+     *          tags: ['tag2'],
+     *        }),
+     *      ),
+     *    )
+     *  )
+     * ```
+     */
     <const T extends AnyTypes, Id extends string & T['Fqn']>(target: Id): (builder: DeploymentModelBuilder<T>) => DeploymentModelBuilder<Types.AddDeploymentFqn<T, NameFromFqn<Id>>>;
+    /**
+     * @example
+     * ```ts
+     * builder.deployment(({ node, instanceOf }, _) =>
+     *    _(
+     *      node('node1').with(
+     *        // Only FQN of the element
+     *        instanceOf('cloud.backend'),
+     *        // ID, FQN of the element and additional props
+     *        instanceOf('b2', 'cloud.backend', {
+     *          tags: ['tag2'],
+     *        }),
+     *      ),
+     *    )
+     *  )
+     * ```
+     */
     <const Id extends string, T extends AnyTypes, Target extends string & T['Fqn']>(id: ValidId<Id>, target: Target, titleOrProps?: string | Props | undefined): (builder: DeploymentModelBuilder<T>) => DeploymentModelBuilder<Types.AddDeploymentFqn<T, Id>>;
 };
-type AddDeploymentNodeHelper<T = unknown> = <const Id extends string>(id: ValidId<Id>, titleOrProps?: string | T) => AddDeploymentNode<Id>;
+type AddDeploymentNodeHelper<T = unknown> = 
+/**
+ * Adds deployment model
+ *
+ * @example
+ *  builder.deployment(({ node }, _) =>
+ *    _(
+ *      node('node1').with(
+ *        node('child1')
+ *      ),
+ *    )
+ *  )
+ *
+ * @example
+ *  builder.deployment((_,d) =>
+ *    d(
+ *      _.node('node1').with(
+ *        _.node('child1')
+ *      ),
+ *    )
+ *  )
+ */
+<const Id extends string>(id: ValidId<Id>, titleOrProps?: string | T) => AddDeploymentNode<Id>;
 type AddDeploymentNodeHelpers<T extends AnyTypes> = T extends Types<any, any, any, any, any, any, infer Kinds extends string, any> ? {
     [Kind in Kinds]: AddDeploymentNodeHelper<T['NewDeploymentNodeProps']>;
 } : Invalid<'No Deployment Kinds'>;
-type AddDeploymentRelation<Props = unknown> = <T extends AnyTypes, Source extends string & T['DeploymentFqn'], Target extends string & T['DeploymentFqn']>(source: Source, target: Target, titleOrProps?: string | Props) => (builder: DeploymentModelBuilder<T>) => DeploymentModelBuilder<T>;
+type AddDeploymentRelation<Props = unknown> = 
+/**
+ * @example
+ * ```ts
+ * rel('source.deployment', 'target.deployment', {
+ *   title: 'title',
+ *   tags: ['tag1'],
+ * })
+ * ```
+ */
+<T extends AnyTypes, Source extends string & T['DeploymentFqn'], Target extends string & T['DeploymentFqn']>(source: Source, target: Target, titleOrProps?: string | Props) => (builder: DeploymentModelBuilder<T>) => DeploymentModelBuilder<T>;
 type DeloymentModelHelpers<T extends AnyTypes> = AddDeploymentNodeHelpers<T> & {
     instanceOf: AddDeployedInstance<T['NewDeploymentNodeProps']>;
     rel: AddDeploymentRelation<T['NewRelationshipProps']>;
@@ -73,8 +140,28 @@ type FromNested<T extends AnyTypes, N> = N extends TypesNested<any, any, infer F
  * Chainable builder to create element
  */
 interface AddElement<Id extends string> {
+    /**
+     * @example
+     * ```ts
+     * el('a')
+     * ```
+     */
     <T extends AnyTypes>(builder: ModelBuilder<T>): ModelBuilder<Types.AddFqn<T, Id>>;
+    /**
+     * @example
+     * ```ts
+     * el('a').with()
+     * ```
+     */
     with<T extends AnyTypes>(): (builder: ModelBuilder<T>) => ModelBuilder<Types.AddFqn<T, Id>>;
+    /**
+     * @example
+     * ```ts
+     * el('a').with(
+     *   relTo('b')
+     * )
+     * ```
+     */
     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>>;
@@ -114,9 +201,58 @@ declare function model<A extends AnyTypes, B extends AnyTypes, C extends AnyType
 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>;
 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, Q 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>, op16: (input: ModelBuilder<P>) => ModelBuilder<Q>): (input: Builder<A>) => Builder<Q>;
 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, Q extends AnyTypes, R 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>, op16: (input: ModelBuilder<P>) => ModelBuilder<Q>, op17: (input: ModelBuilder<Q>) => ModelBuilder<R>): (input: Builder<A>) => Builder<R>;
-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 AddElementHelper<T = unknown> = <const Id extends string>(id: ValidId<Id>, titleOrProps?: string | T) => AddElement<Id>;
+type RelationshipHelper<Props = unknown> = 
+/**
+ * @example
+ * ```ts
+ * rel('a', 'b')
+ * ```
+ *
+ * @example
+ * ```ts
+ * rel('a', 'b', {
+ *   title: 'title',
+ *   tags: ['tag1'],
+ * })
+ * ```
+ */
+<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> = 
+/**
+ * @example
+ * ```ts
+ * el('a').with(
+ *   relTo('b')
+ * )
+ * ```
+ *
+ * @example
+ * ```ts
+ * el('a').with(
+ *   relTo('b', {
+ *     title: 'title',
+ *     tags: ['tag1'],
+ *   })
+ * )
+ * ```
+ */
+<T extends AnyTypesNested, To extends string & T['Fqn']>(to: To, titleOrProps?: string | Props) => (builder: ModelBuilder<T>) => ModelBuilder<T>;
+type AddElementHelper<T = unknown> = 
+/**
+ * @example
+ * ```ts
+ * el('some.id')
+ * ```
+ *
+ * @example
+ * ```ts
+ * el('some.id', {
+ *   title: 'title',
+ *   tags: ['tag1'],
+ * })
+ * ```
+ */
+<const Id extends string>(id: ValidId<Id>, titleOrProps?: string | T) => AddElement<Id>;
 type AddElementHelpers<T extends AnyTypes> = T extends Types<infer Kinds extends string, any, any, any, any, any, any, any> ? {
     [Kind in Kinds]: AddElementHelper<T['NewElementProps']>;
 } : Invalid<'No Element Kinds'>;
@@ -137,7 +273,7 @@ interface LikeC4ViewBuilder<Types extends AnyTypes, Fqn extends string, TypedExp
     $expr(expr: Expr | TypedExpr): TypedExpr;
     include(...exprs: Expr[]): this;
     exclude(...exprs: Expr[]): this;
-    style(rule: ViewRuleStyle): this;
+    style(rule: AnyViewRuleStyle<any>): this;
     autoLayout(layout: AutoLayoutDirection): this;
 }
 declare namespace ViewPredicate {
@@ -166,14 +302,29 @@ declare namespace ViewPredicate {
     };
     type Custom<Types extends AnyTypes> = {
         where?: ViewPredicate.WhereOperator<Types>;
-        with?: Simplify<Omit<ModelLayer.FqnExpr.Custom['custom'] & ModelLayer.RelationExpr.Custom['customRelation'], 'expr' | 'relation' | 'navigateTo'> & {
+        with?: Simplify<Omit<ModelFqnExpr.Custom['custom'] & ModelRelationExpr.Custom['customRelation'], 'expr' | 'relation' | 'navigateTo'> & {
             navigateTo?: Types['ViewId'];
         }>;
     };
 }
 declare function $include<B extends LikeC4ViewBuilder<AnyTypes, any, any>>(...args: [B['Expr']] | [B['TypedExpr']] | [B['Expr'], ViewPredicate.Custom<B['Types']>]): (b: B) => B;
 declare function $exclude<B extends LikeC4ViewBuilder<AnyTypes, any, any>>(...args: [B['Expr']] | [B['TypedExpr']] | [B['Expr'], ViewPredicate.Custom<B['Types']>] | [B['TypedExpr'], ViewPredicate.Custom<B['Types']>]): (b: B) => B;
-declare function $style<B extends LikeC4ViewBuilder<AnyTypes, any, any>>(element: B['ElementExpr'] | B['TypedExpr'] | NonEmptyArray<B['ElementExpr']>, { notation, ...style }: ViewRuleStyle['style'] & {
+/**
+ * @example
+ *  builder.views(({ view, $style }, _) =>
+ *    _(
+ *      view('view1').with(
+ *        $style('*', {
+ *          color: 'red',
+ *        }),
+ *        $style(['bob', 'alice'], {
+ *          color: 'blue',
+ *        }),
+ *      ),
+ *    )
+ *  )
+ */
+declare function $style<B extends LikeC4ViewBuilder<AnyTypes, any, any>>(element: B['ElementExpr'] | B['TypedExpr'] | NonEmptyArray<B['ElementExpr']>, { notation, ...style }: AnyViewRuleStyle<any>['style'] & {
     notation?: string;
 }): (b: B) => B;
 declare function $autoLayout<B extends LikeC4ViewBuilder<AnyTypes, any, any>>(layout: AutoLayoutDirection): (b: B) => B;
@@ -199,9 +350,9 @@ interface AddDeploymentViewHelper {
     };
     <const Id extends string, T extends AnyTypes>(id: Id, propsOrTitle: T['NewViewProps'] | string, bulder: (b: DeploymentViewBuilder<T>) => DeploymentViewBuilder<T>): (builder: ViewsBuilder<T>) => ViewsBuilder<Types.AddView<T, Id>>;
 }
-declare function $deploymentExpr<T extends AnyTypes>(expr: ViewPredicate.DeploymentExpression<T> | ExpressionV2): Types.ToExpression<T>;
+declare function $deploymentExpr<T extends AnyTypes>(expr: ViewPredicate.DeploymentExpression<T> | Expression): Types.ToExpression<T>;
 
-interface ElementViewBuilder<T extends AnyTypes> extends LikeC4ViewBuilder<T, T['Fqn'], Types.ToExpression<T>> {
+interface ElementViewBuilder<T extends AnyTypes> extends LikeC4ViewBuilder<T, T['Fqn'], Expression<Types.ToAux<T>>> {
 }
 type ElementViewRulesBuilder<T extends AnyTypes> = (b: ElementViewBuilder<T>) => ElementViewBuilder<T>;
 interface AddViewRules<Id extends string> {
@@ -221,7 +372,7 @@ interface AddViewHelper {
         (builder: ViewsBuilder<T>): ViewsBuilder<Types.AddView<T, Id>>;
     };
 }
-type ValidFqn<T extends AnyTypes> = IsStringLiteral<T['Fqn']> extends true ? T['Fqn'] : Invalid<'Fqn must be from known'>;
+type ValidFqn<T extends AnyTypes> = IsLiteral<T['Fqn']> extends true ? T['Fqn'] : Invalid<'Fqn must be a literal'>;
 interface AddViewOfHelper {
     <const Id extends string, T extends AnyTypes>(id: Id, of: ValidFqn<T>): (builder: ViewsBuilder<T>) => ViewsBuilder<Types.AddView<T, Id>>;
     <const Id extends string, T extends AnyTypes>(id: Id, of: ValidFqn<T>, propsOrTitle: T['NewViewProps'] | string | ElementViewRulesBuilder<T>): (builder: ViewsBuilder<T>) => ViewsBuilder<Types.AddView<T, Id>>;
@@ -238,10 +389,10 @@ interface TypedAddViewOfHelper<A extends AnyTypes> {
         (builder: ViewsBuilder<T>): ViewsBuilder<Types.AddView<T, Id>>;
     };
 }
-declare function $expr<Types extends AnyTypes>(expr: ViewPredicate.Expression<Types> | ExpressionV2): ExpressionV2;
+declare function $expr<T extends AnyTypes>(expr: ViewPredicate.Expression<T> | Expression): Expression<Types.ToAux<T>>;
 
 interface ViewsBuilder<T extends AnyTypes> extends Builder<T> {
-    __addView(view: LikeC4View): Builder<T>;
+    __addView(view: ParsedView): Builder<T>;
 }
 declare function views<A extends AnyTypes>(): (input: Builder<A>) => Builder<A>;
 declare function views<A extends AnyTypes, B extends AnyTypes>(op1: (input: ViewsBuilder<A>) => ViewsBuilder<B>): (input: Builder<A>) => Builder<B>;
@@ -274,8 +425,8 @@ type ViewsBuilderFunction<A extends AnyTypes, B extends AnyTypes> = (helpers: Si
     viewOf: TypedAddViewOfHelper<A>;
     _: ViewsHelpers['views'];
 }>, add: ViewsHelpers['views']) => ((builder: ViewsBuilder<A>) => ViewsBuilder<B>) | ((builder: Builder<A>) => Builder<B>);
-declare function mkViewBuilder(view: Writable<DeploymentView>): DeploymentViewBuilder<AnyTypes>;
-declare function mkViewBuilder(view: Writable<ElementView>): ElementViewBuilder<AnyTypes>;
+declare function mkViewBuilder(view: Writable<ParsedDeploymentView<any>>): DeploymentViewBuilder<AnyTypes>;
+declare function mkViewBuilder(view: Writable<ParsedElementView<any>>): ElementViewBuilder<AnyTypes>;
 
 interface BuilderMethods<T extends AnyTypes> {
     with<A extends AnyTypes>(): Builder<A>;
@@ -341,10 +492,11 @@ interface Builder<T extends AnyTypes> extends BuilderMethods<T> {
      *    )
      *  )
      *
+     * @example
      *  builder.deployment((_,d) =>
      *    d(
      *      _.node('node1'),
-     *       _.node('node1.child1').with(
+     *      _.node('node1.child1').with(
      *        _.instanceOf('model.element')
      *      )
      *    )
@@ -355,11 +507,34 @@ interface Builder<T extends AnyTypes> extends BuilderMethods<T> {
      * Adds views
      *
      * @example
-     *  builder.views(({ view, $include }, _) =>
+     *  builder.views(({ view, viewOf, deploymentView, $include, $style, $rules }, _) =>
      *    _(
-     *      view('index').with(
+     *      view('view1').with(
+     *        $include('a -> b'),
+     *      ),
+     *      view('view2', {
+     *        title: 'View 2',
+     *      }).with(
+     *        $include('*')
+     *      ),
+     *      view(
+     *        'view3',
+     *        {
+     *          title: 'View 3',
+     *        },
+     *        $rules(
+     *          $include('*'),
+     *          $style(['*', 'alice'], {
+     *            color: 'red',
+     *          }),
+     *        ),
+     *      ),
+     *      viewOf('viewOfA', 'a').with(
+     *        $include('*')
+     *      ),
+     *      deploymentView('deploymentView1').with(
      *        $include('a -> b')
-     *      )
+     *      ),
      *    )
      *  )
      */
@@ -369,11 +544,11 @@ interface Builder<T extends AnyTypes> extends BuilderMethods<T> {
      * Views are not computed or layouted
      * {@link toLikeC4Model} should be used to get model with computed views
      */
-    build(): Types.ToParsedLikeC4Model<T>;
+    build(): ParsedLikeC4ModelData<Types.ToAux<T>>;
     /**
-     * Returns LikeC4Model with computed views
+     * Returns Computed LikeC4Model
      */
-    toLikeC4Model(): Types.ToLikeC4Model<T>;
+    toLikeC4Model(): LikeC4Model.Computed<Types.ToAux<T>>;
 }
 declare namespace Builder {
     type Any = Builder<AnyTypes>;
@@ -386,18 +561,23 @@ declare namespace Builder {
     function specification<const Spec extends BuilderSpecification>(spec: Spec): Builder<Types.FromSpecification<Spec>>;
 }
 
+type ElementSpecification = Omit<ElementSpecification$1, 'tags'> & {
+    tags?: string[];
+};
 type BuilderSpecification = {
     elements: {
-        [kind: string]: Partial<ElementKindSpecification>;
+        [kind: string]: Partial<ElementSpecification>;
     };
     relationships?: {
-        [kind: string]: Partial<RelationshipKindSpecification>;
+        [kind: string]: Partial<RelationshipSpecification>;
     };
     deployments?: {
-        [kind: string]: Partial<DeploymentNodeKindSpecification>;
+        [kind: string]: Partial<ElementSpecification>;
+    };
+    tags?: {
+        [kind: string]: Partial<TagSpecification>;
     };
-    tags?: [string, ...string[]];
-    metadataKeys?: [string, ...string[]];
+    metadataKeys?: string[];
 };
 type Metadata<MetadataKey extends string> = IfNever<MetadataKey, never, Record<MetadataKey, string>>;
 type NewElementProps<Tag, Metadata> = {
@@ -408,7 +588,7 @@ type NewElementProps<Tag, Metadata> = {
     metadata?: Metadata;
     icon?: string;
     shape?: ElementShape;
-    color?: Color;
+    color?: ThemeColor;
     links?: Array<string | {
         title?: string;
         url: string;
@@ -429,7 +609,7 @@ type NewDeploymentNodeProps<Tag, Metadata> = {
     metadata?: Metadata;
     icon?: string;
     shape?: ElementShape;
-    color?: Color;
+    color?: ThemeColor;
     links?: NonEmptyArray<string | {
         title?: string;
         url: string;
@@ -461,7 +641,7 @@ type NewRelationProps<Kind, Tag, Metadata> = {
     head?: RelationshipArrowType;
     tail?: RelationshipArrowType;
     line?: RelationshipLineType;
-    color?: Color;
+    color?: ThemeColor;
     links?: NonEmptyArray<string | {
         title?: string;
         url: string;
@@ -469,7 +649,7 @@ type NewRelationProps<Kind, Tag, Metadata> = {
 };
 type Invalid<Message extends string> = Tagged<Message, 'Error'>;
 type Warn<Id, Existing> = IsLiteral<Existing> extends true ? Id extends Existing ? Invalid<'Already exists'> : Id : Id;
-type ValidId<Id> = Id extends `${number}${string}` ? Invalid<'Id must not start with number'> : IsStringLiteral$1<Id> extends true ? Id : Invalid<'Id must be a literal'>;
+type ValidId<Id> = Id extends `${number}${string}` ? Invalid<'Id must not start with number'> : IsLiteral<Id> extends true ? Id : Invalid<'Id must be a literal'>;
 /**
  * When building nested objects
  */
@@ -497,13 +677,12 @@ interface Types<ElementKind extends string, Fqn extends string, ViewId extends s
     NewDeploymentNodeProps: NewDeploymentNodeProps<Tag, Metadata<MetadataKey>>;
 }
 declare namespace Types {
-    type FromSpecification<Spec> = Spec extends BuilderSpecification ? Types<KeysOf<Spec['elements']>, never, never, KeysOf<Spec['relationships']>, TupleToUnion<Spec['tags']>, TupleToUnion<Spec['metadataKeys']>, KeysOf<Spec['deployments']>, never> : never;
+    type FromSpecification<Spec> = Spec extends BuilderSpecification ? Types<KeysOf<Spec['elements']>, never, never, KeysOf<Spec['relationships']>, KeysOf<Spec['tags']>, TupleToUnion<Spec['metadataKeys']>, KeysOf<Spec['deployments']>, never> : never;
     type AddFqn<T, Id extends string> = T extends TypesNested<infer P, any, any, any, any, any, any, any, any> ? TypesNested<P, T['ElementKind'], `${P}.${Id}` | T['Fqn'], T['ViewId'], T['RelationshipKind'], T['Tag'], T['MetadataKey'], T['DeploymentKind'], T['DeploymentFqn']> : T extends AnyTypes ? Types<T['ElementKind'], Id | T['Fqn'], T['ViewId'], T['RelationshipKind'], T['Tag'], T['MetadataKey'], T['DeploymentKind'], T['DeploymentFqn']> : never;
     type AddDeploymentFqn<T, Id extends string> = T extends TypesNested<infer P, any, any, any, any, any, any, any, any> ? TypesNested<P, T['ElementKind'], T['Fqn'], T['ViewId'], T['RelationshipKind'], T['Tag'], T['MetadataKey'], T['DeploymentKind'], `${P}.${Id}` | T['DeploymentFqn']> : T extends AnyTypes ? Types<T['ElementKind'], T['Fqn'], T['ViewId'], T['RelationshipKind'], T['Tag'], T['MetadataKey'], T['DeploymentKind'], Id | T['DeploymentFqn']> : never;
     type AddView<T, Id extends string> = T extends TypesNested<infer P, any, any, any, any, any, any, any, any> ? TypesNested<P, T['ElementKind'], T['Fqn'], Id | T['ViewId'], T['RelationshipKind'], T['Tag'], T['MetadataKey'], T['DeploymentKind'], T['DeploymentFqn']> : T extends AnyTypes ? Types<T['ElementKind'], T['Fqn'], Id | T['ViewId'], T['RelationshipKind'], T['Tag'], T['MetadataKey'], T['DeploymentKind'], T['DeploymentFqn']> : never;
-    type ToParsedLikeC4Model<T> = T extends AnyTypes ? ParsedLikeC4ModelData<T['ElementKind'], T['RelationshipKind'], T['Tag'], T['Fqn'], T['ViewId'], T['DeploymentFqn']> : never;
-    type ToLikeC4Model<T extends AnyTypes> = LikeC4Model.Computed<T['Fqn'], T['DeploymentFqn'], T['ViewId']>;
-    type ToExpression<T> = T extends AnyTypes ? ExpressionV2<T['DeploymentFqn'], T['Fqn']> : never;
+    type ToAux<T> = T extends AnyTypes ? Aux<'parsed', T['Fqn'], T['DeploymentFqn'], T['ViewId'], 'from-builder', SpecAux<T['ElementKind'], T['DeploymentKind'], T['RelationshipKind'], T['Tag'], T['MetadataKey']>> : Any;
+    type ToExpression<T> = T extends AnyTypes ? Expression<ToAux<T>> : never;
     type From<B> = B extends Builder<infer T> ? B['Types'] extends AnyTypes ? T : AnyTypes : never;
     type DeploymentRules<B> = DeploymentRulesBuilderOp<From<B>>;
 }