@likec4/language-server 1.17.1 → 1.19.0

package/dist/generated/ast.d.ts

@@ -0,0 +1,1242 @@
+/******************************************************************************
+ * This file was generated by langium-cli 3.3.0.
+ * DO NOT EDIT MANUALLY!
+ ******************************************************************************/
+import type { AstNode, Reference, ReferenceInfo, TypeMetaData } from 'langium';
+import { AbstractAstReflection } from 'langium';
+export declare const LikeC4Terminals: {
+    BLOCK_COMMENT: RegExp;
+    LINE_COMMENT: RegExp;
+    WS: RegExp;
+    NL: RegExp;
+    LIB_ICON: RegExp;
+    URI_WITH_SCHEMA: RegExp;
+    URI_RELATIVE: RegExp;
+    DotUnderscore: RegExp;
+    DotWildcard: RegExp;
+    Hash: RegExp;
+    StickyDot: RegExp;
+    Dot: RegExp;
+    NotEqual: RegExp;
+    Eq: RegExp;
+    Percent: RegExp;
+    String: RegExp;
+    IdTerminal: RegExp;
+    Number: RegExp;
+    Hex: RegExp;
+};
+export type LikeC4TerminalNames = keyof typeof LikeC4Terminals;
+export type LikeC4KeywordNames = "(" | ")" | "*" | "," | "->" | "-[" | ":" | ";" | "<-" | "<->" | "BottomTop" | "LeftRight" | "RightLeft" | "TopBottom" | "]->" | "amber" | "and" | "autoLayout" | "blue" | "border" | "browser" | "color" | "crow" | "cylinder" | "dashed" | "deployment" | "deploymentNode" | "description" | "diamond" | "dot" | "dotted" | "dynamic" | "dynamicPredicateGroup" | "element" | "element.kind" | "element.tag" | "exclude" | "extend" | "extends" | "global" | "gray" | "green" | "group" | "head" | "icon" | "icons" | "include" | "indigo" | "instance" | "instanceOf" | "is" | "kind" | "likec4lib" | "line" | "link" | "metadata" | "mobile" | "model" | "muted" | "navigateTo" | "node" | "none" | "normal" | "not" | "notation" | "notes" | "odiamond" | "odot" | "of" | "onormal" | "opacity" | "open" | "or" | "par" | "parallel" | "person" | "predicate" | "predicateGroup" | "primary" | "queue" | "rectangle" | "red" | "relationship" | "secondary" | "shape" | "sky" | "slate" | "solid" | "specification" | "storage" | "style" | "styleGroup" | "tag" | "tail" | "technology" | "title" | "vee" | "view" | "views" | "where" | "with" | "{" | "}";
+export type LikeC4TokenNames = LikeC4TerminalNames | LikeC4KeywordNames;
+export type ArrowType = 'crow' | 'diamond' | 'dot' | 'none' | 'normal' | 'odiamond' | 'odot' | 'onormal' | 'open' | 'vee';
+export declare function isArrowType(item: unknown): item is ArrowType;
+export type BorderStyleValue = 'none' | LineOptions;
+export declare function isBorderStyleValue(item: unknown): item is BorderStyleValue;
+export type CustomColorId = 'element' | 'model' | ArrowType | ElementShape | LineOptions | string;
+export declare function isCustomColorId(item: unknown): item is CustomColorId;
+export type CustomColorValue = string;
+export declare function isCustomColorValue(item: unknown): item is CustomColorValue;
+export type DeploymentElement = DeployedInstance | DeploymentNode;
+export declare const DeploymentElement = "DeploymentElement";
+export declare function isDeploymentElement(item: unknown): item is DeploymentElement;
+export type DeploymentViewRule = DeploymentViewRulePredicate | DeploymentViewRuleStyle | ViewRuleAutoLayout;
+export declare const DeploymentViewRule = "DeploymentViewRule";
+export declare function isDeploymentViewRule(item: unknown): item is DeploymentViewRule;
+export type DotId = string;
+export declare function isDotId(item: unknown): item is DotId;
+export type DynamicViewRule = DynamicViewGlobalPredicateRef | DynamicViewIncludePredicate | ViewRuleAutoLayout | ViewRuleStyleOrGlobalRef;
+export declare const DynamicViewRule = "DynamicViewRule";
+export declare function isDynamicViewRule(item: unknown): item is DynamicViewRule;
+export type ElementExpression = ElementDescedantsExpression | ElementKindExpression | ElementRef | ElementTagExpression | ExpandElementExpression | WildcardExpression;
+export declare const ElementExpression = "ElementExpression";
+export declare function isElementExpression(item: unknown): item is ElementExpression;
+export type ElementPredicate = ElementPredicateOrWhere | ElementPredicateWith;
+export declare const ElementPredicate = "ElementPredicate";
+export declare function isElementPredicate(item: unknown): item is ElementPredicate;
+export type ElementPredicateOrWhere = ElementExpression | ElementPredicateWhere;
+export declare const ElementPredicateOrWhere = "ElementPredicateOrWhere";
+export declare function isElementPredicateOrWhere(item: unknown): item is ElementPredicateOrWhere;
+export type ElementProperty = ElementStringProperty | ElementStyleProperty | IconProperty | LinkProperty | MetadataProperty;
+export declare const ElementProperty = "ElementProperty";
+export declare function isElementProperty(item: unknown): item is ElementProperty;
+export type ElementShape = 'browser' | 'cylinder' | 'mobile' | 'person' | 'queue' | 'rectangle' | 'storage';
+export declare function isElementShape(item: unknown): item is ElementShape;
+export type ExpressionV2 = FqnExpr | RelationExpr;
+export declare const ExpressionV2 = "ExpressionV2";
+export declare function isExpressionV2(item: unknown): item is ExpressionV2;
+export type FqnExpr = FqnRefExpr | WildcardExpression;
+export declare const FqnExpr = "FqnExpr";
+export declare function isFqnExpr(item: unknown): item is FqnExpr;
+export type FqnReferenceable = Element | ExtendElement | Referenceable;
+export declare const FqnReferenceable = "FqnReferenceable";
+export declare function isFqnReferenceable(item: unknown): item is FqnReferenceable;
+export type IconId = string;
+export declare function isIconId(item: unknown): item is IconId;
+export type Id = 'deployment' | 'element' | 'group' | 'instance' | 'model' | 'node' | ArrowType | ElementShape | LineOptions | ThemeColor | string;
+export declare function isId(item: unknown): item is Id;
+export type LikeC4View = DeploymentView | DynamicView | ElementView;
+export declare const LikeC4View = "LikeC4View";
+export declare function isLikeC4View(item: unknown): item is LikeC4View;
+export type LineOptions = 'dashed' | 'dotted' | 'solid';
+export declare function isLineOptions(item: unknown): item is LineOptions;
+export type MetadataProperty = MetadataBody;
+export declare const MetadataProperty = "MetadataProperty";
+export declare function isMetadataProperty(item: unknown): item is MetadataProperty;
+export type Predicate = ElementPredicate | RelationPredicate;
+export declare const Predicate = "Predicate";
+export declare function isPredicate(item: unknown): item is Predicate;
+export type Referenceable = DeployedInstance | DeploymentNode | Element;
+export declare const Referenceable = "Referenceable";
+export declare function isReferenceable(item: unknown): item is Referenceable;
+export type RelationExpr = DirectedRelationExpr | InOutRelationExpr | IncomingRelationExpr | OutgoingRelationExpr;
+export declare const RelationExpr = "RelationExpr";
+export declare function isRelationExpr(item: unknown): item is RelationExpr;
+export type RelationExpression = DirectedRelationExpression | InOutRelationExpression | IncomingRelationExpression | OutgoingRelationExpression;
+export declare const RelationExpression = "RelationExpression";
+export declare function isRelationExpression(item: unknown): item is RelationExpression;
+export type RelationPredicate = RelationPredicateOrWhere | RelationPredicateWith;
+export declare const RelationPredicate = "RelationPredicate";
+export declare function isRelationPredicate(item: unknown): item is RelationPredicate;
+export type RelationPredicateOrWhere = RelationExpression | RelationPredicateWhere;
+export declare const RelationPredicateOrWhere = "RelationPredicateOrWhere";
+export declare function isRelationPredicateOrWhere(item: unknown): item is RelationPredicateOrWhere;
+export type RelationProperty = LinkProperty | MetadataProperty | RelationNavigateToProperty | RelationStringProperty | RelationStyleProperty;
+export declare const RelationProperty = "RelationProperty";
+export declare function isRelationProperty(item: unknown): item is RelationProperty;
+export type RelationshipStyleProperty = ArrowProperty | ColorProperty | LineProperty;
+export declare const RelationshipStyleProperty = "RelationshipStyleProperty";
+export declare function isRelationshipStyleProperty(item: unknown): item is RelationshipStyleProperty;
+export type StringProperty = ElementStringProperty | MetadataAttribute | NotationProperty | NotesProperty | RelationStringProperty | SpecificationElementStringProperty | SpecificationRelationshipStringProperty | ViewStringProperty;
+export declare const StringProperty = "StringProperty";
+export declare function isStringProperty(item: unknown): item is StringProperty;
+export type StyleProperty = BorderProperty | ColorProperty | IconProperty | OpacityProperty | ShapeProperty;
+export declare const StyleProperty = "StyleProperty";
+export declare function isStyleProperty(item: unknown): item is StyleProperty;
+export type TagId = string;
+export declare function isTagId(item: unknown): item is TagId;
+export type ThemeColor = 'amber' | 'blue' | 'gray' | 'green' | 'indigo' | 'muted' | 'primary' | 'red' | 'secondary' | 'sky' | 'slate';
+export declare function isThemeColor(item: unknown): item is ThemeColor;
+export type Uri = string;
+export declare function isUri(item: unknown): item is Uri;
+export type ViewLayoutDirection = 'BottomTop' | 'LeftRight' | 'RightLeft' | 'TopBottom';
+export declare function isViewLayoutDirection(item: unknown): item is ViewLayoutDirection;
+export type ViewProperty = LinkProperty | ViewStringProperty;
+export declare const ViewProperty = "ViewProperty";
+export declare function isViewProperty(item: unknown): item is ViewProperty;
+export type ViewRule = ViewRuleAutoLayout | ViewRuleGlobalPredicateRef | ViewRuleGroup | ViewRulePredicate | ViewRuleStyleOrGlobalRef;
+export declare const ViewRule = "ViewRule";
+export declare function isViewRule(item: unknown): item is ViewRule;
+export type ViewRulePredicate = ExcludePredicate | IncludePredicate;
+export declare const ViewRulePredicate = "ViewRulePredicate";
+export declare function isViewRulePredicate(item: unknown): item is ViewRulePredicate;
+export type ViewRuleStyleOrGlobalRef = ViewRuleGlobalStyle | ViewRuleStyle;
+export declare const ViewRuleStyleOrGlobalRef = "ViewRuleStyleOrGlobalRef";
+export declare function isViewRuleStyleOrGlobalRef(item: unknown): item is ViewRuleStyleOrGlobalRef;
+export type WhereElement = WhereElementKind | WhereElementTag;
+export declare const WhereElement = "WhereElement";
+export declare function isWhereElement(item: unknown): item is WhereElement;
+export type WhereElementExpression = WhereBinaryExpression | WhereElement | WhereElementNegation;
+export declare const WhereElementExpression = "WhereElementExpression";
+export declare function isWhereElementExpression(item: unknown): item is WhereElementExpression;
+export type WhereExpression = WhereElementExpression | WhereRelationExpression;
+export declare const WhereExpression = "WhereExpression";
+export declare function isWhereExpression(item: unknown): item is WhereExpression;
+export type WhereKindEqual = WhereElementKind | WhereRelationKind;
+export declare const WhereKindEqual = "WhereKindEqual";
+export declare function isWhereKindEqual(item: unknown): item is WhereKindEqual;
+export type WhereRelation = WhereRelationKind | WhereRelationTag;
+export declare const WhereRelation = "WhereRelation";
+export declare function isWhereRelation(item: unknown): item is WhereRelation;
+export type WhereRelationExpression = WhereBinaryExpression | WhereRelation | WhereRelationNegation;
+export declare const WhereRelationExpression = "WhereRelationExpression";
+export declare function isWhereRelationExpression(item: unknown): item is WhereRelationExpression;
+export type WhereTagEqual = WhereElementTag | WhereRelationTag;
+export declare const WhereTagEqual = "WhereTagEqual";
+export declare function isWhereTagEqual(item: unknown): item is WhereTagEqual;
+export interface ArrowProperty extends AstNode {
+    readonly $container: CustomRelationProperties | RelationStyleProperty | SpecificationRelationshipKind;
+    readonly $type: 'ArrowProperty';
+    key: 'head' | 'tail';
+    value: ArrowType;
+}
+export declare const ArrowProperty = "ArrowProperty";
+export declare function isArrowProperty(item: unknown): item is ArrowProperty;
+export interface BorderProperty extends AstNode {
+    readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleGroup | ViewRuleStyle;
+    readonly $type: 'BorderProperty';
+    key: 'border';
+    value: BorderStyleValue;
+}
+export declare const BorderProperty = "BorderProperty";
+export declare function isBorderProperty(item: unknown): item is BorderProperty;
+export interface ColorProperty extends AstNode {
+    readonly $container: CustomElementProperties | CustomRelationProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | RelationStyleProperty | SpecificationRelationshipKind | ViewRuleGroup | ViewRuleStyle;
+    readonly $type: 'ColorProperty';
+    customColor?: Reference<CustomColor>;
+    key: 'color';
+    themeColor?: ThemeColor;
+}
+export declare const ColorProperty = "ColorProperty";
+export declare function isColorProperty(item: unknown): item is ColorProperty;
+export interface CustomColor extends AstNode {
+    readonly $container: SpecificationColor;
+    readonly $type: 'CustomColor';
+    name: CustomColorId;
+}
+export declare const CustomColor = "CustomColor";
+export declare function isCustomColor(item: unknown): item is CustomColor;
+export interface CustomElementProperties extends AstNode {
+    readonly $container: ElementPredicateWith;
+    readonly $type: 'CustomElementProperties';
+    props: Array<ElementStringProperty | NavigateToProperty | NotationProperty | StyleProperty>;
+}
+export declare const CustomElementProperties = "CustomElementProperties";
+export declare function isCustomElementProperties(item: unknown): item is CustomElementProperties;
+export interface CustomRelationProperties extends AstNode {
+    readonly $container: DynamicViewStep | RelationPredicateWith;
+    readonly $type: 'CustomRelationProperties';
+    props: Array<NotationProperty | NotesProperty | RelationNavigateToProperty | RelationStringProperty | RelationshipStyleProperty>;
+}
+export declare const CustomRelationProperties = "CustomRelationProperties";
+export declare function isCustomRelationProperties(item: unknown): item is CustomRelationProperties;
+export interface DeployedInstance extends AstNode {
+    readonly $container: DeploymentNodeBody;
+    readonly $type: 'DeployedInstance';
+    body?: DeployedInstanceBody;
+    element: ElementRef;
+    name?: Id;
+    title?: string;
+}
+export declare const DeployedInstance = "DeployedInstance";
+export declare function isDeployedInstance(item: unknown): item is DeployedInstance;
+export interface DeployedInstanceBody extends AstNode {
+    readonly $container: DeployedInstance;
+    readonly $type: 'DeployedInstanceBody';
+    props: Array<ElementProperty>;
+    tags?: Tags;
+}
+export declare const DeployedInstanceBody = "DeployedInstanceBody";
+export declare function isDeployedInstanceBody(item: unknown): item is DeployedInstanceBody;
+export interface DeploymentNode extends AstNode {
+    readonly $container: DeploymentNodeBody | ModelDeployments;
+    readonly $type: 'DeploymentNode';
+    body?: DeploymentNodeBody;
+    kind: Reference<DeploymentNodeKind>;
+    name: Id;
+    title?: string;
+}
+export declare const DeploymentNode = "DeploymentNode";
+export declare function isDeploymentNode(item: unknown): item is DeploymentNode;
+export interface DeploymentNodeBody extends AstNode {
+    readonly $container: DeploymentNode;
+    readonly $type: 'DeploymentNodeBody';
+    elements: Array<DeployedInstance | DeploymentNode | DeploymentRelation>;
+    props: Array<ElementProperty>;
+    tags?: Tags;
+}
+export declare const DeploymentNodeBody = "DeploymentNodeBody";
+export declare function isDeploymentNodeBody(item: unknown): item is DeploymentNodeBody;
+export interface DeploymentNodeKind extends AstNode {
+    readonly $container: SpecificationDeploymentNodeKind;
+    readonly $type: 'DeploymentNodeKind';
+    name: Id;
+}
+export declare const DeploymentNodeKind = "DeploymentNodeKind";
+export declare function isDeploymentNodeKind(item: unknown): item is DeploymentNodeKind;
+export interface DeploymentRelation extends AstNode {
+    readonly $container: DeploymentNodeBody | ModelDeployments;
+    readonly $type: 'DeploymentRelation';
+    body?: DeploymentRelationBody;
+    kind?: Reference<RelationshipKind>;
+    source: FqnRef;
+    tags?: Tags;
+    target: FqnRef;
+    technology?: string;
+    title?: string;
+}
+export declare const DeploymentRelation = "DeploymentRelation";
+export declare function isDeploymentRelation(item: unknown): item is DeploymentRelation;
+export interface DeploymentRelationBody extends AstNode {
+    readonly $container: DeploymentRelation;
+    readonly $type: 'DeploymentRelationBody';
+    props: Array<RelationProperty>;
+    tags?: Tags;
+}
+export declare const DeploymentRelationBody = "DeploymentRelationBody";
+export declare function isDeploymentRelationBody(item: unknown): item is DeploymentRelationBody;
+export interface DeploymentView extends AstNode {
+    readonly $container: ModelViews;
+    readonly $type: 'DeploymentView';
+    body?: DeploymentViewBody;
+    name: Id;
+}
+export declare const DeploymentView = "DeploymentView";
+export declare function isDeploymentView(item: unknown): item is DeploymentView;
+export interface DeploymentViewBody extends AstNode {
+    readonly $container: DeploymentView;
+    readonly $type: 'DeploymentViewBody';
+    props: Array<ViewProperty>;
+    rules: Array<DeploymentViewRule>;
+    tags?: Tags;
+}
+export declare const DeploymentViewBody = "DeploymentViewBody";
+export declare function isDeploymentViewBody(item: unknown): item is DeploymentViewBody;
+export interface DeploymentViewRulePredicate extends AstNode {
+    readonly $container: DeploymentViewBody;
+    readonly $type: 'DeploymentViewRulePredicate';
+    expr: DeploymentViewRulePredicateExpression;
+    isInclude: boolean;
+}
+export declare const DeploymentViewRulePredicate = "DeploymentViewRulePredicate";
+export declare function isDeploymentViewRulePredicate(item: unknown): item is DeploymentViewRulePredicate;
+export interface DeploymentViewRulePredicateExpression extends AstNode {
+    readonly $container: DeploymentViewRulePredicate | DeploymentViewRulePredicateExpression;
+    readonly $type: 'DeploymentViewRulePredicateExpression';
+    prev?: DeploymentViewRulePredicateExpression;
+    value: ExpressionV2;
+}
+export declare const DeploymentViewRulePredicateExpression = "DeploymentViewRulePredicateExpression";
+export declare function isDeploymentViewRulePredicateExpression(item: unknown): item is DeploymentViewRulePredicateExpression;
+export interface DeploymentViewRuleStyle extends AstNode {
+    readonly $container: DeploymentViewBody;
+    readonly $type: 'DeploymentViewRuleStyle';
+    props: Array<NotationProperty | StyleProperty>;
+    targets: FqnExpressions;
+}
+export declare const DeploymentViewRuleStyle = "DeploymentViewRuleStyle";
+export declare function isDeploymentViewRuleStyle(item: unknown): item is DeploymentViewRuleStyle;
+export interface DirectedRelationExpr extends AstNode {
+    readonly $container: DeploymentViewRulePredicateExpression;
+    readonly $type: 'DirectedRelationExpr';
+    source: OutgoingRelationExpr;
+    target: FqnExpr;
+}
+export declare const DirectedRelationExpr = "DirectedRelationExpr";
+export declare function isDirectedRelationExpr(item: unknown): item is DirectedRelationExpr;
+export interface DirectedRelationExpression extends AstNode {
+    readonly $container: Predicates | RelationPredicateWhere | RelationPredicateWith;
+    readonly $type: 'DirectedRelationExpression';
+    source: OutgoingRelationExpression;
+    target: ElementExpression;
+}
+export declare const DirectedRelationExpression = "DirectedRelationExpression";
+export declare function isDirectedRelationExpression(item: unknown): item is DirectedRelationExpression;
+export interface DynamicView extends AstNode {
+    readonly $container: ModelViews;
+    readonly $type: 'DynamicView';
+    body?: DynamicViewBody;
+    name: Id;
+}
+export declare const DynamicView = "DynamicView";
+export declare function isDynamicView(item: unknown): item is DynamicView;
+export interface DynamicViewBody extends AstNode {
+    readonly $container: DynamicView;
+    readonly $type: 'DynamicViewBody';
+    props: Array<ViewProperty>;
+    rules: Array<DynamicViewRule>;
+    steps: Array<DynamicViewParallelSteps | DynamicViewStep>;
+    tags?: Tags;
+}
+export declare const DynamicViewBody = "DynamicViewBody";
+export declare function isDynamicViewBody(item: unknown): item is DynamicViewBody;
+export interface DynamicViewGlobalPredicateRef extends AstNode {
+    readonly $container: DynamicViewBody;
+    readonly $type: 'DynamicViewGlobalPredicateRef';
+    predicate: Reference<GlobalDynamicPredicateGroup>;
+}
+export declare const DynamicViewGlobalPredicateRef = "DynamicViewGlobalPredicateRef";
+export declare function isDynamicViewGlobalPredicateRef(item: unknown): item is DynamicViewGlobalPredicateRef;
+export interface DynamicViewIncludePredicate extends AstNode {
+    readonly $container: DynamicViewBody | GlobalDynamicPredicateGroup;
+    readonly $type: 'DynamicViewIncludePredicate';
+    predicates: DynamicViewPredicateIterator;
+}
+export declare const DynamicViewIncludePredicate = "DynamicViewIncludePredicate";
+export declare function isDynamicViewIncludePredicate(item: unknown): item is DynamicViewIncludePredicate;
+export interface DynamicViewParallelSteps extends AstNode {
+    readonly $container: DynamicViewBody;
+    readonly $type: 'DynamicViewParallelSteps';
+    steps: Array<DynamicViewStep>;
+}
+export declare const DynamicViewParallelSteps = "DynamicViewParallelSteps";
+export declare function isDynamicViewParallelSteps(item: unknown): item is DynamicViewParallelSteps;
+export interface DynamicViewPredicateIterator extends AstNode {
+    readonly $container: DynamicViewIncludePredicate | DynamicViewPredicateIterator;
+    readonly $type: 'DynamicViewPredicateIterator';
+    prev?: DynamicViewPredicateIterator;
+    value: ElementPredicate;
+}
+export declare const DynamicViewPredicateIterator = "DynamicViewPredicateIterator";
+export declare function isDynamicViewPredicateIterator(item: unknown): item is DynamicViewPredicateIterator;
+export interface DynamicViewRef extends AstNode {
+    readonly $container: RelationNavigateToProperty;
+    readonly $type: 'DynamicViewRef';
+    view: Reference<DynamicView>;
+}
+export declare const DynamicViewRef = "DynamicViewRef";
+export declare function isDynamicViewRef(item: unknown): item is DynamicViewRef;
+export interface DynamicViewStep extends AstNode {
+    readonly $container: DynamicViewBody | DynamicViewParallelSteps;
+    readonly $type: 'DynamicViewStep';
+    custom?: CustomRelationProperties;
+    isBackward: boolean;
+    kind?: Reference<RelationshipKind>;
+    source: ElementRef;
+    target: ElementRef;
+    title?: string;
+}
+export declare const DynamicViewStep = "DynamicViewStep";
+export declare function isDynamicViewStep(item: unknown): item is DynamicViewStep;
+export interface Element extends AstNode {
+    readonly $container: ElementBody | ExtendElementBody | Model;
+    readonly $type: 'Element';
+    body?: ElementBody;
+    kind: Reference<ElementKind>;
+    name: Id;
+    props: Array<string>;
+}
+export declare const Element = "Element";
+export declare function isElement(item: unknown): item is Element;
+export interface ElementBody extends AstNode {
+    readonly $container: Element;
+    readonly $type: 'ElementBody';
+    elements: Array<Element | Relation>;
+    props: Array<ElementProperty>;
+    tags?: Tags;
+}
+export declare const ElementBody = "ElementBody";
+export declare function isElementBody(item: unknown): item is ElementBody;
+export interface ElementDescedantsExpression extends AstNode {
+    readonly $container: DirectedRelationExpression | DynamicViewPredicateIterator | ElementExpressionsIterator | ElementPredicateWhere | ElementPredicateWith | IncomingRelationExpression | OutgoingRelationExpression | Predicates;
+    readonly $type: 'ElementDescedantsExpression';
+    parent: ElementRef;
+    suffix: string;
+}
+export declare const ElementDescedantsExpression = "ElementDescedantsExpression";
+export declare function isElementDescedantsExpression(item: unknown): item is ElementDescedantsExpression;
+export interface ElementExpressionsIterator extends AstNode {
+    readonly $container: ElementExpressionsIterator | GlobalStyle | ViewRuleStyle;
+    readonly $type: 'ElementExpressionsIterator';
+    prev?: ElementExpressionsIterator;
+    value: ElementExpression;
+}
+export declare const ElementExpressionsIterator = "ElementExpressionsIterator";
+export declare function isElementExpressionsIterator(item: unknown): item is ElementExpressionsIterator;
+export interface ElementKind extends AstNode {
+    readonly $container: SpecificationElementKind;
+    readonly $type: 'ElementKind';
+    name: Id;
+}
+export declare const ElementKind = "ElementKind";
+export declare function isElementKind(item: unknown): item is ElementKind;
+export interface ElementKindExpression extends AstNode {
+    readonly $container: DirectedRelationExpression | DynamicViewPredicateIterator | ElementExpressionsIterator | ElementPredicateWhere | ElementPredicateWith | IncomingRelationExpression | OutgoingRelationExpression | Predicates;
+    readonly $type: 'ElementKindExpression';
+    isEqual: boolean;
+    kind?: Reference<ElementKind>;
+}
+export declare const ElementKindExpression = "ElementKindExpression";
+export declare function isElementKindExpression(item: unknown): item is ElementKindExpression;
+export interface ElementPredicateWhere extends AstNode {
+    readonly $container: DynamicViewPredicateIterator | ElementPredicateWith | Predicates;
+    readonly $type: 'ElementPredicateWhere';
+    subject: ElementExpression;
+    where?: WhereElementExpression;
+}
+export declare const ElementPredicateWhere = "ElementPredicateWhere";
+export declare function isElementPredicateWhere(item: unknown): item is ElementPredicateWhere;
+export interface ElementPredicateWith extends AstNode {
+    readonly $container: DynamicViewPredicateIterator | Predicates;
+    readonly $type: 'ElementPredicateWith';
+    custom?: CustomElementProperties;
+    subject: ElementPredicateOrWhere;
+}
+export declare const ElementPredicateWith = "ElementPredicateWith";
+export declare function isElementPredicateWith(item: unknown): item is ElementPredicateWith;
+export interface ElementRef extends AstNode {
+    readonly $container: DeployedInstance | DirectedRelationExpression | DynamicViewPredicateIterator | DynamicViewStep | ElementDescedantsExpression | ElementExpressionsIterator | ElementPredicateWhere | ElementPredicateWith | ElementRef | ElementView | ExpandElementExpression | IncomingRelationExpression | OutgoingRelationExpression | Predicates | Relation;
+    readonly $type: 'ElementRef';
+    el: Reference<Element>;
+    parent?: ElementRef;
+}
+export declare const ElementRef = "ElementRef";
+export declare function isElementRef(item: unknown): item is ElementRef;
+export interface ElementStringProperty extends AstNode {
+    readonly $container: CustomElementProperties | DeployedInstanceBody | DeploymentNodeBody | ElementBody;
+    readonly $type: 'ElementStringProperty';
+    key: 'description' | 'technology' | 'title';
+    value: string;
+}
+export declare const ElementStringProperty = "ElementStringProperty";
+export declare function isElementStringProperty(item: unknown): item is ElementStringProperty;
+export interface ElementStyleProperty extends AstNode {
+    readonly $container: DeployedInstanceBody | DeploymentNodeBody | ElementBody | SpecificationDeploymentNodeKind | SpecificationElementKind;
+    readonly $type: 'ElementStyleProperty';
+    key: 'style';
+    props: Array<StyleProperty>;
+}
+export declare const ElementStyleProperty = "ElementStyleProperty";
+export declare function isElementStyleProperty(item: unknown): item is ElementStyleProperty;
+export interface ElementTagExpression extends AstNode {
+    readonly $container: DirectedRelationExpression | DynamicViewPredicateIterator | ElementExpressionsIterator | ElementPredicateWhere | ElementPredicateWith | IncomingRelationExpression | OutgoingRelationExpression | Predicates;
+    readonly $type: 'ElementTagExpression';
+    isEqual: boolean;
+    tag?: Reference<Tag>;
+}
+export declare const ElementTagExpression = "ElementTagExpression";
+export declare function isElementTagExpression(item: unknown): item is ElementTagExpression;
+export interface ElementView extends AstNode {
+    readonly $container: ModelViews;
+    readonly $type: 'ElementView';
+    body?: ElementViewBody;
+    extends?: ElementViewRef;
+    name?: Id;
+    viewOf?: ElementRef;
+}
+export declare const ElementView = "ElementView";
+export declare function isElementView(item: unknown): item is ElementView;
+export interface ElementViewBody extends AstNode {
+    readonly $container: ElementView;
+    readonly $type: 'ElementViewBody';
+    props: Array<ViewProperty>;
+    rules: Array<ViewRule>;
+    tags?: Tags;
+}
+export declare const ElementViewBody = "ElementViewBody";
+export declare function isElementViewBody(item: unknown): item is ElementViewBody;
+export interface ElementViewRef extends AstNode {
+    readonly $container: ElementView;
+    readonly $type: 'ElementViewRef';
+    view: Reference<ElementView>;
+}
+export declare const ElementViewRef = "ElementViewRef";
+export declare function isElementViewRef(item: unknown): item is ElementViewRef;
+export interface ExcludePredicate extends AstNode {
+    readonly $container: ElementViewBody | GlobalPredicateGroup | ViewRuleGroup;
+    readonly $type: 'ExcludePredicate';
+    predicates: Predicates;
+}
+export declare const ExcludePredicate = "ExcludePredicate";
+export declare function isExcludePredicate(item: unknown): item is ExcludePredicate;
+export interface ExpandElementExpression extends AstNode {
+    readonly $container: DirectedRelationExpression | DynamicViewPredicateIterator | ElementExpressionsIterator | ElementPredicateWhere | ElementPredicateWith | IncomingRelationExpression | OutgoingRelationExpression | Predicates;
+    readonly $type: 'ExpandElementExpression';
+    expand: ElementRef;
+}
+export declare const ExpandElementExpression = "ExpandElementExpression";
+export declare function isExpandElementExpression(item: unknown): item is ExpandElementExpression;
+export interface ExtendElement extends AstNode {
+    readonly $container: Model;
+    readonly $type: 'ExtendElement';
+    body: ExtendElementBody;
+    element: FqnElementRef;
+}
+export declare const ExtendElement = "ExtendElement";
+export declare function isExtendElement(item: unknown): item is ExtendElement;
+export interface ExtendElementBody extends AstNode {
+    readonly $container: ExtendElement;
+    readonly $type: 'ExtendElementBody';
+    elements: Array<Element | Relation>;
+}
+export declare const ExtendElementBody = "ExtendElementBody";
+export declare function isExtendElementBody(item: unknown): item is ExtendElementBody;
+export interface FqnElementRef extends AstNode {
+    readonly $container: ExtendElement | FqnElementRef;
+    readonly $type: 'FqnElementRef';
+    el: Reference<Element>;
+    parent?: FqnElementRef;
+}
+export declare const FqnElementRef = "FqnElementRef";
+export declare function isFqnElementRef(item: unknown): item is FqnElementRef;
+export interface FqnExpressions extends AstNode {
+    readonly $container: DeploymentViewRuleStyle | FqnExpressions;
+    readonly $type: 'FqnExpressions';
+    prev?: FqnExpressions;
+    value: FqnExpr;
+}
+export declare const FqnExpressions = "FqnExpressions";
+export declare function isFqnExpressions(item: unknown): item is FqnExpressions;
+export interface FqnRef extends AstNode {
+    readonly $container: DeploymentRelation | FqnRef | FqnRefExpr;
+    readonly $type: 'FqnRef';
+    parent?: FqnRef;
+    value: Reference<Referenceable>;
+}
+export declare const FqnRef = "FqnRef";
+export declare function isFqnRef(item: unknown): item is FqnRef;
+export interface FqnRefExpr extends AstNode {
+    readonly $container: DeploymentViewRulePredicateExpression | DirectedRelationExpr | FqnExpressions | IncomingRelationExpr | OutgoingRelationExpr;
+    readonly $type: 'FqnRefExpr';
+    ref: FqnRef;
+    selector?: string;
+}
+export declare const FqnRefExpr = "FqnRefExpr";
+export declare function isFqnRefExpr(item: unknown): item is FqnRefExpr;
+export interface GlobalDynamicPredicateGroup extends AstNode {
+    readonly $container: Globals;
+    readonly $type: 'GlobalDynamicPredicateGroup';
+    name: string;
+    predicates: Array<DynamicViewIncludePredicate>;
+}
+export declare const GlobalDynamicPredicateGroup = "GlobalDynamicPredicateGroup";
+export declare function isGlobalDynamicPredicateGroup(item: unknown): item is GlobalDynamicPredicateGroup;
+export interface GlobalPredicateGroup extends AstNode {
+    readonly $container: Globals;
+    readonly $type: 'GlobalPredicateGroup';
+    name: string;
+    predicates: Array<ViewRulePredicate>;
+}
+export declare const GlobalPredicateGroup = "GlobalPredicateGroup";
+export declare function isGlobalPredicateGroup(item: unknown): item is GlobalPredicateGroup;
+export interface Globals extends AstNode {
+    readonly $container: LikeC4Grammar;
+    readonly $type: 'Globals';
+    name: 'global';
+    predicates: Array<GlobalDynamicPredicateGroup | GlobalPredicateGroup>;
+    styles: Array<GlobalStyle | GlobalStyleGroup>;
+}
+export declare const Globals = "Globals";
+export declare function isGlobals(item: unknown): item is Globals;
+export interface GlobalStyle extends AstNode {
+    readonly $container: Globals;
+    readonly $type: 'GlobalStyle';
+    id: GlobalStyleId;
+    props: Array<NotationProperty | StyleProperty>;
+    target: ElementExpressionsIterator;
+}
+export declare const GlobalStyle = "GlobalStyle";
+export declare function isGlobalStyle(item: unknown): item is GlobalStyle;
+export interface GlobalStyleGroup extends AstNode {
+    readonly $container: Globals;
+    readonly $type: 'GlobalStyleGroup';
+    id: GlobalStyleId;
+    styles: Array<ViewRuleStyle>;
+}
+export declare const GlobalStyleGroup = "GlobalStyleGroup";
+export declare function isGlobalStyleGroup(item: unknown): item is GlobalStyleGroup;
+export interface GlobalStyleId extends AstNode {
+    readonly $container: GlobalStyle | GlobalStyleGroup;
+    readonly $type: 'GlobalStyleId';
+    name: string;
+}
+export declare const GlobalStyleId = "GlobalStyleId";
+export declare function isGlobalStyleId(item: unknown): item is GlobalStyleId;
+export interface IconProperty extends AstNode {
+    readonly $container: CustomElementProperties | DeployedInstanceBody | DeploymentNodeBody | DeploymentViewRuleStyle | ElementBody | ElementStyleProperty | GlobalStyle | ViewRuleStyle;
+    readonly $type: 'IconProperty';
+    key: 'icon';
+    libicon?: Reference<LibIcon>;
+    value?: 'none' | Uri;
+}
+export declare const IconProperty = "IconProperty";
+export declare function isIconProperty(item: unknown): item is IconProperty;
+export interface IncludePredicate extends AstNode {
+    readonly $container: ElementViewBody | GlobalPredicateGroup | ViewRuleGroup;
+    readonly $type: 'IncludePredicate';
+    predicates: Predicates;
+}
+export declare const IncludePredicate = "IncludePredicate";
+export declare function isIncludePredicate(item: unknown): item is IncludePredicate;
+export interface IncomingRelationExpr extends AstNode {
+    readonly $container: DeploymentViewRulePredicateExpression | InOutRelationExpr;
+    readonly $type: 'IncomingRelationExpr';
+    to: FqnExpr;
+}
+export declare const IncomingRelationExpr = "IncomingRelationExpr";
+export declare function isIncomingRelationExpr(item: unknown): item is IncomingRelationExpr;
+export interface IncomingRelationExpression extends AstNode {
+    readonly $container: InOutRelationExpression | Predicates | RelationPredicateWhere | RelationPredicateWith;
+    readonly $type: 'IncomingRelationExpression';
+    to: ElementExpression;
+}
+export declare const IncomingRelationExpression = "IncomingRelationExpression";
+export declare function isIncomingRelationExpression(item: unknown): item is IncomingRelationExpression;
+export interface InOutRelationExpr extends AstNode {
+    readonly $container: DeploymentViewRulePredicateExpression;
+    readonly $type: 'InOutRelationExpr';
+    inout: IncomingRelationExpr;
+}
+export declare const InOutRelationExpr = "InOutRelationExpr";
+export declare function isInOutRelationExpr(item: unknown): item is InOutRelationExpr;
+export interface InOutRelationExpression extends AstNode {
+    readonly $container: Predicates | RelationPredicateWhere | RelationPredicateWith;
+    readonly $type: 'InOutRelationExpression';
+    inout: IncomingRelationExpression;
+}
+export declare const InOutRelationExpression = "InOutRelationExpression";
+export declare function isInOutRelationExpression(item: unknown): item is InOutRelationExpression;
+export interface LibIcon extends AstNode {
+    readonly $container: LikeC4Lib;
+    readonly $type: 'LibIcon';
+    name: IconId;
+}
+export declare const LibIcon = "LibIcon";
+export declare function isLibIcon(item: unknown): item is LibIcon;
+export interface LikeC4Grammar extends AstNode {
+    readonly $type: 'LikeC4Grammar';
+    deployments: Array<ModelDeployments>;
+    globals: Array<Globals>;
+    likec4lib: Array<LikeC4Lib>;
+    models: Array<Model>;
+    specifications: Array<SpecificationRule>;
+    views: Array<ModelViews>;
+}
+export declare const LikeC4Grammar = "LikeC4Grammar";
+export declare function isLikeC4Grammar(item: unknown): item is LikeC4Grammar;
+export interface LikeC4Lib extends AstNode {
+    readonly $container: LikeC4Grammar;
+    readonly $type: 'LikeC4Lib';
+    icons: Array<LibIcon>;
+}
+export declare const LikeC4Lib = "LikeC4Lib";
+export declare function isLikeC4Lib(item: unknown): item is LikeC4Lib;
+export interface LineProperty extends AstNode {
+    readonly $container: CustomRelationProperties | RelationStyleProperty | SpecificationRelationshipKind;
+    readonly $type: 'LineProperty';
+    key: 'line';
+    value: LineOptions;
+}
+export declare const LineProperty = "LineProperty";
+export declare function isLineProperty(item: unknown): item is LineProperty;
+export interface LinkProperty extends AstNode {
+    readonly $container: DeployedInstanceBody | DeploymentNodeBody | DeploymentRelationBody | DeploymentViewBody | DynamicViewBody | ElementBody | ElementViewBody | RelationBody;
+    readonly $type: 'LinkProperty';
+    key: 'link';
+    title?: string;
+    value: Uri;
+}
+export declare const LinkProperty = "LinkProperty";
+export declare function isLinkProperty(item: unknown): item is LinkProperty;
+export interface MetadataAttribute extends AstNode {
+    readonly $container: MetadataBody;
+    readonly $type: 'MetadataAttribute';
+    key: string;
+    value: string;
+}
+export declare const MetadataAttribute = "MetadataAttribute";
+export declare function isMetadataAttribute(item: unknown): item is MetadataAttribute;
+export interface MetadataBody extends AstNode {
+    readonly $container: DeployedInstanceBody | DeploymentNodeBody | DeploymentRelationBody | ElementBody | RelationBody;
+    readonly $type: 'MetadataBody';
+    props: Array<MetadataAttribute>;
+}
+export declare const MetadataBody = "MetadataBody";
+export declare function isMetadataBody(item: unknown): item is MetadataBody;
+export interface Model extends AstNode {
+    readonly $container: LikeC4Grammar;
+    readonly $type: 'Model';
+    elements: Array<Element | ExtendElement | Relation>;
+    name: 'model';
+}
+export declare const Model = "Model";
+export declare function isModel(item: unknown): item is Model;
+export interface ModelDeployments extends AstNode {
+    readonly $container: LikeC4Grammar;
+    readonly $type: 'ModelDeployments';
+    elements: Array<DeploymentNode | DeploymentRelation>;
+    name: 'deployment';
+}
+export declare const ModelDeployments = "ModelDeployments";
+export declare function isModelDeployments(item: unknown): item is ModelDeployments;
+export interface ModelViews extends AstNode {
+    readonly $container: LikeC4Grammar;
+    readonly $type: 'ModelViews';
+    name: 'views';
+    styles: Array<ViewRuleStyleOrGlobalRef>;
+    views: Array<LikeC4View>;
+}
+export declare const ModelViews = "ModelViews";
+export declare function isModelViews(item: unknown): item is ModelViews;
+export interface NavigateToProperty extends AstNode {
+    readonly $container: CustomElementProperties;
+    readonly $type: 'NavigateToProperty';
+    key: 'navigateTo';
+    value: ViewRef;
+}
+export declare const NavigateToProperty = "NavigateToProperty";
+export declare function isNavigateToProperty(item: unknown): item is NavigateToProperty;
+export interface NotationProperty extends AstNode {
+    readonly $container: CustomElementProperties | CustomRelationProperties | DeploymentViewRuleStyle | GlobalStyle | ViewRuleStyle;
+    readonly $type: 'NotationProperty';
+    key: 'notation';
+    value: string;
+}
+export declare const NotationProperty = "NotationProperty";
+export declare function isNotationProperty(item: unknown): item is NotationProperty;
+export interface NotesProperty extends AstNode {
+    readonly $container: CustomRelationProperties;
+    readonly $type: 'NotesProperty';
+    key: 'notes';
+    value: string;
+}
+export declare const NotesProperty = "NotesProperty";
+export declare function isNotesProperty(item: unknown): item is NotesProperty;
+export interface OpacityProperty extends AstNode {
+    readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleGroup | ViewRuleStyle;
+    readonly $type: 'OpacityProperty';
+    key: 'opacity';
+    value: string;
+}
+export declare const OpacityProperty = "OpacityProperty";
+export declare function isOpacityProperty(item: unknown): item is OpacityProperty;
+export interface OutgoingRelationExpr extends AstNode {
+    readonly $container: DeploymentViewRulePredicateExpression | DirectedRelationExpr;
+    readonly $type: 'OutgoingRelationExpr';
+    from: FqnExpr;
+    isBidirectional: boolean;
+    kind?: Reference<RelationshipKind>;
+}
+export declare const OutgoingRelationExpr = "OutgoingRelationExpr";
+export declare function isOutgoingRelationExpr(item: unknown): item is OutgoingRelationExpr;
+export interface OutgoingRelationExpression extends AstNode {
+    readonly $container: DirectedRelationExpression | Predicates | RelationPredicateWhere | RelationPredicateWith;
+    readonly $type: 'OutgoingRelationExpression';
+    from: ElementExpression;
+    isBidirectional: boolean;
+    kind?: Reference<RelationshipKind>;
+}
+export declare const OutgoingRelationExpression = "OutgoingRelationExpression";
+export declare function isOutgoingRelationExpression(item: unknown): item is OutgoingRelationExpression;
+export interface Predicates extends AstNode {
+    readonly $container: ExcludePredicate | IncludePredicate | Predicates;
+    readonly $type: 'Predicates';
+    prev?: Predicates;
+    value: Predicate;
+}
+export declare const Predicates = "Predicates";
+export declare function isPredicates(item: unknown): item is Predicates;
+export interface Relation extends AstNode {
+    readonly $container: ElementBody | ExtendElementBody | Model;
+    readonly $type: 'Relation';
+    body?: RelationBody;
+    kind?: Reference<RelationshipKind>;
+    source?: ElementRef;
+    tags?: Tags;
+    target: ElementRef;
+    technology?: string;
+    title?: string;
+}
+export declare const Relation = "Relation";
+export declare function isRelation(item: unknown): item is Relation;
+export interface RelationBody extends AstNode {
+    readonly $container: Relation;
+    readonly $type: 'RelationBody';
+    props: Array<RelationProperty>;
+    tags?: Tags;
+}
+export declare const RelationBody = "RelationBody";
+export declare function isRelationBody(item: unknown): item is RelationBody;
+export interface RelationNavigateToProperty extends AstNode {
+    readonly $container: CustomRelationProperties | DeploymentRelationBody | RelationBody;
+    readonly $type: 'RelationNavigateToProperty';
+    key: 'navigateTo';
+    value: DynamicViewRef;
+}
+export declare const RelationNavigateToProperty = "RelationNavigateToProperty";
+export declare function isRelationNavigateToProperty(item: unknown): item is RelationNavigateToProperty;
+export interface RelationPredicateWhere extends AstNode {
+    readonly $container: Predicates | RelationPredicateWith;
+    readonly $type: 'RelationPredicateWhere';
+    subject: RelationExpression;
+    where?: WhereRelationExpression;
+}
+export declare const RelationPredicateWhere = "RelationPredicateWhere";
+export declare function isRelationPredicateWhere(item: unknown): item is RelationPredicateWhere;
+export interface RelationPredicateWith extends AstNode {
+    readonly $container: Predicates;
+    readonly $type: 'RelationPredicateWith';
+    custom?: CustomRelationProperties;
+    subject: RelationPredicateOrWhere;
+}
+export declare const RelationPredicateWith = "RelationPredicateWith";
+export declare function isRelationPredicateWith(item: unknown): item is RelationPredicateWith;
+export interface RelationshipKind extends AstNode {
+    readonly $container: SpecificationRelationshipKind;
+    readonly $type: 'RelationshipKind';
+    name: Id;
+}
+export declare const RelationshipKind = "RelationshipKind";
+export declare function isRelationshipKind(item: unknown): item is RelationshipKind;
+export interface RelationStringProperty extends AstNode {
+    readonly $container: CustomRelationProperties | DeploymentRelationBody | RelationBody;
+    readonly $type: 'RelationStringProperty';
+    key: 'description' | 'technology' | 'title';
+    value: string;
+}
+export declare const RelationStringProperty = "RelationStringProperty";
+export declare function isRelationStringProperty(item: unknown): item is RelationStringProperty;
+export interface RelationStyleProperty extends AstNode {
+    readonly $container: DeploymentRelationBody | RelationBody;
+    readonly $type: 'RelationStyleProperty';
+    key: 'style';
+    props: Array<RelationshipStyleProperty>;
+}
+export declare const RelationStyleProperty = "RelationStyleProperty";
+export declare function isRelationStyleProperty(item: unknown): item is RelationStyleProperty;
+export interface ShapeProperty extends AstNode {
+    readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleStyle;
+    readonly $type: 'ShapeProperty';
+    key: 'shape';
+    value: ElementShape;
+}
+export declare const ShapeProperty = "ShapeProperty";
+export declare function isShapeProperty(item: unknown): item is ShapeProperty;
+export interface SpecificationColor extends AstNode {
+    readonly $container: SpecificationRule;
+    readonly $type: 'SpecificationColor';
+    color: CustomColorValue;
+    name: CustomColor;
+}
+export declare const SpecificationColor = "SpecificationColor";
+export declare function isSpecificationColor(item: unknown): item is SpecificationColor;
+export interface SpecificationDeploymentNodeKind extends AstNode {
+    readonly $container: SpecificationRule;
+    readonly $type: 'SpecificationDeploymentNodeKind';
+    kind: DeploymentNodeKind;
+    props: Array<ElementStyleProperty | SpecificationElementStringProperty>;
+}
+export declare const SpecificationDeploymentNodeKind = "SpecificationDeploymentNodeKind";
+export declare function isSpecificationDeploymentNodeKind(item: unknown): item is SpecificationDeploymentNodeKind;
+export interface SpecificationElementKind extends AstNode {
+    readonly $container: SpecificationRule;
+    readonly $type: 'SpecificationElementKind';
+    kind: ElementKind;
+    props: Array<ElementStyleProperty | SpecificationElementStringProperty>;
+}
+export declare const SpecificationElementKind = "SpecificationElementKind";
+export declare function isSpecificationElementKind(item: unknown): item is SpecificationElementKind;
+export interface SpecificationElementStringProperty extends AstNode {
+    readonly $container: SpecificationDeploymentNodeKind | SpecificationElementKind;
+    readonly $type: 'SpecificationElementStringProperty';
+    key: 'notation' | 'technology';
+    value: string;
+}
+export declare const SpecificationElementStringProperty = "SpecificationElementStringProperty";
+export declare function isSpecificationElementStringProperty(item: unknown): item is SpecificationElementStringProperty;
+export interface SpecificationRelationshipKind extends AstNode {
+    readonly $container: SpecificationRule;
+    readonly $type: 'SpecificationRelationshipKind';
+    kind: RelationshipKind;
+    props: Array<RelationshipStyleProperty | SpecificationRelationshipStringProperty>;
+}
+export declare const SpecificationRelationshipKind = "SpecificationRelationshipKind";
+export declare function isSpecificationRelationshipKind(item: unknown): item is SpecificationRelationshipKind;
+export interface SpecificationRelationshipStringProperty extends AstNode {
+    readonly $container: SpecificationRelationshipKind;
+    readonly $type: 'SpecificationRelationshipStringProperty';
+    key: 'notation' | 'technology';
+    value: string;
+}
+export declare const SpecificationRelationshipStringProperty = "SpecificationRelationshipStringProperty";
+export declare function isSpecificationRelationshipStringProperty(item: unknown): item is SpecificationRelationshipStringProperty;
+export interface SpecificationRule extends AstNode {
+    readonly $container: LikeC4Grammar;
+    readonly $type: 'SpecificationRule';
+    colors: Array<SpecificationColor>;
+    deploymentNodes: Array<SpecificationDeploymentNodeKind>;
+    elements: Array<SpecificationElementKind>;
+    name: 'specification';
+    relationships: Array<SpecificationRelationshipKind>;
+    tags: Array<SpecificationTag>;
+}
+export declare const SpecificationRule = "SpecificationRule";
+export declare function isSpecificationRule(item: unknown): item is SpecificationRule;
+export interface SpecificationTag extends AstNode {
+    readonly $container: SpecificationRule;
+    readonly $type: 'SpecificationTag';
+    tag: Tag;
+}
+export declare const SpecificationTag = "SpecificationTag";
+export declare function isSpecificationTag(item: unknown): item is SpecificationTag;
+export interface Tag extends AstNode {
+    readonly $container: SpecificationTag;
+    readonly $type: 'Tag';
+    name: Id;
+}
+export declare const Tag = "Tag";
+export declare function isTag(item: unknown): item is Tag;
+export interface Tags extends AstNode {
+    readonly $container: DeployedInstanceBody | DeploymentNodeBody | DeploymentRelation | DeploymentRelationBody | DeploymentViewBody | DynamicViewBody | ElementBody | ElementViewBody | Relation | RelationBody | Tags;
+    readonly $type: 'Tags';
+    prev?: Tags;
+    values: Array<Reference<Tag>>;
+}
+export declare const Tags = "Tags";
+export declare function isTags(item: unknown): item is Tags;
+export interface ViewRef extends AstNode {
+    readonly $container: NavigateToProperty;
+    readonly $type: 'ViewRef';
+    view: Reference<LikeC4View>;
+}
+export declare const ViewRef = "ViewRef";
+export declare function isViewRef(item: unknown): item is ViewRef;
+export interface ViewRuleAutoLayout extends AstNode {
+    readonly $container: DeploymentViewBody | DynamicViewBody | ElementViewBody;
+    readonly $type: 'ViewRuleAutoLayout';
+    direction: ViewLayoutDirection;
+    nodeSep?: number;
+    rankSep?: number;
+}
+export declare const ViewRuleAutoLayout = "ViewRuleAutoLayout";
+export declare function isViewRuleAutoLayout(item: unknown): item is ViewRuleAutoLayout;
+export interface ViewRuleGlobalPredicateRef extends AstNode {
+    readonly $container: ElementViewBody;
+    readonly $type: 'ViewRuleGlobalPredicateRef';
+    predicate: Reference<GlobalPredicateGroup>;
+}
+export declare const ViewRuleGlobalPredicateRef = "ViewRuleGlobalPredicateRef";
+export declare function isViewRuleGlobalPredicateRef(item: unknown): item is ViewRuleGlobalPredicateRef;
+export interface ViewRuleGlobalStyle extends AstNode {
+    readonly $container: DynamicViewBody | ElementViewBody | ModelViews;
+    readonly $type: 'ViewRuleGlobalStyle';
+    style: Reference<GlobalStyleId>;
+}
+export declare const ViewRuleGlobalStyle = "ViewRuleGlobalStyle";
+export declare function isViewRuleGlobalStyle(item: unknown): item is ViewRuleGlobalStyle;
+export interface ViewRuleGroup extends AstNode {
+    readonly $container: ElementViewBody | ViewRuleGroup;
+    readonly $type: 'ViewRuleGroup';
+    groupRules: Array<ViewRuleGroup | ViewRulePredicate>;
+    props: Array<BorderProperty | ColorProperty | OpacityProperty>;
+    title?: string;
+}
+export declare const ViewRuleGroup = "ViewRuleGroup";
+export declare function isViewRuleGroup(item: unknown): item is ViewRuleGroup;
+export interface ViewRuleStyle extends AstNode {
+    readonly $container: DynamicViewBody | ElementViewBody | GlobalStyleGroup | ModelViews;
+    readonly $type: 'ViewRuleStyle';
+    props: Array<NotationProperty | StyleProperty>;
+    target: ElementExpressionsIterator;
+}
+export declare const ViewRuleStyle = "ViewRuleStyle";
+export declare function isViewRuleStyle(item: unknown): item is ViewRuleStyle;
+export interface ViewStringProperty extends AstNode {
+    readonly $container: DeploymentViewBody | DynamicViewBody | ElementViewBody;
+    readonly $type: 'ViewStringProperty';
+    key: 'description' | 'title';
+    value: string;
+}
+export declare const ViewStringProperty = "ViewStringProperty";
+export declare function isViewStringProperty(item: unknown): item is ViewStringProperty;
+export interface WhereBinaryExpression extends AstNode {
+    readonly $container: ElementPredicateWhere | RelationPredicateWhere | WhereBinaryExpression | WhereElementNegation | WhereRelationNegation;
+    readonly $type: 'WhereBinaryExpression';
+    left: WhereElementExpression | WhereRelationExpression;
+    operator: 'and' | 'or';
+    right: WhereElementExpression | WhereRelationExpression;
+}
+export declare const WhereBinaryExpression = "WhereBinaryExpression";
+export declare function isWhereBinaryExpression(item: unknown): item is WhereBinaryExpression;
+export interface WhereElementKind extends AstNode {
+    readonly $container: ElementPredicateWhere | WhereBinaryExpression | WhereElementNegation;
+    readonly $type: 'WhereElementKind';
+    not: boolean;
+    operator: 'is' | string;
+    value?: Reference<ElementKind>;
+}
+export declare const WhereElementKind = "WhereElementKind";
+export declare function isWhereElementKind(item: unknown): item is WhereElementKind;
+export interface WhereElementNegation extends AstNode {
+    readonly $container: ElementPredicateWhere | WhereBinaryExpression | WhereElementNegation;
+    readonly $type: 'WhereElementNegation';
+    value: WhereElementExpression;
+}
+export declare const WhereElementNegation = "WhereElementNegation";
+export declare function isWhereElementNegation(item: unknown): item is WhereElementNegation;
+export interface WhereElementTag extends AstNode {
+    readonly $container: ElementPredicateWhere | WhereBinaryExpression | WhereElementNegation;
+    readonly $type: 'WhereElementTag';
+    not: boolean;
+    operator: 'is' | string;
+    value?: Reference<Tag>;
+}
+export declare const WhereElementTag = "WhereElementTag";
+export declare function isWhereElementTag(item: unknown): item is WhereElementTag;
+export interface WhereRelationKind extends AstNode {
+    readonly $container: RelationPredicateWhere | WhereBinaryExpression | WhereRelationNegation;
+    readonly $type: 'WhereRelationKind';
+    not: boolean;
+    operator: 'is' | string;
+    value?: Reference<RelationshipKind>;
+}
+export declare const WhereRelationKind = "WhereRelationKind";
+export declare function isWhereRelationKind(item: unknown): item is WhereRelationKind;
+export interface WhereRelationNegation extends AstNode {
+    readonly $container: RelationPredicateWhere | WhereBinaryExpression | WhereRelationNegation;
+    readonly $type: 'WhereRelationNegation';
+    value: WhereRelationExpression;
+}
+export declare const WhereRelationNegation = "WhereRelationNegation";
+export declare function isWhereRelationNegation(item: unknown): item is WhereRelationNegation;
+export interface WhereRelationTag extends AstNode {
+    readonly $container: RelationPredicateWhere | WhereBinaryExpression | WhereRelationNegation;
+    readonly $type: 'WhereRelationTag';
+    not: boolean;
+    operator: 'is' | string;
+    value?: Reference<Tag>;
+}
+export declare const WhereRelationTag = "WhereRelationTag";
+export declare function isWhereRelationTag(item: unknown): item is WhereRelationTag;
+export interface WildcardExpression extends AstNode {
+    readonly $container: DeploymentViewRulePredicateExpression | DirectedRelationExpr | DirectedRelationExpression | DynamicViewPredicateIterator | ElementExpressionsIterator | ElementPredicateWhere | ElementPredicateWith | FqnExpressions | IncomingRelationExpr | IncomingRelationExpression | OutgoingRelationExpr | OutgoingRelationExpression | Predicates;
+    readonly $type: 'WildcardExpression';
+    isWildcard: boolean;
+}
+export declare const WildcardExpression = "WildcardExpression";
+export declare function isWildcardExpression(item: unknown): item is WildcardExpression;
+export type LikeC4AstType = {
+    ArrowProperty: ArrowProperty;
+    BorderProperty: BorderProperty;
+    ColorProperty: ColorProperty;
+    CustomColor: CustomColor;
+    CustomElementProperties: CustomElementProperties;
+    CustomRelationProperties: CustomRelationProperties;
+    DeployedInstance: DeployedInstance;
+    DeployedInstanceBody: DeployedInstanceBody;
+    DeploymentElement: DeploymentElement;
+    DeploymentNode: DeploymentNode;
+    DeploymentNodeBody: DeploymentNodeBody;
+    DeploymentNodeKind: DeploymentNodeKind;
+    DeploymentRelation: DeploymentRelation;
+    DeploymentRelationBody: DeploymentRelationBody;
+    DeploymentView: DeploymentView;
+    DeploymentViewBody: DeploymentViewBody;
+    DeploymentViewRule: DeploymentViewRule;
+    DeploymentViewRulePredicate: DeploymentViewRulePredicate;
+    DeploymentViewRulePredicateExpression: DeploymentViewRulePredicateExpression;
+    DeploymentViewRuleStyle: DeploymentViewRuleStyle;
+    DirectedRelationExpr: DirectedRelationExpr;
+    DirectedRelationExpression: DirectedRelationExpression;
+    DynamicView: DynamicView;
+    DynamicViewBody: DynamicViewBody;
+    DynamicViewGlobalPredicateRef: DynamicViewGlobalPredicateRef;
+    DynamicViewIncludePredicate: DynamicViewIncludePredicate;
+    DynamicViewParallelSteps: DynamicViewParallelSteps;
+    DynamicViewPredicateIterator: DynamicViewPredicateIterator;
+    DynamicViewRef: DynamicViewRef;
+    DynamicViewRule: DynamicViewRule;
+    DynamicViewStep: DynamicViewStep;
+    Element: Element;
+    ElementBody: ElementBody;
+    ElementDescedantsExpression: ElementDescedantsExpression;
+    ElementExpression: ElementExpression;
+    ElementExpressionsIterator: ElementExpressionsIterator;
+    ElementKind: ElementKind;
+    ElementKindExpression: ElementKindExpression;
+    ElementPredicate: ElementPredicate;
+    ElementPredicateOrWhere: ElementPredicateOrWhere;
+    ElementPredicateWhere: ElementPredicateWhere;
+    ElementPredicateWith: ElementPredicateWith;
+    ElementProperty: ElementProperty;
+    ElementRef: ElementRef;
+    ElementStringProperty: ElementStringProperty;
+    ElementStyleProperty: ElementStyleProperty;
+    ElementTagExpression: ElementTagExpression;
+    ElementView: ElementView;
+    ElementViewBody: ElementViewBody;
+    ElementViewRef: ElementViewRef;
+    ExcludePredicate: ExcludePredicate;
+    ExpandElementExpression: ExpandElementExpression;
+    ExpressionV2: ExpressionV2;
+    ExtendElement: ExtendElement;
+    ExtendElementBody: ExtendElementBody;
+    FqnElementRef: FqnElementRef;
+    FqnExpr: FqnExpr;
+    FqnExpressions: FqnExpressions;
+    FqnRef: FqnRef;
+    FqnRefExpr: FqnRefExpr;
+    FqnReferenceable: FqnReferenceable;
+    GlobalDynamicPredicateGroup: GlobalDynamicPredicateGroup;
+    GlobalPredicateGroup: GlobalPredicateGroup;
+    GlobalStyle: GlobalStyle;
+    GlobalStyleGroup: GlobalStyleGroup;
+    GlobalStyleId: GlobalStyleId;
+    Globals: Globals;
+    IconProperty: IconProperty;
+    InOutRelationExpr: InOutRelationExpr;
+    InOutRelationExpression: InOutRelationExpression;
+    IncludePredicate: IncludePredicate;
+    IncomingRelationExpr: IncomingRelationExpr;
+    IncomingRelationExpression: IncomingRelationExpression;
+    LibIcon: LibIcon;
+    LikeC4Grammar: LikeC4Grammar;
+    LikeC4Lib: LikeC4Lib;
+    LikeC4View: LikeC4View;
+    LineProperty: LineProperty;
+    LinkProperty: LinkProperty;
+    MetadataAttribute: MetadataAttribute;
+    MetadataBody: MetadataBody;
+    MetadataProperty: MetadataProperty;
+    Model: Model;
+    ModelDeployments: ModelDeployments;
+    ModelViews: ModelViews;
+    NavigateToProperty: NavigateToProperty;
+    NotationProperty: NotationProperty;
+    NotesProperty: NotesProperty;
+    OpacityProperty: OpacityProperty;
+    OutgoingRelationExpr: OutgoingRelationExpr;
+    OutgoingRelationExpression: OutgoingRelationExpression;
+    Predicate: Predicate;
+    Predicates: Predicates;
+    Referenceable: Referenceable;
+    Relation: Relation;
+    RelationBody: RelationBody;
+    RelationExpr: RelationExpr;
+    RelationExpression: RelationExpression;
+    RelationNavigateToProperty: RelationNavigateToProperty;
+    RelationPredicate: RelationPredicate;
+    RelationPredicateOrWhere: RelationPredicateOrWhere;
+    RelationPredicateWhere: RelationPredicateWhere;
+    RelationPredicateWith: RelationPredicateWith;
+    RelationProperty: RelationProperty;
+    RelationStringProperty: RelationStringProperty;
+    RelationStyleProperty: RelationStyleProperty;
+    RelationshipKind: RelationshipKind;
+    RelationshipStyleProperty: RelationshipStyleProperty;
+    ShapeProperty: ShapeProperty;
+    SpecificationColor: SpecificationColor;
+    SpecificationDeploymentNodeKind: SpecificationDeploymentNodeKind;
+    SpecificationElementKind: SpecificationElementKind;
+    SpecificationElementStringProperty: SpecificationElementStringProperty;
+    SpecificationRelationshipKind: SpecificationRelationshipKind;
+    SpecificationRelationshipStringProperty: SpecificationRelationshipStringProperty;
+    SpecificationRule: SpecificationRule;
+    SpecificationTag: SpecificationTag;
+    StringProperty: StringProperty;
+    StyleProperty: StyleProperty;
+    Tag: Tag;
+    Tags: Tags;
+    ViewProperty: ViewProperty;
+    ViewRef: ViewRef;
+    ViewRule: ViewRule;
+    ViewRuleAutoLayout: ViewRuleAutoLayout;
+    ViewRuleGlobalPredicateRef: ViewRuleGlobalPredicateRef;
+    ViewRuleGlobalStyle: ViewRuleGlobalStyle;
+    ViewRuleGroup: ViewRuleGroup;
+    ViewRulePredicate: ViewRulePredicate;
+    ViewRuleStyle: ViewRuleStyle;
+    ViewRuleStyleOrGlobalRef: ViewRuleStyleOrGlobalRef;
+    ViewStringProperty: ViewStringProperty;
+    WhereBinaryExpression: WhereBinaryExpression;
+    WhereElement: WhereElement;
+    WhereElementExpression: WhereElementExpression;
+    WhereElementKind: WhereElementKind;
+    WhereElementNegation: WhereElementNegation;
+    WhereElementTag: WhereElementTag;
+    WhereExpression: WhereExpression;
+    WhereKindEqual: WhereKindEqual;
+    WhereRelation: WhereRelation;
+    WhereRelationExpression: WhereRelationExpression;
+    WhereRelationKind: WhereRelationKind;
+    WhereRelationNegation: WhereRelationNegation;
+    WhereRelationTag: WhereRelationTag;
+    WhereTagEqual: WhereTagEqual;
+    WildcardExpression: WildcardExpression;
+};
+export declare class LikeC4AstReflection extends AbstractAstReflection {
+    getAllTypes(): string[];
+    protected computeIsSubtype(subtype: string, supertype: string): boolean;
+    getReferenceType(refInfo: ReferenceInfo): string;
+    getTypeMetaData(type: string): TypeMetaData;
+}
+export declare const reflection: LikeC4AstReflection;