import { r as __name } from "../chunks/rolldown-runtime.mjs";
import { $ as ComputedNode, C as ComputedView, Di as toComputed, Dn as ViewAutoLayout, E as ParsedView, Gr as Any, Jr as AnyParsed, Si as ViewId, X as ComputedDynamicView, Z as ComputedEdge, aa as _stage, bn as AnyIncludePredicate, ei as ElementId, oa as _type, qi as StepPath, v as ComputedLikeC4ModelData, vi as Unknown, vt as LayoutedDynamicView, wn as BaseViewProperties, x as ParsedLikeC4ModelData, ya as NonEmptyArray, yn as AnyExcludePredicate, zn as ModelExpression } from "../chunks/index.mjs";
import { C as ElementModel, T as RelationshipModel, n as LikeC4Model } from "../chunks/LikeC4Model.mjs";
import { U as ViewPredicate } from "../chunks/_types.mjs";
import "../chunks/index5.mjs";
import { a as LayoutedProjectNode, i as LayoutedProjectEdge, n as ComputedProjectNode, o as LayoutedProjectsView, r as ComputedProjectsView, t as ComputedProjectEdge } from "../chunks/_types2.mjs";
//#region src/compute-view/compute-view.d.ts
type ComputeViewResult<V> = {
  isSuccess: true;
  error?: undefined;
  view: V;
} | {
  isSuccess: false;
  error: Error;
  view: undefined;
};
declare function unsafeComputeView<A extends Any>(viewsource: ParsedView<A>, likec4model: LikeC4Model<any>): ComputedView<A>;
declare function computeView<A extends Any>(viewsource: ParsedView<A>, likec4model: LikeC4Model<A>): ComputeViewResult<ComputedView<A>>;
declare function computeParsedModelData<A extends AnyParsed, B extends toComputed<A> = toComputed<A>>(parsed: ParsedLikeC4ModelData<A>): ComputedLikeC4ModelData<B>;
declare function computeLikeC4Model<A extends Any, B extends toComputed<A> = toComputed<A>>(parsed: ParsedLikeC4ModelData<A>): LikeC4Model<B>;
//#endregion
//#region src/compute-view/utils/resolve-extended-views.d.ts
/**
 * Resolve rules of extended views
 * (Removes invalid views)
 */
declare function resolveRulesExtendedViews<A extends Any, V extends Record<any, ParsedView<A>>>(unresolvedViews: V): V;
//#endregion
//#region src/compute-view/utils/with-readable-edges.d.ts
/**
 * Convert hashed edge ids to human-readable
 * Mostly for testing purposes
 */
declare function withReadableEdges<V extends ComputedView<any>>({ edges, nodes, ...view }: V, separator?: string): V & {
  nodeIds: string[];
  edgeIds: string[];
};
declare function viewsWithReadableEdges<A extends Any>({ views, ...model }: ComputedLikeC4ModelData<A>): ComputedLikeC4ModelData<A>;
//#endregion
//#region src/compute-view/projects-view/compute.d.ts
/**
 * Computes an overview of projects and their relationships
 */
declare function computeProjectsView(likec4models: NonEmptyArray<LikeC4Model>): ComputedProjectsView;
//#endregion
//#region src/compute-view/relationships-view/_types.d.ts
type RelationshipsViewData<M extends Any = Unknown> = {
  incomers: ReadonlySet<ElementModel<M>>;
  incoming: ReadonlySet<RelationshipModel<M>>;
  subjects: ReadonlySet<ElementModel<M>>;
  outgoing: ReadonlySet<RelationshipModel<M>>;
  outgoers: ReadonlySet<ElementModel<M>>;
};
//#endregion
//#region src/compute-view/relationships-view/compute.d.ts
declare function computeRelationshipsView<M extends Any>(subjectId: ElementId<M>, likec4model: LikeC4Model<M>, scopeViewId: ViewId<M> | null, scope?: 'global' | 'view'): RelationshipsViewData<M>;
//#endregion
//#region src/compute-view/relationships-view/utils.d.ts
/**
 * Builds a tree structure from a flat list of elements.
 * @param elements - An iterable of ElementModel instances.
 * @returns An object containing the sorted elements, a lookup by ID, root elements, parent and children accessors, and a flatten method.
 * @example
 * ```ts
 * const elements = [
 *   { id: 'A' },
 *   { id: 'A.B' },
 *   { id: 'A.B.C' },
 *   { id: 'A.B.D' },
 *   { id: 'E' },
 * ]
 *
 * const tree = treeFromElements(elements)
 *
 * tree.sorted.map(e => e.id) // ['A', 'A.B', 'A.B.C', 'A.B.D', 'E']
 *
 * tree.byId('A.B').id // 'A.B'
 *
 * [...tree.root].map(e => e.id) // ['A', 'E']
 *
 * tree.parent(tree.byId('A.B.C'))?.id // 'A.B'
 *
 * tree.children(tree.byId('A')).map(e => e.id) // ['A.B']
 */
declare function treeFromElements<M extends Any>(elements: Iterable<ElementModel<M>>): Readonly<{
  /**
   * Elements sorted in a way that parents go before their descendants.
   */
  sorted: ReadonlyArray<ElementModel<M>>;
  /**
   * Get element by its id (FQN)
   */
  byId(id: ElementId<M>): ElementModel<M>;
  /**
   * Root elements (i.e. those without parents)
   */
  root: ReadonlySet<ElementModel<M>>;
  /**
   * Get parent element or null if it's a root
   */
  parent(el: ElementId<M> | ElementModel<M>): ElementModel<M> | null;
  /**
   * Get child elements (i.e. direct descendants)
   */
  children(el: ElementId<M> | ElementModel<M>): ReadonlyArray<ElementModel<M>>;
  /**
   * Flattens the tree structure by removing redundant hierarchy levels,
   * while always keeping the direct parent of every leaf (the leaf owner).
   * @example
   *   A
   *   └── B
   *       ├── C
   *       │   └── D
   *       │       └── E
   *       └── F
   *           └── G
   * becomes
   *   A
   *   ├── C
   *   │   └── D
   *   │       └── E
   *   └── F
   *       └── G
   */
  flatten(): ReadonlySet<ElementModel<M>>;
}>;
//#endregion
//#region src/compute-view/adhoc-view/compute.d.ts
interface AdhocViewIncludePredicate<A extends Any> extends AnyIncludePredicate<ModelExpression<A>> {}
interface AdhocViewExcludePredicate<A extends Any> extends AnyExcludePredicate<ModelExpression<A>> {}
type AdhocViewPredicate<A extends Any = Any> = AdhocViewIncludePredicate<A> | AdhocViewExcludePredicate<A>;
interface ComputedAdhocView extends BaseViewProperties<Any> {
  readonly [_type]: 'adhoc';
  readonly [_stage]: 'computed';
  readonly nodes: ReadonlyArray<ComputedNode>;
  readonly edges: ReadonlyArray<ComputedEdge>;
  readonly autoLayout: ViewAutoLayout;
}
/**
 * Computes an adhoc view based on the given predicates.
 * Adhoc views are not defined in the model, but computed on demand.
 * Available for logical model only.
 *
 * @param predicates accepts the same predicates as element view.
 * @param likec4model The LikeC4 model to compute view.
 * @returns The computed adhoc view.
 */
declare function computeAdhocView<A extends Any>(likec4model: LikeC4Model<A>, predicates: AdhocViewPredicate<NoInfer<A>>[]): ComputedAdhocView;
//#endregion
//#region src/compute-view/adhoc-view/builder.d.ts
/**
 * Allows you to define type-safe adhoc views using types from the model.
 */
declare class AdhocView<A extends Any> {
  #private;
  private readonly model;
  /**
   * Creates a new adhoc view builder.
   */
  static use<A extends Any>(model: LikeC4Model<A>): AdhocView<A>;
  private constructor();
  /**
   * Used to cache the type of the predicates.
   */
  readonly Expr: ViewPredicate.AllExpression<ViewPredicate.ElementExpr<A['ElementId']>>;
  include(...predicates: this['Expr'][]): this;
  exclude(...predicates: this['Expr'][]): this;
  compute(): ComputedAdhocView;
}
//#endregion
//#region src/compute-view/dynamic-view/computeFlow.d.ts
/**
 * Result of {@link computeFlow}: the subset of the dynamic view that should be
 * rendered for a given selection of visible subflows.
 */
interface ComputeFlowResult<V extends ComputedDynamicView<any> | LayoutedDynamicView<any>> {
  /**
   * The subflows that were explicitly requested to be visible.
   */
  readonly subflows: readonly StepPath[];
  readonly nodes: V['nodes'];
  readonly edges: V['edges'];
}
/**
 * Walks the recursive flow tree of a {@link ComputedDynamicView} and resolves
 * which steps (edges) and actors (nodes) must be shown.
 *
 * By default (no `subflows`) everything is visible — every step, every loop/opt
 * and every branch of every `alt`/`try`. Passing `subflows` only narrows the
 * branches/sections of `alt`/`try` containers:
 *
 * - A container whose branches are not mentioned in `subflows` keeps showing all
 *   of them (default), independent of any selection made in other containers.
 * - Once any branch within a container is requested (the container id is a
 *   prefix of a requested subflow), that container shows only the branches on a
 *   requested path — i.e. branches that are themselves requested or that enclose
 *   a requested nested subflow.
 *
 * The last rule means selecting a deeply nested branch keeps all of its parent
 * branches visible (they enclose the requested subflow), while the parents'
 * unrelated siblings are hidden.
 *
 * @param opts.view - The computed dynamic view to resolve.
 * @param opts.subflows - Ids of subflows requested to be visible (empty = all).
 * @returns The visible nodes and edges, preserving the order of `view.nodes`
 *   and `view.edges`. Each node's `children`/`inEdges`/`outEdges` are narrowed
 *   to the visible subset to keep the result internally consistent.
 */
declare function computeFlow<V extends ComputedDynamicView<any> | LayoutedDynamicView<any>>(opts: {
  view: V;
  subflows?: readonly StepPath[];
}): ComputeFlowResult<V>;
//#endregion
export { AdhocView, type AdhocViewExcludePredicate, type AdhocViewIncludePredicate, type AdhocViewPredicate, type ComputeFlowResult, type ComputeViewResult, type ComputedAdhocView, type ComputedProjectEdge, type ComputedProjectNode, type ComputedProjectsView, type LayoutedProjectEdge, type LayoutedProjectNode, type LayoutedProjectsView, type RelationshipsViewData, computeAdhocView, computeFlow, computeLikeC4Model, computeParsedModelData, computeProjectsView, computeRelationshipsView, computeView, resolveRulesExtendedViews, treeFromElements, unsafeComputeView, viewsWithReadableEdges, withReadableEdges };