@likec4/core 1.12.1 → 1.13.0

package/dist/shared/{core.dY8efyk0.d.ts → core.C4jDMQ1i.d.cts}

@@ -1,4 +1,14 @@
-import { LiteralUnion, Tagged, UnwrapTagged } from 'type-fest';
+import { Tagged, LiteralUnion, TupleToUnion } from 'type-fest';
+
+type NonEmptyArray<T> = [T, ...T[]];
+type NonEmptyReadonlyArray<T> = readonly [T, ...T[]];
+type IconUrl = Tagged<string, 'IconUrl'>;
+type CustomColor = 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 = typeof ThemeColors[number];
@@ -34,30 +44,20 @@ interface LikeC4Theme {
     elements: ElementThemeColors;
 }
 
-type NonEmptyArray<T> = [T, ...T[]];
-type NonEmptyReadonlyArray<T> = readonly [T, ...T[]];
-type IconUrl = Tagged<string, 'IconUrl'>;
-type CustomColor = string;
-type Point = readonly [x: number, y: number];
-interface XYPoint {
-    x: number;
-    y: number;
-}
-
-type Fqn = Tagged<string, 'Fqn'>;
+type Fqn<Id extends string = string> = Tagged<Id, 'Fqn'>;
 declare function AsFqn(name: string, parent?: Fqn | null): Fqn;
 declare const BorderStyles: readonly ["solid", "dashed", "dotted", "none"];
-type BorderStyle = typeof BorderStyles[number];
-type ElementKind = Tagged<string, 'ElementKind'>;
+type BorderStyle = TupleToUnion<typeof BorderStyles>;
+type ElementKind<Kinds extends string = string> = Tagged<Kinds, 'ElementKind'>;
 declare const ElementShapes: readonly ["rectangle", "person", "browser", "mobile", "cylinder", "storage", "queue"];
-type ElementShape = typeof ElementShapes[number];
+type ElementShape = TupleToUnion<typeof ElementShapes>;
 declare const DefaultThemeColor = "primary";
 declare const DefaultElementShape = "rectangle";
 interface ElementStyle {
     border?: BorderStyle;
     opacity?: number;
 }
-type Tag = Tagged<string, 'Tag'>;
+type Tag<Tags extends string = string> = Tagged<Tags, 'Tag'>;
 interface TagSpec {
     readonly id: Tag;
     readonly style: ElementStyle;
@@ -67,22 +67,22 @@ interface Link {
     readonly url: string;
     readonly relative?: string;
 }
-interface Element {
-    readonly id: Fqn;
-    readonly kind: ElementKind;
+interface TypedElement<Ids extends string, Kinds extends string, Tags extends string, MetadataKeys extends string = never> {
+    readonly id: Fqn<Ids>;
+    readonly kind: ElementKind<Kinds>;
     readonly title: string;
     readonly description: string | null;
     readonly technology: string | null;
-    readonly tags: NonEmptyArray<Tag> | null;
+    readonly tags: NonEmptyArray<Tag<Tags>> | null;
     readonly links: NonEmptyArray<Link> | null;
     readonly icon?: IconUrl;
     readonly shape?: ElementShape;
     readonly color?: Color;
     readonly style?: ElementStyle;
     readonly notation?: string;
-    readonly metadata?: {
-        [key: string]: string;
-    };
+    readonly metadata?: Record<MetadataKeys, string>;
+}
+interface Element extends TypedElement<string, string, string, string> {
 }
 interface ElementKindSpecificationStyle {
     shape?: ElementShape;
@@ -139,194 +139,6 @@ type Filterable<FTag extends string = string, FKind extends string = string> = {
 type OperatorPredicate<V extends Filterable> = (value: V) => boolean;
 declare function whereOperatorAsPredicate<FTag extends string = string, FKind extends string = string>(operator: WhereOperator<FTag, FKind>): OperatorPredicate<Filterable<FTag, FKind>>;
 
-type RelationID = Tagged<string, 'RelationID'>;
-type RelationshipKind = Tagged<string, 'RelationshipKind'>;
-type RelationshipLineType = 'dashed' | 'solid' | 'dotted';
-type RelationshipArrowType = 'none' | 'normal' | 'onormal' | 'dot' | 'odot' | 'diamond' | 'odiamond' | 'crow' | 'open' | 'vee';
-declare const DefaultLineStyle = "dashed";
-declare const DefaultArrowType = "normal";
-declare const DefaultRelationshipColor = "gray";
-interface Relation {
-    readonly id: RelationID;
-    readonly source: Fqn;
-    readonly target: Fqn;
-    readonly title: string;
-    readonly description?: string;
-    readonly technology?: string;
-    readonly tags?: NonEmptyArray<Tag>;
-    readonly kind?: RelationshipKind;
-    readonly color?: Color;
-    readonly line?: RelationshipLineType;
-    readonly head?: RelationshipArrowType;
-    readonly tail?: RelationshipArrowType;
-    readonly links?: NonEmptyArray<Link>;
-    readonly navigateTo?: ViewID;
-    readonly metadata?: {
-        [key: string]: string;
-    };
-}
-interface RelationshipKindSpecification {
-    readonly technology?: string;
-    readonly notation?: string;
-    readonly color?: Color;
-    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;
-    isDescedants?: boolean;
-}
-declare function isElementRef(expr: Expression): expr is ElementRefExpr;
-interface ExpandedElementExpr extends Omit<BaseExpr, 'expanded'> {
-    expanded: Fqn;
-}
-declare function isExpandedElementExpr(expr: Expression): expr is ExpandedElementExpr;
-interface CustomElementExpr extends Omit<BaseExpr, 'custom'> {
-    custom: {
-        expr: ElementExpression | ElementWhereExpr;
-        title?: string;
-        description?: string;
-        technology?: string;
-        notation?: string;
-        shape?: ElementShape;
-        color?: Color;
-        icon?: IconUrl;
-        border?: BorderStyle;
-        opacity?: number;
-        navigateTo?: ViewID;
-    };
-}
-declare function isCustomElement(expr: Expression): expr is CustomElementExpr;
-interface WildcardExpr extends Omit<BaseExpr, 'wildcard'> {
-    wildcard: true;
-}
-declare function isWildcard(expr: Expression): expr is WildcardExpr;
-interface ElementKindExpr extends Omit<BaseExpr, 'elementKind' | 'isEqual'> {
-    elementKind: ElementKind;
-    isEqual: boolean;
-}
-declare function isElementKindExpr(expr: Expression): expr is ElementKindExpr;
-interface ElementTagExpr extends Omit<BaseExpr, 'elementTag' | 'isEqual'> {
-    elementTag: Tag;
-    isEqual: boolean;
-}
-declare function isElementTagExpr(expr: Expression): expr is ElementTagExpr;
-type ElementExpression = ElementRefExpr | WildcardExpr | ElementKindExpr | ElementTagExpr | ExpandedElementExpr;
-declare function isElement(expr: Expression): expr is ElementExpression;
-interface ElementWhereExpr extends Omit<BaseExpr, 'where'> {
-    where: {
-        expr: ElementExpression;
-        condition: WhereOperator<string, string>;
-    };
-}
-declare function isElementWhere(expr: Expression): expr is ElementWhereExpr;
-type ElementPredicateExpression = ElementExpression | ElementWhereExpr | CustomElementExpr;
-declare function isElementPredicateExpr(expr: Expression): expr is ElementPredicateExpression;
-interface RelationExpr extends Omit<BaseExpr, 'source' | 'target'> {
-    source: ElementExpression;
-    target: ElementExpression;
-    isBidirectional?: boolean;
-}
-declare function isRelation(expr: Expression): expr is RelationExpr;
-interface InOutExpr extends Omit<BaseExpr, 'inout'> {
-    inout: ElementExpression;
-}
-declare function isInOut(expr: Expression): expr is InOutExpr;
-interface IncomingExpr extends Omit<BaseExpr, 'incoming'> {
-    incoming: ElementExpression;
-}
-declare function isIncoming(expr: Expression): expr is IncomingExpr;
-interface OutgoingExpr extends Omit<BaseExpr, 'outgoing'> {
-    outgoing: ElementExpression;
-}
-declare function isOutgoing(expr: Expression): expr is OutgoingExpr;
-type RelationExpression = RelationExpr | InOutExpr | IncomingExpr | OutgoingExpr;
-declare function isRelationExpression(expr: Expression): expr is RelationExpression;
-interface RelationWhereExpr extends Omit<BaseExpr, 'where'> {
-    where: {
-        expr: RelationExpression;
-        condition: WhereOperator<string, string>;
-    };
-}
-declare function isRelationWhere(expr: Expression): expr is RelationWhereExpr;
-interface CustomRelationExpr extends Omit<BaseExpr, 'customRelation'> {
-    customRelation: {
-        relation: RelationExpression | RelationWhereExpr;
-        title?: string;
-        description?: string;
-        technology?: string;
-        notation?: string;
-        navigateTo?: ViewID;
-        notes?: string;
-        color?: Color;
-        line?: RelationshipLineType;
-        head?: RelationshipArrowType;
-        tail?: RelationshipArrowType;
-    };
-}
-declare function isCustomRelationExpr(expr: Expression): expr is CustomRelationExpr;
-type RelationPredicateExpression = RelationExpression | RelationWhereExpr | CustomRelationExpr;
-declare function isRelationPredicateExpr(expr: Expression): expr is RelationPredicateExpression;
-type Expression = ElementPredicateExpression | RelationPredicateExpression;
-
-type expression_CustomElementExpr = CustomElementExpr;
-type expression_CustomRelationExpr = CustomRelationExpr;
-type expression_ElementExpression = ElementExpression;
-type expression_ElementKindExpr = ElementKindExpr;
-type expression_ElementPredicateExpression = ElementPredicateExpression;
-type expression_ElementRefExpr = ElementRefExpr;
-type expression_ElementTagExpr = ElementTagExpr;
-type expression_ElementWhereExpr = ElementWhereExpr;
-type expression_ExpandedElementExpr = ExpandedElementExpr;
-type expression_Expression = Expression;
-type expression_InOutExpr = InOutExpr;
-type expression_IncomingExpr = IncomingExpr;
-type expression_OutgoingExpr = OutgoingExpr;
-type expression_RelationExpr = RelationExpr;
-type expression_RelationExpression = RelationExpression;
-type expression_RelationPredicateExpression = RelationPredicateExpression;
-type expression_RelationWhereExpr = RelationWhereExpr;
-type expression_WildcardExpr = WildcardExpr;
-declare const expression_isCustomElement: typeof isCustomElement;
-declare const expression_isCustomRelationExpr: typeof isCustomRelationExpr;
-declare const expression_isElement: typeof isElement;
-declare const expression_isElementKindExpr: typeof isElementKindExpr;
-declare const expression_isElementPredicateExpr: typeof isElementPredicateExpr;
-declare const expression_isElementRef: typeof isElementRef;
-declare const expression_isElementTagExpr: typeof isElementTagExpr;
-declare const expression_isElementWhere: typeof isElementWhere;
-declare const expression_isExpandedElementExpr: typeof isExpandedElementExpr;
-declare const expression_isInOut: typeof isInOut;
-declare const expression_isIncoming: typeof isIncoming;
-declare const expression_isOutgoing: typeof isOutgoing;
-declare const expression_isRelation: typeof isRelation;
-declare const expression_isRelationExpression: typeof isRelationExpression;
-declare const expression_isRelationPredicateExpr: typeof isRelationPredicateExpr;
-declare const expression_isRelationWhere: typeof isRelationWhere;
-declare const expression_isWildcard: typeof isWildcard;
-declare namespace expression {
-  export { type expression_CustomElementExpr as CustomElementExpr, type expression_CustomRelationExpr as CustomRelationExpr, type expression_ElementExpression as ElementExpression, type expression_ElementKindExpr as ElementKindExpr, type expression_ElementPredicateExpression as ElementPredicateExpression, type expression_ElementRefExpr as ElementRefExpr, type expression_ElementTagExpr as ElementTagExpr, type expression_ElementWhereExpr as ElementWhereExpr, type expression_ExpandedElementExpr as ExpandedElementExpr, type expression_Expression as Expression, type expression_InOutExpr as InOutExpr, type expression_IncomingExpr as IncomingExpr, type expression_OutgoingExpr as OutgoingExpr, type expression_RelationExpr as RelationExpr, type expression_RelationExpression as RelationExpression, type expression_RelationPredicateExpression as RelationPredicateExpression, type expression_RelationWhereExpr as RelationWhereExpr, type expression_WildcardExpr as WildcardExpr, expression_isCustomElement as isCustomElement, expression_isCustomRelationExpr as isCustomRelationExpr, expression_isElement as isElement, expression_isElementKindExpr as isElementKindExpr, expression_isElementPredicateExpr as isElementPredicateExpr, expression_isElementRef as isElementRef, expression_isElementTagExpr as isElementTagExpr, expression_isElementWhere as isElementWhere, expression_isExpandedElementExpr as isExpandedElementExpr, expression_isInOut as isInOut, expression_isIncoming as isIncoming, expression_isOutgoing as isOutgoing, expression_isRelation as isRelation, expression_isRelationExpression as isRelationExpression, expression_isRelationPredicateExpr as isRelationPredicateExpr, expression_isRelationWhere as isRelationWhere, expression_isWildcard as isWildcard };
-}
-
 type ElementNotation = {
     kinds: ElementKind[];
     shape: ElementShape;
@@ -334,7 +146,7 @@ type ElementNotation = {
     title: string;
 };
 
-type ViewID = Tagged<string, 'ViewID'>;
+type ViewID<Id extends string = string> = Tagged<Id, 'ViewID'>;
 type ViewRulePredicate = {
     include: Expression[];
     exclude?: never;
@@ -362,12 +174,12 @@ interface ViewRuleAutoLayout {
 }
 declare function isViewRuleAutoLayout(rule: ViewRule): rule is ViewRuleAutoLayout;
 type ViewRule = ViewRulePredicate | ViewRuleStyle | ViewRuleAutoLayout;
-interface BasicView<ViewType extends 'element' | 'dynamic'> {
+interface BasicView<ViewType extends 'element' | 'dynamic', ViewIDs extends string, Tags extends string> {
     readonly __?: ViewType;
-    readonly id: ViewID;
+    readonly id: ViewID<ViewIDs>;
     readonly title: string | null;
     readonly description: string | null;
-    readonly tags: NonEmptyArray<Tag> | null;
+    readonly tags: NonEmptyArray<Tag<Tags>> | null;
     readonly links: NonEmptyArray<Link> | null;
     /**
      * URI to the source file of this view.
@@ -389,17 +201,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;
     readonly rules: ViewRule[];
 }
-interface ScopedElementView extends BasicElementView {
+interface ScopedElementView<ViewIDs extends string, Tags extends string> extends BasicElementView<ViewIDs, Tags> {
     readonly viewOf: Fqn;
 }
-interface ExtendsElementView extends BasicElementView {
-    readonly extends: ViewID;
+interface ExtendsElementView<ViewIDs extends string, Tags extends string> extends BasicElementView<ViewIDs, Tags> {
+    readonly extends: ViewID<ViewIDs>;
 }
-type ElementView = ScopedElementView | ExtendsElementView | BasicElementView;
+type ElementView<ViewIDs extends string = string, Tags extends string = string> = ScopedElementView<ViewIDs, Tags> | ExtendsElementView<ViewIDs, Tags> | BasicElementView<ViewIDs, Tags>;
 interface DynamicViewStep {
     readonly source: Fqn;
     readonly target: Fqn;
@@ -425,7 +237,7 @@ type DynamicViewIncludeRule = {
 };
 declare function isDynamicViewIncludeRule(rule: DynamicViewRule): rule is DynamicViewIncludeRule;
 type DynamicViewRule = DynamicViewIncludeRule | ViewRuleStyle | ViewRuleAutoLayout;
-interface DynamicView extends BasicView<'dynamic'> {
+interface DynamicView<ViewIDs extends string = string, Tags extends string = string> extends BasicView<'dynamic', ViewIDs, Tags> {
     readonly __: 'dynamic';
     readonly steps: DynamicViewStepOrParallel[];
     readonly rules: DynamicViewRule[];
@@ -434,12 +246,12 @@ declare function isDynamicViewParallelSteps(step: DynamicViewStepOrParallel): st
 type CustomColorDefinitions = {
     [key: string]: ThemeColorValues;
 };
-type LikeC4View = ElementView | DynamicView;
+type LikeC4View<ViewIDs extends string = string, Tags extends string = string> = ElementView<ViewIDs, Tags> | DynamicView<ViewIDs, Tags>;
 declare function isDynamicView(view: LikeC4View): view is DynamicView;
 declare function isElementView(view: LikeC4View): view is ElementView;
-declare function isExtendsElementView(view: LikeC4View): view is ExtendsElementView;
-declare function isScopedElementView(view: LikeC4View): view is ScopedElementView;
-type NodeId = Tagged<string, 'Fqn'>;
+declare function isExtendsElementView(view: LikeC4View): view is ExtendsElementView<string, string>;
+declare function isScopedElementView(view: LikeC4View): view is ScopedElementView<string, string>;
+type NodeId<IDs extends string = string> = Tagged<IDs, 'Fqn'>;
 type EdgeId = Tagged<string, 'EdgeId'>;
 type StepEdgeIdLiteral = `step-${number}` | `step-${number}.${number}`;
 type StepEdgeId = Tagged<StepEdgeIdLiteral, 'EdgeId'>;
@@ -523,15 +335,15 @@ interface ViewAutoLayout {
     rankSep?: number;
     nodeSep?: number;
 }
-interface ComputedElementView extends Omit<ElementView, 'rules' | 'docUri'>, ViewWithHash, ViewWithNotation {
-    readonly extends?: ViewID;
+interface ComputedElementView<ViewIDs extends string = string, Tags extends string = string> extends Omit<ElementView<ViewIDs, Tags>, 'rules' | 'docUri'>, ViewWithHash, ViewWithNotation {
+    readonly extends?: ViewID<ViewIDs>;
     readonly autoLayout: ViewAutoLayout;
     readonly nodes: ComputedNode[];
     readonly edges: ComputedEdge[];
     rules?: never;
     docUri?: never;
 }
-interface ComputedDynamicView extends Omit<DynamicView, 'rules' | 'steps' | 'docUri'>, ViewWithHash, ViewWithNotation {
+interface ComputedDynamicView<ViewIDs extends string = string, Tags extends string = string> extends Omit<DynamicView<ViewIDs, Tags>, 'rules' | 'steps' | 'docUri'>, ViewWithHash, ViewWithNotation {
     readonly autoLayout: ViewAutoLayout;
     readonly nodes: ComputedNode[];
     readonly edges: ComputedEdge[];
@@ -540,7 +352,7 @@ interface ComputedDynamicView extends Omit<DynamicView, 'rules' | 'steps' | 'doc
     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>;
 declare function isComputedElementView(view: ComputedView): view is ComputedElementView;
 type BBox = {
     x: number;
@@ -561,7 +373,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;
@@ -594,18 +406,206 @@ type ViewManualLayout = {
     }>;
 };
 
+type RelationID = Tagged<string, 'RelationID'>;
+type RelationshipKind<Kinds extends string = string> = Tagged<Kinds, 'RelationshipKind'>;
+type RelationshipLineType = 'dashed' | 'solid' | 'dotted';
+type RelationshipArrowType = 'none' | 'normal' | 'onormal' | 'dot' | 'odot' | 'diamond' | 'odiamond' | 'crow' | 'open' | 'vee';
+declare const DefaultLineStyle = "dashed";
+declare const DefaultArrowType = "normal";
+declare const DefaultRelationshipColor = "gray";
+interface Relation {
+    readonly id: RelationID;
+    readonly source: Fqn;
+    readonly target: Fqn;
+    readonly title: string;
+    readonly description?: string;
+    readonly technology?: string;
+    readonly tags?: NonEmptyArray<Tag>;
+    readonly kind?: RelationshipKind;
+    readonly color?: Color;
+    readonly line?: RelationshipLineType;
+    readonly head?: RelationshipArrowType;
+    readonly tail?: RelationshipArrowType;
+    readonly links?: NonEmptyArray<Link>;
+    readonly navigateTo?: ViewID;
+    readonly metadata?: {
+        [key: string]: string;
+    };
+}
+interface RelationshipKindSpecification {
+    readonly technology?: string;
+    readonly notation?: string;
+    readonly color?: Color;
+    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;
+    isDescedants?: boolean;
+}
+declare function isElementRef(expr: Expression): expr is ElementRefExpr;
+interface ExpandedElementExpr extends Omit<BaseExpr, 'expanded'> {
+    expanded: Fqn;
+}
+declare function isExpandedElementExpr(expr: Expression): expr is ExpandedElementExpr;
+interface CustomElementExpr extends Omit<BaseExpr, 'custom'> {
+    custom: {
+        expr: ElementExpression | ElementWhereExpr;
+        title?: string;
+        description?: string;
+        technology?: string;
+        notation?: string;
+        shape?: ElementShape;
+        color?: Color;
+        icon?: IconUrl;
+        border?: BorderStyle;
+        opacity?: number;
+        navigateTo?: ViewID;
+    };
+}
+declare function isCustomElement(expr: Expression): expr is CustomElementExpr;
+interface WildcardExpr extends Omit<BaseExpr, 'wildcard'> {
+    wildcard: true;
+}
+declare function isWildcard(expr: Expression): expr is WildcardExpr;
+interface ElementKindExpr extends Omit<BaseExpr, 'elementKind' | 'isEqual'> {
+    elementKind: ElementKind;
+    isEqual: boolean;
+}
+declare function isElementKindExpr(expr: Expression): expr is ElementKindExpr;
+interface ElementTagExpr extends Omit<BaseExpr, 'elementTag' | 'isEqual'> {
+    elementTag: Tag;
+    isEqual: boolean;
+}
+declare function isElementTagExpr(expr: Expression): expr is ElementTagExpr;
+type ElementExpression = ElementRefExpr | WildcardExpr | ElementKindExpr | ElementTagExpr | ExpandedElementExpr;
+declare function isElement(expr: Expression): expr is ElementExpression;
+interface ElementWhereExpr extends Omit<BaseExpr, 'where'> {
+    where: {
+        expr: ElementExpression;
+        condition: WhereOperator<string, string>;
+    };
+}
+declare function isElementWhere(expr: Expression): expr is ElementWhereExpr;
+type ElementPredicateExpression = ElementExpression | ElementWhereExpr | CustomElementExpr;
+declare function isElementPredicateExpr(expr: Expression): expr is ElementPredicateExpression;
+interface RelationExpr extends Omit<BaseExpr, 'source' | 'target'> {
+    source: ElementExpression;
+    target: ElementExpression;
+    isBidirectional?: boolean;
+}
+declare function isRelation(expr: Expression): expr is RelationExpr;
+interface InOutExpr extends Omit<BaseExpr, 'inout'> {
+    inout: ElementExpression;
+}
+declare function isInOut(expr: Expression): expr is InOutExpr;
+interface IncomingExpr extends Omit<BaseExpr, 'incoming'> {
+    incoming: ElementExpression;
+}
+declare function isIncoming(expr: Expression): expr is IncomingExpr;
+interface OutgoingExpr extends Omit<BaseExpr, 'outgoing'> {
+    outgoing: ElementExpression;
+}
+declare function isOutgoing(expr: Expression): expr is OutgoingExpr;
+type RelationExpression = RelationExpr | InOutExpr | IncomingExpr | OutgoingExpr;
+declare function isRelationExpression(expr: Expression): expr is RelationExpression;
+interface RelationWhereExpr extends Omit<BaseExpr, 'where'> {
+    where: {
+        expr: RelationExpression;
+        condition: WhereOperator<string, string>;
+    };
+}
+declare function isRelationWhere(expr: Expression): expr is RelationWhereExpr;
+interface CustomRelationExpr extends Omit<BaseExpr, 'customRelation'> {
+    customRelation: {
+        relation: RelationExpression | RelationWhereExpr;
+        title?: string;
+        description?: string;
+        technology?: string;
+        notation?: string;
+        navigateTo?: ViewID;
+        notes?: string;
+        color?: Color;
+        line?: RelationshipLineType;
+        head?: RelationshipArrowType;
+        tail?: RelationshipArrowType;
+    };
+}
+declare function isCustomRelationExpr(expr: Expression): expr is CustomRelationExpr;
+type RelationPredicateExpression = RelationExpression | RelationWhereExpr | CustomRelationExpr;
+declare function isRelationPredicateExpr(expr: Expression): expr is RelationPredicateExpression;
+type Expression = ElementPredicateExpression | RelationPredicateExpression;
+
+type expression_CustomElementExpr = CustomElementExpr;
+type expression_CustomRelationExpr = CustomRelationExpr;
+type expression_ElementExpression = ElementExpression;
+type expression_ElementKindExpr = ElementKindExpr;
+type expression_ElementPredicateExpression = ElementPredicateExpression;
+type expression_ElementRefExpr = ElementRefExpr;
+type expression_ElementTagExpr = ElementTagExpr;
+type expression_ElementWhereExpr = ElementWhereExpr;
+type expression_ExpandedElementExpr = ExpandedElementExpr;
+type expression_Expression = Expression;
+type expression_InOutExpr = InOutExpr;
+type expression_IncomingExpr = IncomingExpr;
+type expression_OutgoingExpr = OutgoingExpr;
+type expression_RelationExpr = RelationExpr;
+type expression_RelationExpression = RelationExpression;
+type expression_RelationPredicateExpression = RelationPredicateExpression;
+type expression_RelationWhereExpr = RelationWhereExpr;
+type expression_WildcardExpr = WildcardExpr;
+declare const expression_isCustomElement: typeof isCustomElement;
+declare const expression_isCustomRelationExpr: typeof isCustomRelationExpr;
+declare const expression_isElement: typeof isElement;
+declare const expression_isElementKindExpr: typeof isElementKindExpr;
+declare const expression_isElementPredicateExpr: typeof isElementPredicateExpr;
+declare const expression_isElementRef: typeof isElementRef;
+declare const expression_isElementTagExpr: typeof isElementTagExpr;
+declare const expression_isElementWhere: typeof isElementWhere;
+declare const expression_isExpandedElementExpr: typeof isExpandedElementExpr;
+declare const expression_isInOut: typeof isInOut;
+declare const expression_isIncoming: typeof isIncoming;
+declare const expression_isOutgoing: typeof isOutgoing;
+declare const expression_isRelation: typeof isRelation;
+declare const expression_isRelationExpression: typeof isRelationExpression;
+declare const expression_isRelationPredicateExpr: typeof isRelationPredicateExpr;
+declare const expression_isRelationWhere: typeof isRelationWhere;
+declare const expression_isWildcard: typeof isWildcard;
+declare namespace expression {
+  export { type expression_CustomElementExpr as CustomElementExpr, type expression_CustomRelationExpr as CustomRelationExpr, type expression_ElementExpression as ElementExpression, type expression_ElementKindExpr as ElementKindExpr, type expression_ElementPredicateExpression as ElementPredicateExpression, type expression_ElementRefExpr as ElementRefExpr, type expression_ElementTagExpr as ElementTagExpr, type expression_ElementWhereExpr as ElementWhereExpr, type expression_ExpandedElementExpr as ExpandedElementExpr, type expression_Expression as Expression, type expression_InOutExpr as InOutExpr, type expression_IncomingExpr as IncomingExpr, type expression_OutgoingExpr as OutgoingExpr, type expression_RelationExpr as RelationExpr, type expression_RelationExpression as RelationExpression, type expression_RelationPredicateExpression as RelationPredicateExpression, type expression_RelationWhereExpr as RelationWhereExpr, type expression_WildcardExpr as WildcardExpr, expression_isCustomElement as isCustomElement, expression_isCustomRelationExpr as isCustomRelationExpr, expression_isElement as isElement, expression_isElementKindExpr as isElementKindExpr, expression_isElementPredicateExpr as isElementPredicateExpr, expression_isElementRef as isElementRef, expression_isElementTagExpr as isElementTagExpr, expression_isElementWhere as isElementWhere, expression_isExpandedElementExpr as isExpandedElementExpr, expression_isInOut as isInOut, expression_isIncoming as isIncoming, expression_isOutgoing as isOutgoing, expression_isRelation as isRelation, expression_isRelationExpression as isRelationExpression, expression_isRelationPredicateExpr as isRelationPredicateExpr, expression_isRelationWhere as isRelationWhere, expression_isWildcard as isWildcard };
+}
+
 /**
  * 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[];
-        elements: Record<UnwrapTagged<ElementKind>, ElementKindSpecification>;
-        relationships: Record<UnwrapTagged<ElementKind>, RelationshipKindSpecification>;
+        tags: Tag<Tags>[];
+        elements: Record<ElementKinds, ElementKindSpecification>;
+        relationships: Record<RelationKinds, RelationshipKindSpecification>;
     };
-    elements: Record<Fqn, Element>;
+    elements: Record<Fqns, TypedElement<Fqns, ElementKinds, Tags>>;
     relations: Record<RelationID, Relation>;
-    views: Record<ViewID, LikeC4View>;
+    views: Record<Views, LikeC4View<Views, Tags>>;
 }
 /**
  * Same as `ParsedLikeC4Model` but with computed views.
@@ -678,9 +678,13 @@ declare namespace ViewChange {
     }
     interface ChangeAutoLayout {
         op: 'change-autolayout';
-        layout: ViewRuleAutoLayout;
+        layout: {
+            direction: AutoLayoutDirection;
+            nodeSep?: number | null;
+            rankSep?: number | null;
+        };
     }
 }
 type ViewChange = ViewChange.ChangeElementStyle | ViewChange.SaveManualLayout | ViewChange.ChangeAutoLayout;
 
-export { isElement as $, AsFqn as A, BorderStyles as B, type ComputedView as C, type DiagramView as D, type EdgeId as E, type Fqn as F, isElementRef as G, type HexColorLiteral as H, type IconUrl as I, type ExpandedElementExpr as J, isExpandedElementExpr as K, type LayoutedLikeC4Model as L, type CustomElementExpr as M, type NodeId as N, isCustomElement as O, type Point as P, isWildcard as Q, type RelationID as R, type ElementKindExpr as S, type ThemeColorValues as T, isElementKindExpr as U, type ViewID as V, type WildcardExpr as W, type XYPoint as X, type ElementTagExpr as Y, isElementTagExpr as Z, type ElementExpression as _, type Tag as a, type ElementView as a$, type ElementWhereExpr as a0, isElementWhere as a1, type ElementPredicateExpression as a2, isElementPredicateExpr as a3, type RelationExpr as a4, isRelation as a5, type InOutExpr as a6, isInOut as a7, type IncomingExpr as a8, isIncoming as a9, type RelationshipLineType as aA, type RelationshipArrowType as aB, DefaultLineStyle as aC, DefaultArrowType as aD, DefaultRelationshipColor as aE, type RelationshipKindSpecification as aF, type ThemeColor as aG, type ColorLiteral as aH, isThemeColor as aI, type ElementThemeColorValues as aJ, type ElementThemeColors as aK, type RelationshipThemeColorValues as aL, type RelationshipThemeColors as aM, type LikeC4Theme as aN, type ViewRulePredicate as aO, isViewRulePredicate as aP, type ViewRuleStyle as aQ, isViewRuleStyle as aR, type AutoLayoutDirection as aS, isAutoLayoutDirection as aT, type ViewRuleAutoLayout as aU, isViewRuleAutoLayout as aV, type ViewRule as aW, type BasicView as aX, type BasicElementView as aY, type ScopedElementView as aZ, type ExtendsElementView as a_, type OutgoingExpr as aa, isOutgoing as ab, type RelationExpression as ac, isRelationExpression as ad, type RelationWhereExpr as ae, isRelationWhere as af, type CustomRelationExpr as ag, isCustomRelationExpr as ah, type RelationPredicateExpression as ai, isRelationPredicateExpr as aj, type Expression as ak, type ParsedLikeC4Model as al, type EqualOperator as am, type TagEqual as an, isTagEqual as ao, type KindEqual as ap, isKindEqual as aq, type NotOperator as ar, isNotOperator as as, type AndOperator as at, isAndOperator as au, type OrOperator as av, isOrOperator as aw, type WhereOperator as ax, whereOperatorAsPredicate as ay, OverviewGraph as az, type ComputedNode as b, type DynamicViewStep as b0, type DynamicViewParallelSteps as b1, type DynamicViewStepOrParallel as b2, type DynamicViewIncludeRule as b3, isDynamicViewIncludeRule as b4, type DynamicViewRule as b5, type DynamicView as b6, isDynamicViewParallelSteps as b7, type CustomColorDefinitions as b8, type LikeC4View as b9, isDynamicView as ba, isElementView as bb, isExtendsElementView as bc, isScopedElementView as bd, type StepEdgeIdLiteral as be, StepEdgeId as bf, isStepEdgeId as bg, extractStep as bh, getParallelStepsPrefix as bi, type ViewWithHash as bj, type ViewWithNotation as bk, type ViewAutoLayout as bl, type ComputedElementView as bm, type ComputedDynamicView as bn, isComputedDynamicView as bo, isComputedElementView as bp, type BBox as bq, getBBoxCenter as br, type ViewManualLayout as bs, ViewChange as bt, type ElementNotation as bu, type ElementKind as c, type ElementShape as d, type Color as e, type ComputedEdge as f, type ComputedLikeC4Model as g, type Element as h, type Relation as i, type RelationshipKind as j, type DiagramNode as k, type DiagramEdge as l, type NonEmptyArray as m, expression as n, type NonEmptyReadonlyArray as o, type CustomColor as p, type BorderStyle as q, ElementShapes as r, DefaultThemeColor as s, DefaultElementShape as t, type ElementStyle as u, type TagSpec as v, type Link as w, type ElementKindSpecificationStyle as x, type ElementKindSpecification as y, type ElementRefExpr as z };
+export { type ExpandedElementExpr as $, type AutoLayoutDirection as A, type BorderStyle as B, type Color as C, type DiagramView as D, type ElementKindSpecification as E, type Fqn as F, AsFqn as G, type HexColorLiteral as H, type IconUrl as I, BorderStyles as J, ElementShapes as K, type LikeC4View as L, DefaultThemeColor as M, type NonEmptyArray as N, DefaultElementShape as O, type ParsedLikeC4Model as P, type ElementStyle as Q, type RelationshipKindSpecification as R, type TagSpec as S, type ThemeColorValues as T, type Link as U, type ViewRuleStyle as V, type TypedElement as W, type XYPoint as X, type ElementKindSpecificationStyle as Y, type ElementRefExpr as Z, isElementRef as _, type ElementShape as a, type ScopedElementView as a$, isExpandedElementExpr as a0, isCustomElement as a1, type WildcardExpr as a2, isWildcard as a3, type ElementKindExpr as a4, isElementKindExpr as a5, type ElementTagExpr as a6, isElementTagExpr as a7, type ElementExpression as a8, isElement as a9, type AndOperator as aA, isAndOperator as aB, type OrOperator as aC, isOrOperator as aD, type WhereOperator as aE, whereOperatorAsPredicate as aF, OverviewGraph as aG, DefaultLineStyle as aH, DefaultArrowType as aI, DefaultRelationshipColor as aJ, type ThemeColor as aK, type ColorLiteral as aL, isThemeColor as aM, type ElementThemeColorValues as aN, type ElementThemeColors as aO, type RelationshipThemeColorValues as aP, type RelationshipThemeColors as aQ, type LikeC4Theme as aR, type ViewRulePredicate as aS, isViewRulePredicate as aT, isViewRuleStyle as aU, isAutoLayoutDirection as aV, type ViewRuleAutoLayout as aW, isViewRuleAutoLayout as aX, type ViewRule as aY, type BasicView as aZ, type BasicElementView as a_, type ElementWhereExpr as aa, isElementWhere as ab, type ElementPredicateExpression as ac, isElementPredicateExpr as ad, type RelationExpr as ae, isRelation as af, type InOutExpr as ag, isInOut as ah, type IncomingExpr as ai, isIncoming as aj, type OutgoingExpr as ak, isOutgoing as al, type RelationExpression as am, isRelationExpression as an, type RelationWhereExpr as ao, isRelationWhere as ap, isCustomRelationExpr as aq, type RelationPredicateExpression as ar, isRelationPredicateExpr as as, type EqualOperator as at, type TagEqual as au, isTagEqual as av, type KindEqual as aw, isKindEqual as ax, type NotOperator as ay, isNotOperator as az, type RelationshipArrowType as b, type ExtendsElementView as b0, type ElementView as b1, type DynamicViewStep as b2, type DynamicViewParallelSteps as b3, type DynamicViewStepOrParallel as b4, type DynamicViewIncludeRule as b5, isDynamicViewIncludeRule as b6, type DynamicViewRule as b7, type DynamicView as b8, isDynamicViewParallelSteps as b9, type CustomColorDefinitions as ba, isDynamicView as bb, isElementView as bc, isExtendsElementView as bd, isScopedElementView as be, type StepEdgeIdLiteral as bf, StepEdgeId as bg, isStepEdgeId as bh, extractStep as bi, getParallelStepsPrefix as bj, type ViewWithHash as bk, type ViewWithNotation as bl, type ViewAutoLayout as bm, type ComputedElementView as bn, type ComputedDynamicView as bo, isComputedDynamicView as bp, isComputedElementView as bq, type BBox as br, getBBoxCenter as bs, type ViewManualLayout as bt, ViewChange as bu, type ElementNotation as bv, type RelationshipLineType as c, type Element as d, type Relation as e, type Expression as f, type CustomElementExpr as g, type CustomRelationExpr as h, type RelationID as i, type ViewID as j, type EdgeId as k, type ComputedView as l, type Tag as m, type ComputedNode as n, type NodeId as o, type ElementKind as p, type ComputedEdge as q, type ComputedLikeC4Model as r, type LayoutedLikeC4Model as s, type RelationshipKind as t, type DiagramNode as u, type DiagramEdge as v, expression as w, type NonEmptyReadonlyArray as x, type CustomColor as y, type Point as z };