@likec4/language-server 1.17.1 → 1.18.0

package/dist/shared/{language-server.BysPcTxr.d.ts → language-server.De7S3e5Z.d.ts}

@@ -1,9 +1,9 @@
-import { LangiumDocument, GrammarAST, MaybePromise, ReferenceDescription, AstNode, Reference, MultiMap, AstNodeDescription, DiagnosticInfo, LangiumDocuments, Stream, Cancellation, Disposable, URI, DefaultScopeComputation, PrecomputedScopes, DefaultScopeProvider, ReferenceInfo, Scope, DefaultWorkspaceManager, WorkspaceCache, Module } from 'langium';
+import { LangiumDocument, GrammarAST, MaybePromise, ReferenceDescription, AstNode, Reference, AstNodeDescription, MultiMap, DiagnosticInfo, DefaultNameProvider, CstNode, DefaultScopeComputation, PrecomputedScopes, DefaultScopeProvider, ReferenceInfo, Scope, LangiumDocuments, Stream, Cancellation, Disposable, URI, DefaultWorkspaceManager, WorkspaceCache, DocumentCache, Module } from 'langium';
 import { CodeLensProvider, DefaultCompletionProvider, CompletionContext, CompletionAcceptor, DefaultDocumentHighlightProvider, DocumentLinkProvider, DocumentSymbolProvider, NodeKindProvider as NodeKindProvider$1, AstNodeHoverProvider, AbstractSemanticTokenProvider, SemanticTokenAcceptor, LangiumSharedServices, DefaultWorkspaceSymbolProvider, LangiumServices, PartialLangiumServices, DefaultSharedModuleContext } from 'langium/lsp';
 import { CodeLensParams, CancellationToken, CodeLens, DocumentHighlight, DocumentLinkParams, DocumentLink, WorkspaceFolder } from 'vscode-languageserver';
 import { Diagnostic, DocumentSymbol, SymbolKind, Hover, Location, Range, TextEdit, CompletionItemKind } from 'vscode-languageserver-types';
 import * as c4 from '@likec4/core';
-import { Fqn, ViewID } from '@likec4/core';
+import { Fqn, ViewId } from '@likec4/core';
 import { SetRequired, ValueOf, ConditionalPick } from 'type-fest';
 import { ChangeViewRequestParams } from '../protocol.js';
 import { URI as URI$1 } from 'vscode-uri';
@@ -47,6 +47,18 @@ type ArrowType = 'crow' | 'diamond' | 'dot' | 'none' | 'normal' | 'odiamond' | '
 type BorderStyleValue = 'none' | LineOptions;
 type CustomColorId = 'element' | 'model' | ArrowType | ElementShape | LineOptions | string;
 type CustomColorValue = string;
+type DeploymentElement = DeployedInstance | DeploymentNode;
+declare const DeploymentElement = "DeploymentElement";
+type DeploymentElementExpression = DeploymentRefExpression | WildcardExpression;
+declare const DeploymentElementExpression = "DeploymentElementExpression";
+type DeploymentExpression = DeploymentElementExpression | DeploymentRelationExpression;
+declare const DeploymentExpression = "DeploymentExpression";
+type DeploymentReferenceable = DeployedInstance | DeploymentNode | Element;
+declare const DeploymentReferenceable = "DeploymentReferenceable";
+type DeploymentRelationExpression = DirectedDeploymentRelationExpression | InOutDeploymentRelationExpression | IncomingDeploymentRelationExpression | OutgoingDeploymentRelationExpression;
+declare const DeploymentRelationExpression = "DeploymentRelationExpression";
+type DeploymentViewRule = DeploymentViewRulePredicate | DeploymentViewRuleStyle | ViewRuleAutoLayout;
+declare const DeploymentViewRule = "DeploymentViewRule";
 type DynamicViewRule = DynamicViewGlobalPredicateRef | DynamicViewIncludePredicate | ViewRuleAutoLayout | ViewRuleStyleOrGlobalRef;
 declare const DynamicViewRule = "DynamicViewRule";
 type ElementExpression = ElementDescedantsExpression | ElementKindExpression | ElementRef | ElementTagExpression | ExpandElementExpression | WildcardExpression;
@@ -58,9 +70,11 @@ declare const ElementPredicateOrWhere = "ElementPredicateOrWhere";
 type ElementProperty = ElementStringProperty | ElementStyleProperty | IconProperty | LinkProperty | MetadataProperty;
 declare const ElementProperty = "ElementProperty";
 type ElementShape = 'browser' | 'cylinder' | 'mobile' | 'person' | 'queue' | 'rectangle' | 'storage';
+type FqnReferenceable = DeploymentReferenceable | Element | ExtendElement;
+declare const FqnReferenceable = "FqnReferenceable";
 type IconId = string;
-type Id = 'element' | 'group' | 'model' | ArrowType | ElementShape | LineOptions | ThemeColor | string;
-type LikeC4View = DynamicView | ElementView;
+type Id = 'deployment' | 'element' | 'group' | 'model' | 'node' | ArrowType | ElementShape | LineOptions | ThemeColor | string;
+type LikeC4View = DeploymentView | DynamicView | ElementView;
 declare const LikeC4View = "LikeC4View";
 type LineOptions = 'dashed' | 'dotted' | 'solid';
 type MetadataProperty = MetadataBody;
@@ -114,14 +128,14 @@ interface ArrowProperty extends AstNode {
 }
 declare const ArrowProperty = "ArrowProperty";
 interface BorderProperty extends AstNode {
-    readonly $container: CustomElementProperties | ElementStyleProperty | GlobalStyle | ViewRuleGroup | ViewRuleStyle;
+    readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleGroup | ViewRuleStyle;
     readonly $type: 'BorderProperty';
     key: 'border';
     value: BorderStyleValue;
 }
 declare const BorderProperty = "BorderProperty";
 interface ColorProperty extends AstNode {
-    readonly $container: CustomElementProperties | CustomRelationProperties | ElementStyleProperty | GlobalStyle | RelationStyleProperty | SpecificationRelationshipKind | ViewRuleGroup | ViewRuleStyle;
+    readonly $container: CustomElementProperties | CustomRelationProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | RelationStyleProperty | SpecificationRelationshipKind | ViewRuleGroup | ViewRuleStyle;
     readonly $type: 'ColorProperty';
     customColor?: Reference<CustomColor>;
     key: 'color';
@@ -146,6 +160,128 @@ interface CustomRelationProperties extends AstNode {
     props: Array<NotationProperty | NotesProperty | RelationNavigateToProperty | RelationStringProperty | RelationshipStyleProperty>;
 }
 declare const CustomRelationProperties = "CustomRelationProperties";
+interface DeployedInstance extends AstNode {
+    readonly $container: DeploymentNodeBody;
+    readonly $type: 'DeployedInstance';
+    body?: DeployedInstanceBody;
+    element: ElementRef;
+    name?: Id;
+    title?: string;
+}
+declare const DeployedInstance = "DeployedInstance";
+interface DeployedInstanceBody extends AstNode {
+    readonly $container: DeployedInstance;
+    readonly $type: 'DeployedInstanceBody';
+    props: Array<ElementProperty>;
+    tags?: Tags;
+}
+declare const DeployedInstanceBody = "DeployedInstanceBody";
+interface DeploymentExpressionIterator extends AstNode {
+    readonly $container: DeploymentExpressionIterator | DeploymentViewRuleStyle;
+    readonly $type: 'DeploymentExpressionIterator';
+    prev?: DeploymentExpressionIterator;
+    value: DeploymentElementExpression;
+}
+declare const DeploymentExpressionIterator = "DeploymentExpressionIterator";
+interface DeploymentNode extends AstNode {
+    readonly $container: DeploymentNodeBody | ModelDeployments;
+    readonly $type: 'DeploymentNode';
+    body?: DeploymentNodeBody;
+    kind: Reference<DeploymentNodeKind>;
+    name: Id;
+    title?: string;
+}
+declare const DeploymentNode = "DeploymentNode";
+interface DeploymentNodeBody extends AstNode {
+    readonly $container: DeploymentNode;
+    readonly $type: 'DeploymentNodeBody';
+    elements: Array<DeployedInstance | DeploymentNode | DeploymentRelation>;
+    props: Array<ElementProperty>;
+    tags?: Tags;
+}
+declare const DeploymentNodeBody = "DeploymentNodeBody";
+interface DeploymentNodeKind extends AstNode {
+    readonly $container: SpecificationDeploymentNodeKind;
+    readonly $type: 'DeploymentNodeKind';
+    name: Id;
+}
+declare const DeploymentNodeKind = "DeploymentNodeKind";
+interface DeploymentRef extends AstNode {
+    readonly $container: DeploymentRef | DeploymentRefExpression | DeploymentRelation;
+    readonly $type: 'DeploymentRef';
+    parent?: DeploymentRef;
+    value: Reference<DeploymentReferenceable>;
+}
+declare const DeploymentRef = "DeploymentRef";
+interface DeploymentRefExpression extends AstNode {
+    readonly $container: DeploymentExpressionIterator | DeploymentViewRulePredicateExpression | DirectedDeploymentRelationExpression | IncomingDeploymentRelationExpression | OutgoingDeploymentRelationExpression;
+    readonly $type: 'DeploymentRefExpression';
+    ref: DeploymentRef;
+    selector?: string;
+}
+declare const DeploymentRefExpression = "DeploymentRefExpression";
+interface DeploymentRelation extends AstNode {
+    readonly $container: DeploymentNodeBody | ModelDeployments;
+    readonly $type: 'DeploymentRelation';
+    body?: DeploymentRelationBody;
+    kind?: Reference<RelationshipKind>;
+    source: DeploymentRef;
+    tags?: Tags;
+    target: DeploymentRef;
+    technology?: string;
+    title?: string;
+}
+declare const DeploymentRelation = "DeploymentRelation";
+interface DeploymentRelationBody extends AstNode {
+    readonly $container: DeploymentRelation;
+    readonly $type: 'DeploymentRelationBody';
+    props: Array<RelationProperty>;
+    tags?: Tags;
+}
+declare const DeploymentRelationBody = "DeploymentRelationBody";
+interface DeploymentView extends AstNode {
+    readonly $container: ModelViews;
+    readonly $type: 'DeploymentView';
+    body?: DeploymentViewBody;
+    name: Id;
+}
+declare const DeploymentView = "DeploymentView";
+interface DeploymentViewBody extends AstNode {
+    readonly $container: DeploymentView;
+    readonly $type: 'DeploymentViewBody';
+    props: Array<ViewProperty>;
+    rules: Array<DeploymentViewRule>;
+    tags?: Tags;
+}
+declare const DeploymentViewBody = "DeploymentViewBody";
+interface DeploymentViewRulePredicate extends AstNode {
+    readonly $container: DeploymentViewBody;
+    readonly $type: 'DeploymentViewRulePredicate';
+    expr: DeploymentViewRulePredicateExpression;
+    isInclude: boolean;
+}
+declare const DeploymentViewRulePredicate = "DeploymentViewRulePredicate";
+interface DeploymentViewRulePredicateExpression extends AstNode {
+    readonly $container: DeploymentViewRulePredicate | DeploymentViewRulePredicateExpression;
+    readonly $type: 'DeploymentViewRulePredicateExpression';
+    prev?: DeploymentViewRulePredicateExpression;
+    value: DeploymentExpression;
+}
+declare const DeploymentViewRulePredicateExpression = "DeploymentViewRulePredicateExpression";
+interface DeploymentViewRuleStyle extends AstNode {
+    readonly $container: DeploymentViewBody;
+    readonly $type: 'DeploymentViewRuleStyle';
+    props: Array<NotationProperty | StyleProperty>;
+    target: DeploymentExpressionIterator;
+}
+declare const DeploymentViewRuleStyle = "DeploymentViewRuleStyle";
+interface DirectedDeploymentRelationExpression extends AstNode {
+    readonly $container: DeploymentViewRulePredicateExpression;
+    readonly $type: 'DirectedDeploymentRelationExpression';
+    source: OutgoingDeploymentRelationExpression;
+    target: DeploymentElementExpression;
+}
+declare const DirectedDeploymentRelationExpression = "DirectedDeploymentRelationExpression";
 interface DirectedRelationExpression extends AstNode {
     readonly $container: Predicates | RelationPredicateWhere | RelationPredicateWith;
     readonly $type: 'DirectedRelationExpression';
@@ -232,6 +368,7 @@ interface ElementDescedantsExpression extends AstNode {
     readonly $container: DirectedRelationExpression | DynamicViewPredicateIterator | ElementExpressionsIterator | ElementPredicateWhere | ElementPredicateWith | IncomingRelationExpression | OutgoingRelationExpression | Predicates;
     readonly $type: 'ElementDescedantsExpression';
     parent: ElementRef;
+    suffix: string;
 }
 declare const ElementDescedantsExpression = "ElementDescedantsExpression";
 interface ElementExpressionsIterator extends AstNode {
@@ -269,21 +406,21 @@ interface ElementPredicateWith extends AstNode {
 }
 declare const ElementPredicateWith = "ElementPredicateWith";
 interface ElementRef extends AstNode {
-    readonly $container: DirectedRelationExpression | DynamicViewPredicateIterator | DynamicViewStep | ElementDescedantsExpression | ElementExpressionsIterator | ElementPredicateWhere | ElementPredicateWith | ElementRef | ElementView | ExpandElementExpression | IncomingRelationExpression | OutgoingRelationExpression | Predicates | Relation;
+    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;
 }
 declare const ElementRef = "ElementRef";
 interface ElementStringProperty extends AstNode {
-    readonly $container: CustomElementProperties | ElementBody;
+    readonly $container: CustomElementProperties | DeployedInstanceBody | DeploymentNodeBody | ElementBody;
     readonly $type: 'ElementStringProperty';
     key: 'description' | 'technology' | 'title';
     value: string;
 }
 declare const ElementStringProperty = "ElementStringProperty";
 interface ElementStyleProperty extends AstNode {
-    readonly $container: ElementBody | SpecificationElementKind;
+    readonly $container: DeployedInstanceBody | DeploymentNodeBody | ElementBody | SpecificationDeploymentNodeKind | SpecificationElementKind;
     readonly $type: 'ElementStyleProperty';
     key: 'style';
     props: Array<StyleProperty>;
@@ -395,7 +532,7 @@ interface GlobalStyleId extends AstNode {
 }
 declare const GlobalStyleId = "GlobalStyleId";
 interface IconProperty extends AstNode {
-    readonly $container: CustomElementProperties | ElementBody | ElementStyleProperty | GlobalStyle | ViewRuleStyle;
+    readonly $container: CustomElementProperties | DeployedInstanceBody | DeploymentNodeBody | DeploymentViewRuleStyle | ElementBody | ElementStyleProperty | GlobalStyle | ViewRuleStyle;
     readonly $type: 'IconProperty';
     key: 'icon';
     libicon?: Reference<LibIcon>;
@@ -408,12 +545,24 @@ interface IncludePredicate extends AstNode {
     predicates: Predicates;
 }
 declare const IncludePredicate = "IncludePredicate";
+interface IncomingDeploymentRelationExpression extends AstNode {
+    readonly $container: DeploymentViewRulePredicateExpression | InOutDeploymentRelationExpression;
+    readonly $type: 'IncomingDeploymentRelationExpression';
+    to: DeploymentElementExpression;
+}
+declare const IncomingDeploymentRelationExpression = "IncomingDeploymentRelationExpression";
 interface IncomingRelationExpression extends AstNode {
     readonly $container: InOutRelationExpression | Predicates | RelationPredicateWhere | RelationPredicateWith;
     readonly $type: 'IncomingRelationExpression';
     to: ElementExpression;
 }
 declare const IncomingRelationExpression = "IncomingRelationExpression";
+interface InOutDeploymentRelationExpression extends AstNode {
+    readonly $container: DeploymentViewRulePredicateExpression;
+    readonly $type: 'InOutDeploymentRelationExpression';
+    inout: IncomingDeploymentRelationExpression;
+}
+declare const InOutDeploymentRelationExpression = "InOutDeploymentRelationExpression";
 interface InOutRelationExpression extends AstNode {
     readonly $container: Predicates | RelationPredicateWhere | RelationPredicateWith;
     readonly $type: 'InOutRelationExpression';
@@ -428,6 +577,7 @@ interface LibIcon extends AstNode {
 declare const LibIcon = "LibIcon";
 interface LikeC4Grammar extends AstNode {
     readonly $type: 'LikeC4Grammar';
+    deployments: Array<ModelDeployments>;
     globals: Array<Globals>;
     likec4lib: Array<LikeC4Lib>;
     models: Array<Model>;
@@ -449,7 +599,7 @@ interface LineProperty extends AstNode {
 }
 declare const LineProperty = "LineProperty";
 interface LinkProperty extends AstNode {
-    readonly $container: DynamicViewBody | ElementBody | ElementViewBody | RelationBody;
+    readonly $container: DeployedInstanceBody | DeploymentNodeBody | DeploymentRelationBody | DeploymentViewBody | DynamicViewBody | ElementBody | ElementViewBody | RelationBody;
     readonly $type: 'LinkProperty';
     key: 'link';
     title?: string;
@@ -464,7 +614,7 @@ interface MetadataAttribute extends AstNode {
 }
 declare const MetadataAttribute = "MetadataAttribute";
 interface MetadataBody extends AstNode {
-    readonly $container: ElementBody | RelationBody;
+    readonly $container: DeployedInstanceBody | DeploymentNodeBody | DeploymentRelationBody | ElementBody | RelationBody;
     readonly $type: 'MetadataBody';
     props: Array<MetadataAttribute>;
 }
@@ -476,6 +626,13 @@ interface Model extends AstNode {
     name: 'model';
 }
 declare const Model = "Model";
+interface ModelDeployments extends AstNode {
+    readonly $container: LikeC4Grammar;
+    readonly $type: 'ModelDeployments';
+    elements: Array<DeploymentNode | DeploymentRelation>;
+    name: 'deployment';
+}
+declare const ModelDeployments = "ModelDeployments";
 interface ModelViews extends AstNode {
     readonly $container: LikeC4Grammar;
     readonly $type: 'ModelViews';
@@ -492,7 +649,7 @@ interface NavigateToProperty extends AstNode {
 }
 declare const NavigateToProperty = "NavigateToProperty";
 interface NotationProperty extends AstNode {
-    readonly $container: CustomElementProperties | CustomRelationProperties | GlobalStyle | ViewRuleStyle;
+    readonly $container: CustomElementProperties | CustomRelationProperties | DeploymentViewRuleStyle | GlobalStyle | ViewRuleStyle;
     readonly $type: 'NotationProperty';
     key: 'notation';
     value: string;
@@ -506,12 +663,20 @@ interface NotesProperty extends AstNode {
 }
 declare const NotesProperty = "NotesProperty";
 interface OpacityProperty extends AstNode {
-    readonly $container: CustomElementProperties | ElementStyleProperty | GlobalStyle | ViewRuleGroup | ViewRuleStyle;
+    readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleGroup | ViewRuleStyle;
     readonly $type: 'OpacityProperty';
     key: 'opacity';
     value: string;
 }
 declare const OpacityProperty = "OpacityProperty";
+interface OutgoingDeploymentRelationExpression extends AstNode {
+    readonly $container: DeploymentViewRulePredicateExpression | DirectedDeploymentRelationExpression;
+    readonly $type: 'OutgoingDeploymentRelationExpression';
+    from: DeploymentElementExpression;
+    isBidirectional: boolean;
+    kind?: Reference<RelationshipKind>;
+}
+declare const OutgoingDeploymentRelationExpression = "OutgoingDeploymentRelationExpression";
 interface OutgoingRelationExpression extends AstNode {
     readonly $container: DirectedRelationExpression | Predicates | RelationPredicateWhere | RelationPredicateWith;
     readonly $type: 'OutgoingRelationExpression';
@@ -547,7 +712,7 @@ interface RelationBody extends AstNode {
 }
 declare const RelationBody = "RelationBody";
 interface RelationNavigateToProperty extends AstNode {
-    readonly $container: CustomRelationProperties | RelationBody;
+    readonly $container: CustomRelationProperties | DeploymentRelationBody | RelationBody;
     readonly $type: 'RelationNavigateToProperty';
     key: 'navigateTo';
     value: DynamicViewRef;
@@ -574,21 +739,21 @@ interface RelationshipKind extends AstNode {
 }
 declare const RelationshipKind = "RelationshipKind";
 interface RelationStringProperty extends AstNode {
-    readonly $container: CustomRelationProperties | RelationBody;
+    readonly $container: CustomRelationProperties | DeploymentRelationBody | RelationBody;
     readonly $type: 'RelationStringProperty';
     key: 'description' | 'technology' | 'title';
     value: string;
 }
 declare const RelationStringProperty = "RelationStringProperty";
 interface RelationStyleProperty extends AstNode {
-    readonly $container: RelationBody;
+    readonly $container: DeploymentRelationBody | RelationBody;
     readonly $type: 'RelationStyleProperty';
     key: 'style';
     props: Array<RelationshipStyleProperty>;
 }
 declare const RelationStyleProperty = "RelationStyleProperty";
 interface ShapeProperty extends AstNode {
-    readonly $container: CustomElementProperties | ElementStyleProperty | GlobalStyle | ViewRuleStyle;
+    readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleStyle;
     readonly $type: 'ShapeProperty';
     key: 'shape';
     value: ElementShape;
@@ -601,6 +766,13 @@ interface SpecificationColor extends AstNode {
     name: CustomColor;
 }
 declare const SpecificationColor = "SpecificationColor";
+interface SpecificationDeploymentNodeKind extends AstNode {
+    readonly $container: SpecificationRule;
+    readonly $type: 'SpecificationDeploymentNodeKind';
+    kind: DeploymentNodeKind;
+    props: Array<ElementStyleProperty | SpecificationElementStringProperty>;
+}
+declare const SpecificationDeploymentNodeKind = "SpecificationDeploymentNodeKind";
 interface SpecificationElementKind extends AstNode {
     readonly $container: SpecificationRule;
     readonly $type: 'SpecificationElementKind';
@@ -609,7 +781,7 @@ interface SpecificationElementKind extends AstNode {
 }
 declare const SpecificationElementKind = "SpecificationElementKind";
 interface SpecificationElementStringProperty extends AstNode {
-    readonly $container: SpecificationElementKind;
+    readonly $container: SpecificationDeploymentNodeKind | SpecificationElementKind;
     readonly $type: 'SpecificationElementStringProperty';
     key: 'notation' | 'technology';
     value: string;
@@ -633,6 +805,7 @@ interface SpecificationRule extends AstNode {
     readonly $container: LikeC4Grammar;
     readonly $type: 'SpecificationRule';
     colors: Array<SpecificationColor>;
+    deploymentNodes: Array<SpecificationDeploymentNodeKind>;
     elements: Array<SpecificationElementKind>;
     name: 'specification';
     relationships: Array<SpecificationRelationshipKind>;
@@ -652,7 +825,7 @@ interface Tag extends AstNode {
 }
 declare const Tag = "Tag";
 interface Tags extends AstNode {
-    readonly $container: DynamicViewBody | ElementBody | ElementViewBody | Relation | RelationBody | Tags;
+    readonly $container: DeployedInstanceBody | DeploymentNodeBody | DeploymentRelation | DeploymentRelationBody | DeploymentViewBody | DynamicViewBody | ElementBody | ElementViewBody | Relation | RelationBody | Tags;
     readonly $type: 'Tags';
     prev?: Tags;
     values: Array<Reference<Tag>>;
@@ -665,7 +838,7 @@ interface ViewRef extends AstNode {
 }
 declare const ViewRef = "ViewRef";
 interface ViewRuleAutoLayout extends AstNode {
-    readonly $container: DynamicViewBody | ElementViewBody;
+    readonly $container: DeploymentViewBody | DynamicViewBody | ElementViewBody;
     readonly $type: 'ViewRuleAutoLayout';
     direction: ViewLayoutDirection;
     nodeSep?: number;
@@ -700,7 +873,7 @@ interface ViewRuleStyle extends AstNode {
 }
 declare const ViewRuleStyle = "ViewRuleStyle";
 interface ViewStringProperty extends AstNode {
-    readonly $container: DynamicViewBody | ElementViewBody;
+    readonly $container: DeploymentViewBody | DynamicViewBody | ElementViewBody;
     readonly $type: 'ViewStringProperty';
     key: 'description' | 'title';
     value: string;
@@ -759,7 +932,7 @@ interface WhereRelationTag extends AstNode {
 }
 declare const WhereRelationTag = "WhereRelationTag";
 interface WildcardExpression extends AstNode {
-    readonly $container: DirectedRelationExpression | DynamicViewPredicateIterator | ElementExpressionsIterator | ElementPredicateWhere | ElementPredicateWith | IncomingRelationExpression | OutgoingRelationExpression | Predicates;
+    readonly $container: DeploymentExpressionIterator | DeploymentViewRulePredicateExpression | DirectedDeploymentRelationExpression | DirectedRelationExpression | DynamicViewPredicateIterator | ElementExpressionsIterator | ElementPredicateWhere | ElementPredicateWith | IncomingDeploymentRelationExpression | IncomingRelationExpression | OutgoingDeploymentRelationExpression | OutgoingRelationExpression | Predicates;
     readonly $type: 'WildcardExpression';
     isWildcard: boolean;
 }
@@ -771,6 +944,28 @@ type LikeC4AstType = {
     CustomColor: CustomColor;
     CustomElementProperties: CustomElementProperties;
     CustomRelationProperties: CustomRelationProperties;
+    DeployedInstance: DeployedInstance;
+    DeployedInstanceBody: DeployedInstanceBody;
+    DeploymentElement: DeploymentElement;
+    DeploymentElementExpression: DeploymentElementExpression;
+    DeploymentExpression: DeploymentExpression;
+    DeploymentExpressionIterator: DeploymentExpressionIterator;
+    DeploymentNode: DeploymentNode;
+    DeploymentNodeBody: DeploymentNodeBody;
+    DeploymentNodeKind: DeploymentNodeKind;
+    DeploymentRef: DeploymentRef;
+    DeploymentRefExpression: DeploymentRefExpression;
+    DeploymentReferenceable: DeploymentReferenceable;
+    DeploymentRelation: DeploymentRelation;
+    DeploymentRelationBody: DeploymentRelationBody;
+    DeploymentRelationExpression: DeploymentRelationExpression;
+    DeploymentView: DeploymentView;
+    DeploymentViewBody: DeploymentViewBody;
+    DeploymentViewRule: DeploymentViewRule;
+    DeploymentViewRulePredicate: DeploymentViewRulePredicate;
+    DeploymentViewRulePredicateExpression: DeploymentViewRulePredicateExpression;
+    DeploymentViewRuleStyle: DeploymentViewRuleStyle;
+    DirectedDeploymentRelationExpression: DirectedDeploymentRelationExpression;
     DirectedRelationExpression: DirectedRelationExpression;
     DynamicView: DynamicView;
     DynamicViewBody: DynamicViewBody;
@@ -805,6 +1000,7 @@ type LikeC4AstType = {
     ExtendElement: ExtendElement;
     ExtendElementBody: ExtendElementBody;
     FqnElementRef: FqnElementRef;
+    FqnReferenceable: FqnReferenceable;
     GlobalDynamicPredicateGroup: GlobalDynamicPredicateGroup;
     GlobalPredicateGroup: GlobalPredicateGroup;
     GlobalStyle: GlobalStyle;
@@ -812,8 +1008,10 @@ type LikeC4AstType = {
     GlobalStyleId: GlobalStyleId;
     Globals: Globals;
     IconProperty: IconProperty;
+    InOutDeploymentRelationExpression: InOutDeploymentRelationExpression;
     InOutRelationExpression: InOutRelationExpression;
     IncludePredicate: IncludePredicate;
+    IncomingDeploymentRelationExpression: IncomingDeploymentRelationExpression;
     IncomingRelationExpression: IncomingRelationExpression;
     LibIcon: LibIcon;
     LikeC4Grammar: LikeC4Grammar;
@@ -825,11 +1023,13 @@ type LikeC4AstType = {
     MetadataBody: MetadataBody;
     MetadataProperty: MetadataProperty;
     Model: Model;
+    ModelDeployments: ModelDeployments;
     ModelViews: ModelViews;
     NavigateToProperty: NavigateToProperty;
     NotationProperty: NotationProperty;
     NotesProperty: NotesProperty;
     OpacityProperty: OpacityProperty;
+    OutgoingDeploymentRelationExpression: OutgoingDeploymentRelationExpression;
     OutgoingRelationExpression: OutgoingRelationExpression;
     Predicate: Predicate;
     Predicates: Predicates;
@@ -848,6 +1048,7 @@ type LikeC4AstType = {
     RelationshipStyleProperty: RelationshipStyleProperty;
     ShapeProperty: ShapeProperty;
     SpecificationColor: SpecificationColor;
+    SpecificationDeploymentNodeKind: SpecificationDeploymentNodeKind;
     SpecificationElementKind: SpecificationElementKind;
     SpecificationElementStringProperty: SpecificationElementStringProperty;
     SpecificationRelationshipKind: SpecificationRelationshipKind;
@@ -892,10 +1093,19 @@ declare module './generated/ast' {
         [idattr]?: c4.Fqn | undefined;
     }
     interface ElementView {
-        [idattr]?: c4.ViewID | undefined;
+        [idattr]?: c4.ViewId | undefined;
     }
     interface DynamicView {
-        [idattr]?: c4.ViewID | undefined;
+        [idattr]?: c4.ViewId | undefined;
+    }
+    interface DeploymentView {
+        [idattr]?: c4.ViewId | undefined;
+    }
+    interface DeploymentNode {
+        [idattr]?: c4.Fqn | undefined;
+    }
+    interface DeployedInstance {
+        [idattr]?: c4.Fqn | undefined;
     }
 }
 type ParsedElementStyle = {
@@ -923,6 +1133,7 @@ interface ParsedAstSpecification {
     colors: Record<c4.CustomColor, {
         color: c4.HexColorLiteral;
     }>;
+    deployments: Record<c4.DeploymentNodeKind, c4.DeploymentNodeKindSpecification>;
 }
 interface ParsedAstElement {
     id: c4.Fqn;
@@ -939,7 +1150,7 @@ interface ParsedAstElement {
     };
 }
 interface ParsedAstRelation {
-    id: c4.RelationID;
+    id: c4.RelationId;
     astPath: string;
     source: c4.Fqn;
     target: c4.Fqn;
@@ -953,17 +1164,25 @@ interface ParsedAstRelation {
     head?: c4.RelationshipArrowType;
     tail?: c4.RelationshipArrowType;
     links?: c4.NonEmptyArray<ParsedLink>;
-    navigateTo?: c4.ViewID;
+    navigateTo?: c4.ViewId;
     metadata?: {
         [key: string]: string;
     };
 }
+type ParsedAstDeployment = c4.DeploymentElement;
+declare namespace ParsedAstDeployment {
+    type Node = c4.DeploymentNode;
+    type Instance = c4.DeployedInstance;
+}
+type ParsedAstDeploymentRelation = c4.DeploymentRelation & {
+    astPath: string;
+};
 type ParsedAstGlobals = c4.ModelGlobals;
 interface ParsedAstElementView {
     __: 'element';
-    id: c4.ViewID;
+    id: c4.ViewId;
     viewOf?: c4.Fqn;
-    extends?: c4.ViewID;
+    extends?: c4.ViewId;
     astPath: string;
     title: string | null;
     description: string | null;
@@ -974,7 +1193,7 @@ interface ParsedAstElementView {
 }
 interface ParsedAstDynamicView {
     __: 'dynamic';
-    id: c4.ViewID;
+    id: c4.ViewId;
     astPath: string;
     title: string | null;
     description: string | null;
@@ -984,7 +1203,17 @@ interface ParsedAstDynamicView {
     rules: Array<c4.DynamicViewRule>;
     manualLayout?: c4.ViewManualLayout;
 }
-type ParsedAstView = ParsedAstElementView | ParsedAstDynamicView;
+interface ParsedAstDeploymentView {
+    __: 'deployment';
+    id: c4.ViewId;
+    astPath: string;
+    title: string | null;
+    description: string | null;
+    tags: c4.NonEmptyArray<c4.Tag> | null;
+    links: c4.NonEmptyArray<ParsedLink> | null;
+    rules: Array<c4.DeploymentViewRule>;
+}
+type ParsedAstView = ParsedAstElementView | ParsedAstDynamicView | ParsedAstDeploymentView;
 interface ParsedLink {
     title?: string;
     url: string;
@@ -992,6 +1221,9 @@ interface ParsedLink {
 interface DocFqnIndexAstNodeDescription extends AstNodeDescription {
     fqn: c4.Fqn;
 }
+interface DeploymentAstNodeDescription extends AstNodeDescription {
+    fqn: string;
+}
 type LikeC4AstNode = ValueOf<ConditionalPick<LikeC4AstType, AstNode>>;
 type LikeC4DocumentDiagnostic = Diagnostic & DiagnosticInfo<LikeC4AstNode>;
 interface LikeC4DocumentProps {
@@ -1001,21 +1233,24 @@ interface LikeC4DocumentProps {
     c4Relations?: ParsedAstRelation[];
     c4Globals?: ParsedAstGlobals;
     c4Views?: ParsedAstView[];
+    c4Deployments?: ParsedAstDeployment[];
+    c4DeploymentRelations?: ParsedAstDeploymentRelation[];
     c4fqnIndex?: MultiMap<c4.Fqn, DocFqnIndexAstNodeDescription>;
 }
-interface LikeC4LangiumDocument extends Omit<LangiumDocument<LikeC4Grammar>, 'diagnostics'>, LikeC4DocumentProps {
+type LikeC4GrammarDocument = Omit<LangiumDocument<LikeC4Grammar>, 'diagnostics'>;
+interface LikeC4LangiumDocument extends LikeC4GrammarDocument, LikeC4DocumentProps {
 }
-interface FqnIndexedDocument extends Omit<LangiumDocument<LikeC4Grammar>, 'diagnostics'>, SetRequired<LikeC4DocumentProps, 'c4fqnIndex'> {
+interface FqnIndexedDocument extends SetRequired<LikeC4LangiumDocument, 'c4fqnIndex'> {
 }
-interface ParsedLikeC4LangiumDocument extends Omit<LangiumDocument<LikeC4Grammar>, 'diagnostics'>, Required<LikeC4DocumentProps> {
+interface ParsedLikeC4LangiumDocument extends LikeC4GrammarDocument, Required<LikeC4DocumentProps> {
 }
 type Guard<N extends AstNode> = (n: AstNode) => n is N;
 type Guarded<G> = G extends Guard<infer N> ? N : never;
-declare const isValidatableAstNode: (n: AstNode) => n is RelationStyleProperty | SpecificationRelationshipKind | DynamicViewStep | RelationPredicateWith | DynamicViewBody | DynamicViewParallelSteps | DynamicView | ModelViews | ExcludePredicate | IncludePredicate | ElementViewBody | GlobalPredicateGroup | ViewRuleGroup | ElementView | Globals | RelationBody | Relation | ElementBody | ExtendElementBody | Model | Element | ExtendElement | SpecificationRule | BorderProperty | ElementStyleProperty | GlobalStyle | ViewRuleStyle | ElementPredicateWith | DynamicViewPredicateIterator | DynamicViewIncludePredicate | GlobalDynamicPredicateGroup | SpecificationElementKind | GlobalStyleGroup | ColorProperty | SpecificationColor | DirectedRelationExpression | DynamicViewGlobalPredicateRef | RelationNavigateToProperty | ViewRuleAutoLayout | ViewRuleGlobalStyle | ElementDescedantsExpression | IncomingRelationExpression | OutgoingRelationExpression | InOutRelationExpression | ElementKindExpression | ElementRef | ElementTagExpression | ExpandElementExpression | WildcardExpression | ElementStringProperty | IconProperty | LinkProperty | MetadataBody | OpacityProperty | RelationStringProperty | ShapeProperty | SpecificationTag | ViewStringProperty | Tags | ViewRuleGlobalPredicateRef;
+declare const isValidatableAstNode: (n: AstNode) => n is ArrowProperty | SpecificationRelationshipKind | DynamicViewStep | RelationPredicateWith | DynamicViewParallelSteps | DynamicView | ExcludePredicate | IncludePredicate | GlobalPredicateGroup | ViewRuleGroup | ElementView | Globals | DeploymentNode | Relation | Element | ExtendElement | SpecificationRule | BorderProperty | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleStyle | ElementPredicateWith | DynamicViewPredicateIterator | DynamicViewIncludePredicate | GlobalDynamicPredicateGroup | DeploymentView | SpecificationDeploymentNodeKind | SpecificationElementKind | DeployedInstance | GlobalStyleGroup | ColorProperty | SpecificationColor | DeploymentRefExpression | WildcardExpression | DirectedDeploymentRelationExpression | IncomingDeploymentRelationExpression | OutgoingDeploymentRelationExpression | DeploymentViewRulePredicate | InOutDeploymentRelationExpression | DirectedRelationExpression | ElementPredicateWhere | IncomingRelationExpression | OutgoingRelationExpression | RelationPredicateWhere | InOutRelationExpression | ViewRuleAutoLayout | DynamicViewGlobalPredicateRef | ViewRuleGlobalStyle | ElementDescedantsExpression | ElementKindExpression | ElementRef | ElementTagExpression | ExpandElementExpression | ElementStringProperty | IconProperty | LinkProperty | MetadataBody | LineProperty | MetadataAttribute | NavigateToProperty | NotationProperty | NotesProperty | OpacityProperty | RelationStringProperty | ShapeProperty | SpecificationElementStringProperty | SpecificationRelationshipStringProperty | SpecificationTag | ViewStringProperty | Tags | ViewRuleGlobalPredicateRef;
 type ValidatableAstNode = Guarded<typeof isValidatableAstNode>;
 declare function checksFromDiagnostics(doc: LikeC4LangiumDocument): {
     isValid: (n: ValidatableAstNode) => boolean;
-    invalidNodes: WeakSet<any>;
+    invalidNodes: WeakSet<object>;
 };
 type ChecksFromDiagnostics = ReturnType<typeof checksFromDiagnostics>;
 
@@ -1039,6 +1274,7 @@ declare class LikeC4DocumentSymbolProvider implements DocumentSymbolProvider {
 }
 
 declare class LikeC4HoverProvider extends AstNodeHoverProvider {
+    private parser;
     private locator;
     constructor(services: LikeC4Services);
     protected getAstNodeHoverContent(node: AstNode): MaybePromise<Hover | undefined>;
@@ -1046,10 +1282,100 @@ declare class LikeC4HoverProvider extends AstNodeHoverProvider {
 
 declare class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
     protected highlightElement(node: AstNode, acceptor: SemanticTokenAcceptor): void | undefined | 'prune';
-    private highlightAstElement;
+    private highlightNameAndKind;
     private highlightView;
 }
 
+declare class LikeC4NameProvider extends DefaultNameProvider {
+    protected services: LikeC4Services;
+    constructor(services: LikeC4Services);
+    getNameStrict(node: AstNode): string;
+    getName(node: AstNode): string | undefined;
+    getNameNode(node: AstNode): CstNode | undefined;
+}
+
+type ElementsContainer = Model | ElementBody | ExtendElementBody;
+type DeploymentsContainer = ModelDeployments | DeploymentNodeBody;
+declare class LikeC4ScopeComputation extends DefaultScopeComputation {
+    constructor(services: LikeC4Services);
+    computeExports(document: LikeC4LangiumDocument, _cancelToken?: CancellationToken): Promise<AstNodeDescription[]>;
+    private exportViews;
+    private exportGlobals;
+    private exportModel;
+    private exportLibrary;
+    private exportSpecification;
+    private exportDeployments;
+    computeLocalScopes(document: LikeC4LangiumDocument, _cancelToken?: CancellationToken): Promise<PrecomputedScopes>;
+    protected processContainer(container: ElementsContainer, scopes: PrecomputedScopes, document: LikeC4LangiumDocument): AstNodeDescription[];
+    protected processDeployments(container: DeploymentsContainer, scopes: PrecomputedScopes, document: LikeC4LangiumDocument): AstNodeDescription[];
+}
+
+declare class LikeC4ScopeProvider extends DefaultScopeProvider {
+    private deploymentsIndex;
+    private fqnIndex;
+    constructor(services: LikeC4Services);
+    private directChildrenOf;
+    private uniqueDescedants;
+    private scopeElementRef;
+    private scopeExtendElement;
+    private scopeElementView;
+    getScope(context: ReferenceInfo): Scope;
+    protected getScopeForDeploymentRef(container: DeploymentRef, context: ReferenceInfo): Scope;
+    protected computeScope(context: ReferenceInfo, referenceType?: string): Scope;
+}
+
+declare class DeploymentsIndex {
+    private services;
+    protected Names: LikeC4NameProvider;
+    protected langiumDocuments: LangiumDocuments;
+    constructor(services: LikeC4Services);
+    private documents;
+    get(document: LikeC4LangiumDocument): DocumentDeploymentsIndex;
+    /**
+     * Nested elements (nodes/artifacts) of the node
+     * @param nodeName Name of the deployment node
+     * @returns Stream of artifacts
+     */
+    nested(node: DeploymentNode): Stream<DeploymentAstNodeDescription>;
+    byFqn(fqnName: string): Stream<DeploymentAstNodeDescription>;
+    getFqnName(node: DeploymentElement): Fqn;
+    createDocumentIndex(document: LikeC4LangiumDocument): DocumentDeploymentsIndex;
+}
+declare class DocumentDeploymentsIndex {
+    private _rootNodes;
+    /**
+     * Nested of a deployment node
+     */
+    private _nested;
+    /**
+     * All elements by FQN
+     */
+    private _byfqn;
+    static readonly EMPTY: DocumentDeploymentsIndex;
+    constructor(_rootNodes: Array<DeploymentAstNodeDescription>, 
+    /**
+     * Nested of a deployment node
+     */
+    _nested: MultiMap<string, DeploymentAstNodeDescription>, 
+    /**
+     * All elements by FQN
+     */
+    _byfqn: MultiMap<string, DeploymentAstNodeDescription>);
+    rootNodes(): readonly DeploymentAstNodeDescription[];
+    byFqn(fqnName: string): readonly DeploymentAstNodeDescription[];
+    /**
+     * Returns artifacts of a deployment node
+     * @param nodeName Name of the deployment node
+     * @returns Stream of artifacts
+     */
+    nested(nodeName: string): readonly DeploymentAstNodeDescription[];
+    /**
+     * Returns all deployment elements in the document,
+     * with unique combination "type and name"
+     */
+    unique(): readonly DeploymentAstNodeDescription[];
+}
+
 declare function computeDocumentFqn(document: LikeC4LangiumDocument, services: LikeC4Services): void;
 
 interface FqnIndexEntry {
@@ -1095,7 +1421,7 @@ declare class LikeC4ModelBuilder {
      */
     unsafeSyncBuildComputedModel(model: c4.ParsedLikeC4Model): c4.ComputedLikeC4Model;
     buildComputedModel(cancelToken?: Cancellation.CancellationToken): Promise<c4.ComputedLikeC4Model | null>;
-    computeView(viewId: ViewID, cancelToken?: Cancellation.CancellationToken): Promise<c4.ComputedView | null>;
+    computeView(viewId: ViewId, cancelToken?: Cancellation.CancellationToken): Promise<c4.ComputedView | null>;
     onModelParsed(callback: ModelParsedListener$1): Disposable;
     private documents;
     private notifyListeners;
@@ -1104,18 +1430,20 @@ declare class LikeC4ModelBuilder {
 declare class LikeC4ModelLocator {
     private services;
     private fqnIndex;
+    private deploymentsIndex;
     private langiumDocuments;
     constructor(services: LikeC4Services);
     private documents;
-    getParsedElement(astNode: Element): ParsedAstElement | null;
+    getParsedElement(astNodeOrFqn: Element | c4.Fqn): ParsedAstElement | null;
     locateElement(fqn: c4.Fqn, _prop?: string): Location | null;
-    locateRelation(relationId: c4.RelationID): Location | null;
-    locateViewAst(viewId: c4.ViewID): {
+    locateDeploymentElement(fqn: c4.Fqn, _prop?: string): Location | null;
+    locateRelation(relationId: c4.RelationId): Location | null;
+    locateViewAst(viewId: c4.ViewId): {
         doc: ParsedLikeC4LangiumDocument;
         view: ParsedAstView;
         viewAst: LikeC4View;
     };
-    locateView(viewId: c4.ViewID): Location | null;
+    locateView(viewId: c4.ViewId): Location | null;
 }
 
 type ModelParsedListener = () => void;
@@ -1124,9 +1452,10 @@ declare class LikeC4ModelParser {
     private services;
     private fqnIndex;
     constructor(services: LikeC4Services);
-    parse(doc: LangiumDocument | LangiumDocument[]): ParsedLikeC4LangiumDocument[];
+    parse(doc: LangiumDocument): ParsedLikeC4LangiumDocument;
     protected parseLikeC4Document(_doc: FqnIndexedDocument): ParsedLikeC4LangiumDocument;
     private parseSpecification;
+    private parseSpecificationDeploymentNodeKind;
     private parseModel;
     private parseElement;
     private parseRelation;
@@ -1154,14 +1483,26 @@ declare class LikeC4ModelParser {
     private parseViewRuleGroup;
     private parseRuleStyle;
     private parseViewRuleGlobalStyle;
-    private parseViewManualLaout;
+    private parseViewManualLayout;
     private parseDynamicParallelSteps;
     private parseDynamicStep;
     private parseElementView;
     private parseDynamicElementView;
     private parseDynamicViewRule;
     private parseDynamicViewIncludePredicate;
-    protected resolveFqn(node: Element | ExtendElement): c4.Fqn;
+    private parseDeployment;
+    parseDeploymentNode(astNode: DeploymentNode, isValid: IsValidFn): ParsedAstDeployment.Node;
+    parseDeployedInstance(astNode: DeployedInstance, isValid: IsValidFn): ParsedAstDeployment.Instance;
+    parseDeploymentRelation(astNode: DeploymentRelation, isValid: IsValidFn): ParsedAstDeploymentRelation;
+    private parseDeploymentView;
+    private parseDeploymentViewRule;
+    private parseDeploymentViewRulePredicate;
+    private parseDeploymentElementExpression;
+    private parseDeploymentRelationExpression;
+    private parseDeploymentExpressionIterator;
+    private parseDeploymentDef;
+    protected parseDeploymentViewRuleStyle(astRule: DeploymentViewRuleStyle, isValid: IsValidFn): c4.DeploymentViewRuleStyle;
+    protected resolveFqn(node: FqnReferenceable): c4.Fqn;
     private getAstNodePath;
     private getMetadata;
     private convertTags;
@@ -1180,34 +1521,6 @@ declare class LikeC4ModelChanges {
     };
 }
 
-type ElementsContainer = Model | ElementBody | ExtendElementBody;
-declare class LikeC4ScopeComputation extends DefaultScopeComputation {
-    computeExports(document: LikeC4LangiumDocument, _cancelToken?: CancellationToken): Promise<AstNodeDescription[]>;
-    private exportViews;
-    private exportGlobals;
-    private exportModel;
-    private exportLibrary;
-    private exportSpecification;
-    computeLocalScopes(document: LikeC4LangiumDocument, _cancelToken?: CancellationToken): Promise<PrecomputedScopes>;
-    protected processContainer(container: ElementsContainer, scopes: PrecomputedScopes, document: LikeC4LangiumDocument): MultiMap<string, AstNodeDescription>;
-}
-
-declare class LikeC4ScopeProvider extends DefaultScopeProvider {
-    private fqnIndex;
-    constructor(services: LikeC4Services);
-    private directChildrenOf;
-    private uniqueDescedants;
-    private scopeElementRef;
-    private scopeExtendElement;
-    private scopeElementView;
-    getScope(context: ReferenceInfo): Scope;
-    protected computeScope(context: ReferenceInfo): Scope;
-    /**
-     * Create a global scope filtered for the given reference type.
-     */
-    protected getGlobalScope(referenceType: string): Scope;
-}
-
 declare class Rpc implements Disposable {
     private services;
     private disposables;
@@ -1261,8 +1574,10 @@ type LikeC4SharedServices = LangiumSharedServices & LikeC4AddedSharedServices;
  */
 interface LikeC4AddedServices {
     WorkspaceCache: WorkspaceCache<string, any>;
+    DocumentCache: DocumentCache<string, any>;
     Rpc: Rpc;
     likec4: {
+        DeploymentsIndex: DeploymentsIndex;
         FqnIndex: FqnIndex;
         ModelParser: LikeC4ModelParser;
         ModelBuilder: LikeC4ModelBuilder;
@@ -1279,6 +1594,7 @@ interface LikeC4AddedServices {
         DocumentLinkProvider: LikeC4DocumentLinkProvider;
     };
     references: {
+        NameProvider: LikeC4NameProvider;
         ScopeComputation: LikeC4ScopeComputation;
         ScopeProvider: LikeC4ScopeProvider;
     };
@@ -1300,4 +1616,4 @@ declare function createLanguageServices(context?: LanguageServicesContext): {
 declare const logger: _likec4_log.ConsolaInstance;
 declare function setLogLevel(level: keyof typeof LogLevels): void;
 
-export { type FqnIndexEntry as F, type IsValidFn as I, type LikeC4SharedServices as L, type ModelParsedListener as M, type LikeC4Services as a, createLanguageServices as b, createCustomLanguageServices as c, LikeC4Module as d, computeDocumentFqn as e, FqnIndex as f, LikeC4ModelBuilder as g, LikeC4ModelLocator as h, LikeC4ModelParser as i, type LikeC4AddedServices as j, type LanguageServicesContext as k, createSharedServices as l, logger as m, setLogLevel as s };
+export { DeploymentsIndex as D, type FqnIndexEntry as F, type IsValidFn as I, type LikeC4SharedServices as L, type ModelParsedListener as M, type LikeC4Services as a, createLanguageServices as b, createCustomLanguageServices as c, LikeC4Module as d, DocumentDeploymentsIndex as e, computeDocumentFqn as f, FqnIndex as g, LikeC4ModelBuilder as h, LikeC4ModelLocator as i, LikeC4ModelParser as j, type LikeC4AddedServices as k, type LanguageServicesContext as l, createSharedServices as m, logger as n, setLogLevel as s };