@likec4/core 1.8.0 → 1.9.0

package/dist/shared/core.9l7eW3pn.d.cts

@@ -0,0 +1,817 @@
+/**
+Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive).
+
+@category Type
+*/
+type Primitive =
+	| null
+	| undefined
+	| string
+	| number
+	| boolean
+	| symbol
+	| bigint;
+
+declare global {
+	// eslint-disable-next-line @typescript-eslint/consistent-type-definitions -- It has to be an `interface` so that it can be merged.
+	interface SymbolConstructor {
+		readonly observable: symbol;
+	}
+}
+
+/**
+Allows creating a union type by combining primitive types and literal types without sacrificing auto-completion in IDEs for the literal type part of the union.
+
+Currently, when a union type of a primitive type is combined with literal types, TypeScript loses all information about the combined literals. Thus, when such type is used in an IDE with autocompletion, no suggestions are made for the declared literals.
+
+This type is a workaround for [Microsoft/TypeScript#29729](https://github.com/Microsoft/TypeScript/issues/29729). It will be removed as soon as it's not needed anymore.
+
+@example
+```
+import type {LiteralUnion} from 'type-fest';
+
+// Before
+
+type Pet = 'dog' | 'cat' | string;
+
+const pet: Pet = '';
+// Start typing in your TypeScript-enabled IDE.
+// You **will not** get auto-completion for `dog` and `cat` literals.
+
+// After
+
+type Pet2 = LiteralUnion<'dog' | 'cat', string>;
+
+const pet: Pet2 = '';
+// You **will** get auto-completion for `dog` and `cat` literals.
+```
+
+@category Type
+*/
+type LiteralUnion<
+	LiteralType,
+	BaseType extends Primitive,
+> = LiteralType | (BaseType & Record<never, never>);
+
+declare const tag: unique symbol;
+
+type TagContainer<Token> = {
+	readonly [tag]: Token;
+};
+
+type Tag$1<Token extends PropertyKey, TagMetadata> = TagContainer<{[K in Token]: TagMetadata}>;
+
+/**
+Attach a "tag" to an arbitrary type. This allows you to create distinct types, that aren't assignable to one another, for distinct concepts in your program that should not be interchangeable, even if their runtime values have the same type. (See examples.)
+
+A type returned by `Tagged` can be passed to `Tagged` again, to create a type with multiple tags.
+
+[Read more about tagged types.](https://medium.com/@KevinBGreene/surviving-the-typescript-ecosystem-branding-and-type-tagging-6cf6e516523d)
+
+A tag's name is usually a string (and must be a string, number, or symbol), but each application of a tag can also contain an arbitrary type as its "metadata". See {@link GetTagMetadata} for examples and explanation.
+
+A type `A` returned by `Tagged` is assignable to another type `B` returned by `Tagged` if and only if:
+  - the underlying (untagged) type of `A` is assignable to the underlying type of `B`;
+	- `A` contains at least all the tags `B` has;
+	- and the metadata type for each of `A`'s tags is assignable to the metadata type of `B`'s corresponding tag.
+
+There have been several discussions about adding similar features to TypeScript. Unfortunately, nothing has (yet) moved forward:
+	- [Microsoft/TypeScript#202](https://github.com/microsoft/TypeScript/issues/202)
+	- [Microsoft/TypeScript#4895](https://github.com/microsoft/TypeScript/issues/4895)
+	- [Microsoft/TypeScript#33290](https://github.com/microsoft/TypeScript/pull/33290)
+
+@example
+```
+import type {Tagged} from 'type-fest';
+
+type AccountNumber = Tagged<number, 'AccountNumber'>;
+type AccountBalance = Tagged<number, 'AccountBalance'>;
+
+function createAccountNumber(): AccountNumber {
+	// As you can see, casting from a `number` (the underlying type being tagged) is allowed.
+	return 2 as AccountNumber;
+}
+
+function getMoneyForAccount(accountNumber: AccountNumber): AccountBalance {
+	return 4 as AccountBalance;
+}
+
+// This will compile successfully.
+getMoneyForAccount(createAccountNumber());
+
+// But this won't, because it has to be explicitly passed as an `AccountNumber` type!
+// Critically, you could not accidentally use an `AccountBalance` as an `AccountNumber`.
+getMoneyForAccount(2);
+
+// You can also use tagged values like their underlying, untagged type.
+// I.e., this will compile successfully because an `AccountNumber` can be used as a regular `number`.
+// In this sense, the underlying base type is not hidden, which differentiates tagged types from opaque types in other languages.
+const accountNumber = createAccountNumber() + 2;
+```
+
+@example
+```
+import type {Tagged} from 'type-fest';
+
+// You can apply multiple tags to a type by using `Tagged` repeatedly.
+type Url = Tagged<string, 'URL'>;
+type SpecialCacheKey = Tagged<Url, 'SpecialCacheKey'>;
+
+// You can also pass a union of tag names, so this is equivalent to the above, although it doesn't give you the ability to assign distinct metadata to each tag.
+type SpecialCacheKey2 = Tagged<string, 'URL' | 'SpecialCacheKey'>;
+```
+
+@category Type
+*/
+type Tagged<Type, TagName extends PropertyKey, TagMetadata = never> = Type & Tag$1<TagName, TagMetadata>;
+
+/**
+Revert a tagged type back to its original type by removing all tags.
+
+Why is this necessary?
+
+1. Use a `Tagged` type as object keys
+2. Prevent TS4058 error: "Return type of exported function has or is using name X from external module Y but cannot be named"
+
+@example
+```
+import type {Tagged, UnwrapTagged} from 'type-fest';
+
+type AccountType = Tagged<'SAVINGS' | 'CHECKING', 'AccountType'>;
+
+const moneyByAccountType: Record<UnwrapTagged<AccountType>, number> = {
+	SAVINGS: 99,
+	CHECKING: 0.1
+};
+
+// Without UnwrapTagged, the following expression would throw a type error.
+const money = moneyByAccountType.SAVINGS; // TS error: Property 'SAVINGS' does not exist
+
+// Attempting to pass an non-Tagged type to UnwrapTagged will raise a type error.
+type WontWork = UnwrapTagged<string>;
+```
+
+@category Type
+*/
+type UnwrapTagged<TaggedType extends Tag$1<PropertyKey, any>> =
+RemoveAllTags<TaggedType>;
+
+type RemoveAllTags<T> = T extends Tag$1<PropertyKey, any>
+	? {
+		[ThisTag in keyof T[typeof tag]]: T extends Tagged<infer Type, ThisTag, T[typeof tag][ThisTag]>
+			? RemoveAllTags<Type>
+			: never
+	}[keyof T[typeof tag]]
+	: T;
+
+declare const ThemeColors: readonly ["amber", "blue", "gray", "slate", "green", "indigo", "muted", "primary", "red", "secondary", "sky"];
+type ThemeColor = typeof ThemeColors[number];
+type HexColorLiteral = `#${string}`;
+type ColorLiteral = HexColorLiteral;
+type Color = LiteralUnion<ThemeColor, string>;
+declare function isThemeColor(color: Color): color is ThemeColor;
+interface ElementThemeColorValues {
+    fill: ColorLiteral;
+    stroke: ColorLiteral;
+    hiContrast: ColorLiteral;
+    loContrast: ColorLiteral;
+}
+type ElementThemeColors = {
+    [key in ThemeColor]: ElementThemeColorValues;
+};
+interface RelationshipThemeColorValues {
+    lineColor: ColorLiteral;
+    labelBgColor: ColorLiteral;
+    labelColor: ColorLiteral;
+}
+interface ThemeColorValues {
+    elements: ElementThemeColorValues;
+    relationships: RelationshipThemeColorValues;
+}
+type RelationshipThemeColors = {
+    [key in ThemeColor]: RelationshipThemeColorValues;
+};
+interface LikeC4Theme {
+    font: 'Arial';
+    shadow: ColorLiteral;
+    relationships: RelationshipThemeColors;
+    elements: ElementThemeColors;
+}
+
+type NonEmptyArray<T> = [T, ...T[]];
+type IconUrl = Tagged<string, 'IconUrl'>;
+type CustomColor = string;
+type Point = readonly [x: number, y: number];
+interface XYPoint {
+    x: number;
+    y: number;
+}
+
+type Fqn = Tagged<string, 'Fqn'>;
+declare function AsFqn(name: string, parent?: Fqn | null): Fqn;
+declare const BorderStyles: readonly ["solid", "dashed", "dotted", "none"];
+type BorderStyle = typeof BorderStyles[number];
+type ElementKind = Tagged<string, 'ElementKind'>;
+declare const ElementShapes: readonly ["rectangle", "person", "browser", "mobile", "cylinder", "storage", "queue"];
+type ElementShape = typeof ElementShapes[number];
+declare const DefaultThemeColor = "primary";
+declare const DefaultElementShape = "rectangle";
+interface ElementStyle {
+    border?: BorderStyle;
+    opacity?: number;
+}
+type Tag = Tagged<string, 'Tag'>;
+interface TagSpec {
+    readonly id: Tag;
+    readonly style: ElementStyle;
+}
+interface Link {
+    readonly title?: string;
+    readonly url: string;
+}
+interface Element {
+    readonly id: Fqn;
+    readonly kind: ElementKind;
+    readonly title: string;
+    readonly description: string | null;
+    readonly technology: string | null;
+    readonly tags: NonEmptyArray<Tag> | null;
+    readonly links: NonEmptyArray<Link> | null;
+    readonly icon?: IconUrl;
+    readonly shape?: ElementShape;
+    readonly color?: Color;
+    readonly style?: ElementStyle;
+    readonly notation?: string;
+    readonly metadata?: {
+        [key: string]: string;
+    };
+}
+interface ElementKindSpecificationStyle {
+    shape?: ElementShape;
+    icon?: IconUrl;
+    color?: Color;
+    border?: BorderStyle;
+    opacity?: number;
+}
+interface ElementKindSpecification {
+    readonly technology?: string;
+    readonly notation?: string;
+    readonly style: ElementKindSpecificationStyle;
+}
+
+type EqualOperator<V> = {
+    eq: V;
+    neq?: never;
+} | {
+    eq?: never;
+    neq: V;
+};
+type AllNever = {
+    not?: never;
+    and?: never;
+    or?: never;
+    tag?: never;
+    kind?: never;
+};
+type TagEqual<Tag> = Omit<AllNever, 'tag'> & {
+    tag: EqualOperator<Tag>;
+};
+declare const isTagEqual: <Tag>(operator: WhereOperator<Tag, any>) => operator is TagEqual<Tag>;
+type KindEqual<Kind> = Omit<AllNever, 'kind'> & {
+    kind: EqualOperator<Kind>;
+};
+declare const isKindEqual: <Kind>(operator: WhereOperator<any, Kind>) => operator is KindEqual<Kind>;
+type NotOperator<Tag, Kind> = Omit<AllNever, 'not'> & {
+    not: WhereOperator<Tag, Kind>;
+};
+declare const isNotOperator: <Tag, Kind>(operator: WhereOperator<Tag, Kind>) => operator is NotOperator<Tag, Kind>;
+type AndOperator<Tag, Kind> = Omit<AllNever, 'and'> & {
+    and: NonEmptyArray<WhereOperator<Tag, Kind>>;
+};
+declare const isAndOperator: <Tag, Kind>(operator: WhereOperator<Tag, Kind>) => operator is AndOperator<Tag, Kind>;
+type OrOperator<Tag, Kind> = Omit<AllNever, 'or'> & {
+    or: NonEmptyArray<WhereOperator<Tag, Kind>>;
+};
+declare const isOrOperator: <Tag, Kind>(operator: WhereOperator<Tag, Kind>) => operator is OrOperator<Tag, Kind>;
+type WhereOperator<Tag, Kind> = TagEqual<Tag> | KindEqual<Kind> | NotOperator<Tag, Kind> | AndOperator<Tag, Kind> | OrOperator<Tag, Kind>;
+type Filterable<FTag extends string = string, FKind extends string = string> = {
+    tags?: FTag[] | null;
+    kind?: FKind;
+};
+type OperatorPredicate<V extends Filterable> = (value: V) => boolean;
+declare function whereOperatorAsPredicate<FTag extends string = string, FKind extends string = string>(operator: WhereOperator<FTag, FKind>): OperatorPredicate<Filterable<FTag, FKind>>;
+
+type RelationID = Tagged<string, 'RelationID'>;
+type RelationshipKind = Tagged<string, 'RelationshipKind'>;
+type RelationshipLineType = 'dashed' | 'solid' | 'dotted';
+type RelationshipArrowType = 'none' | 'normal' | 'onormal' | 'dot' | 'odot' | 'diamond' | 'odiamond' | 'crow' | 'open' | 'vee';
+declare const DefaultLineStyle = "dashed";
+declare const DefaultArrowType = "normal";
+declare const DefaultRelationshipColor = "gray";
+interface Relation {
+    readonly id: RelationID;
+    readonly source: Fqn;
+    readonly target: Fqn;
+    readonly title: string;
+    readonly description?: string;
+    readonly technology?: string;
+    readonly tags?: NonEmptyArray<Tag>;
+    readonly kind?: RelationshipKind;
+    readonly color?: Color;
+    readonly line?: RelationshipLineType;
+    readonly head?: RelationshipArrowType;
+    readonly tail?: RelationshipArrowType;
+    readonly links?: NonEmptyArray<Link>;
+    readonly metadata?: {
+        [key: string]: string;
+    };
+}
+interface RelationshipKindSpecification {
+    readonly technology?: string;
+    readonly notation?: string;
+    readonly color?: Color;
+    readonly line?: RelationshipLineType;
+    readonly head?: RelationshipArrowType;
+    readonly tail?: RelationshipArrowType;
+}
+
+type ElementNotation = {
+    kinds: ElementKind[];
+    shape: ElementShape;
+    color: Color;
+    title: string;
+};
+
+type ViewID = Tagged<string, 'ViewID'>;
+type ViewRulePredicate = {
+    include: Expression[];
+    exclude?: never;
+} | {
+    include?: never;
+    exclude: Expression[];
+};
+declare function isViewRulePredicate(rule: ViewRule): rule is ViewRulePredicate;
+interface ViewRuleStyle {
+    targets: ElementExpression[];
+    notation?: string;
+    style: ElementStyle & {
+        color?: Color;
+        shape?: ElementShape;
+        icon?: IconUrl;
+    };
+}
+declare function isViewRuleStyle(rule: ViewRule): rule is ViewRuleStyle;
+type AutoLayoutDirection = 'TB' | 'BT' | 'LR' | 'RL';
+interface ViewRuleAutoLayout {
+    autoLayout: AutoLayoutDirection;
+}
+declare function isViewRuleAutoLayout(rule: ViewRule): rule is ViewRuleAutoLayout;
+type ViewRule = ViewRulePredicate | ViewRuleStyle | ViewRuleAutoLayout;
+interface BasicView<ViewType extends 'element' | 'dynamic'> {
+    readonly __?: ViewType;
+    readonly id: ViewID;
+    readonly title: string | null;
+    readonly description: string | null;
+    readonly tags: NonEmptyArray<Tag> | null;
+    readonly links: NonEmptyArray<Link> | null;
+    /**
+     * URI to the source file of this view.
+     * Undefined if the view is auto-generated.
+     */
+    readonly docUri?: string;
+    /**
+     * For all views we find common ancestor path.
+     * This is used to generate relative paths, i.e.:
+     * - "/home/project/index.c4" becomes "index.c4"
+     * - "/home/project/subdir/views.c4" becomes "subdir/views.c4"
+     *
+     * Undefined if the view is auto-generated.
+     */
+    readonly relativePath?: string;
+    /**
+     * If the view is changed manually this field contains the layout data.
+     */
+    readonly manualLayout?: ViewManualLayout | undefined;
+    readonly customColorDefinitions: CustomColorDefinitions;
+}
+interface BasicElementView extends BasicView<'element'> {
+    readonly viewOf?: Fqn;
+    readonly rules: ViewRule[];
+}
+interface ScopedElementView extends BasicElementView {
+    readonly viewOf: Fqn;
+}
+interface ExtendsElementView extends BasicElementView {
+    readonly extends: ViewID;
+}
+type ElementView = ScopedElementView | ExtendsElementView | BasicElementView;
+interface DynamicViewStep {
+    readonly source: Fqn;
+    readonly target: Fqn;
+    readonly title: string | null;
+    readonly description?: string;
+    readonly technology?: string;
+    readonly notation?: string;
+    readonly color?: Color;
+    readonly line?: RelationshipLineType;
+    readonly head?: RelationshipArrowType;
+    readonly tail?: RelationshipArrowType;
+    readonly isBackward?: boolean;
+}
+type DynamicViewIncludeRule = {
+    include: ElementPredicateExpression[];
+};
+declare function isDynamicViewIncludeRule(rule: DynamicViewRule): rule is DynamicViewIncludeRule;
+type DynamicViewRule = DynamicViewIncludeRule | ViewRuleStyle | ViewRuleAutoLayout;
+interface DynamicView extends BasicView<'dynamic'> {
+    readonly __: 'dynamic';
+    readonly steps: DynamicViewStep[];
+    readonly rules: DynamicViewRule[];
+}
+type CustomColorDefinitions = {
+    [key: string]: ThemeColorValues;
+};
+type LikeC4View = ElementView | DynamicView;
+declare function isDynamicView(view: LikeC4View): view is DynamicView;
+declare function isElementView(view: LikeC4View): view is ElementView;
+declare function isExtendsElementView(view: LikeC4View): view is ExtendsElementView;
+declare function isScopedElementView(view: LikeC4View): view is ScopedElementView;
+type NodeId = Tagged<string, 'Fqn'>;
+type EdgeId = Tagged<string, 'EdgeId'>;
+type StepEdgeIdLiteral = `step-${number}`;
+type StepEdgeId = Tagged<StepEdgeIdLiteral, 'EdgeId'>;
+declare function StepEdgeId(step: number): StepEdgeId;
+declare function isStepEdgeId(id: string): id is StepEdgeId;
+declare function extractStep(id: EdgeId): number;
+interface ComputedNode {
+    id: NodeId;
+    kind: ElementKind;
+    parent: NodeId | null;
+    title: string;
+    description: string | null;
+    technology: string | null;
+    notation?: string;
+    tags: NonEmptyArray<Tag> | null;
+    links: NonEmptyArray<Link> | null;
+    children: NodeId[];
+    inEdges: EdgeId[];
+    outEdges: EdgeId[];
+    shape: ElementShape;
+    /**
+     * @deprecated Use `style` instead
+     */
+    color: Color;
+    /**
+     * @deprecated Use `style` instead
+     */
+    icon?: IconUrl;
+    style: ElementStyle;
+    navigateTo?: ViewID;
+    level: number;
+    depth?: number;
+    /**
+     * If this node was customized in the view
+     */
+    isCustomized?: boolean;
+}
+interface ComputedEdge {
+    id: EdgeId;
+    parent: NodeId | null;
+    source: NodeId;
+    target: NodeId;
+    label: string | null;
+    description?: string;
+    technology?: string;
+    relations: RelationID[];
+    kind?: RelationshipKind;
+    color?: Color;
+    line?: RelationshipLineType;
+    head?: RelationshipArrowType;
+    tail?: RelationshipArrowType;
+    tags?: NonEmptyArray<Tag>;
+    /**
+     * If this edge is derived from custom relationship predicate
+     */
+    isCustomized?: boolean;
+    /**
+     * For layouting purposes
+     * @default 'forward'
+     */
+    dir?: 'forward' | 'back';
+}
+interface ViewWithHash {
+    /**
+     * Hash of the view object.
+     * This is used to detect changes in layout
+     */
+    hash: string;
+}
+interface ViewWithNotation {
+    notation?: {
+        elements: ElementNotation[];
+    };
+}
+interface ComputedElementView extends Omit<ElementView, 'rules' | 'docUri'>, ViewWithHash, ViewWithNotation {
+    readonly extends?: ViewID;
+    readonly autoLayout: ViewRuleAutoLayout['autoLayout'];
+    readonly nodes: ComputedNode[];
+    readonly edges: ComputedEdge[];
+    rules?: never;
+    docUri?: never;
+}
+interface ComputedDynamicView extends Omit<DynamicView, 'rules' | 'steps' | 'docUri'>, ViewWithHash, ViewWithNotation {
+    readonly autoLayout: ViewRuleAutoLayout['autoLayout'];
+    readonly nodes: ComputedNode[];
+    readonly edges: ComputedEdge[];
+    steps?: never;
+    rules?: never;
+    docUri?: never;
+}
+declare function isComputedDynamicView(view: ComputedView): view is ComputedDynamicView;
+type ComputedView = ComputedElementView | ComputedDynamicView;
+declare function isComputedElementView(view: ComputedView): view is ComputedElementView;
+type BBox = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+declare function getBBoxCenter({ x, y, width, height }: BBox): XYPoint;
+interface DiagramNode extends ComputedNode {
+    width: number;
+    height: number;
+    position: Point;
+    labelBBox: BBox;
+}
+interface DiagramEdge extends ComputedEdge {
+    points: NonEmptyArray<Point>;
+    controlPoints?: NonEmptyArray<XYPoint>;
+    labelBBox?: BBox | null;
+    dotpos?: string;
+}
+interface DiagramView extends Omit<ComputedView, 'nodes' | 'edges' | 'manualLayout'> {
+    readonly nodes: DiagramNode[];
+    readonly edges: DiagramEdge[];
+    readonly bounds: BBox;
+    /**
+     * If diagram has manual layout
+     * But was changed and layout should be recalculated
+     */
+    hasLayoutDrift?: boolean;
+    manualLayout?: never;
+}
+type ViewManualLayout = {
+    readonly hash: string;
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+    readonly autoLayout: AutoLayoutDirection;
+    readonly nodes: Record<string, {
+        isCompound: boolean;
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }>;
+    readonly edges: Record<string, {
+        dotpos?: string;
+        points: NonEmptyArray<Point>;
+        controlPoints?: NonEmptyArray<XYPoint>;
+        labelBBox?: BBox;
+    }>;
+};
+
+interface BaseExpr {
+    where?: never;
+    element?: never;
+    custom?: never;
+    expanded?: never;
+    elementKind?: never;
+    elementTag?: never;
+    isEqual?: never;
+    isDescedants?: never;
+    wildcard?: never;
+    source?: never;
+    target?: never;
+    inout?: never;
+    incoming?: never;
+    outgoing?: never;
+    customRelation?: never;
+}
+interface ElementRefExpr extends Omit<BaseExpr, 'element' | 'isDescedants'> {
+    element: Fqn;
+    isDescedants?: boolean;
+}
+declare function isElementRef(expr: Expression): expr is ElementRefExpr;
+interface ExpandedElementExpr extends Omit<BaseExpr, 'expanded'> {
+    expanded: Fqn;
+}
+declare function isExpandedElementExpr(expr: Expression): expr is ExpandedElementExpr;
+interface CustomElementExpr extends Omit<BaseExpr, 'custom'> {
+    custom: {
+        expr: ElementExpression | ElementWhereExpr;
+        title?: string;
+        description?: string;
+        technology?: string;
+        notation?: string;
+        shape?: ElementShape;
+        color?: Color;
+        icon?: IconUrl;
+        border?: BorderStyle;
+        opacity?: number;
+        navigateTo?: ViewID;
+    };
+}
+declare function isCustomElement(expr: Expression): expr is CustomElementExpr;
+interface WildcardExpr extends Omit<BaseExpr, 'wildcard'> {
+    wildcard: true;
+}
+declare function isWildcard(expr: Expression): expr is WildcardExpr;
+interface ElementKindExpr extends Omit<BaseExpr, 'elementKind' | 'isEqual'> {
+    elementKind: ElementKind;
+    isEqual: boolean;
+}
+declare function isElementKindExpr(expr: Expression): expr is ElementKindExpr;
+interface ElementTagExpr extends Omit<BaseExpr, 'elementTag' | 'isEqual'> {
+    elementTag: Tag;
+    isEqual: boolean;
+}
+declare function isElementTagExpr(expr: Expression): expr is ElementTagExpr;
+type ElementExpression = ElementRefExpr | WildcardExpr | ElementKindExpr | ElementTagExpr | ExpandedElementExpr;
+declare function isElement(expr: Expression): expr is ElementExpression;
+interface ElementWhereExpr extends Omit<BaseExpr, 'where'> {
+    where: {
+        expr: ElementExpression;
+        condition: WhereOperator<string, string>;
+    };
+}
+declare function isElementWhere(expr: Expression): expr is ElementWhereExpr;
+type ElementPredicateExpression = ElementExpression | ElementWhereExpr | CustomElementExpr;
+declare function isElementPredicateExpr(expr: Expression): expr is ElementPredicateExpression;
+interface RelationExpr extends Omit<BaseExpr, 'source' | 'target'> {
+    source: ElementExpression;
+    target: ElementExpression;
+    isBidirectional?: boolean;
+}
+declare function isRelation(expr: Expression): expr is RelationExpr;
+interface InOutExpr extends Omit<BaseExpr, 'inout'> {
+    inout: ElementExpression;
+}
+declare function isInOut(expr: Expression): expr is InOutExpr;
+interface IncomingExpr extends Omit<BaseExpr, 'incoming'> {
+    incoming: ElementExpression;
+}
+declare function isIncoming(expr: Expression): expr is IncomingExpr;
+interface OutgoingExpr extends Omit<BaseExpr, 'outgoing'> {
+    outgoing: ElementExpression;
+}
+declare function isOutgoing(expr: Expression): expr is OutgoingExpr;
+type RelationExpression = RelationExpr | InOutExpr | IncomingExpr | OutgoingExpr;
+declare function isRelationExpression(expr: Expression): expr is RelationExpression;
+interface RelationWhereExpr extends Omit<BaseExpr, 'where'> {
+    where: {
+        expr: RelationExpression;
+        condition: WhereOperator<string, string>;
+    };
+}
+declare function isRelationWhere(expr: Expression): expr is RelationWhereExpr;
+interface CustomRelationExpr extends Omit<BaseExpr, 'customRelation'> {
+    customRelation: {
+        relation: RelationExpression | RelationWhereExpr;
+        title?: string;
+        description?: string;
+        technology?: string;
+        notation?: string;
+        color?: Color;
+        line?: RelationshipLineType;
+        head?: RelationshipArrowType;
+        tail?: RelationshipArrowType;
+    };
+}
+declare function isCustomRelationExpr(expr: Expression): expr is CustomRelationExpr;
+type RelationPredicateExpression = RelationExpression | RelationWhereExpr | CustomRelationExpr;
+declare function isRelationPredicateExpr(expr: Expression): expr is RelationPredicateExpression;
+type Expression = ElementPredicateExpression | RelationPredicateExpression;
+
+type expression_CustomElementExpr = CustomElementExpr;
+type expression_CustomRelationExpr = CustomRelationExpr;
+type expression_ElementExpression = ElementExpression;
+type expression_ElementKindExpr = ElementKindExpr;
+type expression_ElementPredicateExpression = ElementPredicateExpression;
+type expression_ElementRefExpr = ElementRefExpr;
+type expression_ElementTagExpr = ElementTagExpr;
+type expression_ElementWhereExpr = ElementWhereExpr;
+type expression_ExpandedElementExpr = ExpandedElementExpr;
+type expression_Expression = Expression;
+type expression_InOutExpr = InOutExpr;
+type expression_IncomingExpr = IncomingExpr;
+type expression_OutgoingExpr = OutgoingExpr;
+type expression_RelationExpr = RelationExpr;
+type expression_RelationExpression = RelationExpression;
+type expression_RelationPredicateExpression = RelationPredicateExpression;
+type expression_RelationWhereExpr = RelationWhereExpr;
+type expression_WildcardExpr = WildcardExpr;
+declare const expression_isCustomElement: typeof isCustomElement;
+declare const expression_isCustomRelationExpr: typeof isCustomRelationExpr;
+declare const expression_isElement: typeof isElement;
+declare const expression_isElementKindExpr: typeof isElementKindExpr;
+declare const expression_isElementPredicateExpr: typeof isElementPredicateExpr;
+declare const expression_isElementRef: typeof isElementRef;
+declare const expression_isElementTagExpr: typeof isElementTagExpr;
+declare const expression_isElementWhere: typeof isElementWhere;
+declare const expression_isExpandedElementExpr: typeof isExpandedElementExpr;
+declare const expression_isInOut: typeof isInOut;
+declare const expression_isIncoming: typeof isIncoming;
+declare const expression_isOutgoing: typeof isOutgoing;
+declare const expression_isRelation: typeof isRelation;
+declare const expression_isRelationExpression: typeof isRelationExpression;
+declare const expression_isRelationPredicateExpr: typeof isRelationPredicateExpr;
+declare const expression_isRelationWhere: typeof isRelationWhere;
+declare const expression_isWildcard: typeof isWildcard;
+declare namespace expression {
+  export { type expression_CustomElementExpr as CustomElementExpr, type expression_CustomRelationExpr as CustomRelationExpr, type expression_ElementExpression as ElementExpression, type expression_ElementKindExpr as ElementKindExpr, type expression_ElementPredicateExpression as ElementPredicateExpression, type expression_ElementRefExpr as ElementRefExpr, type expression_ElementTagExpr as ElementTagExpr, type expression_ElementWhereExpr as ElementWhereExpr, type expression_ExpandedElementExpr as ExpandedElementExpr, type expression_Expression as Expression, type expression_InOutExpr as InOutExpr, type expression_IncomingExpr as IncomingExpr, type expression_OutgoingExpr as OutgoingExpr, type expression_RelationExpr as RelationExpr, type expression_RelationExpression as RelationExpression, type expression_RelationPredicateExpression as RelationPredicateExpression, type expression_RelationWhereExpr as RelationWhereExpr, type expression_WildcardExpr as WildcardExpr, expression_isCustomElement as isCustomElement, expression_isCustomRelationExpr as isCustomRelationExpr, expression_isElement as isElement, expression_isElementKindExpr as isElementKindExpr, expression_isElementPredicateExpr as isElementPredicateExpr, expression_isElementRef as isElementRef, expression_isElementTagExpr as isElementTagExpr, expression_isElementWhere as isElementWhere, expression_isExpandedElementExpr as isExpandedElementExpr, expression_isInOut as isInOut, expression_isIncoming as isIncoming, expression_isOutgoing as isOutgoing, expression_isRelation as isRelation, expression_isRelationExpression as isRelationExpression, expression_isRelationPredicateExpr as isRelationPredicateExpr, expression_isRelationWhere as isRelationWhere, expression_isWildcard as isWildcard };
+}
+
+/**
+ * Parsed elements, relations, and views.
+ */
+interface ParsedLikeC4Model {
+    specification: {
+        tags: Tag[];
+        elements: Record<UnwrapTagged<ElementKind>, ElementKindSpecification>;
+        relationships: Record<UnwrapTagged<ElementKind>, RelationshipKindSpecification>;
+    };
+    elements: Record<Fqn, Element>;
+    relations: Record<RelationID, Relation>;
+    views: Record<ViewID, LikeC4View>;
+}
+/**
+ * Same as `ParsedLikeC4Model` but with computed views.
+ */
+interface ComputedLikeC4Model extends Omit<ParsedLikeC4Model, 'views'> {
+    views: Record<ViewID, ComputedView>;
+}
+
+/**
+ * OverviewGraph is a graph representation of all views in a model
+ */
+declare namespace OverviewGraph {
+    type Node = {
+        id: string;
+        type: 'folder' | 'file';
+        path: string;
+        label: string;
+        parentId: string | null;
+        position: XYPoint;
+        width: number;
+        height: number;
+    } | {
+        id: string;
+        type: 'view';
+        viewId: ViewID;
+        label: string;
+        parentId: string | null;
+        position: XYPoint;
+        width: number;
+        height: number;
+    };
+    /**
+     * Edge represents a navigational link from one view to another
+     */
+    type Edge = {
+        id: string;
+        source: string;
+        target: string;
+        points: NonEmptyArray<Point>;
+    };
+}
+interface OverviewGraph {
+    nodes: OverviewGraph.Node[];
+    edges: OverviewGraph.Edge[];
+    bounds: BBox;
+}
+
+declare namespace ViewChange {
+    interface ChangeElementStyle {
+        op: 'change-element-style';
+        style: {
+            border?: BorderStyle;
+            opacity?: number;
+            shape?: ElementShape;
+            color?: ThemeColor;
+        };
+        targets: NonEmptyArray<Fqn>;
+    }
+    interface SaveManualLayout {
+        op: 'save-manual-layout';
+        layout: ViewManualLayout;
+    }
+    interface ChangeAutoLayout {
+        op: 'change-autolayout';
+        layout: AutoLayoutDirection;
+    }
+}
+type ViewChange = ViewChange.ChangeElementStyle | ViewChange.SaveManualLayout | ViewChange.ChangeAutoLayout;
+
+export { type ElementPredicateExpression as $, AsFqn as A, BorderStyles as B, type ComputedView as C, DefaultThemeColor as D, type EdgeId as E, type Fqn as F, type CustomElementExpr as G, type HexColorLiteral as H, type IconUrl as I, isCustomElement as J, isWildcard as K, type LiteralUnion as L, type ElementKindExpr as M, type NodeId as N, isElementKindExpr as O, type Primitive as P, type ElementTagExpr as Q, type RelationID as R, isElementTagExpr as S, type ThemeColorValues as T, type ElementExpression as U, type ViewID as V, type WildcardExpr as W, type XYPoint as X, isElement as Y, type ElementWhereExpr as Z, isElementWhere as _, type Tag as a, type DynamicViewRule as a$, isElementPredicateExpr as a0, type RelationExpr as a1, isRelation as a2, type InOutExpr as a3, isInOut as a4, type IncomingExpr as a5, isIncoming as a6, type OutgoingExpr as a7, isOutgoing as a8, type RelationExpression as a9, DefaultArrowType as aA, DefaultRelationshipColor as aB, type RelationshipKindSpecification as aC, type ThemeColor as aD, type ColorLiteral as aE, isThemeColor as aF, type ElementThemeColorValues as aG, type ElementThemeColors as aH, type RelationshipThemeColorValues as aI, type RelationshipThemeColors as aJ, type LikeC4Theme as aK, type ViewRulePredicate as aL, isViewRulePredicate as aM, type ViewRuleStyle as aN, isViewRuleStyle as aO, type AutoLayoutDirection as aP, type ViewRuleAutoLayout as aQ, isViewRuleAutoLayout as aR, type ViewRule as aS, type BasicView as aT, type BasicElementView as aU, type ScopedElementView as aV, type ExtendsElementView as aW, type ElementView as aX, type DynamicViewStep as aY, type DynamicViewIncludeRule as aZ, isDynamicViewIncludeRule as a_, isRelationExpression as aa, type RelationWhereExpr as ab, isRelationWhere as ac, type CustomRelationExpr as ad, isCustomRelationExpr as ae, type RelationPredicateExpression as af, isRelationPredicateExpr as ag, type Expression as ah, type ParsedLikeC4Model as ai, type EqualOperator as aj, type TagEqual as ak, isTagEqual as al, type KindEqual as am, isKindEqual as an, type NotOperator as ao, isNotOperator as ap, type AndOperator as aq, isAndOperator as ar, type OrOperator as as, isOrOperator as at, type WhereOperator as au, whereOperatorAsPredicate as av, OverviewGraph as aw, type RelationshipLineType as ax, type RelationshipArrowType as ay, DefaultLineStyle as az, type ComputedNode as b, type DynamicView as b0, type CustomColorDefinitions as b1, type LikeC4View as b2, isDynamicView as b3, isElementView as b4, isExtendsElementView as b5, isScopedElementView as b6, type StepEdgeIdLiteral as b7, StepEdgeId as b8, isStepEdgeId as b9, extractStep as ba, type ViewWithHash as bb, type ViewWithNotation as bc, type ComputedElementView as bd, type ComputedDynamicView as be, isComputedDynamicView as bf, isComputedElementView as bg, type BBox as bh, getBBoxCenter as bi, type DiagramNode as bj, type DiagramEdge as bk, type DiagramView as bl, type ViewManualLayout as bm, ViewChange as bn, type ElementNotation as bo, type ElementKind as c, type ElementShape as d, type Color as e, type ComputedEdge as f, type ComputedLikeC4Model as g, type Element as h, type Relation as i, type RelationshipKind as j, type NonEmptyArray as k, expression as l, type CustomColor as m, type Point as n, type BorderStyle as o, ElementShapes as p, DefaultElementShape as q, type ElementStyle as r, type TagSpec as s, type Link as t, type ElementKindSpecificationStyle as u, type ElementKindSpecification as v, type ElementRefExpr as w, isElementRef as x, type ExpandedElementExpr as y, isExpandedElementExpr as z };