import { n as __exportAll, r as __name } from "./rolldown-runtime.mjs";
import { $r as EdgeId, Ca as ReorderedArray, Gr as Any, Pi as Fqn, ha as IteratorLike, ma as IterableContainer, vi as Unknown } from "./index.mjs";
import { C as ElementModel, S as NodeModel, T as RelationshipModel, a as DeploymentNodeModel, c as NestedElementOfDeployedInstanceModel, i as DeploymentElementModel, l as RelationshipsAccum, r as DeployedInstanceModel, s as DeploymentRelationModel, w as AnyRelationshipModel, x as EdgeModel, y as LikeC4ViewModel } from "./LikeC4Model.mjs";
//#region src/model/connection/Connection.d.ts
interface Connection<Elem = ElementModel<Any> | DeploymentElementModel<Any>, Id = string> {
  readonly id: Id;
  readonly source: Elem;
  readonly target: Elem;
  /**
   * Common ancestor of the source and target elements.
   * Represents the boundary of the connection.
   */
  readonly boundary: Elem | null;
  /**
   * Human readable expression of the connection
   * Mostly used for testing and debugging
   */
  readonly expression: string;
  mergeWith(this: Connection<Elem, Id>, other: typeof this): typeof this;
  nonEmpty(): boolean;
  difference(this: Connection<Elem, Id>, other: typeof this): typeof this;
  intersect(this: Connection<Elem, Id>, other: typeof this): typeof this;
  equals(other: Connection): boolean;
}
declare namespace Connection {
  type ConnectionPredicate = <C extends Connection<{
    id: string;
  }, any>>(connection: C) => boolean;
  type ElementId = Fqn | string;
  export const isInside: (fqn: ElementId) => ConnectionPredicate;
  export const isDirectedBetween: (source: ElementId, target: ElementId) => ConnectionPredicate;
  export const isAnyBetween: (source: ElementId, target: ElementId) => ConnectionPredicate;
  export const isIncoming: (target: ElementId) => ConnectionPredicate;
  export const isOutgoing: (source: ElementId) => ConnectionPredicate;
  export const isAnyInOut: (source: ElementId) => ConnectionPredicate;
  export {};
}
//#endregion
//#region src/utils/const.d.ts
declare const customInspectSymbol: unique symbol;
//#endregion
//#region src/model/connection/deployment/DeploymentConnectionModel.d.ts
/**
 * Connection is ephemeral entity, result of a resolving relationships between source and target.
 * Includes direct relationships and/or between their nested elements.
 */
declare class DeploymentConnectionModel<A extends Any = Any> implements Connection<DeploymentElementModel<A>, EdgeId> {
  readonly source: DeploymentElementModel<A>;
  readonly target: DeploymentElementModel<A>;
  readonly relations: RelationshipsAccum<A>;
  readonly id: EdgeId;
  constructor(source: DeploymentElementModel<A>, target: DeploymentElementModel<A>, relations: RelationshipsAccum<A>);
  /**
   * Human readable expression of the connection
   * Mostly used for testing and debugging
   */
  get expression(): string;
  private _boundary;
  /**
   * Common ancestor of the source and target elements.
   * Represents the boundary of the connection.
   */
  get boundary(): DeploymentNodeModel<A> | null;
  nonEmpty(): boolean;
  [customInspectSymbol](_depth: any, _inspectOptions: any, _inspect: any): string;
  toString(): string;
  /**
   * Check if connection contains deployment relation,
   * that is directly connected to source or target.
   */
  hasDirectDeploymentRelation(): boolean;
  values(): IteratorLike<RelationshipModel<A> | DeploymentRelationModel<A>>;
  /**
   * Merge with another connections, if it has the same source and target.
   * Returns new connection with union of relationships.
   */
  mergeWith(others: DeploymentConnectionModel<A>[]): DeploymentConnectionModel<A>;
  /**
   * Merge with another connection, if it has the same source and target.
   * Returns new connection with union of relationships.
   */
  mergeWith(other: DeploymentConnectionModel<A>): DeploymentConnectionModel<A>;
  difference(other: DeploymentConnectionModel<A>): DeploymentConnectionModel<A>;
  intersect(other: DeploymentConnectionModel<A>): DeploymentConnectionModel<A>;
  equals(other: Connection): boolean;
  /**
   * Creates a clone of the current `DeploymentConnectionModel` instance with optional overrides.
   * if `null` is provided in overrides, the corresponding relation set will be empty.
   */
  update(overrides?: {
    model?: ReadonlySet<RelationshipModel<A>> | null;
    deployment?: ReadonlySet<DeploymentRelationModel<A>> | null;
  }): DeploymentConnectionModel<A>;
}
//#endregion
//#region src/model/connection/model/ConnectionModel.d.ts
/**
 * Connection refers to any relationships between two elements,
 * both direct and implicit ones (between their nested elements).
 *
 * Merges relationships together to an single edge on the diagram.
 */
declare class ConnectionModel<A extends Any = Unknown> implements Connection<ElementModel<A>, EdgeId> {
  readonly source: ElementModel<A>;
  readonly target: ElementModel<A>;
  readonly relations: ReadonlySet<RelationshipModel<A>>;
  readonly id: EdgeId;
  constructor(source: ElementModel<A>, target: ElementModel<A>, relations?: ReadonlySet<RelationshipModel<A>>);
  private _boundary;
  /**
   * Common ancestor of the source and target elements.
   * Represents the boundary of the connection.
   */
  get boundary(): ElementModel<A> | null;
  /**
   * Human readable expression of the connection
   * Mostly used for testing and debugging
   */
  get expression(): string;
  /**
   * Returns true if only includes relations between the source and target elements.
   */
  get isDirect(): boolean;
  /**
   * Returns true if includes relations between nested elements of the source and target elements.
   */
  get isImplicit(): boolean;
  get directRelations(): ReadonlySet<RelationshipModel<A>>;
  nonEmpty(): boolean;
  mergeWith(other: ConnectionModel<A>): ConnectionModel<A>;
  difference(other: ConnectionModel<A>): ConnectionModel<A>;
  intersect(other: ConnectionModel<A>): ConnectionModel<A>;
  equals(other: Connection): boolean;
  /**
   * Returns a new instance with the updated relations.
   *
   * @param relations - A readonly set of `RelationshipModel` instances representing the new relations.
   * @returns A new `ConnectionModel` instance with the updated relations.
   */
  update(relations: ReadonlySet<RelationshipModel<A>>): ConnectionModel<A>;
  [customInspectSymbol](_depth: any, _inspectOptions: any, _inspect: any): string;
  toString(): string;
  /**
   * Creates a new connection with reversed direction (target becomes source and vice versa)
   */
  reversed(): ConnectionModel<A>;
}
//#endregion
//#region src/model/connection/ops.d.ts
/**
 * Check if connection is nested inside another connection
 * (i.e. between descendants)
 */
declare function isNestedConnection<T extends {
  id: string;
}>(parent: WithSourceTarget<NoInfer<T>>): (nested: WithSourceTarget<T>) => boolean;
declare function isNestedConnection<T extends {
  id: string;
}>(nested: WithSourceTarget<T>, parent: WithSourceTarget<T>): boolean;
type ConnectionElemId = Connection<{
  readonly id: string;
}, any>;
declare function findDeepestNestedConnection<C extends ConnectionElemId>(connections: ReadonlyArray<C>, connection: C): C | null;
declare function sortDeepestFirst<C extends ConnectionElemId>(connections: ReadonlyArray<C>): C[];
type WithBoundary = {
  id: string;
  boundary: null | {
    id: string;
  };
};
declare function sortConnectionsByBoundaryHierarchy(sort?: 'asc' | 'desc'): <T extends WithBoundary, A extends IterableContainer<T>>(array: A) => ReorderedArray<A>;
declare function sortConnectionsByBoundaryHierarchy<T extends WithBoundary, A extends IterableContainer<T>>(array: A, sort?: 'asc' | 'desc'): ReorderedArray<A>;
/**
 * Find connections that includes given connection (i.e between it's ancestors)
 */
declare function findAscendingConnections<C extends ConnectionElemId>(connections: ReadonlyArray<C>, connection: C): Array<C>;
/**
 * Find connections that given connection includes (i.e between it's descendants)
 */
declare function findDescendantConnections<C extends ConnectionElemId>(connections: ReadonlyArray<C>, connection: C): Array<C>;
declare function mergeConnections<C extends IterableContainer<Connection<any, any>>>(connections: C): Array<C[number]>;
/**
 * Excludes the values existing in `other` array.
 * The output maintains the same order as the input.
 */
declare function differenceConnections<C extends Connection<any, any>>(source: Iterable<C>, exclude: Iterable<C>): C[];
type WithSourceTarget<T = unknown> = {
  source: T;
  target: T;
};
declare function hasSameSourceTarget<T>(a: WithSourceTarget<NoInfer<T>>): (b: WithSourceTarget<T>) => boolean;
declare function hasSameSourceTarget<T>(a: WithSourceTarget<T>, b: WithSourceTarget<T>): boolean;
declare function hasSameSource<T>(a: WithSourceTarget<NoInfer<T>>): (b: WithSourceTarget<T>) => boolean;
declare function hasSameSource<T>(a: WithSourceTarget<T>, b: WithSourceTarget<T>): boolean;
declare function hasSameTarget<T>(a: WithSourceTarget<NoInfer<T>>): (b: WithSourceTarget<T>) => boolean;
declare function hasSameTarget<T>(a: WithSourceTarget<T>, b: WithSourceTarget<T>): boolean;
type WithId<T> = {
  id: T;
};
declare function isOutgoing<T extends string>(source: WithId<NoInfer<T>>): (a: WithSourceTarget<WithId<T>>) => boolean;
declare function isOutgoing<T extends string>(a: WithSourceTarget<WithId<T>>, source: WithId<T>): boolean;
declare function isIncoming<T extends string>(target: WithId<NoInfer<T>>): (a: WithSourceTarget<WithId<T>>) => boolean;
declare function isIncoming<T extends string>(a: WithSourceTarget<WithId<T>>, target: WithId<T>): boolean;
declare function isAnyInOut<T extends string>(source: WithId<NoInfer<T>>): (a: WithSourceTarget<WithId<T>>) => boolean;
declare function isAnyInOut<T extends string>(a: WithSourceTarget<WithId<T>>, source: WithId<T>): boolean;
declare namespace find_d_exports$1 {
  export { findConnection$1 as findConnection, findConnectionsBetween$1 as findConnectionsBetween, findConnectionsWithin$1 as findConnectionsWithin };
}
/**
 * Resolve connection from source to target
 * If direction is `both`, also look for reverse connection
 *
 * @default direction directed
 */
declare function findConnection$1<M extends Any>(source: DeploymentElementModel<M>, target: DeploymentElementModel<NoInfer<M>>, direction: 'directed'): readonly [DeploymentConnectionModel<M>] | readonly [];
declare function findConnection$1<M extends Any>(source: DeploymentElementModel<M>, target: DeploymentElementModel<NoInfer<M>>, direction: 'both'): readonly [DeploymentConnectionModel<M>, DeploymentConnectionModel<M>] | readonly [DeploymentConnectionModel<M>] | readonly [];
declare function findConnection$1<M extends Any>(source: DeploymentElementModel<M>, target: DeploymentElementModel<NoInfer<M>>, direction?: 'directed' | 'both'): readonly [DeploymentConnectionModel<M>, DeploymentConnectionModel<M>] | readonly [DeploymentConnectionModel<M>] | readonly [];
/**
 * Resolve all connections between element and others
 * By default, look for both directions.
 *
 * @default direction both
 */
declare function findConnectionsBetween$1<M extends Any>(element: DeploymentElementModel<M>, others: Iterable<DeploymentElementModel<NoInfer<M>>>, direction?: 'directed' | 'both'): readonly DeploymentConnectionModel<M>[];
/**
 * Resolve all connections within a given set of elements
 */
declare function findConnectionsWithin$1<M extends Any>(elements: Iterable<DeploymentElementModel<M>>): readonly DeploymentConnectionModel<M>[];
declare namespace find_d_exports {
  export { findConnection, findConnectionsBetween, findConnectionsWithin };
}
/**
 * Resolve connection from source to target
 *
 * @param direction - if 'both', also returns connection from target to source
 * @default `directed`
 */
declare function findConnection<A extends Any>(source: ElementModel<A>, target: ElementModel<A>, direction?: 'directed' | 'both'): [ConnectionModel<A>, ConnectionModel<A>] | [ConnectionModel<A>] | [];
/**
 * Resolve all connections between element and others
 * @param direction - if 'directed', only look for outgoing connections from the element to others
 * @default `both`
 */
declare function findConnectionsBetween<M extends Any>(element: ElementModel<M>, others: Iterable<ElementModel<M>>, direction?: 'directed' | 'both'): readonly ConnectionModel<M>[];
/**
 * Resolve all connections within a given set of elements
 */
declare function findConnectionsWithin<M extends Any>(elements: Iterable<ElementModel<M>>): readonly ConnectionModel<M>[];
//#endregion
//#region src/model/guards.d.ts
type AnyModel<A extends Any> = DeploymentNodeModel<A> | DeployedInstanceModel<A> | DeploymentRelationModel<A> | AnyRelationshipModel<A> | NestedElementOfDeployedInstanceModel<A> | ElementModel<A> | RelationshipModel<A> | LikeC4ViewModel<A> | NodeModel<A> | EdgeModel<A>;
declare function isDeploymentNodeModel<M extends Any>(model: AnyModel<M>): model is DeploymentNodeModel<M>;
declare function isDeployedInstanceModel<M extends Any>(model: AnyModel<M>): model is DeployedInstanceModel<M>;
declare function isDeploymentElementModel<M extends Any>(model: AnyModel<M>): model is DeploymentElementModel<M>;
declare function isNestedElementOfDeployedInstanceModel<M extends Any>(model: AnyModel<M>): model is NestedElementOfDeployedInstanceModel<M>;
declare function isDeploymentRelationModel<M extends Any>(x: AnyModel<M>): x is DeploymentRelationModel<M>;
declare function isRelationModel<M extends Any>(x: AnyModel<M>): x is RelationshipModel<M>;
declare function isElementModel<M extends Any>(element: AnyModel<M>): element is ElementModel<M>;
declare function isLikeC4ViewModel<M extends Any>(view: AnyModel<M>): view is LikeC4ViewModel<M>;
declare function isNodeModel<M extends Any>(node: AnyModel<M>): node is NodeModel<M>;
declare function isEdgeModel<M extends Any>(edge: AnyModel<M>): edge is EdgeModel<M>;
//#endregion
//#region src/model/utils/view-title-path.d.ts
declare const VIEW_FOLDERS_SEPARATOR = "/";
/**
 * Normalizes view path by removing spaces from segments, removing empty segments,
 * and removing leading/trailing slashes
 * @example
 * normalizeViewPath('One / Tw o / Thre e') === 'One/Tw o/Thre e'
 */
declare const normalizeViewPath: (title: string) => string;
/**
 * Returns view group path if it is used as a path
 * Returns empty string if it is not a path
 * @example
 * getViewFolderPath('One / Tw o / Thre e') === 'One/Tw o'
 * getViewFolderPath('One') === ''
 */
declare const getViewFolderPath: (title: string) => string | null;
/**
 * Returns view title if it is used as a path
 * @example
 * getViewTitleFromPath('One / Tw o / Thre e') === 'Thre e'
 * getViewTitleFromPath('One') === 'One'
 */
declare const extractViewTitleFromPath: (title: string) => string;
//#endregion
export { sortDeepestFirst as A, hasSameTarget as C, isOutgoing as D, isNestedConnection as E, DeploymentConnectionModel as M, Connection as N, mergeConnections as O, hasSameSourceTarget as S, isIncoming as T, differenceConnections as _, isDeployedInstanceModel as a, findDescendantConnections as b, isDeploymentRelationModel as c, isLikeC4ViewModel as d, isNestedElementOfDeployedInstanceModel as f, find_d_exports$1 as g, find_d_exports as h, normalizeViewPath as i, ConnectionModel as j, sortConnectionsByBoundaryHierarchy as k, isEdgeModel as l, isRelationModel as m, extractViewTitleFromPath as n, isDeploymentElementModel as o, isNodeModel as p, getViewFolderPath as r, isDeploymentNodeModel as s, VIEW_FOLDERS_SEPARATOR as t, isElementModel as u, findAscendingConnections as v, isAnyInOut as w, hasSameSource as x, findDeepestNestedConnection as y };