@likec4/core 1.46.4 → 1.48.0

package/dist/_chunks/expression-model.d.mts

@@ -0,0 +1,192 @@
+import { H as StrictViewId, U as Tag, m as ElementKind, n as Any, vt as ExclusiveUnion } from "./_aux.mjs";
+import { f as MarkdownOrString, u as Icon } from "./scalar.mjs";
+import { B as ShapeSize, C as BorderStyle, I as RelationshipArrowType, h as WhereOperator, j as IconPosition, k as ElementShape, r as PredicateSelector, w as Color, z as RelationshipLineType } from "./expression.mjs";
+import { t as FqnRef } from "./fqnRef.mjs";
+
+//#region src/types/expression-model.d.ts
+type AnyAux = Any;
+declare namespace ModelFqnExpr {
+  type Wildcard = {
+    wildcard: true;
+  };
+  function isWildcard<A extends AnyAux>(expr: ModelExpression<A>): expr is ModelFqnExpr.Wildcard;
+  interface Ref<M extends AnyAux> {
+    ref: FqnRef.ModelRef<M>;
+    selector?: PredicateSelector;
+  }
+  function isModelRef<A extends AnyAux>(ref: ModelExpression<A>): ref is ModelFqnExpr.Ref<A>;
+  interface ElementKindExpr<A extends AnyAux = AnyAux> {
+    elementKind: ElementKind<A>;
+    isEqual: boolean;
+  }
+  function isElementKindExpr<A extends AnyAux>(expr: ModelExpression<A>): expr is ElementKindExpr<A>;
+  interface ElementTagExpr<A extends AnyAux> {
+    elementTag: Tag<A>;
+    isEqual: boolean;
+  }
+  function isElementTagExpr<A extends AnyAux>(expr: ModelExpression<A>): expr is ElementTagExpr<A>;
+  type NonWildcard<A extends AnyAux = AnyAux> = ExclusiveUnion<{
+    Ref: Ref<A>;
+    ElementKind: ElementKindExpr<A>;
+    ElementTag: ElementTagExpr<A>;
+  }>;
+  interface Where<A extends AnyAux = AnyAux> {
+    where: {
+      expr: ExclusiveUnion<{
+        Wildcard: Wildcard;
+        Ref: Ref<A>;
+        ElementKind: ElementKindExpr<A>;
+        ElementTag: ElementTagExpr<A>;
+      }>;
+      condition: WhereOperator<A>;
+    };
+  }
+  function isWhere<A extends AnyAux>(expr: ModelExpression<A>): expr is ModelFqnExpr.Where<A>;
+  interface Custom<A extends AnyAux = AnyAux> {
+    custom: {
+      expr: OrWhere<A>;
+      title?: string;
+      description?: MarkdownOrString;
+      technology?: string;
+      notation?: string;
+      shape?: ElementShape;
+      color?: Color;
+      icon?: Icon;
+      iconColor?: Color;
+      iconSize?: ShapeSize;
+      iconPosition?: IconPosition;
+      border?: BorderStyle;
+      opacity?: number;
+      navigateTo?: StrictViewId<A>;
+      multiple?: boolean;
+      size?: ShapeSize;
+      padding?: ShapeSize;
+      textSize?: ShapeSize;
+    };
+  }
+  function isCustom<A extends AnyAux>(expr: ModelExpression<A>): expr is Custom<A>;
+  function is<A extends AnyAux>(expr: ModelExpression<A>): expr is ModelFqnExpr<A>;
+  type OrWhere<A extends AnyAux = AnyAux> = ExclusiveUnion<{
+    Wildcard: ModelFqnExpr.Wildcard;
+    Ref: ModelFqnExpr.Ref<A>;
+    ElementKind: ElementKindExpr<A>;
+    ElementTag: ElementTagExpr<A>;
+    Where: ModelFqnExpr.Where<A>;
+  }>;
+  type Any<A extends AnyAux = AnyAux> = ExclusiveUnion<{
+    Wildcard: Wildcard;
+    Ref: Ref<A>;
+    ElementKind: ElementKindExpr<A>;
+    ElementTag: ElementTagExpr<A>;
+    Where: Where<A>;
+    Custom: Custom<A>;
+  }>;
+  function unwrap<A extends AnyAux>(expr: ModelFqnExpr.Any<A>): Wildcard | Ref<A> | ElementKindExpr<A> | ElementTagExpr<A>;
+}
+type ModelFqnExpr<A extends AnyAux = AnyAux> = ExclusiveUnion<{
+  Wildcard: ModelFqnExpr.Wildcard;
+  Ref: ModelFqnExpr.Ref<A>;
+  ElementKind: ModelFqnExpr.ElementKindExpr<A>;
+  ElementTag: ModelFqnExpr.ElementTagExpr<A>;
+}>;
+declare namespace ModelRelationExpr {
+  type Endpoint<A extends AnyAux = AnyAux> = ModelFqnExpr.Where<A>['where']['expr'];
+  interface Direct<A extends AnyAux = AnyAux> {
+    source: Endpoint<A>;
+    target: Endpoint<A>;
+    isBidirectional?: boolean;
+  }
+  function isDirect<A extends AnyAux>(expr: ModelExpression<A>): expr is ModelRelationExpr.Direct<A>;
+  interface Incoming<A extends AnyAux = AnyAux> {
+    incoming: Endpoint<A>;
+  }
+  function isIncoming<A extends AnyAux>(expr: ModelExpression<A>): expr is ModelRelationExpr.Incoming<A>;
+  interface Outgoing<A extends AnyAux = AnyAux> {
+    outgoing: Endpoint<A>;
+  }
+  function isOutgoing<A extends AnyAux>(expr: ModelExpression<A>): expr is ModelRelationExpr.Outgoing<A>;
+  interface InOut<A extends AnyAux = AnyAux> {
+    inout: Endpoint<A>;
+  }
+  function isInOut<A extends AnyAux>(expr: ModelExpression<A>): expr is ModelRelationExpr.InOut<A>;
+  interface Where<A extends AnyAux = AnyAux> {
+    where: {
+      expr: ExclusiveUnion<{
+        Direct: ModelRelationExpr.Direct<A>;
+        Incoming: ModelRelationExpr.Incoming<A>;
+        Outgoing: ModelRelationExpr.Outgoing<A>;
+        InOut: ModelRelationExpr.InOut<A>;
+      }>;
+      condition: WhereOperator<A>;
+    };
+  }
+  function isWhere<A extends AnyAux>(expr: ModelExpression<A>): expr is ModelRelationExpr.Where<A>;
+  interface Custom<A extends AnyAux = AnyAux> {
+    customRelation: {
+      expr: OrWhere<A>;
+      title?: string;
+      description?: string;
+      technology?: string;
+      notation?: string;
+      navigateTo?: StrictViewId<A>;
+      notes?: string;
+      color?: Color;
+      line?: RelationshipLineType;
+      head?: RelationshipArrowType;
+      tail?: RelationshipArrowType;
+    };
+  }
+  function isCustom<A extends AnyAux>(expr: ModelExpression<A>): expr is Custom<A>;
+  function is<A extends AnyAux>(expr: ModelExpression<A>): expr is ModelRelationExpr<A>;
+  type OrWhere<A extends AnyAux = AnyAux> = ExclusiveUnion<{
+    Direct: Direct<A>;
+    Incoming: Incoming<A>;
+    Outgoing: Outgoing<A>;
+    InOut: InOut<A>;
+    Where: Where<A>;
+  }>;
+  type Any<A extends AnyAux = AnyAux> = ExclusiveUnion<{
+    Direct: Direct<A>;
+    Incoming: Incoming<A>;
+    Outgoing: Outgoing<A>;
+    InOut: InOut<A>;
+    Where: Where<A>;
+    Custom: Custom<A>;
+  }>;
+  function unwrap<A extends AnyAux>(expr: ModelRelationExpr.Any<A>): Direct<A> | Incoming<A> | Outgoing<A> | InOut<A>;
+}
+type ModelRelationExpr<A extends AnyAux = AnyAux> = ExclusiveUnion<{
+  Direct: ModelRelationExpr.Direct<A>;
+  Incoming: ModelRelationExpr.Incoming<A>;
+  Outgoing: ModelRelationExpr.Outgoing<A>;
+  InOut: ModelRelationExpr.InOut<A>;
+}>;
+/**
+ * Represents a version 2 expression which can be one of several types.
+ *
+ * @template D - The type for the deployment FQN, defaults to `Fqn`.
+ * @template M - The type for the model FQN, defaults to `Fqn`.
+ */
+type ModelExpression<A extends AnyAux = AnyAux> = ExclusiveUnion<{
+  Wildcard: ModelFqnExpr.Wildcard;
+  Ref: ModelFqnExpr.Ref<A>;
+  ElementKind: ModelFqnExpr.ElementKindExpr<A>;
+  ElementTag: ModelFqnExpr.ElementTagExpr<A>;
+  Custom: ModelFqnExpr.Custom<A>;
+  Direct: ModelRelationExpr.Direct<A>;
+  Incoming: ModelRelationExpr.Incoming<A>;
+  Outgoing: ModelRelationExpr.Outgoing<A>;
+  InOut: ModelRelationExpr.InOut<A>;
+  Where: ModelExpression.Where<A>;
+  CustomRelation: ModelRelationExpr.Custom<A>;
+}>;
+declare namespace ModelExpression {
+  type Where<A extends AnyAux = AnyAux> = ModelFqnExpr.Where<A> | ModelRelationExpr.Where<A>;
+  function isWhere<A extends AnyAux>(expr: ModelExpression<A>): expr is ModelExpression.Where<A>;
+  function isRelationWhere<A extends AnyAux>(expr: ModelExpression<A>): expr is ModelRelationExpr.Where<A>;
+  function isFqnExprWhere<A extends AnyAux>(expr: ModelExpression<A>): expr is ModelFqnExpr.Where<A>;
+  function isFqnExpr<A extends AnyAux>(expr: ModelExpression<A>): expr is ModelFqnExpr.Any<A>;
+  function isRelationExpr<A extends AnyAux>(expr: ModelExpression<A>): expr is ModelRelationExpr.Any<A>;
+}
+//#endregion
+export { ModelFqnExpr as n, ModelRelationExpr as r, ModelExpression as t };

package/dist/_chunks/expression-model.mjs

@@ -0,0 +1,103 @@
+import { t as FqnRef } from "./fqnRef.mjs";
+
+//#region src/types/expression-model.ts
+let ModelFqnExpr;
+(function(_ModelFqnExpr) {
+	function isWildcard(expr) {
+		return "wildcard" in expr && expr.wildcard === true;
+	}
+	_ModelFqnExpr.isWildcard = isWildcard;
+	function isModelRef(ref) {
+		return "ref" in ref && FqnRef.isModelRef(ref.ref);
+	}
+	_ModelFqnExpr.isModelRef = isModelRef;
+	function isElementKindExpr(expr) {
+		return "elementKind" in expr && "isEqual" in expr;
+	}
+	_ModelFqnExpr.isElementKindExpr = isElementKindExpr;
+	function isElementTagExpr(expr) {
+		return "elementTag" in expr && "isEqual" in expr;
+	}
+	_ModelFqnExpr.isElementTagExpr = isElementTagExpr;
+	function isWhere(expr) {
+		return "where" in expr && is(expr.where.expr);
+	}
+	_ModelFqnExpr.isWhere = isWhere;
+	function isCustom(expr) {
+		return "custom" in expr && (is(expr.custom.expr) || isWhere(expr.custom.expr));
+	}
+	_ModelFqnExpr.isCustom = isCustom;
+	function is(expr) {
+		return isWildcard(expr) || isModelRef(expr) || isElementKindExpr(expr) || isElementTagExpr(expr);
+	}
+	_ModelFqnExpr.is = is;
+	function unwrap(expr) {
+		if (isCustom(expr)) expr = expr.custom.expr;
+		if (isWhere(expr)) expr = expr.where.expr;
+		return expr;
+	}
+	_ModelFqnExpr.unwrap = unwrap;
+})(ModelFqnExpr || (ModelFqnExpr = {}));
+let ModelRelationExpr;
+(function(_ModelRelationExpr) {
+	function isDirect(expr) {
+		return "source" in expr && "target" in expr;
+	}
+	_ModelRelationExpr.isDirect = isDirect;
+	function isIncoming(expr) {
+		return "incoming" in expr;
+	}
+	_ModelRelationExpr.isIncoming = isIncoming;
+	function isOutgoing(expr) {
+		return "outgoing" in expr;
+	}
+	_ModelRelationExpr.isOutgoing = isOutgoing;
+	function isInOut(expr) {
+		return "inout" in expr;
+	}
+	_ModelRelationExpr.isInOut = isInOut;
+	function isWhere(expr) {
+		return "where" in expr && (isDirect(expr.where.expr) || isIncoming(expr.where.expr) || isOutgoing(expr.where.expr) || isInOut(expr.where.expr));
+	}
+	_ModelRelationExpr.isWhere = isWhere;
+	function isCustom(expr) {
+		return "customRelation" in expr;
+	}
+	_ModelRelationExpr.isCustom = isCustom;
+	function is(expr) {
+		return isDirect(expr) || isIncoming(expr) || isOutgoing(expr) || isInOut(expr);
+	}
+	_ModelRelationExpr.is = is;
+	function unwrap(expr) {
+		if (isCustom(expr)) expr = expr.customRelation.expr;
+		if (isWhere(expr)) expr = expr.where.expr;
+		return expr;
+	}
+	_ModelRelationExpr.unwrap = unwrap;
+})(ModelRelationExpr || (ModelRelationExpr = {}));
+let ModelExpression;
+(function(_ModelExpression) {
+	function isWhere(expr) {
+		return "where" in expr;
+	}
+	_ModelExpression.isWhere = isWhere;
+	function isRelationWhere(expr) {
+		return ModelRelationExpr.isWhere(expr);
+	}
+	_ModelExpression.isRelationWhere = isRelationWhere;
+	function isFqnExprWhere(expr) {
+		return ModelFqnExpr.isWhere(expr);
+	}
+	_ModelExpression.isFqnExprWhere = isFqnExprWhere;
+	function isFqnExpr(expr) {
+		return ModelFqnExpr.is(expr) || ModelFqnExpr.isWhere(expr) || ModelFqnExpr.isCustom(expr);
+	}
+	_ModelExpression.isFqnExpr = isFqnExpr;
+	function isRelationExpr(expr) {
+		return ModelRelationExpr.is(expr) || ModelRelationExpr.isWhere(expr) || ModelRelationExpr.isCustom(expr);
+	}
+	_ModelExpression.isRelationExpr = isRelationExpr;
+})(ModelExpression || (ModelExpression = {}));
+
+//#endregion
+export { ModelFqnExpr as n, ModelRelationExpr as r, ModelExpression as t };

package/dist/_chunks/expression.d.mts

@@ -0,0 +1,347 @@
+import { H as StrictViewId, U as Tag, W as Tags, m as ElementKind, n as Any, t as AllKinds, vt as ExclusiveUnion, wt as NonEmptyArray } from "./_aux.mjs";
+import { f as MarkdownOrString, u as Icon } from "./scalar.mjs";
+import { t as FqnRef } from "./fqnRef.mjs";
+import { Tagged, TupleToUnion } from "type-fest";
+
+//#region ../../styled-system/preset/src/defaults/types.d.ts
+declare const Sizes: readonly ["xs", "sm", "md", "lg", "xl"];
+declare const IconPositions: readonly ["left", "right", "top", "bottom"];
+declare const BorderStyles: readonly ["solid", "dashed", "dotted", "none"];
+declare const ElementShapes: readonly ["rectangle", "person", "browser", "mobile", "cylinder", "storage", "queue", "bucket", "document"];
+declare const ThemeColors: readonly ["amber", "blue", "gray", "slate", "green", "indigo", "muted", "primary", "red", "secondary", "sky"];
+declare const DefaultTagColors: readonly ["tomato", "grass", "blue", "ruby", "orange", "indigo", "pink", "teal", "purple", "amber", "crimson", "red", "lime", "yellow", "violet"];
+//#endregion
+//#region src/styles/types.d.ts
+/**
+ * For padding, margin, etc.
+ */
+type Size = typeof Sizes[number];
+type TextSize = Size;
+type ShapeSize = Size;
+type SpacingSize = Size;
+type IconSize = Size;
+type IconPosition = typeof IconPositions[number];
+type BorderStyle = typeof BorderStyles[number];
+type ElementShape = typeof ElementShapes[number];
+type HexColor = `#${string}`;
+type ColorLiteral = HexColor | `rgb(${number},${number},${number})` | `rgba(${number},${number},${number},${number})`;
+type RelationshipLineType = 'dashed' | 'solid' | 'dotted';
+declare const RelationshipArrowTypes: readonly ["none", "normal", "onormal", "dot", "odot", "diamond", "odiamond", "crow", "open", "vee"];
+type RelationshipArrowType = TupleToUnion<typeof RelationshipArrowTypes>;
+type ThemeColor = typeof ThemeColors[number];
+declare function isThemeColor(color: string): color is ThemeColor;
+type CustomColorDefinitions = {
+  [key: string]: ThemeColorValues;
+};
+type CustomColor = Tagged<string, 'CustomColor'>;
+declare function isCustomColor(color: string): color is CustomColor;
+type Color = ThemeColor | CustomColor;
+interface ElementColorValues {
+  readonly fill: ColorLiteral;
+  readonly stroke: ColorLiteral;
+  readonly hiContrast: ColorLiteral;
+  readonly loContrast: ColorLiteral;
+}
+interface RelationshipColorValues {
+  readonly line: ColorLiteral;
+  readonly labelBg: ColorLiteral;
+  readonly label: ColorLiteral;
+}
+interface ThemeColorValues {
+  readonly elements: ElementColorValues;
+  readonly relationships: RelationshipColorValues;
+}
+/**
+ * Default style values for elements, groups and relationships
+ */
+interface LikeC4StyleDefaults {
+  readonly color: ThemeColor;
+  readonly size: ShapeSize;
+  readonly shape: ElementShape;
+  readonly opacity?: number;
+  readonly border?: BorderStyle;
+  readonly padding?: SpacingSize;
+  readonly text?: TextSize;
+  readonly iconPosition?: IconPosition;
+  /**
+   * Default style values for groups
+   * If not specified, the default values for elements are used
+   */
+  readonly group?: {
+    readonly color?: ThemeColor;
+    readonly opacity?: number;
+    readonly border?: BorderStyle;
+  };
+  readonly relationship: {
+    readonly color: ThemeColor;
+    readonly line: RelationshipLineType;
+    readonly arrow: RelationshipArrowType;
+  };
+}
+interface LikeC4Theme {
+  readonly colors: Readonly<Record<ThemeColor, ThemeColorValues>>;
+  readonly sizes: Readonly<Record<ShapeSize, {
+    readonly width: number;
+    readonly height: number;
+  }>>;
+  readonly spacing: Readonly<Record<SpacingSize, number>>;
+  readonly textSizes: Readonly<Record<TextSize, number>>;
+  readonly iconSizes: Readonly<Record<IconSize, number>>;
+}
+interface LikeC4StylesConfig {
+  readonly theme: LikeC4Theme;
+  readonly defaults: LikeC4StyleDefaults;
+}
+//#endregion
+//#region src/types/operators.d.ts
+type EqualOperator<V> = {
+  eq: V;
+  neq?: never;
+} | {
+  eq?: never;
+  neq: V;
+};
+type AllNever = {
+  not?: never;
+  and?: never;
+  or?: never;
+  tag?: never;
+  kind?: never;
+  participant?: never;
+  operator?: never;
+};
+type TagEqual<A extends Any> = Omit<AllNever, 'tag'> & {
+  tag: EqualOperator<Tag<A>> | Tag<A>;
+};
+declare function isTagEqual<A extends Any>(operator: WhereOperator<A>): operator is TagEqual<A>;
+type KindEqual<A extends Any> = Omit<AllNever, 'kind'> & {
+  kind: EqualOperator<AllKinds<A>> | AllKinds<A>;
+};
+declare function isKindEqual<A extends Any>(operator: WhereOperator<A>): operator is KindEqual<A>;
+type Participant = 'source' | 'target';
+type ParticipantOperator<A extends Any> = Omit<AllNever, 'participant' | 'operator'> & {
+  participant: Participant;
+  operator: KindEqual<A> | TagEqual<A>;
+};
+declare function isParticipantOperator<A extends Any>(operator: WhereOperator<A>): operator is ParticipantOperator<A>;
+type NotOperator<A extends Any> = Omit<AllNever, 'not'> & {
+  not: WhereOperator<A>;
+};
+declare function isNotOperator<A extends Any>(operator: WhereOperator<A>): operator is NotOperator<A>;
+type AndOperator<A extends Any> = Omit<AllNever, 'and'> & {
+  and: NonEmptyArray<WhereOperator<A>>;
+};
+declare function isAndOperator<A extends Any>(operator: WhereOperator<A>): operator is AndOperator<A>;
+type OrOperator<A extends Any> = Omit<AllNever, 'or'> & {
+  or: NonEmptyArray<WhereOperator<A>>;
+};
+declare function isOrOperator<A extends Any>(operator: WhereOperator<A>): operator is OrOperator<A>;
+type WhereOperator<A extends Any = Any> = TagEqual<A> | KindEqual<A> | ParticipantOperator<A> | NotOperator<A> | AndOperator<A> | OrOperator<A>;
+type Filterable<A extends Any> = {
+  tags?: Tags<A> | null | undefined;
+  kind?: AllKinds<A> | null | undefined;
+  source?: Filterable<A>;
+  target?: Filterable<A>;
+};
+type OperatorPredicate<A extends Any> = (value: Filterable<A>) => boolean;
+declare function whereOperatorAsPredicate<A extends Any>(operator: WhereOperator<A>): OperatorPredicate<A>;
+//#endregion
+//#region src/types/expression.d.ts
+type AnyAux = Any;
+type PredicateSelector = 'children' | 'expanded' | 'descendants';
+declare namespace FqnExpr {
+  type Wildcard = {
+    wildcard: true;
+  };
+  function isWildcard<A extends AnyAux>(expr: Expression<A>): expr is FqnExpr.Wildcard;
+  interface ModelRef<M extends AnyAux = AnyAux> {
+    ref: FqnRef.ModelRef<M>;
+    selector?: PredicateSelector;
+  }
+  function isModelRef<A extends AnyAux>(ref: Expression<A>): ref is FqnExpr.ModelRef<A>;
+  interface DeploymentRef<A extends AnyAux = AnyAux> {
+    ref: FqnRef.DeploymentRef<A>;
+    selector?: PredicateSelector;
+  }
+  function isDeploymentRef<A extends AnyAux>(expr: Expression<A>): expr is FqnExpr.DeploymentRef<A>;
+  interface ElementKindExpr<A extends AnyAux = AnyAux> {
+    elementKind: ElementKind<A>;
+    isEqual: boolean;
+  }
+  function isElementKindExpr<A extends AnyAux>(expr: Expression<A>): expr is ElementKindExpr<A>;
+  interface ElementTagExpr<A extends AnyAux = AnyAux> {
+    elementTag: Tag<A>;
+    isEqual: boolean;
+  }
+  function isElementTagExpr<A extends AnyAux>(expr: Expression<A>): expr is ElementTagExpr<A>;
+  type NonWildcard<A extends AnyAux = AnyAux> = ExclusiveUnion<{
+    ModelRef: ModelRef<A>;
+    DeploymentRef: DeploymentRef<A>;
+    ElementKind: ElementKindExpr<A>;
+    ElementTag: ElementTagExpr<A>;
+  }>;
+  interface Where<A extends AnyAux = AnyAux> {
+    where: {
+      expr: ExclusiveUnion<{
+        Wildcard: Wildcard;
+        ModelRef: ModelRef<A>;
+        DeploymentRef: DeploymentRef<A>;
+        ElementKind: ElementKindExpr<A>;
+        ElementTag: ElementTagExpr<A>;
+      }>;
+      condition: WhereOperator<A>;
+    };
+  }
+  function isWhere<A extends AnyAux>(expr: Expression<A>): expr is FqnExpr.Where<A>;
+  interface Custom<A extends AnyAux = AnyAux> {
+    custom: {
+      expr: OrWhere<A>;
+      title?: string;
+      description?: MarkdownOrString;
+      technology?: string;
+      notation?: string;
+      shape?: ElementShape;
+      color?: Color;
+      icon?: Icon;
+      iconColor?: Color;
+      iconSize?: ShapeSize;
+      iconPosition?: IconPosition;
+      border?: BorderStyle;
+      opacity?: number;
+      navigateTo?: StrictViewId<A>;
+      multiple?: boolean;
+      size?: ShapeSize;
+      padding?: ShapeSize;
+      textSize?: ShapeSize;
+    };
+  }
+  function isCustom<A extends AnyAux>(expr: Expression<A>): expr is Custom<A>;
+  function is<A extends AnyAux>(expr: Expression<A>): expr is FqnExpr<A>;
+  type OrWhere<A extends AnyAux = AnyAux> = ExclusiveUnion<{
+    Wildcard: FqnExpr.Wildcard;
+    ModelRef: FqnExpr.ModelRef<A>;
+    DeploymentRef: FqnExpr.DeploymentRef<A>;
+    ElementKind: ElementKindExpr<A>;
+    ElementTag: ElementTagExpr<A>;
+    Where: FqnExpr.Where<A>;
+  }>;
+  type Any<A extends AnyAux = AnyAux> = ExclusiveUnion<{
+    Wildcard: Wildcard;
+    ModelRef: ModelRef<A>;
+    DeploymentRef: DeploymentRef<A>;
+    ElementKind: ElementKindExpr<A>;
+    ElementTag: ElementTagExpr<A>;
+    Where: Where<A>;
+    Custom: Custom<A>;
+  }>;
+  function unwrap<A extends AnyAux>(expr: FqnExpr.Any<A>): Wildcard | ModelRef<A> | DeploymentRef<A> | ElementKindExpr<A> | ElementTagExpr<A>;
+}
+type FqnExpr<A extends AnyAux = AnyAux> = ExclusiveUnion<{
+  Wildcard: FqnExpr.Wildcard;
+  ModelRef: FqnExpr.ModelRef<A>;
+  DeploymentRef: FqnExpr.DeploymentRef<A>;
+  ElementKind: FqnExpr.ElementKindExpr<A>;
+  ElementTag: FqnExpr.ElementTagExpr<A>;
+}>;
+declare namespace RelationExpr {
+  type Endpoint<A extends AnyAux = AnyAux> = FqnExpr.Where<A>['where']['expr'];
+  interface Direct<A extends AnyAux = AnyAux> {
+    source: Endpoint<A>;
+    target: Endpoint<A>;
+    isBidirectional?: boolean;
+  }
+  function isDirect<A extends AnyAux>(expr: Expression<A>): expr is RelationExpr.Direct<A>;
+  interface Incoming<A extends AnyAux = AnyAux> {
+    incoming: Endpoint<A>;
+  }
+  function isIncoming<A extends AnyAux>(expr: Expression<A>): expr is RelationExpr.Incoming<A>;
+  interface Outgoing<A extends AnyAux = AnyAux> {
+    outgoing: Endpoint<A>;
+  }
+  function isOutgoing<A extends AnyAux>(expr: Expression<A>): expr is RelationExpr.Outgoing<A>;
+  interface InOut<A extends AnyAux = AnyAux> {
+    inout: Endpoint<A>;
+  }
+  function isInOut<A extends AnyAux>(expr: Expression<A>): expr is RelationExpr.InOut<A>;
+  interface Where<A extends AnyAux = AnyAux> {
+    where: {
+      expr: ExclusiveUnion<{
+        Direct: RelationExpr.Direct<A>;
+        Incoming: RelationExpr.Incoming<A>;
+        Outgoing: RelationExpr.Outgoing<A>;
+        InOut: RelationExpr.InOut<A>;
+      }>;
+      condition: WhereOperator<A>;
+    };
+  }
+  function isWhere<A extends AnyAux>(expr: Expression<A>): expr is RelationExpr.Where<A>;
+  interface Custom<A extends AnyAux = AnyAux> {
+    customRelation: {
+      expr: OrWhere<A>;
+      title?: string;
+      description?: string;
+      technology?: string;
+      notation?: string;
+      navigateTo?: StrictViewId<A>;
+      notes?: string;
+      color?: Color;
+      line?: RelationshipLineType;
+      head?: RelationshipArrowType;
+      tail?: RelationshipArrowType;
+    };
+  }
+  function isCustom<A extends AnyAux>(expr: Expression<A>): expr is Custom<A>;
+  function is<A extends AnyAux>(expr: Expression<A>): expr is RelationExpr<A>;
+  type OrWhere<A extends AnyAux = AnyAux> = ExclusiveUnion<{
+    Direct: Direct<A>;
+    Incoming: Incoming<A>;
+    Outgoing: Outgoing<A>;
+    InOut: InOut<A>;
+    Where: Where<A>;
+  }>;
+  type Any<A extends AnyAux = AnyAux> = ExclusiveUnion<{
+    Direct: Direct<A>;
+    Incoming: Incoming<A>;
+    Outgoing: Outgoing<A>;
+    InOut: InOut<A>;
+    Where: Where<A>;
+    Custom: Custom<A>;
+  }>;
+  function unwrap<A extends AnyAux>(expr: RelationExpr.Any<A>): Direct<A> | Incoming<A> | Outgoing<A> | InOut<A>;
+}
+type RelationExpr<A extends AnyAux = AnyAux> = ExclusiveUnion<{
+  Direct: RelationExpr.Direct<A>;
+  Incoming: RelationExpr.Incoming<A>;
+  Outgoing: RelationExpr.Outgoing<A>;
+  InOut: RelationExpr.InOut<A>;
+}>;
+/**
+ * Represents a version 2 expression which can be one of several types.
+ *
+ * @template D - The type for the deployment FQN, defaults to `Fqn`.
+ * @template M - The type for the model FQN, defaults to `Fqn`.
+ */
+type Expression<A extends AnyAux = AnyAux> = ExclusiveUnion<{
+  Wildcard: FqnExpr.Wildcard;
+  ModelRef: FqnExpr.ModelRef<A>;
+  DeploymentRef: FqnExpr.DeploymentRef<A>;
+  ElementKind: FqnExpr.ElementKindExpr<A>;
+  ElementTag: FqnExpr.ElementTagExpr<A>;
+  Custom: FqnExpr.Custom<A>;
+  Direct: RelationExpr.Direct<A>;
+  Incoming: RelationExpr.Incoming<A>;
+  Outgoing: RelationExpr.Outgoing<A>;
+  InOut: RelationExpr.InOut<A>;
+  Where: Expression.Where<A>;
+  CustomRelation: RelationExpr.Custom<A>;
+}>;
+declare namespace Expression {
+  type Where<A extends AnyAux = AnyAux> = FqnExpr.Where<A> | RelationExpr.Where<A>;
+  function isWhere<A extends AnyAux>(expr: Expression<A>): expr is Expression.Where<A>;
+  function isRelationWhere<A extends AnyAux>(expr: Expression<A>): expr is RelationExpr.Where<A>;
+  function isFqnExprWhere<A extends AnyAux>(expr: Expression<A>): expr is FqnExpr.Where<A>;
+  function isFqnExpr<A extends AnyAux>(expr: Expression<A>): expr is FqnExpr.Any<A>;
+  function isRelation<A extends AnyAux>(expr: Expression<A>): expr is RelationExpr.Any<A>;
+}
+//#endregion
+export { ThemeColors as $, HexColor as A, ShapeSize as B, BorderStyle as C, CustomColorDefinitions as D, CustomColor as E, LikeC4Theme as F, ThemeColorValues as G, SpacingSize as H, RelationshipArrowType as I, BorderStyles as J, isCustomColor as K, RelationshipArrowTypes as L, IconSize as M, LikeC4StyleDefaults as N, ElementColorValues as O, LikeC4StylesConfig as P, Sizes as Q, RelationshipColorValues as R, whereOperatorAsPredicate as S, ColorLiteral as T, TextSize as U, Size as V, ThemeColor as W, ElementShapes as X, DefaultTagColors as Y, IconPositions as Z, isKindEqual as _, AndOperator as a, isParticipantOperator as b, KindEqual as c, OrOperator as d, Participant as f, isAndOperator as g, WhereOperator as h, RelationExpr as i, IconPosition as j, ElementShape as k, NotOperator as l, TagEqual as m, FqnExpr as n, EqualOperator as o, ParticipantOperator as p, isThemeColor as q, PredicateSelector as r, Filterable as s, Expression as t, OperatorPredicate as u, isNotOperator as v, Color as w, isTagEqual as x, isOrOperator as y, RelationshipLineType as z };