@likec4/core 1.46.4 → 1.48.0

package/dist/_chunks/index2.d.mts

@@ -0,0 +1,937 @@
+import { $ as WithNotation, D as Never, E as MetadataKey, F as SpecAux, G as Unknown, H as StrictViewId, J as UnknownParsed, K as UnknownComputed, N as RelationKind, O as NodeId, Q as WithMetadata, St as Link, Tt as NonEmptyReadonlyArray, U as Tag, X as WithDescriptionAndTech, Y as ViewId, c as Aux, d as DeploymentKind, dt as ExtractOnStage, et as WithOptionalLinks, f as EdgeId, ft as ModelStage, h as Fqn, ht as _type, i as AnyLayouted, j as ProjectId, l as DeploymentFqn, m as ElementKind, mt as _stage, n as Any, nt as WithTags, o as AnyParsed, p as ElementId, pt as _layout, q as UnknownLayouted, r as AnyComputed, tt as WithOptionalTags, u as DeploymentId, vt as ExclusiveUnion, wt as NonEmptyArray, xt as KeysOf } from "./_aux.mjs";
+import { C as ViewId$1, S as Tag$1, a as EdgeId$1, f as MarkdownOrString, g as RelationId, h as ProjectId$1, p as NodeId$1, r as DeploymentFqn$1, s as Fqn$1, u as Icon, x as StepEdgeKind } from "./scalar.mjs";
+import { a as Point, i as BBox, s as XYPoint } from "./index.mjs";
+import { B as ShapeSize, C as BorderStyle, D as CustomColorDefinitions, F as LikeC4Theme, H as SpacingSize, I as RelationshipArrowType, M as IconSize, N as LikeC4StyleDefaults, T as ColorLiteral, U as TextSize, W as ThemeColor, j as IconPosition, k as ElementShape, n as FqnExpr, t as Expression, w as Color, z as RelationshipLineType } from "./expression.mjs";
+import { t as FqnRef } from "./fqnRef.mjs";
+import { n as ModelFqnExpr, t as ModelExpression } from "./expression-model.mjs";
+import { IsAny, IsNever, NonEmptyTuple, PartialDeep, Simplify, Tagged, WritableDeep } from "type-fest";
+
+//#region src/types/view-common.d.ts
+interface AnyIncludePredicate<Expr> {
+  include: Expr[];
+  exclude?: never;
+}
+interface AnyExcludePredicate<Expr> {
+  include?: never;
+  exclude: Expr[];
+}
+interface AnyViewRuleStyle<Expr> {
+  targets: Expr[];
+  notation?: string;
+  style: {
+    border?: BorderStyle;
+    opacity?: number;
+    multiple?: boolean;
+    size?: ShapeSize;
+    padding?: SpacingSize;
+    textSize?: TextSize;
+    color?: Color;
+    shape?: ElementShape;
+    icon?: Icon;
+    iconColor?: Color;
+    iconSize?: IconSize;
+    iconPosition?: IconPosition;
+  };
+}
+interface ViewRuleGlobalStyle {
+  styleId: GlobalStyleID;
+}
+declare function isViewRuleGlobalStyle(rule: object): rule is ViewRuleGlobalStyle;
+interface ViewRuleGlobalPredicateRef {
+  predicateId: GlobalPredicateId;
+}
+declare function isViewRuleGlobalPredicateRef(rule: object): rule is ViewRuleGlobalPredicateRef;
+type RankValue = 'max' | 'min' | 'same' | 'sink' | 'source';
+interface ViewRuleRank<Expr> {
+  targets: Expr[];
+  rank: RankValue;
+}
+type AutoLayoutDirection = 'TB' | 'BT' | 'LR' | 'RL';
+declare function isAutoLayoutDirection(autoLayout: unknown): autoLayout is AutoLayoutDirection;
+interface ViewRuleAutoLayout {
+  direction: AutoLayoutDirection;
+  nodeSep?: number;
+  rankSep?: number;
+}
+declare function isViewRuleAutoLayout(rule: object): rule is ViewRuleAutoLayout;
+interface ViewAutoLayout {
+  direction: ViewRuleAutoLayout['direction'];
+  rankSep?: number;
+  nodeSep?: number;
+}
+/**
+ * v1 Manual layout of a view, stored in the block comment to the view definition.
+ * Keeping this type for backward compatibility and migration purposes.
+ *
+ * @deprecated Use {@link ViewManualLayoutSnapshot} instead
+ */
+type ViewManualLayout = {
+  readonly hash: string;
+  readonly x: number;
+  readonly y: number;
+  readonly width: number;
+  readonly height: number;
+  readonly autoLayout: ViewAutoLayout;
+  readonly nodes: Record<string, {
+    isCompound: boolean;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+  }>;
+  readonly edges: Record<string, {
+    points: NonEmptyArray<Point>;
+    controlPoints?: NonEmptyArray<XYPoint>;
+    labelBBox?: BBox;
+  }>;
+};
+type ViewType = 'element' | 'dynamic' | 'deployment';
+interface BaseViewProperties<A extends Any> extends WithOptionalTags<A>, WithOptionalLinks {
+  readonly id: StrictViewId<A>;
+  readonly title: string | null;
+  readonly description: MarkdownOrString | null;
+  /**
+   * Source file containing this view, relative to the project root.
+   * Undefined if the view is auto-generated.
+   */
+  readonly sourcePath?: string | undefined;
+}
+interface BaseParsedViewProperties<A extends Any> extends BaseViewProperties<A> {
+  /**
+   * Internal field to identify the stage of the view.
+   * This is used to create the correct type of the view.
+   */
+  readonly [_stage]: 'parsed';
+  /**
+   * URI to the source file of this view.
+   * Undefined if the view is auto-generated.
+   */
+  readonly docUri?: string | undefined;
+}
+type NodeNotation = {
+  kinds: string[];
+  shape: ElementShape;
+  color: Color;
+  title: string;
+};
+interface ViewWithNotation {
+  notation?: {
+    nodes: NodeNotation[];
+  };
+}
+interface ViewWithHash {
+  /**
+   * Hash of the view object.
+   * This is used to detect changes in layout
+   */
+  hash: string;
+}
+//#endregion
+//#region src/types/view-parsed.element.d.ts
+/**
+ * Predicates scoped to logical model
+ */
+interface ElementViewIncludePredicate<A extends Any = Any> extends AnyIncludePredicate<ModelExpression<A>> {}
+interface ElementViewExcludePredicate<A extends Any = Any> extends AnyExcludePredicate<ModelExpression<A>> {}
+type ElementViewPredicate<A extends Any = Any> = ElementViewIncludePredicate<A> | ElementViewExcludePredicate<A>;
+interface ElementViewRuleGroup<A extends Any = Any> {
+  groupRules: Array<ElementViewPredicate<A> | ElementViewRuleGroup<A>>;
+  title: string | null;
+  color?: Color;
+  border?: BorderStyle;
+  opacity?: number;
+  multiple?: boolean;
+  size?: ShapeSize;
+  padding?: SpacingSize;
+  textSize?: TextSize;
+}
+declare function isViewRuleGroup<A extends Any>(rule: ElementViewRule<A>): rule is ElementViewRuleGroup<A>;
+interface ElementViewRuleStyle<A extends Any = Any> extends AnyViewRuleStyle<ModelFqnExpr<A>> {}
+interface ElementViewRuleRank<A extends Any = Any> extends ViewRuleRank<ModelFqnExpr<A>> {}
+declare function isViewRuleRank<A extends Any>(rule: ElementViewRule<A>): rule is ElementViewRuleRank<A>;
+type ElementViewRule<A extends Any = Any> = ExclusiveUnion<{
+  IncludePredicate: ElementViewIncludePredicate<A>;
+  ExcludePredicate: ElementViewExcludePredicate<A>;
+  Group: ElementViewRuleGroup<A>;
+  Style: ElementViewRuleStyle<A>;
+  GlobalStyle: ViewRuleGlobalStyle;
+  GlobalPredicateRef: ViewRuleGlobalPredicateRef;
+  AutoLayout: ViewRuleAutoLayout;
+  Rank: ElementViewRuleRank<A>;
+}>;
+interface ParsedElementView<A extends Any = Any> extends BaseParsedViewProperties<A> {
+  [_type]: 'element';
+  readonly rules: ElementViewRule<A>[];
+  readonly viewOf?: Fqn<A>;
+  readonly extends?: StrictViewId<A>;
+}
+//#endregion
+//#region src/types/view-parsed.dynamic.d.ts
+interface DynamicStep<A extends Any = Any> {
+  readonly source: Fqn<A>;
+  readonly target: Fqn<A>;
+  readonly title?: string | null;
+  readonly kind?: RelationKind<A>;
+  readonly description?: MarkdownOrString;
+  readonly technology?: string;
+  readonly notation?: string;
+  readonly notes?: MarkdownOrString;
+  readonly color?: Color;
+  readonly line?: RelationshipLineType;
+  readonly head?: RelationshipArrowType;
+  readonly tail?: RelationshipArrowType;
+  readonly isBackward?: boolean;
+  readonly navigateTo?: StrictViewId<A>;
+  /**
+   * Path to the AST node relative to the view body ast
+   * Used to locate the step in the source code
+   */
+  readonly astPath: string;
+}
+interface DynamicStepsSeries<A extends Any = Any> {
+  readonly seriesId: string;
+  readonly __series: NonEmptyReadonlyArray<DynamicStep<A>>;
+}
+interface DynamicStepsParallel<A extends Any = Any> {
+  readonly parallelId: string;
+  readonly __parallel: NonEmptyReadonlyArray<DynamicStep<A> | DynamicStepsSeries<A>>;
+}
+declare function getParallelStepsPrefix(id: string): string | null;
+type DynamicViewStep<A extends Any = Any> = ExclusiveUnion<{
+  Step: DynamicStep<A>;
+  Series: DynamicStepsSeries<A>;
+  Parallel: DynamicStepsParallel<A>;
+}>;
+declare function isDynamicStep<A extends Any>(step: DynamicViewStep<A> | undefined): step is DynamicStep<A>;
+declare function isDynamicStepsParallel<A extends Any>(step: DynamicViewStep<A> | undefined): step is DynamicStepsParallel<A>;
+declare function isDynamicStepsSeries<A extends Any>(step: DynamicViewStep<A> | undefined): step is DynamicStepsSeries<A>;
+interface DynamicViewIncludeRule<A extends Any = Any> {
+  include: ModelFqnExpr.Any<A>[];
+}
+type DynamicViewRule<A extends Any = Any> = ExclusiveUnion<{
+  Include: DynamicViewIncludeRule<A>;
+  GlobalPredicateRef: ViewRuleGlobalPredicateRef;
+  ElementViewRuleStyle: ElementViewRuleStyle<A>;
+  GlobalStyle: ViewRuleGlobalStyle;
+  AutoLayout: ViewRuleAutoLayout;
+}>;
+type DynamicViewDisplayVariant = 'diagram' | 'sequence';
+interface ParsedDynamicView<A extends Any = Any> extends BaseParsedViewProperties<A> {
+  [_type]: 'dynamic';
+  /**
+   * How to display the dynamic view
+   * - `diagram`: display as a regular likec4 view
+   * - `sequence`: display as a sequence diagram
+   *
+   * @default 'diagram'
+   */
+  readonly variant?: DynamicViewDisplayVariant;
+  readonly steps: DynamicViewStep<A>[];
+  readonly rules: DynamicViewRule<A>[];
+}
+//#endregion
+//#region src/types/global.d.ts
+type GlobalPredicateId = Tagged<string, 'GlobalPredicateId'>;
+type GlobalPredicates<A extends Any = Any> = NonEmptyArray<ElementViewPredicate<A>>;
+type GlobalDynamicPredicates<A extends Any = Any> = NonEmptyArray<DynamicViewIncludeRule<A>>;
+type GlobalStyleID = Tagged<string, 'GlobalStyleID'>;
+type GlobalStyles<A extends Any = Any> = NonEmptyTuple<ElementViewRuleStyle<A>>;
+interface ModelGlobals<A extends Any = Any> {
+  readonly predicates: Record<GlobalPredicateId, GlobalPredicates<A>>;
+  readonly dynamicPredicates: Record<GlobalPredicateId, GlobalDynamicPredicates<A>>;
+  readonly styles: Record<GlobalStyleID, GlobalStyles<A>>;
+}
+//#endregion
+//#region src/types/model-logical.d.ts
+interface ElementStyle {
+  readonly icon?: Icon;
+  readonly iconColor?: Color;
+  readonly iconSize?: IconSize;
+  readonly iconPosition?: IconPosition;
+  readonly shape?: ElementShape;
+  readonly color?: Color;
+  readonly border?: BorderStyle;
+  /**
+   * In percentage 0-100, 0 is fully transparent
+   *
+   * @default 100
+   */
+  readonly opacity?: number;
+  /**
+   * If true, the element is rendered as multiple shapes
+   * @default false
+   */
+  readonly multiple?: boolean;
+  /**
+   * Shape size
+   *
+   * @default 'md'
+   */
+  readonly size?: ShapeSize;
+  readonly padding?: SpacingSize;
+  readonly textSize?: TextSize;
+}
+type WithSizes = Pick<ElementStyle, 'size' | 'padding' | 'textSize' | 'iconSize'>;
+/**
+ * Ensures that the sizes are set to default values if they are not set
+ */
+declare function ensureSizes<S extends WithSizes>({
+  size,
+  padding,
+  textSize,
+  iconSize,
+  ...rest
+}: S, defaultSize?: "xs" | "sm" | "md" | "lg" | "xl"): Omit<S, keyof WithSizes> & Required<WithSizes>;
+interface Element<A extends Any = Any> extends WithDescriptionAndTech, WithOptionalTags<A>, WithOptionalLinks, WithMetadata<A>, WithNotation {
+  readonly id: Fqn<A>;
+  readonly kind: ElementKind<A>;
+  readonly title: string;
+  readonly style: ElementStyle;
+}
+interface AbstractRelationship<A extends Any> extends WithDescriptionAndTech, WithOptionalTags<A>, WithOptionalLinks, WithMetadata<A> {
+  readonly id: RelationId;
+  readonly title?: string | null;
+  readonly kind?: RelationKind<A>;
+  readonly color?: Color;
+  readonly line?: RelationshipLineType;
+  readonly head?: RelationshipArrowType;
+  readonly tail?: RelationshipArrowType;
+  readonly navigateTo?: StrictViewId<A>;
+}
+/**
+ * Relationship between two model elements
+ */
+interface Relationship<A extends Any = Any> extends AbstractRelationship<A> {
+  readonly source: FqnRef.ModelRef<A>;
+  readonly target: FqnRef.ModelRef<A>;
+}
+/**
+ * Backward compatibility alias
+ * @deprecated Use {@link Relationship} instead
+ */
+type ModelRelation<A extends Any = Any> = Relationship<A>;
+//#endregion
+//#region src/types/model-deployment.d.ts
+interface DeploymentNode<A extends Any = Unknown> extends WithDescriptionAndTech, WithOptionalTags<A>, WithOptionalLinks, WithMetadata<A>, WithNotation {
+  element?: never;
+  readonly id: DeploymentFqn<A>;
+  readonly kind: DeploymentKind<A>;
+  readonly title: string;
+  readonly style: ElementStyle;
+}
+interface DeployedInstance<A extends Any = Unknown> extends WithDescriptionAndTech, WithOptionalTags<A>, WithOptionalLinks, WithMetadata<A>, WithNotation {
+  kind?: never;
+  /**
+   * Format: `<DeploymentNode Fqn>.<Instance Id>`
+   * i.e parent fqn is deployment target
+   */
+  readonly id: DeploymentFqn<A>;
+  readonly element: Fqn<A>;
+  readonly title?: string;
+  readonly style: ElementStyle;
+}
+type DeploymentElement<A extends Any = Unknown> = DeploymentNode<A> | DeployedInstance<A>;
+type DeploymentElementRef<A extends Any = Unknown> = {
+  readonly id: DeploymentFqn<A>;
+  readonly element?: Fqn<A>;
+};
+declare function isDeploymentNode<A extends Any>(el: DeploymentElement<A>): el is DeploymentNode<A>;
+declare function isDeployedInstance<A extends Any>(el: DeploymentElement<A>): el is DeployedInstance<A>;
+/**
+ * Relationship in deployment model
+ */
+interface DeploymentRelationship<A extends Any = Unknown> extends AbstractRelationship<A> {
+  readonly source: FqnRef.DeploymentRef<A>;
+  readonly target: FqnRef.DeploymentRef<A>;
+}
+/**
+ * Backward compatibility alias
+ * @deprecated Use {@link DeploymentRelationship} instead
+ */
+type DeploymentRelation<A extends Any = Unknown> = DeploymentRelationship<A>;
+//#endregion
+//#region src/types/model-spec.d.ts
+/**
+ * Element and deployment kind specification
+ */
+interface ElementSpecification {
+  tags?: Tag$1[];
+  title?: string;
+  summary?: MarkdownOrString;
+  description?: MarkdownOrString;
+  technology?: string;
+  notation?: string;
+  links?: NonEmptyArray<Link>;
+  style: {
+    shape?: ElementShape;
+    icon?: Icon;
+    iconColor?: Color;
+    iconSize?: ShapeSize;
+    iconPosition?: IconPosition;
+    color?: Color;
+    border?: BorderStyle;
+    opacity?: number;
+    size?: ShapeSize;
+    padding?: SpacingSize;
+    textSize?: TextSize;
+    multiple?: boolean;
+  };
+}
+interface TagSpecification {
+  color: ThemeColor | ColorLiteral;
+}
+/**
+ * Checks if tag color is defined in the specification
+ * Expects HEX, `rgb(...)` or `rgba(...)` color
+ */
+declare function isTagColorSpecified(spec: string | TagSpecification): spec is {
+  color: ColorLiteral;
+};
+interface RelationshipSpecification {
+  technology?: string;
+  notation?: string;
+  color?: Color;
+  line?: RelationshipLineType;
+  head?: RelationshipArrowType;
+  tail?: RelationshipArrowType;
+}
+type Specification<A> = A extends Any ? {
+  tags: { [key in Tag<A>]: TagSpecification };
+  elements: { [key in ElementKind<A>]: Partial<ElementSpecification> };
+  deployments: { [key in DeploymentKind<A>]: Partial<ElementSpecification> };
+  relationships: { [key in RelationKind<A>]: Partial<RelationshipSpecification> };
+  metadataKeys?: IsNever<MetadataKey<A>> extends true ? never : MetadataKey<A>[];
+  customColors?: CustomColorDefinitions;
+} : never;
+//#endregion
+//#region src/types/project.d.ts
+type LikeC4ProjectTheme = PartialDeep<WritableDeep<LikeC4Theme>, {
+  recurseIntoArrays: false;
+  allowUndefinedInNonTupleArrays: false;
+}>;
+type LikeC4ProjectStyleDefaults = PartialDeep<WritableDeep<LikeC4StyleDefaults>, {
+  recurseIntoArrays: false;
+  allowUndefinedInNonTupleArrays: false;
+}>;
+interface LikeC4ProjectStylesCustomStylesheets {
+  /**
+   * List of paths to CSS files, relative to the project root
+   * (available in LSP, but not in dumped JSON)
+   */
+  paths?: string[];
+  /**
+   * Merged CSS
+   */
+  content: string;
+}
+interface LikeC4ProjectStylesConfig {
+  theme?: LikeC4ProjectTheme;
+  defaults?: LikeC4ProjectStyleDefaults;
+  customCss?: LikeC4ProjectStylesCustomStylesheets;
+}
+interface LikeC4ProjectManualLayoutsConfig {
+  outDir: string;
+}
+/**
+ * Configuration of the project, as read from the config file.
+ * LikeC4 projects encapsulate models, and can import from each other
+ */
+interface LikeC4Project {
+  /**
+   * ID of the project, casted to {@link ProjectId}
+   */
+  readonly id: ProjectId$1;
+  title?: string;
+  /**
+   * Custom styles
+   */
+  styles?: LikeC4ProjectStylesConfig | undefined;
+  /**
+   * Configuration for manual layouts snapshots
+   */
+  manualLayouts?: LikeC4ProjectManualLayoutsConfig | undefined;
+}
+//#endregion
+//#region src/types/view-computed.d.ts
+type ComputedNodeStyle = Simplify<ElementStyle & {
+  icon?: never;
+  shape?: never;
+  color?: never;
+}>;
+interface ComputedNode<A extends Any = Any> extends WithTags<A>, WithOptionalLinks {
+  id: NodeId$1;
+  kind: ElementKind<A> | DeploymentKind<A> | '@group';
+  parent: NodeId$1 | null;
+  /**
+   * Reference to model element
+   */
+  modelRef?: Fqn<A>;
+  /**
+   * Reference to deployment element
+   */
+  deploymentRef?: DeploymentFqn<A>;
+  title: string;
+  /**
+   * Description of the node
+   * either summary or description
+   */
+  description?: MarkdownOrString | null;
+  technology?: string | null;
+  children: NodeId$1[];
+  inEdges: EdgeId$1[];
+  outEdges: EdgeId$1[];
+  shape: ElementShape;
+  color: Color;
+  icon?: Icon | null;
+  style: ComputedNodeStyle;
+  navigateTo?: StrictViewId<A> | null;
+  level: number;
+  depth?: number | null;
+  /**
+   * If this node was customized in the view
+   */
+  isCustomized?: boolean;
+  notation?: string | null;
+}
+interface ComputedEdge<A extends Any = Any> extends WithOptionalTags<A> {
+  id: EdgeId$1;
+  parent: NodeId$1 | null;
+  source: NodeId$1;
+  target: NodeId$1;
+  label: string | null;
+  description?: MarkdownOrString | null;
+  technology?: string | null;
+  relations: RelationId[];
+  kind?: RelationKind<A> | typeof StepEdgeKind;
+  notation?: string;
+  notes?: MarkdownOrString;
+  color: Color;
+  line: RelationshipLineType;
+  head?: RelationshipArrowType;
+  tail?: RelationshipArrowType;
+  navigateTo?: StrictViewId<A> | null;
+  /**
+   * If this edge is derived from custom relationship predicate
+   */
+  isCustomized?: boolean;
+  /**
+   * Path to the AST node relative to the view body ast
+   * Available only in dynamic views
+   * @internal
+   */
+  astPath?: string;
+  /**
+   * For layouting purposes
+   * @default 'forward'
+   */
+  dir?: 'forward' | 'back' | 'both';
+}
+interface ComputedRankConstraint {
+  type: RankValue;
+  nodes: NodeId$1[];
+}
+interface BaseComputedViewProperties<A extends Any> extends BaseViewProperties<A>, ViewWithHash, ViewWithNotation {
+  readonly [_stage]: 'computed';
+  readonly autoLayout: ViewAutoLayout;
+  readonly nodes: ReadonlyArray<ComputedNode<A>>;
+  readonly edges: ReadonlyArray<ComputedEdge<A>>;
+  /**
+   * If the view has manual layout (v2)
+   */
+  readonly hasManualLayout?: boolean;
+  /**
+   * Manual layout data (v1), for compatibility during migration
+   * @deprecated
+   */
+  readonly manualLayout?: ViewManualLayout | undefined;
+}
+interface ComputedElementView<A extends Any = Any> extends BaseComputedViewProperties<A> {
+  readonly [_type]: 'element';
+  readonly viewOf?: Fqn<A>;
+  readonly extends?: StrictViewId<A>;
+  readonly ranks?: ComputedRankConstraint[];
+}
+interface ComputedDeploymentView<A extends Any = Any> extends BaseComputedViewProperties<A> {
+  readonly [_type]: 'deployment';
+}
+interface ComputedDynamicView<A extends Any = Any> extends BaseComputedViewProperties<A> {
+  readonly [_type]: 'dynamic';
+  /**
+   * How to display the dynamic view
+   * - `diagram`: display as a regular likec4 view
+   * - `sequence`: display as a sequence diagram
+   */
+  readonly variant: DynamicViewDisplayVariant;
+}
+//#endregion
+//#region src/types/view-manual-layout.d.ts
+type LayoutedViewDriftReason = 'not-exists' | 'type-changed' | 'nodes-added' | 'nodes-removed' | 'nodes-drift' | 'edges-added' | 'edges-removed' | 'edges-drift';
+type DiagramNodeDriftReason = 'removed' | 'added' | 'label-changed' | 'modelRef-changed' | 'parent-changed' | 'children-changed' | 'became-compound' | 'became-leaf' | 'shape-changed';
+type DiagramEdgeDriftReason = 'removed' | 'added' | 'label-added' | 'label-removed' | 'label-changed' | 'notes-changed' | 'direction-changed' | 'source-changed' | 'target-changed';
+type ViewManualLayoutSnapshotPerType = {
+  readonly [_type]: 'element';
+  readonly viewOf?: Fqn$1;
+  readonly extends?: ViewId$1;
+} | {
+  readonly [_type]: 'deployment';
+} | {
+  readonly [_type]: 'dynamic';
+  readonly sequenceLayout: LayoutedDynamicView.Sequence.Layout;
+};
+type ViewManualLayoutSnapshot<Type extends ViewType = ViewType> = Simplify<ViewManualLayoutSnapshotPerType & {
+  readonly id: ViewId$1;
+  readonly title: string | null;
+  readonly description: MarkdownOrString | null;
+  readonly [_type]: Type;
+  readonly [_stage]: 'layouted';
+  readonly hash: string;
+  readonly nodes: ReadonlyArray<DiagramNode>;
+  readonly edges: ReadonlyArray<DiagramEdge>;
+  readonly bounds: BBox;
+  readonly autoLayout: ViewAutoLayout;
+} & ViewWithNotation>;
+//#endregion
+//#region src/types/view-layouted.d.ts
+interface DiagramNode<A extends Any = Any> extends ComputedNode<A>, BBox {
+  /**
+   * Absolute X coordinate
+   */
+  x: number;
+  /**
+   * Absolute Y coordinate
+   */
+  y: number;
+  width: number;
+  height: number;
+  /**
+   * Bounding box of label
+   * (Absolute coordinates)
+   */
+  labelBBox: BBox;
+  /**
+   * List of reasons causing node drift
+   */
+  drifts?: NonEmptyReadonlyArray<DiagramNodeDriftReason> | null;
+}
+interface DiagramEdge<A extends Any = Any> extends ComputedEdge<A> {
+  /**
+   * Bezier points
+   * (Absolute coordinates)
+   */
+  points: NonEmptyArray<Point>;
+  /**
+   * Control points to adjust the edge
+   * (Absolute coordinates)
+   */
+  controlPoints?: NonEmptyArray<XYPoint> | null;
+  /**
+   * Bounding box of label
+   * (Absolute coordinates)
+   */
+  labelBBox?: BBox | null;
+  /**
+   * List of reasons causing edge drift
+   */
+  drifts?: NonEmptyReadonlyArray<DiagramEdgeDriftReason> | null;
+}
+/**
+ * Type of the layout
+ * - `auto`: auto-layouted from the current sources
+ * - `manual`: read from the manually layouted snapshot
+ */
+type LayoutType = 'auto' | 'manual';
+interface BaseLayoutedViewProperties<A extends Any> extends BaseViewProperties<A>, ViewWithHash, ViewWithNotation {
+  readonly [_stage]: 'layouted';
+  /**
+   * If undefined, view does not have any manual layouts, and is auto-layouted
+   */
+  readonly [_layout]?: LayoutType;
+  readonly autoLayout: ViewAutoLayout;
+  readonly nodes: ReadonlyArray<DiagramNode<A>>;
+  readonly edges: ReadonlyArray<DiagramEdge<A>>;
+  readonly bounds: BBox;
+  /**
+   * If diagram has manual layout
+   * But was changed and layout should be recalculated
+   * @deprecated manual layout v2 uses {@link drifts}
+   */
+  readonly hasLayoutDrift?: boolean;
+  /**
+   * List of reasons causing layout drift
+   * If undefined or null, there is no layout drift or view is auto-layouted
+   */
+  readonly drifts?: NonEmptyReadonlyArray<LayoutedViewDriftReason> | null;
+}
+interface LayoutedElementView<A extends Any = Any> extends BaseLayoutedViewProperties<A> {
+  readonly [_type]: 'element';
+  readonly viewOf?: Fqn<A>;
+  readonly extends?: StrictViewId<A>;
+}
+interface LayoutedDeploymentView<A extends Any = Any> extends BaseLayoutedViewProperties<A> {
+  readonly [_type]: 'deployment';
+}
+interface LayoutedDynamicView<A extends Any = Any> extends BaseLayoutedViewProperties<A> {
+  readonly [_type]: 'dynamic';
+  /**
+   * Default variant of this dynamic view
+   * - `diagram`: display as a regular likec4 view (default if not specified)
+   * - `sequence`: display as a sequence diagram
+   */
+  readonly variant: DynamicViewDisplayVariant;
+  /**
+   * Sequence layout of this dynamic view
+   */
+  readonly sequenceLayout: LayoutedDynamicView.Sequence.Layout;
+}
+declare namespace LayoutedDynamicView {
+  namespace Sequence {
+    interface ActorPort {
+      readonly id: string;
+      readonly cx: number;
+      readonly cy: number;
+      readonly height: number;
+      readonly type: 'target' | 'source';
+      readonly position: 'left' | 'right' | 'top' | 'bottom';
+    }
+    interface Actor {
+      readonly id: NodeId;
+      readonly x: number;
+      readonly y: number;
+      readonly width: number;
+      readonly height: number;
+      readonly ports: ReadonlyArray<ActorPort>;
+    }
+    interface Compound {
+      readonly id: NodeId;
+      /**
+       * Original node id, since multiple compound nodes can be built from one node
+       */
+      readonly origin: NodeId;
+      readonly x: number;
+      readonly y: number;
+      readonly width: number;
+      readonly height: number;
+      readonly depth: number;
+    }
+    interface ParallelArea {
+      readonly parallelPrefix: string;
+      readonly x: number;
+      readonly y: number;
+      readonly width: number;
+      readonly height: number;
+    }
+    interface Step {
+      readonly id: EdgeId;
+      readonly labelBBox?: {
+        width: number;
+        height: number;
+      } | undefined;
+      readonly sourceHandle: string;
+      readonly targetHandle: string;
+    }
+    interface Layout {
+      readonly actors: ReadonlyArray<Actor>;
+      /**
+       * Steps in the sequence diagram (filtered edges with compound nodes)
+       */
+      readonly steps: ReadonlyArray<Step>;
+      readonly compounds: ReadonlyArray<Compound>;
+      readonly parallelAreas: ReadonlyArray<ParallelArea>;
+      readonly bounds: BBox;
+    }
+  }
+}
+//#endregion
+//#region src/types/view-parsed.deployment.d.ts
+/**
+ * Predicates scoped to deployment model
+ */
+interface DeploymentViewIncludePredicate<A extends Any = Unknown> extends AnyIncludePredicate<Expression<A>> {}
+interface DeploymentViewExcludePredicate<A extends Any = Unknown> extends AnyExcludePredicate<Expression<A>> {}
+type DeploymentViewPredicate<A extends Any = Unknown> = DeploymentViewIncludePredicate<A> | DeploymentViewExcludePredicate<A>;
+interface DeploymentViewRuleStyle<A extends Any = Unknown> extends AnyViewRuleStyle<FqnExpr<A>> {}
+type DeploymentViewRule<A extends Any = Unknown> = ExclusiveUnion<{
+  Include: DeploymentViewIncludePredicate<A>;
+  Exclude: DeploymentViewExcludePredicate<A>;
+  Style: DeploymentViewRuleStyle<A>;
+  AutoLayout: ViewRuleAutoLayout;
+}>;
+interface ParsedDeploymentView<A extends Any = Unknown> extends BaseParsedViewProperties<A> {
+  [_type]: 'deployment';
+  readonly rules: DeploymentViewRule<A>[];
+}
+//#endregion
+//#region src/types/view.d.ts
+type ParsedView<A extends Any = Any> = ParsedElementView<A> | ParsedDeploymentView<A> | ParsedDynamicView<A>;
+type ComputedView<A extends Any = Any> = ComputedElementView<A> | ComputedDeploymentView<A> | ComputedDynamicView<A>;
+type LayoutedView<A extends Any = Any> = LayoutedElementView<A> | LayoutedDeploymentView<A> | LayoutedDynamicView<A>;
+type ProcessedView<A extends Any = Any> = ComputedView<A> | LayoutedView<A>;
+type AnyView<A extends Any = Any> = ParsedElementView<A> | ParsedDeploymentView<A> | ParsedDynamicView<A> | ComputedElementView<A> | ComputedDeploymentView<A> | ComputedDynamicView<A> | LayoutedElementView<A> | LayoutedDeploymentView<A> | LayoutedDynamicView<A>;
+type ViewOnStage<V extends AnyView<Any>, T extends ModelStage> = Extract<V, {
+  [_stage]: T;
+}>;
+type ViewWithType<V extends AnyView<Any>, T extends ViewType> = Extract<V, {
+  [_type]: T;
+}>;
+type ViewRule<A extends Any = Any> = ParsedView<A>['rules'][number];
+type ViewRulePredicate<A extends Any = Any> = Extract<ViewRule<A>, {
+  include: any[];
+} | {
+  exclude: any[];
+}>;
+declare function isViewRulePredicate<V extends ViewRule<any>>(rule: V): rule is Extract<V, {
+  include: any[];
+} | {
+  exclude: any[];
+}>;
+declare function isViewRuleStyle<V extends ViewRule<any>>(rule: V): rule is Extract<V, {
+  targets: any[];
+  style: {};
+}>;
+declare function isComputedView<V extends AnyView<any>>(view: V): view is ExtractOnStage<V, 'computed'>;
+declare function isDiagramView<V extends AnyView<any>>(view: V): view is ExtractOnStage<V, 'layouted'>;
+declare function isElementView<V extends AnyView<any>>(view: V): view is ViewWithType<V, 'element'>;
+declare function isScopedElementView<V extends AnyView<any>>(view: V): view is ViewWithType<V, 'element'> & {
+  viewOf: Fqn<Any>;
+};
+declare function isExtendsElementView<V extends AnyView<any>>(view: V): view is ViewWithType<V, 'element'> & {
+  extends: StrictViewId<Any>;
+};
+declare function isDeploymentView<V extends AnyView<any>>(view: V): view is ViewWithType<V, 'deployment'>;
+declare function isDynamicView<V extends AnyView<any>>(view: V): view is ViewWithType<V, 'dynamic'>;
+//#endregion
+//#region src/types/model-data.d.ts
+/**
+ * Represents a LikeC4 model data, in different stages of processing
+ * - {@link ParsedLikeC4ModelData} - parsed from DSL or result from Builder
+ * - {@link ComputedLikeC4ModelData} - computed from parsed model
+ * - {@link LayoutedLikeC4ModelData} - layouted from computed model
+ *
+ * !IMPORTANT: This is a low-level type, use `LikeC4Model` instead.
+ */
+interface BaseLikeC4ModelData<A extends Any> {
+  [_stage]: A['Stage'];
+  projectId: ProjectId<A>;
+  project: LikeC4Project;
+  specification: Specification<A>;
+  elements: Record<ElementId<A>, Element<A>>;
+  deployments: {
+    elements: Record<DeploymentId<A>, DeploymentElement<A>>;
+    relations: Record<RelationId, DeploymentRelationship<A>>;
+  };
+  relations: Record<RelationId, Relationship<A>>;
+  globals: ModelGlobals;
+  imports: Record<string, NonEmptyArray<Element<A>>>;
+}
+type AuxFromLikeC4ModelData<D> = D extends BaseLikeC4ModelData<infer A extends Any> ? IsAny<A> extends true ? never : A : never;
+interface ParsedLikeC4ModelData<A extends AnyParsed = UnknownParsed> extends BaseLikeC4ModelData<A> {
+  [_stage]: 'parsed';
+  views: Record<ViewId<A>, ParsedView<A>>;
+}
+interface ComputedLikeC4ModelData<A extends AnyComputed = UnknownComputed> extends BaseLikeC4ModelData<A> {
+  [_stage]: 'computed';
+  views: Record<ViewId<A>, ComputedView<A>>;
+  /**
+   * If project contains saved manual layouts
+   */
+  manualLayouts?: Record<ViewId$1, ViewManualLayoutSnapshot>;
+}
+interface LayoutedLikeC4ModelData<A extends AnyLayouted = UnknownLayouted> extends BaseLikeC4ModelData<A> {
+  [_stage]: 'layouted';
+  views: Record<ViewId<A>, LayoutedView<A>>;
+  /**
+   * If this model contains saved manual layouts
+   */
+  manualLayouts?: Record<ViewId$1, ViewManualLayoutSnapshot>;
+}
+type LikeC4ModelData<A extends Any> = ParsedLikeC4ModelData<A> | ComputedLikeC4ModelData<A> | LayoutedLikeC4ModelData<A>;
+//#endregion
+//#region src/types/model-dump.d.ts
+/**
+ * JSON representation of {@link Specification}
+ */
+interface SpecificationDump {
+  elements: {
+    [kind: string]: object;
+  };
+  tags?: {
+    [tag: string]: object;
+  };
+  deployments?: {
+    [kind: string]: object;
+  };
+  relationships?: {
+    [kind: string]: object;
+  };
+  metadataKeys?: string[];
+  customColors?: {
+    [kind: string]: object;
+  };
+}
+type SpecTypesFromDump<J> = J extends SpecificationDump ? SpecAux<KeysOf<J['elements']>, KeysOf<J['deployments']>, KeysOf<J['relationships']>, KeysOf<J['tags']>, J['metadataKeys'] extends readonly [string, ...string[]] ? J['metadataKeys'][number] : never> : SpecAux<never, never, never, never, never>;
+/**
+ * Dump differs from {@link ParsedLikeC4ModelData} by the fact that it is computed or layouted
+ */
+type LikeC4ModelDump = {
+  [_stage]?: 'computed' | 'layouted';
+  projectId?: string;
+  project?: ProjectDump;
+  specification: SpecificationDump;
+  elements?: {
+    [kind: string]: object;
+  };
+  deployments: {
+    elements?: {
+      [kind: string]: object;
+    };
+    relations?: {};
+  };
+  views?: {
+    [kind: string]: object;
+  };
+  relations?: {};
+  globals?: {
+    predicates?: {};
+    dynamicPredicates?: {};
+    styles?: {};
+  };
+  imports?: {};
+};
+type ProjectDump = {
+  id: string;
+  name?: string;
+  title?: string | undefined;
+};
+type AuxFromDump<D> = D extends LikeC4ModelDump ? Aux<D[_stage] extends infer S extends 'computed' | 'layouted' ? S : 'computed' | 'layouted' | 'parsed', KeysOf<D['elements']>, KeysOf<D['deployments']['elements']>, KeysOf<D['views']>, D['projectId'] extends infer PID extends string ? PID : never, SpecTypesFromDump<D['specification']>> : Never;
+//#endregion
+//#region src/types/view-changes.d.ts
+declare namespace ViewChange {
+  interface ChangeElementStyle {
+    op: 'change-element-style';
+    style: {
+      border?: BorderStyle;
+      opacity?: number;
+      shape?: ElementShape;
+      color?: ThemeColor;
+    };
+    targets: NonEmptyArray<Fqn$1 | DeploymentFqn$1>;
+  }
+  interface SaveViewSnapshot {
+    op: 'save-view-snapshot';
+    layout: LayoutedView;
+  }
+  interface ResetManualLayout {
+    op: 'reset-manual-layout';
+  }
+  interface ChangeAutoLayout {
+    op: 'change-autolayout';
+    layout: {
+      direction: AutoLayoutDirection;
+      nodeSep?: number | null;
+      rankSep?: number | null;
+    };
+  }
+}
+type ViewChange = ViewChange.ChangeElementStyle | ViewChange.SaveViewSnapshot | ViewChange.ResetManualLayout | ViewChange.ChangeAutoLayout;
+//#endregion
+export { LikeC4Project as $, AnyIncludePredicate as $t, DeploymentViewExcludePredicate as A, DynamicStep as At, LayoutedDynamicView as B, isDynamicStepsParallel as Bt, isDiagramView as C, ensureSizes as Ct, isScopedElementView as D, GlobalStyleID as Dt, isExtendsElementView as E, GlobalPredicates as Et, ParsedDeploymentView as F, DynamicViewRule as Ft, ViewManualLayoutSnapshot as G, ElementViewRule as Gt, DiagramEdgeDriftReason as H, ElementViewExcludePredicate as Ht, DiagramEdge as I, DynamicViewStep as It, ComputedEdge as J, ElementViewRuleStyle as Jt, ComputedDeploymentView as K, ElementViewRuleGroup as Kt, DiagramNode as L, ParsedDynamicView as Lt, DeploymentViewPredicate as M, DynamicStepsSeries as Mt, DeploymentViewRule as N, DynamicViewDisplayVariant as Nt, isViewRulePredicate as O, GlobalStyles as Ot, DeploymentViewRuleStyle as P, DynamicViewIncludeRule as Pt, ComputedRankConstraint as Q, AnyExcludePredicate as Qt, LayoutType as R, getParallelStepsPrefix as Rt, isDeploymentView as S, Relationship as St, isElementView as T, GlobalPredicateId as Tt, DiagramNodeDriftReason as U, ElementViewIncludePredicate as Ut, LayoutedElementView as V, isDynamicStepsSeries as Vt, LayoutedViewDriftReason as W, ElementViewPredicate as Wt, ComputedNode as X, isViewRuleGroup as Xt, ComputedElementView as Y, ParsedElementView as Yt, ComputedNodeStyle as Z, isViewRuleRank as Zt, ViewOnStage as _, isViewRuleGlobalPredicateRef as _n, isDeploymentNode as _t, SpecTypesFromDump as a, RankValue as an, ElementSpecification as at, ViewWithType as b, ElementStyle as bt, ComputedLikeC4ModelData as c, ViewRuleAutoLayout as cn, TagSpecification as ct, ParsedLikeC4ModelData as d, ViewRuleRank as dn, DeploymentElement as dt, AnyViewRuleStyle as en, LikeC4ProjectManualLayoutsConfig as et, AnyView as f, ViewType as fn, DeploymentElementRef as ft, ProcessedView as g, isViewRuleAutoLayout as gn, isDeployedInstance as gt, ParsedView as h, isAutoLayoutDirection as hn, DeploymentRelationship as ht, ProjectDump as i, NodeNotation as in, LikeC4ProjectTheme as it, DeploymentViewIncludePredicate as j, DynamicStepsParallel as jt, isViewRuleStyle as k, ModelGlobals as kt, LayoutedLikeC4ModelData as l, ViewRuleGlobalPredicateRef as ln, isTagColorSpecified as lt, LayoutedView as m, ViewWithNotation as mn, DeploymentRelation as mt, AuxFromDump as n, BaseParsedViewProperties as nn, LikeC4ProjectStylesConfig as nt, SpecificationDump as o, ViewAutoLayout as on, RelationshipSpecification as ot, ComputedView as p, ViewWithHash as pn, DeploymentNode as pt, ComputedDynamicView as q, ElementViewRuleRank as qt, LikeC4ModelDump as r, BaseViewProperties as rn, LikeC4ProjectStylesCustomStylesheets as rt, AuxFromLikeC4ModelData as s, ViewManualLayout as sn, Specification as st, ViewChange as t, AutoLayoutDirection as tn, LikeC4ProjectStyleDefaults as tt, LikeC4ModelData as u, ViewRuleGlobalStyle as un, DeployedInstance as ut, ViewRule as v, isViewRuleGlobalStyle as vn, AbstractRelationship as vt, isDynamicView as w, GlobalDynamicPredicates as wt, isComputedView as x, ModelRelation as xt, ViewRulePredicate as y, Element as yt, LayoutedDeploymentView as z, isDynamicStep as zt };