@likec4/core 1.8.1 → 1.10.0

package/dist/index.d.cts

@@ -0,0 +1,793 @@
+import { P as Primitive, H as HexColorLiteral, T as ThemeColorValues, L as LiteralUnion, F as Fqn$1, R as RelationID$1, V as ViewID$1, E as EdgeId$1, C as ComputedView, a as Tag, b as ComputedNode, N as NodeId, c as ElementKind, d as ElementShape, e as Color, f as ComputedEdge, g as ComputedLikeC4Model, h as Element, i as Relation, j as RelationshipKind, k as NonEmptyArray } from './shared/core.CpR2fq5B.cjs';
+export { aq as AndOperator, A as AsFqn, aP as AutoLayoutDirection, bl as BBox, aU as BasicElementView, aT as BasicView, o as BorderStyle, B as BorderStyles, aE as ColorLiteral, bi as ComputedDynamicView, bh as ComputedElementView, m as CustomColor, b4 as CustomColorDefinitions, G as CustomElementExpr, ad as CustomRelationExpr, aA as DefaultArrowType, q as DefaultElementShape, az as DefaultLineStyle, aB as DefaultRelationshipColor, D as DefaultThemeColor, bo as DiagramEdge, bn as DiagramNode, bp as DiagramView, b2 as DynamicView, a$ as DynamicViewIncludeRule, aZ as DynamicViewParallelSteps, b1 as DynamicViewRule, aY as DynamicViewStep, a_ as DynamicViewStepOrParallel, U as ElementExpression, M as ElementKindExpr, v as ElementKindSpecification, u as ElementKindSpecificationStyle, bs as ElementNotation, $ as ElementPredicateExpression, w as ElementRefExpr, p as ElementShapes, r as ElementStyle, Q as ElementTagExpr, aG as ElementThemeColorValues, aH as ElementThemeColors, aX as ElementView, Z as ElementWhereExpr, aj as EqualOperator, y as ExpandedElementExpr, l as Expr, ah as Expression, aW as ExtendsElementView, I as IconUrl, a3 as InOutExpr, a5 as IncomingExpr, am as KindEqual, aK as LikeC4Theme, b5 as LikeC4View, t as Link, ao as NotOperator, as as OrOperator, a7 as OutgoingExpr, aw as OverviewGraph, ai as ParsedLikeC4Model, n as Point, a1 as RelationExpr, a9 as RelationExpression, af as RelationPredicateExpression, ab as RelationWhereExpr, ay as RelationshipArrowType, aC as RelationshipKindSpecification, ax as RelationshipLineType, aI as RelationshipThemeColorValues, aJ as RelationshipThemeColors, aV as ScopedElementView, bb as StepEdgeId, ba as StepEdgeIdLiteral, ak as TagEqual, s as TagSpec, aD as ThemeColor, br as ViewChange, bq as ViewManualLayout, aS as ViewRule, aQ as ViewRuleAutoLayout, aL as ViewRulePredicate, aN as ViewRuleStyle, bf as ViewWithHash, bg as ViewWithNotation, au as WhereOperator, W as WildcardExpr, X as XYPoint, bd as extractStep, bm as getBBoxCenter, be as getParallelStepsPrefix, ar as isAndOperator, bj as isComputedDynamicView, bk as isComputedElementView, J as isCustomElement, ae as isCustomRelationExpr, b6 as isDynamicView, b0 as isDynamicViewIncludeRule, b3 as isDynamicViewParallelSteps, Y as isElement, O as isElementKindExpr, a0 as isElementPredicateExpr, x as isElementRef, S as isElementTagExpr, b7 as isElementView, _ as isElementWhere, z as isExpandedElementExpr, b8 as isExtendsElementView, a4 as isInOut, a6 as isIncoming, an as isKindEqual, ap as isNotOperator, at as isOrOperator, a8 as isOutgoing, a2 as isRelation, aa as isRelationExpression, ag as isRelationPredicateExpr, ac as isRelationWhere, b9 as isScopedElementView, bc as isStepEdgeId, al as isTagEqual, aF as isThemeColor, aR as isViewRuleAutoLayout, aM as isViewRulePredicate, aO as isViewRuleStyle, K as isWildcard, av as whereOperatorAsPredicate } from './shared/core.CpR2fq5B.cjs';
+
+type Numeric = number | bigint;
+
+/**
+Returns a boolean for whether the given type is `never`.
+
+@link https://github.com/microsoft/TypeScript/issues/31751#issuecomment-498526919
+@link https://stackoverflow.com/a/53984913/10292952
+@link https://www.zhenghao.io/posts/ts-never
+
+Useful in type utilities, such as checking if something does not occur.
+
+@example
+```
+import type {IsNever, And} from 'type-fest';
+
+// https://github.com/andnp/SimplyTyped/blob/master/src/types/strings.ts
+type AreStringsEqual<A extends string, B extends string> =
+	And<
+		IsNever<Exclude<A, B>> extends true ? true : false,
+		IsNever<Exclude<B, A>> extends true ? true : false
+	>;
+
+type EndIfEqual<I extends string, O extends string> =
+	AreStringsEqual<I, O> extends true
+		? never
+		: void;
+
+function endIfEqual<I extends string, O extends string>(input: I, output: O): EndIfEqual<I, O> {
+	if (input === output) {
+		process.exit(0);
+	}
+}
+
+endIfEqual('abc', 'abc');
+//=> never
+
+endIfEqual('abc', '123');
+//=> void
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsNever<T> = [T] extends [never] ? true : false;
+
+/**
+Returns a boolean for whether the given type `T` is the specified `LiteralType`.
+
+@link https://stackoverflow.com/a/52806744/10292952
+
+@example
+```
+LiteralCheck<1, number>
+//=> true
+
+LiteralCheck<number, number>
+//=> false
+
+LiteralCheck<1, string>
+//=> false
+```
+*/
+type LiteralCheck<T, LiteralType extends Primitive> = (
+	IsNever<T> extends false // Must be wider than `never`
+		? [T] extends [LiteralType & infer U] // Remove any branding
+			? [U] extends [LiteralType] // Must be narrower than `LiteralType`
+				? [LiteralType] extends [U] // Cannot be wider than `LiteralType`
+					? false
+					: true
+				: false
+			: false
+		: false
+);
+
+/**
+Returns a boolean for whether the given type `T` is one of the specified literal types in `LiteralUnionType`.
+
+@example
+```
+LiteralChecks<1, Numeric>
+//=> true
+
+LiteralChecks<1n, Numeric>
+//=> true
+
+LiteralChecks<bigint, Numeric>
+//=> false
+```
+*/
+type LiteralChecks<T, LiteralUnionType> = (
+	// Conditional type to force union distribution.
+	// If `T` is none of the literal types in the union `LiteralUnionType`, then `LiteralCheck<T, LiteralType>` will evaluate to `false` for the whole union.
+	// If `T` is one of the literal types in the union, it will evaluate to `boolean` (i.e. `true | false`)
+	IsNotFalse<LiteralUnionType extends Primitive
+		? LiteralCheck<T, LiteralUnionType>
+		: never
+	>
+);
+
+/**
+Returns a boolean for whether the given type is a `number` or `bigint` [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
+
+Useful for:
+	- providing strongly-typed functions when given literal arguments
+	- type utilities, such as when constructing parsers and ASTs
+
+@example
+```
+import type {IsNumericLiteral} from 'type-fest';
+
+// https://github.com/inocan-group/inferred-types/blob/master/src/types/boolean-logic/EndsWith.ts
+type EndsWith<TValue, TEndsWith extends string> =
+	TValue extends string
+		? IsStringLiteral<TEndsWith> extends true
+			? IsStringLiteral<TValue> extends true
+				? TValue extends `${string}${TEndsWith}`
+					? true
+					: false
+				: boolean
+			: boolean
+		: TValue extends number
+			? IsNumericLiteral<TValue> extends true
+				? EndsWith<`${TValue}`, TEndsWith>
+				: false
+			: false;
+
+function endsWith<Input extends string | number, End extends string>(input: Input, end: End) {
+	return `${input}`.endsWith(end) as EndsWith<Input, End>;
+}
+
+endsWith('abc', 'c');
+//=> true
+
+endsWith(123456, '456');
+//=> true
+
+const end = '123' as string;
+
+endsWith('abc123', end);
+//=> boolean
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsNumericLiteral<T> = LiteralChecks<T, Numeric>;
+
+/**
+Returns a boolean for whether the given `boolean` is not `false`.
+*/
+type IsNotFalse<T extends boolean> = [T] extends [false] ? false : true;
+
+declare const ElementColors: {
+    readonly primary: {
+        fill: "#3b82f6";
+        stroke: "#2563eb";
+        hiContrast: "#eff6ff";
+        loContrast: "#bfdbfe";
+    };
+    readonly blue: {
+        fill: "#3b82f6";
+        stroke: "#2563eb";
+        hiContrast: "#eff6ff";
+        loContrast: "#bfdbfe";
+    };
+    readonly secondary: {
+        fill: "#0284c7";
+        stroke: "#0369a1";
+        hiContrast: "#f0f9ff";
+        loContrast: "#B6ECF7";
+    };
+    readonly sky: {
+        fill: "#0284c7";
+        stroke: "#0369a1";
+        hiContrast: "#f0f9ff";
+        loContrast: "#B6ECF7";
+    };
+    readonly muted: {
+        fill: "#64748b";
+        stroke: "#475569";
+        hiContrast: "#f8fafc";
+        loContrast: "#cbd5e1";
+    };
+    readonly slate: {
+        fill: "#64748b";
+        stroke: "#475569";
+        hiContrast: "#f8fafc";
+        loContrast: "#cbd5e1";
+    };
+    readonly gray: {
+        readonly fill: "#737373";
+        readonly stroke: "#525252";
+        readonly hiContrast: "#fafafa";
+        readonly loContrast: "#d4d4d4";
+    };
+    readonly red: {
+        readonly fill: "#AC4D39";
+        readonly stroke: "#853A2D";
+        readonly hiContrast: "#FBD3CB";
+        readonly loContrast: "#f5b2a3";
+    };
+    readonly green: {
+        readonly fill: "#428a4f";
+        readonly stroke: "#2d5d39";
+        readonly hiContrast: "#f8fafc";
+        readonly loContrast: "#c2f0c2";
+    };
+    readonly amber: {
+        readonly fill: "#A35829";
+        readonly stroke: "#7E451D";
+        readonly hiContrast: "#FFE0C2";
+        readonly loContrast: "#f9b27c";
+    };
+    readonly indigo: {
+        readonly fill: "#6366f1";
+        readonly stroke: "#4f46e5";
+        readonly hiContrast: "#eef2ff";
+        readonly loContrast: "#c7d2fe";
+    };
+};
+
+declare const RelationshipColors: {
+    amber: {
+        lineColor: "#b45309";
+        labelBgColor: "#78350f";
+        labelColor: "#FFE0C2";
+    };
+    blue: {
+        lineColor: "#3b82f6";
+        labelBgColor: "#172554";
+        labelColor: "#60a5fa";
+    };
+    gray: {
+        lineColor: "#6E6E6E";
+        labelBgColor: "#18191b";
+        labelColor: "#C6C6C6";
+    };
+    green: {
+        lineColor: "#15803d";
+        labelBgColor: "#052e16";
+        labelColor: "#22c55e";
+    };
+    indigo: {
+        lineColor: "#6366f1";
+        labelBgColor: "#1e1b4b";
+        labelColor: "#818cf8";
+    };
+    muted: {
+        lineColor: "#64748b";
+        labelBgColor: "#0f172a";
+        labelColor: "#cbd5e1";
+    };
+    primary: {
+        lineColor: "#3b82f6";
+        labelBgColor: "#172554";
+        labelColor: "#60a5fa";
+    };
+    red: {
+        lineColor: "#AC4D39";
+        labelBgColor: "#b91c1c";
+        labelColor: "#f5b2a3";
+    };
+    secondary: {
+        lineColor: "#0ea5e9";
+        labelBgColor: "#082f49";
+        labelColor: "#38bdf8";
+    };
+    sky: {
+        lineColor: "#0ea5e9";
+        labelBgColor: "#082f49";
+        labelColor: "#38bdf8";
+    };
+    slate: {
+        lineColor: "#64748b";
+        labelBgColor: "#0f172a";
+        labelColor: "#cbd5e1";
+    };
+};
+
+declare const defaultTheme: {
+    elements: {
+        readonly primary: {
+            fill: "#3b82f6";
+            stroke: "#2563eb";
+            hiContrast: "#eff6ff";
+            loContrast: "#bfdbfe";
+        };
+        readonly blue: {
+            fill: "#3b82f6";
+            stroke: "#2563eb";
+            hiContrast: "#eff6ff";
+            loContrast: "#bfdbfe";
+        };
+        readonly secondary: {
+            fill: "#0284c7";
+            stroke: "#0369a1";
+            hiContrast: "#f0f9ff";
+            loContrast: "#B6ECF7";
+        };
+        readonly sky: {
+            fill: "#0284c7";
+            stroke: "#0369a1";
+            hiContrast: "#f0f9ff";
+            loContrast: "#B6ECF7";
+        };
+        readonly muted: {
+            fill: "#64748b";
+            stroke: "#475569";
+            hiContrast: "#f8fafc";
+            loContrast: "#cbd5e1";
+        };
+        readonly slate: {
+            fill: "#64748b";
+            stroke: "#475569";
+            hiContrast: "#f8fafc";
+            loContrast: "#cbd5e1";
+        };
+        readonly gray: {
+            readonly fill: "#737373";
+            readonly stroke: "#525252";
+            readonly hiContrast: "#fafafa";
+            readonly loContrast: "#d4d4d4";
+        };
+        readonly red: {
+            readonly fill: "#AC4D39";
+            readonly stroke: "#853A2D";
+            readonly hiContrast: "#FBD3CB";
+            readonly loContrast: "#f5b2a3";
+        };
+        readonly green: {
+            readonly fill: "#428a4f";
+            readonly stroke: "#2d5d39";
+            readonly hiContrast: "#f8fafc";
+            readonly loContrast: "#c2f0c2";
+        };
+        readonly amber: {
+            readonly fill: "#A35829";
+            readonly stroke: "#7E451D";
+            readonly hiContrast: "#FFE0C2";
+            readonly loContrast: "#f9b27c";
+        };
+        readonly indigo: {
+            readonly fill: "#6366f1";
+            readonly stroke: "#4f46e5";
+            readonly hiContrast: "#eef2ff";
+            readonly loContrast: "#c7d2fe";
+        };
+    };
+    relationships: {
+        amber: {
+            lineColor: "#b45309";
+            labelBgColor: "#78350f";
+            labelColor: "#FFE0C2";
+        };
+        blue: {
+            lineColor: "#3b82f6";
+            labelBgColor: "#172554";
+            labelColor: "#60a5fa";
+        };
+        gray: {
+            lineColor: "#6E6E6E";
+            labelBgColor: "#18191b";
+            labelColor: "#C6C6C6";
+        };
+        green: {
+            lineColor: "#15803d";
+            labelBgColor: "#052e16";
+            labelColor: "#22c55e";
+        };
+        indigo: {
+            lineColor: "#6366f1";
+            labelBgColor: "#1e1b4b";
+            labelColor: "#818cf8";
+        };
+        muted: {
+            lineColor: "#64748b";
+            labelBgColor: "#0f172a";
+            labelColor: "#cbd5e1";
+        };
+        primary: {
+            lineColor: "#3b82f6";
+            labelBgColor: "#172554";
+            labelColor: "#60a5fa";
+        };
+        red: {
+            lineColor: "#AC4D39";
+            labelBgColor: "#b91c1c";
+            labelColor: "#f5b2a3";
+        };
+        secondary: {
+            lineColor: "#0ea5e9";
+            labelBgColor: "#082f49";
+            labelColor: "#38bdf8";
+        };
+        sky: {
+            lineColor: "#0ea5e9";
+            labelBgColor: "#082f49";
+            labelColor: "#38bdf8";
+        };
+        slate: {
+            lineColor: "#64748b";
+            labelBgColor: "#0f172a";
+            labelColor: "#cbd5e1";
+        };
+    };
+    font: "Arial";
+    shadow: "#0a0a0a";
+};
+declare function computeColorValues(color: HexColorLiteral): ThemeColorValues;
+
+declare function nonNullable<T>(value: T, message?: string): NonNullable<T>;
+declare function invariant(condition: any, message?: string): asserts condition;
+declare function nonexhaustive(value: never): never;
+
+type Fqn = LiteralUnion<Fqn$1, string>;
+type RelationID = LiteralUnion<RelationID$1, string>;
+type ViewID = LiteralUnion<ViewID$1, string>;
+type EdgeId = LiteralUnion<EdgeId$1, string>;
+
+type ElementOrFqn$1 = Fqn | LikeC4ViewModel.Element;
+/**
+ * All methods are view-scoped, i.e. only return elements and connections in the view.
+ */
+declare class LikeC4ViewModel {
+    #private;
+    readonly view: ComputedView;
+    readonly model: LikeC4Model;
+    constructor(view: ComputedView, model: LikeC4Model);
+    get id(): ViewID$1;
+    get title(): string;
+    get viewOf(): LikeC4Model.Element;
+    get tags(): Tag[];
+    roots(): ReadonlyArray<LikeC4ViewModel.Element>;
+    elements(): ReadonlyArray<LikeC4ViewModel.Element>;
+    element(id: Fqn): LikeC4ViewModel.Element;
+    hasElement(id: Fqn): boolean;
+    connections(): ReadonlyArray<LikeC4ViewModel.Connection>;
+    connection(id: EdgeId): LikeC4ViewModel.Connection;
+    findConnections(source: ElementOrFqn$1, target: ElementOrFqn$1, direction?: 'both' | 'direct'): ReadonlyArray<LikeC4ViewModel.Connection>;
+    parent(element: ElementOrFqn$1): LikeC4ViewModel.Element | null;
+    children(element: ElementOrFqn$1): ReadonlyArray<LikeC4ViewModel.Element>;
+    siblings(element: ElementOrFqn$1): ReadonlyArray<LikeC4ViewModel.Element>;
+    /**
+     * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
+     * (from closest to root)
+     */
+    ancestors(element: ElementOrFqn$1): ReadonlyArray<LikeC4ViewModel.Element>;
+    descendants(element: ElementOrFqn$1): ReadonlyArray<LikeC4ViewModel.Element>;
+    incoming(element: ElementOrFqn$1, filter?: 'all' | 'direct' | 'to-descendants'): ReadonlyArray<LikeC4ViewModel.Connection>;
+    incomers(element: ElementOrFqn$1, filter?: 'all' | 'direct' | 'to-descendants'): ReadonlyArray<LikeC4ViewModel.Element>;
+    /**
+     * Outgoing relationships from the element and its descendants
+     */
+    outgoing(element: ElementOrFqn$1, filter?: 'all' | 'direct' | 'from-descendants'): ReadonlyArray<LikeC4ViewModel.Connection>;
+    outgoers(element: ElementOrFqn$1, filter?: 'all' | 'direct' | 'from-descendants'): ReadonlyArray<LikeC4ViewModel.Element>;
+}
+declare namespace LikeC4ViewModel {
+    /**
+     * Represents an element in the view. (Diagram node)
+     * All methods are view-scoped, i.e. `children` returns only children of the element in the view.
+     */
+    class Element {
+        readonly node: ComputedNode;
+        private viewmodel;
+        constructor(node: ComputedNode, viewmodel: LikeC4ViewModel);
+        get id(): NodeId;
+        get title(): string;
+        get kind(): ElementKind;
+        get isRoot(): boolean;
+        get hasNested(): boolean;
+        get shape(): ElementShape;
+        get color(): Color;
+        get tags(): Tag[];
+        model(): LikeC4Model.Element;
+        parent(): LikeC4ViewModel.Element | null;
+        metadata(key: string): string | undefined;
+        metadata(key: string, defaultValue: string): string;
+        hasMetadata(key: string): boolean;
+        ancestors(): ReadonlyArray<LikeC4ViewModel.Element>;
+        siblings(): ReadonlyArray<LikeC4ViewModel.Element>;
+        descendants(): ReadonlyArray<LikeC4ViewModel.Element>;
+        children(): ReadonlyArray<LikeC4ViewModel.Element>;
+        incoming(filter?: 'all' | 'direct' | 'to-descendants'): ReadonlyArray<LikeC4ViewModel.Connection>;
+        incomers(filter?: 'all' | 'direct' | 'to-descendants'): ReadonlyArray<LikeC4ViewModel.Element>;
+        outgoing(filter?: 'all' | 'direct' | 'from-descendants'): ReadonlyArray<LikeC4ViewModel.Connection>;
+        outgoers(filter?: 'all' | 'direct' | 'from-descendants'): ReadonlyArray<LikeC4ViewModel.Element>;
+        connectionsTo(target: Fqn | LikeC4ViewModel.Element): ReadonlyArray<LikeC4ViewModel.Connection>;
+    }
+    /**
+     * Represents a connection between two elements.
+     * May be source from multiple model relationships.
+     */
+    class Connection {
+        readonly edge: ComputedEdge;
+        private viewmodel;
+        constructor(edge: ComputedEdge, viewmodel: LikeC4ViewModel);
+        get id(): EdgeId$1;
+        get source(): LikeC4ViewModel.Element;
+        get target(): LikeC4ViewModel.Element;
+        get tags(): Tag[];
+        /**
+         * Model relationships
+         */
+        relationships(): ReadonlyArray<LikeC4Model.Relationship>;
+    }
+}
+
+type ElementOrFqn = Fqn | LikeC4Model.Element;
+declare class LikeC4Model {
+    #private;
+    protected computed: ComputedLikeC4Model;
+    static from(computed: ComputedLikeC4Model): LikeC4Model;
+    protected constructor(computed: ComputedLikeC4Model);
+    /**
+     * Returns the root elements of the model.
+     */
+    roots(): ReadonlyArray<LikeC4Model.Element>;
+    /**
+     * Returns all elements in the model.
+     */
+    elements(): ReadonlyArray<LikeC4Model.Element>;
+    /**
+     * Returns a specific element by its FQN.
+     */
+    element(id: Fqn): LikeC4Model.Element;
+    /**
+     * Returns all relationships in the model.
+     */
+    relationships(): ReadonlyArray<LikeC4Model.Relationship>;
+    /**
+     * Returns a specific relationship by its ID.
+     */
+    relationship(id: RelationID): LikeC4Model.Relationship;
+    /**
+     * Returns all views in the model.
+     */
+    views(): ReadonlyArray<LikeC4ViewModel>;
+    /**
+     * Returns a specific view by its ID.
+     */
+    view(viewId: ViewID): LikeC4ViewModel;
+    /**
+     * Returns the parent element of given element.
+     * @see ancestors
+     */
+    parent(element: ElementOrFqn): LikeC4Model.Element | null;
+    /**
+     * Get all children of the element (only direct children),
+     * @see descendants
+     */
+    children(element: ElementOrFqn): ReadonlyArray<LikeC4Model.Element>;
+    /**
+     * Get all sibling (i.e. same parent)
+     */
+    siblings(element: ElementOrFqn): ReadonlyArray<LikeC4Model.Element>;
+    /**
+     * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
+     * (from closest to root)
+     */
+    ancestors(element: ElementOrFqn): ReadonlyArray<LikeC4Model.Element>;
+    /**
+     * Get all descendant elements (i.e. children, children’s children, etc.)
+     */
+    descendants(element: ElementOrFqn): ReadonlyArray<LikeC4Model.Element>;
+    /**
+     * Incoming relationships to the element and its descendants
+     * @see incomers
+     */
+    incoming(element: ElementOrFqn, filter?: 'all' | 'direct' | 'to-descendants'): ReadonlyArray<LikeC4Model.Relationship>;
+    /**
+     * Source elements of incoming relationships
+     */
+    incomers(element: ElementOrFqn, filter?: 'all' | 'direct' | 'to-descendants'): ReadonlyArray<LikeC4Model.Element>;
+    /**
+     * Outgoing relationships from the element and its descendants
+     * @see outgoers
+     */
+    outgoing(element: ElementOrFqn, filter?: 'all' | 'direct' | 'from-descendants'): ReadonlyArray<LikeC4Model.Relationship>;
+    /**
+     * Target elements of outgoing relationships
+     */
+    outgoers(element: ElementOrFqn, filter?: 'all' | 'direct' | 'from-descendants'): ReadonlyArray<LikeC4Model.Element>;
+    /**
+     * Relationships inside the element, among descendants
+     */
+    internal(element: ElementOrFqn): ReadonlyArray<LikeC4Model.Relationship>;
+    /**
+     * Resolve siblings of the element and siblings of ancestors
+     *  (from closest to root)
+     */
+    ascendingSiblings(element: ElementOrFqn): ReadonlyArray<LikeC4Model.Element>;
+    /**
+     * Resolve all views that contain the element
+     */
+    viewsWithElement(element: ElementOrFqn): ReadonlyArray<LikeC4ViewModel>;
+    private addElement;
+    private addRelation;
+    private _childrenOf;
+    private _incomingTo;
+    private _outgoingFrom;
+    private _internalOf;
+}
+declare namespace LikeC4Model {
+    class Element {
+        readonly element: Element;
+        private model;
+        constructor(element: Element, model: LikeC4Model);
+        get id(): Fqn$1;
+        get title(): string;
+        get kind(): ElementKind;
+        get isRoot(): boolean;
+        get hasNested(): boolean;
+        get shape(): ElementShape;
+        get color(): Color;
+        get tags(): Tag[];
+        parent(): LikeC4Model.Element | null;
+        metadata(key: string): string | undefined;
+        metadata(key: string, defaultValue: string): string;
+        hasMetadata(key: string): boolean;
+        ancestors(): readonly Element[];
+        siblings(): readonly Element[];
+        descendants(): readonly Element[];
+        children(): readonly Element[];
+        /**
+         * Views that contain this element
+         */
+        views(): readonly LikeC4ViewModel[];
+        incoming(filter?: 'all' | 'direct' | 'to-descendants'): readonly Relationship[];
+        incomers(filter?: 'all' | 'direct' | 'to-descendants'): readonly Element[];
+        outgoing(filter?: 'all' | 'direct' | 'from-descendants'): readonly Relationship[];
+        outgoers(filter?: 'all' | 'direct' | 'from-descendants'): readonly Element[];
+        internal(): readonly Relationship[];
+    }
+    class Relationship {
+        readonly relationship: Relation;
+        private model;
+        constructor(relationship: Relation, model: LikeC4Model);
+        get id(): RelationID$1;
+        get title(): string;
+        get kind(): RelationshipKind;
+        get tags(): Tag[];
+        get source(): LikeC4Model.Element;
+        get target(): LikeC4Model.Element;
+        metadata(key: string): string | undefined;
+        metadata(key: string, defaultValue: string): string;
+        hasMetadata(key: string): boolean;
+    }
+}
+
+declare function compareNatural(a: string | undefined, b: string | undefined): -1 | 0 | 1;
+
+type Predicate<T> = (x: T) => boolean;
+declare function nameFromFqn(fqn: Fqn$1): string;
+declare function isAncestor<E extends {
+    id: Fqn$1;
+}>(...args: [ancestor: string, another: string] | [ancestor: E, another: E]): boolean;
+declare function isSameHierarchy<E extends {
+    id: Fqn$1;
+}>(one: E | Fqn$1, another: E | Fqn$1): boolean;
+declare function isDescendantOf<E extends {
+    id: Fqn$1;
+}>(ancestors: E[]): (e: E) => boolean;
+declare function notDescendantOf(ancestors: Element[]): (e: Element) => boolean;
+declare function commonAncestor(first: Fqn$1, second: Fqn$1): Fqn$1;
+declare function parentFqn(fqn: Fqn$1): Fqn$1 | null;
+declare function parentFqnPredicate<T extends {
+    parent: Fqn$1 | null;
+}>(parent: Fqn$1): Predicate<T>;
+/**
+ * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
+ * (from closest to root)
+ */
+declare function ancestorsFqn(fqn: Fqn$1): Fqn$1[];
+/**
+ * Compares two fully qualified names (fqns) hierarchically based on their depth.
+ * From parent nodes to leaves
+ *
+ * @param {string} a - The first fqn to compare.
+ * @param {string} b - The second fqn to compare.
+ * @returns {number} - 0 if the fqns have the same depth.
+ *                    - Positive number if a is deeper than b.
+ *                    - Negative number if b is deeper than a.
+ */
+declare function compareFqnHierarchically<T extends string = string>(a: T, b: T): -1 | 0 | 1;
+declare function compareByFqnHierarchically<T extends {
+    id: string;
+}>(a: T, b: T): 0 | 1 | -1;
+type IterableContainer$1<T = unknown> = ReadonlyArray<T> | readonly [];
+type ReorderedArray<T extends IterableContainer$1> = {
+    -readonly [P in keyof T]: T[number];
+};
+declare function sortByFqnHierarchically<T extends {
+    id: string;
+}, A extends IterableContainer$1<T>>(array: A): ReorderedArray<A>;
+declare function sortNaturalByFqn<T extends {
+    id: string;
+}, A extends IterableContainer$1<T>>(array: A): ReorderedArray<A>;
+
+/**
+ * This should only be used for defining generics which extend any kind of JS
+ * array under the hood, this includes arrays *AND* tuples (of the form [x, y],
+ * and of the form [x, ...y[]], etc...), and their readonly equivalent. This
+ * allows us to be more inclusive to what functions can process.
+ *
+ * @example map<T extends ArrayLike>(items: T) { ... }
+ *
+ * We would've named this `ArrayLike`, but that's already used by typescript...
+ * @see This was inspired by the type-definition of Promise.all (https://github.com/microsoft/TypeScript/blob/1df5717b120cddd325deab8b0f2b2c3eecaf2b01/src/lib/es2015.promise.d.ts#L21)
+ */
+type IterableContainer<T = unknown> = ReadonlyArray<T> | readonly [];
+
+type ArraySetRequired<T extends IterableContainer, Min extends number, Iteration extends ReadonlyArray<unknown> = []> = number extends Min ? never : Iteration["length"] extends Min ? T : T extends readonly [] ? never : T extends [infer Head, ...infer Rest] ? [
+    Head,
+    ...ArraySetRequired<Rest, Min, [unknown, ...Iteration]>
+] : T extends readonly [infer Head, ...infer Rest] ? readonly [
+    Head,
+    ...ArraySetRequired<Rest, Min, [unknown, ...Iteration]>
+] : T extends Array<infer Item> ? [
+    Item,
+    ...ArraySetRequired<T, Min, [unknown, ...Iteration]>
+] : T extends ReadonlyArray<infer Item> ? readonly [
+    Item,
+    ...ArraySetRequired<T, Min, [unknown, ...Iteration]>
+] : never;
+/**
+ * Checks if the given array has at least the defined number of elements. When
+ * the minimum used is a literal (e.g. `3`) the output is refined accordingly so
+ * that those indices are defined when accessing the array even when using
+ * typescript's 'noUncheckedIndexAccess'.
+ *
+ * @param data - The input array.
+ * @param minimum - The minimum number of elements the array must have.
+ * @returns True if the array's length is *at least* `minimum`. When `minimum`
+ * is a literal value, the output is narrowed to ensure the first items are
+ * guaranteed.
+ * @signature
+ *   R.hasAtLeast(data, minimum)
+ * @example
+ *   R.hasAtLeast([], 4); // => false
+ *
+ *   const data: number[] = [1,2,3,4];
+ *   R.hasAtLeast(data, 1); // => true
+ *   data[0]; // 1, with type `number`
+ * @dataFirst
+ * @category Array
+ */
+declare function hasAtLeast<T extends IterableContainer, N extends number>(data: IterableContainer | T, minimum: IsNumericLiteral<N> extends true ? N : never): data is ArraySetRequired<T, N>;
+declare function hasAtLeast(data: IterableContainer, minimum: number): boolean;
+/**
+ * Checks if the given array has at least the defined number of elements. When
+ * the minimum used is a literal (e.g. `3`) the output is refined accordingly so
+ * that those indices are defined when accessing the array even when using
+ * typescript's 'noUncheckedIndexAccess'.
+ *
+ * @param minimum - The minimum number of elements the array must have.
+ * @returns True if the array's length is *at least* `minimum`. When `minimum`
+ * is a literal value, the output is narrowed to ensure the first items are
+ * guaranteed.
+ * @signature
+ *   R.hasAtLeast(minimum)(data)
+ * @example
+ *   R.pipe([], R.hasAtLeast(4)); // => false
+ *
+ *   const data = [[1,2], [3], [4,5]];
+ *   R.pipe(
+ *     data,
+ *     R.filter(R.hasAtLeast(2)),
+ *     R.map(([, second]) => second),
+ *   ); // => [2,5], with type `number[]`
+ * @dataLast
+ * @category Array
+ */
+declare function hasAtLeast<N extends number>(minimum: IsNumericLiteral<N> extends true ? N : never): <T extends IterableContainer>(data: IterableContainer | T) => data is ArraySetRequired<T, N>;
+declare function hasAtLeast(minimum: number): (data: IterableContainer) => boolean;
+
+declare function isString(value: unknown): value is string;
+declare function isNonEmptyArray<A>(arr: ArrayLike<A> | undefined): arr is NonEmptyArray<A>;
+
+declare function delay(ms?: number): Promise<unknown>;
+
+/**
+ * Compares two relations hierarchically.
+ * From the most general (implicit) to the most specific.
+ */
+declare const compareRelations: <T extends {
+    source: string;
+    target: string;
+}>(a: T, b: T) => 0 | 1 | -1;
+
+export { Color, ComputedEdge, ComputedLikeC4Model, ComputedNode, ComputedView, EdgeId$1 as EdgeId, Element, ElementColors, ElementKind, ElementShape, Fqn$1 as Fqn, HexColorLiteral, LikeC4Model, LikeC4ViewModel, NodeId, NonEmptyArray, Relation, RelationID$1 as RelationID, RelationshipColors, RelationshipKind, Tag, ThemeColorValues, ViewID$1 as ViewID, ancestorsFqn, commonAncestor, compareByFqnHierarchically, compareFqnHierarchically, compareNatural, compareRelations, computeColorValues, defaultTheme, delay, hasAtLeast, invariant, isAncestor, isDescendantOf, isNonEmptyArray, isSameHierarchy, isString, nameFromFqn, nonNullable, nonexhaustive, notDescendantOf, parentFqn, parentFqnPredicate, sortByFqnHierarchically, sortNaturalByFqn };